-*** ANNOUNCE: SWIG 2.0.12 (9 Feb 2014) ***
+*** ANNOUNCE: SWIG 3.0.10 (12 Jun 2016) ***
http://www.swig.org
-We're pleased to announce SWIG-2.0.12, the latest SWIG release.
+We're pleased to announce SWIG-3.0.10, the latest SWIG release.
What is SWIG?
=============
SWIG is a software development tool that reads C/C++ header files and
generates the wrapper code needed to make C and C++ code accessible
from other programming languages including Perl, Python, Tcl, Ruby,
-PHP, C#, Go, Java, Lua, Scheme (Guile, MzScheme, CHICKEN), D, Ocaml,
-Pike, Modula-3, Octave, R, Common Lisp (CLISP, Allegro CL, CFFI, UFFI).
-SWIG can also export its parse tree in the form of XML and Lisp
-s-expressions. Major applications of SWIG include generation of
-scripting language extension modules, rapid prototyping, testing,
-and user interface development for large C/C++ systems.
+PHP, C#, Go, Java, Javascript, Lua, Scheme (Guile, MzScheme, CHICKEN),
+D, Ocaml, Pike, Modula-3, Octave, R, Scilab, Common Lisp (CLISP,
+Allegro CL, CFFI, UFFI). SWIG can also export its parse tree in
+the form of XML and Lisp s-expressions. Major applications of SWIG
+include generation of scripting language extension modules, rapid
+prototyping, testing, and user interface development for large
+C/C++ systems.
+
+Release Notes
+=============
+Detailed release notes are available with the release and are also
+published on the SWIG web site at http://swig.org/release.html.
Availability
============
The release is available for download on Sourceforge at
- http://prdownloads.sourceforge.net/swig/swig-2.0.12.tar.gz
+ http://prdownloads.sourceforge.net/swig/swig-3.0.10.tar.gz
A Windows version is also available at
- http://prdownloads.sourceforge.net/swig/swigwin-2.0.12.zip
+ http://prdownloads.sourceforge.net/swig/swigwin-3.0.10.zip
Please report problems with this release to the swig-devel mailing list,
details at http://www.swig.org/mail.html.
CC=@CC@
CFLAGS=@CFLAGS@ -I.
SWIG=swig
-SWIG_LIB=../../Lib
+SWIG_LIB=../$(srcdir)/../Lib
EXEEXT=@EXEEXT@
# Use standard autoconf approach to transform executable name using --program-prefix and --program-suffix
all: $(PACKAGE_NAME)$(EXEEXT)
+# Regenerate Makefile if Makefile.in or config.status have changed.
+Makefile: $(srcdir)/Makefile.in ./config.status
+ $(SHELL) ./config.status
+
# Note that HTML documentation is actually generated and used from the main SWIG documentation Makefile
-docs: $(PACKAGE_NAME).1 web/ccache-man.html
+docs: $(srcdir)/$(PACKAGE_NAME).1 $(srcdir)/web/ccache-man.html
$(PACKAGE_NAME)$(EXEEXT): $(OBJS) $(HEADERS)
$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
-$(PACKAGE_NAME).1: ccache.yo
- -yodl2man -o $(PACKAGE_NAME).1 ccache.yo
+$(srcdir)/$(PACKAGE_NAME).1: $(srcdir)/ccache.yo
+ -yodl2man -o $(srcdir)/$(PACKAGE_NAME).1 $(srcdir)/ccache.yo
-web/ccache-man.html: ccache.yo
- yodl2html -o web/ccache-man.html ccache.yo
+$(srcdir)/web/ccache-man.html: $(srcdir)/ccache.yo
+ yodl2html -o $(srcdir)/web/ccache-man.html $(srcdir)/ccache.yo
-install: $(PACKAGE_NAME)$(EXEEXT) $(PACKAGE_NAME).1
+install: $(PACKAGE_NAME)$(EXEEXT)
@echo "Installing $(PACKAGE_NAME)"
@echo "Installing $(DESTDIR)${bindir}/`echo $(PACKAGE_NAME) | sed '$(transform)'`$(EXEEXT)"
${INSTALLCMD} -d $(DESTDIR)${bindir}
${INSTALLCMD} -m 755 $(PACKAGE_NAME)$(EXEEXT) $(DESTDIR)${bindir}/`echo $(PACKAGE_NAME) | sed '$(transform)'`$(EXEEXT)
+
+install-docs: $(srcdir)/$(PACKAGE_NAME).1
@echo "Installing $(DESTDIR)${mandir}/man1/`echo $(PACKAGE_NAME) | sed '$(transform)'`.1"
${INSTALLCMD} -d $(DESTDIR)${mandir}/man1
- ${INSTALLCMD} -m 644 ${srcdir}/$(PACKAGE_NAME).1 $(DESTDIR)${mandir}/man1/`echo $(PACKAGE_NAME) | sed '$(transform)'`.1
+ ${INSTALLCMD} -m 644 $(srcdir)/$(PACKAGE_NAME).1 $(DESTDIR)${mandir}/man1/`echo $(PACKAGE_NAME) | sed '$(transform)'`.1
-uninstall: $(PACKAGE_NAME)$(EXEEXT) $(PACKAGE_NAME).1
+uninstall: $(PACKAGE_NAME)$(EXEEXT)
rm -f $(DESTDIR)${bindir}/`echo $(PACKAGE_NAME) | sed '$(transform)'`$(EXEEXT)
+
+uninstall-docs: $(srcdir)/$(PACKAGE_NAME).1
rm -f $(DESTDIR)${mandir}/man1/`echo $(PACKAGE_NAME) | sed '$(transform)'`.1
clean:
/bin/rm -f $(OBJS) *~ $(PACKAGE_NAME)$(EXEEXT)
-check : test
-
test: test.sh
- SWIG_LIB='$(SWIG_LIB)' PATH=../..:$$PATH SWIG='$(SWIG)' CC='$(CC)' NOSOFTLINKSTEST='$(NOSOFTLINKSTEST)' ./test.sh
+ SWIG_LIB='$(SWIG_LIB)' PATH=../..:$$PATH SWIG='$(SWIG)' CC='$(CC)' NOSOFTLINKSTEST='$(NOSOFTLINKSTEST)' $(srcdir)/test.sh
check: test
/bin/rm -rf autom4te.cache
maintainer-clean: distclean
- /bin/rm -f $(PACKAGE_NAME).1 web/ccache-man.html
+ /bin/rm -f $(srcdir)/$(PACKAGE_NAME).1 $(srcdir)/web/ccache-man.html
+
-
# FIXME: To fix this, test.sh needs to be able to take ccache from the
# installed prefix, not from the source dir.
-installcheck:
+installcheck:
@echo "WARNING! This is not really \"installcheck\" yet."
$(MAKE) check
+++ /dev/null
-.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
-
#include <sys/wait.h>
#include <sys/mman.h>
#else
-#define _WIN32_WINNT 0x0500
+#ifndef _WIN32_WINNT
+ #define _WIN32_WINNT 0x0500
+#endif
#include <windows.h>
#include <shlobj.h>
#endif
#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.68 for ccache-swig 0.0.
+# Generated by GNU Autoconf 2.69 for ccache-swig 0.0.
#
#
-# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
-# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
-# Foundation, Inc.
+# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
#
#
# This configure script is free software; the Free Software Foundation
# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+# Use a proper internal environment variable to ensure we don't fall
+ # into an infinite loop, continuously re-executing ourselves.
+ if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
+ _as_can_reexec=no; export _as_can_reexec;
+ # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+ *v*x* | *x*v* ) as_opts=-vx ;;
+ *v* ) as_opts=-v ;;
+ *x* ) as_opts=-x ;;
+ * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+as_fn_exit 255
+ fi
+ # We don't want this to propagate to other subprocesses.
+ { _as_can_reexec=; unset _as_can_reexec;}
if test "x$CONFIG_SHELL" = x; then
as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
emulate sh
else
exitcode=1; echo positional parameters were not saved.
fi
-test x\$exitcode = x0 || exit 1"
+test x\$exitcode = x0 || exit 1
+test -x / || exit 1"
as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
if test "x$CONFIG_SHELL" != x; then :
- # We cannot yet assume a decent shell, so we have to provide a
- # neutralization value for shells without unset; and this also
- # works around shells that cannot unset nonexistent variables.
- # Preserve -v and -x to the replacement shell.
- BASH_ENV=/dev/null
- ENV=/dev/null
- (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
- export CONFIG_SHELL
- case $- in # ((((
- *v*x* | *x*v* ) as_opts=-vx ;;
- *v* ) as_opts=-v ;;
- *x* ) as_opts=-x ;;
- * ) as_opts= ;;
- esac
- exec "$CONFIG_SHELL" $as_opts "$as_myself" ${1+"$@"}
+ export CONFIG_SHELL
+ # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+ *v*x* | *x*v* ) as_opts=-vx ;;
+ *v* ) as_opts=-v ;;
+ *x* ) as_opts=-x ;;
+ * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
fi
if test x$as_have_required = xno; then :
} # as_fn_mkdir_p
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+ test -f "$1" && test -x "$1"
+} # as_fn_executable_p
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
chmod +x "$as_me.lineno" ||
{ $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+ # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+ # already done that, so ensure we don't try to do so again and fall
+ # in an infinite loop. This has already happened in practice.
+ _as_can_reexec=no; export _as_can_reexec
# Don't try to exec as it changes $[0], causing all sort of problems
# (the dirname of $[0] is not the place where we might find the
# original and so on. Autoconf is especially sensitive to this).
# ... but there are two gotchas:
# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
- # In both cases, we have to default to `cp -p'.
+ # In both cases, we have to default to `cp -pR'.
ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
- as_ln_s='cp -p'
+ as_ln_s='cp -pR'
elif ln conf$$.file conf$$ 2>/dev/null; then
as_ln_s=ln
else
- as_ln_s='cp -p'
+ as_ln_s='cp -pR'
fi
else
- as_ln_s='cp -p'
+ as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null
as_mkdir_p=false
fi
-if test -x / >/dev/null 2>&1; then
- as_test_x='test -x'
-else
- if ls -dL / >/dev/null 2>&1; then
- as_ls_L_option=L
- else
- as_ls_L_option=
- fi
- as_test_x='
- eval sh -c '\''
- if test -d "$1"; then
- test -d "$1/.";
- else
- case $1 in #(
- -*)set "./$1";;
- esac;
- case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
- ???[sx]*):;;*)false;;esac;fi
- '\'' sh
- '
-fi
-as_executable_p=$as_test_x
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
docdir
oldincludedir
includedir
+runstatedir
localstatedir
sharedstatedir
sysconfdir
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
+runstatedir='${localstatedir}/run'
includedir='${prefix}/include'
oldincludedir='/usr/include'
docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
| -silent | --silent | --silen | --sile | --sil)
silent=yes ;;
+ -runstatedir | --runstatedir | --runstatedi | --runstated \
+ | --runstate | --runstat | --runsta | --runst | --runs \
+ | --run | --ru | --r)
+ ac_prev=runstatedir ;;
+ -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
+ | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
+ | --run=* | --ru=* | --r=*)
+ runstatedir=$ac_optarg ;;
+
-sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
ac_prev=sbindir ;;
-sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
datadir sysconfdir sharedstatedir localstatedir includedir \
oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
- libdir localedir mandir
+ libdir localedir mandir runstatedir
do
eval ac_val=\$$ac_var
# Remove trailing slashes.
if test "x$host_alias" != x; then
if test "x$build_alias" = x; then
cross_compiling=maybe
- $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host.
- If a cross compiler is detected then cross compile mode will be used" >&2
elif test "x$build_alias" != "x$host_alias"; then
cross_compiling=yes
fi
--sysconfdir=DIR read-only single-machine data [PREFIX/etc]
--sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
--localstatedir=DIR modifiable single-machine data [PREFIX/var]
+ --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run]
--libdir=DIR object code libraries [EPREFIX/lib]
--includedir=DIR C header files [PREFIX/include]
--oldincludedir=DIR C header files for non-gcc [/usr/include]
if $ac_init_version; then
cat <<\_ACEOF
ccache-swig configure 0.0
-generated by GNU Autoconf 2.68
+generated by GNU Autoconf 2.69
-Copyright (C) 2010 Free Software Foundation, Inc.
+Copyright (C) 2012 Free Software Foundation, Inc.
This configure script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it.
_ACEOF
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
- $as_test_x conftest$ac_exeext
+ test -x conftest$ac_exeext
}; then :
ac_retval=0
else
running configure, to aid debugging if configure makes a mistake.
It was created by ccache-swig $as_me 0.0, which was
-generated by GNU Autoconf 2.68. Invocation command line was
+generated by GNU Autoconf 2.69. Invocation command line was
$ $0 $@
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}gcc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="gcc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}cc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
ac_prog_rejected=yes
continue
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
/* end confdefs.h. */
#include <stdarg.h>
#include <stdio.h>
-#include <sys/types.h>
-#include <sys/stat.h>
+struct stat;
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
struct buf { int x; };
FILE * (*rcsopen) (struct buf *, struct stat *, int);
# by default.
for ac_prog in ginstall scoinst install; do
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
if test $ac_prog = install &&
grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
# AIX install. It has an incompatible calling convention.
for ac_prog in grep ggrep; do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
- { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
+ as_fn_executable_p "$ac_path_GREP" || continue
# Check for GNU ac_path_GREP and select it if it is found.
# Check for GNU $ac_path_GREP
case `"$ac_path_GREP" --version 2>&1` in
for ac_prog in egrep; do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
- { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
+ as_fn_executable_p "$ac_path_EGREP" || continue
# Check for GNU ac_path_EGREP and select it if it is found.
# Check for GNU $ac_path_EGREP
case `"$ac_path_EGREP" --version 2>&1` in
# ... but there are two gotchas:
# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
- # In both cases, we have to default to `cp -p'.
+ # In both cases, we have to default to `cp -pR'.
ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
- as_ln_s='cp -p'
+ as_ln_s='cp -pR'
elif ln conf$$.file conf$$ 2>/dev/null; then
as_ln_s=ln
else
- as_ln_s='cp -p'
+ as_ln_s='cp -pR'
fi
else
- as_ln_s='cp -p'
+ as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null
as_mkdir_p=false
fi
-if test -x / >/dev/null 2>&1; then
- as_test_x='test -x'
-else
- if ls -dL / >/dev/null 2>&1; then
- as_ls_L_option=L
- else
- as_ls_L_option=
- fi
- as_test_x='
- eval sh -c '\''
- if test -d "$1"; then
- test -d "$1/.";
- else
- case $1 in #(
- -*)set "./$1";;
- esac;
- case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
- ???[sx]*):;;*)false;;esac;fi
- '\'' sh
- '
-fi
-as_executable_p=$as_test_x
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+ test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
# values after options handling.
ac_log="
This file was extended by ccache-swig $as_me 0.0, which was
-generated by GNU Autoconf 2.68. Invocation command line was
+generated by GNU Autoconf 2.69. Invocation command line was
CONFIG_FILES = $CONFIG_FILES
CONFIG_HEADERS = $CONFIG_HEADERS
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
ccache-swig config.status 0.0
-configured by $0, generated by GNU Autoconf 2.68,
+configured by $0, generated by GNU Autoconf 2.69,
with options \\"\$ac_cs_config\\"
-Copyright (C) 2010 Free Software Foundation, Inc.
+Copyright (C) 2012 Free Software Foundation, Inc.
This config.status script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
if \$ac_cs_recheck; then
- set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+ set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
shift
\$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
CONFIG_SHELL='$SHELL'
SWIG=swig
fi
+# fix: Remove ccache from $PATH if it exists
+# as it will influence the unit tests
+PATH="`echo $PATH | \
+ sed -e 's!:/usr\(/local\)*/lib\([0-9]\)*/ccache\(/\)*!!g'`"
+
CCACHE=../ccache-swig
TESTDIR=test.$$
rm -rf $TESTDIR
mkdir $TESTDIR
cd $TESTDIR || exit 1
+
+unset CCACHE_DIR
+unset CCACHE_TEMPDIR
+unset CCACHE_LOGFILE
+unset CCACHE_VERBOSE
+unset CCACHE_PATH
+unset CCACHE_CC
+unset CCACHE_PREFIX
+unset CCACHE_DISABLE
+unset CCACHE_READONLY
+unset CCACHE_CPP2
+unset CCACHE_NOCOMPRESS
+unset CCACHE_NOSTATS
+unset CCACHE_NLEVELS
+unset CCACHE_HARDLINK
+unset CCACHE_RECACHE
+unset CCACHE_UMASK
+unset CCACHE_HASHDIR
+unset CCACHE_UNIFY
+unset CCACHE_EXTENSION
+unset CCACHE_STRIPC
+unset CCACHE_SWIG
+
CCACHE_DIR="ccache dir" # with space in directory name (like Windows default)
mkdir "$CCACHE_DIR"
export CCACHE_DIR
See the CHANGES.current file for changes in the current version.
See the RELEASENOTES file for a summary of changes in each release.
+Version 3.0.9 (29 May 2016)
+===========================
+
+2016-05-24: mromberg
+ [Python] Patch #612 - Add support for Python's implicit namespace packages.
+
+2016-05-23: wsfulton
+ [Ruby] Fix #602 - Error handling regression of opaque pointers introduced
+ in swig-3.0.8 when C functions explicitly reset a pointer using 'DATA_PTR(self) = 0'.
+ An ObjectPreviouslyDeleted error was incorrectly thrown when the pointer was used
+ as a parameter.
+
+2016-05-17: tamuratak
+ [Ruby] Patch #651 - Correct overloaded function error message when function is
+ using %newobject.
+
+2016-05-17: aurelj
+ [Ruby] Patch #582 - add support for docstring option in %module()
+
+2016-05-14: wsfulton
+ Fix #434 - Passing classes by value as parameters in director methods did not create
+ a copy of the argument leading to invalid memory accesses if the object was used
+ after the upcall into the target language. Passing arguments by value shouldn't give
+ rise to these sorts of memory problems and so the objects are now copied and ownership
+ of their lifetime is controlled by the target language.
+
+2016-05-07: wsfulton
+ Fix #611. Fix assertion handling defaultargs when using %extend for a template
+ class and the extended methods contain default arguments.
+
+2016-05-05: ejulian
+ [Python] Patch #617. Fix operator/ wrappers.
+
+2016-05-02: wsfulton
+ Fix #669. Don't issue warning about ignoring base classes when the derived class is
+ itself ignored.
+
+2016-04-18: ianlancetaylor
+ [Go] Fix use of goout typemap when calling base method by
+ forcing the "type" attribute to the value we need.
+
+2016-04-17: ianlancetaylor
+ [Go] Fixes for Go 1.6: avoid returning Go pointers from
+ directors that return string values; add a trailing 0 byte
+ when treating Go string as C char*.
+
+2016-04-06: smarchetto
+ [Scilab] #552 Make Scilab runtime keep track of pointer types
+ Instead of a Scilab pointer which has no type, SWIG Scilab maps a
+ pointer to a structure tlist containing the pointer adress and its type.
+
+2016-04-02: ahnolds
+ [Python] Apply #598. Fix misleading error message when attempting to read a non-existent
+ attribute. The previous cryptic error message:
+ AttributeError: type object 'object' has no attribute '__getattr__'
+ is now replaced with one mentioning the attribute name, eg:
+ AttributeError: 'Foo' object has no attribute 'bar'
+
+2016-04-02: derkuci
+ [Python] Patch #610 to fix #607.
+ Fix single arguments when using python -builtin -O with %feature("compactdefaultargs")
+
+2016-03-31: wsfulton
+ Fixes #594. Fix assertion for some languages when wrapping a C++11 enum class that
+ is private in a class.
+
+ Also don't wrap private enums for a few languages that attempted to do so.
+
+2016-03-31: wsfulton
+ [Java] unsigned long long marshalling improvements when a negative number
+ is passed from Java to C. A cast to signed long long in the C layer will now
+ result in the expected value. No change for positive numbers passed to C.
+ Fixes #623.
+
+2016-03-22: alexwarg
+ [Lua] #398 Fix lua __getitem + inheritance
+ The new handling of classes in Lua (not merging methods into the derived classes)
+ breaks for classes that provide a __getitem function. The __getitem function
+ prevents method calls to any method defined in a base class. This fix calls
+ __getitem only if the member is not found using recursive lookup.
+
+2016-03-18: ptomulik
+ [Python] #563 Stop generating unnecessary _swigconstant helpers.
+
+2016-03-16: richardbeare
+ [R] #636 Add extra std::vector numeric types
+
+2016-03-14: wsfulton
+ [Java] Add std_array.i for C++11 std::array support.
+
+2016-03-12: wsfulton
+ [Java, C#, D] Fix static const char member variables wrappers with %javaconst(1)
+ %csconst(1) or %dmanifestconst.
+ This fixes the case when an integer is used as the initializer, such as:
+
+ struct W { static const char w = 100; };
+
+ Fix generated code parsing enum values using char escape sequences
+ when these values appear in the Java code (usually when using %javaconst(1))
+ such as:
+
+ enum X { x1 = '\n', x2 = '\1' };
+
+ Similarly for static const member char variables such as:
+
+ struct Y { static const char y = '\n'; }
+
+ Likewise for D and %dmanifestconstant. For C# and %csconst(1), char
+ values in C# are now hex escaped as C# doesn't support C octal escaping.
+
+2016-03-11: wsfulton
+ [Java C#] Add support for treating C++ base classes as Java interfaces
+ instead of Java proxy classes. This enable some sort of support for
+ multiple inheritance. The implementation is in swiginterface.i and
+ provides additional macros (see Java.html for full documentation):
+
+ %interface(CTYPE)
+ %interface_impl(CTYPE)
+ %interface_custom("PROXY", "INTERFACE", CTYPE)
+
+2016-03-01: wsfulton
+ Add rstrip encoder for use in %rename. This is like the strip encoder but
+ strips the symbol's suffix instead of the prefix. The example below
+ will rename SomeThingCls to SomeThing and AnotherThingCls to AnotherThing:
+
+ %rename("%(rstrip:[Cls])s") "";
+
+ class SomeThingCls {};
+ struct AnotherThingCls {};
+
+2016-03-01: olly
+ Fix isfinite() check to work with GCC6. Fixes
+ https://github.com/swig/swig/issues/615 reported by jplesnik.
+
+2016-02-17: olly
+ [Python] Add missing keywords 'as' and 'with' to pythonkw.swg.
+
+2016-02-07: kwwette
+ [Octave] recognise various unary functions
+ * Use __float__() for numeric conversions, e.g. when calling double()
+ * Map various unary functions, e.g. abs() to __abs__(), see full list
+ in section 32.3.10 of manual; only available in Octave 3.8.0 or later
+
+2016-02-07: kwwette
+ [Octave] export function swig_octave_prereq() for testing Octave version
+
+2016-02-06: pjohangustavsson
+ [C#] Fix duplicate symbol problems when linking the source generated
+ from multiple SWIG modules into one shared library for the -namespace
+ option. The namespace is now mangled into the global PInvoke function
+ names.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2016-01-27: ahnolds
+ [Python] Added support for differentiating between Python Bytes
+ and Unicode objects using by defining SWIG_PYTHON_STRICT_BYTE_CHAR
+ and SWIG_PYTHON_STRICT_UNICODE_WCHAR.
+
+2016-01-27: steeve
+ [Go] Ensure structs are properly packed between gc and GCC/clang.
+
+2016-01-25: ahnolds
+ [Python] Support the full Python test suite in -classic mode
+ * Convert long/unsigned long/long long/unsigned long long to PyInt
+ rather than PyLong when possible. Certain python functions like
+ len() require a PyInt when operating on old-style classes.
+ * Add support for static methods in classic mode, including support
+ for pythonappend, pythonprepend, and docstrings.
+ * Removing the use of __swig_getmethods__ for static member methods
+ since they will always be found by the standard argument lookup
+ * Fix a bug where the wrong type of exception was caught when
+ checking for new-style class support
+
+2016-01-23: ahnolds
+ [Go] Enable support for the Go test-suite on OSX:
+ * The linker on OSX requires that all symbols (even weak symbols)
+ are defined at link time. Because the function _cgo_topofstack is
+ only defined starting in Go version 1.4, we explicitly mark it as
+ undefined for older versions of Go on OSX.
+ * Avoid writing empty swigargs structs, since empty structs are not
+ allowed in extern "C" blocks.
+
+2016-01-12: olly
+ [Javascript] Look for "nodejs" as well as "node", as it's packaged
+ as the former on Debian.
+
+2016-01-12: olly
+ [Javascript] For v8 >= 4.3.0, use V8_MAJOR_VERSION.
+ Fixes https://github.com/swig/swig/issues/561.
+
+2016-01-10: ahnolds
+ Improved size_t and ptrdiff_t typemaps to support large values
+ on platforms where sizeof(size_t) > sizeof(unsigned long) and
+ sizeof(ptrdiff_t) > sizeof(long).
+
+Version 3.0.8 (31 Dec 2015)
+===========================
+
+2015-12-30: wsfulton
+ The pdf documentation is now generated by wkhtmltopdf and has colour
+ for the code snippets just like the html documentation!
+
+2015-12-23: ahnolds
+ [Python] Fixes for conversion of signed and unsigned integer types:
+
+ No longer check for PyInt objects in Python3. Because PyInt_Check
+ and friends are #defined to the corresponding PyLong methods, this
+ had caused errors in Python3 where values greater than what could be
+ stored in a long were incorrectly interpreted as the value -1 with
+ the Python error indicator set to OverflowError. This applies to
+ both the conversions PyLong->long and PyLong->double.
+
+ Conversion from PyLong to long, unsigned long, long long, and
+ unsigned long long now raise OverflowError instead of TypeError in
+ both Python2 and Python3 for PyLong values outside the range
+ expressible by the corresponding C type. This matches the existing
+ behavior for other integral types (signed and unsigned ints, shorts,
+ and chars), as well as the conversion for PyInt to all numeric
+ types. This also indirectly applies to the size_t and ptrdiff_t
+ types, which depend on the conversions for unsigned long and long.
+
+2015-12-19: wsfulton
+ [Python] Python 2 Unicode UTF-8 strings can be used as inputs to char * or
+ std::string types if the generated C/C++ code has SWIG_PYTHON_2_UNICODE defined.
+
+2015-12-17: wsfulton
+ Issues #286, #128
+ Remove ccache-swig.1 man page - please use the CCache.html docs instead.
+ The yodl2man and yodl2html tools are no longer used and so SWIG no
+ longer has a dependency on these packages which were required when
+ building from git.
+
+2015-12-16: zturner/coleb
+ [Python] Fix Python3.5 interpreter assertions when objects are being
+ deleted due to an existing exception. Most notably in generators
+ which terminate using a StopIteration exception. Fixes #559 #560 #573.
+ If a further exception is raised during an object destruction,
+ PyErr_WriteUnraisable is used on this second exception and the
+ original exception bubbles through.
+
+2015-12-14: ahnolds/wsfulton
+ [Python] Add in missing initializers for tp_finalize,
+ nb_matrix_multiply, nb_inplace_matrix_multiply, ht_qualname
+ ht_cached_keys and tp_prev.
+
+2015-12-12: wsfulton
+ Fix STL wrappers to not generate <: digraphs.
+ For example std::vector<::X::Y> was sometimes generated, now
+ corrected to std::vector< ::X::Y >.
+
+2015-11-25: wsfulton
+ [Ruby] STL ranges and slices fixes.
+
+ Ruby STL container setting slices fixes:
+
+ Setting an STL container wrapper slice better matches the way Ruby
+ arrays work. The behaviour is now the same as Ruby arrays. The only
+ exception is the default value used when expanding a container
+ cannot be nil as this is not a valid type/value for C++ container
+ elements.
+
+ Obtaining a Ruby STL container ranges and slices fixes:
+
+ Access via ranges and slices now behave identically to Ruby arrays.
+ The fixes are mostly for out of range indices and lengths.
+ - Zero length slice requests return an empty container instead of nil.
+ - Slices which request a length greater than the size of the container
+ no longer chop off the last element.
+ - Ranges which used to return nil now return an empty array when the
+ the start element is a valid index.
+
+ Ruby STL container negative indexing support improved.
+
+ Using negative indexes to set values works the same as Ruby arrays, eg
+
+ %template(IntVector) std::vector<int>;
+
+ iv = IntVector.new([1,2,3,4])
+ iv[-4] = 9 # => [1,2,3,9]
+ iv[-5] = 9 # => IndexError
+
+2015-11-21: wsfulton
+ [Ruby, Python] Add std::array container wrappers.
+
+ These work much like any of the other STL containers except Python/Ruby slicing
+ is somewhat limited because the array is a fixed size. Only slices of
+ the full size are supported.
+
+2015-10-10: wsfulton
+ [Python] #539 - Support Python 3.5 and -builtin. PyAsyncMethods is a new
+ member in PyHeapTypeObject.
+
+2015-10-06: ianlancetaylor
+ [Go] Don't emit a constructor function for a director
+ class with an abstract method, since the function will
+ always panic.
+
+2015-10-01: wsfulton
+ Fix %shared_ptr support for private and protected inheritance.
+ - Remove unnecessary Warning 520: Derived class 'Derived' of 'Base'
+ is not similarly marked as a smart pointer
+ - Do not generate code that attempts to cast up the inheritance chain in the
+ type system runtime in such cases as it doesn't compile and can't be used.
+ Remove unnecessary warning 520 for %shared_ptr when the base class is ignored.
+
+2015-10-01: vkalinin
+ Fix #508: Fix segfault parsing anonymous typedef nested classes.
+
+2015-09-26: wsfulton
+ [Ruby] Add shared_ptr support
+
+2015-09-13: kkaempf
+ [Ruby] Resolve tracking bug - issue #225.
+ The bug is that the tracking code uses a ruby hash and thus may
+ allocate objects (Bignum) while running the GC. This was tolerated in
+ 1.8 but is invalid (raises an exception) in 1.9.
+ The patch uses a C hash (also used by ruby) instead.
+
+2015-09-09: lyze
+ [CFFI] Extend the "export" feature in the CFFI module to support
+ exporting to a specified package.
+
+2015-09-04: olly
+ [Python] Fix docstrings for %callback functions.
+
+2015-09-03: demi-rluddy
+ [Go] Removed golang stringing for signed/unsigned char
+
+ Changed default handling of signed char* and unsigned char* to be
+ opaque pointers rather than strings, similarly to how other
+ languages work.
+
+ Any existing code relying on treating signed char* or unsigned
+ char* as a string can restore the old behavior with typemaps.i by
+ using %apply to copy the [unchanged] char* behavior.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2015-08-07: talby
+ [Perl] tidy -Wtautological-constant-out-of-range-compare warnings when building generated code under clang
+
+2015-08-07: xantares
+ [Python] pep257 & numpydoc conforming docstrings:
+ - Mono-line module docsstring
+ - Rewrite autodoc parameters section in numpydoc style:
+ https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt
+ - One line summary should end with "."
+ - Adds a blank line after class docstring
+
+2015-08-05: vadz
+ [Java] Make (char* STRING, size_t LENGTH) typemaps usable for
+ strings of other types, e.g. "unsigned char*".
+
+Version 3.0.7 (3 Aug 2015)
+==========================
+
+2015-08-02: wsfulton
+ [Java] Fix potential security exploit in generated Java classes.
+ The swigCPtr and swigCMemOwn member variables in the generated Java
+ classes are now declared 'transient' by default. Further details of the exploit
+ in Android is being published in an academic paper as part of USENIX WOOT '15:
+ https://www.usenix.org/conference/woot15/workshop-program/presentation/peles.
+
+ In the unlikely event that you are relying on these members being serializable,
+ then you will need to override the default javabody and javabody_derived typemaps
+ to generate the old generated code. The relevant typemaps are in the Lib directory
+ in the java.swg, boost_shared_ptr.i and boost_intrusive_ptr.i files. Copy the
+ relevant default typemaps into your interface file and remove the 'transient' keyword.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2015-08-01: vadz
+ Make configure --without-alllang option more useful: it can now be overridden by the following
+ --with-xxx options, allowing to easily enable just one or two languages.
+
+2015-07-30: wsfulton
+ Fix #440 - Initialise all newly created arrays when using %array_functions and %array_class
+ in the carrays.i library - bug is only relevant when using C++.
+
+2015-07-29: wsfulton
+ [Python] Improve indentation warning and error messages for code in the following directives:
+
+ %pythonprepend
+ %pythonappend
+ %pythoncode
+ %pythonbegin
+ %feature("shadow")
+
+ Old error example:
+ Error: Line indented less than expected (line 3 of pythoncode)
+
+ New error example:
+ Error: Line indented less than expected (line 3 of %pythoncode or %insert("python") block)
+ as no line should be indented less than the indentation in line 1
+
+ Old warning example:
+ Warning 740: Whitespace prefix doesn't match (line 2 of %pythoncode or %insert("python") block)
+
+ New warning example:
+ Warning 740: Whitespace indentation is inconsistent compared to earlier lines (line 3 of
+ %pythoncode or %insert("python") block)
+
+
+2015-07-28: wsfulton
+ [Python] Fix #475. Improve docstring indentation handling.
+
+ SWIG-3.0.5 and earlier sometimes truncated text provided in the docstring feature.
+ This occurred when the indentation (whitespace) in the docstring was less in the
+ second or later lines when compared to the first line.
+ SWIG-3.0.6 gave a 'Line indented less than expected' error instead of truncating
+ the docstring text.
+ Now the indentation for the 'docstring' feature is smarter and is appropriately
+ adjusted so that no truncation occurs.
+
+2015-07-22: wsfulton
+ Support for special variable expansion in typemap attributes. Example usage expansion
+ in the 'out' attribute (C# specific):
+
+ %typemap(ctype, out="$*1_ltype") unsigned int& "$*1_ltype"
+
+ is equivalent to the following as $*1_ltype expands to 'unsigned int':
+
+ %typemap(ctype, out="unsigned int") unsigned int& "unsigned int"
+
+ Special variables can be used within special variable macros too. Example usage expansion:
+
+ %typemap(cstype) unsigned int "uint"
+ %typemap(cstype, out="$typemap(cstype, $*1_ltype)") unsigned int& "$typemap(cstype, $*1_ltype)"
+
+ Special variables are expanded first and hence the above is equivalent to:
+
+ %typemap(cstype, out="$typemap(cstype, unsigned int)") unsigned int& "$typemap(cstype, unsigned int)"
+
+ which then expands to:
+
+ %typemap(cstype, out="uint") unsigned int& "uint"
+
+2015-07-22: lindleyf
+ Apply patch #439 - support for $typemap() (aka embedded typemaps or special variable
+ macros) in typemap attributes. A simple example where $typemap() is expanded in the
+ 'out' attribute (C# specific):
+
+ %typemap(cstype) unsigned int "uint"
+ %typemap(cstype, out="$typemap(cstype, unsigned int)") unsigned int& "$typemap(cstype, unsigned int)"
+
+ is equivalent to:
+
+ %typemap(cstype, out="uint") unsigned int& "uint"
+
+2015-07-18: m7thon
+ [Python] Docstrings provided via %feature("docstring") are now quoted and added to
+ the tp_doc slot when using python builtin classes (-builtin). When no docstring is
+ provided, the tp_doc slot is set to the fully qualified C/C++ class name.
+ Github issues #445 and #461.
+
+2015-07-17: kwwette
+ [octave] Support Octave version 4.0.0 (thanks to patches from Orion Poplawski).
+
+2015-07-07: wsfulton
+ SWIG no longer generates a wrapper for a class' constructor if that class has
+ any base class with a private destructor. This is because your compiler should
+ not allow a class to be instantiated if a base has a private destructor. Some
+ compilers do, so if you need the old behaviour, use the "notabstract" feature, eg:
+
+ %feature("notabstract") Derived;
+ class Base {
+ ~Base() {}
+ };
+ struct Derived : Base {};
+
+Version 3.0.6 (5 Jul 2015)
+==========================
+
+2015-07-02: wsfulton
+ Fix syntax error when the template keyword is used in types, eg:
+
+ std::template vector<int> v;
+
+2015-07-02: ngladitz
+ [Lua] Push characters as unformatted 1-character strings to avoid
+ unprintable characters such as (char)127 being converted to
+ "<\127>" with Lua 5.3 and later. (github PR #452)
+
+2015-06-29: olly
+ [Python] Improve handling of whitespace in %pythoncode.
+
+ Previously SWIG looked at the indentation of the first line and
+ removed that many characters from each subsequent line, regardless
+ of what those characters were. This was made worse because SWIG's
+ preprocessor removes any whitespace before a '#'. Fixes github
+ issue #379, reported by Joe Orton.
+
+2015-06-12: wsfulton
+ [R] Fix #430 - call to SWIG_createNewRef in copyToC was incorrectly named.
+
+2015-06-11: sghirate
+ [C#] Patch #427 adds in new command line option -outfile to combine all the
+ generated C# code into a single file.
+
+2015-06-09: wsfulton
+ Fix seg fault processing C++11 type aliasing. Issue #424.
+
+2015-05-28: wsfulton
+ [Python] Add new feature "python:cdefaultargs" to control default argument
+ code generation. By default, SWIG attempts to convert C/C++ default argument values
+ into Python values and generates code into the Python layer with these values.
+ Recent versions of SWIG are able to convert more of these values, however, the
+ new behaviour can be circumvented if desired via this new feature, such that
+ the default argument values are obtained from the C layer and not the Python layer.
+ For example:
+
+ struct CDA {
+ int fff(int a = 1, bool b = false);
+ };
+
+ The default code generation in the Python layer is:
+
+ class CDA(_object):
+ ...
+ def fff(self, a=1, b=False):
+ return _default_args.CDA_fff(self, a, b)
+
+ Adding the feature:
+
+ %feature("python:cdefaultargs") CDA::fff;
+
+ Results in:
+
+ class CDA(_object):
+ ...
+ def fff(self, *args):
+ return _default_args.CDA_fff(self, *args)
+
+ Some code generation modes, eg -builtin and -fastproxy, are unaffected by this as
+ the default values are always obtained from the C layer.
+
+2015-05-27: wsfulton
+ [Python] Deal with an integer as the default value of a typedef to bool
+ parameter in the C++ prototype. See #327. Regression from 3.0.0 onwards.
+
+2015-05-19: olly
+ [Python] Fix warning when compiling generated code with MSVC.
+ (Fixes https://sourceforge.net/p/swig/patches/351/ reported by
+ Mateusz Szyma¿ski).
+
+2015-05-14: wsfulton
+ Fix seg fault wrapping shared_ptr of classes with private constructors and destructors.
+ This also fixes the "unref" feature when used on classes with private destructors.
+
+2015-05-10: wsfulton
+ [Java] Fix multi-argument typemaps (char *STRING, size_t LENGTH)
+ so that they can be applied to a wider range of types. Fixes #385.
+
+2015-05-07: olly
+ [Python] Deal with an integer as the default value of a bool
+ parameter in the C++ prototype. Fixes github #327, reported by
+ Greg Allen.
+
+2015-05-07: LindleyF
+ [Java] Allow feature("director") and feature("ref") to be used
+ together. Github PR#403.
+
+2015-05-05: olly
+ Suppress warning 325 "Nested class not currently supported (Foo
+ ignored)" when Foo has already been explicitly ignored with "%ignore".
+
+2015-05-04: wsfulton
+ Add support for friend templates, including operator overloading - fixes #196. Considering
+ the example below, previously the operator gave a syntax error and friendfunc incorrectly
+ warned with:
+
+ "Warning 503: Can't wrap 'friendfunc<(Type)>' unless renamed to a valid identifier."
+
+ template <class Type> class MyClass {
+ friend int friendfunc <Type>(double is, MyClass <Type> & x);
+ friend int operator<< <Type>(double un, const MyClass <Type> &x);
+ };
+
+ The following also previously incorrectly warned with:
+
+ "Warning 302: Identifier 'template_friend' redefined (ignored),"
+
+ template<typename T> T template_friend(T);
+ struct MyTemplate {
+ template<typename T> friend T template_friend(T);
+ };
+
+2015-05-01: wsfulton
+ Fix handling of conversion operators where the operator is split over multiple
+ lines or has comments within the operator type. Fixes #401.
+
+ Also fix similar problem with normal operators which gave a syntax error if split over
+ multiple lines or had a comment within the operator declaration.
+
+2015-04-30: olly
+ Ignore unknown preprocessor directives which are inside an inactive
+ conditional (github issue #394, reported by Dan Wilcox).
+ Regression introduced in 3.0.3.
+
+2015-04-27: vadz
+ [Python] Fix "default" typemap used after an argument with "numinputs=0" (#377).
+
+2015-04-24: wsfulton
+ [Python] Fix #256. Code generated with '-builtin -modernargs' segfaults for any
+ method taking zero arguments.
+
+ Also fixes: "SystemError: error return without exception set" during error checking
+ when using just -builtin and the incorrect number of arguments is passed to a class
+ method expecting zero arguments.
+
+2015-04-23: wsfulton
+ [Java] Bug #386 - Memory leak fix in (char *STRING, size_t LENGTH) typemaps.
+
+2015-04-23: vadz
+ [Python] Make "default" typemap work again (#330, #377).
+
+2015-04-23: vadz
+ [Python] Fix the use of default values for the pointer types (#365, #376).
+
+2015-04-23: wsfulton
+ Fix 'make check-ccache' which is part of 'make check' when one of the CCACHE_
+ environment variables, for example CCACHE_DISABLE, is set.
+
+2015-04-14: wsfulton
+ Clearer warning message for badly constructed typecheck typemaps. For example, was:
+
+ example.i:3: Warning 467: Overloaded foo(int) not supported (no type checking
+ rule for 'int').
+
+ Now:
+
+ example.i:3: Warning 467: Overloaded foo(int) not supported (incomplete type checking
+ rule - no precedence level in typecheck typemap for 'int').
+
+2015-04-11: wsfulton
+ [Java] Fix #353 - Linker multiple definition of 'ExceptionMatches' when
+ using directors and multiple modules.
+
+2015-04-11: wsfulton
+ Merge #320 - Make __dict__ accessible for Python builtin classes.
+
+2015-04-07: wsfulton
+ Fix #375 - parsing of extern "C" and typedef for example:
+ extern "C" typedef void (*Hook2_t)(int, const char *);
+ extern "C" typedef int Integer;
+
+2015-03-12: olly
+ -DSWIG_DIRECTOR_STATIC is now supported for all languages with
+ director support, not only Python and PHP.
+
+2015-03-02: ianlancetaylor
+ [Go] Add -cgo option, required for Go versions 1.5 and
+ later.
+
+2015-02-26: olly
+ Fix segmentation fault when top==NULL, introduced by nested class
+ handling (reported in issue#346 by Pawe¿ Tomulik).
+
+2015-02-09: wsfulton
+ [Guile] Fix generated code for static const char member variables when
+ defined and declared inline.
+
+2015-02-09: mishas
+ [Go] Fix %import of files in sub directories.
+
+2015-02-05: ianlancetaylor
+ [Go] Ignore Go specific type maps (goin, goout, etc.) if they are empty.
+
+2015-02-05: ianlancetaylor
+ [Go] Generated Go code no longer calls _swig_goallocate or
+ _swig_makegostring, as they will no longer work as of Go 1.5.
+
+Version 3.0.5 (31 Jan 2015)
+===========================
+
+2015-01-30: wsfulton
+ [Python] Fix Python -classic and property setting. Setting properties on classic classes
+ was broken in swig-3.0.3 by attempting to use __setattr__. This regression is fixed now
+ by using __dict__ again when using -classic.
+ Fixes patch #232.
+
+2015-01-27: smarchetto
+ [Scilab] Support for the Scilab language has been added
+
+2015-01-23: olly
+ [PHP] When wrapping a returned resource as an object, check if all
+ cases wrap it in the same class, and if so eliminate the pointless
+ switch statement wrapper we previously generated.
+
+2015-01-22: wsfulton
+ [Octave] Merge patch #297 for SF bug #1277 - Octave shared_ptr support
+
+2015-01-15: wsfulton
+ [Python] Merge patch #250 - Fixes for using %constant and objects (non-primitive types)
+
+2015-01-15: wsfulton
+ [C# Go] Merge patch #308 and fix #307 - C++11 strongly typed enum support
+ in directors
+
+2015-01-15: wsfulton
+ [Python] Second fix for #294 #296 - Regression introduced in SWIG-3.0.3 when
+ wrapping functions with default arguments, this time when using kwargs.
+
+Version 3.0.4 (14 Jan 2015)
+===========================
+
+2015-01-12: olly
+ [PHP] Fix segfault in director upcall check when using PHP built with
+ ZTS enabled. Fixes #155, reported by Pierre Labastie.
+
+2015-01-12: vadz
+ [Python] Fix #294 #296 - Regression introduced in SWIG-3.0.3 when
+ wrapping functions with default arguments. Invalid or missing default
+ arguments were sometimes being generated into the python layer.
+
+2015-01-08: olly
+ Allow C++11 "explicit constexpr". Fixes github issue #284 reported
+ by Pawel Tomulik. Also handle "constexpr explicit" and "constexpr
+ static".
+
+2015-01-08: olly
+ When reporting an error for a construct which hasn't been
+ terminated when the end of the file is reached, report it at the
+ start line rather than "EOF" as then tools like editors and IDEs
+ will take you to a generally more useful place for fixing the
+ problem.
+
+2015-01-08: olly
+ Improve error messages for a few cases which previously gave the
+ one of the cryptic catch-all errors "Syntax error in input".
+
+2015-01-08: olly
+ Provide -cppext as a general command line option for setting the
+ extension used for generated C++ files (previously it was specific
+ to the PHP backend). Deprecate the equivalent -suffix option
+ provided by the Ocaml backend, but continue to support that for
+ now.
+
+Version 3.0.3 (30 Dec 2014)
+===========================
+
+2014-12-27: wsfulton
+ Fix #280 - abort using all default template parameters within other template
+ parameters.
+
+2014-12-27: talby
+ [Perl] Issue #282 perl5 archlib vs archlibexp
+ [Perl] tidy "warning: duplicate 'extern' declaration specifier" when building generated code
+ under clang
+
+2014-12-18: wsfulton
+ Add support for %constant and structs/classes - issue #272
+
+2014-12-09: wsfulton
+ Fix #245 - regression (since swig-3.0.0) in templated constructors.
+ Templated constructors could not be instantiated - they were incorrectly ignored with a warning 504:
+ "Function: xyz must have a return type. Ignored."
+
+2014-12-07: wsfulton
+ Add support for C++11 strongly typed enumerations.
+
+2014-11-21: wsfulton
+ [Java C#] Fix multiply defined error when using %rename of enum items when using the "simple enum"
+ wrappers.
+
+2014-10-28: vadz
+ [Python] Patch #201 The generated .py file no longer uses *args for all Python parameters.
+ Instead, the parameters are named using the C++ parameter names.
+
+ "compactdefaultargs" feature can be enabled to restore the old behaviour.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2014-10-24: timotheecour
+ [D] Patch #204 Use core.atomic.atomicOp to mutate shared variables
+
+2014-10-21: wsfulton
+ Fix issue #242 - Use of the "kwargs" feature no longer automatically turns on the
+ "compactdefaultargs" feature if the target language does not support kwargs.
+ This change affects all languages except Python and Ruby.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2014-10-10: diorcety
+ [Python] Patch #232 Fix property access using directors
+
+2014-10-06: wsfulton
+ [Python] Fixes when using -builtin and std::vector/std::list wrappers to allow deletion
+ of single elements, such as 'del vec[0]'.
+
+2014-09-30: oliverb
+ [Javascript] Merge patch #216 by Richie765 - Added support for many versions of v8 javascript.
+
+2014-09-30: oliverb
+ [Javascript] Merge patch #195 by zittix - Fixed JSClassRef declaration not using the static one.
+
+2014-09-30: ianlancetaylor
+ [Go] In configure script, require Go 1.1 or later.
+
+2014-09-30: wsfulton
+ [Python] Patch #207 - Fix No module error with -relativeimport when using single
+ header file import.
+
+2014-09-27: wsfulton
+ Patch #208 - Initialise newly created array when using array_functions in the
+ carrays.i library (C++ usage).
+
+2014-09-27: wsfulton
+ [Ruby] Patch #187 - Fix crash on shutdown of the Ruby interpreter if more than one
+ module was loaded at a time when data is being shared between modules.
+
+2014-09-27: wsfulton
+ [Java] Patch #168 - Fix leak in Java director string handling after the Java
+ upcall when called from a native thread.
+
+2014-09-25: ianlancetaylor
+ [Go] Adjust generated code to work with upcoming Go 1.4
+ release.
+
+2014-09-23: wsfulton
+ [Python] Add patch from Thomas Maslach to fix crash in wrappers when using -threads in
+ the STL iterators (SwigPyIterator destructor).
+
+2014-09-17: wsfulton
+ [C#] Merge patch #229 from contre - Add bool array types to arrays_csharp.i
+
+2014-09-12: olly
+ [PHP] Add support for specifying any PHP interfaces a wrapped class
+ implements, e.g.: %typemap("phpinterfaces") MyIterator "Iterator";
+
+2014-09-11: olly
+ [PHP] Fix throwing a PHP exception through C++ from a subclassed
+ director method - PHP NULL gets returned by the subclassed method
+ in this case, so the directorout typemap needs to allow that (at
+ least if an exception is active).
+
+2014-09-09: ianlancetaylor
+ [Go] Add goargout typemap.
+
+2014-09-09: olly
+ [PHP] Fix segmentation faults with directors in PHP >= 5.4, and
+ reenable runme tests for director_basic testcase. Fix from
+ pavel-charvat in issue#164.
+
+2014-09-05: ianlancetaylor
+ [Go] Add imtype, goin, goout, godirectorin, and
+ godirectorout typemaps, to support writing Go code to
+ convert between types.
+
+2014-09-02: olly
+ [Python] Fix regression in indentation of python code produced with
+ -modern, introduced by changes in #188. Reported by fabiencastan
+ in #218.
+
+2014-09-01: olly
+ Issue an error for unknown SWIG preprocessor directives, rather
+ than quietly ignoring them. Reported by jrhelsey in issue#217.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2014-08-15: talby
+ [Perl] Include guard fix for nested modules from Anthony Heading (SF Patch #350).
+
+2014-08-04: wsfulton
+ [C#] Merge patch #200 from gpetrou - Changed CSharp license header to include auto-generated
+ tag so that StyleCop ignores the files.
+
+2014-08-04: wsfulton
+ [Java] Merge patch #198 from Yuval Kashtan - Support for java.nio.ByteBuffer mapping to
+ unsigned char * in various.i in NIOBUFFER typemaps.
+
+2014-07-14: ianlancetaylor
+ [Go] Change struct definition to use void *, not uint8, so
+ that the type is recorded as possibly containing
+ pointers. This ensures that the 1.3 garbage collector
+ does not collect pointers passed to C++ code.
+
+2014-07-01: wsfulton
+ Fix SF Bug #1375 - Expansion of the $parentclassname special variable incorrectly contains
+ brackets in the expanded name.
+
+Version 3.0.2 (4 Jun 2014)
+==========================
+
+2014-06-02: v-for-vandal
+ [Lua] Pull request #176:
+ If class has no __eq implemented, then default __eq is generated.
+ Default __eq compares actual pointers stored inside Lua userdata.
+
+2014-06-02: vkalinin
+ Fix #183 - %extend and unnamed nested structs
+
+2014-05-28: kwwette
+ Fix install failure when using an 'out of source' build using the shipped
+ tarball - regression introduced in swig-3.0.1.
+
+2014-05-24: kwwette
+ [Octave] Remove deprecated -global/-noglobal command-line arguments
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+Version 3.0.1 (27 May 2014)
+===========================
+
+2014-05-25: hfalcic
+ [Python] Python 3 byte string output: use errors="surrogateescape"
+ if available on the version of Python that's in use. This allows
+ obtaining the original byte string (and potentially trying a fallback
+ encoding) if the bytes can't be decoded as UTF-8.
+
+ Previously, a UnicodeDecodeError would be raised with no way to treat
+ the data as bytes or try another codec.
+
+2014-05-18: vkalinin
+ Bug #175 - Restore %extend to work for unnamed nested structures by using a C
+ symbol comprising the outer structure name and unnamed variable instance name.
+
+2014-05-15: kwwette
+ Add #166 - 'make check' now works out of source. This required the examples to build
+ out of source. The main languages have been tested - C#, Go, Guile, Java, Javascript,
+ Lua, Octave, Perl, PHP, Python, Ruby and Tcl.
+
+2014-05-01: Oliver Buchtala
+ Javascript support added, see Javascript chapter in the documentation.
+
+2014-05-01: olly
+ [PHP] The generated __isset() method now returns true for read-only properties.
+
+2014-04-24: kwwette
+ [Go] Fix go ./configure parsing of gccgo --version, and
+ goruntime.swg typo in __GNUC_PATCHLEVEL__ (SF Bug #1298)
+
+2014-04-24: kwwette
+ Fix {python|perl5|ruby|tcl}/java examples
+
+ In Lib/gcj/cni.i, for compatibility with newer gcj versions:
+
+ - remove JvAllocObject() which gcj no longer defines, from gcj Changelog:
+ 2004-04-16 Bryce McKinlay <mckinlay@redhat.com>
+ * gcj/cni.h (JvAllocObject): Remove these obsolete,
+ undocumented CNI calls.
+
+ - change JvCreateJavaVM() argument from void* to JvVMInitArgs*, from gcj Changelog:
+ 2005-02-23 Thomas Fitzsimmons <fitzsim@redhat.com>
+ PR libgcj/16923
+ ...
+ (JvCreateJavaVM): Declare vm_args as JvVMInitArgs* rather than void*.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2014-04-08: wsfulton
+ SF Bug #1366 - Remove duplicate declarations of strtoimax and strtoumax in inttypes.i
+
+2014-04-08: wsfulton
+ [Java C#] Enums which have been ignored via %ignore and are subsequently
+ used are handled slightly differently. Type wrapper classes are now generated
+ which are effectively a wrapper of an empty enum. Previously in Java uncompilable
+ code was generated and in C# an int was used.
+
+2014-04-04: wsfulton
+ Fix regression in 3.0.0 where legal code following an operator<< definition might
+ give a syntax error. SF Bug #1365.
+
+2014-04-03: olly
+ [PHP] Fix wrapping director constructors with default parameters
+ with a ZTS-enabled build of PHP.
+
+2014-04-02: olly
+ [PHP] Pass the ZTS context we already have to avoid needing to
+ call TSRMLS_FETCH, which is relatively expensive.
+
+2014-04-02: olly
+ [PHP] Pass ZTS context through to t_output_helper() so it works
+ with a ZTS-enabled build of PHP. Reported by Pierre Labastie in
+ github PR#155.
+
+2014-03-28: wsfulton
+ [Java C# D Go] Fixes for C enums used in an API and the definition of the enum
+ has not been parsed. For D, this fixes a segfault in SWIG. The other languages
+ now produce code that compiles, although the definition of the enum is needed
+ in order to use the enum properly from the target language.
+
+2014-03-23: v-for-vandal
+ [Lua] Fix for usage of snprintf in Lua runtime which Visual Studio does not have.
+
+Version 3.0.0 (16 Mar 2014)
+===========================
+
+2014-03-16: wsfulton
+ C++11 support initially developed as C++0x support by Matevz Jekovec as a Google Summer of Code
+ project has been further extended. The C++11 support is comprehensive, but by no means complete
+ or without limitations. Full details for each new feature in C++11 is covered in the
+ CPlusPlus11.html chapter in the documentation which is included in SWIG and also available
+ online at http://www.swig.org/Doc3.0/CPlusPlus11.html.
+
+2014-03-14: v-for-vandal
+ [Lua] Numerous Lua improvements:
+ 1. %nspace support has been added. Namespaces are mapped to tables in the module, with the same
+ name as the C++ namespace.
+ 2. Inheritance is now handled differently. Each class metatable keeps a list of class bases instead
+ of merging all members of all bases into the derived class.
+ 3. The new metatables result in differences in accessing class members. For example:
+
+ %module example
+ struct Test {
+ enum { TEST1 = 10, TEST2 = 20 };
+ static const int ICONST = 12;
+ };
+
+ Now this can be used as follows:
+ print(example.Test.TEST1)
+ print(example.Test.ICONST)
+ The old way was:
+ print(example.Test_TEST1)
+ print(example.Test_ICONST)
+
+ 4. The special class metatable member ".constructor" was removed. Now SWIG generates the proxy
+ function by itself and assigns it directly to the class table "__call" method.
+ 5. eLua should also now support inheritance.
+ 6. 'const' subtable in eLua is considered deprecated.
+
+ Changes in behaviour:
+ a. You can no longer assign to non-existing class members in classes without a __setitem__ method.
+ It will cause a Lua error.
+ b. You can no longer iterate over a module table and copy everything into the global namespace.
+ Actually, this was never the case, but it is now explicitly prohibited.
+ c. Now changing a base class will immediately affect all derived classes.
+ d. There might be some issues with inheritance. Although the bases iteration scheme is the same
+ as was used for merging base classes into derived one, some unknown issues may arise.
+
+ The old metatable behaviour can be restored by using the -no-old-metatable-bindings option.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2014-03-06: wsfulton
+ [Python] Change in default behaviour wrapping C++ bool. Only a Python True or False
+ will now work for C++ bool parameters. This fixes overloading bool with other types.
+ Python 2.3 minimum is now required for wrapping bool.
+
+ When wrapping:
+
+ const char* overloaded(bool value) { return "bool"; }
+ const char* overloaded(int value) { return "int"; }
+
+ Previous behaviour:
+ >>> overloaded(False)
+ 'int'
+ >>> overloaded(True)
+ 'int'
+ >>> overloaded(0)
+ 'int'
+
+ Now we get the expected behaviour:
+ >>> overloaded(False)
+ 'bool'
+ >>> overloaded(0)
+ 'int'
+
+ The consequence is when wrapping bool in non-overloaded functions:
+
+ const char* boolfunction(bool value) { return value ? "true" : "false"; }
+
+ The previous behaviour was very Pythonic:
+ >>> boolfunction("")
+ 'false'
+ >>> boolfunction("hi")
+ 'true'
+ >>> boolfunction(12.34)
+ 'true'
+ >>> boolfunction(0)
+ 'false'
+ >>> boolfunction(1)
+ 'true'
+
+ Now the new behaviour more along the lines of C++ due to stricter type checking. The
+ above calls result in an exception and need to be explicitly converted into a bool as
+ follows:
+ >>> boolfunction(0)
+ Traceback (most recent call last):
+ File "<stdin>", line 1, in <module>
+ TypeError: in method 'boolfunction', argument 1 of type 'bool'
+ >>> boolfunction(bool(0))
+ 'false'
+
+ The old behaviour can be resurrected by passing the -DSWIG_PYTHON_LEGACY_BOOL command line
+ parameter when executing SWIG. Typemaps can of course be written to customise the behaviour
+ for specific parameters.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2014-03-06: wsfulton
+ Fix SF Bug #1363 - Problem with method overloading when some methods are added by %extend
+ and others are real methods and using template default parameters with smart pointers.
+ This is noticeable as a regression since 2.0.12 when using the default smart pointer
+ handling for some languages when the smart pointer wraps std::map and other STL containers.
+
+2014-03-02: wsfulton
+ [Python] SF Patch #346 from Jens Krueger. Correct exception thrown attempting to
+ access a non-existent C/C++ global variable on the 'cvar' object. The exception thrown
+ used to be a NameError. However, as this access is via a primary, an AttributeError
+ is more correct and so the exception thrown now is an AttributeError. Reference:
+ http://docs.python.org/2/reference/expressions.html#attribute-references
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2014-03-01: wsfulton
+ [Python] Patch #143 Fix type shown when using type() to include the module and package
+ name when using -builtin.
+
+2014-03-01: wsfulton
+ [Python] SF patch #347 Fix missing argument count checking with -modern.
+ Fixes regression introduced when builtin changes were introduced in SWIG-2.0.3.
+
+2014-02-21: wsfulton
+ [PHP] Fix warning suppression using %warnfilter for PHP reserved class names.
+
+2014-02-19: olly
+ [Lua] Add keyword warnings for Lua keywords and Basic Functions.
+
+2014-02-19: olly
+ -Wallkw now includes keywords for all languages with keyword
+ warnings (previously Go and R were missing).
+
+2014-02-19: olly
+ [PHP] Update the lists of PHP keywords with new ones from PHP 5.4
+ and newer (and some missing ones from 5.3). Reserved PHP constants
+ names are now checked against enum values and constants, instead
+ of against function and method names. Built-in PHP function names
+ no longer match methods added by %extend. Functions and methods
+ named '__sleep', '__wakeup', 'not', 'parent', or 'virtual' are no
+ longer needlessly renamed.
+
+2014-02-15: wsfulton
+ Fix the %$ismember %rename predicates to also apply to members added via %extend.
+
+ Add %$isextendmember for %rename of members added via %extend. This can be used to
+ distinguish between normal class/struct members and %extend members. For example
+ '%$ismember, %$not %$isextendmember' will now identify just class/struct members.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2014-02-16: hfalcic
+ [Python] Patch #137 - fix crashes/exceptions in exception handling in Python 3.3
+
+2014-02-15: wsfulton
+ [Java] Add support for the cdata library.
+
+2014-02-08: vkalinin
+ Nested class support added. This primarily allows SWIG to properly parse nested
+ classes and keep the nested class information in the parse tree. Java and C#
+ have utilised this information wrapping the C++ nested classes as Java/C#
+ nested classes. The remaining target languages ignore nested classes as in
+ previous versions. Help is needed by users of these remaining languages to
+ design how C++ nested classes can be best wrapped. Please talk to us on the
+ swig-devel mailing list if you think you can help.
+
+ Previously, there was limited nested class support. Nested classes were treated
+ as opaque pointers. However, the "nestedworkaround" feature provided a way to
+ wrap a nested class as if it was a global class. This feature no longer exists
+ and is replaced by the new "flatnested" feature. This effectively does the same
+ thing with less manual code to be written. Please see the 'Nested classes'
+ section in the documentation in SWIGPlus.html if you were previously using this
+ feature.
+
+ SWIG now parses the contents of nested classes where previously it did not. You
+ may find that you will need to make adjustments to your interface file as
+ effectively extra code is being wrapped.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2014-02-06: gjanssens
+ [Guile] Patch #133. Make scm to string conversion work with non-ascii strings.
+ Guile 2 has a completely rewritten string implementation. SWIG made some assumptions
+ that are no longer valid as to the internals of guile's string representation.
+
+2014-01-30: wsfulton
+ [C#] Add new swigtype_inout.i library containing 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
+
+2014-01-21: ianlancetaylor
+ [Go] Add %go_import directive.
+
+2014-01-21: ianlancetaylor
+ [Go] Add support for Go 1.3, not yet released.
+
+2014-01-20: wsfulton
+ Director exceptions (Swig::DirectorException) now derive from std::exception
+ and hence provide the what() method. In Python and Ruby, this replaces the now
+ deprecated DirectorException::getMessage() method.
+
+2014-01-14: diorcety
+ Patch #112 - Fix symbol resolution involving scopes that have multiple levels
+ of typedefs - fixes some template resolutions as well as some typemap searches.
+
+2014-01-11: wsfulton
+ Fix and document the naturalvar feature override behaviour - the naturalvar
+ feature attached to a variable name has precedence over the naturalvar
+ feature attached to the variable's type. The overriding was not working
+ when turning the feature off on the variable's name.
+
+ Fix so that any use of the naturalvar feature will override the global
+ setting. Previously when set globally by -naturalvar or %module(naturalvar=1),
+ use of the naturalvar feature was not always honoured.
+
+2014-01-06: ianlancetaylor
+ [Go] Fix bug that broke using directors from a thread not
+ created by Go.
+
+2013-12-24: ptomulik
+ [Python] SF Bug #1297
+
+ Resolve several issues related to python imports.
+ For example, it's now possible to import modules having the same module
+ names, but belonging in different packages.
+
+ From the user's viewpoint, this patch gives a little bit more control on
+ import statements generated by SWIG. The user may choose to use relative
+ or absolute imports.
+
+ Some details:
+ - we (still) generate import statements in the form 'import a.b.c' which
+ corresponds to absolute imports in python3 and (the only available)
+ ambiguous one in python2.
+ - added -relativeimport option to use explicit relative import syntax
+ (python3),
+
+ The "Python Packages" section in the documentation discusses how to work
+ with importing packages including the new -relativeimport command line option.
+
+2013-12-23: vadz
+ [Octave, Perl, Python, R, Ruby, Tcl] Change the length of strings created from fixed-size char
+ buffers in C code.
+
+ This is a potential backwards compatibility break: a "char buf[5]" containing "ho\0la" was
+ returned as a string of length 5 before, but is returned as a string of length 2 now. Also,
+ it was possible to assign a (non-NUL-terminated) string "hello" to such a buffer before but
+ now this fails and only "helo" can fit.
+
+ Apply "char FIXSIZE[ANY]" typemaps to explicitly choose the old behaviour.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2013-12-23: talby
+ [Perl] Add support for directors.
+
+2013-12-18: ianlancetaylor
+ [Go] Don't require that Go environment variables be set
+ when running examples or testsuite when using Go 1 or
+ later.
+
+2013-12-17: ianlancetaylor
+ [Go] Remove -longsize option (for backward compatibility,
+ ignore it if seen).
+
+2013-12-17: ianlancetaylor
+ [Go] Add -go-pkgpath option.
+
+2013-12-16: ianlancetaylor
+ [Go] Update for Go 1.2 release. Add support for linking
+ SWIG code directly into executable, rather than using a
+ shared library.
+
+2013-12-13: ianlancetaylor
+ [Go] Add SWIG source file name as comments in generated
+ files. This can be used by Go documentation tools.
+
+2013-12-12: jleveque
+ [Lua] Fix typo (wchar instead of wchar_t) which made wchar.i
+ for Lua useless.
+
+2013-12-12: vmiklos
+ [PHP] PHP's peculiar call-time pass-by-reference feature was
+ deprecated in PHP 5.3 and removed in PHP 5.4, so update the REF
+ typemaps in phppointers.i to specify pass-by-reference in the
+ function definition. Examples/php/pointer has been updated
+ accordingly.
+
+2013-12-12: olly
+ [PHP] The usage of $input in PHP directorout typemaps has been
+ changed to be consistent with other languages. The typemaps
+ provided by SWIG have been updated accordingly, but if you
+ have written your own directorout typemaps, you'll need to
+ update $input to &$input (or make equivalent changes).
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2013-11-27: vadz
+ [C#, Java, Python] Add std_auto_ptr.i defining typemaps for returning std::auto_ptr<>.
+
+2013-11-09: wsfulton
+ [C#] Apply patch #79 from Brant Kyser
+ - Remove using directives from the generated C# code and fully qualify the use of all .NET
+ framework types in order to minimize potential name collisions from input files defining
+ types, namespace, etc with the same name as .NET framework members.
+ - Globally qualify the use of .NET framework types in the System namespace
+ - Remove .NET 1.1 support, .NET 2 is the minimum for the C# module
+
+ This is a potential backwards compatibility break if code has been added relying on these using
+ statements that used to be generated:
+
+ using System;
+ using System.Runtime.InteropServices;
+
+ The quick fix to add these back in is to add the -DSWIG2_CSHARP command line option when
+ executing SWIG. See CSharp.html documentation for more info.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2013-11-05: wsfulton
+ [Java] Fix some corner cases for the $packagepath/$javaclassname special variable substitution.
+
+2013-11-05: wsfulton
+ [Java] Apply patch #91 from Marvin Greenberg - Add director:except feature for improved
+ exception handling in director methods for Java.
+
+2013-10-15: vadz
+ Allow using \l, \L, \u, \U and \E in the substitution part of %(regex:/pattern/subst/)
+ inside %rename to change the case of the text being replaced.
+
+2013-10-12: wsfulton
+ [CFFI] Apply #96 - superclass not lispify
+
+2013-10-12: wsfulton
+ Merge in C++11 support from the gsoc2009-matevz branch where Matevz Jekovec first
+ started the C++0x additions. Documentation of the C++11 features supported is in a
+ new Chapter of the documentation, "SWIG and C++11" in Doc/Manual/CPlusPlus11.html.
+
+2013-10-04: wsfulton
+ Fix %naturalvar not having any affect on templated classes instantiated with an
+ enum as the template parameter type. Problem reported by Vadim Zeitlin.
+
+2013-09-20: wsfulton
+ [Java] Fix a memory leak for the java char **STRING_ARRAY typemaps.
+
+Version 2.0.12 (9 Feb 2014)
+===========================
+
+2014-01-16: wsfulton
+ [PHP] Fix compilation error in ZTS mode (64 bit windows) due to incorrect placement
+ of TSRMLS_FETCH() in SWIG_Php_GetModule() as reported by Mark Dawson-Butterworth.
+
+2014-01-13: kwwette
+ [Octave] update support to Octave version 3.8.0
+
+ - Octave 3.8.0 no longer defines OCTAVE_API_VERSION_NUMBER, but 3.8.1
+ will define OCTAVE_{MAJOR,MINOR,PATCH}_VERSION instead: see
+ http://hg.savannah.gnu.org/hgweb/octave/rev/b6b6e0dc700e
+ So we now use a new macro SWIG_OCTAVE_PREREQ(major,minor,patch) to
+ enable features requiring Octave version major.minor.patch or later.
+
+ For Octave versions prior to 3.8.1, we reconstruct values for
+ OCTAVE_{MAJOR,MINOR,PATCH}_VERSION based on OCTAVE_API_VERSION_NUMBER,
+ extracted from Octave's ChangeLogs. An additional hack is needed to
+ distinguish between Octave <= 3.2.x and 3.8.0, neither of which define
+ OCTAVE_API_VERSION_NUMBER.
+
+ - Octave 3.8.0 deprecates symbol_table::varref(), so remove its use
+ for this and future versions of Octave.
+
+ - Octave 3.8.0 removes octave_value::is_real_nd_array(), used in
+ octave_swig_type::dims(). Its use is not required here, so remove it.
+
+ - Retested against Octave versions 3.0.5, 3.2.4, 3.4.3, 3.6.4, and 3.8.0.
+
+ - Updated Octave documentation with tested Octave versions, and added a
+ warning against using versions <= 3.x.x, which are no longer tested.
+
+2013-12-22: wsfulton
+ C++11 support for new versions of erase and insert in the STL containers.
+
+ The erase and insert methods in the containers use const_iterator instead
+ of iterator in C++11. There are times when the methods wrapped must match
+ the parameters exactly. Specifically when full type information for
+ template types is missing or SWIG fails to look up the type correctly,
+ for example:
+
+ %include <std_vector.i>
+ typedef float Real;
+ %template(RealVector) std::vector<Real>;
+
+ SWIG does not find std::vector<Real>::iterator because %template using
+ typedefs does not always work and so SWIG doesn't know if the type is
+ copyable and so uses SwigValueWrapper<iterator> which does
+ not support conversion to another type (const_iterator). This resulted
+ in compilation errors when using the C++11 version of the containers.
+
+ Closes #73
+
+2013-10-17: wsfulton
+ [R] Fix SF #1340 - Visual Studio compile error in C++ wrappers due to #include <exception>
+ within extern "C" block.
+
+2013-10-17: wsfulton
+ [Python] Fix SF #1345 - Missing #include <stddef.h> for offsetof when using -builtin.
+
+2013-10-12: wsfulton
+ [Lua] Apply #92 - missing return statements for SWIG_Lua_add_namespace_details()
+ and SWIG_Lua_namespace_register().
+
Version 2.0.11 (15 Sep 2013)
============================
The macros are silently ignored.
2013-04-17: wsfulton
- [C#] Pull patch #34 from BrantKyser to fix smart pointers in conjuction with directors.
+ [C#] Pull patch #34 from BrantKyser to fix smart pointers in conjunction with directors.
2013-04-15: kwwette
[Octave] Fix bugs in output of cleanup code.
2012-10-11: wsfulton
Most of the special variables available for use in %exception are now also available for expansion in
- %extend blocks. These are: $name $symname $overname $decl $fulldecl $parentname $parentsymname, see docs
+ %extend blocks. These are: $name $symname $overname $decl $fulldecl $parentclassname $parentclasssymname, see docs
on "Class extension" in SWIGPlus.html. Patch based on submission from Kris Thielemans.
2012-10-10: wsfulton
Additional new special variables in %exception are expanded as follows:
- $parentname - The parent class name (if any) for a method.
- $parentsymname - The target language parent class name (if any) for a method.
+ $parentclassname - The parent class name (if any) for a method.
+ $parentclasssymname - The target language parent class name (if any) for a method.
2012-10-08: iant
[Go] Generating Go code now requires using the -intgosize option to
[Lua] Fix uninitialised variable in SWIGTYPE **OUTPUT typemaps as reported by Jim Anderson.
2012-04-28: wsfulton
- [Python] Fix compilation errors when wrapping STL containers on Mac OSX and possibly other systems.
+ [Python] Fix compilation errors when wrapping STL containers on Mac OS X and possibly other systems.
2012-04-28: wsfulton
[Java] Patch 3521811 from Leo Davis - char **STRING_ARRAY typemaps fixed to handle
-tmsearch and -tmused.
2011-08-26: wsfulton
- [C#, D] Fix %callback which was generating uncompileable code.
+ [C#, D] Fix %callback which was generating uncompilable code.
2011-08-25: wsfulton
Fix constructors in named typedef class declarations as reported by Gregory Bronner:
PySlice_GetIndices, which changed signatures in python3.2.
2011-04-07: wsfulton
- Fix wrapping of const array typedefs which were generating uncompileable code as
+ Fix wrapping of const array typedefs which were generating uncompilable code as
reported by Karl Wette.
2011-04-03: szager
Update chapter name to MzScheme/Racket accounting for the rename of MzScheme to Racket.
2011-02-05: wsfulton
- [C#] SF #3085906 - Possible fix running test-suite on Mac OSX.
+ [C#] SF #3085906 - Possible fix running test-suite on Mac OS X.
2011-02-05: wsfulton
SF #3173367 Better information during configure about Boost prerequisite for running
Fix handling of multiple regex-using %renames attached to the same
declaration. For example, now
- %rename("%(regex/^Set(.*)/put\\1/)s") "";
- %rename("%(regex/^Get(.*)/get\\1/)s") "";
+ %rename("%(regex:/^Set(.*)/put\\1/)s") "";
+ %rename("%(regex:/^Get(.*)/get\\1/)s") "";
works as expected whereas before only the last anonymous rename was
taken into account.
in this case).
2010-06-03: wsfulton
- Fix uncompileable code when %rename results in two enum items
+ Fix uncompilable code when %rename results in two enum items
with the same name. Reported by Vadim Zeitlin.
Version 2.0.0 (2 June 2010)
Fix #2310483 - function pointer typedef within extern "C" block.
2009-11-13: wsfulton
- Fix usage of nested template classes within templated classes so that compileable code
+ Fix usage of nested template classes within templated classes so that compilable code
is generated.
2009-11-13: olly
wasn't being used. Patch from gverbruggen in SF#2892647.
2009-11-12: wsfulton
- Fix usage of nested template classes so that compileable code is generated - the nested
+ Fix usage of nested template classes so that compilable code is generated - the nested
template class is now treated like a normal nested classes, that is, as an opaque type
unless the nestedworkaround feature is used.
2009-11-11: wsfulton
There were a number of C++ cases where nested classes/structs/unions were being handled
- as if C code was being parsed which would oftentimes lead to uncompileable code as an
+ as if C code was being parsed which would oftentimes lead to uncompilable code as an
attempt was made to wrap the nested structs like it is documented for C code. Now all
nested structs/classes/unions are ignored in C++ mode, as was always documented. However,
there is an improvement as usage of nested structs/classes/unions is now always treated
Fix R for -fcompact and add std_map.i
2009-11-08: wsfulton
- Fix inconsistency for nested structs/unions/classes. Uncompileable code was being
+ Fix inconsistency for nested structs/unions/classes. Uncompilable code was being
generated when inner struct and union declarations were used as types within the
inner struct. The inner struct/union is now treated as a forward declaration making the
behaviour the same as an inner class. (C++ code), eg:
Ignored nested class/struct warnings now display the name of the ignored class/struct.
2009-11-07: wsfulton
- Bug #1514681 - Fix nested template classes within a namespace generated uncompileable
+ Bug #1514681 - Fix nested template classes within a namespace generated uncompilable
code and introduced strange side effects to other wrapper code especially code
after the nested template class. Note that nested template classes are still ignored.
and in template parameter specializations:
struct S {};
- template <typename T> struct X { void a() {}; };
- template <> struct X<S> { void b() {}; };
+ template <typename T> struct X { void a() {} };
+ template <> struct X<S> { void b() {} };
%template(MyTConcrete) X< ::S >;
plus probably some other corner case usage of ::.
in Allegro CL
2008-07-19: wsfulton
- Fix building of Tcl examples/test-suite on Mac OSX reported by Gideon Simpson.
+ Fix building of Tcl examples/test-suite on Mac OS X reported by Gideon Simpson.
2008-07-17: wsfulton
Fix SF #2019156 Configuring with --without-octave or --without-alllang
06/19/2008: wsfulton
[Java, C#] C# and Java keywords will be renamed instead of just issuing a warning
- and then generating uncompileable code. Warning 314 gives the new name when a
+ and then generating uncompilable code. Warning 314 gives the new name when a
keyword is found.
06/19/2008: wsfulton
Makefile target being generated when generating makefiles with the -M family
of options. For example:
- $ swig -java -MM -MT overiddenname -c++ example.i
- overiddenname: \
+ $ swig -java -MM -MT overriddenname -c++ example.i
+ overriddenname: \
example.i \
example.h
11/30/2007: wsfulton
Fix using statements using a base class method where the methods were overloaded.
Depending on the order of the using statements and method declarations, these
- were previously generating uncompileable wrappers, eg:
+ were previously generating uncompilable wrappers, eg:
struct Derived : Base {
virtual void funk();
%attributeref(Class, AttributeType, AttributeName, AccessorMethod)
10/16/2007: olly
- [Tcl] Fix several ocurrences of "warning: deprecated conversion
+ [Tcl] Fix several occurrences of "warning: deprecated conversion
from string constant to 'char*'" from GCC 4.2 in generated C/C++
code.
10/03/2006: wsfulton
[Ruby] Fix #1527885 - Overloaded director virtual methods sometimes produced
- uncompileable code when used with the director:except feature.
+ uncompilable code when used with the director:except feature.
10/03/2006: wsfulton
Directors: Directors are output in the order in which they are declared in
6146 _std_containers.so
174 _std_containers.so.hidden
- Excecution times:
+ Execution times:
real 0m0.050s user 0m0.039s sys 0m0.005s _std_containers.so
real 0m0.039s user 0m0.026s sys 0m0.007s _std_containers.so.hidden
protected methods by default.
In previous releases, you needed to use the 'dirprot'
- option to acheive the same.
+ option to achieve the same.
If you want, you can disable the new default behaviour,
use the 'nodirprot' option:
%rename("%(utitle)s",%$isfunction,%$ismember) "";
- to avoid clashings with other swig macros/directives.
+ to avoid clashes with other swig macros/directives.
01/14/2006: cfisavage
[Ruby]
12/10/2005: mmatus
[UTF]
- - Fix unneccessary calls to SWIG_TypeQuery for 'char *'
+ - Fix unnecessary calls to SWIG_TypeQuery for 'char *'
and 'wchar_t *', problem found by Clay Culver while
profiling the PyOgre project.
wrapper method only and not the extra overloaded methods that SWIG generates.
For example:
- %feature("except") void hello(int i=0, double d=0.0);
+ %feature("except") hello(int i=0, double d=0.0);
void hello(int i=0, double d=0.0);
will apply the feature to all three wrapper methods, that is:
If the default arguments are not specified in the feature:
- %feature("except") void hello(int i, double d);
+ %feature("except") hello(int i, double d);
void hello(int i=0, double d=0.0);
then the feature will only apply to this wrapper method:
- Remove the ability to share type information by using c linking.
All type sharing happens through a global variable in the target language.
+ Remove SWIG_NOIMPORT, SWIG_RUNTIME, and related defines.
- + Depreciate -runtime, -noruntime command line options
+ + Deprecate -runtime, -noruntime command line options
+ Update test-suite common.mk to correctly build multicpptest
+ Remove reference to precommon.swg
+ Update the guile_gh interface to share data by a global var instead
now if you have
- %pythonnondynamic(1) A;
+ %pythonnondynamic A;
struct A {
int a;
Since this is a feature, you can use
- %pythonnondynamic(1);
+ %pythonnondynamic;
or
- %pythondynamic(0); [ Note: %pythondynamic since deprecated ]
+ %pythondynamic; [ Note: %pythondynamic since deprecated ]
to force all the wrapped classes to be "nondynamic" ones.
...
}
- Previously, none of BIG, LARGE or BAR would have produced compileable code
+ Previously, none of BIG, LARGE or BAR would have produced compilable code
when using %javaconst(1).
06/27/2004: wsfulton
11/30/2003: cheetah (William Fulton)
[Java] Fixed [ 766409 ] missing symbol SWIG_JavaThrowException during module load
- SWIGs internal functions are all static as there is no need for different SWIG
+ SWIG's internal functions are all static as there is no need for different SWIG
generated modules to share any code at runtime.
11/30/2003: beazley
Suggested by Kerim Borchaev.
11/11/2003: beazley
- Configuration changes to make SWIG work on Mac OSX 10.3.x (Panther).
+ Configuration changes to make SWIG work on Mac OS X 10.3.x (Panther).
Tested with Python, Tcl, Perl, and Ruby---all of which seem to work.
11/08/2003: cheetah (William Fulton)
class TestClass
{
public:
- TestClass() {};
- TestClass(int a) {};
- ~TestClass() {};
- unsigned long xyz(short k) {};
- unsigned long xyz(int n) {};
- static void static_func() {};
- static void static_func(int a) {};
+ TestClass() {}
+ TestClass(int a) {}
+ ~TestClass() {}
+ unsigned long xyz(short k) {}
+ unsigned long xyz(int n) {}
+ static void static_func() {}
+ static void static_func(int a) {}
};
void delete_TestClass(int a);
*** POTENTIAL INCOMPATIBILITY ***
1/30/00 : loic
- Conditionaly compile experimental code with --enable-experiment
+ Conditionally compile experimental code with --enable-experiment
configure flag.
- Fix .cvsignore to ignore configrue & yacc generated files
+ Fix .cvsignore to ignore configure & yacc generated files
1/28/00 : loic
Apply automake everywhere
12/29/97: Fixed configure script and a few makefiles to support Python 1.5
12/29/97: Added 'embed15.i' library file. This file should be used to
- staticly link versions of Python 1.5. To make it the default,
+ statically link versions of Python 1.5. To make it the default,
simply copy 'swig_lib/python/embed15.i' to 'swig_lib/python/embed.i'
Version 1.1 Patch 3 (November 24, 1997)
2/23/97 : Modified Python module to be better behaved under Windows
- Module initialization function is now properly exported.
- It should not be neccessary to explicitly export this function
+ It should not be necessary to explicitly export this function
yourself.
- Bizarre compilation problems when compiling the SWIG wrapper
See the CHANGES file for changes in older releases.
See the RELEASENOTES file for a summary of changes in each release.
-Version 2.0.12 (9 Feb 2014)
-===========================
-
-2014-01-16: wsfulton
- [PHP] Fix compilation error in ZTS mode (64 bit windows) due to incorrect placement
- of TSRMLS_FETCH() in SWIG_Php_GetModule() as reported by Mark Dawson-Butterworth.
-
-2014-01-13: kwwette
- [Octave] update support to Octave version 3.8.0
-
- - Octave 3.8.0 no longer defines OCTAVE_API_VERSION_NUMBER, but 3.8.1
- will define OCTAVE_{MAJOR,MINOR,PATCH}_VERSION instead: see
- http://hg.savannah.gnu.org/hgweb/octave/rev/b6b6e0dc700e
- So we now use a new macro SWIG_OCTAVE_PREREQ(major,minor,patch) to
- enable features requiring Octave version major.minor.patch or later.
-
- For Octave versions prior to 3.8.1, we reconstruct values for
- OCTAVE_{MAJOR,MINOR,PATCH}_VERSION based on OCTAVE_API_VERSION_NUMBER,
- extracted from Octave's ChangeLogs. An additional hack is needed to
- distinguish between Octave <= 3.2.x and 3.8.0, neither of which define
- OCTAVE_API_VERSION_NUMBER.
-
- - Octave 3.8.0 deprecates symbol_table::varref(), so remove its use
- for this and future versions of Octave.
-
- - Octave 3.8.0 removes octave_value::is_real_nd_array(), used in
- octave_swig_type::dims(). Its use is not required here, so remove it.
-
- - Retested against Octave versions 3.0.5, 3.2.4, 3.4.3, 3.6.4, and 3.8.0.
-
- - Updated Octave documentation with tested Octave versions, and added a
- warning against using versions <= 3.x.x, which are no longer tested.
-
-2013-12-22: wsfulton
- C++11 support for new versions of erase and insert in the STL containers.
-
- The erase and insert methods in the containers use const_iterator instead
- of iterator in C++11. There are times when the methods wrapped must match
- the parameters exactly. Specifically when full type information for
- template types is missing or SWIG fails to look up the type correctly,
- for example:
-
- %include <std_vector.i>
- typedef float Real;
- %template(RealVector) std::vector<Real>;
-
- SWIG does not find std::vector<Real>::iterator because %template using
- typedefs does not always work and so SWIG doesn't know if the type is
- copyable and so uses SwigValueWrapper<iterator> which does
- not support conversion to another type (const_iterator). This resulted
- in compilation errors when using the C++11 version of the containers.
-
- Closes #73
-
-2013-10-17: wsfulton
- [R] Fix SF #1340 - Visual Studio compile error in C++ wrappers due to #include <exception>
- within extern "C" block.
-
-2013-10-17: wsfulton
- [Python] Fix SF #1345 - Missing #include <stddef.h> for offsetof when using -builtin.
-
-2013-10-12: wsfulton
- [Lua] Apply #92 - missing return statements for SWIG_Lua_add_namespace_details()
- and SWIG_Lua_namespace_register().
-
+Version 3.0.10 (12 Jun 2016)
+============================
+
+2016-06-06: mromberg
+ [Python] Patch #698. Add support for -relativeimport for python 2.7, so -py3 is no
+ longer also required for relative import support.
+
+2016-06-05: mromberg
+ [Python] Patch #694 - Fix package import regressions introduced in swig-3.0.9.
+
+ 1) The code in 3.0.9 did not fall back to 'import _foo' if 'import bar._foo' failed
+ (assuming bar.foo was the main module). Every place _foo is imported now first tries
+ it from the package where foo was found and if that fails tries _foo as a global module.
+
+ 2) The separate block of Python code that injected code to pull in the attributes
+ from _foo when -builtin is used made use of the -py3 switch to either do
+ 'from ._foo import *' or "from _foo import *". This block of code no longer does this
+ and instead checks the Python version at runtime to switch between the two syntaxes.
+
+ In summary, swig-3.0.10 has been modified to ease the creation of wrapper modules
+ that can be fully made part of a Python package. SWIG no longer
+ assumes the dynamically linked C module is a global module.
+ The dynamic module can now be placed into either the same package as the pure Python
+ module or as a global module. Both locations are used by the Python wrapper to
+ locate the C module.
+
+ However, this could cause a backwards incompatibility with some code
+ that was relying on the ability of "from package import _module" to
+ pull attributes out of the package directly. If your code populates a
+ module (which is also a package) with attributes that are SWIG
+ generated modules which were not loaded in a conventional way,
+ swig-3.0.8 and earlier may have worked due to 'from package import
+ _module' bypassing a real import and pulling your module in as an
+ attribute. This will no longer work. Since this is not a common (or
+ even recommended) practice, most folk should not be affected.
+
+ *** POTENTIAL INCOMPATIBILITY ***
+
+2016-05-31: wsfulton
+ Fix #690 - Smart pointer to %ignored class doesn't expose inherited methods.
+ Regression introduced in swig-3.0.9.
Information-technology Promotion Agency, Japan
Active SWIG Developers:
- William Fulton (wsf@fultondesigns.co.uk) (SWIG core, Java, C#, Windows, Cygwin)
- Olly Betts (olly@survex.com) (PHP)
- Joseph Wang (joequant@gmail.com) (R)
- Xavier Delacour (xavier.delacour@gmail.com) (Octave)
- David Nadlinger (code@klickverbot.at) (D)
+ William Fulton (wsf@fultondesigns.co.uk) (SWIG core, Java, C#, Windows, Cygwin)
+ Olly Betts (olly@survex.com) (PHP)
+ Joseph Wang (joequant@gmail.com) (R)
+ Xavier Delacour (xavier.delacour@gmail.com) (Octave)
+ David Nadlinger (code@klickverbot.at) (D)
+ Oliver Buchtala (oliver.buchtala@gmail.com) (Javascript)
+ Neha Narang (narangneha03@gmail.com) (Javascript)
+ Simon Marchetto (simon.marchetto@scilab-enterprises.com) (Scilab)
Past SWIG developers and major contributors include:
- Dave Beazley (dave-swig@dabeaz.com) (SWIG core, Python, Tcl, Perl)
- Henning Thielemann (swig@henning-thielemann.de) (Modula3)
- Matthias Köppe (mkoeppe@mail.math.uni-magdeburg.de) (Guile, MzScheme)
- Luigi Ballabio (luigi.ballabio@fastwebnet.it) (STL wrapping)
- Mikel Bancroft (mikel@franz.com) (Allegro CL)
- Surendra Singhi (efuzzyone@netscape.net) (CLISP, CFFI)
- Marcelo Matus (mmatus@acms.arizona.edu) (SWIG core, Python, UTL[python,perl,tcl,ruby])
- Art Yerkes (ayerkes@speakeasy.net) (Ocaml)
- Lyle Johnson (lyle@users.sourceforge.net) (Ruby)
- Charlie Savage (cfis@interserv.com) (Ruby)
- Thien-Thi Nguyen (ttn@glug.org) (build/test/misc)
- Richard Palmer (richard@magicality.org) (PHP)
- Sam Liddicott - Ananova Ltd (saml@liddicott.com) (PHP)
- Tim Hockin - Sun Microsystems (thockin@sun.com) (PHP)
- Kevin Ruland (PHP)
- Shibukawa Yoshiki (Japanese Translation)
- Jason Stewart (jason@openinformatics.com) (Perl5)
- Loic Dachary (Perl5)
- David Fletcher (Perl5)
- Gary Holt (Perl5)
- Masaki Fukushima (Ruby)
- Scott Michel (scottm@cs.ucla.edu) (Java directors)
- Tiger Feng (songyanf@cs.uchicago.edu) (SWIG core)
- Mark Rose (mrose@stm.lbl.gov) (Directors)
- Jonah Beckford (beckford@usermail.com) (CHICKEN)
- Ahmon Dancy (dancy@franz.com) (Allegro CL)
- Dirk Gerrits (Allegro CL)
- Neil Cawse (C#)
- Harco de Hilster (Java)
- Alexey Dyachenko (dyachenko@fromru.com) (Tcl)
- Bob Techentin (Tcl)
- Martin Froehlich <MartinFroehlich@ACM.org> (Guile)
- Marcio Luis Teixeira <marciot@holly.colostate.edu> (Guile)
- Duncan Temple Lang (R)
- Miklos Vajna <vmiklos@frugalware.org> (PHP directors)
- Mark Gossage (mark@gossage.cjb.net) (Lua)
- Raman Gopalan (ramangopalan@gmail.com) (eLua)
- Gonzalo Garramuno (ggarra@advancedsl.com.ar) (Ruby, Ruby's UTL)
- John Lenz (Guile, MzScheme updates, Chicken module, runtime system)
- Ian Lance Taylor (Go)
- Vadim Zeitlin (PCRE)
- Stefan Zager (szager@gmail.com) (Python)
+ Dave Beazley (dave-swig@dabeaz.com) (SWIG core, Python, Tcl, Perl)
+ Henning Thielemann (swig@henning-thielemann.de) (Modula3)
+ Matthias Köppe (mkoeppe@mail.math.uni-magdeburg.de) (Guile, MzScheme)
+ Luigi Ballabio (luigi.ballabio@fastwebnet.it) (STL wrapping)
+ Mikel Bancroft (mikel@franz.com) (Allegro CL)
+ Surendra Singhi (efuzzyone@netscape.net) (CLISP, CFFI)
+ Marcelo Matus (mmatus@acms.arizona.edu) (SWIG core, Python, UTL[python,perl,tcl,ruby])
+ Art Yerkes (ayerkes@speakeasy.net) (Ocaml)
+ Lyle Johnson (lyle@users.sourceforge.net) (Ruby)
+ Charlie Savage (cfis@interserv.com) (Ruby)
+ Thien-Thi Nguyen (ttn@glug.org) (build/test/misc)
+ Richard Palmer (richard@magicality.org) (PHP)
+ Sam Liddicott - Ananova Ltd (saml@liddicott.com) (PHP)
+ Tim Hockin - Sun Microsystems (thockin@sun.com) (PHP)
+ Kevin Ruland (PHP)
+ Shibukawa Yoshiki (Japanese Translation)
+ Jason Stewart (jason@openinformatics.com) (Perl5)
+ Loic Dachary (Perl5)
+ David Fletcher (Perl5)
+ Gary Holt (Perl5)
+ Masaki Fukushima (Ruby)
+ Scott Michel (scottm@cs.ucla.edu) (Java directors)
+ Tiger Feng (songyanf@cs.uchicago.edu) (SWIG core)
+ Mark Rose (mrose@stm.lbl.gov) (Directors)
+ Jonah Beckford (beckford@usermail.com) (CHICKEN)
+ Ahmon Dancy (dancy@franz.com) (Allegro CL)
+ Dirk Gerrits (Allegro CL)
+ Neil Cawse (C#)
+ Harco de Hilster (Java)
+ Alexey Dyachenko (dyachenko@fromru.com) (Tcl)
+ Bob Techentin (Tcl)
+ Martin Froehlich <MartinFroehlich@ACM.org> (Guile)
+ Marcio Luis Teixeira <marciot@holly.colostate.edu> (Guile)
+ Duncan Temple Lang (R)
+ Miklos Vajna <vmiklos@frugalware.org> (PHP directors)
+ Mark Gossage (mark@gossage.cjb.net) (Lua)
+ Raman Gopalan (ramangopalan@gmail.com) (eLua)
+ Gonzalo Garramuno (ggarra@advancedsl.com.ar) (Ruby, Ruby's UTL)
+ John Lenz (Guile, MzScheme updates, Chicken module, runtime system)
+ Baozeng Ding <sploving1@163.com> (Scilab)
+ Ian Lance Taylor (Go)
+ Vadim Zeitlin (PCRE, Python)
+ Stefan Zager (szager@gmail.com) (Python)
+ Vincent Couvert (Scilab)
+ Sylvestre Ledru (Scilab)
+ Wolfgang Frisch (Scilab)
Past contributors include:
James Michael DuPont, Clark McGrew, Dustin Mitchell, Ian Cooke, Catalin Dumitrescu, Baran
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+ <META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
+ <TITLE></TITLE>
+ <META NAME="GENERATOR" CONTENT="OpenOffice.org 3.0 (Unix)">
+ <META NAME="CREATED" CONTENT="20090712;16061100">
+ <META NAME="CHANGED" CONTENT="20090817;17311900">
+ <META NAME="Podatek 1" CONTENT="">
+ <META NAME="Podatek 2" CONTENT="">
+ <META NAME="Podatek 3" CONTENT="">
+ <META NAME="Podatek 4" CONTENT="">
+ <STYLE TYPE="text/css">
+ <!--
+ @page { margin: 2cm }
+ H1 { margin-bottom: 0.21cm }
+ H1.western { font-family: "Liberation Serif", serif }
+ H1.cjk { font-family: "DejaVu Sans" }
+ H1.ctl { font-family: "DejaVu Sans" }
+ P { margin-bottom: 0.21cm }
+ H2 { margin-bottom: 0.21cm }
+ A:link { so-language: zxx }
+ -->
+ </STYLE>
+</HEAD>
+<BODY LANG="en-US" DIR="LTR">
+<H1 CLASS="western"><U>C++0x/C++11 support for SWIG</U></H1>
+<H1 CLASS="western">Summary</H1>
+<P>This is a technical overview of the C++0x/C++11 support for the Swig.
+This area of Swig is a work in progress. Initial C++0x/C++11 support for
+Swig was written during the Google Summer of Code 2009 period by
+Matevž Jekovec.</P>
+<H1 CLASS="western">SVN branch</H1>
+<P>branches/gsoc2009-matevz</P>
+<H1 CLASS="western">New C++11 features status</H1>
+<P>Wikipedia article: <A HREF="http://en.wikipedia.org/wiki/C++0x">http://en.wikipedia.org/wiki/C%2B%2B0x</A>
+</P>
+<H2>Rvalue reference and move semantics [done]</H2>
+<P>The Rvalues are used in practice to speed up the move operations
+on different containers.</P>
+<P>In the following example, we want to swap the given elements:</P>
+<PRE>template <class T> swap(T& a, T& b) {
+ T tmp(a); // now we have two copies of a
+ a = b; // now we have two copies of b
+ b = tmp; // now we have two copies of tmp (aka a)
+}</PRE><P>
+This can now be solved using the new function std::move():</P>
+<PRE>template <class T> swap(T& a, T& b) {
+ T tmp(std::move(a));
+ a = std::move(b);
+ b = std::move(tmp);
+}</PRE><P STYLE="margin-bottom: 0cm">
+For the move function to take effect, user needs to reimplement the
+move constructor (taking ClassType&& as an argument) and
+operator=(ClassType&&):</P>
+<PRE>class MyClass {
+ MyClass(MyClass&& p) : ptr(p.ptr) {p.ptr = 0;}
+ MyClass& operator=(MyClass&& p) {
+ std::swap(ptr, p.ptr);
+ return *this;
+ }
+};</PRE><P>
+In practice, the Rvalues are used for temporaries (when passing the
+result of one function as an argument to another).</P>
+<P>Done: Added type&& to Swig parser. Added testcase
+cpp11_rvalue_reference.i. Operator && is treated the same as
+operator &. R11450</P>
+<P STYLE="margin-bottom: 0cm">Article:
+<A HREF="http://www.artima.com/cppsource/rvalue.html">http://www.artima.com/cppsource/rvalue.html</A></P>
+<H2>Generalized constant expressions [done]</H2>
+<P>In C++11 you can define functions as constant expressions.
+Functions need to return constant value in form "return expr",
+where expr is a constant expression.
+</P>
+<P>A keyword "constexpr" is introduced for this. eg.:
+constexpr int getNumber() { return 5; } const int MY_CONSTANT =
+getNumber();
+</P>
+<P>Constants are treated as normal variables in interpreted languages
+because they are not compiled into the executable. Java "final"
+constants are defined runtime as well. C++ constants need to be
+declared in the header file and defined in the implementation file,
+so swig doesn't need to know about the constant values when parsing
+the header file.
+</P>
+<P>Done: Added the “constexpr “ keyword to Swig. Added testcase
+cpp11_constexpr. R11322</P>
+<P>Problem: No compilers were known to support constexpr yet, so the
+testcase was temporarily commented out in common.mk.
+</P>
+<H2>Extern template [done]</H2>
+<P>Extern template forces the GCC compiler to not instantiate the
+template in the translation unit at that time. It's a feature
+specifically aimed at compilers to speed up the compilation process.
+</P>
+<P>Done: Added support for 'extern template class
+std::vector<MyClass>;'. Added testcase cpp11_template_explicit.
+R11385 , R11386</P>
+<H2>Initializer lists [done]</H2>
+<P>Initializer list is a new type in standard library:
+std::initializer_list<T>. New symbols {} are introduced for the
+initializer lists.
+</P>
+<P>One can now use:
+</P>
+<PRE> class A {
+ public:
+ A( std::initializer_list<int> );
+ };
+ A a1 = {1,2,3,4};</PRE><P>
+Languages like Java, C# and Python already support direct creation of
+lists natively.</P>
+<P>Problem: initializer_list cannot be treated as an ordinary list.
+The constructor containing initializer_list can only be accessed by
+assigning the value using the {} brackets. I also don't think there
+is a simple way to convert an ordinary list or a vector to the
+initializer_list.</P>
+<P>Done: Ignored the constructor having initializer_list as its
+argument. Show warning to the user. Added testcase
+cpp11_initializer_list. R11450</P>
+<P>Article:
+<A HREF="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1919.pdf">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1919.pdf</A></P>
+<H2>Uniform initialization [done]</H2>
+<P>The new C++11 standard will allow the following:</P>
+<PRE>struct IdString {
+ std::string name;
+ int identifier;
+};
+
+IdString GetString() {
+ return {"SomeName", 4}; //Note the lack of explicit type.
+}</PRE><P>
+The feature works exactly as it did now for POD types only (eg. int
+a[] = {1,2,3};). The following declarations are the same in the new
+C++11:</P>
+<PRE>IdString str1 = {„SomeName“, 4};
+IdString str2{„SomeName“, 4};</PRE><P>
+The new way of using uniform initialization allows the following:</P>
+<PRE>struct BasicStruct {
+ int x;
+ double y;
+};
+
+struct AltStruct {
+ AltStruct(int x, double y) : x_{x}, y_{y} {}
+
+private:
+ int x_;
+ double y_;
+};
+
+BasicStruct var1{5, 3.2}; // only fills the struct components
+AltStruct var2{2, 4.3}; // calls the constructor</PRE><P>
+The new syntax is specific to C++. Java, C# and scripting languages
+do not support this behaviour, but always need constructors. They
+support {} brackets for declaration of arrays as C does + they add
+support for creation of arrays on-the-fly (what C++11 introduced with
+this feature and more).</P>
+<P>Done: Added syntax for {} member initialization in class
+constructor. Added testcase cpp11_uniform_initialization. R11413</P>
+<H2>Type inference [partially done]</H2>
+<P>A new keyword 'auto' is introduced in C++11:</P>
+<PRE>auto a1 = 100;
+auto a2 = myFunc();</PRE><P>
+The type of a1 and a2 is automatically determined according to the
+initialization value during the semantic phase of the compiler.</P>
+<P>Another macro 'decltype()' is introduced. The macro takes the
+concrete object as an argument and returns its type. User could use
+this as:</P>
+<PRE>int i = 100;
+decltype(i) j = 200; // decltype(i) = int</PRE><P STYLE="margin-bottom: 0cm">
+Calling operators are allowed as well:</P>
+<PRE STYLE="margin-bottom: 0.5cm">decltype(i+j) k = 300;</PRE><P>
+Done: Added support for decltype() syntax. Test cases for normal
+decltype members and alternate function members work fine. Currently
+only syntax in form decltype(variable name) work. No support for
+custom expresions eg. decltype(i+j) yet. R11525</P>
+<P>TODO: William proposed to support the hidden variables as well
+(ones not parsed by Swig and added to symbol table). This also allows
+Swig to parse custom expressions like decltype(i+j). The idea is to
+introduce a new SwigType for this.</P>
+<H2>Range-based for-loop [ignored]</H2>
+<P>This feature is always present inside the implementation block
+only.
+</P>
+<H2>Lambda functions and expressions [done]</H2>
+<P>C++11 introduces lambda functions defined as:</P>
+<PRE STYLE="margin-bottom: 0.5cm">[](int x, int y) -> int { return x + y; }</PRE><P>
+If the lambda function contains a single return statement only or the
+function doesn't return any type, the return type '->' can be
+omitted. Lambda functions are function objects.</P>
+<P>The following example prints the number of items stored in a list:</P>
+<PRE>std::vector<int> someList;
+int total = 0;
+std::for_each( someList.begin(), someList.end(), [&total](int x) {total += x} );
+std::cout << total;</PRE><P>
+Parameters inside the [] are the visible parameters of the lambda
+functions. These can be & (references), = (copies), variable name
+(variable copy), &variable name (variable reference) or this
+(copy of the current object).</P>
+<P>Lambda functions can be stored using:</P>
+<PRE STYLE="margin-bottom: 0.5cm">auto myLambdaFunc = [this]() { this->SomePrivateMemberFunction() };</PRE><P>
+Proposal: Lambda functions are most commonly used inside the function
+block to quickly define how the sort, find and similar functions
+should work (the other way would be overriding a class – the Java
+style). The latest GCC does not support lambda functions yet so it is
+difficult to test the feature once implemented. I would implement the
+syntax support for this feature, but produce no wrapper code. Lambda
+functions still work inside the function block though.</P>
+<P>Article:
+<A HREF="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2550.pdf">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2550.pdf</A></P>
+<P>Done: Added syntax support for the lambda functions. Added
+testcase cpp11_lambda_functions.i. R11491, R11492</P>
+<H2>Alternate function syntax [done]</H2>
+<P>The problem with decltype() is that the parameters need to be
+defined before the decltype. The following syntax is not valid,
+because lhs and rhs hasn't been defined at the time of decltype:</P>
+<PRE>template< typename LHS, typename RHS>
+ decltype(lhs+rhs) AddingFunc(const LHS &lhs, const RHS &rhs) {return lhs + rhs;} //Not legal C++11</PRE><P>
+The solution C++11 offers is the combination of the 'auto' keyword
+before and '-> rettype' after the function declaration:</P>
+<PRE>template< typename LHS, typename RHS>
+ auto AddingFunc(const LHS &lhs, const RHS &rhs) -> decltype(lhs+rhs) {return lhs + rhs;}</PRE><P>
+The new syntax only makes the job for the C++ compilers easier when
+parsing such functions. The new syntax can be used for ordinary
+functions as well:</P>
+<PRE>struct SomeStruct {
+ auto FuncName(int x, int y) -> int;
+};
+
+auto SomeStruct::FuncName(int x, int y) -> int {
+ return x + y;
+}</PRE><P>
+Done: Added support for the 'auto' return type. Added support for the
+'-> type' after the funtion declaration. Added testcases
+cpp11_alternate_function_syntax.i and
+cpp11_alternate_function_syntax_runme.py. R11414</P>
+<H2>Concepts, Axioms [ignored]</H2>
+<P>In C++ there is a common problem when you use a template in the
+class which doesn't support all the operations the functions in the
+class actually do on the type. Compiler errors are usually very long
+and unreadable. C++11 adds support for the "concepts". The
+idea is to define what operations and attributes should the template
+have. In contrast to class inheritance and polimorphism, all lookups
+are done in compile-time.
+</P>
+<P>Basic syntax (note LessThanComparable<A HREF="http://www.dabeaz.com/cgi-bin/wiki.pl?action=change1&id=LessThanComparable">?</A>
+instead of "class" or "typename"):
+</P>
+<PRE> template<LessThanComparable<A HREF="http://www.dabeaz.com/cgi-bin/wiki.pl?action=change1&id=LessThanComparable">?</A> T>
+ const T& min(const T &x, const T &y) {
+ return y < x ? y : x;
+ }</PRE><P>
+Extended syntax (requires conditions are separated with &&,
+|| or !):
+</P>
+<PRE> template< typename T> requires LessThanComparable<A HREF="http://www.dabeaz.com/cgi-bin/wiki.pl?action=change1&id=LessThanComparable">?</A><T>
+ const T& min(const T &x, const T &y) {
+ return y < x ? y : x;
+ }</PRE><P>
+Definition of the concepts:
+</P>
+<PRE> concept LessThanComparable<A HREF="http://www.dabeaz.com/cgi-bin/wiki.pl?action=change1&id=LessThanComparable">?</A>< typename T > {
+ bool operator<(T,T);
+ requires GreaterThanComparable<A HREF="http://www.dabeaz.com/cgi-bin/wiki.pl?action=change1&id=GreaterThanComparable">?</A><T>;
+ typename value_type;
+ typename reference;
+ };</PRE><P>
+Concept maps allow usage of a specific type:
+</P>
+<PRE> template< typename T>
+ concept_map InputIterator<A HREF="http://www.dabeaz.com/cgi-bin/wiki.pl?action=change1&id=InputIterator">?</A><T*> {
+ typedef T value_type ;
+ typedef T& reference ;
+ typedef T* pointer ;
+ typedef std::ptrdiff_t difference_type ;
+ };</PRE><P>
+Concept maps can act as mini-types, with function definitions and
+other constructs commonly associated with classes:
+</P>
+<PRE> concept Stack< typename X> {
+ typename value_type;
+ void push(X&, const value_type&);
+ void pop(X&);
+ value_type top(const X&);
+ bool empty(const X&);
+ };
+ template< typename T>
+ concept_map Stack<std::vector<T> > {
+ typedef T value_type;
+ void push(std::vector<T>& v, const T& x) { v.push_back(x); }
+ void pop(std::vector<T>& v) { v.pop_back(); }
+ T top(const std::vector<T>& v) { return v.back(); }
+ bool empty(const std::vector<T>& v) { return v.empty(); }
+ };</PRE><P>
+Axioms are a facility pertaining to concepts supplied by C++11 to
+express the semantic properties of concepts. For example, the concept
+Semigroup can be defined with an axiom Associativity as:
+</P>
+<PRE> concept Semigroup< typename Op, typename T> : CopyConstructible<A HREF="http://www.dabeaz.com/cgi-bin/wiki.pl?action=change1&id=CopyConstructible">?</A><T> {
+ T operator()(Op, T, T);
+ axiom Associativity(Op op, T x, T y, T z) {
+ op(x, op(y, z)) == op(op(x, y), z);
+ }
+ };</PRE><P>
+Axioms are more like hints to the compiler to speed-up the process of
+compilation.
+</P>
+<P>Ignored: Concepts and axioms were removed from the C++11 standard.
+</P>
+<H2>Object construction improvement [done]</H2>
+<P>This feature allows classes constructors to call other
+constructors with different arguments (similar to Java and C#
+behaviour).
+</P>
+<P>The syntax is as follows:
+</P>
+<PRE> class SomeType {
+ int number;
+ public:
+ SomeType(int newNumber) : number(newNumber) {}
+ SomeType() : SomeType(42) {}
+ };</PRE><P>
+Also when using the inheritance, the feature introduces inheritance
+of all superclass constructors without being defined separately in
+the inherited class:
+</P>
+<PRE> class BaseClass {
+ public:
+ BaseClass(int iValue);
+ };
+ class DerivedClass: public BaseClass {
+ public:
+ using BaseClass::BaseClass; // Adds DerivedClass(int) constructor
+ };</PRE><P>
+Swig already correctly parses and produces the correct wrapper for
+the “using” keyword.</P>
+<P>Done: Added testcase cpp11_constructors.i which covers both
+constructor delegation and constructor inheritance. R11532</P>
+<P>Problem: Constructor delegation and constructor inheritance is not
+supported by any compiler yet, so it's impossible to try and test
+this feature.</P>
+<H2>Null pointer constant [done]</H2>
+<P>nullptr is part of the standard library.
+</P>
+<P>It's defined as typedef decltype(nullptr) nullptr_t;
+</P>
+<P>nullptr_t is defined in <cstddef>.
+</P>
+<P>As far as the C++ is compatible with 0 as the pointer value, swig
+values will work for the C++. And the other way around, nullptr
+behaves as the ordinary pointer (false, if empty, true, if not
+empty), so it's ok for swig to compare it.</P>
+<P>Done: Written a testcase cpp11_null_pointer_constant.i and
+cpp11_null_pointer_constant_runme.py to prove the nullptr
+functionality. R11484</P>
+<H2>Strongly typed enumerations [partially done]</H2>
+<P>C++11 introduces a new syntax for strongly typed enum declaration:
+</P>
+<PRE> enum class Enumeration {
+ Val1,
+ Val2,
+ Val3 = 100,
+ Val4 /* = 101 */
+ };</PRE><P>
+Typing if (Val4 == 101) will result in compilation error.
+</P>
+<P>The enum itself can now be explicitely of type int, long, unsigned
+int etc.:
+</P>
+<PRE STYLE="margin-bottom: 0.5cm"> enum class Enum2 : unsigned int {Val1, Val2};</PRE><P>
+And it can be forward declared as well:
+</P>
+<PRE> enum Enum1; //Illegal in C++ and C++11; no size is explicitly specified.
+ enum Enum2 : unsigned int; //Legal in C++11.
+ enum class Enum3; //Legal in C++11, because enum class declarations have a default type of "int".
+ enum class Enum4: unsigned int; //Legal C++11.
+ enum Enum2 : unsigned short; //Illegal in C++11, because Enum2 was previously declared with a different type.</PRE><P>
+Done: Added syntax 'enum class Name' and forward declarators 'enum
+Name : inherited type' or 'enum class Name : inherited type' in
+R11449.</P>
+<P>TODO: Add semantic support for enum elements not clashing with
+enum elements in other enum classes. See cpp11_strongly_typed_enums.i
+warnings.</P>
+<P>Problem: Swig currently doesn't support nested classes. This
+feature should be implemented using a new nested class when using
+“enum class” with a single anonymous “enum {elements}”
+element inside. For example:</P>
+<PRE STYLE="margin-bottom: 0.5cm">class A { enum class EA { a,b,c,d }; };</PRE><P>
+should be mapped to</P>
+<PRE STYLE="margin-bottom: 0.5cm">class A { class EA { enum {a,b,c,d}; }; };</PRE><H2>
+Angle bracket [done]</H2>
+<P>Support for right angled brackets was implemented using the
+following article as a base:
+<A HREF="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html</A>
+</P>
+<P>Done: Added support for angle brackets. Used the preferred
+"Approach 1". Added a testcase named
+cpp11_template_double_brackets. R11245</P>
+<H2>Explicit conversion operators [done]</H2>
+<P>This is used when converting one type to another (eg. if
+(myObject) {}, where myObject is your custom class converted to
+bool).
+</P>
+<P>Requires both operator and function overloading which is not
+supported in any target language (eg. python, php).
+</P>
+<P>Done: Swig already supports the keyword "explicit" for
+function types as well. Added test case
+cpp11_explicit_conversion_operators. R11323</P>
+<H2>Template typedefs [partially done]</H2>
+<P>The new C++11 will allow creation of wrapper around the template.
+For example, if we want to do this:</P>
+<PRE>template< typename first, typename second, int third>
+class SomeType;
+
+template< typename second>
+typedef SomeType<OtherType, second, 5> TypedefName; //Illegal in C++</PRE><P>
+This is still illegal! But we can now use the new syntax for
+achieving the same effect:</P>
+<PRE>template< typename first, typename second, int third>
+class SomeType;
+
+template< typename second>
+using TypedefName = SomeType<OtherType, second, 5>;</PRE><P>
+Here we created a new wrapper TypedefName taking one template
+argument <second> which creates a type SomeType<OtherType,
+second, 5>. OtherType and 5 are predefined here and hidden from
+the user – the user only uses TypedefName type.</P>
+<P>The same goes for the following example:</P>
+<PRE>typedef void (*PFD)(double); // Old style
+using PF = void (*)(double); // New introduced syntax</PRE><P>
+Swig supports parsing typedefs for templates as well for example:</P>
+<PRE STYLE="margin-bottom: 0.5cm">typedef List<int> intList;</PRE><P>
+Done: Expanded support for the new 'using' syntax and template
+aliasing. Added testcase cpp11_template_typedefs. R11533</P>
+<P>TODO: Make Swig aware of the newly defined typedef. The TYPEDEF
+keyword is part of the storage_class rule and type+declarator (see
+c_decl rule) is the right part of the definition – for example void
+(*PFD)(double) cannot be transformed to void *(double) easily. To
+fully support the new 'using' form, we'll probably have to change the
+type, type_right rules and declarator, direct_declarator,
+notso_direct_declarator etc., which is PITA.</P>
+<H2>Unrestricted unions [done]</H2>
+<P>C++ currently offers usage of unions for types with trivial
+constructors only. The new C++11 standard allows usage of types with
+non-trivial constructors as well:</P>
+<PRE> struct point {
+ point() {}
+ point(int x, int y): x_(x), y_(y) {}
+ int x_, y_;
+ };
+ union P {
+ int z;
+ double w;
+ point p; // Illegal in C++; point has a non-trivial constructor. However, this is legal in C++11.
+ } p1;</PRE><P>
+Swig already parses the given syntax.</P>
+<P>Done: Added testcase cpp11_unrestricted_unions. R11435, R11447</P>
+<P>Problem: GCC doesn't support unrestricted unions yet so there is
+no way to actually test, if it works.</P>
+<H2>Variadic templates [partially done]</H2>
+<P>The new C++11 offers the following syntax:</P>
+<PRE STYLE="margin-bottom: 0.5cm">template<typename... Values> class tuple;</PRE><P>
+This can be used for example:</P>
+<PRE STYLE="margin-bottom: 0.5cm">class tuple<int, std::vector<int>, std::map<std::string, std::vector<int>>> someInstanceName;</PRE><P>
+The ... is used in two cases. One is in the template header where it
+marks on the left the keywords 'typename' or 'class' and a type name
+on the right. The second case is usually in the function block to
+decompose typename on the left of the ... . For example:</P>
+<PRE>void printf(const char *s) {
+ while (*s) {
+ if (*s == '%' && *(++s) != '%')
+ throw std::runtime_error("invalid format string: missing arguments");
+ std::cout << *s++;
+ }
+}
+
+template<typename T, typename... Args>
+void printf(const char* s, T value, Args... args) { // recursive action – split previous args to value + args
+ while (*s) {
+ if (*s == '%' && *(++s) != '%') {
+ std::cout << value;
+ printf(*s ? ++s : s, args...); // call even when *s == 0 to detect extra arguments
+ return;
+ }
+ std::cout << *s++;
+ }
+ throw std::logic_error("extra arguments provided to printf");
+}</PRE><P>
+The tricky part is that variadic templates can unpack actually
+anywhere – including the class inheritance :(</P>
+<PRE>template <typename... BaseClasses> class ClassName : public BaseClasses... {
+public:
+
+ ClassName (BaseClasses&&... baseClasses) : BaseClasses(baseClasses)... {}
+}</PRE><P>
+A new extension to sizeof is also introduced with this feature. The
+... after sizeof returns number of arguments:</P>
+<PRE>template<typename ...Args> struct SomeStruct {
+ static const int size = sizeof...(Args);
+}
+// SomeStruct<Type1, Type2>::size is 2 and SomeStruct<>::size is 0</PRE><P>
+Done: Added syntax support for 'typename' or 'class' + ... + id.
+Added testcase cpp11_variadic_templates. R11458</P>
+<P>Done: Added syntax support for BaseClass + ..., type + ... + id in
+parameters and baseclass + ... for intializers after constructor.
+Extended Swig syntax to support sizeof...(Args). R11467</P>
+<P>Done: Fixed %template to support variadic number of templates.</P>
+<P>TODO: Only (if present) first variadically defined argument is
+currently used in %template directive. The next ones are ignored.</P>
+<H2>New string literals [partially done]</H2>
+<P>Beside the implementation, the new C++11 Unicode and custom
+delimeter constants can occur in templates in the header file.
+</P>
+<P>Done: Added symbols 'u', 'u8' and 'U' to mark the beginning of the
+UTF string. Also added test case cpp11_raw_string_literals. R11327</P>
+<P>Done: Added R"DELIMITER[, ]DELIMITER" for a custom
+delimiter for the beginning/end of the string. R11328</P>
+<P>TODO: Fix the Swig's C++ preprocessor bug when parsing an odd
+number of “ inside the string brackets. See
+Source/Preprocessor/cpp.c.</P>
+<H2>User-defined literals [partially done]</H2>
+<P>C++ has different suffix literals. eg. 12.5f marks the number 12.5
+as float.
+</P>
+<P>C++11 allows user to define his own suffix for the strings always
+starting with the underscore (_). eg. int a = "hello"_mySuffix;
+</P>
+<P>The syntax is similar to other operator overloading functions:
+</P>
+<PRE STYLE="margin-bottom: 0.5cm"> OutputType operator "" _mySuffix(const char * string_values);</PRE><P>
+The null terminated const char* is the string between the "".
+The _mySuffix is the name of the suffix operator. And the OutputType
+is the outputType the operator returns.
+</P>
+<P>Other forms are:
+</P>
+<PRE> OutputType operator "" _mySuffix(const char * string_values, size_t num_chars);
+ OutputType operator "" _mySuffix(const wchar_t * string_values, size_t num_chars);
+ OutputType operator "" _mySuffix(const char16_t * string_values, size_t num_chars);
+ OutputType operator "" _mySuffix(const char32_t * string_values, size_t num_chars);
+ OutputType operator "" _mySuffix(int value); /* cooked version - ie. atoi() of string */</PRE><P>
+Another possibility is to use variadic templates:
+</P>
+<PRE> template<char...> OutputType operator "" _mySuffix();
+ OutputType someVariable = "1234"_mySuffix;</PRE><P>
+This instantiates the literal processing function as
+operator""_Suffix<'1', '2', '3', '4'>. In this form,
+there is no terminating null character to the string. The main
+purpose to doing this is to use C++11's constexpr keyword and the
+compiler to allow the literal to be transformed entirely at compile
+time, assuming OutputType is a constexpr-constructable and copyable
+type, and the literal processing function is a constexpr function.</P>
+<P>Article:
+<A HREF="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf</A></P>
+<P>Done: Added syntax support for userdefined literals. Added
+testcase cpp11_userdefined_literals.i. R11494</P>
+<P>TODO: %rename doesn't parse operator”” yet.</P>
+<H2>Thread-local storage [done]
+</H2>
+<P>New C++11 introduces keyword "thread_local" which marks
+the following variable dynamically located depending on the current
+thread when using the address-of (&) operator.
+</P>
+<P>Syntax:
+</P>
+<PRE> struct A {
+ thread_local int val;
+ };</PRE><P>
+Done: Add "thread_local" keyword to Swig. Added testcase
+cpp11_thread_local. R11393</P>
+<H2>Defaulting/deleting of standard functions on C++ objects [done]</H2>
+<P>C++ automatically creates default constructor with empty
+parameters, copy constructor, operator= and destructor for any class.
+Sometimes user wants to explicitly remove one of them or enable them
+(eg. default constructor with empty parameters doesn't work any more,
+if any other constructor is defined).
+</P>
+<P>Words "default" and "delete" are introduced.
+The syntax is similar to declaration of pure virtual function:
+</P>
+<PRE> struct NonCopyable {
+ NonCopyable & operator=(const NonCopyable&) = delete; /* Removes operator= */
+ NonCopyable(const NonCopyable&) = delete; /* Removed copy constructor */
+ NonCopyable() = default; /* Explicitly allows the empty constructor */
+ void *operator new(std::size_t) = delete; /* Removes new NonCopyable */
+ };</PRE><P>
+User has the ability by using keyword delete to disallow calling of
+the standard functions brought by C++ itself.
+</P>
+<PRE> struct A1 {
+ void f(int i);
+ void f(double i) = delete; /* Don't cast double to int. Compiler returns an error */
+ };
+ struct A2 {
+ void f(int i);
+ template<class T> void f(T) = delete; /* Only accept int */
+ };</PRE><P>
+Ignored: Swig already parses the keywords "= delete" and "=
+default". These keywords are used for built-in functions (copy
+constructor, operator= etc.), which are ignored by Swig anyway.</P>
+<P>Done: Added testcase cpp11_default_delete. R11535</P>
+<H2>Type long long int [done]</H2>
+<P>Type long long int is an integer type that has at least 64 useful
+bits. C99 added it to its standard, but the C++ didn't adopt it until
+C++11. Most C++ compilers supported it though.
+</P>
+<P>Done: Swig already parses the C code including the long long type.
+</P>
+<H2>Static assertions [done]</H2>
+<P>static_assert() can be used at class scope as well eg.:
+</P>
+<PRE> template <typename T>
+ struct Check {
+ static_assert(sizeof(int) <= sizeof(T), "not big enough");
+ };</PRE><P>
+Done: Added syntax support for "static_assert()". Added
+test case cpp11_static_assert. R11369</P>
+<H2>Allow sizeof to work on members of classes without an explicit
+object [done]</H2>
+<P>C++11 allows calls of sizeof to concrete objects as well:
+</P>
+<PRE> struct A { int member; };
+ sizeof(A::member); //Does not work with C++03. Okay with C++11</PRE><P>
+This kind of syntax is already supported by Swig.</P>
+<P>Done: Added testcase cpp11_sizeof_objects. R11538
+</P>
+<H2>Threading facilities [ignored]</H2>
+<P>C++11 will add the following classes to the standard library:
+</P>
+<PRE> * std::thread
+ * std::mutex, std::recursive_mutex
+ * std::condition_variable, std::condition_variable_any
+ * std::lock_guard, std::unique_lock
+ * std::packaged_task</PRE><P>
+Ignored: No changes to the language itself is made.
+</P>
+<H2>Tuple types [TODO]</H2>
+<P>Tuple is array of various types. C++11 introduced this feature
+using variadic templates. Tuple is defined as:</P>
+<PRE STYLE="margin-bottom: 0.5cm">template <class ...Types> class tuple;</PRE><P>
+Constructor is automatically generated filling the tuple elements.
+get<X> function is introduced to get the Xth element in the
+tuple.</P>
+<PRE>typedef tuple< int, double, long &, const char * > test_tuple ;
+long lengthy = 12 ;
+test_tuple proof( 18, 6.5, lengthy, "Ciao!" ) ;
+lengthy = get<0>(proof) ; // Assign to 'lengthy' the value 18.
+get<3>(proof) = " Beautiful!" ; // Modify the tuple’s fourth element.</PRE><P>
+Tuples can be copied to each other, if all the elements are copiable:</P>
+<PRE>typedef tuple< int , double, string > tuple_1 t1 ;
+typedef tuple< char, short , const char * > tuple_2 t2( 'X', 2, "Hola!" ) ;
+t1 = t2 ; // Ok, first two elements can be converted,
+ // the third one can be constructed from a 'const char *'.</PRE><P>
+TODO: Implement wrappers for the tuplet<> class.</P>
+<H2>Hash tables [TODO]</H2>
+<P>C++11 introduces the "unordered" version of existing
+types, which in practice work faster than the linear types:
+</P>
+<PRE> - unordered set
+ - unordered multiset
+ - unordered map
+ - unordered multimap</PRE><P>
+Swig should use the "unordered" types exactly the same as
+the original linear types.</P>
+<P>Problem: Unordered types do not contain exactly same members as
+ordered ones (eg. _Hashtable_iterator does not offer operator--() and
+constructor with compare function which is required). So simply
+aliasing unordered classes to ordered ones doesn't work.</P>
+<P>TODO: Implement wrappers for unordered_ types. Initial work is
+already done in Lib/std/unordered_*.i files.</P>
+<H2>Regular expressions [ignored]</H2>
+<P>Two new classes are introduced in C++11: basic_regex and
+match_results. Both are defined in regex header file.
+</P>
+<P>Ignored: The new feature extends the standardy library only. No
+changes to Swig needed.
+</P>
+<H2>General-purpose smart pointers [done]</H2>
+<P>This feature deprecates auto_ptr and adds shared_ptr, weak_ptr and
+unique_ptr to the standard library.
+</P>
+<P>This feature only adds the smart pointers to the standard library
+and doesn't effect the C++ syntax.</P>
+<P>Done: Added test case which uses all three smart pointers in the
+class. R11394</P>
+<P>Problem: GCC standard library doesn't contain the new smart
+pointers yet.
+</P>
+<H2>Extensible random number facility [ignored]</H2>
+<P>This feature standardize the pseudo random number algorithm
+(currently, the random number generator was dependent on the
+platform/compiler). It adds functions linear_congruential,
+subtract_with_carry and mersenne_twister and symbols
+uniform_int_distribution, bernoulli_distribution,
+geometric_distribution, poisson_distribution, binomial_distribution,
+uniform_real_distribution, exponential_distribution,
+normal_distribution and gamma_distribution to the standard library.
+</P>
+<P>Ignored: The new feature extends the standardy library only. No
+changes to Swig needed.
+</P>
+<H2>Wrapper reference [ignored]</H2>
+<P>This feature adds ref and cref classes to the standard library
+(#include <utility>) usually used in tempalte functions.
+</P>
+<P>Ignored: The new feature extends the standardy library only. No
+changes to Swig needed.
+</P>
+<H2>Polymorphous wrappers for function objects [done]</H2>
+<P>Two features are introduced:
+</P>
+<UL>
+ <LI><P>The function template wrapper:
+ </P>
+</UL>
+<PRE STYLE="margin-bottom: 0.5cm"> function<int ( int, int )> pF;</PRE>
+<UL>
+ <LI><P>and the function object:
+ </P>
+</UL>
+<PRE> struct Test {
+ bool operator()( short x, short y );
+ };</PRE><P>
+Swig already supports the two.</P>
+<P>Done: Added a runtime testcase for function objects
+cpp11_function_objects. R11419.</P>
+<H2>Type traits for metaprogramming [ignored]</H2>
+<P>C++11 adds a new header file <type_traits> which includes
+helper functions to determine the template type while initializing
+the object at compile time.
+</P>
+<P>Swig already supports the following code:
+</P>
+<PRE> template< int B, int N >
+ struct Pow {
+ // recursive call and recombination.
+ enum{ value = B*Pow< B, N-1 >::value };
+ };
+ template< int B > struct Pow< B, 0 > // <EM>N == 0</EM> condition of termination.
+ {
+ enum{ value = 1 };
+ };
+ int quartic_of_three = Pow< 3, 4 >::value ;</PRE><P>
+Functions is_convertible, is_integral, is_integral_const etc. are
+part of the new header:
+</P>
+<PRE>// First way of operating.
+template< bool B > struct algorithm {
+ template< class T1, class T2 > int do_it( T1 &, T2 & ) { /*...*/ }
+};
+// Second way of operating.
+template<> struct algorithm<true> {
+ template< class T1, class T2 > int do_it( T1, T2 ) { /*...*/ }
+};
+// Instantiating 'elaborate' will automatically instantiate the correct way to operate.
+template< class T1, class T2 > int elaborate( T1 A, T2 B ) {
+ // Use the second way only if 'T1' is an integer and if 'T2' is
+ // in floating point, otherwise use the first way.
+ return algorithm< is_integral<T1>::value && is_floating_point<T2>::value >::do_it( A, B );
+}</PRE><P>
+Swig correctly parses the syntax for template<bool>,
+template<class T> and template<>.
+</P>
+<P>Ignored: Swig requires explicitly defined template class
+(%template directive) to export it to the target language.</P>
+<H2>Uniform method for computing return type of function objects
+[partially done]</H2>
+<P>The template function is introduced: std::result_of() which
+depends on decltype:
+</P>
+<PRE>template< class Obj >
+class calculus_ver2 {
+ public:
+ template< class Arg >
+ typename std::result_of<Obj(Arg)>::type operator()( Arg& a ) const {
+ return member(a);
+ }
+ private:
+ Obj member;
+};</PRE><P>
+Swig correctly parses the result_of class.</P>
+<P>TODO: The return type (the result_of::type member) is not
+calculated by Swig. This needs a much more complex semantic parser.</P>
+<P>Done: Added testcase cpp11_result_of. R11534</P>
+</BODY>
+</HTML>
All objects are referenced counted and given a reference count of 1 when initially created. The
<tt>Delete()</tt> function only destroys an object when the reference count reaches zero. When
-an object is placed in a list or hash table, it's reference count is automatically increased. For example:
+an object is placed in a list or hash table, its reference count is automatically increased. For example:
<blockquote>
<pre>
<li><tt>char *Swig_clocal_deref(DataType *t, char *name)</tt><br>
This function is the inverse of the <tt>clocal()</tt> function. Given a type and a name,
it produces a string containing the code needed to cast/convert the type produced by
-<tt>Swig_clocal()</tt> back into it's original type.
+<tt>Swig_clocal()</tt> back into its original type.
<p>
<li><tt>char *Swig_clocal_assign(DataType *t, char *name)</tt><br>
<blockquote>
This function is similar to <tt>Swig_save()</tt> except that adds additional attribute checking. There are different interpretations
of the attribute names. A name of "attr" merely requests that the function check for the presence of an attribute. If the attribute is missing, SWIG will exit with a failed assertion. An attribute name of "?attr" specifies that the attribute "attr" is optional and
-that it's old value must be saved (if any). An attribute name of "*attr" specifies that the attribute is required and that
+that its old value must be saved (if any). An attribute name of "*attr" specifies that the attribute is required and that
its value must be saved. The saving of attributes is performed in the same manner as with <tt>Swig_save()</tt>. Here is an example:
<pre>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<!-- Hand-written HTML -->
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Allegro Common Lisp</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Allegrocl"></a>17 SWIG and Allegro Common Lisp</H1>
+<H1><a name="Allegrocl">18 SWIG and Allegro Common Lisp</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
to it.
</p>
-<H2><a name="Allegrocl_nn2"></a>17.1 Basics</H2>
+<H2><a name="Allegrocl_nn2">18.1 Basics</a></H2>
-<H3><a name="Allegrocl_nn3"></a>17.1.1 Running SWIG</H3>
+<H3><a name="Allegrocl_nn3">18.1.1 Running SWIG</a></H3>
<p>
the C++ wrapper will be what you then load into Allegro CL.
</p>
-<H3><a name="Allegrocl_nn4"></a>17.1.2 Command Line Options</H3>
+<H3><a name="Allegrocl_nn4">18.1.2 Command Line Options</a></H3>
<p>
-identifier-converter [name] - Binds the variable swig:*swig-identifier-convert*
in the generated .cl file to <tt>name</tt>.
- This function is used to generate symbols
- for the lisp side of the interface.
+ This function is used to generate symbols
+ for the lisp side of the interface.
-cwrap - [default] Generate a .cxx file containing C wrapper function when
wrapping C code. The interface generated is similar to what is
- done for C++ code.
+ done for C++ code.
-nocwrap - Explicitly turn off generation of .cxx wrappers for C code. Reasonable
for modules with simple interfaces. Can not handle all legal enum
- and constant constructs, or take advantage of SWIG customization features.
+ and constant constructs, or take advantage of SWIG customization features.
-isolate - With this command-line argument, all lisp helper functions are defined
in a unique package named <tt>swig.<module-name></tt> rather than
- <tt>swig</tt>. This prevents conflicts when the module is
- intended to be used with other swig generated interfaces that may,
- for instance, make use of different identifier converters.
+ <tt>swig</tt>. This prevents conflicts when the module is
+ intended to be used with other swig generated interfaces that may,
+ for instance, make use of different identifier converters.
</pre>
</div>
functions</a> for more details.
</p>
-<H3><a name="Allegrocl_nn5"></a>17.1.3 Inserting user code into generated files</H3>
+<H3><a name="Allegrocl_nn5">18.1.3 Inserting user code into generated files</a></H3>
<p>
</p>
-<H2><a name="Allegrocl_nn6"></a>17.2 Wrapping Overview</H2>
+<H2><a name="Allegrocl_nn6">18.2 Wrapping Overview</a></H2>
<p>
interested in generating an interface to C++.
</p>
-<H3><a name="Allegrocl_nn7"></a>17.2.1 Function Wrapping</H3>
+<H3><a name="Allegrocl_nn7">18.2.1 Function Wrapping</a></H3>
<p>
| Foreign Code | What we're generating an interface to.
|______________|
|
- |
+ |
_______v______
| | (foreign side)
| Wrapper code | extern "C" wrappers calling C++
| FFI Layer | Low level lisp interface. ff:def-foreign-call,
|______________| ff:def-foreign-variable
|
- +----------------------------
+ +----------------------------
_______v______ _______v______
| | | | (lisp side)
| Defuns | | Defmethods | wrapper for overloaded
|______________| |______________| functions or those with
(lisp side) | defaulted arguments
- Wrapper for non-overloaded |
- functions and methods _______v______
- | | (lisp side)
- | Defuns | dispatch function
- |______________| to overloads based
- on arity
+ Wrapper for non-overloaded |
+ functions and methods _______v______
+ | | (lisp side)
+ | Defuns | dispatch function
+ |______________| to overloads based
+ on arity
</pre>
</div>
-<H3><a name="Allegrocl_nn8"></a>17.2.2 Foreign Wrappers</H3>
+<H3><a name="Allegrocl_nn8">18.2.2 Foreign Wrappers</a></H3>
<p>
typemap.
</p>
-<H3><a name="Allegrocl_nn9"></a>17.2.3 FFI Wrappers</H3>
+<H3><a name="Allegrocl_nn9">18.2.3 FFI Wrappers</a></H3>
<p>
ff:def-foreign-call's.
</p>
-<H3><a name="Allegrocl_nn10"></a>17.2.4 Non-overloaded Defuns</H3>
+<H3><a name="Allegrocl_nn10">18.2.4 Non-overloaded Defuns</a></H3>
<p>
this function can be manipulated via the <tt>lout</tt> typemap.
</p>
-<H3><a name="Allegrocl_nn11"></a>17.2.5 Overloaded Defuns</H3>
+<H3><a name="Allegrocl_nn11">18.2.5 Overloaded Defuns</a></H3>
<p>
can be manipulated via the <tt>lout</tt> typemap.
</p>
-<H3><a name="Allegrocl_nn12"></a>17.2.6 What about constant and variable access?</H3>
+<H3><a name="Allegrocl_nn12">18.2.6 What about constant and variable access?</a></H3>
<p>
into the foreign module.
</p>
-<H3><a name="Allegrocl_nn13"></a>17.2.7 Object Wrapping</H3>
+<H3><a name="Allegrocl_nn13">18.2.7 Object Wrapping</a></H3>
<p>
foreign function interface.
</p>
-<H2><a name="Allegrocl_nn14"></a>17.3 Wrapping Details</H2>
+<H2><a name="Allegrocl_nn14">18.3 Wrapping Details</a></H2>
<p>
translated into lisp.
</p>
-<H3><a name="Allegrocl_nn15"></a>17.3.1 Namespaces</H3>
+<H3><a name="Allegrocl_nn15">18.3.1 Namespaces</a></H3>
<p>
function such as <tt>(car '(1 2 3)</tt>.
</p>
-<H3><a name="Allegrocl_nn16"></a>17.3.2 Constants</H3>
+<H3><a name="Allegrocl_nn16">18.3.2 Constants</a></H3>
<p>
Constants, as declared by the preprocessor #define macro or SWIG
- <tt>%constant</tt> directive, are included in SWIGs parse tree
+ <tt>%constant</tt> directive, are included in SWIG's parse tree
when it can be determined that they are, or could be reduced to,
a literal value. Such values are translated into defconstant
forms in the generated lisp wrapper when the -nocwrap command-line
</pre>
</div>
<p>
- Users are cautioned to get to know their constants before use, or
- not use the <tt>-nocwrap</tt> command-line option.
+ Users are cautioned to get to know their constants before use, or
+ not use the <tt>-nocwrap</tt> command-line option.
</p>
-<H3><a name="Allegrocl_nn17"></a>17.3.3 Variables</H3>
+<H3><a name="Allegrocl_nn17">18.3.3 Variables</a></H3>
<p>
</pre>
</div>
-<H3><a name="Allegrocl_nn18"></a>17.3.4 Enumerations</H3>
+<H3><a name="Allegrocl_nn18">18.3.4 Enumerations</a></H3>
<p>
In C, an enumeration value is an integer value, while in C++ an
enumeration value is implicitly convertible to an integer value,
- but can also be distinguished by it's enum type. For each enum
+ but can also be distinguished by its enum type. For each enum
declaration a def-foreign-type is generated, assigning the enum
a default type of :int. Users may adjust the foreign type of
enums via SWIG <tt>typemaps</tt>.
of it not being necessary to probe into foreign space to retrieve enum
values. When generating a .cxx wrapper file, a more general solution is
employed. A wrapper variable is created in the module_wrap.cxx file, and
- a ff:def-foreign-variable call is generated to retrieve it's value into lisp.
+ a ff:def-foreign-variable call is generated to retrieve its value into lisp.
</p>
<p>For example, the following header file
<div class="code">enum.h:
<pre>
-enum COL { RED, GREEN, BLUE };
+enum COL { RED, GREEN, BLUE };
enum FOO { FOO1 = 10, FOO2, FOO3 };
</pre>
</div>
</pre>
</div>
-<H3><a name="Allegrocl_nn19"></a>17.3.5 Arrays</H3>
+<H3><a name="Allegrocl_nn19">18.3.5 Arrays</a></H3>
<p>
</pre>
</div>
-<H3><a name="Allegrocl_nn20"></a>17.3.6 Classes and Structs and Unions (oh my!)</H3>
+<H3><a name="Allegrocl_nn20">18.3.6 Classes and Structs and Unions (oh my!)</a></H3>
-<H4><a name="Allegrocl_nn21"></a>17.3.6.1 CLOS wrapping of</H4>
+<H4><a name="Allegrocl_nn21">18.3.6.1 CLOS wrapping of</a></H4>
<p>
integer values.
</p>
-<H4><a name="Allegrocl_nn22"></a>17.3.6.2 CLOS Inheritance</H4>
+<H4><a name="Allegrocl_nn22">18.3.6.2 CLOS Inheritance</a></H4>
<p>
inheritance of the classes in foreign code, with the
ff:foreign-pointer class at its root. ff:foreign-pointer is a thin
wrapper for pointers that is made available by the foreign function
- interface. It's key benefit is that it may be passed as an argument
+ interface. Its key benefit is that it may be passed as an argument
to any ff:def-foreign-call that is expecting a pointer as the
parameter.
</p>
-<H4><a name="Allegrocl_nn23"></a>17.3.6.3 Member fields and functions</H4>
+<H4><a name="Allegrocl_nn23">18.3.6.3 Member fields and functions</a></H4>
<p>
the interface does nothing for <tt>friend</tt> directives,
</p>
-<H4><a name="Allegrocl_nn24"></a>17.3.6.4 Why not directly access C++ classes using foreign types?</H4>
+<H4><a name="Allegrocl_nn24">18.3.6.4 Why not directly access C++ classes using foreign types?</a></H4>
<p>
use the more robust wrapper functions.
</p>
-<H3><a name="Allegrocl_nn25"></a>17.3.7 Templates</H3>
+<H3><a name="Allegrocl_nn25">18.3.7 Templates</a></H3>
-<H4><a name="Allegrocl_nn26"></a>17.3.7.1 Generating wrapper code for templates</H4>
+<H4><a name="Allegrocl_nn26">18.3.7.1 Generating wrapper code for templates</a></H4>
- SWIG provides support for dealing with templates, but by
- default, it will not generate any member variable or function
- wrappers for templated classes. In order to create these
- wrappers, you need to explicitly tell SWIG to instantiate
- them. This is done via the
-
<a href="SWIGPlus.html#SWIGPlus_nn30"><tt>%template</tt></a>
- directive.
- </p>
+<p>
+SWIG provides support for dealing with templates, but by
+default, it will not generate any member variable or function
+wrappers for templated classes. In order to create these
+wrappers, you need to explicitly tell SWIG to instantiate
+them. This is done via the
+<a href="SWIGPlus.html#SWIGPlus_nn30"><tt>%template</tt></a>
+directive.
+</p>
-<H4><a name="Allegrocl_nn27"></a>17.3.7.2 Implicit Template instantiation</H4>
+<H4><a name="Allegrocl_nn27">18.3.7.2 Implicit Template instantiation</a></H4>
- While no wrapper code is generated for accessing member
- variables, or calling member functions, type code is generated
- to include these templated classes in the foreign-type and CLOS
- class schema.
- </p>
+<p>
+While no wrapper code is generated for accessing member
+variables, or calling member functions, type code is generated
+to include these templated classes in the foreign-type and CLOS
+class schema.
+</p>
-<H3><a name="Allegrocl_nn28"></a>17.3.8 Typedef, Templates, and Synonym Types</H3>
+<H3><a name="Allegrocl_nn28">18.3.8 Typedef, Templates, and Synonym Types</a></H3>
<p>
definition, we generate a form that expands to:
</p>
<div class="targetlang">
- <tt>(setf (find-class <synonym>) <primary>)</tt>
+ <tt>(setf (find-class <synonym>) <primary>)</tt>
</div>
<p>
The result is that all references to synonym types in foreign
</pre>
</div>
-<H4><a name="Allegrocl_nn29"></a>17.3.8.1 Choosing a primary type</H4>
+<H4><a name="Allegrocl_nn29">18.3.8.1 Choosing a primary type</a></H4>
<p>
criteria from a set of synonym types.
</p>
<ul>
- <li>
- If a synonym type has a class definition, it is the primary type.
- </li>
- <li>
- If a synonym type is a class template and has been explicitly
- instantiated via <tt>%template</tt>, it is the primary type.
- </li>
- <li>
- For all other sets of synonymous types, the synonym which is
- parsed first becomes the primary type.
- </li>
+ <li>
+ If a synonym type has a class definition, it is the primary type.
+ </li>
+ <li>
+ If a synonym type is a class template and has been explicitly
+ instantiated via <tt>%template</tt>, it is the primary type.
+ </li>
+ <li>
+ For all other sets of synonymous types, the synonym which is
+ parsed first becomes the primary type.
+ </li>
</ul>
-<H3><a name="Allegrocl_nn30"></a>17.3.9 Function overloading/Parameter defaulting</H3>
+<H3><a name="Allegrocl_nn30">18.3.9 Function overloading/Parameter defaulting</a></H3>
<p>
</pre>
</div>
-<H3><a name="Allegrocl_nn31"></a>17.3.10 Operator wrapping and Operator overloading</H3>
+<H3><a name="Allegrocl_nn31">18.3.10 Operator wrapping and Operator overloading</a></H3>
<p>
<pre>
/* name conversion for overloaded operators. */
#ifdef __cplusplus
-%rename(__add__) *::operator+;
-%rename(__pos__) *::operator+();
-%rename(__pos__) *::operator+() const;
+%rename(__add__) *::operator+;
+%rename(__pos__) *::operator+();
+%rename(__pos__) *::operator+() const;
-%rename(__sub__) *::operator-;
-%rename(__neg__) *::operator-() const;
-%rename(__neg__) *::operator-();
+%rename(__sub__) *::operator-;
+%rename(__neg__) *::operator-() const;
+%rename(__neg__) *::operator-();
-%rename(__mul__) *::operator*;
-%rename(__deref__) *::operator*();
-%rename(__deref__) *::operator*() const;
+%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(__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(__not__) *::operator!();
+%rename(__not__) *::operator!() const;
-%rename(__assign__) *::operator=;
+%rename(__assign__) *::operator=;
%rename(__add_assign__) *::operator+=;
-%rename(__sub_assign__) *::operator-=;
-%rename(__mul_assign__) *::operator*=;
-%rename(__div_assign__) *::operator/=;
-%rename(__mod_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__) *::operator<<;
%rename(__lshift_assign__) *::operator<<=;
-%rename(__rshift__) *::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(__eq__) *::operator==;
+%rename(__ne__) *::operator!=;
+%rename(__lt__) *::operator<;
+%rename(__gt__) *::operator>;
+%rename(__lte__) *::operator<=;
+%rename(__gte__) *::operator>=;
-%rename(__and__) *::operator&&;
-%rename(__or__) *::operator||;
+%rename(__and__) *::operator&&;
+%rename(__or__) *::operator||;
-%rename(__preincr__) *::operator++();
-%rename(__postincr__) *::operator++(int);
-%rename(__predecr__) *::operator--();
-%rename(__postdecr__) *::operator--(int);
+%rename(__preincr__) *::operator++();
+%rename(__postincr__) *::operator++(int);
+%rename(__predecr__) *::operator--();
+%rename(__postdecr__) *::operator--(int);
-%rename(__comma__) *::operator,();
-%rename(__comma__) *::operator,() const;
+%rename(__comma__) *::operator,();
+%rename(__comma__) *::operator,() const;
%rename(__member_ref__) *::operator->;
%rename(__member_func_ref__) *::operator->*;
-%rename(__funcall__) *::operator();
-%rename(__aref__) *::operator[];
+%rename(__funcall__) *::operator();
+%rename(__aref__) *::operator[];
</pre>
</div>
</pre>
</div>
-<H3><a name="Allegrocl_nn32"></a>17.3.11 Varargs</H3>
+<H3><a name="Allegrocl_nn32">18.3.11 Varargs</a></H3>
<p>
directive. This directive allows you to specify a (finite)
argument list which will be inserted into the wrapper in place
of the variable length argument indicator. As an example,
- consider the function <tt>printf()</tt>. It's declaration would
+ consider the function <tt>printf()</tt>. Its declaration would
appear as follows:
</p>
with other ways such functions can be wrapped.
</p>
-<H3><a name="Allegrocl_nn33"></a>17.3.12 C++ Exceptions</H3>
+<H3><a name="Allegrocl_nn33">18.3.12 C++ Exceptions</a></H3>
<p>
implemented.
</p>
-<H3><a name="Allegrocl_nn34"></a>17.3.13 Pass by value, pass by reference</H3>
+<H3><a name="Allegrocl_nn34">18.3.13 Pass by value, pass by reference</a></H3>
<p>
newly defined types.
</p>
-<H2><a name="Allegrocl_nn35"></a>17.4 Typemaps</H2>
+<H2><a name="Allegrocl_nn35">18.4 Typemaps</a></H2>
<p>
on <a href="Typemaps.html#Typemaps">Typemaps</a> for more information.
</p>
-<H3><a name="Allegrocl_nn36"></a>17.4.1 Code Generation in the C++ Wrapper</H3>
+<H3><a name="Allegrocl_nn36">18.4.1 Code Generation in the C++ Wrapper</a></H3>
</pre>
</div>
-<H4><a name="Allegrocl_nn37"></a>17.4.1.1 IN Typemap</H4>
+<H4><a name="Allegrocl_nn37">18.4.1.1 IN Typemap</a></H4>
<p>
</pre>
</div>
-<H4><a name="Allegrocl_nn38"></a>17.4.1.2 OUT Typemap</H4>
+<H4><a name="Allegrocl_nn38">18.4.1.2 OUT Typemap</a></H4>
<p>
The <tt>out</tt> typemap is used to generate code to form the
return value of the wrapper from the return value of the wrapped
function. This code is placed in the <convert and bind result to lresult>
- section of the above code diagram. It's default mapping is as follows:
+ section of the above code diagram. Its default mapping is as follows:
</p>
<div class="code">
</pre>
</div>
-<H4><a name="Allegrocl_nn39"></a>17.4.1.3 CTYPE Typemap</H4>
+<H4><a name="Allegrocl_nn39">18.4.1.3 CTYPE Typemap</a></H4>
<p>
This typemap is not used for code generation, but purely for the
transformation of types in the parameter list of the wrapper function.
- It's primary use is to handle by-value to by-reference conversion in the
+ Its primary use is to handle by-value to by-reference conversion in the
wrappers parameter list. Its default settings are:
</p>
these <a href="Typemaps.html#Typemaps_nn25">common typemaps</a> here.
</p>
-<H3><a name="Allegrocl_nn40"></a>17.4.2 Code generation in Lisp wrappers</H3>
+<H3><a name="Allegrocl_nn40">18.4.2 Code generation in Lisp wrappers</a></H3>
<p>
<a href="#Allegrocl_nn15">16.3.1 Namespaces</a> for details.
</p>
-<H4><a name="Allegrocl_nn41"></a>17.4.2.1 LIN Typemap</H4>
+<H4><a name="Allegrocl_nn41">18.4.2.1 LIN Typemap</a></H4>
<p>
<p>The LIN typemap accepts the following <tt>$variable</tt> references.
</p>
<ul>
- <li><tt>$in</tt> - expands to the name of the parameter being
- applied to this typemap
- </li>
- <li><tt>$out</tt> - expands to the name of the local variable
- assigned to this typemap
- </li>
- <li><tt>$in_fftype</tt> - the foreign function type of the C type.</li>
- <li><tt>$*in_fftype</tt> - the foreign function type of the C type
- with one pointer removed. If there is no pointer, then $*in_fftype
- is the same as $in_fftype.
- </li>
- <li><tt>$body</tt> - very important. Instructs SWIG where
- subsequent code generation steps should be inserted into the
- current typemap. Leaving out a <tt>$body</tt> reference
- will result in lisp wrappers that do very little by way of
- calling into foreign code. Not recommended.
- </li>
+ <li><tt>$in</tt> - expands to the name of the parameter being
+ applied to this typemap
+ </li>
+ <li><tt>$out</tt> - expands to the name of the local variable
+ assigned to this typemap
+ </li>
+ <li><tt>$in_fftype</tt> - the foreign function type of the C type.</li>
+ <li><tt>$*in_fftype</tt> - the foreign function type of the C type
+ with one pointer removed. If there is no pointer, then $*in_fftype
+ is the same as $in_fftype.
+ </li>
+ <li><tt>$body</tt> - very important. Instructs SWIG where
+ subsequent code generation steps should be inserted into the
+ current typemap. Leaving out a <tt>$body</tt> reference
+ will result in lisp wrappers that do very little by way of
+ calling into foreign code. Not recommended.
+ </li>
</ul>
<div class="code">
<pre>
-%typemap(lin) SWIGTYPE "(cl:let (($out $in))\n $body)";
+%typemap(lin) SWIGTYPE "(cl:let (($out $in))\n $body)";
</pre>
</div>
-<H4><a name="Allegrocl_nn42"></a>17.4.2.2 LOUT Typemap</H4>
+<H4><a name="Allegrocl_nn42">18.4.2.2 LOUT Typemap</a></H4>
<p>
<p>The LOUT typemap uses the following $variable
</p>
<ul>
- <li><tt>$lclass</tt> - Expands to the CLOS class that
- represents foreign-objects of the return type matching this
- typemap.
- </li>
- <li><tt>$body</tt> - Same as for the LIN map. Place this
- variable where you want the foreign-function call to occur.
- </li>
- <li><tt>$ldestructor</tt> - Expands to the symbol naming the destructor for this
- class ($lclass) of object. Allows you to insert finalization or automatic garbage
- collection into the wrapper code (see default mappings below).
- </li>
+ <li><tt>$lclass</tt> - Expands to the CLOS class that
+ represents foreign-objects of the return type matching this
+ typemap.
+ </li>
+ <li><tt>$body</tt> - Same as for the LIN map. Place this
+ variable where you want the foreign-function call to occur.
+ </li>
+ <li><tt>$ldestructor</tt> - Expands to the symbol naming the destructor for this
+ class ($lclass) of object. Allows you to insert finalization or automatic garbage
+ collection into the wrapper code (see default mappings below).
+ </li>
</ul>
<div class="code">
</pre>
</div>
-<H4><a name="Allegrocl_nn43"></a>17.4.2.3 FFITYPE Typemap</H4>
+<H4><a name="Allegrocl_nn43">18.4.2.3 FFITYPE Typemap</a></H4>
</pre>
</div>
-<H4><a name="Allegrocl_nn44"></a>17.4.2.4 LISPTYPE Typemap</H4>
+<H4><a name="Allegrocl_nn44">18.4.2.4 LISPTYPE Typemap</a></H4>
<p>
</pre>
</div>
-<H4><a name="Allegrocl_nn45"></a>17.4.2.5 LISPCLASS Typemap</H4>
+<H4><a name="Allegrocl_nn45">18.4.2.5 LISPCLASS Typemap</a></H4>
<p>
</pre>
</div>
-<H3><a name="Allegrocl_nn46"></a>17.4.3 Modifying SWIG behavior using typemaps</H3>
+<H3><a name="Allegrocl_nn46">18.4.3 Modifying SWIG behavior using typemaps</a></H3>
<p>
</pre>
</div>
-<H2><a name="Allegrocl_nn47"></a>17.5 Identifier Converter functions</H2>
+<H2><a name="Allegrocl_nn47">18.5 Identifier Converter functions</a></H2>
-<H3><a name="Allegrocl_nn48"></a>17.5.1 Creating symbols in the lisp environment</H3>
+<H3><a name="Allegrocl_nn48">18.5.1 Creating symbols in the lisp environment</a></H3>
<p>
of arguments.
</p>
-<H3><a name="Allegrocl_nn49"></a>17.5.2 Existing identifier-converter functions</H3>
+<H3><a name="Allegrocl_nn49">18.5.2 Existing identifier-converter functions</a></H3>
<p>Two basic identifier routines have been defined.
-<H4><a name="Allegrocl_nn50"></a>17.5.2.1 identifier-convert-null</H4>
+<H4><a name="Allegrocl_nn50">18.5.2.1 identifier-convert-null</a></H4>
<p>
strings, from which a symbol will be created.
</p>
-<H4><a name="Allegrocl_nn51"></a>17.5.2.2 identifier-convert-lispify</H4>
+<H4><a name="Allegrocl_nn51">18.5.2.2 identifier-convert-lispify</a></H4>
<p>
same symbol transformations.
</p>
-<H4><a name="Allegrocl_nn52"></a>17.5.2.3 Default identifier to symbol conversions</H4>
+<H4><a name="Allegrocl_nn52">18.5.2.3 Default identifier to symbol conversions</a></H4>
<p>
default naming conventions.
</p>
-<H3><a name="Allegrocl_nn53"></a>17.5.3 Defining your own identifier-converter</H3>
+<H3><a name="Allegrocl_nn53">18.5.3 Defining your own identifier-converter</a></H3>
<p>
<p>
The :type keyword argument provides more information on the type of
-identifier. It's value is a symbol. This allows the
+identifier. Its value is a symbol. This allows the
identifier-converter to apply different heuristics when mapping
different types of identifiers to symbols. SWIG will generate calls
to your identifier-converter using the following types.
<p>
The :arity keyword argument only appears in swig:swig-defmethod forms
-generated for overloaded functions. It's value is an integer
+generated for overloaded functions. Its value is an integer
indicating the number of arguments passed to the routine indicated by
this identifier.
</p>
-<H3><a name="Allegrocl_nn54"></a>17.5.4 Instructing SWIG to use a particular identifier-converter</H3>
+<H3><a name="Allegrocl_nn54">18.5.4 Instructing SWIG to use a particular identifier-converter</a></H3>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Android</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#FFFFFF">
-<H1><a name="Android"></a>18 SWIG and Android</H1>
+<H1><a name="Android">19 SWIG and Android</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
-<H2><a name="Android_overview"></a>18.1 Overview</H2>
+<H2><a name="Android_overview">19.1 Overview</a></H2>
<p>
The Android chapter is fairly short as support for Android is the same as for Java, where the Java Native Interface (JNI) is
used to call from Android Java into C or C++ compiled code.
-Everything in the <a href="Java.html">Java chapter</a> applies to generating code for access from Android Java code.
+Everything in the <a href="Java.html#Java">Java chapter</a> applies to generating code for access from Android Java code.
This chapter contains a few Android specific notes and examples.
</p>
-<H2><a name="Android_examples"></a>18.2 Android examples</H2>
+<H2><a name="Android_examples">19.2 Android examples</a></H2>
-<H3><a name="Android_examples_intro"></a>18.2.1 Examples introduction</H3>
+<H3><a name="Android_examples_intro">19.2.1 Examples introduction</a></H3>
<p>
-The examples require the <a href="http://developer.android.com/sdk/index.html">Android SDK</a> and <a href="http://developer.android.com/sdk/ndk/index.html">Android NDK</a> which can be installed as per instructions in the links.
+The examples require the <a href="http://developer.android.com/sdk/index.html">Android SDK</a> and <a href="http://developer.android.com/tools/sdk/ndk/index.html">Android NDK</a> which can be installed as per instructions in the links.
The Eclipse version is not required for these examples as just the command line tools are used (shown for Linux as the host, but Windows will be very similar, if not identical in most places).
Add the SDK tools and NDK tools to your path and create a directory somewhere for your Android projects (adjust PATH as necessary to where you installed the tools):
</p>
<pre>
$ export PATH=$HOME/android/android-sdk-linux_x86/tools:$HOME/android/android-sdk-linux_x86/platform-tools:$HOME/android/android-ndk-r6b:$PATH
$ mkdir AndroidApps
-$ cd AnrdoidApps
+$ cd AndroidApps
</pre>
</div>
The following examples are shipped with SWIG under the Examples/android directory and include a Makefile to build and install each example.
</p>
-<H3><a name="Android_example_simple"></a>18.2.2 Simple C example</H3>
+<H3><a name="Android_example_simple">19.2.2 Simple C example</a></H3>
<p>
<pre>
$ adb devices
List of devices attached
-A32-6DBE0001-9FF80000-015D62C3-02018028 device
+A32-6DBE0001-9FF80000-015D62C3-02018028 device
</pre>
</div>
<pre>
$ adb install bin/SwigSimple-debug.apk
95 KB/s (4834 bytes in 0.049s)
- pkg: /data/local/tmp/SwigSimple-debug.apk
+ pkg: /data/local/tmp/SwigSimple-debug.apk
Success
</pre>
</div>
<center><img src="android-simple.png" alt="Android screenshot of SwigSimple example"></center>
-<H3><a name="Android_example_class"></a>18.2.3 C++ class example</H3>
+<H3><a name="Android_example_class">19.2.3 C++ class example</a></H3>
<p>
}
virtual ~Shape() {
nshapes--;
- };
+ }
double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
</pre>
</div>
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
</pre>
<center><img src="android-class.png" alt="Android screenshot of SwigClass example"></center>
-<H3><a name="Android_examples_other"></a>18.2.4 Other examples</H3>
+<H3><a name="Android_examples_other">19.2.4 Other examples</a></H3>
<p>
Normally C++ exception handling and the STL is not available by default in the version of g++ shipped with Android, but this example turns these features on as described in the next section.
</p>
-<H2><a name="Android_stl"></a>18.3 C++ STL</H2>
+<H2><a name="Android_stl">19.3 C++ STL</a></H2>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Argument Handling</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Arguments"></a>9 Argument Handling</H1>
+<H1><a name="Arguments">10 Argument Handling</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
describes some of the techniques for doing this.
</p>
-<H2><a name="Arguments_nn2"></a>9.1 The typemaps.i library</H2>
+<H2><a name="Arguments_nn2">10.1 The typemaps.i library</a></H2>
<p>
change certain properties of argument conversion.
</p>
-<H3><a name="Arguments_nn3"></a>9.1.1 Introduction</H3>
+<H3><a name="Arguments_nn3">10.1.1 Introduction</a></H3>
<p>
<div class="code"><pre>
void add(double a, double b, double *result) {
- *result = a + b;
+ *result = a + b;
}
</pre></div>
</pre>
</div>
-<H3><a name="Arguments_nn4"></a>9.1.2 Input parameters</H3>
+<H3><a name="Arguments_nn4">10.1.2 Input parameters</a></H3>
<p>
</p>
<div class="code"><pre>
-int *INPUT
+int *INPUT
short *INPUT
long *INPUT
unsigned int *INPUT
<div class="code"><pre>
double add(double *a, double *b) {
- return *a+*b;
+ return *a+*b;
}
</pre></div>
result = add(3,4)
</pre></div>
-<H3><a name="Arguments_nn5"></a>9.1.3 Output parameters</H3>
+<H3><a name="Arguments_nn5">10.1.3 Output parameters</a></H3>
<p>
<div class="code"><pre>
void add(double a, double b, double *c) {
- *c = a+b;
+ *c = a+b;
}
</pre></div>
</pre>
</div>
-<H3><a name="Arguments_nn6"></a>9.1.4 Input/Output parameters</H3>
+<H3><a name="Arguments_nn6">10.1.4 Input/Output parameters</a></H3>
<p>
<div class="code"><pre>
void negate(double *x) {
- *x = -(*x);
+ *x = -(*x);
}
</pre></div>
SWIG. Backwards compatibility is preserved, but deprecated.
</p>
-<H3><a name="Arguments_nn7"></a>9.1.5 Using different names</H3>
+<H3><a name="Arguments_nn7">10.1.5 Using different names</a></H3>
<p>
file or a matching <tt>%clear</tt> declaration.
</p>
-<H2><a name="Arguments_nn8"></a>9.2 Applying constraints to input values</H2>
+<H2><a name="Arguments_nn8">10.2 Applying constraints to input values</a></H2>
<p>
can be accomplished including the <tt>constraints.i</tt> library file.
</p>
-<H3><a name="Arguments_nn9"></a>9.2.1 Simple constraint example</H3>
+<H3><a name="Arguments_nn9">10.2.1 Simple constraint example</a></H3>
<p>
exception will be raised. As a result, it is possible to catch bad
values, prevent mysterious program crashes and so on.</p>
-<H3><a name="Arguments_nn10"></a>9.2.2 Constraint methods</H3>
+<H3><a name="Arguments_nn10">10.2.2 Constraint methods</a></H3>
<p>
</pre></div>
-<H3><a name="Arguments_nn11"></a>9.2.3 Applying constraints to new datatypes</H3>
+<H3><a name="Arguments_nn11">10.2.3 Applying constraints to new datatypes</a></H3>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>ccache-swig(1) manpage</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="CCache"></a>16 Using SWIG with ccache - ccache-swig(1) manpage</H1>
+<H1><a name="CCache">17 Using SWIG with ccache - ccache-swig(1) manpage</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<p>
-<H2><a name="CCache_nn2"></a>16.1 NAME</H2>
+<H2><a name="CCache_nn2">17.1 NAME</a></H2>
<p>
ccache-swig - a fast compiler cache
<p>
-<H2><a name="CCache_nn3"></a>16.2 SYNOPSIS</H2>
+<H2><a name="CCache_nn3">17.2 SYNOPSIS</a></H2>
<p>
<p>
<compiler> [COMPILER OPTIONS]
<p>
-<H2><a name="CCache_nn4"></a>16.3 DESCRIPTION</H2>
+<H2><a name="CCache_nn4">17.3 DESCRIPTION</a></H2>
<p>
-ccache-swig is a compiler cache. It speeds up re-compilation of C/C++/SWIG code
+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.
<p>
-<H2><a name="CCache_nn5"></a>16.4 OPTIONS SUMMARY</H2>
+<H2><a name="CCache_nn5">17.4 OPTIONS SUMMARY</a></H2>
<p>
</pre>
<p>
-<H2><a name="CCache_nn6"></a>16.5 OPTIONS</H2>
+<H2><a name="CCache_nn6">17.5 OPTIONS</a></H2>
<p>
cache. Using "ccache-swig -s" adds up the statistics across all
subdirectories and prints the totals.
<p>
-<p><dt><strong><strong>-z</strong></strong><dd> Zero the cache statistics.
+<p><dt><strong><strong>-z</strong></strong><dd> Zero the cache statistics.
<p>
<p><dt><strong><strong>-V</strong></strong><dd> Print the ccache version number
<p>
<p>
</dl>
<p>
-<H2><a name="CCache_nn7"></a>16.6 INSTALLATION</H2>
+<H2><a name="CCache_nn7">17.6 INSTALLATION</a></H2>
<p>
wish to use ccache for all your compiles.
<p>
To install for usage by the first method just copy ccache-swig to somewhere
-in your path.
+in your path.
<p>
To install for the second method do something like this:
<pre>
Note! Do not use a hard link, use a symbolic link. A hardlink will
cause "interesting" problems.
<p>
-<H2><a name="CCache_nn8"></a>16.7 EXTRA OPTIONS</H2>
+<H2><a name="CCache_nn8">17.7 EXTRA OPTIONS</a></H2>
<p>
command line options as the compiler you are using. The only exception
to this is the option '--ccache-skip'. 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.
+should be passed along to the compiler as-is.
<p>
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
treated as an input file name and instead be passed along to the
compiler as a command line option.
<p>
-<H2><a name="CCache_nn9"></a>16.8 ENVIRONMENT VARIABLES</H2>
+<H2><a name="CCache_nn9">17.8 ENVIRONMENT VARIABLES</a></H2>
<p>
<p>
<p><dt><strong><strong>CCACHE_NLEVELS</strong></strong><dd> 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.
+default is 2. The minimum is 1 and the maximum is 8.
<p>
<p><dt><strong><strong>CCACHE_HARDLINK</strong></strong><dd> If you set the environment variable
CCACHE_HARDLINK then ccache will attempt to use hard links from the
the default. On HP-UX set this environment variable to "i" if you use
the aCC compiler.
<p>
-<p><dt><strong><strong>CCACHE_STRIPC</strong></strong><dd> If you set the environment variable
+<p><dt><strong><strong>CCACHE_STRIPC</strong></strong><dd> 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:
when -E and -c is used together.
<p>
<p><dt><strong><strong>CCACHE_SWIG</strong></strong><dd> When using SWIG as the compiler and it does not
-have 'swig' in the executable name, then the CCACHE_SWIG environment
-variable needs to be set in order for ccache to work correctly with
+have 'swig' 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
<p>
</dl>
<p>
-<H2><a name="CCache_nn10"></a>16.9 CACHE SIZE MANAGEMENT</H2>
+<H2><a name="CCache_nn10">17.9 CACHE SIZE MANAGEMENT</a></H2>
<p>
below the numbers you specified in order to avoid doing the cache
clean operation too often.
<p>
-<H2><a name="CCache_nn11"></a>16.10 CACHE COMPRESSION</H2>
+<H2><a name="CCache_nn11">17.10 CACHE COMPRESSION</a></H2>
<p>
-By default on most platforms ccache will compress all files it puts
+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.
<p>
-<H2><a name="CCache_nn12"></a>16.11 HOW IT WORKS</H2>
+<H2><a name="CCache_nn12">17.11 HOW IT WORKS</a></H2>
<p>
discover a case where ccache changes the output of your compiler then
please let me know.
<p>
-<H2><a name="CCache_nn13"></a>16.12 USING CCACHE WITH DISTCC</H2>
+<H2><a name="CCache_nn13">17.12 USING CCACHE WITH DISTCC</a></H2>
<p>
To use distcc with ccache I recommend using the CCACHE_PREFIX
option. You just need to set the environment variable CCACHE_PREFIX to
'distcc' and ccache will prefix the command line used with the
-compiler with the command 'distcc'.
+compiler with the command 'distcc'.
<p>
-<H2><a name="CCache_nn14"></a>16.13 SHARING A CACHE</H2>
+<H2><a name="CCache_nn14">17.13 SHARING A CACHE</a></H2>
<p>
to 002, this ensures that cached files are accessible to everyone in
the group.
<li> Make sure that all users have write permission in the entire
- cache directory (and that you trust all users of the shared cache).
+ cache directory (and that you trust all users of the shared cache).
<li> 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 "chmod g+s `find $CCACHE_DIR -type d`" might
versions of ccache that do not support compression.
</ul>
<p>
-<H2><a name="CCache_nn15"></a>16.14 HISTORY</H2>
+<H2><a name="CCache_nn15">17.14 HISTORY</a></H2>
<p>
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
+work. See
<a href="http://www.erikyyy.de/compilercache/">http://www.erikyyy.de/compilercache/</a>
for the Erik's scripts.
ccache-swig is a port of the original ccache with support added for use
compiler cache and I wanted to remove some of the limitations of the
shell-script version.
<p>
-<H2><a name="CCache_nn16"></a>16.15 DIFFERENCES FROM COMPILERCACHE</H2>
+<H2><a name="CCache_nn16">17.15 DIFFERENCES FROM COMPILERCACHE</a></H2>
<p>
<li> ccache avoids a double call to cpp on a cache miss
</ul>
<p>
-<H2><a name="CCache_nn17"></a>16.16 CREDITS</H2>
+<H2><a name="CCache_nn17">17.16 CREDITS</a></H2>
<p>
<li> Paul Russell for many suggestions and the debian packaging
</ul>
<p>
-<H2><a name="CCache_nn18"></a>16.17 AUTHOR</H2>
+<H2><a name="CCache_nn18">17.17 AUTHOR</a></H2>
<p>
</body>
</html>
-
-
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<title>SWIG and C++11</title>
+<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
+</head>
+
+<body bgcolor="#ffffff">
+<H1><a name="CPlusPlus11">7 SWIG and C++11</a></H1>
+<!-- INDEX -->
+<div class="sectiontoc">
+<ul>
+<li><a href="#CPlusPlus11_introduction">Introduction</a>
+<li><a href="#CPlusPlus11_core_language_changes">Core language changes</a>
+<ul>
+<li><a href="#CPlusPlus11_rvalue_reference_and_move_semantics">Rvalue reference and move semantics</a>
+<li><a href="#CPlusPlus11_generalized_constant_expressions">Generalized constant expressions</a>
+<li><a href="#CPlusPlus11_extern_template">Extern template</a>
+<li><a href="#CPlusPlus11_initializer_lists">Initializer lists</a>
+<li><a href="#CPlusPlus11_uniform_initialization">Uniform initialization</a>
+<li><a href="#CPlusPlus11_type_inference">Type inference</a>
+<li><a href="#CPlusPlus11_range_based_for_loop">Range-based for-loop</a>
+<li><a href="#CPlusPlus11_lambda_functions_and_expressions">Lambda functions and expressions</a>
+<li><a href="#CPlusPlus11_alternate_function_syntax">Alternate function syntax</a>
+<li><a href="#CPlusPlus11_object_construction_improvement">Object construction improvement</a>
+<li><a href="#CPlusPlus11_explicit_overrides_final">Explicit overrides and final</a>
+<li><a href="#CPlusPlus11_null_pointer_constant">Null pointer constant</a>
+<li><a href="#CPlusPlus11_strongly_typed_enumerations">Strongly typed enumerations</a>
+<li><a href="#CPlusPlus11_double_angle_brackets">Double angle brackets</a>
+<li><a href="#CPlusPlus11_explicit_conversion_operators">Explicit conversion operators</a>
+<li><a href="#CPlusPlus11_alias_templates">Alias templates</a>
+<li><a href="#CPlusPlus11_unrestricted_unions">Unrestricted unions</a>
+<li><a href="#CPlusPlus11_variadic_templates">Variadic templates</a>
+<li><a href="#CPlusPlus11_new_string_literals">New string literals</a>
+<li><a href="#CPlusPlus11_user_defined_literals">User-defined literals</a>
+<li><a href="#CPlusPlus11_thread_local_storage">Thread-local storage</a>
+<li><a href="#CPlusPlus11_defaulted_deleted">Explicitly defaulted functions and deleted functions</a>
+<li><a href="#CPlusPlus11_type_long_long_int">Type long long int</a>
+<li><a href="#CPlusPlus11_static_assertions">Static assertions</a>
+<li><a href="#CPlusPlus11_sizeof">Allow sizeof to work on members of classes without an explicit object</a>
+<li><a href="#CPlusPlus11_noexcept">Exception specifications and noexcept</a>
+<li><a href="#CPlusPlus11_alignment">Control and query object alignment</a>
+<li><a href="#CPlusPlus11_attributes">Attributes</a>
+</ul>
+<li><a href="#CPlusPlus11_standard_library_changes">Standard library changes</a>
+<ul>
+<li><a href="#CPlusPlus11_threading_facilities">Threading facilities</a>
+<li><a href="#CPlusPlus11_tuple_types">Tuple types</a>
+<li><a href="#CPlusPlus11_hash_tables">Hash tables</a>
+<li><a href="#CPlusPlus11_regular_expressions">Regular expressions</a>
+<li><a href="#CPlusPlus11_general_purpose_smart_pointers">General-purpose smart pointers</a>
+<li><a href="#CPlusPlus11_extensible_random_number_facility">Extensible random number facility</a>
+<li><a href="#CPlusPlus11_wrapper_reference">Wrapper reference</a>
+<li><a href="#CPlusPlus11_polymorphous_wrappers_for_function_objects">Polymorphous wrappers for function objects</a>
+<li><a href="#CPlusPlus11_type_traits_for_metaprogramming">Type traits for metaprogramming</a>
+<li><a href="#CPlusPlus11_uniform_method_for_computing_return_type_of_function_objects">Uniform method for computing return type of function objects</a>
+</ul>
+</ul>
+</div>
+<!-- INDEX -->
+
+
+
+<H2><a name="CPlusPlus11_introduction">7.1 Introduction</a></H2>
+
+
+<p>This chapter gives you a brief overview about the SWIG
+implementation of the C++11 standard. This part of SWIG is still a work in
+progress.
+</p>
+<p>SWIG supports the new C++ syntax changes with some minor limitations
+in some areas such as decltype expressions and variadic templates. Wrappers for the
+new STL types (unordered_ containers, result_of, tuples) are incomplete.
+The wrappers for the new containers would work much like the C++03 containers and
+users are welcome to help by adapting the existing container interface files and submitting them
+as a patch for inclusion in future versions of SWIG.
+</p>
+
+<H2><a name="CPlusPlus11_core_language_changes">7.2 Core language changes</a></H2>
+
+
+<H3><a name="CPlusPlus11_rvalue_reference_and_move_semantics">7.2.1 Rvalue reference and move semantics</a></H3>
+
+
+<p>
+SWIG correctly parses the rvalue reference syntax '&&',
+for example the typical usage of it in the move constructor and move assignment operator below:
+</p>
+
+<div class="code"><pre>
+class MyClass {
+...
+ std::vector<int> numbers;
+public:
+ MyClass(MyClass &&other) : numbers(std::move(other.numbers)) {}
+ MyClass & operator=(MyClass &&other) {
+ numbers = std::move(other.numbers);
+ return *this;
+ }
+};
+</pre></div>
+
+<p>
+Rvalue references are designed for C++ temporaries and so are not very useful when used from non-C++ target languages.
+Generally you would just ignore them via <tt>%ignore</tt> before parsing the class.
+For example, ignore the move constructor:
+</p>
+
+<div class="code"><pre>
+%ignore MyClass::MyClass(MyClass &&);
+</pre></div>
+
+<p>
+The plan is to ignore move constructors by default in a future version of SWIG. Note that both normal assignment operators as well as move assignment operators are ignored by default in most target languages with the following warning:
+</p>
+
+<div class="shell">
+<pre>
+example.i:18: Warning 503: Can't wrap 'operator =' unless renamed to a valid identifier.
+</pre>
+</div>
+
+
+<H3><a name="CPlusPlus11_generalized_constant_expressions">7.2.2 Generalized constant expressions</a></H3>
+
+
+<p>SWIG parses and identifies the keyword <tt>constexpr</tt>, but cannot fully utilise it.
+These C++ compile time constants are usable as runtime constants from the target languages.
+Below shows example usage for assigning a C++ compile time constant from a compile time constant function:
+</p>
+
+<div class="code"><pre>
+constexpr int XXX() { return 10; }
+constexpr int YYY = XXX() + 100;
+</pre></div>
+
+<p>
+When either of these is used from a target language, a runtime call is made to obtain the underlying constant.
+</p>
+
+<H3><a name="CPlusPlus11_extern_template">7.2.3 Extern template</a></H3>
+
+
+<p>SWIG correctly parses the keywords <tt>extern template</tt>.
+However, this template instantiation suppression in a translation unit has no relevance outside of the C++ compiler and so is not used by SWIG.
+SWIG only uses <tt>%template</tt> for instantiating and wrapping templates.</p>
+
+<div class="code"><pre>
+template class std::vector<int>; // C++03 explicit instantiation in C++
+extern template class std::vector<int>; // C++11 explicit instantiation suppression in C++
+%template(VectorInt) std::vector<int>; // SWIG instantiation
+</pre></div>
+
+<H3><a name="CPlusPlus11_initializer_lists">7.2.4 Initializer lists</a></H3>
+
+
+<p>
+Initializer lists are very much a C++ compiler construct and are not very accessible from wrappers as
+they are intended for compile time initialization of classes using the special <tt>std::initializer_list</tt> type.
+SWIG detects usage of initializer lists and will emit a special informative warning each time one is used:
+</p>
+
+<div class="shell">
+<pre>
+example.i:33: Warning 476: Initialization using std::initializer_list.
+</pre>
+</div>
+
+<p>
+Initializer lists usually appear in constructors but can appear in any function or method.
+They often appear in constructors which are overloaded with alternative approaches to initializing a class,
+such as the std container's push_back method for adding elements to a container.
+The recommended approach then is to simply ignore the initializer-list constructor, for example:
+</p>
+
+<div class="code"><pre>
+%ignore Container::Container(std::initializer_list<int>);
+class Container {
+public:
+ Container(std::initializer_list<int>); // initializer-list constructor
+ Container();
+ void push_back(const int &);
+ ...
+};
+</pre></div>
+
+<p>Alternatively you could modify the class and add another constructor for initialization by some other means,
+for example by a <tt>std::vector</tt>:</p>
+
+<div class="code"><pre>
+%include <std_vector.i>
+class Container {
+public:
+ Container(const std::vector<int> &);
+ Container(std::initializer_list<int>); // initializer-list constructor
+ Container();
+ void push_back(const int &);
+ ...
+};
+</pre></div>
+
+<p>And then call this constructor from your target language, for example, in Python, the following will call the constructor taking the <tt>std::vector</tt>:</p>
+
+<div class="targetlang"><pre>
+>>> c = Container( [1,2,3,4] )
+</pre></div>
+
+<p>
+If you are unable to modify the class being wrapped, consider ignoring the initializer-list constructor and using
+%extend to add in an alternative constructor:
+</p>
+
+<div class="code"><pre>
+%include <std_vector.i>
+%extend Container {
+ Container(const std::vector<int> &elements) {
+ Container *c = new Container();
+ for (int element : elements)
+ c->push_back(element);
+ return c;
+ }
+}
+
+%ignore Container::Container(std::initializer_list<int>);
+
+class Container {
+public:
+ Container(std::initializer_list<int>); // initializer-list constructor
+ Container();
+ void push_back(const int &);
+ ...
+};
+</pre></div>
+
+<p>
+The above makes the wrappers look is as if the class had been declared as follows:
+</p>
+
+<div class="code"><pre>
+%include <std_vector.i>
+class Container {
+public:
+ Container(const std::vector<int> &);
+// Container(std::initializer_list<int>); // initializer-list constructor (ignored)
+ Container();
+ void push_back(const int &);
+ ...
+};
+</pre></div>
+
+<p>
+<tt>std::initializer_list</tt> is simply a container that can only be initialized at compile time.
+As it is just a C++ type, it is possible to write typemaps for a target language container to map onto
+<tt>std::initializer_list</tt>. However, this can only be done for a fixed number of elements as
+initializer lists are not designed to be constructed with a variable number of arguments at runtime.
+The example below is a very simple approach which ignores any parameters passed in and merely initializes
+with a fixed list of fixed integer values chosen at compile time:
+</p>
+
+<div class="code"><pre>
+%typemap(in) std::initializer_list<int> {
+ $1 = {10, 20, 30, 40, 50};
+}
+class Container {
+public:
+ Container(std::initializer_list<int>); // initializer-list constructor
+ Container();
+ void push_back(const int &);
+ ...
+};
+</pre></div>
+
+<p>
+Any attempt at passing in values from the target language will be ignored and be replaced by <tt>{10, 20, 30, 40, 50}</tt>.
+Needless to say, this approach is very limited, but could be improved upon, but only slightly.
+A typemap could be written to map a fixed number of elements on to the <tt>std::initializer_list</tt>,
+but with values decided at runtime.
+The typemaps would be target language specific.
+</p>
+
+<p>
+Note that the default typemap for <tt>std::initializer_list</tt> does nothing but issue the warning
+and hence any user supplied typemaps will override it and suppress the warning.
+</p>
+
+<H3><a name="CPlusPlus11_uniform_initialization">7.2.5 Uniform initialization</a></H3>
+
+
+<p>The curly brackets {} for member initialization are fully
+supported by SWIG:</p>
+
+<div class="code"><pre>
+struct BasicStruct {
+ int x;
+ double y;
+};
+
+struct AltStruct {
+ AltStruct(int x, double y) : x_{x}, y_{y} {}
+
+ int x_;
+ double y_;
+};
+
+BasicStruct var1{5, 3.2}; // only fills the struct components
+AltStruct var2{2, 4.3}; // calls the constructor
+</pre></div>
+
+<p>Uniform initialization does not affect usage from the target language, for example in Python:</p>
+
+<div class="targetlang"><pre>
+>>> a = AltStruct(10, 142.15)
+>>> a.x_
+10
+>>> a.y_
+142.15
+</pre></div>
+
+<H3><a name="CPlusPlus11_type_inference">7.2.6 Type inference</a></H3>
+
+
+<p>SWIG supports <tt>decltype()</tt> with some limitations. Single
+variables are allowed, however, expressions are not supported yet. For
+example, the following code will work:</p>
+<div class="code"><pre>
+int i;
+decltype(i) j;
+</pre></div>
+
+<p>However, using an expression inside the decltype results in syntax error:</p>
+<div class="code"><pre>
+int i; int j;
+decltype(i+j) k; // syntax error
+</pre></div>
+
+<H3><a name="CPlusPlus11_range_based_for_loop">7.2.7 Range-based for-loop</a></H3>
+
+
+<p>This feature is part of the implementation block only. SWIG
+ignores it.</p>
+
+<H3><a name="CPlusPlus11_lambda_functions_and_expressions">7.2.8 Lambda functions and expressions</a></H3>
+
+
+<p>SWIG correctly parses most of the Lambda functions syntax. For example:</p>
+<div class="code"><pre>
+auto val = [] { return something; };
+auto sum = [](int x, int y) { return x+y; };
+auto sum = [](int x, int y) -> int { return x+y; };
+</pre></div>
+
+<p>The lambda functions are removed from the wrappers for now, because of the lack of support
+for closures (scope of the lambda functions) in the target languages.</p>
+
+<p>
+Lambda functions used to create variables can also be parsed, but due to limited support of <tt>auto</tt> when
+the type is deduced from the expression, the variables are simply ignored.
+</p>
+
+<div class="code"><pre>
+auto six = [](int x, int y) { return x+y; }(4, 2);
+</pre></div>
+
+<p>
+Better support should be available in a later release.
+</p>
+
+<H3><a name="CPlusPlus11_alternate_function_syntax">7.2.9 Alternate function syntax</a></H3>
+
+
+<p>SWIG fully supports the new definition of functions. For example:</p>
+<div class="code"><pre>
+struct SomeStruct {
+ int FuncName(int x, int y);
+};
+</pre></div>
+
+<p>can now be written as in C++11:</p>
+
+<div class="code"><pre>
+struct SomeStruct {
+ auto FuncName(int x, int y) -> int;
+};
+
+auto SomeStruct::FuncName(int x, int y) -> int {
+ return x + y;
+}
+</pre></div>
+
+<p>The usage in the target languages remains the same, for example in Python:</p>
+
+<div class="targetlang"><pre>
+>>> a = SomeStruct()
+>>> a.FuncName(10,5)
+15
+</pre></div>
+
+<p>SWIG will also deal with type inference for the return type, as per the limitations described earlier. For example:</p>
+<div class="code"><pre>
+auto square(float a, float b) -> decltype(a);
+</pre></div>
+
+<H3><a name="CPlusPlus11_object_construction_improvement">7.2.10 Object construction improvement</a></H3>
+
+
+<p>
+There are three parts to object construction improvement.
+The first improvement is constructor delegation such as the following:
+</p>
+
+<div class="code"><pre>
+class A {
+public:
+ int a;
+ int b;
+ int c;
+
+ A() : A(10) {}
+ A(int aa) : A(aa, 20) {}
+ A(int aa, int bb) : A(aa, bb, 30) {}
+ A(int aa, int bb, int cc) { a=aa; b=bb; c=cc; }
+};
+</pre></div>
+
+<p>
+where peer constructors can be called. SWIG handles this without any issue.
+</p>
+
+<p>
+The second improvement is constructor inheritance via a <tt>using</tt> declaration.
+This is parsed correctly, but the additional constructors are not currently added to the derived proxy class in the target language.
+An example is shown below:
+<!--
+The extra constructors provided by the <tt>using</tt> syntax will add the appropriate constructors into the target language proxy derived classes.
+In the example below a wrapper for the <tt>DerivedClass(int)</tt> is added to <tt>DerivedClass</tt>:
+-->
+</p>
+
+<div class="code"><pre>
+class BaseClass {
+public:
+ BaseClass(int iValue);
+};
+
+class DerivedClass: public BaseClass {
+ public:
+ using BaseClass::BaseClass; // Adds DerivedClass(int) constructor
+};
+</pre></div>
+
+<p>
+The final part is member initialization at the site of the declaration.
+This kind of initialization is handled by SWIG.
+</p>
+
+<div class="code"><pre>
+class SomeClass {
+public:
+ SomeClass() {}
+ explicit SomeClass(int new_value) : value(new_value) {}
+
+ int value = 5;
+};
+</pre></div>
+
+<H3><a name="CPlusPlus11_explicit_overrides_final">7.2.11 Explicit overrides and final</a></H3>
+
+
+<p>
+The special identifiers <tt>final</tt> and <tt>override</tt> can be used on methods and destructors,
+such as in the following example:
+</p>
+
+<div class="code"><pre>
+struct BaseStruct {
+ virtual void ab() const = 0;
+ virtual void cd();
+ virtual void ef();
+ virtual ~BaseStruct();
+};
+struct DerivedStruct : BaseStruct {
+ virtual void ab() const override;
+ virtual void cd() final;
+ virtual void ef() final override;
+ virtual ~DerivedStruct() override;
+};
+</pre></div>
+
+
+<H3><a name="CPlusPlus11_null_pointer_constant">7.2.12 Null pointer constant</a></H3>
+
+
+<p>The <tt>nullptr</tt> constant is mostly unimportant in wrappers. In the few places it has an effect, it is treated like <tt>NULL</tt>.</p>
+
+<H3><a name="CPlusPlus11_strongly_typed_enumerations">7.2.13 Strongly typed enumerations</a></H3>
+
+
+<p>SWIG supports strongly typed enumerations and parses the new <tt>enum class</tt> syntax and forward declarator for the enums, such as:</p>
+<div class="code"><pre>
+enum class MyEnum : unsigned int;
+</pre></div>
+
+<p>
+Strongly typed enums are often used to avoid name clashes such as the following:
+</p>
+
+<div class="code"><pre>
+struct Color {
+ enum class RainbowColors : unsigned int {
+ Red, Orange, Yellow, Green, Blue, Indigo, Violet
+ };
+
+ enum class WarmColors {
+ Yellow, Orange, Red
+ };
+
+ // Note normal enum
+ enum PrimeColors {
+ Red=100, Green, Blue
+ };
+};
+</pre></div>
+
+<p>
+There are various ways that the target languages handle enums, so it is not possible to precisely state how they are handled in this section.
+However, generally, most scripting languages mangle in the strongly typed enumeration's class name,
+but do not use any additional mangling for normal enumerations. For example, in Python, the following code
+</p>
+
+<div class="targetlang"><pre>
+print Color.RainbowColors_Red, Color.WarmColors_Red, Color.Red
+</pre></div>
+
+<p>
+results in
+</p>
+
+<div class="shell"><pre>
+0 2 100
+</pre></div>
+
+<p>
+The strongly typed languages often wrap normal enums into an enum class and so treat normal enums and strongly typed enums the same.
+The equivalent in Java is:
+</p>
+
+<div class="targetlang"><pre>
+System.out.println(Color.RainbowColors.Red.swigValue() + " " + Color.WarmColors.Red.swigValue() + " " + Color.PrimeColors.Red.swigValue());
+</pre></div>
+
+<H3><a name="CPlusPlus11_double_angle_brackets">7.2.14 Double angle brackets</a></H3>
+
+
+<p>SWIG correctly parses the symbols >> as closing the
+template block, if found inside it at the top level, or as the right
+shift operator >> otherwise.</p>
+
+<div class="code"><pre>
+std::vector<std::vector<int>> myIntTable;
+</pre></div>
+
+<H3><a name="CPlusPlus11_explicit_conversion_operators">7.2.15 Explicit conversion operators</a></H3>
+
+
+<p>SWIG correctly parses the keyword <tt>explicit</tt> for operators in addition to constructors now.
+For example:</p>
+
+<div class="code"><pre>
+class U {
+public:
+ int u;
+};
+
+class V {
+public:
+ int v;
+};
+
+class TestClass {
+public:
+ //implicit converting constructor
+ TestClass(U const &val) { t=val.u; }
+
+ // explicit constructor
+ explicit TestClass(V const &val) { t=val.v; }
+
+ int t;
+};
+
+struct Testable {
+ // explicit conversion operator
+ explicit operator bool() const {
+ return false;
+ }
+};
+</pre></div>
+
+<p>
+The effect of explicit constructors and operators has little relevance for the proxy classes as target
+languages don't have the same concepts of implicit conversions as C++.
+Conversion operators either with or without <tt>explicit</tt> need renaming to a valid identifier name in order to make
+them available as a normal proxy method.
+</p>
+
+<H3><a name="CPlusPlus11_alias_templates">7.2.16 Alias templates</a></H3>
+
+
+<p>
+The following is an example of an alias template:
+
+<div class="code"><pre>
+template< typename T1, typename T2, int >
+class SomeType {
+public:
+ T1 a;
+ T2 b;
+ int c;
+};
+
+template< typename T2 >
+using TypedefName = SomeType<char*, T2, 5>;
+</pre></div>
+
+<p>
+These are partially supported as SWIG will parse these and identify them, however, they are ignored as they are not added to the type system. A warning such as the following is issued:
+</p>
+
+<div class="shell">
+<pre>
+example.i:13: Warning 342: The 'using' keyword in template aliasing is not fully supported yet.
+</pre>
+</div>
+
+<p>
+Similarly for non-template type aliasing:
+</p>
+
+<div class="code"><pre>
+using PFD = void (*)(double); // New introduced syntax
+</pre></div>
+
+<p>
+A warning will be issued:
+</p>
+
+<div class="shell">
+<pre>
+example.i:17: Warning 341: The 'using' keyword in type aliasing is not fully supported yet.
+</pre>
+</div>
+
+
+<p>The equivalent old style typedefs can be used as a workaround:</p>
+
+<div class="code"><pre>
+typedef void (*PFD)(double); // The old style
+</pre></div>
+
+<H3><a name="CPlusPlus11_unrestricted_unions">7.2.17 Unrestricted unions</a></H3>
+
+
+<p>SWIG fully supports any type inside a union even if it does not
+define a trivial constructor. For example, the wrapper for the following
+code correctly provides access to all members in the union:</p>
+
+<div class="code"><pre>
+struct point {
+ point() {}
+ point(int x, int y) : x_(x), y_(y) {}
+ int x_, y_;
+};
+
+#include <new> // For placement 'new' in the constructor below
+union P {
+ int z;
+ double w;
+ point p; // Illegal in C++03; legal in C++11.
+ // Due to the point member, a constructor definition is required.
+ P() {
+ new(&p) point();
+ }
+} p1;
+</pre></div>
+
+<H3><a name="CPlusPlus11_variadic_templates">7.2.18 Variadic templates</a></H3>
+
+
+<p>SWIG supports the variadic templates syntax (inside the <>
+block, variadic class inheritance and variadic constructor and
+initializers) with some limitations. The following code is correctly parsed:</p>
+
+<div class="code"><pre>
+template <typename... BaseClasses> class ClassName : public BaseClasses... {
+public:
+ ClassName (BaseClasses &&... baseClasses) : BaseClasses(baseClasses)... {}
+}
+</pre></div>
+
+<p>
+For now however, the <tt>%template</tt> directive only accepts one parameter substitution
+for the variable template parameters.
+</p>
+
+<div class="code"><pre>
+%template(MyVariant1) ClassName<> // zero argument not supported yet
+%template(MyVariant2) ClassName<int> // ok
+%template(MyVariant3) ClassName<int, int> // too many arguments not supported yet
+</pre></div>
+
+<p>Support for the variadic <tt>sizeof()</tt> function is correctly parsed:</p>
+
+<div class="code"><pre>
+const int SIZE = sizeof...(ClassName<int, int>);
+</pre></div>
+
+<p>
+In the above example <tt>SIZE</tt> is of course wrapped as a constant.
+</p>
+
+<H3><a name="CPlusPlus11_new_string_literals">7.2.19 New string literals</a></H3>
+
+
+<p>SWIG supports wide string and Unicode string constants and raw string literals.</p>
+
+<div class="code"><pre>
+// New string literals
+wstring aa = L"Wide string";
+const char *bb = u8"UTF-8 string";
+const char16_t *cc = u"UTF-16 string";
+const char32_t *dd = U"UTF-32 string";
+
+// Raw string literals
+const char *xx = ")I'm an \"ascii\" \\ string.";
+const char *ee = R"XXX()I'm an "ascii" \ string.)XXX"; // same as xx
+wstring ff = LR"XXX(I'm a "raw wide" \ string.)XXX";
+const char *gg = u8R"XXX(I'm a "raw UTF-8" \ string.)XXX";
+const char16_t *hh = uR"XXX(I'm a "raw UTF-16" \ string.)XXX";
+const char32_t *ii = UR"XXX(I'm a "raw UTF-32" \ string.)XXX";
+</pre></div>
+
+<p>
+Non-ASCII string support varies quite a bit among the various target languages though.
+</p>
+
+<p>
+Note: There is a bug currently where SWIG's preprocessor incorrectly parses an odd number of double quotes
+inside raw string literals.
+</p>
+
+<H3><a name="CPlusPlus11_user_defined_literals">7.2.20 User-defined literals</a></H3>
+
+
+<p>
+SWIG parses the declaration of user-defined literals, that is, the <tt>operator "" _mysuffix()</tt> function syntax.
+</p>
+
+<p>
+Some examples are the raw literal:
+</p>
+<div class="code"><pre>
+OutputType operator "" _myRawLiteral(const char * value);
+</pre></div>
+
+<p>
+numeric cooked literals:
+</p>
+<div class="code"><pre>
+OutputType operator "" _mySuffixIntegral(unsigned long long);
+OutputType operator "" _mySuffixFloat(long double);
+</pre></div>
+
+<p>
+and cooked string literals:
+</p>
+<div class="code"><pre>
+OutputType operator "" _mySuffix(const char * string_values, size_t num_chars);
+OutputType operator "" _mySuffix(const wchar_t * string_values, size_t num_chars);
+OutputType operator "" _mySuffix(const char16_t * string_values, size_t num_chars);
+OutputType operator "" _mySuffix(const char32_t * string_values, size_t num_chars);
+</pre></div>
+
+<p>
+Like other operators that SWIG parses, a warning is given about renaming the operator in order for it to be wrapped:
+</p>
+
+<div class="shell"><pre>
+example.i:27: Warning 503: Can't wrap 'operator "" _myRawLiteral' unless renamed to a valid identifier.
+</pre></div>
+
+<p>
+If %rename is used, then it can be called like any other wrapped method.
+Currently you need to specify the full declaration including parameters for %rename:
+</p>
+
+<div class="code"><pre>
+%rename(MyRawLiteral) operator"" _myRawLiteral(const char * value);
+</pre></div>
+
+<p>
+Or if you just wish to ignore it altogether:
+</p>
+
+<div class="code"><pre>
+%ignore operator "" _myRawLiteral(const char * value);
+</pre></div>
+
+<p>
+Note that use of user-defined literals such as the following still give a syntax error:
+</p>
+
+<div class="code"><pre>
+OutputType var1 = "1234"_suffix;
+OutputType var2 = 1234_suffix;
+OutputType var3 = 3.1416_suffix;
+</pre></div>
+
+<H3><a name="CPlusPlus11_thread_local_storage">7.2.21 Thread-local storage</a></H3>
+
+
+<p>SWIG correctly parses the <tt>thread_local</tt> keyword. For example, variables
+reachable by the current thread can be defined as:</p>
+
+<div class="code"><pre>
+struct A {
+ static thread_local int val;
+};
+thread_local int global_val;
+</pre></div>
+
+<p>
+The use of the <tt>thread_local</tt> storage specifier does not affect the wrapping process; it does not modify
+the wrapper code compared to when it is not specified.
+A variable will be thread local if accessed from different threads from the target language in the
+same way that it will be thread local if accessed from C++ code.
+</p>
+
+<H3><a name="CPlusPlus11_defaulted_deleted">7.2.22 Explicitly defaulted functions and deleted functions</a></H3>
+
+
+<p>SWIG handles explicitly defaulted functions, that is, <tt>= default</tt> added to a function declaration. Deleted definitions, which are also called deleted functions, have <tt>= delete</tt> added to the function declaration.
+For example:</p>
+
+<div class="code"><pre>
+struct NonCopyable {
+ NonCopyable & operator=(const NonCopyable &) = delete; /* Removes operator= */
+ NonCopyable(const NonCopyable &) = delete; /* Removes copy constructor */
+ NonCopyable() = default; /* Explicitly allows the empty constructor */
+};
+</pre></div>
+
+<p>
+Wrappers for deleted functions will not be available in the target language.
+Wrappers for defaulted functions will of course be available in the target language.
+Explicitly defaulted functions have no direct effect for SWIG wrapping as the declaration is handled
+much like any other method declaration parsed by SWIG.
+</p>
+
+<p>
+Deleted functions are also designed to prevent implicit conversions when calling the function.
+For example, the C++ compiler will not compile any code which attempts to use an int as the type of the parameter passed to <tt>f</tt> below:
+</p>
+
+<div class="code"><pre>
+struct NoInt {
+ void f(double i);
+ void f(int) = delete;
+};
+</pre></div>
+
+<p>
+This is a C++ compile time check and SWIG does not make any attempt to detect if the target language is using an int instead of a double though,
+so in this case it is entirely possible to pass an int instead of a double to <tt>f</tt> from Java, Python etc.
+</p>
+
+<H3><a name="CPlusPlus11_type_long_long_int">7.2.23 Type long long int</a></H3>
+
+
+<p>SWIG correctly parses and uses the new <tt>long long</tt> type already introduced in C99 some time ago.</p>
+
+<H3><a name="CPlusPlus11_static_assertions">7.2.24 Static assertions</a></H3>
+
+
+<p>
+SWIG correctly parses the new <tt>static_assert</tt> declarations.
+This is a C++ compile time directive so there isn't anything useful that SWIG can do with it.
+</p>
+
+<div class="code"><pre>
+template <typename T>
+struct Check {
+ static_assert(sizeof(int) <= sizeof(T), "not big enough");
+};
+</pre></div>
+
+<H3><a name="CPlusPlus11_sizeof">7.2.25 Allow sizeof to work on members of classes without an explicit object</a></H3>
+
+
+<p>
+SWIG can parse the new sizeof() on types as well as on objects. For example:
+</p>
+
+<div class="code"><pre>
+struct A {
+ int member;
+};
+
+const int SIZE = sizeof(A::member); // does not work with C++03. Okay with C++11
+</pre></div>
+
+<p>In Python:</p>
+<div class="targetlang"><pre>
+>>> SIZE
+8
+</pre></div>
+
+<H3><a name="CPlusPlus11_noexcept">7.2.26 Exception specifications and noexcept</a></H3>
+
+
+<p>
+C++11 added in the noexcept specification to exception specifications to indicate that a function simply may or may not throw an exception, without actually naming any exception.
+SWIG understands these, although there isn't any useful way that this information can be taken advantage of by target languages,
+so it is as good as ignored during the wrapping process.
+Below are some examples of noexcept in function declarations:
+</p>
+
+<div class="code"><pre>
+static void noex1() noexcept;
+int noex2(int) noexcept(true);
+int noex3(int, bool) noexcept(false);
+</pre></div>
+
+<H3><a name="CPlusPlus11_alignment">7.2.27 Control and query object alignment</a></H3>
+
+
+<p>
+An <tt>alignof</tt> operator is used mostly within C++ to return alignment in number of bytes, but could be used to initialize a variable as shown below.
+The variable's value will be available for access by the target language as any other variable's compile time initialised value.
+
+<div class="code"><pre>
+const int align1 = alignof(A::member);
+</pre></div>
+
+<p>
+The <tt>alignas</tt> specifier for variable alignment is not yet supported.
+Example usage:
+</p>
+
+<div class="code"><pre>
+struct alignas(16) S {
+ int num;
+};
+alignas(double) unsigned char c[sizeof(double)];
+</pre></div>
+
+<p>
+Use the preprocessor to work around this for now:
+</p>
+
+<div class="code"><pre>
+#define alignas(T)
+</pre></div>
+
+
+<H3><a name="CPlusPlus11_attributes">7.2.28 Attributes</a></H3>
+
+
+<p>
+Attributes such as those shown below, are not yet supported and will give a syntax error.
+</p>
+
+<div class="code"><pre>
+int [[attr1]] i [[attr2, attr3]];
+
+[[noreturn, nothrow]] void f [[noreturn]] ();
+</pre></div>
+
+<H2><a name="CPlusPlus11_standard_library_changes">7.3 Standard library changes</a></H2>
+
+
+<H3><a name="CPlusPlus11_threading_facilities">7.3.1 Threading facilities</a></H3>
+
+
+<p>SWIG does not currently wrap or use any of the new threading
+classes introduced (thread, mutex, locks, condition variables, task). The main reason is that
+SWIG target languages offer their own threading facilities so there is limited use for them.
+</p>
+
+<H3><a name="CPlusPlus11_tuple_types">7.3.2 Tuple types</a></H3>
+
+
+<p>
+SWIG does not provide library files for the new tuple types yet.
+Variadic template support requires further work to provide substantial tuple wrappers.
+</p>
+
+<H3><a name="CPlusPlus11_hash_tables">7.3.3 Hash tables</a></H3>
+
+
+<p>
+The new hash tables in the STL are <tt>unordered_set</tt>, <tt>unordered_multiset</tt>, <tt>unordered_map</tt>, <tt>unordered_multimap</tt>.
+These are not available in SWIG, but in principle should be easily implemented by adapting the current STL containers.
+</p>
+
+<H3><a name="CPlusPlus11_regular_expressions">7.3.4 Regular expressions</a></H3>
+
+
+<p>
+While SWIG could provide wrappers for the new C++11 regular expressions classes, there is little need as the target languages have their own regular expression facilities.
+</p>
+
+<H3><a name="CPlusPlus11_general_purpose_smart_pointers">7.3.5 General-purpose smart pointers</a></H3>
+
+
+<p>
+SWIG provides special smart pointer handling for <tt>std::shared_ptr</tt> in the same way it has support for <tt>boost::shared_ptr</tt>.
+Please see the <a href="Library.html#Library_std_shared_ptr">shared_ptr smart pointer</a> library section.
+There is no special smart pointer handling available for <tt>std::weak_ptr</tt> and <tt>std::unique_ptr</tt> yet.
+</p>
+
+<H3><a name="CPlusPlus11_extensible_random_number_facility">7.3.6 Extensible random number facility</a></H3>
+
+
+<p>This feature extends and standardizes the standard library only and does not effect the C++ language nor SWIG.</p>
+
+<H3><a name="CPlusPlus11_wrapper_reference">7.3.7 Wrapper reference</a></H3>
+
+
+<p>
+Wrapper references are similar to normal C++ references but are copy-constructible and copy-assignable.
+They could conceivably be used in public APIs.
+There is no special support for <tt>std::reference_wrapper</tt> in SWIG though.
+Users would need to write their own typemaps if wrapper references are being used and these would be similar to the plain C++ reference typemaps.
+</p>
+
+
+<H3><a name="CPlusPlus11_polymorphous_wrappers_for_function_objects">7.3.8 Polymorphous wrappers for function objects</a></H3>
+
+
+<p>
+SWIG supports functor classes in a few languages in a very natural way.
+However nothing is provided yet for the new <tt>std::function</tt> template.
+SWIG will parse usage of the template like any other template.
+</p>
+
+<div class="code"><pre>
+%rename(__call__) Test::operator(); // Default renaming used for Python
+
+struct Test {
+ bool operator()(int x, int y); // function object
+};
+
+#include <functional>
+std::function<void (int, int)> pF = Test; // function template wrapper
+
+</pre></div>
+
+<p>
+Example of supported usage of the plain functor from Python is shown below.
+It does not involve <tt>std::function</tt>.
+</p>
+
+<div class="targetlang"><pre>
+t = Test()
+b = t(1,2) # invoke C++ function object
+</pre></div>
+
+<H3><a name="CPlusPlus11_type_traits_for_metaprogramming">7.3.9 Type traits for metaprogramming</a></H3>
+
+
+<p>The type_traits functions to support C++ metaprogramming is useful at compile time and is aimed specifically at C++ development:</p>
+
+<div class="code"><pre>
+#include <type_traits>
+
+// First way of operating.
+template< bool B > struct algorithm {
+ template< class T1, class T2 > static int do_it(T1 &, T2 &) { /*...*/ return 1; }
+};
+
+// Second way of operating.
+template<> struct algorithm<true> {
+ template< class T1, class T2 > static int do_it(T1, T2) { /*...*/ return 2; }
+};
+
+// Instantiating 'elaborate' will automatically instantiate the correct way to operate, depending on the types used.
+template< class T1, class T2 > int elaborate(T1 A, T2 B) {
+ // Use the second way only if 'T1' is an integer and if 'T2' is a floating point,
+ // otherwise use the first way.
+ return algorithm< std::is_integral<T1>::value && std::is_floating_point<T2>::value >::do_it(A, B);
+}
+</pre></div>
+
+<p>
+SWIG correctly parses the template specialization, template types etc.
+However, metaprogramming and the additional support in the type_traits header is really for compile time and is not much use at runtime for the target languages.
+For example, as SWIG requires explicit instantiation of templates via <tt>%template</tt>, there isn't much that <tt>std::is_integral<int></tt> is going to provide by itself.
+However, template functions using such metaprogramming techniques might be useful to wrap.
+For example, the following instantiations could be made:
+</p>
+
+<div class="code"><pre>
+%template(Elaborate) elaborate<int, int>;
+%template(Elaborate) elaborate<int, double>;
+</pre></div>
+
+<p>
+Then the appropriate algorithm can be called for the subset of types given by the above <tt>%template</tt> instantiations from a target language, such as Python:
+</p>
+
+<div class="targetlang"><pre>
+>>> Elaborate(0, 0)
+1
+>>> Elaborate(0, 0.0)
+2
+</pre></div>
+
+<H3><a name="CPlusPlus11_uniform_method_for_computing_return_type_of_function_objects">7.3.10 Uniform method for computing return type of function objects</a></H3>
+
+
+<p>
+The new <tt>std::result_of</tt> class introduced in the <functional> header provides a generic way to obtain the return type of a function type via <tt>std::result_of::type</tt>.
+There isn't any library interface file to support this type.
+With a bit of work, SWIG will deduce the return type of functions when used in <tt>std::result_of</tt> using the approach shown below.
+The technique basically forward declares the <tt>std::result_of</tt> template class, then partially specializes it for the function types of interest.
+SWIG will use the partial specialization and hence correctly use the <tt>std::result_of::type</tt> provided in the partial specialization.
+</p>
+
+<div class="code"><pre>
+%inline %{
+#include <functional>
+typedef double(*fn_ptr)(double);
+%}
+
+namespace std {
+ // Forward declaration of result_of
+ template<typename Func> struct result_of;
+ // Add in a partial specialization of result_of
+ template<> struct result_of< fn_ptr(double) > {
+ typedef double type;
+ };
+}
+
+%template() std::result_of< fn_ptr(double) >;
+
+%inline %{
+
+double square(double x) {
+ return (x * x);
+}
+
+template<class Fun, class Arg>
+typename std::result_of<Fun(Arg)>::type test_result_impl(Fun fun, Arg arg) {
+ return fun(arg);
+}
+%}
+
+%template(test_result) test_result_impl< fn_ptr, double >;
+%constant double (*SQUARE)(double) = square;
+</pre></div>
+
+<p>
+Note the first use of <tt>%template</tt> which SWIG requires to instantiate the template.
+The empty template instantiation suffices as no proxy class is required for <tt>std::result_of<Fun(Arg)>::type</tt> as this type is really just a <tt>double</tt>.
+The second <tt>%template</tt> instantiates the template function which is being wrapped for use as a callback.
+The <tt>%constant</tt> can then be used for any callback function as described in <a href="SWIG.html#SWIG_nn30">Pointers to functions and callbacks</a>.
+</p>
+
+<p>
+Example usage from Python should give the not too surprising result:
+</p>
+
+<div class="targetlang"><pre>
+>>> test_result(SQUARE, 5.0)
+25.0
+</pre></div>
+
+<p>
+Phew, that is a lot of hard work to get a callback working.
+You could just go with the more attractive option of just using <tt>double</tt> as the return type in the function declaration instead of <tt>result_of</tt>!
+</p>
+
+</body>
+</html>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and C#</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#FFFFFF">
-<H1><a name="CSharp"></a>19 SWIG and C#</H1>
+<H1><a name="CSharp">20 SWIG and C#</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#CSharp_introduction">Introduction</a>
+<ul>
+<li><a href="#CSharp_introduction_swig2_compatibility">SWIG 2 Compatibility</a>
+<li><a href="#CSharp_commandline">Additional command line options</a>
+</ul>
<li><a href="#CSharp_differences_java">Differences to the Java module</a>
<li><a href="#CSharp_void_pointers">Void pointers</a>
<li><a href="#CSharp_arrays">C# Arrays</a>
<li><a href="#CSharp_directors_implementation">Directors implementation</a>
<li><a href="#CSharp_director_caveats">Director caveats</a>
</ul>
-<li><a href="#CSharp_multiple_modules">Multiples modules</a>
+<li><a href="#CSharp_multiple_modules">Multiple modules</a>
<li><a href="#CSharp_typemap_examples">C# Typemap examples</a>
<ul>
<li><a href="#CSharp_memory_management_member_variables">Memory management when returning references to member variables</a>
-<H2><a name="CSharp_introduction"></a>19.1 Introduction</H2>
+<H2><a name="CSharp_introduction">20.1 Introduction</a></H2>
<p>
<p>
To get the most out of this chapter an understanding of interop is required.
The <a href="http://msdn.microsoft.com">Microsoft Developer Network (MSDN)</a> has a good reference guide in a section titled "Interop Marshaling".
-Monodoc, available from the Mono project, has a very useful section titled <a href="http://www.mono-project.com/Interop_with_Native_Libraries">Interop with native libraries</a>.
+Monodoc, available from the Mono project, has a very useful section titled <a href="http://www.mono-project.com/docs/advanced/pinvoke/">Interop with native libraries</a>.
+</p>
+
+<H3><a name="CSharp_introduction_swig2_compatibility">20.1.1 SWIG 2 Compatibility</a></H3>
+
+
+<p>
+In order to minimize name collisions between names generated based on input to SWIG and names used in the generated code from the .NET framework, SWIG 3 fully qualifies the use of all .NET types. Furthermore, SWIG 3 avoids <tt>using</tt> directives in generated code. This breaks backwards compatibility with typemaps, pragmas, etc written for use with SWIG 2 that assume the presence of <tt>using System;</tt> or <tt>using System.Runtime.InteropServices;</tt> directives in the intermediate class imports, module imports, or proxy imports. SWIG 3 supports backwards compatibility though the use of the <tt>SWIG2_CSHARP</tt> macro. If <tt>SWIG2_CSHARP</tt> is defined, SWIG 3 generates <tt>using</tt> directives in the intermediate class, module class, and proxy class code similar to those generated by SWIG 2. This can be done without modifying any of the input code by passing the <tt>-DSWIG2_CSHARP</tt> commandline parameter when executing <tt>swig</tt>.
+</p>
+
+
+<H3><a name="CSharp_commandline">20.1.2 Additional command line options</a></H3>
+
+
+<p>
+The following table lists the additional commandline options available for the C# module. They can also be seen by using:
+</p>
+
+<div class="code"><pre>
+swig -csharp -help
+</pre></div>
+
+<table summary="C# specific options">
+<tr>
+<th>C# specific options</th>
+</tr>
+
+<tr>
+<td>-dllimport <dl></td>
+<td>Override DllImport attribute name to <dl></td>
+</tr>
+
+<tr>
+<td>-namespace <nm></td>
+<td>Generate wrappers into C# namespace <nm></td>
+</tr>
+
+<tr>
+<td>-noproxy</td>
+<td>Generate the low-level functional interface instead of proxy classes</td>
+</tr>
+
+<tr>
+<td>-oldvarnames</td>
+<td>Old intermediary method names for variable wrappers</td>
+</tr>
+
+<tr>
+<td>-outfile <file></td>
+<td>Write all C# into a single <file> located in the output directory
+</td>
+</tr>
+
+</table>
+
+<p>
+The -outfile option combines all the generated C# code into a single output file instead of creating multiple C# files.
+The default, when this option is not provided, is to generate separate .cs files for the module class,
+intermediary class and each of the generated proxy and type wrapper classes.
+Note that the file extension (.cs) will not be automatically added and needs to be provided.
+Due to possible compiler limits it is not advisable to use <tt>-outfile</tt> for large projects.
</p>
-<H2><a name="CSharp_differences_java"></a>19.2 Differences to the Java module</H2>
+<H2><a name="CSharp_differences_java">20.2 Differences to the Java module</a></H2>
<p>
javafinalize -> csfinalize
javadestruct -> csdestruct
javadestruct_derived -> csdestruct_derived
+javainterfacecode -> csinterfacecode
</pre></div>
</li>
$javaclazzname -> $csclazzname
$javainput -> $csinput
$jnicall -> $imcall
+$javainterfacename -> $csinterfacename
+$&javainterfacename -> $&csinterfacename
+$*javainterfacename -> $*csinterfacename
</pre></div>
</li>
<div class="code">
<pre>
-%typemap(imtype, out="IntPtr") char * "string"
+%typemap(imtype, out="global::System.IntPtr") char * "string"
char * function(char *);
</pre>
</div>
<div class="code">
<pre>
-public static extern IntPtr function(string jarg1);
+public static extern global::System.IntPtr function(string jarg1);
</pre>
</div>
<div class="code">
<pre>
%typemap(imtype,
- inattributes="[MarshalAs(UnmanagedType.LPStr)]",
- outattributes="[return: MarshalAs(UnmanagedType.LPStr)]") const char * "String"
+ inattributes="[global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPStr)]",
+ outattributes="[return: global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPStr)]") const char * "String"
const char * GetMsg() {}
void SetMsg(const char *msg) {}
<pre>
class examplePINVOKE {
...
- [DllImport("example", EntryPoint="CSharp_GetMsg")]
- [return: MarshalAs(UnmanagedType.LPStr)]
+ [global::System.Runtime.InteropServices.DllImport("example", EntryPoint="CSharp_GetMsg")]
+ [return: global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPStr)]
public static extern String GetMsg();
- [DllImport("example", EntryPoint="CSharp_SetMsg")]
- public static extern void SetMsg([MarshalAs(UnmanagedType.LPStr)]String jarg1);
+ [global::System.Runtime.InteropServices.DllImport("example", EntryPoint="CSharp_SetMsg")]
+ public static extern void SetMsg([global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPStr)]String jarg1);
}
</pre>
</div>
<div class="code">
<pre>
[ThreadSafe]
-public class AClass : IDisposable {
+public class AClass : global::System.IDisposable {
...
[ThreadSafe(false)]
public AClass(double a) ...
<div class="code">
<pre>
-%typemap(csattributes) Couleur "[System.ComponentModel.Description(\"Colours\")]"
-%csattributes Rouge "[System.ComponentModel.Description(\"Red\")]"
-%csattributes Vert "[System.ComponentModel.Description(\"Green\")]"
+%typemap(csattributes) Couleur "[global::System.ComponentModel.Description(\"Colours\")]"
+%csattributes Rouge "[global::System.ComponentModel.Description(\"Red\")]"
+%csattributes Vert "[global::System.ComponentModel.Description(\"Green\")]"
%inline %{
enum Couleur { Rouge, Orange, Vert };
%}
<div class="code">
<pre>
-[System.ComponentModel.Description("Colours")]
+[global::System.ComponentModel.Description("Colours")]
public enum Couleur {
- [System.ComponentModel.Description("Red")]
+ [global::System.ComponentModel.Description("Red")]
Rouge,
Orange,
- [System.ComponentModel.Description("Green")]
+ [global::System.ComponentModel.Description("Green")]
Vert
}
</pre>
<a href="http://www.cygwin.com">Cygwin</a> or <a href="http://www.mingw.org">MinGW</a> environment for automatic configuration of the example makefiles.
Any one of the three C# compilers (Portable.NET, Mono or Microsoft) can be detected from within a Cygwin or Mingw environment if installed in your path.
-<H2><a name="CSharp_void_pointers"></a>19.3 Void pointers</H2>
+<H2><a name="CSharp_void_pointers">20.3 Void pointers</a></H2>
<p>
</pre>
</div>
-<H2><a name="CSharp_arrays"></a>19.4 C# Arrays</H2>
+<H2><a name="CSharp_arrays">20.4 C# Arrays</a></H2>
<p>
pinned arrays.
</p>
-<H3><a name="CSharp_arrays_swig_library"></a>19.4.1 The SWIG C arrays library</H3>
+<H3><a name="CSharp_arrays_swig_library">20.4.1 The SWIG C arrays library</a></H3>
<p>
</div>
-<H3><a name="CSharp_arrays_pinvoke_default_array_marshalling"></a>19.4.2 Managed arrays using P/Invoke default array marshalling</H3>
+<H3><a name="CSharp_arrays_pinvoke_default_array_marshalling">20.4.2 Managed arrays using P/Invoke default array marshalling</a></H3>
<p>
<div class="code">
<pre>
-[DllImport("example", EntryPoint="CSharp_myArrayCopy")]
-public static extern void myArrayCopy([In, MarshalAs(UnmanagedType.LPArray)]int[] jarg1,
- [Out, MarshalAs(UnmanagedType.LPArray)]int[] jarg2,
+[global::System.Runtime.InteropServices.DllImport("example", EntryPoint="CSharp_myArrayCopy")]
+public static extern void myArrayCopy([global::System.Runtime.InteropServices.In, global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPArray)]int[] jarg1,
+ [global::System.Runtime.InteropServices.Out, global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPArray)]int[] jarg2,
int jarg3);
</pre>
</div>
<div class="code">
<pre>
- [DllImport("example", EntryPoint="CSharp_myArraySwap")]
- public static extern void myArraySwap([In, Out, MarshalAs(UnmanagedType.LPArray)]int[] jarg1,
- [In, Out, MarshalAs(UnmanagedType.LPArray)]int[] jarg2,
+ [global::System.Runtime.InteropServices.DllImport("example", EntryPoint="CSharp_myArraySwap")]
+ public static extern void myArraySwap([global::System.Runtime.InteropServices.In, global::System.Runtime.InteropServices.Out, global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPArray)]int[] jarg1,
+ [global::System.Runtime.InteropServices.In, global::System.Runtime.InteropServices.Out, global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPArray)]int[] jarg2,
int jarg3);
</pre>
</div>
-<H3><a name="CSharp_arrays_pinning"></a>19.4.3 Managed arrays using pinning</H3>
+<H3><a name="CSharp_arrays_pinning">20.4.3 Managed arrays using pinning</a></H3>
<p>
fixed ( int *swig_ptrTo_sourceArray = sourceArray ) {
fixed ( int *swig_ptrTo_targetArray = targetArray ) {
{
- examplePINVOKE.myArrayCopy((IntPtr)swig_ptrTo_sourceArray, (IntPtr)swig_ptrTo_targetArray,
+ examplePINVOKE.myArrayCopy((global::System.IntPtr)swig_ptrTo_sourceArray, (global::System.IntPtr)swig_ptrTo_targetArray,
nitems);
}
}
<div class="code">
<pre>
-[DllImport("example", EntryPoint="CSharp_myArrayCopy")]
-public static extern void myArrayCopy(IntPtr jarg1, IntPtr jarg2, int jarg3);
+[global::System.Runtime.InteropServices.DllImport("example", EntryPoint="CSharp_myArrayCopy")]
+public static extern void myArrayCopy(global::System.IntPtr jarg1, global::System.IntPtr jarg2, int jarg3);
</pre>
</div>
-<H2><a name="CSharp_exceptions"></a>19.5 C# Exceptions</H2>
+<H2><a name="CSharp_exceptions">20.5 C# Exceptions</a></H2>
<p>
</p>
-<H3><a name="CSharp_exception_example_check_typemap"></a>19.5.1 C# exception example using "check" typemap</H3>
+<H3><a name="CSharp_exception_example_check_typemap">20.5.1 C# exception example using "check" typemap</a></H3>
<p>
-Lets say we have the following simple C++ method:
+Let's say we have the following simple C++ method:
</p>
Actually it will issue this warning for any function beginning with <tt>SWIG_CSharpSetPendingException</tt>.
</P>
-<H3><a name="CSharp_exception_example_percent_exception"></a>19.5.2 C# exception example using %exception</H3>
+<H3><a name="CSharp_exception_example_percent_exception">20.5.2 C# exception example using %exception</a></H3>
<p>
$action
} catch (std::out_of_range e) {
SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
+ return $null;
}
%}
</pre>
</div>
-<H3><a name="CSharp_exception_example_exception_specifications"></a>19.5.3 C# exception example using exception specifications</H3>
+<H3><a name="CSharp_exception_example_exception_specifications">20.5.3 C# exception example using exception specifications</a></H3>
<p>
Multiple catch handlers are generated should there be more than one exception specifications declared.
</p>
-<H3><a name="CSharp_custom_application_exception"></a>19.5.4 Custom C# ApplicationException example</H3>
+<H3><a name="CSharp_custom_application_exception">20.5.4 Custom C# ApplicationException example</a></H3>
<p>
static CustomExceptionDelegate customDelegate =
new CustomExceptionDelegate(SetPendingCustomException);
- [DllImport("$dllimport", EntryPoint="CustomExceptionRegisterCallback")]
+ [global::System.Runtime.InteropServices.DllImport("$dllimport", EntryPoint="CustomExceptionRegisterCallback")]
public static extern
void CustomExceptionRegisterCallback(CustomExceptionDelegate customCallback);
<div class="code">
<pre>
// Custom C# Exception
-class CustomApplicationException : System.ApplicationException {
+class CustomApplicationException : global::System.ApplicationException {
public CustomApplicationException(string message)
: base(message) {
}
</pre>
</div>
-<H2><a name="CSharp_directors"></a>19.6 C# Directors</H2>
+<H2><a name="CSharp_directors">20.6 C# Directors</a></H2>
<p>
However, the <a href="Java.html#Java_directors">Java directors</a> section should also be read in order to gain more insight into directors.
</p>
-<H3><a name="CSharp_directors_example"></a>19.6.1 Directors example</H3>
+<H3><a name="CSharp_directors_example">20.6.1 Directors example</a></H3>
<p>
</pre>
</div>
-<H3><a name="CSharp_directors_implementation"></a>19.6.2 Directors implementation</H3>
+<H3><a name="CSharp_directors_implementation">20.6.2 Directors implementation</a></H3>
<p>
<div class="code">
<pre>
-using System;
-using System.Runtime.InteropServices;
-
-public class Base : IDisposable {
- private HandleRef swigCPtr;
+public class Base : global::System.IDisposable {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- internal Base(IntPtr cPtr, bool cMemoryOwn) {
+ internal Base(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
- swigCPtr = new HandleRef(this, cPtr);
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static HandleRef getCPtr(Base obj) {
- return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Base obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
~Base() {
public virtual void Dispose() {
lock(this) {
- if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+ if(swigCPtr.Handle != global::System.IntPtr.Zero && swigCMemOwn) {
swigCMemOwn = false;
examplePINVOKE.delete_Base(swigCPtr);
}
- swigCPtr = new HandleRef(null, IntPtr.Zero);
- GC.SuppressFinalize(this);
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ global::System.GC.SuppressFinalize(this);
}
}
examplePINVOKE.Base_director_connect(swigCPtr, swigDelegate0, swigDelegate1);
}
- private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes) {
+ private bool SwigDerivedClassHasMethod(string methodName, global::System.global::System.Type[] methodTypes) {
System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, methodTypes);
bool hasDerivedMethod = methodInfo.DeclaringType.IsSubclassOf(typeof(Base));
return hasDerivedMethod;
return UIntMethod(x);
}
- private void SwigDirectorBaseBoolMethod(IntPtr b, bool flag) {
+ private void SwigDirectorBaseBoolMethod(global::System.IntPtr b, bool flag) {
BaseBoolMethod(new Base(b, false), flag);
}
internal delegate uint SwigDelegateBase_0(uint x);
- internal delegate void SwigDelegateBase_1(IntPtr b, bool flag);
+ internal delegate void SwigDelegateBase_1(global::System.IntPtr b, bool flag);
private SwigDelegateBase_0 swigDelegate0;
private SwigDelegateBase_1 swigDelegate1;
- private static Type[] swigMethodTypes0 = new Type[] { typeof(uint) };
- private static Type[] swigMethodTypes1 = new Type[] { typeof(Base), typeof(bool) };
+ private static global::System.Type[] swigMethodTypes0 = new global::System.Type[] { typeof(uint) };
+ private static global::System.Type[] swigMethodTypes1 = new global::System.Type[] { typeof(Base), typeof(bool) };
}
</pre>
</div>
</pre>
</div>
-<H3><a name="CSharp_director_caveats"></a>19.6.3 Director caveats</H3>
+<H3><a name="CSharp_director_caveats">20.6.3 Director caveats</a></H3>
<p>
should pass the call on to <tt>CSharpDefaults.DefaultMethod(int)</tt>using the C++ default value, as shown above.
</p>
-<H2><a name="CSharp_multiple_modules"></a>19.7 Multiples modules</H2>
+<H2><a name="CSharp_multiple_modules">20.7 Multiple modules</a></H2>
<p>
-When using <a href="Modules.html">multiple modules</a> it is is possible to compile each SWIG generated wrapper
+When using <a href="Modules.html#Modules">multiple modules</a> it is is possible to compile each SWIG generated wrapper
into a different assembly.
However, by default the generated code may not compile if
generated classes in one assembly use generated classes in another assembly.
if you don't want users to easily stumble upon these so called 'internal workings' of the wrappers.
</p>
-<H2><a name="CSharp_typemap_examples"></a>19.8 C# Typemap examples</H2>
+<H2><a name="CSharp_typemap_examples">20.8 C# Typemap examples</a></H2>
This section includes a few examples of typemaps. For more examples, you
the SWIG library.
-<H3><a name="CSharp_memory_management_member_variables"></a>19.8.1 Memory management when returning references to member variables</H3>
+<H3><a name="CSharp_memory_management_member_variables">20.8.1 Memory management when returning references to member variables</a></H3>
<p>
Wheel wheel = new Bike(10).getWheel();
Console.WriteLine("wheel size: " + wheel.size);
// Simulate a garbage collection
- System.GC.Collect();
- System.GC.WaitForPendingFinalizers();
- Console.WriteLine("wheel size: " + wheel.size);
+ global::System.GC.Collect();
+ global::System.GC.WaitForPendingFinalizers();
+ global::System.Console.WriteLine("wheel size: " + wheel.size);
</pre>
</div>
// of dangling C++ pointer. Intended for methods that return pointers or
// references to a member variable.
%typemap(csout, excode=SWIGEXCODE) Wheel& getWheel {
- IntPtr cPtr = $imcall;$excode
+ global::System.IntPtr cPtr = $imcall;$excode
$csclassname ret = null;
- if (cPtr != IntPtr.Zero) {
+ if (cPtr != global::System.IntPtr.Zero) {
ret = new $csclassname(cPtr, $owner);
ret.addReference(this);
}
<div class="code">
<pre>
-public class Wheel : IDisposable {
+public class Wheel : global::System.IDisposable {
...
// Ensure that the GC doesn't collect any Bike instance set from C#
private Bike bikeReference;
}
}
-public class Bike : IDisposable {
+public class Bike : global::System.IDisposable {
...
public Wheel getWheel() {
- IntPtr cPtr = examplePINVOKE.Bike_getWheel(swigCPtr);
+ global::System.IntPtr cPtr = examplePINVOKE.Bike_getWheel(swigCPtr);
Wheel ret = null;
- if (cPtr != IntPtr.Zero) {
+ if (cPtr != global::System.IntPtr.Zero) {
ret = new Wheel(cPtr, false);
ret.addReference(this);
}
Note the <tt>addReference</tt> call.
</p>
-<H3><a name="CSharp_memory_management_objects"></a>19.8.2 Memory management for objects passed to the C++ layer</H3>
+<H3><a name="CSharp_memory_management_objects">20.8.2 Memory management for objects passed to the C++ layer</a></H3>
<p>
container.setElement(element);
Console.WriteLine("element.value: " + container.getElement().value);
// Simulate a garbage collection
- System.GC.Collect();
- System.GC.WaitForPendingFinalizers();
- Console.WriteLine("element.value: " + container.getElement().value);
+ global::System.GC.Collect();
+ global::System.GC.WaitForPendingFinalizers();
+ global::System.Console.WriteLine("element.value: " + container.getElement().value);
</pre>
</div>
<div class="code">
<pre>
-public class Container : IDisposable {
+public class Container : global::System.IDisposable {
...
// Ensure that the GC doesn't collect any Element set from C#
// as the underlying C++ class stores a shallow copy
private Element elementReference;
- private HandleRef getCPtrAndAddReference(Element element) {
+ private global::System.Runtime.InteropServices.HandleRef getCPtrAndAddReference(Element element) {
elementReference = element;
return Element.getCPtr(element);
}
// Ensure that the GC doesn't collect any Element set from C#
// as the underlying C++ class stores a shallow copy
private Element elementReference;
- private HandleRef getCPtrAndAddReference(Element element) {
+ private global::System.Runtime.InteropServices.HandleRef getCPtrAndAddReference(Element element) {
elementReference = element;
return Element.getCPtr(element);
}
</div>
-<H3><a name="CSharp_date_marshalling"></a>19.8.3 Date marshalling using the csin typemap and associated attributes</H3>
+<H3><a name="CSharp_date_marshalling">20.8.3 Date marshalling using the csin typemap and associated attributes</a></H3>
<p>
<div class="code">
<pre>
-public class Action : IDisposable {
+public class Action : global::System.IDisposable {
...
public Action(CDate dateIn, CDate dateOut)
: this(examplePINVOKE.new_Action(CDate.getCPtr(dateIn), CDate.getCPtr(dateOut)), true) {
<div class="code">
<pre>
-public class Action : IDisposable {
+public class Action : global::System.IDisposable {
...
public int doSomething(System.DateTime dateIn, out System.DateTime dateOut) {
CDate tempdateIn = new CDate(dateIn.Year, dateIn.Month, dateIn.Day);
}
}
- static private IntPtr SwigConstructAction(System.DateTime dateIn, out System.DateTime dateOut) {
+ static private global::System.IntPtr SwigConstructAction(System.DateTime dateIn, out System.DateTime dateOut) {
CDate tempdateIn = new CDate(dateIn.Year, dateIn.Month, dateIn.Day);
CDate tempdateOut = new CDate();
try {
</pre>
</div>
-<H3><a name="CSharp_date_properties"></a>19.8.4 A date example demonstrating marshalling of C# properties</H3>
+<H3><a name="CSharp_date_properties">20.8.4 A date example demonstrating marshalling of C# properties</a></H3>
<p>
%typemap(csvarout, excode=SWIGEXCODE2) CDate * %{
/* csvarout typemap code */
get {
- IntPtr cPtr = $imcall;
- CDate tempDate = (cPtr == IntPtr.Zero) ? null : new CDate(cPtr, $owner);$excode
+ global::System.IntPtr cPtr = $imcall;
+ CDate tempDate = (cPtr == global::System.IntPtr.Zero) ? null : new CDate(cPtr, $owner);$excode
return new System.DateTime(tempDate.getYear(), tempDate.getMonth(), tempDate.getDay(),
0, 0, 0);
} %}
}
/* csvarout typemap code */
get {
- IntPtr cPtr = examplePINVOKE.ImportantDate_get();
- CDate tempDate = (cPtr == IntPtr.Zero) ? null : new CDate(cPtr, false);
+ global::System.IntPtr cPtr = examplePINVOKE.ImportantDate_get();
+ CDate tempDate = (cPtr == global::System.IntPtr.Zero) ? null : new CDate(cPtr, false);
return new System.DateTime(tempDate.getYear(), tempDate.getMonth(), tempDate.getDay(),
0, 0, 0);
}
<li>The 'csin' typemap has 'pre', 'post' and 'cshin' attributes, and these are all ignored in the property set. The code in these attributes must instead be replicated within the 'csvarin' typemap. The line creating the <tt>temp$csinput</tt> variable is such an example; it is identical to what is in the 'pre' attribute.
</ul>
-<H3><a name="CSharp_date_pre_post_directors"></a>19.8.5 Date example demonstrating the 'pre' and 'post' typemap attributes for directors</H3>
+<H3><a name="CSharp_date_pre_post_directors">20.8.5 Date example demonstrating the 'pre' and 'post' typemap attributes for directors</a></H3>
<p>
<div class="code"><pre>
...
- private void SwigDirectorsomeCallback(IntPtr date) {
+ private void SwigDirectorsomeCallback(global::System.IntPtr date) {
System.DateTime tempdate = new System.DateTime();
try {
someCallback(out tempdate);
</p>
-<H3><a name="CSharp_partial_classes"></a>19.8.6 Turning wrapped classes into partial classes</H3>
+<H3><a name="CSharp_partial_classes">20.8.6 Turning wrapped classes into partial classes</a></H3>
<p>
<div class="code">
<pre>
-public class ExtendMe : IDisposable {
+public class ExtendMe : global::System.IDisposable {
...
public int Part1() {
...
<div class="code">
<pre>
-public partial class ExtendMe : IDisposable {
+public partial class ExtendMe : global::System.IDisposable {
...
public int Part1() {
...
<div class="code">
<pre>
-public partial class ExtendMe : IDisposable {
+public partial class ExtendMe : global::System.IDisposable {
public int Part2() {
return 2;
}
The following example is an alternative approach to adding managed code to the generated proxy class.
</p>
-<H3><a name="CSharp_extending_proxy_class"></a>19.8.7 Extending proxy classes with additional C# code</H3>
+<H3><a name="CSharp_extending_proxy_class">20.8.7 Extending proxy classes with additional C# code</a></H3>
<p>
<div class="code">
<pre>
-public class ExtendMe : IDisposable {
+public class ExtendMe : global::System.IDisposable {
...
public int Part3() {
return 3;
</pre>
</div>
-<H3><a name="CSharp_enum_underlying_type"></a>19.8.8 Underlying type for enums</H3>
+<H3><a name="CSharp_enum_underlying_type">20.8.8 Underlying type for enums</a></H3>
<P>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<!-- Hand-written HTML -->
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Chicken</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Chicken"></a>20 SWIG and Chicken</H1>
+<H1><a name="Chicken">21 SWIG and Chicken</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
</p>
<ol>
- <li>generates portable C code</li>
- <li>includes a customizable interpreter</li>
- <li>links to C libraries with a simple Foreign Function Interface</li>
- <li>supports full tail-recursion and first-class continuations</li>
+ <li>generates portable C code</li>
+ <li>includes a customizable interpreter</li>
+ <li>links to C libraries with a simple Foreign Function Interface</li>
+ <li>supports full tail-recursion and first-class continuations</li>
</ol>
<p>
</p>
-<H2><a name="Chicken_nn2"></a>20.1 Preliminaries</H2>
+<H2><a name="Chicken_nn2">21.1 Preliminaries</a></H2>
<p>
directory for the basic steps to run SWIG CHICKEN.
</p>
-<H3><a name="Chicken_nn3"></a>20.1.1 Running SWIG in C mode</H3>
+<H3><a name="Chicken_nn3">21.1.1 Running SWIG in C mode</a></H3>
<p>
</p>
<div class="shell">
- <pre>% swig -chicken example.i</pre>
+
<pre>% swig -chicken example.i</pre>
</div>
<p>
object files and linked into your project.
</p>
-<H3><a name="Chicken_nn4"></a>20.1.2 Running SWIG in C++ mode</H3>
+<H3><a name="Chicken_nn4">21.1.2 Running SWIG in C++ mode</a></H3>
<p>
</p>
<div class="shell">
- <pre>% swig -chicken -c++ example.i</pre>
+
<pre>% swig -chicken -c++ example.i</pre>
</div>
<p>
</p>
<div class="shell">
- <pre>% chicken example.scm -output-file oexample.c</pre>
+
<pre>% chicken example.scm -output-file oexample.c</pre>
</div>
<p>
object files and linked into your project.
</p>
-<H2><a name="Chicken_nn5"></a>20.2 Code Generation</H2>
+<H2><a name="Chicken_nn5">21.2 Code Generation</a></H2>
-<H3><a name="Chicken_nn6"></a>20.2.1 Naming Conventions</H3>
+<H3><a name="Chicken_nn6">21.2.1 Naming Conventions</a></H3>
<p>
<tt>%rename</tt> SWIG directive in the SWIG interface file.
</p>
-<H3><a name="Chicken_nn7"></a>20.2.2 Modules</H3>
+<H3><a name="Chicken_nn7">21.2.2 Modules</a></H3>
<p>
The name of the module must be declared one of two ways:
<ul>
- <li>Placing <tt>%module example</tt> in the SWIG interface
- file.</li>
- <li>Using <tt>-module example</tt> on the SWIG command
- line.</li>
+ <li>Placing <tt>%module example</tt> in the SWIG interface
+ file.</li>
+ <li>Using <tt>-module example</tt> on the SWIG command
+ line.</li>
</ul>
<p>
<p>
CHICKEN will be able to access the module using the <code>(declare
- (uses <i>modulename</i>))</code> CHICKEN Scheme form.
+ (uses <i>modulename</i>))</code> CHICKEN Scheme form.
</p>
-<H3><a name="Chicken_nn8"></a>20.2.3 Constants and Variables</H3>
+<H3><a name="Chicken_nn8">21.2.3 Constants and Variables</a></H3>
<p>
the interface file:
</p>
<ol>
- <li><code>#define MYCONSTANT1 ...</code></li>
- <li><code>%constant int MYCONSTANT2 = ...</code></li>
- <li><code>const int MYCONSTANT3 = ...</code></li>
- <li><code>enum { MYCONSTANT4 = ... };</code></li>
+ <li><code>#define MYCONSTANT1 ...</code></li>
+ <li><code>%constant int MYCONSTANT2 = ...</code></li>
+ <li><code>const int MYCONSTANT3 = ...</code></li>
+ <li><code>enum { MYCONSTANT4 = ... };</code></li>
</ol>
<p>
for info on how to apply the %feature.
</p>
-<H3><a name="Chicken_nn9"></a>20.2.4 Functions</H3>
+<H3><a name="Chicken_nn9">21.2.4 Functions</a></H3>
<p>
parameters). The return values can then be accessed with <code>(call-with-values)</code>.
</p>
-<H3><a name="Chicken_nn10"></a>20.2.5 Exceptions</H3>
+<H3><a name="Chicken_nn10">21.2.5 Exceptions</a></H3>
<p>The SWIG chicken module has support for exceptions thrown from
</pre></div>
-<H2><a name="Chicken_nn11"></a>20.3 TinyCLOS</H2>
+<H2><a name="Chicken_nn11">21.3 TinyCLOS</a></H2>
<p>
The author of TinyCLOS, Gregor Kiczales, describes TinyCLOS as:
- "Tiny CLOS is a Scheme implementation of a `kernelized' CLOS, with a
- metaobject protocol. The implementation is even simpler than
- the simple CLOS found in `The Art of the Metaobject Protocol,'
- weighing in at around 850 lines of code, including (some)
- comments and documentation."
+ "Tiny CLOS is a Scheme implementation of a `kernelized' CLOS, with a
+ metaobject protocol. The implementation is even simpler than
+ the simple CLOS found in `The Art of the Metaobject Protocol,'
+ weighing in at around 850 lines of code, including (some)
+ comments and documentation."
</p>
<p>
</p>
-<H2><a name="Chicken_nn12"></a>20.4 Linkage</H2>
+<H2><a name="Chicken_nn12">21.4 Linkage</a></H2>
<p>
</p>
-<H3><a name="Chicken_nn13"></a>20.4.1 Static binary or shared library linked at compile time</H3>
+<H3><a name="Chicken_nn13">21.4.1 Static binary or shared library linked at compile time</a></H3>
<p>We can easily use csc to build a static binary.</p>
be run with <tt>csi</tt>.
</p>
-<H3><a name="Chicken_nn14"></a>20.4.2 Building chicken extension libraries</H3>
+<H3><a name="Chicken_nn14">21.4.2 Building chicken extension libraries</a></H3>
<p>Building a shared library like in the above section only works if the library
<p>See the <tt>Examples/chicken/egg</tt> directory in the SWIG source for an example that builds
two eggs, one using the first method and one using the second method.</p>
-<H3><a name="Chicken_nn15"></a>20.4.3 Linking multiple SWIG modules with TinyCLOS</H3>
+<H3><a name="Chicken_nn15">21.4.3 Linking multiple SWIG modules with TinyCLOS</a></H3>
<p>Linking together multiple modules that share type information using the <code>%import</code>
To create an extension library or an egg, just create a <tt>module_load.scm</tt> file that <code>(declare (uses ...))</code>
all the modules.</p>
-<H2><a name="Chicken_nn16"></a>20.5 Typemaps</H2>
+<H2><a name="Chicken_nn16">21.5 Typemaps</a></H2>
<p>
<code>Lib/chicken/chicken.swg</code>.
</p>
-<H2><a name="Chicken_nn17"></a>20.6 Pointers</H2>
+<H2><a name="Chicken_nn17">21.6 Pointers</a></H2>
<p>
type. flags is either zero or SWIG_POINTER_DISOWN (see below).
</p>
-<H3><a name="Chicken_collection"></a>20.6.1 Garbage collection</H3>
+<H3><a name="Chicken_collection">21.6.1 Garbage collection</a></H3>
<p>If the owner flag passed to <code>SWIG_NewPointerObj</code> is 1, <code>NewPointerObj</code> will add a
must be called manually.
</p>
-<H2><a name="Chicken_nn18"></a>20.7 Unsupported features and known problems</H2>
+<H2><a name="Chicken_nn18">21.7 Unsupported features and known problems</a></H2>
<ul>
<a href="SWIGPlus.html#SWIGPlus_default_args">%feature(compactdefaultargs)</a>.</li>
</ul>
-<H3><a name="Chicken_nn19"></a>20.7.1 TinyCLOS problems with Chicken version <= 1.92</H3>
+<H3><a name="Chicken_nn19">21.7.1 TinyCLOS problems with Chicken version <= 1.92</a></H3>
<p>In Chicken versions equal to or below 1.92, TinyCLOS has a limitation such that generic methods do not properly work on methods
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<HTML>
<HEAD>
<TITLE>SWIG Users Manual</TITLE>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</HEAD>
<BODY BGCOLOR="#ffffff">
+
<H1><a name="Contents"></a>SWIG Users Manual</H1>
<p>
<li><a href="SWIG.html#SWIG_nn10">Basic Type Handling</a>
<li><a href="SWIG.html#SWIG_nn11">Global Variables</a>
<li><a href="SWIG.html#SWIG_nn12">Constants</a>
-<li><a href="SWIG.html#SWIG_nn13">A brief word about <tt>const</tt></a>
-<li><a href="SWIG.html#SWIG_nn14">A cautionary tale of <tt>char *</tt></a>
+<li><a href="SWIG.html#SWIG_nn13">A brief word about const</a>
+<li><a href="SWIG.html#SWIG_nn14">A cautionary tale of char *</a>
</ul>
<li><a href="SWIG.html#SWIG_nn15">Pointers and complex objects</a>
<ul>
<li><a href="SWIG.html#SWIG_nn22">Passing structures by value</a>
<li><a href="SWIG.html#SWIG_nn23">Return by value</a>
<li><a href="SWIG.html#SWIG_nn24">Linking to structure variables</a>
-<li><a href="SWIG.html#SWIG_nn25">Linking to <tt>char *</tt></a>
+<li><a href="SWIG.html#SWIG_nn25">Linking to char *</a>
<li><a href="SWIG.html#SWIG_nn26">Arrays</a>
<li><a href="SWIG.html#SWIG_readonly_variables">Creating read-only variables</a>
<li><a href="SWIG.html#SWIG_rename_ignore">Renaming and ignoring declarations</a>
</div>
<!-- INDEX -->
-<h3><a href="Preprocessor.html#Preprocessor">7 Preprocessing</a></h3>
+<h3><a href="CPlusPlus11.html#CPlusPlus11">7 SWIG and C++11</a></h3>
+
+<!-- INDEX -->
+<div class="sectiontoc">
+<ul>
+<li><a href="CPlusPlus11.html#CPlusPlus11_introduction">Introduction</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_core_language_changes">Core language changes</a>
+<ul>
+<li><a href="CPlusPlus11.html#CPlusPlus11_rvalue_reference_and_move_semantics">Rvalue reference and move semantics</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_generalized_constant_expressions">Generalized constant expressions</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_extern_template">Extern template</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_initializer_lists">Initializer lists</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_uniform_initialization">Uniform initialization</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_type_inference">Type inference</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_range_based_for_loop">Range-based for-loop</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_lambda_functions_and_expressions">Lambda functions and expressions</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_alternate_function_syntax">Alternate function syntax</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_object_construction_improvement">Object construction improvement</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_explicit_overrides_final">Explicit overrides and final</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_null_pointer_constant">Null pointer constant</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_strongly_typed_enumerations">Strongly typed enumerations</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_double_angle_brackets">Double angle brackets</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_explicit_conversion_operators">Explicit conversion operators</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_alias_templates">Alias templates</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_unrestricted_unions">Unrestricted unions</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_variadic_templates">Variadic templates</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_new_string_literals">New string literals</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_user_defined_literals">User-defined literals</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_thread_local_storage">Thread-local storage</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_defaulted_deleted">Explicitly defaulted functions and deleted functions</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_type_long_long_int">Type long long int</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_static_assertions">Static assertions</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_sizeof">Allow sizeof to work on members of classes without an explicit object</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_noexcept">Exception specifications and noexcept</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_alignment">Control and query object alignment</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_attributes">Attributes</a>
+</ul>
+<li><a href="CPlusPlus11.html#CPlusPlus11_standard_library_changes">Standard library changes</a>
+<ul>
+<li><a href="CPlusPlus11.html#CPlusPlus11_threading_facilities">Threading facilities</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_tuple_types">Tuple types</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_hash_tables">Hash tables</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_regular_expressions">Regular expressions</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_general_purpose_smart_pointers">General-purpose smart pointers</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_extensible_random_number_facility">Extensible random number facility</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_wrapper_reference">Wrapper reference</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_polymorphous_wrappers_for_function_objects">Polymorphous wrappers for function objects</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_type_traits_for_metaprogramming">Type traits for metaprogramming</a>
+<li><a href="CPlusPlus11.html#CPlusPlus11_uniform_method_for_computing_return_type_of_function_objects">Uniform method for computing return type of function objects</a>
+</ul>
+</ul>
+</div>
+<!-- INDEX -->
+
+<h3><a href="Preprocessor.html#Preprocessor">8 Preprocessing</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Library.html#Library">8 SWIG library</a></h3>
+<h3><a href="Library.html#Library">9 SWIG library</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<li><a href="Library.html#Library_std_vector">std::vector</a>
<li><a href="Library.html#Library_stl_exceptions">STL exceptions</a>
<li><a href="Library.html#Library_std_shared_ptr">shared_ptr smart pointer</a>
+<li><a href="Library.html#Library_std_auto_ptr">auto_ptr smart pointer</a>
</ul>
<li><a href="Library.html#Library_nn16">Utility Libraries</a>
<ul>
</div>
<!-- INDEX -->
-<h3><a href="Arguments.html#Arguments">9 Argument Handling</a></h3>
+<h3><a href="Arguments.html#Arguments">10 Argument Handling</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Typemaps.html#Typemaps">10 Typemaps</a></h3>
+<h3><a href="Typemaps.html#Typemaps">11 Typemaps</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<li><a href="Typemaps.html#Typemaps_special_macro_descriptor">$descriptor(type)</a>
<li><a href="Typemaps.html#Typemaps_special_macro_typemap">$typemap(method, typepattern)</a>
</ul>
+<li><a href="Typemaps.html#Typemaps_special_variable_attributes">Special variables and typemap attributes</a>
+<li><a href="Typemaps.html#Typemaps_special_variables_and_macros">Special variables combined with special variable macros</a>
</ul>
<li><a href="Typemaps.html#Typemaps_nn25">Common typemap methods</a>
<ul>
<li><a href="Typemaps.html#Typemaps_runtime_type_checker_usage">Usage</a>
</ul>
<li><a href="Typemaps.html#Typemaps_overloading">Typemaps and overloading</a>
-<li><a href="Typemaps.html#Typemaps_nn48">More about <tt>%apply</tt> and <tt>%clear</tt></a>
+<li><a href="Typemaps.html#Typemaps_nn48">More about %apply and %clear</a>
<li><a href="Typemaps.html#Typemaps_nn47">Passing data between typemaps</a>
<li><a href="Typemaps.html#Typemaps_nn52">C++ "this" pointer</a>
<li><a href="Typemaps.html#Typemaps_nn51">Where to go for more information?</a>
</div>
<!-- INDEX -->
-<h3><a href="Customization.html#Customization">11 Customization Features</a></h3>
+<h3><a href="Customization.html#Customization">12 Customization Features</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Contract.html#Contract">12 Contracts</a></h3>
+<h3><a href="Contract.html#Contract">13 Contracts</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Varargs.html#Varargs">13 Variable Length Arguments</a></h3>
+<h3><a href="Varargs.html#Varargs">14 Variable Length Arguments</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Warnings.html#Warnings">14 Warning Messages</a></h3>
+<h3><a href="Warnings.html#Warnings">15 Warning Messages</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Modules.html#Modules">15 Working with Modules</a></h3>
+<h3><a href="Modules.html#Modules">16 Working with Modules</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="CCache.html#CCache">16 Using SWIG with ccache - ccache-swig(1) manpage</a></h3>
+<h3><a href="CCache.html#CCache">17 Using SWIG with ccache - ccache-swig(1) manpage</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Allegrocl.html#Allegrocl">17 SWIG and Allegro Common Lisp</a></h3>
+<h3><a href="Allegrocl.html#Allegrocl">18 SWIG and Allegro Common Lisp</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Android.html#Android">18 SWIG and Android</a></h3>
+<h3><a href="Android.html#Android">19 SWIG and Android</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="CSharp.html#CSharp">19 SWIG and C#</a></h3>
+<h3><a href="CSharp.html#CSharp">20 SWIG and C#</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="CSharp.html#CSharp_introduction">Introduction</a>
+<ul>
+<li><a href="CSharp.html#CSharp_introduction_swig2_compatibility">SWIG 2 Compatibility</a>
+<li><a href="CSharp.html#CSharp_commandline">Additional command line options</a>
+</ul>
<li><a href="CSharp.html#CSharp_differences_java">Differences to the Java module</a>
<li><a href="CSharp.html#CSharp_void_pointers">Void pointers</a>
<li><a href="CSharp.html#CSharp_arrays">C# Arrays</a>
<li><a href="CSharp.html#CSharp_directors_implementation">Directors implementation</a>
<li><a href="CSharp.html#CSharp_director_caveats">Director caveats</a>
</ul>
-<li><a href="CSharp.html#CSharp_multiple_modules">Multiples modules</a>
+<li><a href="CSharp.html#CSharp_multiple_modules">Multiple modules</a>
<li><a href="CSharp.html#CSharp_typemap_examples">C# Typemap examples</a>
<ul>
<li><a href="CSharp.html#CSharp_memory_management_member_variables">Memory management when returning references to member variables</a>
</div>
<!-- INDEX -->
-<h3><a href="Chicken.html#Chicken">20 SWIG and Chicken</a></h3>
+<h3><a href="Chicken.html#Chicken">21 SWIG and Chicken</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="D.html#D">21 SWIG and D</a></h3>
+<h3><a href="D.html#D">22 SWIG and D</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<li><a href="D.html#D_code_injection_typemaps">Code injection typemaps</a>
<li><a href="D.html#D_special_variables">Special variable macros</a>
</ul>
-<li><a href="D.html#D_features"><tt>%feature</tt>s</a>
+<li><a href="D.html#D_features">D and %feature</a>
<li><a href="D.html#D_pragmas">Pragmas</a>
<li><a href="D.html#D_exceptions">D Exceptions</a>
<li><a href="D.html#D_directors">D Directors</a>
<li><a href="D.html#D_other_features">Other features</a>
<ul>
-<li><a href="D.html#D_nspace">Extended namespace support (<tt>nspace</tt>)</a>
+<li><a href="D.html#D_nspace">Extended namespace support (nspace)</a>
<li><a href="D.html#D_native_pointer_support">Native pointer support</a>
<li><a href="D.html#D_operator_overloading">Operator overloading</a>
<li><a href="D.html#D_test_suite">Running the test-suite</a>
</div>
<!-- INDEX -->
-<h3><a href="Go.html#Go">22 SWIG and Go</a></h3>
+<h3><a href="Go.html#Go">23 SWIG and Go</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="Go.html#Go_overview">Overview</a>
+<li><a href="Go.html#Go_examples">Examples</a>
<li><a href="Go.html#Go_running_swig">Running SWIG with Go</a>
<ul>
-<li><a href="Go.html#Go_commandline">Additional Commandline Options</a>
-<li><a href="Go.html#Go_outputs">Go Output Files</a>
+<li><a href="Go.html#Go_commandline">Go-specific Commandline Options</a>
+<li><a href="Go.html#Go_outputs">Generated Wrapper Files</a>
</ul>
<li><a href="Go.html#Go_basic_tour">A tour of basic C/C++ wrapping</a>
<ul>
<li><a href="Go.html#Go_enumerations">Go Enumerations</a>
<li><a href="Go.html#Go_classes">Go Classes</a>
<ul>
+<li><a href="Go.html#Go_class_memory">Go Class Memory Management</a>
<li><a href="Go.html#Go_class_inheritance">Go Class Inheritance</a>
</ul>
<li><a href="Go.html#Go_templates">Go Templates</a>
<li><a href="Go.html#Go_director_classes">Go Director Classes</a>
+<ul>
+<li><a href="Go.html#Go_director_example_cpp_code">Example C++ code</a>
+<li><a href="Go.html#Go_director_enable">Enable director feature</a>
+<li><a href="Go.html#Go_director_ctor_dtor">Constructor and destructor</a>
+<li><a href="Go.html#Go_director_overriding">Override virtual methods</a>
+<li><a href="Go.html#Go_director_base_methods">Call base methods</a>
+<li><a href="Go.html#Go_director_subclass">Subclass via embedding</a>
+<li><a href="Go.html#Go_director_finalizer">Memory management with runtime.SetFinalizer</a>
+<li><a href="Go.html#Go_director_foobargo_class">Complete FooBarGo example class</a>
+</ul>
<li><a href="Go.html#Go_primitive_type_mappings">Default Go primitive type mappings</a>
<li><a href="Go.html#Go_output_arguments">Output arguments</a>
<li><a href="Go.html#Go_adding_additional_code">Adding additional go code</a>
+<li><a href="Go.html#Go_typemaps">Go typemaps</a>
</ul>
</ul>
</div>
<!-- INDEX -->
-<h3><a href="Guile.html#Guile">23 SWIG and Guile</a></h3>
+<h3><a href="Guile.html#Guile">24 SWIG and Guile</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Java.html#Java">24 SWIG and Java</a></h3>
+<h3><a href="Java.html#Java">25 SWIG and Java</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<li><a href="Java.html#Java_namespaces">C++ namespaces</a>
<li><a href="Java.html#Java_templates">C++ templates</a>
<li><a href="Java.html#Java_smart_pointers">C++ Smart Pointers</a>
+<ul>
+<li><a href="Java.html#Java_smart_pointers_shared_ptr">The shared_ptr Smart Pointer</a>
+<li><a href="Java.html#Java_smart_pointers_generic">Generic Smart Pointers</a>
+</ul>
</ul>
<li><a href="Java.html#Java_further_details">Further details on the generated Java classes</a>
<ul>
<li><a href="Java.html#Java_proper_enums_classes">Proper Java enum classes</a>
<li><a href="Java.html#Java_typeunsafe_enums_classes">Type unsafe enum classes</a>
</ul>
+<li><a href="Java.html#Java_interfaces">Interfaces</a>
</ul>
<li><a href="Java.html#Java_directors">Cross language polymorphism using directors</a>
<ul>
<li><a href="Java.html#Java_directors_example">Simple directors example</a>
<li><a href="Java.html#Java_directors_threading">Director threading issues</a>
<li><a href="Java.html#Java_directors_performance">Director performance tuning</a>
+<li><a href="Java.html#Java_exceptions_from_directors">Java exceptions from directors</a>
</ul>
<li><a href="Java.html#Java_allprotected">Accessing protected members</a>
<li><a href="Java.html#Java_common_customization">Common customization features</a>
</div>
<!-- INDEX -->
-<h3><a href="Lisp.html#Lisp">25 SWIG and Common Lisp</a></h3>
+<h3><a href="Javascript.html#Javascript">26 SWIG and Javascript</a></h3>
+
+<!-- INDEX -->
+<div class="sectiontoc">
+<ul>
+<li><a href="Javascript.html#Javascript_overview">Overview</a>
+<li><a href="Javascript.html#Javascript_preliminaries">Preliminaries</a>
+<ul>
+<li><a href="Javascript.html#Javascript_running_swig">Running SWIG</a>
+<li><a href="Javascript.html#Javascript_running_tests_examples">Running Tests and Examples</a>
+<li><a href="Javascript.html#Javascript_known_issues">Known Issues</a>
+</ul>
+<li><a href="Javascript.html#Javascript_integration">Integration</a>
+<ul>
+<li><a href="Javascript.html#Javascript_node_extensions">Creating node.js Extensions</a>
+<ul>
+<li><a href="Javascript.html#Javascript_troubleshooting">Troubleshooting</a>
+</ul>
+<li><a href="Javascript.html#Javascript_embedded_webkit">Embedded Webkit</a>
+<ul>
+<li><a href="Javascript.html#Javascript_osx">Mac OS X</a>
+<li><a href="Javascript.html#Javascript_gtk">GTK</a>
+</ul>
+<li><a href="Javascript.html#Javascript_applications_webkit">Creating Applications with node-webkit</a>
+</ul>
+<li><a href="Javascript.html#Javascript_examples">Examples</a>
+<ul>
+<li><a href="Javascript.html#Javascript_simple_example">Simple</a>
+<li><a href="Javascript.html#Javascript_class_example">Class</a>
+</ul>
+<li><a href="Javascript.html#Javascript_implementation">Implementation</a>
+<ul>
+<li><a href="Javascript.html#Javascript_source_code">Source Code</a>
+<li><a href="Javascript.html#Javascript_code_templates">Code Templates</a>
+<li><a href="Javascript.html#Javascript_emitter">Emitter</a>
+<li><a href="Javascript.html#Javascript_emitter_states">Emitter states</a>
+<li><a href="Javascript.html#Javascript_jsc_exceptions">Handling Exceptions in JavascriptCore</a>
+</ul>
+</ul>
+</div>
+<!-- INDEX -->
+
+<h3><a href="Lisp.html#Lisp">27 SWIG and Common Lisp</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Lua.html#Lua">26 SWIG and Lua</a></h3>
+<h3><a href="Lua.html#Lua">28 SWIG and Lua</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<li><a href="Lua.html#Lua_nn9">Functions</a>
<li><a href="Lua.html#Lua_nn10">Global variables</a>
<li><a href="Lua.html#Lua_nn11">Constants and enums</a>
+<ul>
+<li><a href="Lua.html#Lua_nn13">Constants/enums and classes/structures</a>
+</ul>
<li><a href="Lua.html#Lua_nn12">Pointers</a>
-<li><a href="Lua.html#Lua_nn13">Structures</a>
+<li><a href="Lua.html#Lua_structures">Structures</a>
<li><a href="Lua.html#Lua_nn14">C++ classes</a>
<li><a href="Lua.html#Lua_nn15">C++ inheritance</a>
<li><a href="Lua.html#Lua_nn16">Pointers, references, values, and arrays</a>
<li><a href="Lua.html#Lua_nn21">C++ templates</a>
<li><a href="Lua.html#Lua_nn22">C++ Smart Pointers</a>
<li><a href="Lua.html#Lua_nn23">C++ Exceptions</a>
+<li><a href="Lua.html#Lua_namespaces">Namespaces </a>
+<ul>
+<li><a href="Lua.html#Lua_nn27">Compatibility Note </a>
+<li><a href="Lua.html#Lua_nn29">Names </a>
+<li><a href="Lua.html#Lua_nn30">Inheritance </a>
+</ul>
</ul>
<li><a href="Lua.html#Lua_nn24">Typemaps</a>
<ul>
<li><a href="Lua.html#Lua_nn25">What is a typemap?</a>
<li><a href="Lua.html#Lua_nn26">Using typemaps</a>
-<li><a href="Lua.html#Lua_nn27">Typemaps and arrays</a>
-<li><a href="Lua.html#Lua_nn28">Typemaps and pointer-pointer functions</a>
+<li><a href="Lua.html#Lua_typemap_arrays">Typemaps and arrays</a>
+<li><a href="Lua.html#Lua_typemaps_ptr_ptr_functions">Typemaps and pointer-pointer functions</a>
</ul>
-<li><a href="Lua.html#Lua_nn29">Writing typemaps</a>
+<li><a href="Lua.html#Lua_writing_typemaps">Writing typemaps</a>
<ul>
-<li><a href="Lua.html#Lua_nn30">Typemaps you can write</a>
+<li><a href="Lua.html#Lua_typemaps_write">Typemaps you can write</a>
<li><a href="Lua.html#Lua_nn31">SWIG's Lua-C API</a>
</ul>
<li><a href="Lua.html#Lua_nn32">Customization of your Bindings</a>
</div>
<!-- INDEX -->
-<h3><a href="Modula3.html#Modula3">27 SWIG and Modula-3</a></h3>
+<h3><a href="Modula3.html#Modula3">29 SWIG and Modula-3</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Mzscheme.html#Mzscheme">28 SWIG and MzScheme/Racket</a></h3>
+<h3><a href="Mzscheme.html#Mzscheme">30 SWIG and MzScheme/Racket</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Ocaml.html#Ocaml">29 SWIG and Ocaml</a></h3>
+<h3><a href="Ocaml.html#Ocaml">31 SWIG and Ocaml</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<li><a href="Ocaml.html#Ocaml_nn24">Overriding Methods in Ocaml</a>
<li><a href="Ocaml.html#Ocaml_nn25">Director Usage Example</a>
<li><a href="Ocaml.html#Ocaml_nn26">Creating director objects</a>
-<li><a href="Ocaml.html#Ocaml_nn27">Typemaps for directors, <tt>directorin, directorout, directorargout</tt></a>
-<li><a href="Ocaml.html#Ocaml_nn28"><tt>directorin</tt> typemap</a>
-<li><a href="Ocaml.html#Ocaml_nn29"><tt>directorout</tt> typemap</a>
-<li><a href="Ocaml.html#Ocaml_nn30"><tt>directorargout</tt> typemap</a>
+<li><a href="Ocaml.html#Ocaml_nn27">Typemaps for directors, directorin, directorout, directorargout</a>
+<li><a href="Ocaml.html#Ocaml_nn28">typemap</a>
+<li><a href="Ocaml.html#Ocaml_nn29">directorout typemap</a>
+<li><a href="Ocaml.html#Ocaml_nn30">directorargout typemap</a>
</ul>
<li><a href="Ocaml.html#Ocaml_nn31">Exceptions</a>
</ul>
</div>
<!-- INDEX -->
-<h3><a href="Octave.html#Octave">30 SWIG and Octave</a></h3>
+<h3><a href="Octave.html#Octave">32 SWIG and Octave</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<li><a href="Octave.html#Octave_nn19">Class extension with %extend</a>
<li><a href="Octave.html#Octave_nn20">C++ templates</a>
<li><a href="Octave.html#Octave_nn21">C++ Smart Pointers</a>
+<ul>
+<li><a href="Octave.html#Octave_smart_pointers_shared_ptr">The shared_ptr Smart Pointer</a>
+<li><a href="Octave.html#Octave_smart_pointers_generic">Generic Smart Pointers</a>
+</ul>
<li><a href="Octave.html#Octave_nn22">Directors (calling Octave from C++ code)</a>
<li><a href="Octave.html#Octave_nn23">Threads</a>
<li><a href="Octave.html#Octave_nn24">Memory management</a>
</div>
<!-- INDEX -->
-<h3><a href="Perl5.html#Perl5">31 SWIG and Perl5</a></h3>
+<h3><a href="Perl5.html#Perl5">33 SWIG and Perl5</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<li><a href="Perl5.html#Perl5_nn46">Modifying the proxy methods</a>
</ul>
<li><a href="Perl5.html#Perl5_nn47">Adding additional Perl code</a>
+<li><a href="Perl5.html#Perl5_directors">Cross language polymorphism</a>
+<ul>
+<li><a href="Perl5.html#Perl5_nn48">Enabling directors</a>
+<li><a href="Perl5.html#Perl5_nn49">Director classes</a>
+<li><a href="Perl5.html#Perl5_nn50">Ownership and object destruction</a>
+<li><a href="Perl5.html#Perl5_nn51">Exception unrolling</a>
+<li><a href="Perl5.html#Perl5_nn52">Overhead and code bloat</a>
+<li><a href="Perl5.html#Perl5_nn53">Typemaps</a>
+</ul>
</ul>
</div>
<!-- INDEX -->
-<h3><a href="Php.html#Php">32 SWIG and PHP</a></h3>
+<h3><a href="Php.html#Php">34 SWIG and PHP</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<li><a href="Php.html#Php_nn2_5">Pointers and References</a>
<li><a href="Php.html#Php_nn2_6">Structures and C++ classes</a>
<ul>
-<li><a href="Php.html#Php_nn2_6_1">Using <tt>-noproxy</tt></a>
+<li><a href="Php.html#Php_nn2_6_1">Using -noproxy</a>
<li><a href="Php.html#Php_nn2_6_2">Constructors and Destructors</a>
<li><a href="Php.html#Php_nn2_6_3">Static Member Variables</a>
<li><a href="Php.html#Php_nn2_6_4">Static Member Functions</a>
+<li><a href="Php.html#Php_nn2_6_5">Specifying Implemented Interfaces</a>
</ul>
<li><a href="Php.html#Php_nn2_7">PHP Pragmas, Startup and Shutdown code</a>
</ul>
</div>
<!-- INDEX -->
-<h3><a href="Pike.html#Pike">33 SWIG and Pike</a></h3>
+<h3><a href="Pike.html#Pike">35 SWIG and Pike</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Python.html#Python">34 SWIG and Python</a></h3>
+<h3><a href="Python.html#Python">36 SWIG and Python</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<li><a href="Python.html#Python_nn25">C++ namespaces</a>
<li><a href="Python.html#Python_nn26">C++ templates</a>
<li><a href="Python.html#Python_nn27">C++ Smart Pointers</a>
+<ul>
+<li><a href="Python.html#Python_smart_pointers_shared_ptr">The shared_ptr Smart Pointer</a>
+<li><a href="Python.html#Python_smart_pointers_generic">Generic Smart Pointers</a>
+</ul>
<li><a href="Python.html#Python_nn27a">C++ reference counted objects</a>
</ul>
<li><a href="Python.html#Python_nn28">Further details on the Python class interface</a>
<li><a href="Python.html#Python_nn47">Simple pointers</a>
<li><a href="Python.html#Python_nn48">Unbounded C Arrays</a>
<li><a href="Python.html#Python_nn49">String handling</a>
+<li><a href="Python.html#Python_default_args">Default arguments</a>
</ul>
<li><a href="Python.html#Python_nn53">Typemaps</a>
<ul>
<li><a href="Python.html#Python_nn71">%feature("docstring")</a>
</ul>
<li><a href="Python.html#Python_nn72">Python Packages</a>
+<ul>
+<li><a href="Python.html#Python_modulepackage">Setting the Python package</a>
+<li><a href="Python.html#Python_absrelimports">Absolute and relative imports</a>
+<li><a href="Python.html#Python_absimport">Enforcing absolute import semantics</a>
+<li><a href="Python.html#Python_importfrominit">Importing from __init__.py</a>
+<li><a href="Python.html#Python_implicit_namespace_packages">Implicit Namespace Packages</a>
+<li><a href="Python.html#Python_package_search">Searching for the wrapper module</a>
+<ul>
+<li><a href="Python.html#Python_package_search_both_package_modules">Both modules in the same package</a>
+<li><a href="Python.html#Python_package_search_wrapper_split">Split modules</a>
+<li><a href="Python.html#Python_package_search_both_global_modules">Both modules are global</a>
+<li><a href="Python.html#Python_package_search_static">Statically linked C modules</a>
+</ul>
+</ul>
<li><a href="Python.html#Python_python3support">Python 3 Support</a>
<ul>
<li><a href="Python.html#Python_nn74">Function annotation</a>
<li><a href="Python.html#Python_nn75">Buffer interface</a>
<li><a href="Python.html#Python_nn76">Abstract base classes</a>
+<li><a href="Python.html#Python_nn77">Byte string output conversion</a>
+<li><a href="Python.html#Python_2_unicode">Python 2 Unicode</a>
</ul>
</ul>
</div>
<!-- INDEX -->
-<h3><a href="R.html#R">35 SWIG and R</a></h3>
+<h3><a href="R.html#R">37 SWIG and R</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Ruby.html#Ruby">36 SWIG and Ruby</a></h3>
+<h3><a href="Ruby.html#Ruby">38 SWIG and Ruby</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
<li><a href="Ruby.html#Ruby_C_STL_Functors">C++ STL Functors</a>
<li><a href="Ruby.html#Ruby_C_Iterators">C++ STL Iterators</a>
<li><a href="Ruby.html#Ruby_nn24">C++ Smart Pointers</a>
+<ul>
+<li><a href="Ruby.html#Ruby_smart_pointers_shared_ptr">The shared_ptr Smart Pointer</a>
+<li><a href="Ruby.html#Ruby_smart_pointers_generic">Generic Smart Pointers</a>
+</ul>
<li><a href="Ruby.html#Ruby_nn25">Cross-Language Polymorphism</a>
<ul>
<li><a href="Ruby.html#Ruby_nn26">Exception Unrolling</a>
</div>
<!-- INDEX -->
-<h3><a href="Tcl.html#Tcl">37 SWIG and Tcl</a></h3>
+<h3><a href="Scilab.html#Scilab">39 SWIG and Scilab</a></h3>
+
+<!-- INDEX -->
+<div class="sectiontoc">
+<ul>
+<li><a href="Scilab.html#Scilab_preliminaries">Preliminaries</a>
+<li><a href="Scilab.html#Scilab_running_swig">Running SWIG</a>
+<ul>
+<li><a href="Scilab.html#Scilab_running_swig_generating_module">Generating the module</a>
+<li><a href="Scilab.html#Scilab_running_swig_building_module">Building the module</a>
+<li><a href="Scilab.html#Scilab_running_swig_loading_module">Loading the module</a>
+<li><a href="Scilab.html#Scilab_running_swig_using_module">Using the module</a>
+<li><a href="Scilab.html#Scilab_running_swig_options">Scilab command line options</a>
+</ul>
+<li><a href="Scilab.html#Scilab_wrapping">A basic tour of C/C++ wrapping</a>
+<ul>
+<li><a href="Scilab.html#Scilab_wrapping_overview">Overview</a>
+<li><a href="Scilab.html#Scilab_wrapping_identifiers">Identifiers</a>
+<li><a href="Scilab.html#Scilab_wrapping_functions">Functions</a>
+<ul>
+<li><a href="Scilab.html#Scilab_nn13">Argument passing</a>
+<li><a href="Scilab.html#Scilab_nn14">Multiple output arguments</a>
+</ul>
+<li><a href="Scilab.html#Scilab_wrapping_global_variables">Global variables</a>
+<li><a href="Scilab.html#Scilab_wrapping_constants_and_enums">Constants and enumerations</a>
+<ul>
+<li><a href="Scilab.html#Scilab_wrapping_constants">Constants</a>
+<li><a href="Scilab.html#Scilab_wrapping_enums">Enumerations</a>
+</ul>
+<li><a href="Scilab.html#Scilab_wrapping_pointers">Pointers</a>
+<ul>
+<li><a href="Scilab.html#Scilab_wrapping_pointers_pointer_adresses">Utility functions</a>
+<li><a href="Scilab.html#Scilab_wrapping_pointers_null_pointers">Null pointers:</a>
+</ul>
+<li><a href="Scilab.html#Scilab_wrapping_structs">Structures</a>
+<li><a href="Scilab.html#Scilab_wrapping_cpp_classes">C++ classes</a>
+<li><a href="Scilab.html#Scilab_wrapping_cpp_inheritance">C++ inheritance</a>
+<li><a href="Scilab.html#Scilab_wrapping_cpp_overloading">C++ overloading</a>
+<li><a href="Scilab.html#Scilab_wrapping_pointers_references_values_arrays">Pointers, references, values, and arrays</a>
+<li><a href="Scilab.html#Scilab_wrapping_cpp_templates">C++ templates</a>
+<li><a href="Scilab.html#Scilab_wrapping_cpp_operators">C++ operators</a>
+<li><a href="Scilab.html#Scilab_wrapping_cpp_namespaces">C++ namespaces</a>
+<li><a href="Scilab.html#Scilab_wrapping_cpp_exceptions">C++ exceptions</a>
+<li><a href="Scilab.html#Scilab_wrapping_cpp_stl">C++ STL</a>
+</ul>
+<li><a href="Scilab.html#Scilab_typemaps">Type mappings and libraries</a>
+<ul>
+<li><a href="Scilab.html#Scilab_typemaps_primitive_types">Default primitive type mappings</a>
+<li><a href="Scilab.html#Scilab_typemaps_arrays">Arrays</a>
+<li><a href="Scilab.html#Scilab_typemaps_pointer-to-pointers">Pointer-to-pointers</a>
+<li><a href="Scilab.html#Scilab_typemaps_matrices">Matrices</a>
+<li><a href="Scilab.html#Scilab_typemaps_stl">STL</a>
+</ul>
+<li><a href="Scilab.html#Scilab_module_initialization">Module initialization</a>
+<li><a href="Scilab.html#Scilab_building_modes">Building modes</a>
+<ul>
+<li><a href="Scilab.html#Scilab_building_modes_nobuilder_mode">No-builder mode</a>
+<li><a href="Scilab.html#Scilab_building_modes_builder_mode">Builder mode</a>
+</ul>
+<li><a href="Scilab.html#Scilab_generated_scripts">Generated scripts</a>
+<ul>
+<li><a href="Scilab.html#Scilab_generated_scripts_builder_script">Builder script</a>
+<li><a href="Scilab.html#Scilab_generated_scripts_loader_script">Loader script</a>
+</ul>
+<li><a href="Scilab.html#Scilab_other_resources">Other resources</a>
+</ul>
+</div>
+<!-- INDEX -->
+
+<h3><a href="Tcl.html#Tcl">40 SWIG and Tcl</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
</div>
<!-- INDEX -->
-<h3><a href="Extending.html#Extending">38 Extending SWIG to support new languages</a></h3>
+<h3><a href="Extending.html#Extending">41 Extending SWIG to support new languages</a></h3>
<!-- INDEX -->
<div class="sectiontoc">
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Contract Checking</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Contract"></a>12 Contracts</H1>
+<H1><a name="Contract">13 Contracts</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
generated rather than having the program continue to execute.
</p>
-<H2><a name="Contract_nn2"></a>12.1 The %contract directive</H2>
+<H2><a name="Contract_nn2">13.1 The %contract directive</a></H2>
<p>
</pre>
</div>
-<H2><a name="Contract_nn3"></a>12.2 %contract and classes</H2>
+<H2><a name="Contract_nn3">13.2 %contract and classes</a></H2>
<p>
this means that both the arguments to <tt>Spam::bar</tt> must be positive.
</p>
-<H2><a name="Contract_nn4"></a>12.3 Constant aggregation and %aggregate_check</H2>
+<H2><a name="Contract_nn4">13.3 Constant aggregation and %aggregate_check</a></H2>
<p>
release.
</p>
-<H2><a name="Contract_nn5"></a>12.4 Notes</H2>
+<H2><a name="Contract_nn5">13.4 Notes</a></H2>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Customization Features</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Customization"></a>11 Customization Features</H1>
+<H1><a name="Customization">12 Customization Features</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
customization mechanism known as "features" is described.
</p>
-<H2><a name="Customization_exception"></a>11.1 Exception handling with %exception</H2>
+<H2><a name="Customization_exception">12.1 Exception handling with %exception</a></H2>
<p>
provides the same functionality, but is substantially more flexible.
</p>
-<H3><a name="Customization_nn3"></a>11.1.1 Handling exceptions in C code</H3>
+<H3><a name="Customization_nn3">12.1.1 Handling exceptions in C code</a></H3>
<p>
static int error_status = 0;
void throw_exception(char *msg) {
- strncpy(error_message,msg,256);
- error_status = 1;
+ strncpy(error_message,msg,256);
+ error_status = 1;
}
void clear_exception() {
- error_status = 0;
+ error_status = 0;
}
char *check_exception() {
- if (error_status) return error_message;
- else return NULL;
+ if (error_status)
+ return error_message;
+ else
+ return NULL;
}
</pre></div>
<div class="code"><pre>
double inv(double x) {
- if (x != 0) return 1.0/x;
- else {
- throw_exception("Division by zero");
- return 0;
- }
+ if (x != 0)
+ return 1.0/x;
+ else {
+ throw_exception("Division by zero");
+ return 0;
+ }
}
-
</pre></div>
<p>
<div class="code"><pre>
%exception {
- char *err;
- clear_exception();
- $action
- if ((err = check_exception())) {
- croak(err);
- }
+ char *err;
+ clear_exception();
+ $action
+ if ((err = check_exception())) {
+ croak(err);
+ }
}
</pre></div>
and for Perl it is the <tt>croak</tt> method shown above.
</p>
-<H3><a name="Customization_nn4"></a>11.1.2 Exception handling with longjmp()</H3>
+<H3><a name="Customization_nn4">12.1.2 Exception handling with longjmp()</a></H3>
<p>
<div class="code"><pre>
double inv(double x) {
- if (x) return 1.0/x;
- else throw(DivisionByZero);
+ if (x)
+ return 1.0/x;
+ else
+ throw(DivisionByZero);
}
</pre></div>
%}
%exception {
- try {
- $action
- } catch(RangeError) {
- croak("Range Error");
- } catch(DivisionByZero) {
- croak("Division by zero");
- } catch(OutOfMemory) {
- croak("Out of memory");
- } finally {
- croak("Unknown exception");
- }
+ try {
+ $action
+ } catch(RangeError) {
+ croak("Range Error");
+ } catch(DivisionByZero) {
+ croak("Division by zero");
+ } catch(OutOfMemory) {
+ croak("Out of memory");
+ } finally {
+ croak("Unknown exception");
+ }
}
</pre></div>
modify it to handle nested <tt>try</tt> declarations.
</p>
-<H3><a name="Customization_nn5"></a>11.1.3 Handling C++ exceptions</H3>
+<H3><a name="Customization_nn5">12.1.3 Handling C++ exceptions</a></H3>
<p>
<div class="code"><pre>
%exception {
- try {
- $action
- } catch(RangeError) {
- croak("Range Error");
- } catch(DivisionByZero) {
- croak("Division by zero");
- } catch(OutOfMemory) {
- croak("Out of memory");
- } catch(...) {
- croak("Unknown exception");
- }
+ try {
+ $action
+ } catch(RangeError) {
+ croak("Range Error");
+ } catch(DivisionByZero) {
+ croak("Division by zero");
+ } catch(OutOfMemory) {
+ croak("Out of memory");
+ } catch(...) {
+ croak("Unknown exception");
+ }
}
</pre></div>
</pre>
</div>
-<H3><a name="Customization_allowexcept"></a>11.1.4 Exception handlers for variables</H3>
+<H3><a name="Customization_allowexcept">12.1.4 Exception handlers for variables</a></H3>
<p>
</pre>
</div>
-<H3><a name="Customization_nn6"></a>11.1.5 Defining different exception handlers</H3>
+<H3><a name="Customization_nn6">12.1.5 Defining different exception handlers</a></H3>
<p>
<div class="code"><pre>
%exception {
- ... your exception handler ...
+ ... your exception handler ...
}
/* Define critical operations that can throw exceptions here */
%exception directive is much better.
</p>
-<H3><a name="Customization_exception_special_variables"></a>11.1.6 Special variables for %exception</H3>
+<H3><a name="Customization_exception_special_variables">12.1.6 Special variables for %exception</a></H3>
<p>
</tr>
<tr>
-<td>$parentname</td>
+<td>$parentclassname</td>
<td>The parent class name (if any) for a method.</td>
</tr>
<tr>
-<td>$parentsymname</td>
+<td>$parentclasssymname</td>
<td>The target language parent class name (if any) for a method.</td>
</tr>
</pre></div>
-<H3><a name="Customization_nn7"></a>11.1.7 Using The SWIG exception library</H3>
+<H3><a name="Customization_nn7">12.1.7 Using The SWIG exception library</a></H3>
<p>
The <tt>exception.i</tt> library file provides support for creating
language independent exceptions in your interfaces. To use it, simply
put an "<tt>%include exception.i</tt>" in your interface file. This
-creates a function<tt> SWIG_exception()</tt> that can be used to raise
+provides a function <tt>SWIG_exception()</tt> that can be used to raise
common scripting language exceptions in a portable manner. For example :</p>
<div class="code"><pre>
The <tt>SWIG_exception()</tt> function can also be used in typemaps.
</p>
-<H2><a name="Customization_ownership"></a>11.2 Object ownership and %newobject</H2>
+<H2><a name="Customization_ownership">12.2 Object ownership and %newobject</a></H2>
<p>
The results might not be what you expect.
</p>
-<H2><a name="Customization_features"></a>11.3 Features and the %feature directive</H2>
+<H2><a name="Customization_features">12.3 Features and the %feature directive</a></H2>
<p>
The syntax in the first variation will generate the <tt>{ }</tt> delimiters used whereas the other variations will not.
</p>
-<H3><a name="Customization_feature_attributes"></a>11.3.1 Feature attributes</H3>
+<H3><a name="Customization_feature_attributes">12.3.1 Feature attributes</a></H3>
<p>
Further details can be obtained from the <a href="Java.html#Java_exception_handling">Java exception handling</a> section.
</p>
-<H3><a name="Customization_feature_flags"></a>11.3.2 Feature flags</H3>
+<H3><a name="Customization_feature_flags">12.3.2 Feature flags</a></H3>
<p>
The concept of clearing features is discussed next.
</p>
-<H3><a name="Customization_clearing_features"></a>11.3.3 Clearing features</H3>
+<H3><a name="Customization_clearing_features">12.3.3 Clearing features</a></H3>
<p>
</pre>
</div>
-<H3><a name="Customization_features_default_args"></a>11.3.4 Features and default arguments</H3>
+<H3><a name="Customization_features_default_args">12.3.4 Features and default arguments</a></H3>
<p>
<div class="code">
<pre>
-%feature("except") void hello(int i=0, double d=0.0) { ... }
+%feature("except") hello(int i=0, double d=0.0) { ... }
void hello(int i=0, double d=0.0);
</pre>
</div>
<div class="code">
<pre>
-%feature("except") void hello(int i, double d) { ... }
+%feature("except") hello(int i, double d) { ... }
void hello(int i=0, double d=0.0);
</pre>
</div>
in SWIG-1.3.23 when the approach to wrapping methods with default arguments was changed.
</p>
-<H3><a name="Customization_features_example"></a>11.3.5 Feature example</H3>
+<H3><a name="Customization_features_example">12.3.5 Feature example</a></H3>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and D</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#FFFFFF">
-<H1><a name="D"></a>21 SWIG and D</H1>
+<H1><a name="D">22 SWIG and D</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#D_code_injection_typemaps">Code injection typemaps</a>
<li><a href="#D_special_variables">Special variable macros</a>
</ul>
-<li><a href="#D_features"><tt>%feature</tt>s</a>
+<li><a href="#D_features">D and %feature</a>
<li><a href="#D_pragmas">Pragmas</a>
<li><a href="#D_exceptions">D Exceptions</a>
<li><a href="#D_directors">D Directors</a>
<li><a href="#D_other_features">Other features</a>
<ul>
-<li><a href="#D_nspace">Extended namespace support (<tt>nspace</tt>)</a>
+<li><a href="#D_nspace">Extended namespace support (nspace)</a>
<li><a href="#D_native_pointer_support">Native pointer support</a>
<li><a href="#D_operator_overloading">Operator overloading</a>
<li><a href="#D_test_suite">Running the test-suite</a>
-<H2><a name="D_introduction"></a>21.1 Introduction</H2>
+<H2><a name="D_introduction">22.1 Introduction</a></H2>
<p>From the <a href="http://www.digitalmars.com/d/">D Programming Language</a> web site: <em>D is a systems programming language. Its focus is on combining the power and high performance of C and C++ with the programmer productivity of modern languages like Ruby and Python. [...] The D language is statically typed and compiles directly to machine code.</em> As such, it is not very surprising that D is able to directly <a href="http://www.digitalmars.com/d/1.0/interfaceToC.html">interface with C libraries</a>. Why would a SWIG module for D be needed then in the first place?</p>
<p>While these issues can be worked around relatively easy by hand-coding a thin wrapper layer around the C library in question, there is another issue where writing wrapper code per hand is not feasible: C++ libraries. D did not support interfacing to C++ in version 1 at all, and even if <tt>extern(C++)</tt> has been added to D2, the support is still very limited, and a custom wrapper layer is still required in many cases. </p>
-<p>To help addressing these issues, the SWIG C# module has been forked to support D. Is has evolved quite a lot since then, but there are still many similarities, so if you do not find what you are looking for on this page, it might be worth having a look at the chapter on <a href="CSharp.html">C#</a> (and also on <a href="Java.html">Java</a>, since the C# module was in turn forked from it).</p>
+<p>To help addressing these issues, the SWIG C# module has been forked to support D. Is has evolved quite a lot since then, but there are still many similarities, so if you do not find what you are looking for on this page, it might be worth having a look at the chapter on <a href="CSharp.html#CSharp">C#</a> (and also on <a href="Java.html#Java">Java</a>, since the C# module was in turn forked from it).</p>
-<H2><a name="D_command_line_invocation"></a>21.2 Command line invocation</H2>
+<H2><a name="D_command_line_invocation">22.2 Command line invocation</a></H2>
<p>To activate the D module, pass the <tt>-d</tt> option to SWIG at the command line. The same standard command line switches as with any other language module are available, plus the following D specific ones:</p>
<p>By default, SWIG generates code for D1/Tango. Use the <tt>-d2</tt> flag to target D2/Phobos instead.</p>
</dd>
- <dt id="D_splitproxy"><tt>-splitproxy</tt></dt>
+ <dt><a name="D_splitproxy"></a><tt>-splitproxy</tt></dt>
<dd>
<p>By default, SWIG generates two D modules: the <em>proxy</em> module, named like the source module (either specified via the <tt>%module</tt> directive or via the <tt>module</tt> command line switch), which contains all the proxy classes, functions, enums, etc., and the <em>intermediary</em> module (named like the proxy module, but suffixed with <tt>_im</tt>), which contains all the <tt>extern(C)</tt> function declarations and other private parts only used internally by the proxy module.</p>
<p>If the split proxy mode is enabled by passing this switch at the command line, all proxy classes and enums are emitted to their own D module instead. The main proxy module only contains free functions and constants in this case.</p>
</dl>
-<H2><a name="D_typemaps"></a>21.3 Typemaps</H2>
+<H2><a name="D_typemaps">22.3 Typemaps</a></H2>
-<H3><a name="D_typemap_name_comparison"></a>21.3.1 C# <-> D name comparison</H3>
+<H3><a name="D_typemap_name_comparison">22.3.1 C# <-> D name comparison</a></H3>
<p>If you already know the SWIG C# module, you might find the following name comparison table useful:</p>
</pre></div>
-<H3><a name="D_ctype_imtype_dtype"></a>21.3.2 ctype, imtype, dtype</H3>
+<H3><a name="D_ctype_imtype_dtype">22.3.2 ctype, imtype, dtype</a></H3>
<p>Mapping of types between the C/C++ library, the C/C++ library wrapper exposing the C functions, the D wrapper module importing these functions and the D proxy code.</p>
<p>The <tt>ctype</tt> typemap is used to determine the types to use in the C wrapper functions. The types from the <tt>imtype</tt> typemap are used in the extern(C) declarations of these functions in the intermediary D module. The <tt>dtype</tt> typemap contains the D types used in the D proxy module/class.</p>
-<H3><a name="D_in_out_directorin_direcetorout"></a>21.3.3 in, out, directorin, directorout</H3>
+<H3><a name="D_in_out_directorin_direcetorout">22.3.3 in, out, directorin, directorout</a></H3>
<p>Used for converting between the types for C/C++ and D when generating the code for the wrapper functions (on the C++ side).</p>
-<p>The code from the <tt>in</tt> typemap is used to convert arguments to the C wrapper function to the type used in the wrapped code (<tt>ctype</tt>->original C++ type), the <tt>out</tt> typemap is utilized to convert values from the wrapped code to wrapper function return types (original C++ type-><tt>ctype</tt>).</p>
+<p>The code from the <tt>in</tt> typemap is used to convert arguments to the C wrapper function to the type used in the wrapped code (<tt>ctype</tt>->original C++ type), the <tt>out</tt> typemap is utilized to convert values from the wrapped code to wrapper function return types (original C++ type-><tt>ctype</tt>).</p>
<p>The <tt>directorin</tt> typemap is used to convert parameters to the type used in the D director callback function, its return value is processed by <tt>directorout</tt> (see below).</p>
-<H3><a name="D_din_dout_ddirectorin_ddirectorout"></a>21.3.4 din, dout, ddirectorin, ddirectorout</H3>
+<H3><a name="D_din_dout_ddirectorin_ddirectorout">22.3.4 din, dout, ddirectorin, ddirectorout</a></H3>
<p>Typemaps for code generation in D proxy and type wrapper classes.</p>
-<p
id="D_din">The <tt>din</tt> typemap is used for converting function parameter types from the type used in the proxy module or class to the type used in the intermediary D module (the <a href="D.html#D_dinput"><tt>$dinput</tt></a> macro is replaced). To inject further parameter processing code before or after the call to the intermediary layer, the <tt>pre</tt>, <tt>post</tt> and <tt>terminator</tt> attributes can be used (please refer to the <a href="CSharp.html#CSharp_date_marshalling">C# date marshalling example</a> for more information on these).</p>
+<p
><a name="D_din"></a>The <tt>din</tt> typemap is used for converting function parameter types from the type used in the proxy module or class to the type used in the intermediary D module (the <a href="D.html#D_dinput">$dinput</a> macro is replaced). To inject further parameter processing code before or after the call to the intermediary layer, the <tt>pre</tt>, <tt>post</tt> and <tt>terminator</tt> attributes can be used (please refer to the <a href="CSharp.html#CSharp_date_marshalling">C# date marshalling example</a> for more information on these).</p>
-<p
id="D_dout">The <tt>dout</tt> typemap is used for converting function return values from the return type used in the intermediary D module to the type returned by the proxy function. The <tt>$excode</tt> special variable in <tt>dout</tt> typemaps is replaced by the <tt>excode</tt> typemap attribute code if the method can throw any exceptions from unmanaged code, otherwise by nothing (the <a href="D.html#D_imcall"><tt>$imcall</tt> and <tt>$owner</tt></a> macros are replaced).</p>
+<p
><a name="D_dout"></a>The <tt>dout</tt> typemap is used for converting function return values from the return type used in the intermediary D module to the type returned by the proxy function. The <tt>$excode</tt> special variable in <tt>dout</tt> typemaps is replaced by the <tt>excode</tt> typemap attribute code if the method can throw any exceptions from unmanaged code, otherwise by nothing (the <a href="D.html#D_imcall"><tt>$imcall</tt> and <tt>$owner</tt></a> macros are replaced).</p>
-<p
id="D_ddirectorinout">The code from the <tt>ddirectorin</tt> and <tt>ddirectorout</tt> typemaps is used for conversion in director callback functions. Arguments are converted to the type used in the proxy class method they are calling by using the code from <tt>ddirectorin</tt>, the proxy class method return value is converted to the type the C++ code expects via the <tt>ddirectorout</tt> typemap (the <a href="D.html#D_dpcall"><tt>$dcall</tt> and <tt>$winput</tt></a> macros are replaced).</p>
+<p
><a name="D_ddirectorinout"></a>The code from the <tt>ddirectorin</tt> and <tt>ddirectorout</tt> typemaps is used for conversion in director callback functions. Arguments are converted to the type used in the proxy class method they are calling by using the code from <tt>ddirectorin</tt>, the proxy class method return value is converted to the type the C++ code expects via the <tt>ddirectorout</tt> typemap (the <a href="D.html#D_dpcall"><tt>$dcall</tt> and <tt>$winput</tt></a> macros are replaced).</p>
<p>The full chain of type conversions when a director callback is invoked looks like this:</p>
dtype DClass.method(dtype a)</pre></div>
-<H3><a name="D_typecheck_typemaps"></a>21.3.5 typecheck typemaps</H3>
+<H3><a name="D_typecheck_typemaps">22.3.5 typecheck typemaps</a></H3>
<p>Because, unlike many scripting languages supported by SWIG, D does not need any dynamic dispatch helper to access an overloaded function, the purpose of these is merely to issue a warning for overloaded C++ functions that cannot be overloaded in D (as more than one C++ type maps to a single D type).</p>
-<H3><a name="D_code_injection_typemaps"></a>21.3.6 Code injection typemaps</H3>
+<H3><a name="D_code_injection_typemaps">22.3.6 Code injection typemaps</a></H3>
<p>These typemaps are used for generating the skeleton of proxy classes for C++ types.</p>
<p>Using <tt>dcode</tt> and <tt>dimports</tt>, you can specify additional D code which will be emitted into the class body respectively the imports section of the D module the class is written to.</p>
-<p id="D_class_code_typemaps"><tt>dconstructor</tt>, <tt>ddestructor</tt>, <tt>ddispose</tt> and <tt>ddispose_derived</tt> are used to generate the class constructor, destructor and <tt>dispose()</tt> method, respectively. The auxiliary code for handling the pointer to the C++ object is stored in <tt>dbody</tt> and <tt>dbody_derived</tt>. You can override them for specific types.</p>
+<p><a name="D_class_code_typemaps"></a><tt>dconstructor</tt>, <tt>ddestructor</tt>, <tt>ddispose</tt> and <tt>ddispose_derived</tt> are used to generate the class constructor, destructor and <tt>dispose()</tt> method, respectively. The auxiliary code for handling the pointer to the C++ object is stored in <tt>dbody</tt> and <tt>dbody_derived</tt>. You can override them for specific types.</p>
-<H3><a name="D_special_variables"></a>21.3.7 Special variable macros</H3>
+<H3><a name="D_special_variables">22.3.7 Special variable macros</a></H3>
<p>The standard SWIG special variables are available for use within typemaps as described in the <a href="Typemaps.html#Typemaps">Typemaps documentation</a>, for example <tt>$1</tt>, <tt>$input</tt>, <tt>$result</tt> etc.</p>
<dt><tt>$null</tt></dt>
<dd><p>In code inserted into the generated C/C++ wrapper functions, this variable is replaced by either <tt>0</tt> or nothing at all, depending on whether the function has a return value or not. It can be used to bail out early e.g. in case of errors (<tt>return $null;</tt>).</p></dd>
- <dt id="D_dinput"><tt>$dinput</tt> (C#: <tt>$csinput</tt>)</dt>
+ <dt><a name="D_dinput"></a><tt>$dinput</tt> (C#: <tt>$csinput</tt>)</dt>
<dd>
<p>This variable is used in <tt><a href="D.html#D_din">din</a></tt> typemaps and is replaced by the expression which is to be passed to C/C++.</p>
<p>For example, this input</p>
example_im.foo(SomeClass.getCPointer(arg));
}</pre></div></dd>
- <dt id="D_imcall"><tt>$imcall</tt> and <tt>$owner</tt> (C#: <tt>$imcall</tt>)</dt>
+ <dt><a name="D_imcall"></a><tt>$imcall</tt> and <tt>$owner</tt> (C#: <tt>$imcall</tt>)</dt>
<dd>
<p>These variables are used in <tt><a href="D.html#D_dout">dout</a></tt> typemaps. <tt>$imcall</tt> contains the call to the intermediary module which provides the value to be used, and <tt>$owner</tt> signals if the caller is responsible for managing the object lifetime (that is, if the called method is a constructor or has been marked via <tt>%newobject</tt>).</p>
<p>Consider the following example:</p>
</dd>
<dt><tt>$dcall</tt> and <tt>$winput</tt> (C#: <tt>$cscall</tt>, <tt>$iminput</tt>)</dt>
- <dd
id="D_dpcall"><p>These variables are used in the director-specific typemaps <a href="D.html#D_ddirectorinout"><tt>ddirectorin</tt></a> and <a href="D.html#D_ddirectorinout"><tt>ddirectorout</tt></a>. They are more or less the reverse of the <tt>$imcall</tt> and <tt>$dinput</tt> macros: <tt>$dcall</tt> contains the invocation of the D proxy method of which the return value is to be passed back to C++, <tt>$winput</tt> contains the parameter value from C++.</p></dd>
+ <dd
><a name="D_dpcall"></a><p>These variables are used in the director-specific typemaps <a href="D.html#D_ddirectorinout"><tt>ddirectorin</tt></a> and <a href="D.html#D_ddirectorinout"><tt>ddirectorout</tt></a>. They are more or less the reverse of the <tt>$imcall</tt> and <tt>$dinput</tt> macros: <tt>$dcall</tt> contains the invocation of the D proxy method of which the return value is to be passed back to C++, <tt>$winput</tt> contains the parameter value from C++.</p></dd>
<dt><tt>$excode</tt></dt>
<dd><p>This variable is used in <tt>dout</tt> and <tt>dconstructor</tt> typemaps and is filled with the contents of the <tt>excode</tt> typemap attribute if an exception could be thrown from the C++ side. See the <a href="CSharp.html#CSharp_exceptions">C# documentation</a> for details.</p></dd>
</pre></div>
</dd>
- <dt id="D_importtype"><tt>$importtype(SomeDType)</tt></dt>
+ <dt><a name="D_importtype"></a><tt>$importtype(SomeDType)</tt></dt>
<dd>
<p>This macro is used in the <tt>dimports</tt> typemap if a dependency on another D type generated by SWIG is added by a custom typemap.</p>
<p>Consider the following code snippet:</p>
</dl>
-<H2><a name="D_features"></a>21.4 <tt>%feature</tt>s</H2>
+<H2><a name="D_features">22.4 D and %feature</a></H2>
<p>The D module defines a number of directives which modify the <a href="Customization.html#Customization_features">SWIG features</a> set globally or for a specific declaration:</p>
</dl>
-<H2><a name="D_pragmas"></a>21.5 Pragmas</H2>
+<H2><a name="D_pragmas">22.5 Pragmas</a></H2>
<p>There are a few SWIG pragmas specific to the D module, which you can use to influence the D code SWIG generates:</p>
</dl>
-<H2><a name="D_exceptions"></a>21.6 D Exceptions</H2>
+<H2><a name="D_exceptions">22.6 D Exceptions</a></H2>
<p>Out of the box, C++ exceptions are fundamentally incompatible to their equivalent in the D world and cannot simply be propagated to a calling D method. There is, however, an easy way to solve this problem: Just catch the exception in the C/C++ wrapper layer, pass the contents to D, and make the wrapper code rethrow the exception in the D world.</p>
<p>As this feature is implemented in exactly the same way it is for C#, please see the <a href="CSharp.html#CSharp_exceptions">C# documentation</a> for a more detailed explanation.</p>
-<H2><a name="D_directors"></a>21.7 D Directors</H2>
+<H2><a name="D_directors">22.7 D Directors</a></H2>
<p>When the directors feature is activated, SWIG generates extra code on both the C++ and the D side to enable cross-language polymorphism. Essentially, this means that if you subclass a proxy class in D, C++ code can access any overridden virtual methods just as if you created a derived class in C++.</p>
</p>
-<H2><a name="D_other_features"></a>21.8 Other features</H2>
+<H2><a name="D_other_features">22.8 Other features</a></H2>
-<H3><a name="D_nspace"></a>21.8.1 Extended namespace support (<tt>nspace</tt>)</H3>
+<H3><a name="D_nspace">22.8.1 Extended namespace support (nspace)</a></H3>
<p>By default, SWIG flattens all C++ namespaces into a single target language namespace, but as for Java and C#, the <a href="SWIGPlus.html#SWIGPlus_nspace"><tt>nspace</tt></a> feature is supported for D. If it is active, C++ namespaces are mapped to D packages/modules. Note, however, that like for the other languages, <em>free</em> variables and functions are not supported yet; currently, they are all allows written to the main proxy D module.</p>
-<H3><a name="D_native_pointer_support"></a>21.8.2 Native pointer support</H3>
+<H3><a name="D_native_pointer_support">22.8.2 Native pointer support</a></H3>
<p>Contrary to many of the scripting languages supported by SWIG, D fully supports C-style pointers. The D module thus includes a custom mechanism to wrap C pointers directly as D pointers where applicable, that is, if the type that is pointed to is represented the same in C and D (on the bit-level), dubbed a <em>primitive type</em> below.</p>
<p>To determine if a type should be considered primitive, the <tt>cprimitive</tt> attribute on its <tt>dtype</tt> attribute is used. For example, the <tt>dtype</tt> typemap for <tt>float</tt> has <tt>cprimitive="1"</tt>, so the code from the <tt>nativepointer</tt> attribute is taken into account e.g. for <tt>float **</tt> or the function pointer <tt>float (*)(float *)</tt>.</p>
-<H3><a name="D_operator_overloading"></a>21.8.3 Operator overloading</H3>
+<H3><a name="D_operator_overloading">22.8.3 Operator overloading</a></H3>
<p>The D module comes with basic operator overloading support for both D1 and D2. There are, however, a few limitations arising from conceptual differences between C++ and D:</p>
<p>There are also some cases where the operators can be translated to D, but the differences in the implementation details are big enough that a rather involved scheme would be required for automatic wrapping them, which has not been implemented yet. This affects, for example, the array subscript operator, <tt>[]</tt>, in combination with assignments - while <tt>operator []</tt> in C++ simply returns a reference which is then written to, D resorts to a separate <tt>opIndexAssign</tt> method -, or implicit casting (which was introduced in D2 via <tt>alias this</tt>). Despite the lack of automatic support, manually handling these cases should be perfectly possible.</p>
-<H3><a name="D_test_suite"></a>21.8.4 Running the test-suite</H3>
+<H3><a name="D_test_suite">22.8.4 Running the test-suite</a></H3>
<p>As with any other language, the SWIG test-suite can be built for D using the <tt>*-d-test-suite</tt> targets of the top-level Makefile. By default, D1 is targeted, to build it with D2, use the optional <tt>D_VERSION</tt> variable, e.g. <tt>make check-d-test-suite D_VERSION=2</tt>.</p>
<p>Note: If you want to use GDC on Linux or another platform which requires you to link <tt>libdl</tt> for dynamically loading the shared library, you might have to add <tt>-ldl</tt> manually to the <tt>d_compile</tt> target in <tt>Examples/Makefile</tt>, because GDC does not currently honor the <tt>pragma(lib,...)</tt> statement.</p>
-<H2><a name="D_typemap_examples"></a>21.9 D Typemap examples</H2>
+<H2><a name="D_typemap_examples">22.9 D Typemap examples</a></H2>
<p>There are no D-specific typemap examples yet. However, with the above <a href="D.html#D_typemap_name_comparison">name comparison table</a>, you should be able to get an idea what can be done by looking at the <a href="CSharp.html#CSharp_typemap_examples">corresponding C# section</a>.</p>
-<H2><a name="D_planned_features"></a>21.10 Work in progress and planned features</H2>
+<H2><a name="D_planned_features">22.10 Work in progress and planned features</a></H2>
<p>There are a couple of features which are not implemented yet, but would be very useful and might be added in the near future:</p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Extending SWIG to support new languages</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Extending"></a>38 Extending SWIG to support new languages</H1>
+<H1><a name="Extending">41 Extending SWIG to support new languages</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
-<H2><a name="Extending_nn2"></a>38.1 Introduction</H2>
+<H2><a name="Extending_nn2">41.1 Introduction</a></H2>
<p>
you should probably look at one of SWIG's existing modules.
</p>
-<H2><a name="Extending_nn3"></a>38.2 Prerequisites</H2>
+<H2><a name="Extending_nn3">41.2 Prerequisites</a></H2>
<p>
wrapper code are driven by C++ datatypes.
</p>
-<H2><a name="Extending_nn4"></a>38.3 The Big Picture</H2>
+<H2><a name="Extending_nn4">41.3 The Big Picture</a></H2>
<p>
based on pattern matching and interact heavily with the underlying type system.
</p>
-<H2><a name="Extending_nn5"></a>38.4 Execution Model</H2>
+<H2><a name="Extending_nn5">41.4 Execution Model</a></H2>
<p>
The next few sections briefly describe some of these stages.
</p>
-<H3><a name="Extending_nn6"></a>38.4.1 Preprocessing</H3>
+<H3><a name="Extending_nn6">41.4.1 Preprocessing</a></H3>
<p>
construction of the wrapper code.
</p>
-<H3><a name="Extending_nn7"></a>38.4.2 Parsing</H3>
+<H3><a name="Extending_nn7">41.4.2 Parsing</a></H3>
<p>
arguments).
</p>
-<H3><a name="Extending_nn8"></a>38.4.3 Parse Trees</H3>
+<H3><a name="Extending_nn8">41.4.3 Parse Trees</a></H3>
<p>
</pre>
</div>
-<H3><a name="Extending_nn9"></a>38.4.4 Attribute namespaces</H3>
+<H3><a name="Extending_nn9">41.4.4 Attribute namespaces</a></H3>
<p>
<tt>perl:foo</tt>.
</p>
-<H3><a name="Extending_nn10"></a>38.4.5 Symbol Tables</H3>
+<H3><a name="Extending_nn10">41.4.5 Symbol Tables</a></H3>
<p>
</pre>
</div>
-<H3><a name="Extending_nn11"></a>38.4.6 The %feature directive</H3>
+<H3><a name="Extending_nn11">41.4.6 The %feature directive</a></H3>
<p>
stored without any modifications.
</p>
-<H3><a name="Extending_nn12"></a>38.4.7 Code Generation</H3>
+<H3><a name="Extending_nn12">41.4.7 Code Generation</a></H3>
<p>
The role of these functions is described shortly.
</p>
-<H3><a name="Extending_nn13"></a>38.4.8 SWIG and XML</H3>
+<H3><a name="Extending_nn13">41.4.8 SWIG and XML</a></H3>
<p>
your mind as a model.
</p>
-<H2><a name="Extending_nn14"></a>38.5 Primitive Data Structures</H2>
+<H2><a name="Extending_nn14">41.5 Primitive Data Structures</a></H2>
<p>
</pre>
</div>
-<H3><a name="Extending_nn15"></a>38.5.1 Strings</H3>
+<H3><a name="Extending_nn15">41.5.1 Strings</a></H3>
<p>
</div>
-<H3><a name="Extending_nn16"></a>38.5.2 Hashes</H3>
+<H3><a name="Extending_nn16">41.5.2 Hashes</a></H3>
<p>
</div>
-<H3><a name="Extending_nn17"></a>38.5.3 Lists</H3>
+<H3><a name="Extending_nn17">41.5.3 Lists</a></H3>
<p>
and is used to create a String object.
</div>
-<H3><a name="Extending_nn18"></a>38.5.4 Common operations</H3>
+<H3><a name="Extending_nn18">41.5.4 Common operations</a></H3>
The following operations are applicable to all datatypes.
Gets the line number associated with <tt>x</tt>.
</div>
-<H3><a name="Extending_nn19"></a>38.5.5 Iterating over Lists and Hashes</H3>
+<H3><a name="Extending_nn19">41.5.5 Iterating over Lists and Hashes</a></H3>
To iterate over the elements of a list or a hash table, the following functions are used:
</div>
-<H3><a name="Extending_nn20"></a>38.5.6 I/O</H3>
+<H3><a name="Extending_nn20">41.5.6 I/O</a></H3>
Special I/O functions are used for all internal I/O. These operations
</div>
<p>
-<b><tt>int Close(String_or_FILE *f)</tt></b>
+There's no explicit function to close a file, just call <tt>Delete(f)</tt> -
+this decreases the reference count, and the file will be closed when the
+reference count reaches zero.
</p>
-<div class="indent">
-<p>Closes a file. Has no effect on strings.</p>
-
<p>
The use of the above I/O functions and strings play a critical role in SWIG. It is
common to see small code fragments of code generated using code like this:
Similarly, the preprocessor and parser all operate on string-files.
</p>
-</div>
-
-<H2><a name="Extending_nn21"></a>38.6 Navigating and manipulating parse trees</H2>
+<H2><a name="Extending_nn21">41.6 Navigating and manipulating parse trees</a></H2>
Parse trees are built as collections of hash tables. Each node is a hash table in which
the parent so that sibling nodes are unaffected.
</div>
-<H2><a name="Extending_nn22"></a>38.7 Working with attributes</H2>
+<H2><a name="Extending_nn22">41.7 Working with attributes</a></H2>
<p>
function.
</div>
-<H2><a name="Extending_nn23"></a>38.8 Type system</H2>
+<H2><a name="Extending_nn23">41.8 Type system</a></H2>
<p>
type theory is impossible here. However, let's cover the highlights.
</p>
-<H3><a name="Extending_nn24"></a>38.8.1 String encoding of types</H3>
+<H3><a name="Extending_nn24">41.8.1 String encoding of types</a></H3>
<p>
string concatenation.
</p>
-<H3><a name="Extending_nn25"></a>38.8.2 Type construction</H3>
+<H3><a name="Extending_nn25">41.8.2 Type construction</a></H3>
<p>
<tt>ty</tt> is unmodified.
</div>
-<H3><a name="Extending_nn26"></a>38.8.3 Type tests</H3>
+<H3><a name="Extending_nn26">41.8.3 Type tests</a></H3>
<p>
Checks if <tt>ty</tt> is a templatized type.
</div>
-<H3><a name="Extending_nn27"></a>38.8.4 Typedef and inheritance</H3>
+<H3><a name="Extending_nn27">41.8.4 Typedef and inheritance</a></H3>
<p>
will consist only of primitive typenames.
</div>
-<H3><a name="Extending_nn28"></a>38.8.5 Lvalues</H3>
+<H3><a name="Extending_nn28">41.8.5 Lvalues</a></H3>
<p>
</pre>
</div>
-<H3><a name="Extending_nn29"></a>38.8.6 Output functions</H3>
+<H3><a name="Extending_nn29">41.8.6 Output functions</a></H3>
<p>
that appear in wrappers (e.g., <tt>SWIGTYPE_p_double</tt>).
</div>
-<H2><a name="Extending_nn30"></a>38.9 Parameters</H2>
+<H2><a name="Extending_nn30">41.9 Parameters</a></H2>
<p>
Returns the number of required (non-optional) arguments in <tt>p</tt>.
</div>
-<H2><a name="Extending_nn31"></a>38.10 Writing a Language Module</H2>
+<H2><a name="Extending_nn31">41.10 Writing a Language Module</a></H2>
<p>
this to other languages.
</p>
-<H3><a name="Extending_nn32"></a>38.10.1 Execution model</H3>
+<H3><a name="Extending_nn32">41.10.1 Execution model</a></H3>
<p>
different methods of the <tt>Language</tt> that must be defined by your module.
</p>
-<H3><a name="Extending_starting_out"></a>38.10.2 Starting out</H3>
+<H3><a name="Extending_starting_out">41.10.2 Starting out</a></H3>
<p>
messages from your new module should appear.
</p>
-<H3><a name="Extending_nn34"></a>38.10.3 Command line options</H3>
+<H3><a name="Extending_nn34">41.10.3 Command line options</a></H3>
<p>
unrecognized command line option error.
</p>
-<H3><a name="Extending_nn35"></a>38.10.4 Configuration and preprocessing</H3>
+<H3><a name="Extending_nn35">41.10.4 Configuration and preprocessing</a></H3>
<p>
<tt>python.swg</tt>.
</p>
-<H3><a name="Extending_nn36"></a>38.10.5 Entry point to code generation</H3>
+<H3><a name="Extending_nn36">41.10.5 Entry point to code generation</a></H3>
<p>
</pre>
</div>
-<H3><a name="Extending_nn37"></a>38.10.6 Module I/O and wrapper skeleton</H3>
+<H3><a name="Extending_nn37">41.10.6 Module I/O and wrapper skeleton</a></H3>
<!-- please report bugs in this section to mgossage -->
<li>begin: This section is a placeholder for users to put code at the beginning of the C/C++ wrapper file.
<li>runtime: This section has most of the common SWIG runtime code.
<li>header: This section holds declarations and inclusions from the .i file.
-<li>wrapper: This section holds all the wrappering code.
-<li>init: This section holds the module initalisation function
+<li>wrapper: This section holds all the wrapper code.
+<li>init: This section holds the module initialisation function
(the entry point for the interpreter).
</ul>
<p>
Delete(f_header);
Delete(f_wrappers);
Delete(f_init);
- Close(f_begin);
Delete(f_begin);
return SWIG_OK;
</pre>
</div>
-<H3><a name="Extending_nn38"></a>38.10.7 Low-level code generators</H3>
+<H3><a name="Extending_nn38">41.10.7 Low-level code generators</a></H3>
<!-- please report bugs in this section to mgossage -->
/* write typemaps(in) */
....
- /* write constriants */
+ /* write constraints */
....
/* Emit the function call */
</p>
-<H3><a name="Extending_configuration_files"></a>38.10.8 Configuration files</H3>
+<H3><a name="Extending_configuration_files">41.10.8 Configuration files</a></H3>
<!-- please report bugs in this section to ttn -->
</dl>
-<H3><a name="Extending_nn40"></a>38.10.9 Runtime support</H3>
+<H3><a name="Extending_nn40">41.10.9 Runtime support</a></H3>
<p>
the SWIG files that implement those functions.
</p>
-<H3><a name="Extending_nn41"></a>38.10.10 Standard library files</H3>
+<H3><a name="Extending_nn41">41.10.10 Standard library files</a></H3>
<p>
Please copy these and modify for any new language.
</p>
-<H3><a name="Extending_nn42"></a>38.10.11 User examples</H3>
+<H3><a name="Extending_nn42">41.10.11 User examples</a></H3>
<p>
files</a>.
</p>
-<H3><a name="Extending_test_suite"></a>38.10.12 Test driven development and the test-suite</H3>
+<H3><a name="Extending_test_suite">41.10.12 Test driven development and the test-suite</a></H3>
<p>
but error/exception out with an error message on stderr on failure.
</p>
-<H4><a name="Extending_running_test_suite"></a>38.10.12.1 Running the test-suite</H4>
+<H4><a name="Extending_running_test_suite">41.10.12.1 Running the test-suite</a></H4>
<p>
<div class="shell"><pre>
$ make check-python-test-suite
checking python test-suite
-checking testcase argcargvtest (with run test) under python
-checking testcase python_autodoc under python
-checking testcase python_append (with run test) under python
-checking testcase callback (with run test) under python
+checking python testcase argcargvtest (with run test)
+checking python testcase python_autodoc
+checking python testcase python_append (with run test)
+checking python testcase callback (with run test)
</pre></div>
<p>
make ret_by_value.ctest SWIG_FEATURES="-debug-tmsearch"
</pre></div>
-<H3><a name="Extending_nn43"></a>38.10.13 Documentation</H3>
+<p>
+There is also a special 'errors' test-suite which is a set of regression tests checking SWIG warning and error messages.
+It can be run in the same way as the other language test-suites, replacing [lang] with errors, such as <tt>make check-errors-test-suite</tt>.
+The test cases used and the way it works is described in <tt>Examples/test-suite/errors/Makefile.in</tt>.
+</p>
+
+<H3><a name="Extending_nn43">41.10.13 Documentation</a></H3>
<p>
if available.
</ul>
-<H3><a name="Extending_prerequisites"></a>38.10.14 Prerequisites for adding a new language module to the SWIG distribution</H3>
+<H3><a name="Extending_prerequisites">41.10.14 Prerequisites for adding a new language module to the SWIG distribution</a></H3>
<p>
the existing tests.
</p>
-<H3><a name="Extending_coding_style_guidelines"></a>38.10.15 Coding style guidelines</H3>
+<H3><a name="Extending_coding_style_guidelines">41.10.15 Coding style guidelines</a></H3>
<p>
should be avoided as unlike the SWIG developers, users will never have consistent tab settings.
</p>
-<H2><a name="Extending_debugging_options"></a>38.11 Debugging Options</H2>
+<H2><a name="Extending_debugging_options">41.11 Debugging Options</a></H2>
<p>
The complete list of command line options for SWIG are available by running <tt>swig -help</tt>.
</p>
-<H2><a name="Extending_nn46"></a>38.12 Guide to parse tree nodes</H2>
+<H2><a name="Extending_nn46">41.12 Guide to parse tree nodes</a></H2>
<p>
</pre>
</div>
-<H2><a name="Extending_further_info"></a>38.13 Further Development Information</H2>
+<H2><a name="Extending_further_info">41.13 Further Development Information</a></H2>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Go</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#FFFFFF">
-<H1><a name="Go"></a>22 SWIG and Go</H1>
+<H1><a name="Go">23 SWIG and Go</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#Go_overview">Overview</a>
+<li><a href="#Go_examples">Examples</a>
<li><a href="#Go_running_swig">Running SWIG with Go</a>
<ul>
-<li><a href="#Go_commandline">Additional Commandline Options</a>
-<li><a href="#Go_outputs">Go Output Files</a>
+<li><a href="#Go_commandline">Go-specific Commandline Options</a>
+<li><a href="#Go_outputs">Generated Wrapper Files</a>
</ul>
<li><a href="#Go_basic_tour">A tour of basic C/C++ wrapping</a>
<ul>
<li><a href="#Go_enumerations">Go Enumerations</a>
<li><a href="#Go_classes">Go Classes</a>
<ul>
+<li><a href="#Go_class_memory">Go Class Memory Management</a>
<li><a href="#Go_class_inheritance">Go Class Inheritance</a>
</ul>
<li><a href="#Go_templates">Go Templates</a>
<li><a href="#Go_director_classes">Go Director Classes</a>
+<ul>
+<li><a href="#Go_director_example_cpp_code">Example C++ code</a>
+<li><a href="#Go_director_enable">Enable director feature</a>
+<li><a href="#Go_director_ctor_dtor">Constructor and destructor</a>
+<li><a href="#Go_director_overriding">Override virtual methods</a>
+<li><a href="#Go_director_base_methods">Call base methods</a>
+<li><a href="#Go_director_subclass">Subclass via embedding</a>
+<li><a href="#Go_director_finalizer">Memory management with runtime.SetFinalizer</a>
+<li><a href="#Go_director_foobargo_class">Complete FooBarGo example class</a>
+</ul>
<li><a href="#Go_primitive_type_mappings">Default Go primitive type mappings</a>
<li><a href="#Go_output_arguments">Output arguments</a>
<li><a href="#Go_adding_additional_code">Adding additional go code</a>
+<li><a href="#Go_typemaps">Go typemaps</a>
</ul>
</ul>
</div>
see <a href="http://golang.org/">golang.org</a>.
</p>
-<H2><a name="Go_overview"></a>22.1 Overview</H2>
+<H2><a name="Go_overview">23.1 Overview</a></H2>
+
+
+<p>
+Go does not support direct calling of functions written in C/C++. The
+<a href="https://golang.org/cmd/cgo/">cgo program</a> may be used to generate
+wrappers to call C code from Go, but there is no convenient way to call C++
+code. SWIG fills this gap.
+</p>
+
+<p>
+There are (at least) two different Go compilers. The first is the gc compiler
+of the <a href="https://golang.org/doc/install">Go distribution</a>, normally
+invoked via the <a href="https://golang.org/cmd/go/">go tool</a>.
+The second Go compiler is the <a href="https://golang.org/doc/install/gccgo">
+gccgo compiler</a>, which is a frontend to the GCC compiler suite.
+The interface to C/C++ code is completely different for the two Go compilers.
+SWIG supports both Go compilers, selected by the <tt>-gccgo</tt> command line
+option.
+</p>
+
+<p>
+Go is a type-safe compiled language and the wrapper code generated by SWIG is
+type-safe as well. In case of type issues the build will fail and hence SWIG's
+<a href="Modules.html#Modules_nn2">runtime library</a> and
+<a href="Typemaps.html#Typemaps_runtime_type_checker">runtime type checking</a>
+are not used.
+</p>
+
+<H2><a name="Go_examples">23.2 Examples</a></H2>
<p>
-Go is a compiled language, not a scripting language. However, it does
-not support direct calling of functions written in C/C++. The cgo
-program may be used to generate wrappers to call C code from Go, but
-there is no convenient way to call C++ code. SWIG fills this gap.
+Working examples can be found in the
+<a href="https://github.com/swig/swig/tree/master/Examples/go">SWIG source tree
+</a>.
</p>
<p>
-There are (at least) two different Go compilers. One is the gc
-compiler, normally invoked under the names 6g, 8g, or 5g. The other
-is the gccgo compiler, which is a frontend to the gcc compiler suite.
-The interface to C/C++ code is completely different for the two Go
-compilers. SWIG supports both, selected by a command line option.
+Please note that the examples in the SWIG source tree use makefiles with the .i
+SWIG interface file extension for backwards compatibility with Go 1.
</p>
+
+<H2><a name="Go_running_swig">23.3 Running SWIG with Go</a></H2>
+
+
+<p>
+Most Go programs are built using the <a href="https://golang.org/cmd/go/">go
+tool</a>. Since Go 1.1 the go tool has support for SWIG. To use it, give your
+SWIG interface file the extension .swig (for C code) or .swigcxx (for C++ code).
+Put that file in a GOPATH/src directory as usual for Go sources. Put other
+C/C++ code in the same directory with extensions of .c and .cxx. The
+<tt>go build</tt> and <tt>go install</tt> commands will automatically run SWIG
+for you and compile the generated wrapper code. To check the SWIG command line
+options the go tool uses run <tt>go build -x</tt>. To access the automatically
+generated files run <tt>go build -work</tt>. You'll find the files under the
+temporary WORK directory.
+</p>
+
+<p>
+To manually generate and compile C/C++ wrapper code for Go, use the <tt>-go</tt>
+option with SWIG. By default SWIG will generate code for the Go compiler of the
+Go distribution. To generate code for gccgo, you should also use the
+<tt>-gccgo</tt> option.
+</p>
+
+<p>
+When using the <tt>-cgo</tt> option, SWIG will generate files that can be used
+directly by <tt>go build</tt>. Starting with the Go 1.5 distribution the
+<tt>-cgo</tt> option has to be given. Put your SWIG interface file in a
+directory under GOPATH/src, and give it a name that does <b>not</b> end in the
+.swig or .swigcxx extension. Typically the SWIG interface file extension is .i
+in this case.
+</p>
+
+<div class="code"><pre>
+% swig -go -cgo example.i
+% go install
+</pre></div>
+
<p>
-Because Go is a type-safe compiled language, SWIG's runtime type
-checking and runtime library are not used with Go. This should be
-borne in mind when reading the rest of the SWIG documentation.
+You will now have a Go package that you can import from other Go packages as
+usual.
</p>
-<H2><a name="Go_running_swig"></a>22.2 Running SWIG with Go</H2>
+<p>
+To use SWIG without the <tt>-cgo</tt> option, more steps are required. Recall
+that this only works with Go versions before 1.5. When using Go version 1.2 or
+later, or when using gccgo, the code generated by SWIG can be linked directly
+into the Go program. A typical command sequence when using the Go compiler of
+the Go distribution would look like this:
+</p>
+<div class="code"><pre>
+% swig -go example.i
+% gcc -c code.c # The C library being wrapped.
+% gcc -c example_wrap.c
+% go tool 6g example.go
+% go tool 6c example_gc.c
+% go tool pack grc example.a example.6 example_gc.6 code.o example_wrap.o
+% go tool 6g main.go
+% go tool 6l main.6
+</pre></div>
<p>
-To generate Go code, use the <tt>-go</tt> option with SWIG. By
-default SWIG will generate code for the gc compilers. To generate
-code for gccgo, you should also use the <tt>-gccgo</tt> option.
+You can also put the wrapped code into a shared library, and when using the Go
+versions before 1.2 this is the only supported option. A typical command
+sequence for this approach would look like this:
</p>
-<H3><a name="Go_commandline"></a>22.2.1 Additional Commandline Options</H3>
+<div class="code"><pre>
+% swig -go -use-shlib example.i
+% gcc -c -fpic example.c
+% gcc -c -fpic example_wrap.c
+% gcc -shared example.o example_wrap.o -o example.so
+% go tool 6g example.go
+% go tool 6c example_gc.c
+% go tool pack grc example.a example.6 example_gc.6
+% go tool 6g main.go # your code, not generated by SWIG
+% go tool 6l main.6
+</pre></div>
+
+
+<H3><a name="Go_commandline">23.3.1 Go-specific Commandline Options</a></H3>
<p>
-These are the command line options for SWIG's GO module. They can
+These are the command line options for SWIG's Go module. They can
also be seen by using:
</p>
swig -go -help
</pre></div>
-<table summary="Go specific options">
+<table summary="Go-specific options">
+<tr>
+<th>Go-specific options</th>
+</tr>
+
<tr>
-<th>Go specific options</th>
+<td>-cgo</td>
+<td>Generate files to be used as input for the Go cgo tool. This
+ option is required for Go 1.5 and later, and works for Go 1.2 and
+ later. In the future this option will likely become the
+ default.</td>
</tr>
<tr>
-<td>-intgo-type-size %lt;s%gt;</td>
+<td>-intgosize <s></td>
<td>Set the size for the Go type <tt>int</tt>. This controls the size
- that the C/C++ code expects to see. The %lt;s%gt; argument should
+ that the C/C++ code expects to see. The <s> argument should
be 32 or 64. This option is currently required during the
transition from Go 1.0 to Go 1.1, as the size of <tt>int</tt> on
64-bit x86 systems changes between those releases (from 32 bits to
<tr>
<td>-gccgo</td>
<td>Generate code for gccgo. The default is to generate code for
- 6g/8g/5g.</td>
+ the Go compiler of the Go distribution.</td>
</tr>
<tr>
</tr>
<tr>
-<td>-soname %lt;name%gt;</td>
+<td>-use-shlib</td>
+<td>Tell SWIG to emit code that uses a shared library. This is only
+ meaningful for the Go compiler of the Go distribution, which needs to know at
+ compile time whether a shared library will be used.</td>
+</tr>
+
+<tr>
+<td>-soname <name></td>
<td>Set the runtime name of the shared library that the dynamic linker
should include at runtime. The default is the package name with
".so" appended. This is only used when generating code for
- 6g/8g/5g; when using gccgo, the equivalent name will be taken from
- the <code>-soname</code> option passed to the linker.</td>
+ the Go compiler of the Go distribution; when using gccgo, the equivalent name
+ will be taken from the <code>-soname</code> option passed to the linker.
+ Using this option implies the -use-shlib option.</td>
</tr>
<tr>
-<td>-go-prefix <prefix></td>
-<td>When generating code for gccgo, set the prefix to use. This
- corresponds to the <tt>-fgo-prefix</tt> option to gccgo.</td>
+<td>-go-pkgpath <pkgpath></td>
+<td>When generating code for gccgo, set the pkgpath to use. This
+ corresponds to the <tt>-fgo-pkgpath</tt> option to gccgo.</td>
</tr>
<tr>
-<td>-long-type-size <s></td>
-<td>Set the size for the C/C++ type <tt>long</tt>. This controls
- whether <tt>long</tt> is converted to the Go type <tt>int32</tt>
- or <tt>int64</tt>. The <s> argument should be 32 or 64.</td>
+<td>-go-prefix <prefix></td>
+<td>When generating code for gccgo, set the prefix to use. This
+ corresponds to the <tt>-fgo-prefix</tt> option to gccgo.
+ If <tt>-go-pkgpath</tt> is used, <tt>-go-prefix</tt> will be
+ ignored.</td>
</tr>
</table>
-<H3><a name="Go_outputs"></a>22.2.2 Go Output Files</H3>
+<H3><a name="Go_outputs">23.3.2 Generated Wrapper Files</a></H3>
+
+
+<p>There are two different approaches to generating wrapper files,
+ controlled by SWIG's <tt>-cgo</tt> option. The <tt>-cgo</tt> option
+ works with Go version 1.2 or later. It is required when using Go
+ version 1.5 or later.</p>
-<p> When generating Go code, SWIG will generate the following
- files:</p>
+<p>With or without the <tt>-cgo</tt> option, SWIG will generate the
+ following files when generating wrapper code:</p>
<ul>
<li>
These functions will be wrappers for the C++ functions defined by your
module. This file should, of course, be compiled with the Go
compiler.
+</li>
<li>
MODULE_wrap.c or MODULE_wrap.cxx will contain C/C++ functions will be
invoked by the Go wrapper code. This file should be compiled with the
-usual C or C++ compiler and linked into a shared library.
+usual C or C++ compiler.
+</li>
<li>
MODULE_wrap.h will be generated if you use the directors feature. It
provides a definition of the generated C++ director classes. It is
generally not necessary to use this file, but in some special cases it
may be helpful to include it in your code, compiled with the usual C
or C++ compiler.
-<li>
-If using the gc compiler, MODULE_gc.c will contain C code which should
-be compiled with the C compiler distributed as part of the gc compiler: 6c, 8c,
-or 5c. It should then be combined with the compiled MODULE.go using
-gopack. This file will not be generated when using gccgo.
+</li>
</ul>
-<p>
-A typical command sequence would look like this:
-</p>
+<p>When neither the <tt>-cgo</tt> nor the <tt>-gccgo</tt> option is
+ used, SWIG will also generate an additional file:</p>
+
+<ul>
+<li>
+MODULE_gc.c will contain C code which should be compiled with the C
+compiler distributed as part of the gc compiler. It should then be
+combined with the compiled MODULE.go using go tool pack.
+</li>
+</ul>
-<div class="code"><pre>
-% swig -go example.i
-% gcc -c -fpic example.c
-% gcc -c -fpic example_wrap.c
-% gcc -shared example.o example_wrap.o -o example.so
-% 6g example.go
-% 6c example_gc.c
-% gopack grc example.a example.6 example_gc.6
-% 6g main.go # your code, not generated by SWIG
-% 6l main.6
-</pre></div>
-<H2><a name="Go_basic_tour"></a>22.3 A tour of basic C/C++ wrapping</H2>
+<H2><a name="Go_basic_tour">23.4 A tour of basic C/C++ wrapping</a></H2>
<p>
essential aspects of this wrapping.
</p>
-<H3><a name="Go_package"></a>22.3.1 Go Package Name</H3>
+<H3><a name="Go_package">23.4.1 Go Package Name</a></H3>
<p>
command line option.
</p>
-<H3><a name="Go_names"></a>22.3.2 Go Names</H3>
+<H3><a name="Go_names">23.4.2 Go Names</a></H3>
<p>
named <tt>Delete</tt> followed by that name.
</p>
-<H3><a name="Go_constants"></a>22.3.3 Go Constants</H3>
+<H3><a name="Go_constants">23.4.3 Go Constants</a></H3>
<p>
directive become Go constants, declared with a <tt>const</tt>
declaration.
-<H3><a name="Go_enumerations"></a>22.3.4 Go Enumerations</H3>
+<H3><a name="Go_enumerations">23.4.4 Go Enumerations</a></H3>
<p>
code should avoid modifying those variables.
</p>
-<H3><a name="Go_classes"></a>22.3.5 Go Classes</H3>
+<H3><a name="Go_classes">23.4.5 Go Classes</a></H3>
<p>
MyMethod() int
}
-MyClassMyFactoryFunction() MyClass {
+func MyClassMyFactoryFunction() MyClass {
// swig magic here
}
</pre>
for this by calling the Swigcptr() method.
</p>
-<H4><a name="Go_class_inheritance"></a>22.3.5.1 Go Class Inheritance</H4>
+<H4><a name="Go_class_memory">23.4.5.1 Go Class Memory Management</a></H4>
+
+
+<p>
+Calling <tt>NewClassName</tt> for a C++ class <tt>ClassName</tt> will allocate
+memory using the C++ memory allocator. This memory will not be automatically
+freed by Go's garbage collector as the object ownership is not tracked. When
+you are done with the C++ object you must free it using
+<tt>DeleteClassName</tt>.<br>
+<br>
+The most Go idiomatic way to manage the memory for some C++ class is to call
+<tt>NewClassName</tt> followed by a
+<tt><a href="https://golang.org/doc/effective_go.html#defer">defer</a></tt> of
+the <tt>DeleteClassName</tt> call. Using <tt>defer</tt> ensures that the memory
+of the C++ object is freed as soon as the function containing the <tt>defer</tt>
+statement returns. Furthemore <tt>defer</tt> works great for short-lived
+objects and fits nicely C++'s RAII idiom. Example:
+</p>
+<div class="code">
+<pre>
+func UseClassName(...) ... {
+ o := NewClassName(...)
+ defer DeleteClassName(o)
+ // Use the ClassName object
+ return ...
+}
+</pre>
+</div>
+
+<p>
+With increasing complexity, especially complex C++ object hierarchies, the
+correct placement of <tt>defer</tt> statements becomes harder and harder as C++
+objects need to be freed in the correct order. This problem can be eased by
+keeping a C++ object function local so that it is only available to the function
+that creates a C++ object and functions called by this function. Example:
+</p>
+<div class="code">
+<pre>
+func WithClassName(constructor args, f func(ClassName, ...interface{}) error, data ...interface{}) error {
+ o := NewClassName(constructor args)
+ defer DeleteClassName(o)
+ return f(o, data...)
+}
+
+func UseClassName(o ClassName, data ...interface{}) (err error) {
+ // Use the ClassName object and additional data and return error.
+}
+
+func main() {
+ WithClassName(constructor args, UseClassName, additional data)
+}
+</pre>
+</div>
+
+<p>
+Using <tt>defer</tt> has limitations though, especially when it comes to
+long-lived C++ objects whichs lifetimes are hard to predict. For such C++
+objects a common technique is to store the C++ object into a Go object, and to
+use the Go function <tt>runtime.SetFinalizer</tt> to add a finalizer which frees
+the C++ object when the Go object is freed. It is strongly recommended to read
+the <a href="https://golang.org/pkg/runtime/#SetFinalizer">runtime.SetFinalizer
+</a> documentation before using this technique to understand the
+<tt>runtime.SetFinalizer</tt> limitations.<br>
+</p>
+<p>
+Common pitfalls with <tt>runtime.SetFinalizer</tt> are:
+</p>
+<ul>
+<li>
+If a hierarchy of C++ objects will be automatically freed by Go finalizers then
+the Go objects that store the C++ objects need to replicate the hierarchy of the
+C++ objects to prevent that C++ objects are freed prematurely while other C++
+objects still rely on them.
+</li>
+<li>
+The usage of Go finalizers is problematic with C++'s RAII idiom as it isn't
+predictable when the finalizer will run and this might require a Close or Delete
+method to be added the Go object that stores a C++ object to mitigate.
+</li>
+<li>
+The Go finalizer function typically runs in a different OS thread which can be
+problematic with C++ code that uses thread-local storage.
+</li>
+</ul>
+
+<p>
+<tt>runtime.SetFinalizer</tt> Example:
+</p>
+<div class="code">
+<pre>
+import (
+ "runtime"
+ "wrap" // SWIG generated wrapper code
+)
+
+type GoClassName struct {
+ wcn wrap.ClassName
+}
+
+func NewGoClassName() *GoClassName {
+ o := &GoClassName{wcn: wrap.NewClassName()}
+ runtime.SetFinalizer(o, deleteGoClassName)
+ return o
+}
+
+func deleteGoClassName(o *GoClassName) {
+ // Runs typically in a different OS thread!
+ wrap.DeleteClassName(o.wcn)
+ o.wcn = nil
+}
+
+func (o *GoClassName) Close() {
+ // If the C++ object has a Close method.
+ o.wcn.Close()
+
+ // If the GoClassName object is no longer in an usable state.
+ runtime.SetFinalizer(o, nil) // Remove finalizer.
+ deleteGoClassName() // Free the C++ object.
+}
+</pre>
+</div>
+
+<H4><a name="Go_class_inheritance">23.4.5.2 Go Class Inheritance</a></H4>
<p>
be checked dynamically.
</p>
-<H3><a name="Go_templates"></a>22.3.6 Go Templates</H3>
+<H3><a name="Go_templates">23.4.6 Go Templates</a></H3>
<p>
wrappers for a particular template instantation. To do this, use
the <tt>%template</tt> directive.
-<H3><a name="Go_director_classes"></a>22.3.7 Go Director Classes</H3>
+<H3><a name="Go_director_classes">23.4.7 Go Director Classes</a></H3>
+
+
+<p>
+SWIG's director feature permits a Go type to act as the subclass of a C++ class.
+This is complicated by the fact that C++ and Go define inheritance differently.
+SWIG normally represents the C++ class inheritance automatically in Go via
+interfaces but with a Go type representing a subclass of a C++ class some manual
+work is necessary.
+</p>
+
+<p>
+This subchapter gives a step by step guide how to properly sublass a C++ class
+with a Go type. In general it is strongly recommended to follow this guide
+completely to avoid common pitfalls with directors in Go.
+</p>
+
+
+<H4><a name="Go_director_example_cpp_code">23.4.7.1 Example C++ code</a></H4>
+
+
+<p>
+The step by step guide is based on two example C++ classes. FooBarAbstract is
+an abstract C++ class and the FooBarCpp class inherits from it. This guide
+explains how to implement a FooBarGo class similar to the FooBarCpp class.
+</p>
+
+<p>
+<tt>FooBarAbstract</tt> abstract C++ class:
+</p>
+
+<div class="code">
+<pre>
+class FooBarAbstract
+{
+public:
+ FooBarAbstract() {};
+ virtual ~FooBarAbstract() {};
+
+ std::string FooBar() {
+ return this->Foo() + ", " + this->Bar();
+ };
+
+protected:
+ virtual std::string Foo() {
+ return "Foo";
+ };
+
+ virtual std::string Bar() = 0;
+};
+</pre>
+</div>
+
+<p>
+<tt>FooBarCpp</tt> C++ class:
+</p>
+
+<div class="code">
+<pre>
+class FooBarCpp : public FooBarAbstract
+{
+protected:
+ virtual std::string Foo() {
+ return "C++ " + FooBarAbstract::Foo();
+ }
+
+ virtual std::string Bar() {
+ return "C++ Bar";
+ }
+};
+</pre>
+</div>
+
+<p>
+Returned string by the <tt>FooBarCpp::FooBar</tt> method is:
+</p>
+
+<div class="code">
+<pre>
+C++ Foo, C++ Bar
+</pre>
+</div>
+
+
+<p>
+The complete example, including the <tt>FooBarGoo</tt> class implementation, can
+be found in <a href="#Go_director_foobargo_class">the end of the guide</a>.
+</p>
+
+
+<H4><a name="Go_director_enable">23.4.7.2 Enable director feature</a></H4>
+
+
+<p>
+The director feature is disabled by default. To use directors you must make two
+changes to the interface file. First, add the "directors" option to the %module
+directive, like this:
+</p>
+
+<div class="code">
+<pre>
+%module(directors="1") modulename
+</pre>
+</div>
+
+<p>
+Second, you must use the %feature("director") directive to tell SWIG which
+classes should get directors. In the example the FooBarAbstract class needs the
+director feature enabled so that the FooBarGo class can inherit from it, like
+this:
+</p>
+
+<div class="code">
+<pre>
+%feature("director") FooBarAbstract;
+</pre>
+</div>
<p>
-SWIG's director feature permits a Go type to act as the subclass of a
-C++ class with virtual methods. This is complicated by the fact that
-C++ and Go define inheritance differently. In Go, structs can inherit
-methods via anonymous field embedding. However, when a method is
-called for an embedded struct, if that method calls any other methods,
-they are called for the embedded struct, not for the original type.
-Therefore, SWIG must use Go interfaces to represent C++ inheritance.
+For a more detailed documentation of the director feature and how to enable or
+disable it for specific classes and virtual methods see SWIG's Java
+documentation on directors.
+</p>
+
+
+<H4><a name="Go_director_ctor_dtor">23.4.7.3 Constructor and destructor</a></H4>
+
+
+<p>
+SWIG creates an additional set of constructor and destructor functions once the
+director feature has been enabled for a C++ class.
+<tt>NewDirectorClassName</tt> allows overriding virtual methods on the new
+object instance and <tt>DeleteDirectorClassName</tt> needs to be used to free a
+director object instance created with <tt>NewDirectorClassName</tt>.
+More on overriding virtual methods follows later in this guide under
+<a href="#Go_director_overriding">overriding virtual methods</a>.
</p>
<p>
-In order to use the director feature in Go, you must define a type in
-your Go code. You must then add methods for the type. Define a
-method in Go for each C++ virtual function that you want to override.
-You must then create a value of your new type, and pass a pointer to
-it to the function <tt>NewDirectorClassName</tt>,
-where <tt>ClassName</tt> is the name of the C++ class. That will
-return a value of type <tt>ClassName</tt>.
+The default constructor and destructor functions <tt>NewClassName</tt> and
+<tt>DeleteClassName</tt> can still be used as before so that existing code
+doesn't break just because the director feature has been enabled for a C++
+class. The behavior is undefined if the default and director constructor and
+destructor functions get mixed and so great care needs to be taken that only one
+of the constructor and destructor function pairs is used for any object
+instance. Both constructor functions, the default and the director one, return
+the same interface type. This makes it potentially hard to know which
+destructor function, the default or the director one, needs to be called to
+delete an object instance.
</p>
<p>
-For example:
+In <b>theory</b> the <tt>DirectorInterface</tt> method could be used to
+determine if an object instance was created via <tt>NewDirectorClassName</tt>:
</p>
<div class="code">
<pre>
-type GoClass struct { }
-func (p *GoClass) VirtualFunction() { }
-func MakeClass() ClassName {
- return NewDirectorClassName(&GoClass{})
+if o.DirectorInterface() != nil {
+ DeleteDirectorClassName(o)
+} else {
+ DeleteClassName(o)
}
</pre>
</div>
<p>
-Any call in C++ code to the virtual function will wind up calling the
-method defined in Go. The Go code may of course call other methods on
-itself, and those methods may be defined either in Go or in C++.
+In <b>practice</b> it is strongly recommended to embed a director object
+instance in a Go struct so that a director object instance will be represented
+as a distinct Go type that subclasses a C++ class. For this Go type custom
+constructor and destructor functions take care of the director constructor and
+destructor function calls and the resulting Go class will appear to the user as
+any other SWIG wrapped C++ class. More on properly subclassing a C++ class
+follows later in this guide under <a href="#Go_director_subclass">subclass via
+embedding</a>.
+</p>
+
+
+<H4><a name="Go_director_overriding">23.4.7.4 Override virtual methods</a></H4>
+
+
+<p>
+In order to override virtual methods on a C++ class with Go methods the
+<tt>NewDirectorClassName</tt> constructor functions receives a
+<tt>DirectorInterface</tt> argument. The methods in the <tt>
+DirectorInterface</tt> are a subset of the public and protected virtual methods
+of the C++ class. If the <tt>DirectorInterface</tt> contains a method with a
+matching signature to a virtual method of the C++ class then the virtual C++
+method will be overwritten with the Go method. As Go doesn't support protected
+methods all overriden protected virtual C++ methods will be public in Go.
</p>
-<H3><a name="Go_primitive_type_mappings"></a>22.3.8 Default Go primitive type mappings</H3>
+<p>
+As an example see part of the <tt>FooBarGo</tt> class:
+</p>
+
+<div class="code">
+<pre>
+type overwrittenMethodsOnFooBarAbstract struct {
+ fb FooBarAbstract
+}
+
+func (om *overwrittenMethodsOnFooBarAbstract) Foo() string {
+ ...
+}
+
+func (om *overwrittenMethodsOnFooBarAbstract) Bar() string {
+ ...
+}
+
+func NewFooBarGo() FooBarGo {
+ om := &overwrittenMethodsOnFooBarAbstract{}
+ fb := NewDirectorFooBarAbstract(om)
+ om.fb = fb
+ ...
+}
+</pre>
+</div>
+
+<p>
+The complete example, including the <tt>FooBarGoo</tt> class implementation, can
+be found in <a href="#Go_director_foobargo_class">the end of the guide</a>. In
+this part of the example the virtual methods <tt>FooBarAbstract::Foo</tt> and
+<tt>FooBarAbstract::Bar</tt> have been overwritten with Go methods similarly to
+how the <tt>FooBarAbstract</tt> virtual methods are overwritten by the
+<tt>FooBarCpp</tt> class.
+</p>
+
+<p>
+The <tt>DirectorInterface</tt> in the example is implemented by the
+<tt>overwrittenMethodsOnFooBarAbstract</tt> Go struct type. A pointer to a
+<tt>overwrittenMethodsOnFooBarAbstract</tt> struct instance will be given to the
+<tt>NewDirectorFooBarAbstract</tt> constructor function. The constructor return
+value implements the <tt>FooBarAbstract</tt> interface.
+<tt>overwrittenMethodsOnFooBarAbstract</tt> could in theory be any Go type but
+in practice a struct is used as it typically contains at least a value of the
+C++ class interface so that the overwritten methods can use the rest of the
+C++ class. If the <tt>FooBarGo</tt> class would receive additional constructor
+arguments then these would also typically be stored in the
+<tt>overwrittenMethodsOnFooBarAbstract</tt> struct so that they can be used by
+the Go methods.
+</p>
+
+
+<H4><a name="Go_director_base_methods">23.4.7.5 Call base methods</a></H4>
+
+
+<p>
+Often a virtual method will be overwritten to extend the original behavior of
+the method in the base class. This is also the case for the
+<tt>FooBarCpp::Foo</tt> method of the example code:
+</p>
+
+<div class="code">
+<pre>
+virtual std::string Foo() {
+ return "C++ " + FooBarAbstract::Foo();
+}
+</pre>
+</div>
+
+<p>
+To use base methods the <tt>DirectorClassNameMethodName</tt> wrapper functions
+are automatically generated by SWIG for public and protected virtual methods.
+The <tt>FooBarGo.Foo</tt> implementation in the example looks like this:
+</p>
+
+<div class="code">
+<pre>
+func (om *overwrittenMethodsOnFooBarAbstract) Foo() string {
+ return "Go " + DirectorFooBarAbstractFoo(om.fb)
+}
+</pre>
+</div>
+
+<p>
+The complete example, including the <tt>FooBarGoo</tt> class implementation, can
+be found in <a href="#Go_director_foobargo_class">the end of the guide</a>.
+</p>
+
+
+<H4><a name="Go_director_subclass">23.4.7.6 Subclass via embedding</a></H4>
+
+
+<p>
+<a href="#Go_director_ctor_dtor">As previously mentioned in this guide</a> the
+default and director constructor functions return the same interface type. To
+properly subclass a C++ class with a Go type the director object instance
+returned by the <tt>NewDirectorClassName</tt> constructor function should be
+embedded into a Go struct so that it represents a distinct but compatible type
+in Go's type system. This Go struct should be private and the constructor and
+destructor functions should instead work with a public interface type so that
+the Go class that subclasses a C++ class can be used as a compatible drop in.
+</p>
+
+<p>
+The subclassing part of the <tt>FooBarGo</tt> class for an example looks like
+this:
+</p>
+
+<div class="code">
+<pre>
+type FooBarGo interface {
+ FooBarAbstract
+ deleteFooBarAbstract()
+ IsFooBarGo()
+}
+
+type fooBarGo struct {
+ FooBarAbstract
+}
+
+func (fbgs *fooBarGo) deleteFooBarAbstract() {
+ DeleteDirectorFooBarAbstract(fbgs.FooBarAbstract)
+}
+
+func (fbgs *fooBarGo) IsFooBarGo() {}
+
+func NewFooBarGo() FooBarGo {
+ om := &overwrittenMethodsOnFooBarAbstract{}
+ fb := NewDirectorFooBarAbstract(om)
+ om.fb = fb
+
+ return &fooBarGo{FooBarAbstract: fb}
+}
+
+func DeleteFooBarGo(fbg FooBarGo) {
+ fbg.deleteFooBarAbstract()
+}
+</pre>
+</div>
+
+
+<p>
+The complete example, including the <tt>FooBarGoo</tt> class implementation, can
+be found in <a href="#Go_director_foobargo_class">the end of the guide</a>. In
+this part of the example the private <tt>fooBarGo</tt> struct embeds <tt>
+FooBarAbstract</tt> which lets the <tt>fooBarGo</tt> Go type "inherit" all the
+methods of the <tt>FooBarAbstract</tt> C++ class by means of embedding. The
+public <tt>FooBarGo</tt> interface type includes the <tt>FooBarAbstract</tt>
+interface and hence <tt>FooBarGo</tt> can be used as a drop in replacement for
+<tt>FooBarAbstract</tt> while the reverse isn't possible and would raise a
+compile time error. Furthemore the constructor and destructor functions <tt>
+NewFooBarGo</tt> and <tt>DeleteFooBarGo</tt> take care of all the director
+specifics and to the user the class appears as any other SWIG wrapped C++
+class.
+</p>
+
+
+<H4><a name="Go_director_finalizer">23.4.7.7 Memory management with runtime.SetFinalizer</a></H4>
+
+
+<p>
+In general all guidelines for <a href="#Go_class_memory">C++ class memory
+management</a> apply as well to director classes. One often overlooked
+limitation with <tt>runtime.SetFinalizer</tt> is that a finalizer doesn't run
+in case of a cycle and director classes typically have a cycle. The cycle
+in the <tt>FooBarGo</tt> class is here:
+</p>
+
+<div class="code">
+<pre>
+type overwrittenMethodsOnFooBarAbstract struct {
+ fb FooBarAbstract
+}
+
+func NewFooBarGo() FooBarGo {
+ om := &overwrittenMethodsOnFooBarAbstract{}
+ fb := NewDirectorFooBarAbstract(om) // fb.v = om
+ om.fb = fb // Backlink causes cycle as fb.v = om!
+ ...
+}
+</pre>
+</div>
+
+<p>
+In order to be able to use <tt>runtime.SetFinalizer</tt> nevertheless the
+finalizer needs to be set on something that isn't in a cycle and that references
+the director object instance. In the <tt>FooBarGo</tt> class example the <tt>
+FooBarAbstract</tt> director instance can be automatically deleted by setting
+the finalizer on <tt>fooBarGo</tt>:
+</p>
+
+<div class="code">
+<pre>
+type fooBarGo struct {
+ FooBarAbstract
+}
+
+type overwrittenMethodsOnFooBarAbstract struct {
+ fb FooBarAbstract
+}
+
+func NewFooBarGo() FooBarGo {
+ om := &overwrittenMethodsOnFooBarAbstract{}
+ fb := NewDirectorFooBarAbstract(om)
+ om.fb = fb // Backlink causes cycle as fb.v = om!
+
+ fbgs := &fooBarGo{FooBarAbstract: fb}
+ runtime.SetFinalizer(fbgs, FooBarGo.deleteFooBarAbstract)
+ return fbgs
+}
+</pre>
+</div>
+
+<p>
+Furthermore if <tt>runtime.SetFinalizer</tt> is in use either the <tt>
+DeleteClassName</tt> destructor function needs to be removed or the <tt>
+fooBarGo</tt> struct needs additional data to prevent double deletion. Please
+read the <a href="#Go_class_memory">C++ class memory management</a> subchapter
+before using <tt>runtime.SetFinalizer</tt> to know all of its gotchas.
+</p>
+
+
+<H4><a name="Go_director_foobargo_class">23.4.7.8 Complete FooBarGo example class</a></H4>
+
+
+<p>
+The complete and annotated <tt>FooBarGo</tt> class looks like this:
+</p>
+
+<div class="code">
+<pre>
+// FooBarGo is a superset of FooBarAbstract and hence FooBarGo can be used as a
+// drop in replacement for FooBarAbstract but the reverse causes a compile time
+// error.
+type FooBarGo interface {
+ FooBarAbstract
+ deleteFooBarAbstract()
+ IsFooBarGo()
+}
+
+// Via embedding fooBarGo "inherits" all methods of FooBarAbstract.
+type fooBarGo struct {
+ FooBarAbstract
+}
+
+func (fbgs *fooBarGo) deleteFooBarAbstract() {
+ DeleteDirectorFooBarAbstract(fbgs.FooBarAbstract)
+}
+
+// The IsFooBarGo method ensures that FooBarGo is a superset of FooBarAbstract.
+// This is also how the class hierarchy gets represented by the SWIG generated
+// wrapper code. For an instance FooBarCpp has the IsFooBarAbstract and
+// IsFooBarCpp methods.
+func (fbgs *fooBarGo) IsFooBarGo() {}
+
+// Go type that defines the DirectorInterface. It contains the Foo and Bar
+// methods that overwrite the respective virtual C++ methods on FooBarAbstract.
+type overwrittenMethodsOnFooBarAbstract struct {
+ // Backlink to FooBarAbstract so that the rest of the class can be used by
+ // the overridden methods.
+ fb FooBarAbstract
+
+ // If additional constructor arguments have been given they are typically
+ // stored here so that the overriden methods can use them.
+}
+
+func (om *overwrittenMethodsOnFooBarAbstract) Foo() string {
+ // DirectorFooBarAbstractFoo calls the base method FooBarAbstract::Foo.
+ return "Go " + DirectorFooBarAbstractFoo(om.fb)
+}
+
+func (om *overwrittenMethodsOnFooBarAbstract) Bar() string {
+ return "Go Bar"
+}
+
+func NewFooBarGo() FooBarGo {
+ // Instantiate FooBarAbstract with selected methods overridden. The methods
+ // that will be overwritten are defined on
+ // overwrittenMethodsOnFooBarAbstract and have a compatible signature to the
+ // respective virtual C++ methods. Furthermore additional constructor
+ // arguments will be typically stored in the
+ // overwrittenMethodsOnFooBarAbstract struct.
+ om := &overwrittenMethodsOnFooBarAbstract{}
+ fb := NewDirectorFooBarAbstract(om)
+ om.fb = fb // Backlink causes cycle as fb.v = om!
+
+ fbgs := &fooBarGo{FooBarAbstract: fb}
+ // The memory of the FooBarAbstract director object instance can be
+ // automatically freed once the FooBarGo instance is garbage collected by
+ // uncommenting the following line. Please make sure to understand the
+ // runtime.SetFinalizer specific gotchas before doing this. Furthemore
+ // DeleteFooBarGo should be deleted if a finalizer is in use or the fooBarGo
+ // struct needs additional data to prevent double deletion.
+ // runtime.SetFinalizer(fbgs, FooBarGo.deleteFooBarAbstract)
+ return fbgs
+}
+
+// Recommended to be removed if runtime.SetFinalizer is in use.
+func DeleteFooBarGo(fbg FooBarGo) {
+ fbg.deleteFooBarAbstract()
+}
+</pre>
+</div>
+
+<p>
+Returned string by the <tt>FooBarGo.FooBar</tt> method is:
+</p>
+
+<div class="code">
+<pre>
+Go Foo, Go Bar
+</pre>
+</div>
+
+<p>
+For comparison the <tt>FooBarCpp</tt> class looks like this:
+</p>
+
+<div class="code">
+<pre>
+class FooBarCpp : public FooBarAbstract
+{
+protected:
+ virtual std::string Foo() {
+ return "C++ " + FooBarAbstract::Foo();
+ }
+
+ virtual std::string Bar() {
+ return "C++ Bar";
+ }
+};
+</pre>
+</div>
+
+<p>
+For comparison the returned string by the <tt>FooBarCpp::FooBar</tt> method is:
+</p>
+
+<div class="code">
+<pre>
+C++ Foo, C++ Bar
+</pre>
+</div>
+
+<p>
+The complete source of this example can be found under
+<a href="https://github.com/swig/swig/tree/master/Examples/go/director">
+SWIG/Examples/go/director/</a>.
+</p>
+
+
+<H3><a name="Go_primitive_type_mappings">23.4.8 Default Go primitive type mappings</a></H3>
<p>
<tr>
<td>long</td>
-<td>int32 or int64, depending on <tt>-long-type-size</tt></td>
+<td>int64</td>
</tr>
<tr>
<td>unsigned long</td>
-<td>uint32 or uint64, depending on <tt>-long-type-size</tt></td>
+<td>uint64</td>
</tr>
<tr>
into Go types.
</p>
-<H3><a name="Go_output_arguments"></a>22.3.9 Output arguments</H3>
+<H3><a name="Go_output_arguments">23.4.9 Output arguments</a></H3>
<p>Because of limitations in the way output arguments are processed in swig,
</pre>
</div>
-<H3><a name="Go_adding_additional_code"></a>22.3.10 Adding additional go code</H3>
+<H3><a name="Go_adding_additional_code">23.4.10 Adding additional go code</a></H3>
<p>Often the APIs generated by swig are not very natural in go, especially if
few, then you might as well define your own struct that includes the
swig-wrapped object, instead of adding methods to the swig-generated object.</p>
-<p>This only works if your wrappers do not need to import other go modules.
-There is at present no way to insert import statements in the correct place
-in swig-generated go. If you need to do that, you must put your go code
-in a separate file.</p>
+<p>If you need to import other go packages, you can do this with
+<code>%go_import</code>. For example,</p>
+<div class="code">
+<pre>
+%go_import("fmt", _ "unusedPackage", rp "renamed/package")
+
+%insert(go_wrapper) %{
+
+func foo() {
+ fmt.Println("Some string:", rp.GetString())
+}
+
+// Importing the same package twice is permitted,
+// Go code will be generated with only the first instance of the import.
+%go_import("fmt")
+
+%insert(go_wrapper) %{
+
+func bar() {
+ fmt.Println("Hello world!")
+}
+
+%}
+</pre>
+</div>
+
+<H3><a name="Go_typemaps">23.4.11 Go typemaps</a></H3>
+
+
+<p>
+You can use the <tt>%typemap</tt> directive to modify SWIG's default
+wrapping behavior for specific C/C++ types. You need to be familiar
+with the material in the general
+"<a href="Typemaps.html#Typemaps">Typemaps</a>" chapter. That chapter
+explains how to define a typemap. This section describes some
+specific typemaps used for Go.
+</p>
+
+<p>
+In general type conversion code may be written either in C/C++ or in
+Go. The choice to make normally depends on where memory should be
+allocated. To allocate memory controlled by the Go garbage collector,
+write Go code. To allocate memory in the C/C++ heap, write C code.
+</p>
+
+<table BORDER summary="Go Typemaps">
+<tr>
+<td><b>Typemap</b></td>
+<td><b>Description</b></td>
+</tr>
+
+<tr>
+<td>gotype</td>
+<td>
+The Go type to use for a C++ type. This type will appear in the
+generated Go wrapper function. If this is not defined SWIG will use a
+default as <a href="#Go_primitive_type_mappings">described above</a>.
+</td>
+</tr>
+
+<tr>
+<td>imtype</td>
+<td>
+An intermediate Go type used by the "goin", "goout", "godirectorin",
+and "godirectorout" typemaps. If this typemap is not defined for a
+C/C++ type, the gotype typemape will be used. This is useful when
+gotype is best converted to C/C++ using Go code.
+</td>
+</tr>
+
+<tr>
+<td>goin</td>
+<td>
+Go code to convert from gotype to imtype when calling a C/C++
+function. SWIG will then internally convert imtype to a C/C++ type
+and pass it down. If this is not defined, or is the empty string, no
+conversion is done.
+</td>
+</tr>
+
+<tr>
+<td>in</td>
+<td>
+C/C++ code to convert the internally generated C/C++ type, based on
+imtype, into the C/C++ type that a function call expects. If this is
+not defined the value will simply be cast to the desired type.
+</td>
+</tr>
+
+<tr>
+<td>out</td>
+<td>
+C/C++ code to convert the C/C++ type that a function call returns into
+the internally generated C/C++ type, based on imtype, that will be
+returned to Go. If this is not defined the value will simply be cast
+to the desired type.
+</td>
+</tr>
+
+<tr>
+<td>goout</td>
+<td>
+Go code to convert a value returned from a C/C++ function from imtype
+to gotype. If this is not defined, or is the empty string, no
+conversion is done.
+</td>
+</tr>
+
+<tr>
+<td>argout</td>
+<td>
+C/C++ code to adjust an argument value when returning from a function.
+This is called after the real C/C++ function has run. This uses the
+internally generated C/C++ type, based on imtype. This is only useful
+for a pointer type of some sort. If this is not defined nothing will
+be done.
+</td>
+</tr>
+
+<tr>
+<td>goargout</td>
+<td>
+Go code to adjust an argument value when returning from a function.
+This is called after the real C/C++ function has run. The value will
+be in imtype. This is only useful for a pointer type of some sort.
+If this is not defined, or is the empty string, nothing will be done.
+</td>
+</tr>
+
+<tr>
+<td>directorin</td>
+<td>
+C/C++ code to convert the C/C++ type used to call a director method
+into the internally generated C/C++ type, based on imtype, that will
+be passed to Go. If this is not defined the value will simply be cast
+to the desired type.
+</td>
+</tr>
+
+<tr>
+<td>godirectorin</td>
+<td>
+Go code to convert a value used to call a director method from imtype
+to gotype. If this is not defined, or is the empty string, no
+conversion is done.
+</td>
+</tr>
+
+<tr>
+<td>godirectorout</td>
+<td>
+Go code to convert a value returned from a director method from gotype
+to imtype. If this is not defined, or is the empty string, no
+conversion is done.
+</td>
+</tr>
+
+<tr>
+<td>directorout</td>
+<td>
+C/C++ code to convert a value returned from a director method from the
+internally generated C/C++ type, based on imtype, into the type that
+the method should return If this is not defined the value will simply
+be cast to the desired type.
+</td>
+</tr>
+
+</table>
+
</body>
</html>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<!-- Hand-written HTML -->
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Guile</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Guile"></a>23 SWIG and Guile</H1>
+<H1><a name="Guile">24 SWIG and Guile</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<p>
This section details guile-specific support in SWIG.
-<H2><a name="Guile_nn1"></a>23.1 Supported Guile Versions</H2>
+<H2><a name="Guile_nn1">24.1 Supported Guile Versions</a></H2>
<p>
so your mileage may vary. To be safe set environment variable
GUILE_AUTO_COMPILE to 0 when using swig generated guile code.
-<H2><a name="Guile_nn2"></a>23.2 Meaning of "Module"</H2>
+<H2><a name="Guile_nn2">24.2 Meaning of "Module"</a></H2>
<p>
separately for SWIG, Guile, and Libtool. To avoid horrible confusion,
we explicitly prefix the context, e.g., "guile-module".
-<H2><a name="Guile_nn3"></a>23.3 Old GH Guile API</H2>
+<H2><a name="Guile_nn3">24.3 Old GH Guile API</a></H2>
<p>Guile 1.8 and older could be interfaced using two different api's, the SCM
version of SWIG that can still generate guile GH wrapper code is 2.0.9. Please
use that version if you really need the GH wrapper code.
-<H2><a name="Guile_nn4"></a>23.4 Linkage</H2>
+<H2><a name="Guile_nn4">24.4 Linkage</a></H2>
<p>
which manifests in multiple shared-library usage conventions. A set of
policies implementing a usage convention is called a <b>linkage</b>.
-<H3><a name="Guile_nn5"></a>23.4.1 Simple Linkage</H3>
+<H3><a name="Guile_nn5">24.4.1 Simple Linkage</a></H3>
<p>
<div class="targetlang">
<pre>
(module-map (lambda (sym var)
- (module-export! (current-module) (list sym)))
- (current-module))
+ (module-export! (current-module) (list sym)))
+ (current-module))
</pre>
</div>
<code>SWIG_init</code> via a preprocessor define to avoid symbol
clashes. For this case, however, passive linkage is available.
-<H3><a name="Guile_nn6"></a>23.4.2 Passive Linkage</H3>
+<H3><a name="Guile_nn6">24.4.2 Passive Linkage</a></H3>
<p>Passive linkage is just like simple linkage, but it generates an
<p>You should use passive linkage rather than simple linkage when you
are using multiple modules.
-<H3><a name="Guile_nn7"></a>23.4.3 Native Guile Module Linkage</H3>
+<H3><a name="Guile_nn7">24.4.3 Native Guile Module Linkage</a></H3>
<p>SWIG can also generate wrapper code that does all the Guile module
</div>
</ul>
-<H3><a name="Guile_nn8"></a>23.4.4 Old Auto-Loading Guile Module Linkage</H3>
+<H3><a name="Guile_nn8">24.4.4 Old Auto-Loading Guile Module Linkage</a></H3>
<p>Guile used to support an autoloading facility for object-code
an appropriate name.
-<H3><a name="Guile_nn9"></a>23.4.5 Hobbit4D Linkage</H3>
+<H3><a name="Guile_nn9">24.4.5 Hobbit4D Linkage</a></H3>
<p>
experimental; the (hobbit4d link) conventions are not well understood.
</p>
-<H2><a name="Guile_nn10"></a>23.5 Underscore Folding</H2>
+<H2><a name="Guile_nn10">24.5 Underscore Folding</a></H2>
<p>
<code>%rename</code> to specify the Guile name of the wrapped
functions and variables (see CHANGES).
-<H2><a name="Guile_nn11"></a>23.6 Typemaps</H2>
+<H2><a name="Guile_nn11">24.6 Typemaps</a></H2>
<p>
<a href="Customization.html#Customization_features">Features and the %feature directive</a>
for info on how to apply the %feature.</p>
-<H2><a name="Guile_nn12"></a>23.7 Representation of pointers as smobs</H2>
+<H2><a name="Guile_nn12">24.7 Representation of pointers as smobs</a></H2>
<p>
If the Scheme object passed was not a SWIG smob representing a compatible
pointer, a <code>wrong-type-arg</code> exception is raised.
-<H3><a name="Guile_nn14"></a>23.7.1 Smobs</H3>
+<H3><a name="Guile_nn14">24.7.1 Smobs</a></H3>
<p>
the corresponding GOOPS class.</p>
-<H3><a name="Guile_nn15"></a>23.7.2 Garbage Collection</H3>
+<H3><a name="Guile_nn15">24.7.2 Garbage Collection</a></H3>
<p>Garbage collection is a feature of Guile since version 1.6. As SWIG now requires Guile > 1.8,
Object ownership and %newobject</a> in the SWIG manual. All typemaps use an $owner var, and
the guile module replaces $owner with 0 or 1 depending on feature:new.</p>
-<H2><a name="Guile_nn16"></a>23.8 Exception Handling</H2>
+<H2><a name="Guile_nn16">24.8 Exception Handling</a></H2>
<p>
<div class="code">
<pre>
- 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");
+ 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");
</pre>
</div>
The default when not specified here is to use "swig-error".
See Lib/exception.i for details.
-<H2><a name="Guile_nn17"></a>23.9 Procedure documentation</H2>
+<H2><a name="Guile_nn17">24.9 Procedure documentation</a></H2>
<p>If invoked with the command-line option <code>-procdoc
typemap argument <code>doc</code>. See <code>Lib/guile/typemaps.i</code> for
details.
-<H2><a name="Guile_nn18"></a>23.10 Procedures with setters</H2>
+<H2><a name="Guile_nn18">24.10 Procedures with setters</a></H2>
<p>For global variables, SWIG creates a single wrapper procedure
pointer)</code> and <code>(<var>struct-member</var>-set pointer
value)</code> are <em>not</em> generated.
-<H2><a name="Guile_nn19"></a>23.11 GOOPS Proxy Classes</H2>
+<H2><a name="Guile_nn19">24.11 GOOPS Proxy Classes</a></H2>
<p>SWIG can also generate classes and generic functions for use with
<code>%import "foo.h"</code> before the <code>%inline</code> block.
</p>
-<H3><a name="Guile_nn20"></a>23.11.1 Naming Issues</H3>
+<H3><a name="Guile_nn20">24.11.1 Naming Issues</a></H3>
<p>As you can see in the example above, there are potential naming conflicts. The default exported
(use-modules ((Test) #:renamer (symbol-prefix-proc 'goops:)))
</pre></div>
-<H3><a name="Guile_nn21"></a>23.11.2 Linking</H3>
+<H3><a name="Guile_nn21">24.11.2 Linking</a></H3>
<p>The guile-modules generated above all need to be linked together. GOOPS support requires
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Introduction</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Introduction"></a>2 Introduction</H1>
+<H1><a name="Introduction">2 Introduction</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
-<H2><a name="Introduction_nn2"></a>2.1 What is SWIG?</H2>
+<H2><a name="Introduction_nn2">2.1 What is SWIG?</a></H2>
<p>
SWIG is a software development tool that simplifies the task of
interfacing different languages to C and C++ programs. In a
nutshell, SWIG is a compiler that takes C/C++ declarations and creates
-the wrappers needed to access those declarations from other languages including
+the wrappers needed to access those declarations from other languages
including Perl, Python, Tcl, Ruby, Guile, and Java. SWIG normally
requires no modifications to existing code and can often be used to
build a usable interface in only a few minutes. Possible applications
<li>Building interpreted interfaces to existing C programs.
<li>Rapid prototyping and application development.
<li>Interactive debugging.
-<li>Reengineering or refactoring of legacy software into a scripting language components.
+<li>Reengineering or refactoring of legacy software into scripting language components.
<li>Making a graphical user interface (using Tk for example).
<li>Testing of C libraries and programs (using scripts).
<li>Building high performance C modules for scripting languages.
in scientific and engineering projects. However, nowadays SWIG is known to be used in many
large open source and commercial projects.
-<H2><a name="Introduction_nn3"></a>2.2 Why use SWIG?</H2>
+<H2><a name="Introduction_nn3">2.2 Why use SWIG?</a></H2>
<p>
<li>Testing is time consuming (the compile/debug cycle).
<li>Not easy to reconfigure or customize without recompilation.
<li>Modularization can be tricky.
-<li>Security concerns (buffer overflow for instance).
+<li>Security concerns (buffer overflows for instance).
</ul>
<p>
To address these limitations, many programmers have arrived at the
every aspect of the language bindings. This is the main reason why SWIG has such a large
user manual ;-).
-<H2><a name="Introduction_nn4"></a>2.3 A SWIG example</H2>
+<H2><a name="Introduction_nn4">2.3 A SWIG example</a></H2>
<p>
double My_variable = 3.0;
/* Compute factorial of n */
-int fact(int n) {
- if (n <= 1) return 1;
- else return n*fact(n-1);
+int fact(int n) {
+ if (n <= 1)
+ return 1;
+ else
+ return n*fact(n-1);
}
/* Compute n mod m */
int my_mod(int n, int m) {
- return(n % m);
+ return(n % m);
}
</pre></div>
interface file as shown below (by convention, these files carry a .i
suffix) :
-<H3><a name="Introduction_nn5"></a>2.3.1 SWIG interface file</H3>
+<H3><a name="Introduction_nn5">2.3.1 SWIG interface file</a></H3>
<div class="code"><pre>
provides a location for inserting additional code, such as C header
files or additional C declarations, into the generated C wrapper code.
-<H3><a name="Introduction_nn6"></a>2.3.2 The swig command</H3>
+<H3><a name="Introduction_nn6">2.3.2 The swig command</a></H3>
<p>
7.5
%
</pre></div>
- <p>
-
+<p>
The <tt>swig</tt> command produced a new file called
<tt>example_wrap.c</tt> that should be compiled along with the
<tt>example.c</tt> file. Most operating systems and scripting
<tt>example_wrap.c</tt> reveals a hideous mess. However, you
almost never need to worry about it.
-<H3><a name="Introduction_nn7"></a>2.3.3 Building a Perl5 module</H3>
+<H3><a name="Introduction_nn7">2.3.3 Building a Perl5 module</a></H3>
<p>
<div class="shell"><pre>
unix > <b>swig -perl5 example.i</b>
unix > <b>gcc -c example.c example_wrap.c \
- -I/usr/local/lib/perl5/sun4-solaris/5.003/CORE</b>
-unix > <b>ld -G example.o example_wrap.o -o example.so</b> # This is for Solaris
+ -I/usr/local/lib/perl5/sun4-solaris/5.003/CORE</b>
+unix > <b>ld -G example.o example_wrap.o -o example.so</b> # This is for Solaris
unix > <b>perl5.003
use example;
print example::fact(4), "\n";
</pre></div>
-<H3><a name="Introduction_nn8"></a>2.3.4 Building a Python module</H3>
+<H3><a name="Introduction_nn8">2.3.4 Building a Python module</a></H3>
<p>
7.5
</pre></div>
-<H3><a name="Introduction_nn9"></a>2.3.5 Shortcuts</H3>
+<H3><a name="Introduction_nn9">2.3.5 Shortcuts</a></H3>
<p>
<div class="shell"><pre>
unix > <b>swig -perl5 -module example example.h</b>
unix > <b>gcc -c example.c example_wrap.c \
- -I/usr/local/lib/perl5/sun4-solaris/5.003/CORE</b>
+ -I/usr/local/lib/perl5/sun4-solaris/5.003/CORE</b>
unix > <b>ld -G example.o example_wrap.o -o example.so</b>
unix > <b>perl5.003
use example;
7.5
</pre></div>
-<H2><a name="Introduction_nn10"></a>2.4 Supported C/C++ language features</H2>
+<H2><a name="Introduction_nn10">2.4 Supported C/C++ language features</a></H2>
<p>
</ul>
<p>
-Currently, the only major C++ feature not supported is nested classes--a limitation
-that should be removed in a future release, but has some workarounds for the moment.
+Most of C++11 is also supported. Details are in the <a href="CPlusPlus11.html#CPlusPlus11">C++11</a> section.
</p>
<p>
able to understand C++ semantics. SWIG generates its wrappers with
full knowledge of this information. As a result, you will find SWIG
to be just as capable of dealing with nasty corner cases as it is in
-wrapping simple C++ code. In fact, SWIG is able handle C++ code that
+wrapping simple C++ code. In fact, SWIG is able to handle C++ code that
stresses the very limits of many C++ compilers.
-<H2><a name="Introduction_nn11"></a>2.5 Non-intrusive interface building</H2>
+<H2><a name="Introduction_nn11">2.5 Non-intrusive interface building</a></H2>
<p>
possible to support different types of interfaces depending on the application.
</p>
-<H2><a name="Introduction_build_system"></a>2.6 Incorporating SWIG into a build system</H2>
+<H2><a name="Introduction_build_system">2.6 Incorporating SWIG into a build system</a></H2>
<p>
</p>
<p>
-There is growing support for SWIG in some build tools, for example <a href="http://www.cmake.org">CMake</a>
+There is growing support for SWIG in some build tools, for example <a href="http://cmake.org">CMake</a>
is a cross-platform, open-source build manager with built in support for SWIG. CMake can detect the SWIG executable
and many of the target language libraries for linking against.
CMake knows how to build shared libraries and loadable modules on many different operating systems.
-This allows easy cross platform SWIG development. It also can generate the custom commands necessary for
-driving SWIG from IDE's and makefiles. All of this can be done from a single cross platform input file.
+This allows easy cross platform SWIG development. It can also generate the custom commands necessary for
+driving SWIG from IDEs and makefiles. All of this can be done from a single cross platform input file.
The following example is a CMake input file for creating a python wrapper for the SWIG interface file, example.i:
</p>
For other target languages on Windows a dll, instead of a .pyd file, is usually generated.
</p>
-<H2><a name="Introduction_nn12"></a>2.7 Hands off code generation</H2>
+<H2><a name="Introduction_nn12">2.7 Hands off code generation</a></H2>
<p>
details.
</p>
-<H2><a name="Introduction_nn13"></a>2.8 SWIG and freedom</H2>
+<H2><a name="Introduction_nn13">2.8 SWIG and freedom</a></H2>
<p>
<p>
Ironically, the freedom that SWIG provides is countered by an
-extremely conservative approach to code generation. At it's core, SWIG
+extremely conservative approach to code generation. At its core, SWIG
tries to distill even the most advanced C++ code down to a small
well-defined set of interface building techniques based on ANSI C
programming. Because of this, you will find that SWIG interfaces can
of the programmer's way----the last thing any developer wants to do is
to spend their time debugging the output of a tool that relies on
non-portable or unreliable programming features.
+Dependencies are often a source of incompatibilities and problems and so
+additional third party libraries are not used in the generated code.
+SWIG will also generally avoid generating code that introduces a dependency
+on the C++ Standard Template Library (STL).
+SWIG will generate code that depends on the C libraries though.
+</p>
</body>
</html>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Java</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#FFFFFF">
-<H1><a name="Java"></a>24 SWIG and Java</H1>
+<H1><a name="Java">25 SWIG and Java</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#Java_namespaces">C++ namespaces</a>
<li><a href="#Java_templates">C++ templates</a>
<li><a href="#Java_smart_pointers">C++ Smart Pointers</a>
+<ul>
+<li><a href="#Java_smart_pointers_shared_ptr">The shared_ptr Smart Pointer</a>
+<li><a href="#Java_smart_pointers_generic">Generic Smart Pointers</a>
+</ul>
</ul>
<li><a href="#Java_further_details">Further details on the generated Java classes</a>
<ul>
<li><a href="#Java_proper_enums_classes">Proper Java enum classes</a>
<li><a href="#Java_typeunsafe_enums_classes">Type unsafe enum classes</a>
</ul>
+<li><a href="#Java_interfaces">Interfaces</a>
</ul>
<li><a href="#Java_directors">Cross language polymorphism using directors</a>
<ul>
<li><a href="#Java_directors_example">Simple directors example</a>
<li><a href="#Java_directors_threading">Director threading issues</a>
<li><a href="#Java_directors_performance">Director performance tuning</a>
+<li><a href="#Java_exceptions_from_directors">Java exceptions from directors</a>
</ul>
<li><a href="#Java_allprotected">Accessing protected members</a>
<li><a href="#Java_common_customization">Common customization features</a>
</p>
-<H2><a name="Java_overview"></a>24.1 Overview</H2>
+<H2><a name="Java_overview">25.1 Overview</a></H2>
<p>
The latter sections cover the advanced techniques of using typemaps for complete control of the wrapping process.
</p>
-<H2><a name="Java_preliminaries"></a>24.2 Preliminaries</H2>
+<H2><a name="Java_preliminaries">25.2 Preliminaries</a></H2>
<p>
This is the commonly used method to load JNI code so your system will more than likely support this.</p>
<p>
-Android uses Java JNI and also works with SWIG. Please read the <a href="Android.html">Android chapter</a> in conjunction with this one if you are targeting Android.
+Android uses Java JNI and also works with SWIG. Please read the <a href="Android.html#Android">Android chapter</a> in conjunction with this one if you are targeting Android.
</p>
-<H3><a name="Java_running_swig"></a>24.2.1 Running SWIG</H3>
+<H3><a name="Java_running_swig">25.2.1 Running SWIG</a></H3>
<p>
compiling and using the generated files.
</p>
-<H3><a name="Java_commandline"></a>24.2.2 Additional Commandline Options</H3>
+<H3><a name="Java_commandline">25.2.2 Additional Commandline Options</a></H3>
<p>
Their use will become clearer by the time you have finished reading this section on SWIG and Java.
</p>
-<H3><a name="Java_getting_right_headers"></a>24.2.3 Getting the right header files</H3>
+<H3><a name="Java_getting_right_headers">25.2.3 Getting the right header files</a></H3>
<p>
<p>
The exact location may vary on your machine, but the above locations are typical. </p>
-<H3><a name="Java_compiling_dynamic"></a>24.2.4 Compiling a dynamic module</H3>
+<H3><a name="Java_compiling_dynamic">25.2.4 Compiling a dynamic module</a></H3>
<p>
<div class="code"><pre>
$ swig -java example.i
-$ gcc -c example_wrap.c -I/usr/java/include -I/usr/java/include/solaris
-$ gcc -c example.c
+$ gcc -fPIC -c example_wrap.c -I/usr/java/include -I/usr/java/include/solaris
+$ gcc -fPIC -c example.c
$ ld -G example_wrap.o example.o -o libexample.so
</pre></div>
your compiler and linker to get the right set of options. You might also
check the <a href="http://www.dabeaz.com/cgi-bin/wiki.pl">SWIG Wiki</a> for
additional information.
-<a href="http://weblogs.java.net/blog/kellyohair/archive/2006/01/compilation_of.html">JNI compilation</a>
-is a useful reference for compiling on different platforms.
</p>
<p>
<p>
The name of the shared library output file is important.
If the name of your SWIG module is "<tt>example</tt>", the name of the corresponding shared library file should be "<tt>libexample.so</tt>" (or equivalent depending on your machine, see <a href="#Java_dynamic_linking_problems">Dynamic linking problems</a> for more information).
-The name of the module is specified using the <tt>%module</tt> directive or<tt> -module</tt> command line option.</p>
+The name of the module is specified using the <tt>%module</tt> directive or <tt>-module</tt> command line option.</p>
-<H3><a name="Java_using_module"></a>24.2.5 Using your module</H3>
+<H3><a name="Java_using_module">25.2.5 Using your module</a></H3>
<p>
If it doesn't work have a look at the following section which discusses problems loading the shared library.
</p>
-<H3><a name="Java_dynamic_linking_problems"></a>24.2.6 Dynamic linking problems</H3>
+<H3><a name="Java_dynamic_linking_problems">25.2.6 Dynamic linking problems</a></H3>
<p>
<div class="code"><pre>
$ java runme
Exception in thread "main" java.lang.UnsatisfiedLinkError: exampleJNI.gcd(II)I
- at exampleJNI.gcd(Native Method)
- at example.gcd(example.java:12)
- at runme.main(runme.java:18)
+ at exampleJNI.gcd(Native Method)
+ at example.gcd(example.java:12)
+ at runme.main(runme.java:18)
</pre></div>
<p>
</p>
-<H3><a name="Java_compilation_problems_cpp"></a>24.2.7 Compilation problems and compiling with C++</H3>
+<H3><a name="Java_compilation_problems_cpp">25.2.7 Compilation problems and compiling with C++</a></H3>
<p>
<div class="code"><pre>
% swig -c++ -java example.i
% g++ -c -fpic example.cxx
-% g++ -c -fpic example_wrap.cxx -I/usr/java/j2sdk1.4.1/include -I/usr/java/
-j2sdk1.4.1/include/linux
+% g++ -c -fpic example_wrap.cxx -I/usr/java/j2sdk1.4.1/include -I/usr/java/j2sdk1.4.1/include/linux
% g++ -shared example.o example_wrap.o -o libexample.so
</pre></div>
</p>
-<H3><a name="Java_building_windows"></a>24.2.8 Building on Windows</H3>
+<H3><a name="Java_building_windows">25.2.8 Building on Windows</a></H3>
<p>
This section covers the process of using SWIG with Microsoft Visual C++ 6 although the procedure may be similar with other compilers.
In order for everything to work, you will need to have a JDK installed on your machine in order to read the JNI header files.</p>
-<H4><a name="Java_visual_studio"></a>24.2.8.1 Running SWIG from Visual Studio</H4>
+<H4><a name="Java_visual_studio">25.2.8.1 Running SWIG from Visual Studio</a></H4>
<p>
If the library fails to load have a look at <a href="#Java_dynamic_linking_problems">Dynamic linking problems</a>.
</p>
-<H4><a name="Java_nmake"></a>24.2.8.2 Using NMAKE</H4>
+<H4><a name="Java_nmake">25.2.8.2 Using NMAKE</a></H4>
<p>
JAVA_INCLUDE = -ID:\jdk1.3\include -ID:\jdk1.3\include\win32
java::
- swig -java -o $(WRAPFILE) $(INTERFACE)
- $(CC) $(CFLAGS) $(JAVA_INCLUDE) $(SRCS) $(WRAPFILE)
- set LIB=$(TOOLS)\lib
- $(LINK) $(LOPT) -out:example.dll $(LIBS) example.obj example_wrap.obj
- javac *.java
+ swig -java -o $(WRAPFILE) $(INTERFACE)
+ $(CC) $(CFLAGS) $(JAVA_INCLUDE) $(SRCS) $(WRAPFILE)
+ set LIB=$(TOOLS)\lib
+ $(LINK) $(LOPT) -out:example.dll $(LIBS) example.obj example_wrap.obj
+ javac *.java
</pre></div>
<p>
</p>
-<H2><a name="Java_basic_tour"></a>24.3 A tour of basic C/C++ wrapping</H2>
+<H2><a name="Java_basic_tour">25.3 A tour of basic C/C++ wrapping</a></H2>
<p>
This section briefly covers the essential aspects of this wrapping.
</p>
-<H3><a name="Java_module_packages_classes"></a>24.3.1 Modules, packages and generated Java classes</H3>
+<H3><a name="Java_module_packages_classes">25.3.1 Modules, packages and generated Java classes</a></H3>
<p>
SWIG won't create the directory, so make sure it exists beforehand.
</p>
-<H3><a name="Java_functions"></a>24.3.2 Functions</H3>
+<H3><a name="Java_functions">25.3.2 Functions</a></H3>
<p>
</pre></div>
-<H3><a name="Java_global_variables"></a>24.3.3 Global variables</H3>
+<H3><a name="Java_global_variables">25.3.3 Global variables</a></H3>
<p>
</div>
-<H3><a name="Java_constants"></a>24.3.4 Constants</H3>
+<H3><a name="Java_constants">25.3.4 Constants</a></H3>
<p>
</p>
-<H3><a name="Java_enumerations"></a>24.3.5 Enumerations</H3>
+<H3><a name="Java_enumerations">25.3.5 Enumerations</a></H3>
<p>
Before looking at the various approaches for wrapping named C/C++ enums, anonymous enums are considered.
</p>
-<H4><a name="Java_anonymous_enums"></a>24.3.5.1 Anonymous enums</H4>
+<H4><a name="Java_anonymous_enums">25.3.5.1 Anonymous enums</a></H4>
<p>
</p>
-<H4><a name="Java_typesafe_enums"></a>24.3.5.2 Typesafe enums</H4>
+<H4><a name="Java_typesafe_enums">25.3.5.2 Typesafe enums</a></H4>
<p>
The following section details proper Java enum generation.
</p>
-<H4><a name="Java_proper_enums"></a>24.3.5.3 Proper Java enums</H4>
+<H4><a name="Java_proper_enums">25.3.5.3 Proper Java enums</a></H4>
<p>
<a href="#Java_simpler_enum_classes">Simpler Java enums for enums without initializers</a> section.
</p>
-<H4><a name="Java_typeunsafe_enums"></a>24.3.5.4 Type unsafe enums</H4>
+<H4><a name="Java_typeunsafe_enums">25.3.5.4 Type unsafe enums</a></H4>
<p>
Thus the upgrade path to proper enums provided in JDK 1.5 is more painful.
</p>
-<H4><a name="Java_simple_enums"></a>24.3.5.5 Simple enums</H4>
+<H4><a name="Java_simple_enums">25.3.5.5 Simple enums</a></H4>
<p>
The type unsafe approach is preferable to this one and this simple approach is only included for backwards compatibility with these earlier versions of SWIG.
</p>
-<H3><a name="Java_pointers"></a>24.3.6 Pointers</H3>
+<H3><a name="Java_pointers">25.3.6 Pointers</a></H3>
<p>
a NULL pointer if the conversion can't be performed.
</p>
-<H3><a name="Java_structures"></a>24.3.7 Structures</H3>
+<H3><a name="Java_structures">25.3.7 Structures</a></H3>
<p>
<div class="code"><pre>
struct Vector {
- double x,y,z;
+ double x,y,z;
};
</pre></div>
</div>
-<H3><a name="Java_classes"></a>24.3.8 C++ classes</H3>
+<H3><a name="Java_classes">25.3.8 C++ classes</a></H3>
<p>
</div>
-<H3><a name="Java_inheritance"></a>24.3.9 C++ inheritance</H3>
+<H3><a name="Java_inheritance">25.3.9 C++ inheritance</a></H3>
<p>
A warning is given when multiple inheritance is detected and only the first base class is used.
</p>
-<H3><a name="Java_pointers_refs_arrays"></a>24.3.10 Pointers, references, arrays and pass by value</H3>
+<H3><a name="Java_pointers_refs_arrays">25.3.10 Pointers, references, arrays and pass by value</a></H3>
<p>
when the returned object's finalizer is run by the garbage collector).
</p>
-<H4><a name="Java_null_pointers"></a>24.3.10.1 Null pointers</H4>
+<H4><a name="Java_null_pointers">25.3.10.1 Null pointers</a></H4>
<p>
The converse also occurs, that is, NULL pointers are translated into <tt>null</tt> Java objects when returned from a C/C++ function.
</p>
-<H3><a name="Java_overloaded_functions"></a>24.3.11 C++ overloaded functions</H3>
+<H3><a name="Java_overloaded_functions">25.3.11 C++ overloaded functions</a></H3>
<p>
</pre>
</div>
-<H3><a name="Java_default_arguments"></a>24.3.12 C++ default arguments</H3>
+<H3><a name="Java_default_arguments">25.3.12 C++ default arguments</a></H3>
<p>
</p>
-<H3><a name="Java_namespaces"></a>24.3.13 C++ namespaces</H3>
+<H3><a name="Java_namespaces">25.3.13 C++ namespaces</a></H3>
<p>
you will need to open up the visibility for the pointer constructor and <tt>getCPtr</tt> method from the default 'protected' to 'public' with the <tt>SWIG_JAVABODY_PROXY</tt> macro. See <a href="#Java_code_typemaps">Java code typemaps</a>.
</p>
-<H3><a name="Java_templates"></a>24.3.14 C++ templates</H3>
+<H3><a name="Java_templates">25.3.14 C++ templates</a></H3>
<p>
More details can be found in the <a href="SWIGPlus.html#SWIGPlus">SWIG and C++</a> chapter.
</p>
-<H3><a name="Java_smart_pointers"></a>24.3.15 C++ Smart Pointers</H3>
+<H3><a name="Java_smart_pointers">25.3.15 C++ Smart Pointers</a></H3>
+
+
+<H4><a name="Java_smart_pointers_shared_ptr">25.3.15.1 The shared_ptr Smart Pointer</a></H4>
+
+
+<p>
+The C++11 standard provides <tt>std::shared_ptr</tt> which was derived from the Boost
+implementation, <tt>boost::shared_ptr</tt>.
+Both of these are available for Java in the SWIG library and usage is outlined
+in the <a href="Library.html#Library_std_shared_ptr">shared_ptr smart pointer</a> library section.
+</p>
+
+
+<H4><a name="Java_smart_pointers_generic">25.3.15.2 Generic Smart Pointers</a></H4>
<p>
</pre>
</div>
-<H2><a name="Java_further_details"></a>24.4 Further details on the generated Java classes</H2>
+<H2><a name="Java_further_details">25.4 Further details on the generated Java classes</a></H2>
<p>
First, the crucial intermediary JNI class is considered.
</p>
-<H3><a name="Java_imclass"></a>24.4.1 The intermediary JNI class</H3>
+<H3><a name="Java_imclass">25.4.1 The intermediary JNI class</a></H3>
<p>
from <tt>modulename</tt> to <tt>modulenameModule</tt>.
</p>
-<H4><a name="Java_imclass_pragmas"></a>24.4.1.1 The intermediary JNI class pragmas</H4>
+<H4><a name="Java_imclass_pragmas">25.4.1.1 The intermediary JNI class pragmas</a></H4>
<p>
%pragma(java) jniclasscode=%{
static {
try {
- System.loadLibrary("example");
+ System.loadLibrary("example");
} catch (UnsatisfiedLinkError e) {
System.err.println("Native code library failed to load. \n" + e);
System.exit(1);
All the methods in the intermediary JNI class will then not be callable outside of the package as the method modifiers have been changed from public access to default access. This is useful if you want to prevent users calling these low level functions.
</p>
-<H3><a name="Java_module_class"></a>24.4.2 The Java module class</H3>
+<H3><a name="Java_module_class">25.4.2 The Java module class</a></H3>
<p>
The primary reason for having the module class wrapping the calls in the intermediary JNI class is to implement static type checking. In this case only a <tt>Foo</tt> can be passed to the <tt>egg</tt> function, whereas any <tt>long</tt> can be passed to the <tt>egg</tt> function in the intermediary JNI class.
</p>
-<H4><a name="Java_module_class_pragmas"></a>24.4.2.1 The Java module class pragmas</H4>
+<H4><a name="Java_module_class_pragmas">25.4.2.1 The Java module class pragmas</a></H4>
<p>
</p>
-<H3><a name="Java_proxy_classes"></a>24.4.3 Java proxy classes</H3>
+<H3><a name="Java_proxy_classes">25.4.3 Java proxy classes</a></H3>
<p>
<div class="code">
<pre>
public class Foo {
- private long swigCPtr;
- protected boolean swigCMemOwn;
+ private transient long swigCPtr;
+ protected transient boolean swigCMemOwn;
protected Foo(long cPtr, boolean cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
member variables. These functions call the native methods in the intermediary JNI class.
The advantage of having this extra layer is the type safety that the proxy class functions offer.
It adds static type checking which leads to fewer surprises at runtime.
-For example, you can see that if you attempt to use the <tt> spam() </tt>
+For example, you can see that if you attempt to use the <tt>spam()</tt>
function it will only compile when the parameters passed are an <tt>int</tt> and a <tt>Foo</tt>.
From a user's point of view, it makes the class work as if it were a Java class:
</p>
</pre>
</div>
-<H4><a name="Java_memory_management"></a>24.4.3.1 Memory management</H4>
+<H4><a name="Java_memory_management">25.4.3.1 Memory management</a></H4>
<p>
</p>
-<H4><a name="Java_inheritance_mirroring"></a>24.4.3.2 Inheritance</H4>
+<H4><a name="Java_inheritance_mirroring">25.4.3.2 Inheritance</a></H4>
<p>
<div class="code"><pre>
public class Base {
- private long swigCPtr;
- protected boolean swigCMemOwn;
+ private transient long swigCPtr;
+ protected transient boolean swigCMemOwn;
protected Base(long cPtr, boolean cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
<div class="code"><pre>
public class Derived extends Base {
- private long swigCPtr;
+ private transient long swigCPtr;
protected Derived(long cPtr, boolean cMemoryOwn) {
super(exampleJNI.SWIGDerivedUpcast(cPtr), cMemoryOwn);
</p>
-<H4><a name="Java_proxy_classes_gc"></a>24.4.3.3 Proxy classes and garbage collection</H4>
+<H4><a name="Java_proxy_classes_gc">25.4.3.3 Proxy classes and garbage collection</a></H4>
<p>
See the <a href="http://www.devx.com/Java/Article/30192">How to Handle Java Finalization's Memory-Retention Issues</a> article for alternative approaches to managing memory by avoiding finalizers altogether.
</p>
-<H4><a name="Java_pgcpp"></a>24.4.3.4 The premature garbage collection prevention parameter for proxy class marshalling</H4>
+<H4><a name="Java_pgcpp">25.4.3.4 The premature garbage collection prevention parameter for proxy class marshalling</a></H4>
<p>
<b>Compatibility note:</b> The generation of this additional parameter did not occur in versions prior to SWIG-1.3.30.
</p>
-<H4><a name="Java_multithread_libraries"></a>24.4.3.5 Single threaded applications and thread safety</H4>
+<H4><a name="Java_multithread_libraries">25.4.3.5 Single threaded applications and thread safety</a></H4>
<p>
<div class="code"><pre>
public class Test {
- private long swigCPtr;
- protected boolean swigCMemOwn;
+ private transient long swigCPtr;
+ protected transient boolean swigCMemOwn;
protected Test(long cPtr, boolean cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
</pre></div>
-<H3><a name="Java_type_wrapper_classes"></a>24.4.4 Type wrapper classes</H3>
+<H3><a name="Java_type_wrapper_classes">25.4.4 Type wrapper classes</a></H3>
<p>
<div class="code"><pre>
public class SWIGTYPE_p_int {
- private long swigCPtr;
+ private transient long swigCPtr;
protected SWIGTYPE_p_int(long cPtr, boolean bFutureUse) {
swigCPtr = cPtr;
</div>
-<H3><a name="Java_enum_classes"></a>24.4.5 Enum classes</H3>
+<H3><a name="Java_enum_classes">25.4.5 Enum classes</a></H3>
<p>
The following sub-sections detail the various types of enum classes that can be generated.
</p>
-<H4><a name="Java_typesafe_enums_classes"></a>24.4.5.1 Typesafe enum classes</H4>
+<H4><a name="Java_typesafe_enums_classes">25.4.5.1 Typesafe enum classes</a></H4>
<p>
The <tt>toString</tt> method is overridden so that the enum name is available.
</p>
-<H4><a name="Java_proper_enums_classes"></a>24.4.5.2 Proper Java enum classes</H4>
+<H4><a name="Java_proper_enums_classes">25.4.5.2 Proper Java enum classes</a></H4>
<p>
<a href="#Java_simpler_enum_classes">Simpler Java enums for enums without initializers</a> section describes how typemaps can be used to achieve this.
</p>
-<H4><a name="Java_typeunsafe_enums_classes"></a>24.4.5.3 Type unsafe enum classes</H4>
+<H4><a name="Java_typeunsafe_enums_classes">25.4.5.3 Type unsafe enum classes</a></H4>
<p>
</pre>
</div>
-<H2><a name="Java_directors"></a>24.5 Cross language polymorphism using directors</H2>
+<H3><a name="Java_interfaces">25.4.6 Interfaces</a></H3>
+
+
+<p>
+By default SWIG wraps all C++ classes as Java classes.
+As Java only supports derivation from a single base class, SWIG has to ignore all
+bases except the first when a C++ class inherits from more than one base class.
+However, there is a family of SWIG macros that change the default wrapping and allows a C++ class
+to be wrapped as a Java interface instead of a Java class.
+These macros provide a way to support some sort of multiple inheritance as there is no limit to
+the number of interfaces that a Java class can inherit from.
+</p>
+
+<p>
+When a C++ class is wrapped as a Java interface, a Java proxy class is still needed.
+The <tt>swiginterface.i</tt> library file provides three macros for marking a C++ class to be
+wrapped as a Java interface.
+There is more than one macro in order to provide a choice for choosing the Java interface and Java proxy names.
+</p>
+
+<table BORDER summary="Java interface macros">
+<tr VALIGN=TOP>
+ <td><b>Interface Macro Name</b></td>
+ <td><b>Description</b></td>
+</tr>
+<tr>
+ <td><tt>%interface(CTYPE)</tt></td>
+ <td>Proxy class name is unchanged, interface name has <tt>SwigInterface</tt> added as a suffix for C++ class <tt>CTYPE</tt>.</td>
+</tr>
+<tr>
+ <td><tt>%interface_impl(CTYPE)</tt></td>
+ <td>Proxy class name has <tt>SwigImpl</tt> as a suffix, interface name has <tt>SwigInterface</tt> added as a suffix for C++ class <tt>CTYPE</tt>.</td>
+</tr>
+<tr>
+ <td><tt>%interface_custom("PROXY", "INTERFACE", CTYPE)</tt></td>
+ <td>Proxy class name is given by the string <tt>PROXY</tt>, interface name is given by the string <tt>INTERFACE</tt> for C++ class <tt>CTYPE</tt>. The <tt>PROXY</tt> and <tt>INTERFACE</tt> names can use the <a href="SWIG.html#SWIG_advanced_renaming">string formatting functions</a> used in <tt>%rename</tt>.</td>
+</tr>
+</table>
+
+<p>
+The table below has a few examples showing the resulting proxy and interface names.
+</p>
+
+<table BORDER summary="Java interface macro examples">
+<tr VALIGN=TOP>
+ <td><b>Example Usage</b></td>
+ <td><b>Proxy Class Name</b></td>
+ <td><b>Interface Class Name</b></td>
+</tr>
+<tr>
+ <td><tt>%interface(Base)</tt></td>
+ <td><tt>Base</tt></td>
+ <td><tt>BaseSwigInterface</tt></td>
+</tr>
+<tr>
+ <td><tt>%interface_impl(Base)</tt></td>
+ <td><tt>BaseSwigImpl</tt></td>
+ <td><tt>Base</tt></td>
+</tr>
+<tr>
+ <td><tt>%interface_custom("BaseProxy", "IBase", Base)</tt></td>
+ <td><tt>BaseProxy</tt></td>
+ <td><tt>IBase</tt></td>
+</tr>
+<tr>
+ <td><tt>%interface_custom("%sProxy", "IBase", Base)</tt></td>
+ <td><tt>BaseProxy</tt></td>
+ <td><tt>IBase</tt></td>
+</tr>
+<tr>
+ <td><tt>%interface_custom("%sProxy", "%sInterface", Base)</tt></td>
+ <td><tt>BaseProxy</tt></td>
+ <td><tt>BaseProxyInterface</tt></td>
+</tr>
+<tr>
+ <td><tt>%interface_custom("%sProxy", "%(rstrip:[Proxy])sInterface", Base)</tt></td>
+ <td><tt>BaseProxy</tt></td>
+ <td><tt>BaseInterface</tt></td>
+</tr>
+</table>
+
+<p>
+The 2nd last example shows the names used in the string formatting functions.
+The input for <tt>PROXY</tt> that <tt>"%s"</tt> expands to is the proxy name, that is, Base.
+The input for <tt>INTERFACE</tt> that <tt>"%s"</tt> expands to is the proxy name, that is, <tt>BaseProxy</tt>.
+</p>
+<p>
+The last example shows <tt>rstrip</tt> and in this case strips the <tt>Proxy</tt> suffix and then adds on <tt>Interface</tt>.
+</p>
+
+<p>
+Consider the following C++ code:
+</p>
+
+<div class="code">
+<pre>
+namespace Space {
+ struct Base1 {
+ virtual void Method1();
+ };
+ struct Base2 {
+ virtual void Method2();
+ };
+ struct Derived : Base1, Base2 {
+ };
+ void UseBases(const Base1 &b1, const Base2 &b2);
+}
+</pre>
+</div>
+
+<p>
+By default all classes are wrapped and are available in Java, but, <tt>Derived</tt>
+has all bases ignored except the first.
+SWIG generates a warning for the above code:
+</p>
+
+<div class="shell">
+<pre>
+example.i:10: Warning 813: Warning for Derived, base Base2 ignored.
+Multiple inheritance is not supported in Java.
+</pre>
+</div>
+
+<p>
+If we decide to wrap the two base classes as interfaces and add the following before SWIG parses the above example code:
+</p>
+
+<div class="code">
+<pre>
+%include <swiginterface.i>
+%interface_impl(Space::Base1);
+%interface_impl(Space::Base2);
+</pre>
+</div>
+
+<p>
+then two interface files are generated, Base1.java and Base2.java in addition to proxy class files, Base1SwigImpl.java and Base2SwigImpl.java.
+The contents of interface file Base1.java for <tt>Base1</tt> is shown below:
+</p>
+
+<div class="code">
+<pre>
+public interface Base1 {
+ long Base1_GetInterfaceCPtr();
+ void Method1();
+}
+</pre>
+</div>
+
+<p>
+The proxy class in Base1SwigImpl.java for Base1 is as it would have been if <tt>%interface</tt> was not used,
+except the name has changed to <tt>Base1SwigImpl</tt> and it implements the appropriate base:
+</p>
+
+<div class="code">
+<pre>
+public class Base1SwigImpl implements Base1 {
+...
+ public long Base1_GetInterfaceCPtr() {
+ return exampleJNI.Base1SwigImpl_Base1_GetInterfaceCPtr(swigCPtr);
+ }
+
+ public void Method1() {
+ exampleJNI.Base1SwigImpl_Method1(swigCPtr, this);
+ }
+...
+}
+</pre>
+</div>
+
+<p>
+In fact any class deriving from <tt>Base</tt> will now implement the interface instead of
+deriving from it (or ignoring the base in the case of multiple base classes).
+Hence the <tt>Derived</tt> proxy class will now implement both bases:
+</p>
+
+<div class="code">
+<pre>
+public class Derived implements Base1, Base2 {
+...
+ public long Base1_GetInterfaceCPtr() {
+ return exampleJNI.Derived_Base1_GetInterfaceCPtr(swigCPtr);
+ }
+
+ public long Base2_GetInterfaceCPtr() {
+ return exampleJNI.Derived_Base2_GetInterfaceCPtr(swigCPtr);
+ }
+
+ public void Method1() {
+ exampleJNI.Derived_Method1(swigCPtr, this);
+ }
+
+ public void Method2() {
+ exampleJNI.Derived_Method2(swigCPtr, this);
+ }
+...
+}
+</pre>
+</div>
+
+<p>
+Wherever a class marked as an interface is used, such as the <tt>UseBases</tt> method in the example,
+the interface name is used as the type in the Java layer:
+</p>
+
+<div class="code">
+<pre>
+ public static void UseBases(Base1 b1, Base2 b2) {
+ exampleJNI.UseBases(b1.Base1_GetInterfaceCPtr(), b1, b2.Base2_GetInterfaceCPtr(), b2);
+ }
+</pre>
+</div>
+
+<p>
+Note that each Java interface has a method added to obtain the correct C++ pointer for passing to the native function -
+<tt>Base1_GetInterfaceCPtr</tt> for <tt>Base1</tt>.
+This method is similar to the <tt>getCPtr</tt> method in the proxy classes.
+In fact, as shown above in the <tt>Derived</tt> class, the proxy classes implement
+this generated interface by calling a native method (<tt>Derived_Base1_GetInterfaceCPtr</tt>)
+which calls an appropriate C++ cast of the pointer up the inheritance chain.
+</p>
+
+<p>
+The interface macros are implemented using the <tt>interface</tt> feature and typemaps.
+For example:
+</p>
+
+<div class="code">
+<pre>
+%define %interface(CTYPE...)
+%feature("interface", name="%sSwigInterface") CTYPE;
+INTERFACE_TYPEMAPS(CTYPE)
+%enddef
+</pre>
+</div>
+
+<p>
+The feature accepts one attribute called <tt>name</tt>, which is the name of the Java interface mentioned earlier.
+The <tt>INTERFACE_TYPEMAPS</tt> macro implements the typemaps and can be viewed in the
+<tt>swiginterface.i</tt> file and contain
+the usual Java typemaps for generating code plus the <tt>javainterfacecode</tt>
+typemap which is only used when a class is marked with the <tt>interface</tt> feature.
+See <a href="Java.html#Java_code_typemaps">Java code typemaps</a> for details.
+</p>
+
+<H2><a name="Java_directors">25.5 Cross language polymorphism using directors</a></H2>
<p>
Neither C++ code nor Java code needs to know where a particular method is implemented: the combination of proxy classes, director classes, and C wrapper functions transparently takes care of all the cross-language method routing.
</p>
-<H3><a name="Java_enabling_directors"></a>24.5.1 Enabling directors</H3>
+<H3><a name="Java_enabling_directors">25.5.1 Enabling directors</a></H3>
<p>
</pre>
</div>
-<H3><a name="Java_directors_classes"></a>24.5.2 Director classes</H3>
+<H3><a name="Java_directors_classes">25.5.2 Director classes</a></H3>
<p>
</p>
-<H3><a name="Java_directors_overhead"></a>24.5.3 Overhead and code bloat</H3>
+<H3><a name="Java_directors_overhead">25.5.3 Overhead and code bloat</a></H3>
<p>
</p>
-<H3><a name="Java_directors_example"></a>24.5.4 Simple directors example</H3>
+<H3><a name="Java_directors_example">25.5.4 Simple directors example</a></H3>
<p>
</pre>
</div>
-<H3><a name="Java_directors_threading"></a>24.5.5 Director threading issues</H3>
+<H3><a name="Java_directors_threading">25.5.5 Director threading issues</a></H3>
<p>
</pre>
</div>
-<H3><a name="Java_directors_performance"></a>24.5.6 Director performance tuning</H3>
+<H3><a name="Java_directors_performance">25.5.6 Director performance tuning</a></H3>
<p>
The disadvantage is that invocation of director methods from C++ when Java doesn't actually override the method will require an additional call up into Java and back to C++. As such, this option is only useful when overrides are extremely common and instantiation is frequent enough that its performance is critical.
</p>
+<H3><a name="Java_exceptions_from_directors">25.5.7 Java exceptions from directors</a></H3>
+
+
+<p>
+With directors routing method calls to Java, and proxies routing them
+to C++, the handling of exceptions is an important concern.
+The default behavior from SWIG 3.0
+onwards is to convert the thrown Java exception into a SWIG defined
+<code>DirectorException</code> C++ exception.
+SWIG 2.0 and earlier versions didn't provide any mechanism to handle the Java director method exceptions in C++.
+</p>
+
+<p>
+Converting Java exceptions into C++ exceptions can be done in two different ways using
+the <code>director:except</code> <a href="Customization.html#Customization_features">feature</a>.
+In the simplest approach, a code block is attached to each director method to
+handle the mapping of Java exceptions into C++ exceptions.
+</p>
+
+<div class="code">
+<pre>
+%feature("director:except") MyClass::method(int x) {
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ jenv->ExceptionClear();
+ if (Swig::ExceptionMatches(jenv, $error, "java/lang/IndexOutOfBoundsException"))
+ throw std::out_of_range(Swig::JavaExceptionMessage(jenv, $error).message());
+ if (Swig::ExceptionMatches(jenv, $error, "$packagepath/MyJavaException"))
+ throw MyCppException(Swig::JavaExceptionMessage(jenv, $error).message());
+ throw std::runtime_error("Unexpected exception thrown in MyClass::method");
+ }
+}
+
+class MyClass {
+ /** Throws either a std::out_of_range or MyCppException on error */
+ void method(int x);
+}
+</pre>
+</div>
+
+<p>
+This approach allows a flexible mapping of Java exceptions thrown by director methods into
+C++ exceptions expected by a C++ caller. There
+need not be any C++ <em>exception specifications</em> on the C++ method. The
+utility function <code>Swig::ExceptionMatches</code>
+and class <code>Swig::JavaExceptionMessage</code> are provided to simplify
+writing code for wrappers that use the <code>director:except</code> feature. The
+function <code>Swig::ExceptionMatches</code> matches the type of the
+<code>jthrowable</code> thrown against a <b>fully qualified</b> JNI style class
+name, such as <code>"java/lang/IOError"</code>. If the throwable class is the same
+type, or derives from the given type, <code>Swig::ExceptionMatches</code> will return true. Care must be taken to
+provide the correct fully qualified name, since for wrapped exceptions the
+generated proxy class will have additional package qualification, depending on
+the '-package' argument and use of the <a href="#Java_namespaces">nspace
+ feature</a>. The special variable <code>$error</code> is expanded by SWIG into a unique variable name and
+should be used for the
+assignment of the exception that occurred. The special variable <code>$packagepath</code> is
+replaced by the outer package provided for SWIG generation by the -package
+option. The utility class <code>Swig::JavaExceptionMessage</code> is a holder
+providing access to the message from the thrown Java exception.
+The <code>message()</code> method returns the exception message as a <code>const char *</code>,
+which is only valid during the lifetime of the holder. Any code using this message
+needs to copy it, for example into a std::string or a newly constructed C++ exception.
+</p>
+
+<p>
+Using the above approach to
+write handlers for a large number of methods will require
+repetitive duplication of the <code>director:except</code> feature code.
+To mitigate this, an alternative approach is provided via typemaps in a
+fashion analagous to
+the <a href="Typemaps.html#throws_typemap">"throws" typemap.</a> The
+"throws" typemap provides an approach to automatically map all the C++
+exceptions listed in a method's defined exceptions (either from
+a C++ <em>exception specification</em> or a <code>%catches</code>
+feature) into Java exceptions.
+The "directorthrows" typemap provides the inverse mapping and should contain
+code to convert a suitably matching Java exception into a C++ exception.
+The example below converts a Java <code>java.lang.IndexOutOfBoundsException</code> exception
+to the typemap's type, that is <code>std::out_of_range</code>:
+
+<div class="code">
+<pre>
+%typemap(directorthrows) std::out_of_range %{
+ if (Swig::ExceptionMatches(jenv, $error, "java/lang/IndexOutOfBoundsException")) {
+ throw std::out_of_range(Swig::JavaExceptionMessage(jenv, $error).message());
+ }
+%}
+</pre>
+</div>
+
+<p>
+The "directorthrows" typemap is then used in conjunction with the
+<code>director:except</code> feature if the <code>$directorthrowshandlers</code> special variable
+is used in the feature code. Consider the following, which also happens to be the default:
+</p>
+
+<div class="code">
+<pre>
+%feature("director:except") %{
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ jenv->ExceptionClear();
+ $directorthrowshandlers
+ throw Swig::DirectorException(jenv, $error);
+ }
+%}
+</pre>
+</div>
+
+<p>The code generated using the <code>director:except</code> feature
+replaces the <code>$directorthrowshandlers</code> special variable with the code in
+the "directorthrows" typemaps, for each and every exception defined for the method.
+The possible exceptions can be defined either with a C++ exception
+specification or <code>%catches</code> as described for the
+<a href="Typemaps.html#throws_typemap">"throws" typemap</a>.
+</p>
+
+<p>
+Consider the following director method:
+</p>
+
+<div class="code">
+<pre>
+ ...
+ virtual void doSomething(int index) throw (std::out_of_range);
+ ...
+</pre>
+</div>
+
+<p>
+When combined with the default <code>director:except</code> feature and the "directorthrows" typemap above,
+the resulting code generated in the director method after calling up to Java will be:
+</p>
+
+<div class="code">
+<pre>
+jthrowable swigerror = jenv->ExceptionOccurred();
+if (swigerror) {
+ jenv->ExceptionClear();
+ if (Swig::ExceptionMatches(jenv, swigerror, "java/lang/IndexOutOfBoundsException")) {
+ throw std::out_of_range(Swig::JavaExceptionMessage(jenv, swigerror).message());
+ }
+
+ throw Swig::DirectorException(jenv, swigerror);
+}
+</pre>
+</div>
+
+<p><em>
+Note: Beware of using exception specifications as the SWIG director methods
+will be generated with the same exception specifications and if the
+director method throws an exception that is not specified it is likely
+to terminate your program. See the C++ standard for more details.
+Using the %catches feature instead to define the handled exceptions does not suffer
+this potential fate.
+</em></p>
+
+<p>Because the default code generation maps any unhandled Java exceptions to
+<code>Swig::DirectorException</code>, any director methods that have exception
+specifications may cause program termination. To simply ignore
+unexpected exceptions, the default handling can be changed with:
+</p>
+
+<div class="code">
+<pre>
+%feature("director:except") %{
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ jenv->ExceptionClear();
+ $directorthrowshandlers
+ return $null; // exception is ignored
+ }
+%}
+</pre>
+</div>
+
+<p>Alternatively an exception compatible with the existing director
+method exception specifications can be thrown. Assuming that all
+methods allow std::runtime_error to be thrown,
+the <code>return $null;</code> could be changed to:
+</p>
+
+<div class="code">
+<pre>
+ throw std::runtime_error(Swig::JavaExceptionMessage(jenv, $error).message());
+</pre>
+</div>
+
+<p>In more complex situations, a separate <code>director:except</code> feature
+may need to be attached to specific methods.
+</p>
+
+<p>Below is a complete example demonstrating the use
+of the "directorthrows" typemaps. In this example, a
+generic "directorthrows" typemap is appropriate for all three exceptions - all
+take single string constructors. If the exceptions had different constructors,
+it would be necessary to have separate typemaps for each exception type.
+
+
+<!-- All the DEFINE_ and DECLARE_EXCEPTIONS CAN BE OMITTED to make
+ this more succinct. They are included to make this a complete
+ example interface that could be generated and built. -->
+<div class="code">
+<pre>
+%module(directors="1") example
+
+%{
+ #include <string>
+ #include <stdexcept>
+%}
+
+// Define exceptions in header section using std::runtime_error
+%define DEFINE_EXCEPTION(NAME)
+%{
+ namespace MyNS {
+ struct NAME : public std::runtime_error { NAME(const std::string &what) : runtime_error(what) {} };
+ }
+%}
+%enddef
+
+// Expose C++ exceptions as Java Exceptions by changing the Java base class and providing a getMessage()
+%define DECLARE_EXCEPTION(NAME)
+%typemap(javabase) MyNS::NAME "java.lang.Exception";
+%rename(getMessage) MyNS::NAME::what;
+namespace MyNS {
+ struct NAME {
+ NAME(const std::string& what);
+ const char * what();
+ };
+}
+%enddef
+
+DEFINE_EXCEPTION(ExceptionA)
+DEFINE_EXCEPTION(ExceptionB)
+DEFINE_EXCEPTION(Unexpected)
+
+// Mark three methods to map director thrown exceptions.
+%feature("director:except") MyClass::meth1(int);
+%feature("director:except") MyClass::meth2;
+%feature("director:except") meth3;
+
+%typemap(directorthrows) MyNS::ExceptionA, MyNS::ExceptionB, MyNS::Unexpected %{
+ if (Swig::ExceptionMatches(jenv, $error, "$packagepath/$javaclassname"))
+ throw $1_type(Swig::JavaExceptionMessage(jenv, $error).message());
+%}
+
+DECLARE_EXCEPTION(ExceptionA)
+DECLARE_EXCEPTION(ExceptionB)
+DECLARE_EXCEPTION(Unexpected)
+
+%catches(MyNS::ExceptionA, MyNS::ExceptionB, MyNS::Unexpected) MyClass::meth2();
+
+%inline {
+ class MyClass {
+ public:
+ virtual void meth1(int x) throw(MyNS::ExceptionA, MyNS::ExceptionB) = 0;
+ virtual void meth2() = 0; /* throws MyNS::ExceptionA, MyNS::ExceptionB, MyNS::Unexpected */
+ virtual void meth3(float x) throw(MyNS::Unexpected) = 0;
+ virtual ~MyClass() {}
+ };
+}
+</pre>
+</div>
+
+<p>
+In this case the three different "directorthrows" typemaps will be used
+to generate the three different exception handlers for
+<code>meth1</code>, <code>meth2</code> and <code>meth3</code>. The generated
+handlers will have "if" blocks for each exception type specified, in
+the exception specification or <code>%catches</code> feature.
+</p>
+
+<p>Note that the "directorthrows" typemaps are important
+only if it is important for the the exceptions passed through the C++
+layer to be mapped to distinct C++ exceptions. If director methods
+are being called by C++ code that is itself wrapped in a
+SWIG generated Java wrapper and access is always through this wrapper,
+the default <code>Swig::DirectorException</code> class provides enough information
+to reconstruct the original exception. In this case removing the
+<code>$directorthrowshandlers</code> special variable from the
+default <code>director:except</code> feature and simply always
+throwing a <code>Swig::DirectorException</code> will achieve the desired result.
+Along with this a generic exception feature is added to convert any
+caught <code>Swig::DirectorException</code>s back into the underlying
+Java exceptions via the <code>Swig::DirectorException::raiseJavaException</code> method,
+as demonstrated with <code>%javaexception</code> below:
+</p>
-<H2><a name="Java_allprotected"></a>24.6 Accessing protected members</H2>
+<div class="code">
+<pre>
+%javaexception("Exception") MyClass::myMethod %{
+ try {
+ $action
+ } catch (Swig::DirectorException &e) {
+ // raise/throw the Java exception that originally caused the DirectorException
+ e.raiseJavaException(jenv);
+ return $null;
+ }
+%}
+</pre>
+</div>
+
+<p>
+See the <a href="#Java_exception_handling">Exception handling with %exception and %javaexception</a>
+section for more on converting C++ exceptions to Java exceptions.
+</p>
+
+<H2><a name="Java_allprotected">25.6 Accessing protected members</a></H2>
<p>
-<H2><a name="Java_common_customization"></a>24.7 Common customization features</H2>
+<H2><a name="Java_common_customization">25.7 Common customization features</a></H2>
<p>
to improve the interface to existing C/C++ code.
</p>
-<H3><a name="Java_helper_functions"></a>24.7.1 C/C++ helper functions</H3>
+<H3><a name="Java_helper_functions">25.7.1 C/C++ helper functions</a></H3>
<p>
customization features as covered in later sections, but sometimes helper functions are a quick and easy solution to difficult cases.
</p>
-<H3><a name="Java_class_extension"></a>24.7.2 Class extension with %extend</H3>
+<H3><a name="Java_class_extension">25.7.2 Class extension with %extend</a></H3>
<p>
in any way---the extensions only show up in the Java interface.
</p>
-<H3><a name="Java_exception_handling"></a>24.7.3 Exception handling with %exception and %javaexception</H3>
+<H3><a name="Java_exception_handling">25.7.3 Exception handling with %exception and %javaexception</a></H3>
<p>
<p>
If no declaration name is given to <tt>%exception</tt>, it is applied to all wrapper functions.
-The <tt> $action </tt> is a SWIG special variable and is replaced by the C/C++ function call being wrapped.
-The <tt> return $null; </tt> handles all native method return types, namely those that have a void return and those that do not.
+The <tt>$action</tt> is a SWIG special variable and is replaced by the C/C++ function call being wrapped.
+The <tt>return $null;</tt> handles all native method return types, namely those that have a void return and those that do not.
This is useful for typemaps that will be used in native method returning all return types.
See the section on
<a href="#Java_special_variables">Java special variables</a> for further explanation.
The typemap example <a href="#Java_exception_typemap">Handling C++ exception specifications as Java exceptions</a> provides further exception handling capabilities.
</p>
-<H3><a name="Java_method_access"></a>24.7.4 Method access with %javamethodmodifiers</H3>
+<H3><a name="Java_method_access">25.7.4 Method access with %javamethodmodifiers</a></H3>
<p>
</pre>
</div>
-<H2><a name="Java_tips_techniques"></a>24.8 Tips and techniques</H2>
+<H2><a name="Java_tips_techniques">25.8 Tips and techniques</a></H2>
<p>
solving these problems.
</p>
-<H3><a name="Java_input_output_parameters"></a>24.8.1 Input and output parameters using primitive pointers and references</H3>
+<H3><a name="Java_input_output_parameters">25.8.1 Input and output parameters using primitive pointers and references</a></H3>
<p>
will not have the intended effect since <tt>typemaps.i</tt> does not define an OUTPUT rule for <tt>Bar</tt>.
</p>
-<H3><a name="Java_simple_pointers"></a>24.8.2 Simple pointers</H3>
+<H3><a name="Java_simple_pointers">25.8.2 Simple pointers</a></H3>
<p>
See the <a href="Library.html#Library">SWIG Library</a> chapter for further details.
</p>
-<H3><a name="Java_c_arrays"></a>24.8.3 Wrapping C arrays with Java arrays</H3>
+<H3><a name="Java_c_arrays">25.8.3 Wrapping C arrays with Java arrays</a></H3>
<p>
There is an alternative approach using the SWIG array library and this is covered in the next section.
</p>
-<H3><a name="Java_unbounded_c_arrays"></a>24.8.4 Unbounded C Arrays</H3>
+<H3><a name="Java_unbounded_c_arrays">25.8.4 Unbounded C Arrays</a></H3>
<p>
package binary data, etc.
</p>
-<H3><a name="Java_binary_char"></a>24.8.5 Binary data vs Strings</H3>
+<H3><a name="Java_binary_char">25.8.5 Binary data vs Strings</a></H3>
<p>
</pre></div>
-<H3><a name="Java_heap_allocations"></a>24.8.6 Overriding new and delete to allocate from Java heap</H3>
+<H3><a name="Java_heap_allocations">25.8.6 Overriding new and delete to allocate from Java heap</a></H3>
<p>
code.
</p>
-<H2><a name="Java_typemaps"></a>24.9 Java typemaps</H2>
+<H2><a name="Java_typemaps">25.9 Java typemaps</a></H2>
<p>
part of using SWIG---the default wrapping behavior is enough in most cases.
Typemaps are only used if you want to change some aspect of the generated code.
-<H3><a name="Java_default_primitive_type_mappings"></a>24.9.1 Default primitive type mappings</H3>
+<H3><a name="Java_default_primitive_type_mappings">25.9.1 Default primitive type mappings</a></H3>
<p>
</p>
-<H3><a name="Java_default_non_primitive_typemaps"></a>24.9.2 Default typemaps for non-primitive types</H3>
+<H3><a name="Java_default_non_primitive_typemaps">25.9.2 Default typemaps for non-primitive types</a></H3>
<p>
The Java type is either the proxy class or type wrapper class.
</p>
-<H3><a name="Java_jvm64"></a>24.9.3 Sixty four bit JVMs</H3>
+<H3><a name="Java_jvm64">25.9.3 Sixty four bit JVMs</a></H3>
<p>
</p>
-<H3><a name="Java_what_is_typemap"></a>24.9.4 What is a typemap?</H3>
+<H3><a name="Java_what_is_typemap">25.9.4 What is a typemap?</a></H3>
<p>
</pre>
</div>
-<H3><a name="Java_typemaps_c_to_java_types"></a>24.9.5 Typemaps for mapping C/C++ types to Java types</H3>
+<H3><a name="Java_typemaps_c_to_java_types">25.9.5 Typemaps for mapping C/C++ types to Java types</a></H3>
<p>
<td>Use for mapping NULL terminated arrays of C strings to Java String arrays</td>
</tr>
+<tr>
+<td>unsigned char *</td>
+<td>NIOBUFFER</td>
+<td>various.i</td>
+<td>input<br> output</td>
+<td>java.nio.Buffer</td>
+<td>Use for mapping directly allocated buffers to c/c++. useful with directors and long lived memory objects</td>
+</tr>
+
</table>
-<H3><a name="Java_typemap_attributes"></a>24.9.6 Java typemap attributes</H3>
+<H3><a name="Java_typemap_attributes">25.9.6 Java typemap attributes</a></H3>
<p>
Note that when the 'pre' or 'post' attributes are specified and the associated type is used in a constructor, a constructor helper function is generated. This is necessary as the Java proxy constructor wrapper makes a call to a support constructor using a <i>this</i> call. In Java the <i>this</i> call must be the first statement in the constructor body. The constructor body thus calls the helper function and the helper function instead makes the JNI call, ensuring the 'pre' code is called before the JNI call is made. There is a <a href="#Java_date_marshalling">Date marshalling</a> example showing 'pre', 'post' and 'pgcppname' attributes in action.
</p>
-<H3><a name="Java_special_variables"></a>24.9.7 Java special variables</H3>
+<H3><a name="Java_special_variables">25.9.7 Java special variables</a></H3>
<p>
expands to the proxy classname when wrapping <tt>Foo *&</tt>.
If the type does not have an associated proxy class, it expands to the type wrapper class name, for example,
<tt>SWIGTYPE_p_unsigned_short</tt> is generated when wrapping <tt>unsigned short *</tt>.
+The class name is fully qualified with the package name when using the
+<a href="SWIGPlus.html#SWIGPlus_nspace">nspace feature</a>.
</p>
<p>
</p>
<p>
-<b><tt>$null </tt></b><br>
+<b><tt>$null</tt></b><br>
Used in input typemaps to return early from JNI functions that have either void or a non-void return type. Example:
</p>
</p>
<p>
-<b><tt>$jniinput, $javacall and $packagepath</tt></b><br>
+<b><tt>$error, $jniinput, $javacall and $packagepath</tt></b><br>
These special variables are used in the directors typemaps. See <a href="#Java_directors_typemaps">Director specific typemaps</a> for details.
</p>
unless the jniclassname attribute is specified in the <a href="Java.html#Java_module_directive">%module directive</a>.
</p>
-<H3><a name="Java_typemaps_for_c_and_cpp"></a>24.9.8 Typemaps for both C and C++ compilation</H3>
+<p>
+<b><tt>$javainterfacename</tt></b><br>
+This special variable is only expanded when the <tt>interface</tt> feature is applied to a class.
+It works much like <tt>$javaclassname</tt>, but instead of expanding to the proxy classname,
+it expands to the value in the <tt>name</tt> attribute in the <tt>interface</tt> feature.
+For example:
+</p>
+
+<div class="code"><pre>
+%feature("interface", name="MyInterface") MyClass;
+%typemap(jstype) MyClass "$&javainterfacename"
+%typemap(jstype) MyClass * "$javainterfacename"
+</pre></div>
+
+<p>
+will result in the <tt>jstype</tt> typemap expanding to <tt>MyInterface</tt> for both
+<tt>MyClass</tt> and <tt>MyClass *</tt>.
+The interface name is fully qualified with the package name when using the
+<a href="SWIGPlus.html#SWIGPlus_nspace">nspace feature</a>.
+</p>
+
+<p>
+<b><tt>$interfacename</tt></b><br>
+This special variable is only expanded when the <tt>interface</tt> feature is applied to a class.
+It expands to just the interface name and is thus different to <tt>$javainterfacename</tt>
+in that it is not fully qualified with the package name when using the
+<a href="SWIGPlus.html#SWIGPlus_nspace">nspace feature</a>.
+</p>
+
+<H3><a name="Java_typemaps_for_c_and_cpp">25.9.8 Typemaps for both C and C++ compilation</a></H3>
<p>
</p>
-<H3><a name="Java_code_typemaps"></a>24.9.9 Java code typemaps</H3>
+<H3><a name="Java_code_typemaps">25.9.9 Java code typemaps</a></H3>
<p>
</div>
+<p><tt>%typemap(javainterfacecode, declaration="...", cptrmethod="...")</tt></p>
+<div class="indent">
+<p>
+The code in this typemap is added to the body of a Java proxy class but only when a class is
+marked with the <tt>interface</tt> feature.
+The typemap is used in the proxy class marked with the interface feature as well as all proxy classes derived from the marked C++ class,
+as they are all generated as implementing the Java interface.
+The default typemap used in the <tt>%interface</tt> family of macros mentioned in
+the <a href="Java.html#Java_interfaces">Java interfaces</a> section,
+where <tt>CTYPE</tt> is the C++ class macro argument,
+is as follows:
+</p>
+
+<div class="code"><pre>
+%typemap(javainterfacecode,
+ declaration=" long $interfacename_GetInterfaceCPtr();\n",
+ cptrmethod="$interfacename_GetInterfaceCPtr") CTYPE %{
+ public long $interfacename_GetInterfaceCPtr() {
+ return $imclassname.$javaclazzname$interfacename_GetInterfaceCPtr(swigCPtr);
+ }
+%}
+</pre></div>
+</div>
+
+<p>
+The special variable <tt>$interfacename</tt> is expanded into the
+name specified in the <tt>interface</tt> feature.
+</p>
+
<p>
<b>Compatibility Note:</b> In SWIG-1.3.21 and earlier releases, typemaps called "javagetcptr" and "javaptrconstructormodifiers" were available.
These are deprecated and the "javabody" typemap can be used instead.
+The <tt>javainterfacecode</tt> typemap and interface feature was introduced in SWIG-3.0.9.
</p>
<p>
[ javafinalize typemap ]
public synchronized void <i>delete</i>() [ javadestruct OR javadestruct_derived typemap ]
[ javacode typemap ]
+[ javainterfacecode typemap]
... proxy functions ...
}
</pre>
</p>
<p>
+The <tt>javainterfacecode</tt> typemap is only used when bases are marked by the <tt>interface</tt>
+feature and the <tt>implements</tt> list will also then be expanded to include these Java interfaces.
+</p>
+
+<p>
The type wrapper class is similar in construction:
</p>
The "javaimports" typemap is ignored if the enum class is wrapped by an inner Java class, that is when wrapping an enum declared within a C++ class.
</p>
+<p>The Java interface turned on by the <tt>interface</tt> feature is fairly simple:</p>
+<div class="code">
+<pre>
+[ javaimports typemap ]
+public interface [ javainterfacename ] {
+[ javainterfacecode:cptrmethod typemap attribute ]
+... interface declarations ...
+}
+</pre>
+</div>
+
<p>
-The defaults can be overridden to tailor these classes.
+where <tt>javainterfacename</tt> is the <tt>name</tt> attribute in the <a href="Java.html#Java_interfaces">interface feature</a>.
+</p>
+
+<p>
+The defaults can be overridden to tailor the generated classes.
Here is an example which will change the <tt>getCPtr</tt> method and constructor from the default public access to protected access.
If the classes in one package are not using the classes in another package, then these methods need not be public and removing access to these low level implementation details, is a good thing.
If you are invoking SWIG more than once and generating the wrapped classes into different packages in each invocation, then you cannot do this as you will then have different packages.
<div class="code">
<pre>
%typemap(javabody) SWIGTYPE %{
- private long swigCPtr;
- protected boolean swigCMemOwn;
+ private transient long swigCPtr;
+ protected transient boolean swigCMemOwn;
protected $javaclassname(long cPtr, boolean cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
<div class="code">
<pre>
%typemap(javabody) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
- private long swigCPtr;
+ private transient long swigCPtr;
protected $javaclassname(long cPtr, boolean bFutureUse) {
swigCPtr = cPtr;
</p>
<p>
-When using <a href="Modules.html">multiple modules</a> or the <a href="#Java_namespaces">nspace feature</a> it is common to invoke SWIG with a different <tt>-package</tt>
+When using <a href="Modules.html
#Modules">multiple modules</a> or the <a href="#Java_namespaces">nspace feature</a> it is common to invoke SWIG with a different <tt>-package</tt>
command line option for each module.
However, by default the generated code may not compile if
generated classes in one package use generated classes in another package.
</pre>
</div>
-<H3><a name="Java_directors_typemaps"></a>24.9.10 Director specific typemaps</H3>
+<H3><a name="Java_directors_typemaps">25.9.10 Director specific typemaps</a></H3>
<p>
If the <tt>-package</tt> commandline option is not used to specify the package, then '$packagepath/' will be removed from the resulting output JNI field descriptor.
<b>Do not forget the terminating ';' for JNI field descriptors starting with 'L'.</b>
If the ';' is left out, Java will generate a "method not found" runtime error.
+Note that the <code>$packagepath</code> substitution always uses the path separator '/' when expanded.
+The <code>$javaclassname</code> expansion can be confusing as it is normally expanded using the '.' separator.
+However, <code>$javaclassname</code> is expanded using the path separator '/' in typemap's "descriptor" attribute
+as well as in the "directorthrows" typemap.
</p>
</div>
</div>
+<p><tt>%typemap(directorthrows)</tt></p>
+<div class="indent">
+
+<p>
+Conversion of Java exceptions to C++ exceptions in director method's exception handling.
+This typemap is expected to test the <tt>$error</tt> special variable for a matching Java exception
+and if successful convert and throw it into a C++ exception given by the typemap's type.
+The <code>$error</code> special variable is of type <code>jthrowable</code> and is
+substituted with a unique variable name in the generated code.
+</p>
+
+<p>
+The example below converts a Java <code>java.lang.IndexOutOfBoundsException</code> exception
+to the typemap's type, that is <code>std::out_of_range</code>:
+</p>
+
+<div class="code">
+<pre>
+%typemap(directorthrows) std::out_of_range %{
+ if (Swig::ExceptionMatches(jenv, $error, "java/lang/IndexOutOfBoundsException")) {
+ throw std::out_of_range(Swig::JavaExceptionMessage(jenv, $error).message());
+ }
+%}
+</pre>
+</div>
+
+<p>
+The utility function <code>Swig::ExceptionMatches</code>
+and class <code>Swig::JavaExceptionMessage</code> are helpers available when using directors and are described
+in the <a href="#Java_exceptions_from_directors">Java Exceptions from Directors</a> section.
+</p>
+
+</div>
+
<p><tt>%typemap(javapackage)</tt></p>
<div class="indent">
</div>
-<H2><a name="Java_typemap_examples"></a>24.10 Typemap Examples</H2>
+<H2><a name="Java_typemap_examples">25.10 Typemap Examples</a></H2>
<p>
</p>
-<H3><a name="Java_simpler_enum_classes"></a>24.10.1 Simpler Java enums for enums without initializers</H3>
+<H3><a name="Java_simpler_enum_classes">25.10.1 Simpler Java enums for enums without initializers</a></H3>
<p>
</p>
-<H3><a name="Java_exception_typemap"></a>24.10.2 Handling C++ exception specifications as Java exceptions</H3>
+<H3><a name="Java_exception_typemap">25.10.2 Handling C++ exception specifications as Java exceptions</a></H3>
<p>
</p>
-<H3><a name="Java_nan_exception_typemap"></a>24.10.3 NaN Exception - exception handling for a particular type</H3>
+<H3><a name="Java_nan_exception_typemap">25.10.3 NaN Exception - exception handling for a particular type</a></H3>
<p>
If we had, we would have put it in the "in" typemap which, like all JNI and Java typemaps, also supports the 'throws' attribute.
</p>
-<H3><a name="Java_converting_java_string_arrays"></a>24.10.4 Converting Java String arrays to char ** </H3>
+<H3><a name="Java_converting_java_string_arrays">25.10.4 Converting Java String arrays to char ** </a></H3>
<p>
what Java types to use.
</p>
-<H3><a name="Java_expanding_java_object"></a>24.10.5 Expanding a Java object to multiple arguments</H3>
+<H3><a name="Java_expanding_java_object">25.10.5 Expanding a Java object to multiple arguments</a></H3>
<p>
</div>
-<H3><a name="Java_using_typemaps_return_arguments"></a>24.10.6 Using typemaps to return arguments</H3>
+<H3><a name="Java_using_typemaps_return_arguments">25.10.6 Using typemaps to return arguments</a></H3>
<p>
*out1 = a*10.0;
*out2 = b*100.0;
return status;
-};
+}
%}
/*
1 12.0 340.0
</pre></div>
-<H3><a name="Java_adding_downcasts"></a>24.10.7 Adding Java downcasts to polymorphic return types</H3>
+<H3><a name="Java_adding_downcasts">25.10.7 Adding Java downcasts to polymorphic return types</a></H3>
<p>
Note that the JNI code above uses a number of string lookups to call a constructor, whereas this would not occur using byte compiled Java code.
</p>
-<H3><a name="Java_adding_equals_method"></a>24.10.8 Adding an equals method to the Java classes</H3>
+<H3><a name="Java_adding_equals_method">25.10.8 Adding an equals method to the Java classes</a></H3>
<p>
</div>
-<H3><a name="Java_void_pointers"></a>24.10.9 Void pointers and a common Java base class</H3>
+<H3><a name="Java_void_pointers">25.10.9 Void pointers and a common Java base class</a></H3>
<p>
<li> It also has a function which effectively implements a cast from the type of the proxy/type wrapper class to a void pointer. This is necessary for passing a proxy class or a type wrapper class to a function that takes a void pointer.
</ul>
-<H3><a name="Java_struct_pointer_pointer"></a>24.10.10 Struct pointer to pointer</H3>
+<H3><a name="Java_struct_pointer_pointer">25.10.10 Struct pointer to pointer</a></H3>
<p>
the Butler class would behave much like any pure Java class and feel more natural to Java users.
</p>
-<H3><a name="Java_memory_management_member_variables"></a>24.10.11 Memory management when returning references to member variables</H3>
+<H3><a name="Java_memory_management_member_variables">25.10.11 Memory management when returning references to member variables</a></H3>
<p>
Note the <tt>addReference</tt> call.
</p>
-<H3><a name="Java_memory_management_objects"></a>24.10.12 Memory management for objects passed to the C++ layer</H3>
+<H3><a name="Java_memory_management_objects">25.10.12 Memory management for objects passed to the C++ layer</a></H3>
<p>
</div>
-<H3><a name="Java_date_marshalling"></a>24.10.13 Date marshalling using the javain typemap and associated attributes</H3>
+<H3><a name="Java_date_marshalling">25.10.13 Date marshalling using the javain typemap and associated attributes</a></H3>
<p>
-<H2><a name="Java_directors_faq"></a>24.11 Living with Java Directors</H2>
+<H2><a name="Java_directors_faq">25.11 Living with Java Directors</a></H2>
<p>
</li>
</ol>
-<H2><a name="Java_odds_ends"></a>24.12 Odds and ends</H2>
+<H2><a name="Java_odds_ends">25.12 Odds and ends</a></H2>
-<H3><a name="Java_javadoc_comments"></a>24.12.1 JavaDoc comments</H3>
+<H3><a name="Java_javadoc_comments">25.12.1 JavaDoc comments</a></H3>
<p>
-<H3><a name="Java_functional_interface"></a>24.12.2 Functional interface without proxy classes</H3>
+<H3><a name="Java_functional_interface">25.12.2 Functional interface without proxy classes</a></H3>
<p>
</p>
-<H3><a name="Java_using_own_jni_functions"></a>24.12.3 Using your own JNI functions</H3>
+<H3><a name="Java_using_own_jni_functions">25.12.3 Using your own JNI functions</a></H3>
<p>
</p>
-<H3><a name="Java_performance"></a>24.12.4 Performance concerns and hints</H3>
+<H3><a name="Java_performance">25.12.4 Performance concerns and hints</a></H3>
<p>
This method normally calls the C++ destructor or <tt>free()</tt> for C code.
</p>
-<H3><a name="Java_debugging"></a>24.12.5 Debugging</H3>
+<H3><a name="Java_debugging">25.12.5 Debugging</a></H3>
<p>
<p>
Alternatively, debugging can involve placing debug printout statements in the JNI layer using the <tt>%exception</tt> directive.
See the <a href="Customization.html#Customization_exception_special_variables">special variables for %exception</a> section.
-Many of the default typemaps can also be overidden and modified for adding in extra logging/debug display information.
+Many of the default typemaps can also be overridden and modified for adding in extra logging/debug display information.
</p>
<p>
</p>
-<H2><a name="Java_examples"></a>24.13 Java Examples</H2>
+<H2><a name="Java_examples">25.13 Java Examples</a></H2>
<p>
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<link rel="stylesheet" type="text/css" href="./style.css">
+<title></title>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
+</head>
+<body>
+
+<H1><a name="Javascript">26 SWIG and Javascript</a></H1>
+<!-- INDEX -->
+<div class="sectiontoc">
+<ul>
+<li><a href="#Javascript_overview">Overview</a>
+<li><a href="#Javascript_preliminaries">Preliminaries</a>
+<ul>
+<li><a href="#Javascript_running_swig">Running SWIG</a>
+<li><a href="#Javascript_running_tests_examples">Running Tests and Examples</a>
+<li><a href="#Javascript_known_issues">Known Issues</a>
+</ul>
+<li><a href="#Javascript_integration">Integration</a>
+<ul>
+<li><a href="#Javascript_node_extensions">Creating node.js Extensions</a>
+<ul>
+<li><a href="#Javascript_troubleshooting">Troubleshooting</a>
+</ul>
+<li><a href="#Javascript_embedded_webkit">Embedded Webkit</a>
+<ul>
+<li><a href="#Javascript_osx">Mac OS X</a>
+<li><a href="#Javascript_gtk">GTK</a>
+</ul>
+<li><a href="#Javascript_applications_webkit">Creating Applications with node-webkit</a>
+</ul>
+<li><a href="#Javascript_examples">Examples</a>
+<ul>
+<li><a href="#Javascript_simple_example">Simple</a>
+<li><a href="#Javascript_class_example">Class</a>
+</ul>
+<li><a href="#Javascript_implementation">Implementation</a>
+<ul>
+<li><a href="#Javascript_source_code">Source Code</a>
+<li><a href="#Javascript_code_templates">Code Templates</a>
+<li><a href="#Javascript_emitter">Emitter</a>
+<li><a href="#Javascript_emitter_states">Emitter states</a>
+<li><a href="#Javascript_jsc_exceptions">Handling Exceptions in JavascriptCore</a>
+</ul>
+</ul>
+</div>
+<!-- INDEX -->
+
+
+
+<p>This chapter describes SWIG's support of Javascript. It does not cover SWIG basics, but only information that is specific to this module.</p>
+
+<H2><a name="Javascript_overview">26.1 Overview</a></H2>
+
+
+<p>Javascript is a prototype-based scripting language that is dynamic, weakly typed and has first-class functions. Its arguably the most popular language for web development.
+Javascript has gone beyond being a browser-based scripting language and with <a href="http://nodejs.org">node.js</a>, it is also used as a backend development language.</p>
+<p>Native Javascript extensions can be used for applications that embed a web-browser view or that embed a Javascript engine (such as <em>node.js</em>). Extending a general purpose web-browser is not possible as this would be a severe security issue.</p>
+<p>SWIG Javascript currently supports <strong>JavascriptCore</strong>, the Javascript engine used by <code>Safari/Webkit</code>, and <a href="https://developers.google.com/v8"><strong>v8</strong></a>, which is used by <code>Chromium</code> and <code>node.js</code>.</p>
+<p><a href="http://www.webkit.org/">WebKit</a> is a modern browser implementation available as open-source which can be embedded into an application.
+With <a href="https://github.com/rogerwang/node-webkit">node-webkit</a> there is a platform which uses Google's <code>Chromium</code> as Web-Browser widget and <code>node.js</code> for javascript extensions.
+</p>
+
+<H2><a name="Javascript_preliminaries">26.2 Preliminaries</a></H2>
+
+
+<H3><a name="Javascript_running_swig">26.2.1 Running SWIG</a></H3>
+
+
+<p>Suppose that you defined a SWIG module such as the following:</p>
+<div class="code">
+<pre>
+%module example
+%{
+#include "example.h"
+%}
+int gcd(int x, int y);
+extern double Foo;</pre>
+</div>
+<p>To build a Javascript module, run SWIG using the <code>-javascript</code> option and a desired target engine <code>-jsc</code>, <code>-v8</code>, or <code>-node</code>. The generator for <code>node</code> is essentially delegating to the <code>v8</code> generator and adds some necessary preprocessor definitions.</p>
+<div class="shell">
+<pre>
+$ swig -javascript -jsc example.i</pre>
+</div>
+<p>If building a C++ extension, add the -c++ option:</p>
+<div class="shell">
+<pre>
+$ swig -c++ -javascript -jsc example.i</pre>
+</div>
+<p>The V8 code that SWIG generates should work with most versions from 3.11.10 up to 3.29.14 and later.</p>
+<p>The API headers for V8 >= 4.3.0 define constants which SWIG can use to
+determine the V8 version it is compiling for. For versions < 4.3.0, you
+need to specify the V8 version when running SWIG. 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. For example:</p>
+<div class="shell">
+<pre>
+$ swig -c++ -javascript -v8 -DV8_VERSION=0x032530 example.i</pre>
+</div>
+<p>If you're targetting V8 >= 4.3.0, you would just run swig like so:</p>
+<div class="shell">
+<pre>
+$ swig -c++ -javascript -v8 example.i</pre>
+</div>
+<p>This creates a C/C++ source file <code>example_wrap.c</code> or <code>example_wrap.cxx</code>. The generated C source file contains the low-level wrappers that need to be compiled and linked with the rest of your C/C++ application to create an extension module.</p>
+<p>The name of the wrapper file is derived from the name of the input file. For example, if the input file is <code>example.i</code>, the name of the wrapper file is <code>example_wrap.c</code>. To change this, you can use the -o option. The wrapped module will export one function which must be called to register the module with the Javascript interpreter. For example, if your module is named <code>example</code> the corresponding initializer for JavascriptCore would be</p>
+<div class="code">
+<pre>
+bool example_initialize(JSGlobalContextRef context, JSObjectRef *exports)</pre>
+</div>
+<p>and for v8:</p>
+<div class="code">
+<pre>
+void example_initialize(v8::Handle<v8::Object> exports)</pre>
+</div>
+<p>
+<b>Note</b>: be aware that <code>v8</code> has a C++ API, and thus, the generated modules must be compiled as C++.
+</p>
+
+<H3><a name="Javascript_running_tests_examples">26.2.2 Running Tests and Examples</a></H3>
+
+
+<p>The configuration for tests and examples currently supports Linux and Mac only and not MinGW (Windows) yet.</p>
+<p>The default interpreter is <code>node.js</code> as it is available on all platforms and convenient to use.</p>
+<p>Running the examples with JavascriptCore requires <code>libjavascriptcoregtk-1.0</code> to be installed, e.g., under Ubuntu with</p>
+<div class="shell">
+<pre>
+$ sudo apt-get install libjavascriptcoregtk-1.0-dev</pre>
+</div>
+<p>Running with <code>V8</code> requires <code>libv8</code>:</p>
+<div class="shell">
+<pre>
+$ sudo apt-get install libv8-dev</pre>
+</div>
+<p>Examples can be run using</p>
+<div class="shell">
+<pre>
+$ make check-javascript-examples ENGINE=jsc</pre>
+</div>
+<p><code>ENGINE</code> can be <code>node</code>, <code>jsc</code>, or <code>v8</code>.</p>
+<p>The test-suite can be run using</p>
+<div class="shell">
+<pre>
+$ make check-javascript-test-suite ENGINE=jsc</pre>
+</div>
+<p>You can specify a specific <code>V8</code> version for running the examples and tests</p>
+<div class="shell">
+<pre>
+$ make check-javascript-examples V8_VERSION=0x032530 ENGINE=v8</pre>
+</div>
+
+<H3><a name="Javascript_known_issues">26.2.3 Known Issues</a></H3>
+
+
+<p>At the moment, the Javascript generators pass all tests syntactically, i.e., the generated source code compiles. However, there are still remaining runtime issues.</p>
+
+<ul>
+ <li><p>Default optional arguments do not work for all targeted interpreters</p></li>
+ <li><p>Multiple output arguments do not work for JSC</p></li>
+ <li><p>C89 incompatibily: the JSC generator might still generate C89 violating code</p></li>
+ <li><p><code>long long</code> is not supported</p></li>
+ <li><p><code>%native</code> is not supported</p></li>
+ <li><p>Javascript callbacks are not supported</p></li>
+ <li><p><code>instanceOf</code> does not work under JSC</p></li>
+</ul>
+
+<p>The primary development environment has been Linux (Ubuntu 12.04). Windows and Mac OS X have been tested sporadically. Therefore, the generators might have more issues on those platforms. Please report back any problem you observe to help us improving this module quickly.</p>
+
+<H2><a name="Javascript_integration">26.3 Integration</a></H2>
+
+
+<p>This chapter gives a short introduction how to use a native Javascript extension: as a <code>node.js</code> module, and as an extension for an embedded Webkit.</p>
+
+<H3><a name="Javascript_node_extensions">26.3.1 Creating node.js Extensions</a></H3>
+
+
+<p>To install <code>node.js</code> you can download an installer from their <a href="https://launchpad.net/~chris-lea/+archive/node.js">web-site</a> for Mac OS X and Windows. For Linux you can either build the source yourself and run <code>sudo checkinstall</code> or keep to the (probably stone-age) packaged version. For Ubuntu there is a <a href="https://launchpad.net/~chris-lea/+archive/ubuntu/node.js/">PPA</a> available.</p>
+<div class="shell">
+<pre>
+$ sudo add-apt-repository ppa:chris-lea/node.js
+$ sudo apt-get update
+$ sudo apt-get install nodejs</pre>
+</div>
+<p>As <code>v8</code> is written in C++ and comes as a C++ library it is crucial to compile your module using the same compiler flags as used for building v8. To make things easier, <code>node.js</code> provides a build tool called <code>node-gyp</code>.</p>
+<p>You have to install it using <code>npm</code>:</p>
+<div class="shell">
+<pre>
+$ sudo npm install -g node-gyp</pre>
+</div>
+<p><code>node-gyp</code> expects a configuration file named <code>binding.gyp</code> which is basically in JSON format and conforms to the same format that is used with Google's build-tool <code>gyp</code>.</p>
+<p><code>binding.gyp</code>:</p>
+<div class="code">
+<pre>
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "example.cxx", "example_wrap.cxx" ]
+ }
+ ]
+}</pre>
+</div>
+<p>First create the wrapper using SWIG:</p>
+<div class="shell">
+<pre>
+$ swig -javascript -node -c++ example.i</pre>
+</div>
+<p>Then run <code>node-gyp build</code> to actually create the module:</p>
+<div class="shell">
+<pre>
+$ node-gyp build</pre>
+</div>
+<p>This will create a <code>build</code> folder containing the native module. To use the extension you need to 'require' it in your Javascript source file:</p>
+<div class="code">
+<pre>
+require("./build/Release/example")</pre>
+</div>
+<p>A more detailed explanation is given in the <a href="#Javascript_examples">Examples</a> section.</p>
+
+<H4><a name="Javascript_troubleshooting">26.3.1.1 Troubleshooting</a></H4>
+
+
+<ul>
+<li><em>'module' object has no attribute 'script_main'</em></li>
+</ul>
+<p>This error happens when <code>gyp</code> is installed as a distribution package. It seems to be outdated. Removing it resolves the problem.</p>
+<div class="shell">
+<pre>
+$ sudo apt-get remove gyp</pre>
+</div>
+
+<H3><a name="Javascript_embedded_webkit">26.3.2 Embedded Webkit</a></H3>
+
+
+<p>Webkit is pre-installed on Mac OS X and available as a library for GTK.</p>
+
+<H4><a name="Javascript_osx">26.3.2.1 Mac OS X</a></H4>
+
+
+<p>There is general information about programming with WebKit on <a href="https://developer.apple.com/library/mac/documentation/cocoa/conceptual/DisplayWebContent/DisplayWebContent.html">Apple Developer Documentation</a>. Details about <code>Cocoa</code> programming are not covered here.</p>
+<p>An integration of a native extension 'example' would look like this:</p>
+<div class="code">
+<pre>
+#import "appDelegate.h"
+
+extern bool example_initialize(JSGlobalContextRef context, JSObjectRef* exports);
+
+
+@implementation ExampleAppDelegate
+
+@synthesize webView;
+
+- (void)addGlobalObject:(JSContextRef) context:(NSString *)objectName:(JSObjectRef) theObject {
+ JSObjectRef global = JSContextGetGlobalObject(context);
+ JSStringRef objectJSName = JSStringCreateWithCFString( (CFStringRef) objectName )
+ if ( objectJSName != NULL ) {
+ JSObjectSetProperty(context, global, objectJSName, theObject, kJSPropertyAttributeReadOnly, NULL);
+ JSStringRelease( objectJSName );
+ }
+}
+
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
+
+ // Start a webview with the bundled index.html file
+ NSString *path = [[NSBundle mainBundle] bundlePath];
+ NSString *url = [NSString stringWithFormat: @"file://%@/Contents/Assets/index.html", path];
+
+ WebFrame *webframe = [webView mainFrame];
+ JSGlobalContextRef context = [webframe globalContext];
+
+ JSObjectRef example;
+ example_initialize(context, &example);
+ [self addGlobalObject:context:@"example":example]
+
+ JSObjectSetProperty(context, global, JSStringRef propertyName, example, JSPropertyAttributes attributes, NULL);
+
+ [ [webView mainFrame] loadRequest:
+ [NSURLRequest requestWithURL: [NSURL URLWithString:url] ]
+ ];
+}
+
+@end</pre>
+</div>
+
+<H4><a name="Javascript_gtk">26.3.2.2 GTK</a></H4>
+
+
+<p>There is general information about programming GTK at <a href="https://developer.gnome.org/gtk2/">GTK documentation</a> and in the <a href="https://developer.gnome.org/gtk-tutorial">GTK tutorial</a>, and for Webkit there is a <a href="http://webkitgtk.org/reference/webkitgtk/stable/index.html">Webkit GTK+ API Reference</a>.</p>
+<p>An integration of a native extension 'example' would look like this:</p>
+<div class="code">
+<pre>
+#include <gtk/gtk.h>
+#include <webkit/webkit.h>
+
+extern bool example_initialize(JSGlobalContextRef context);
+
+int main(int argc, char* argv[])
+{
+ // Initialize GTK+
+ gtk_init(&argc, &argv);
+
+ ...
+
+ // Create a browser instance
+ WebKitWebView *webView = WEBKIT_WEB_VIEW(webkit_web_view_new());
+ WebFrame *webframe = webkit_web_view_get_main_frame(webView);
+ JSGlobalContextRef context = webkit_web_frame_get_global_context(webFrame);
+ JSObjectRef global = JSContextGetGlobalObject(context);
+
+ JSObjectRef exampleModule;
+ example_initialize(context, &exampleModule);
+ JSStringRef jsName = JSStringCreateWithUTF8CString("example");
+ JSObjectSetProperty(context, global, jsName, exampleModule, kJSPropertyAttributeReadOnly, NULL);
+ JSStringRelease(jsName);
+
+ ...
+
+ // Load a web page into the browser instance
+ webkit_web_view_load_uri(webView, "http://www.webkitgtk.org/");
+
+ ...
+
+ // Run the main GTK+ event loop
+ gtk_main();
+
+ return 0;
+}</pre>
+</div>
+
+<H3><a name="Javascript_applications_webkit">26.3.3 Creating Applications with node-webkit</a></H3>
+
+
+<p>To get started with <code>node-webkit</code> there is a very informative set of <a href="https://github.com/rogerwang/node-webkit/wiki">wiki pages</a>.</p>
+<p>Similar to <code>node.js</code>, <code>node-webkit</code> is started from command line within a <code>node.js</code> project directory.
+Native extensions are created in the very same way as for <code>node.js</code>, except that a customized <code>gyp</code> derivate has to be used: <a href="https://github.com/rogerwang/nw-gyp">nw-gyp</a>.
+</p>
+
+<p>
+A simple example would have the following structure:
+</p>
+
+<div class="code">
+<pre>
+- package.json
+- app.html
+- app.js
+- node_modules
+ / example
+ ... (as known from node.js)
+</pre>
+</div>
+
+<p>
+The configuration file essentially conforms to <code>node.js</code> syntax.
+It has some extras to configure <code>node-webkit</code>. See the <a href="https://github.com/rogerwang/node-webkit/wiki/Manifest-format">Manifest</a> specification for more details.
+</p>
+
+<p>
+<code>package.json</code>:
+</p>
+<div class="code">
+<pre>
+{
+ "name": "example",
+ "main": "app.html",
+ "window": {
+ "show": true,
+ "width": 800,
+ "height": 600
+ }
+}</pre>
+</div>
+
+<p>
+The <code>'main'</code> property of <code>package.json</code> specifies a web-page to be rendered in
+the main window.</p>
+
+<p>
+<code>app.html</code>:
+</p>
+
+<div class="code">
+<pre>
+<html>
+ <head>
+ <script src="app.js"></script>
+ </head>
+ <body>
+ <div>
+ The greatest common divisor of
+ <span id="x"></span> and
+ <span id="y"></span> is
+ <span id="z"></span>.
+ </div>
+ </body>
+</html></pre>
+</div>
+
+<p>
+As known from <code>node.js</code> one can use <code>require</code> to load javascript modules.
+Additionally, <code>node-webkit</code> provides an API that allows to manipulate the window's menu,
+open new windows, and many more things.
+</p>
+
+<p>
+<code>app.js</code>:
+</p>
+
+<div class="code">
+<pre>window.onload = function() {
+ var example = require("example");
+ var x = 18;
+ var y = 24;
+ var z = example.gcd(x,y);
+ document.querySelector('#x').innerHTML = x;
+ document.querySelector('#y').innerHTML = y;
+ document.querySelector('#z').innerHTML = z;
+};</pre>
+</div>
+
+<H2><a name="Javascript_examples">26.4 Examples</a></H2>
+
+
+<p>Some basic examples are shown here in more detail.</p>
+
+<H3><a name="Javascript_simple_example">26.4.1 Simple</a></H3>
+
+
+<p>The common example <code>simple</code> looks like this:</p>
+<div class="code">
+<pre>
+/* File : example.i */
+%module example
+
+%inline %{
+extern int gcd(int x, int y);
+extern double Foo;
+%}</pre>
+</div>
+<p>To make this available as a node extension a <code>binding.gyp</code> has to be created:</p>
+<div class="code">
+<pre>
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "example.cxx", "example_wrap.cxx" ]
+ }
+ ]
+}</pre>
+</div>
+<p>Then <code>node-gyp</code> is used to build the extension:</p>
+<div class="shell">
+<pre>
+$ node-gyp configure build</pre>
+</div>
+<p>From a 'nodejs` application the extension would be used like this:</p>
+<div class="code">
+<pre>
+// import the extension via require
+var example = require("./build/Release/example");
+
+// calling the global method
+var x = 42;
+var y = 105;
+var g = example.gcd(x,y);
+
+// Accessing the global variable
+var f = example.Foo;
+example.Foo = 3.1415926;</pre>
+</div>
+<p>First the module <code>example</code> is loaded from the previously built extension. Global methods and variables are available in the scope of the module.</p>
+
+<p><b>Note</b>: ECMAScript 5, the currently implemented Javascript standard, does not have modules. <code>node.js</code> and other implementations provide this mechanism defined by the <a href="http://wiki.commonjs.org/wiki/CommonJS">CommonJS</a> group. For browsers this is provided by <a href="http://browserify.org">Browserify</a>, for instance.</p>
+
+<H3><a name="Javascript_class_example">26.4.2 Class</a></H3>
+
+
+<p>The common example <code>class</code> defines three classes, <code>Shape</code>, <code>Circle</code>, and <code>Square</code>:</p>
+<div class="code">
+<pre>
+class Shape {
+public:
+ Shape() {
+ nshapes++;
+ }
+ virtual ~Shape() {
+ nshapes--;
+ }
+ double x, y;
+ void move(double dx, double dy);
+ virtual double area(void) = 0;
+ virtual double perimeter(void) = 0;
+ static int nshapes;
+};
+
+class Circle : public Shape {
+private:
+ double radius;
+public:
+ Circle(double r) : radius(r) { }
+ virtual double area(void);
+ virtual double perimeter(void);
+};
+
+class Square : public Shape {
+private:
+ double width;
+public:
+ Square(double w) : width(w) { }
+ virtual double area(void);
+ virtual double perimeter(void);
+};</pre>
+</div>
+<p><code>Circle</code> and <code>Square</code> inherit from <code>Shape</code>. <code>Shape</code> has a static variable <code>nshapes</code>, a function <code>move</code> that can't be overridden (non-virtual), and two abstract functions <code>area</code> and <code>perimeter</code> (pure virtual) that must be overridden by the sub-classes.</p>
+<p>A <code>nodejs</code> extension is built the same way as for the <code>simple</code> example.</p>
+<p>In Javascript it can be used as follows:</p>
+<div class="code">
+<pre>
+var example = require("./build/Release/example");
+
+// local aliases for convenience
+var Shape = example.Shape;
+var Circle = example.Circle;
+var Square = example.Square;
+
+// creating new instances using the 'new' operator
+var c = new Circle(10);
+var s = new Square(10);
+
+// accessing a static member
+Shape.nshapes;
+
+// accessing member variables
+c.x = 20;
+c.y = 30;
+s.x = -10;
+s.y = 5;
+
+// calling some methods
+c.area();
+c.perimeter();
+s.area();
+s.perimeter();
+
+// instantiation of Shape is not permitted
+new Shape();</pre>
+</div>
+<p>Running these commands in an interactive node shell results in the following output:</p>
+<div class="shell">
+<pre>
+$ node -i
+& var example = require("./build/Release/example");
+undefined
+& var Shape = example.Shape;
+undefined
+& var Circle = example.Circle;
+undefined
+& var Square = example.Square;
+undefined
+& var c = new Circle(10);
+undefined
+& var s = new Square(10);
+undefined
+& Shape.nshapes;
+2
+& c.x = 20;
+20
+& c.y = 30;
+30
+& s.x = -10;
+-10
+& s.y = 5;
+5
+& c.area();
+314.1592653589793
+& c.perimeter();
+62.83185307179586
+& s.area();
+100
+& s.perimeter();
+40
+& c.move(40, 40)
+undefined
+& c.x
+60
+& c.y
+70
+& new Shape()
+Error: Class Shape can not be instantiated
+at repl:1:2
+at REPLServer.self.eval (repl.js:110:21)
+at Interface.<anonymous> (repl.js:239:12)
+at Interface.EventEmitter.emit (events.js:95:17)
+at Interface._onLine (readline.js:202:10)
+at Interface._line (readline.js:531:8)
+at Interface._ttyWrite (readline.js:760:14)
+at ReadStream.onkeypress (readline.js:99:10)
+at ReadStream.EventEmitter.emit (events.js:98:17)
+at emitKey (readline.js:1095:12)</pre>
+</div>
+<p>
+<b>Note</b>: In ECMAScript 5 there is no concept for classes. Instead each function can be used as a constructor function which is executed by the 'new' operator. Furthermore, during construction the key property <code>prototype</code> of the constructor function is used to attach a prototype instance to the created object. A prototype is essentially an object itself that is the first-class delegate of a class used whenever the access to a property of an object fails. The very same prototype instance is shared among all instances of one type. Prototypal inheritance is explained in more detail on in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain">Inheritance and the prototype chain</a>, for instance.
+</p>
+
+<H2><a name="Javascript_implementation">26.5 Implementation</a></H2>
+
+
+<p>The Javascript Module implementation has taken a very different approach compared to other language modules in order to support different Javascript interpreters.</p>
+
+<H3><a name="Javascript_source_code">26.5.1 Source Code</a></H3>
+
+
+<p>The Javascript module is implemented in <code>Source/Modules/javascript.cxx</code>. It dispatches the code generation to a <code>JSEmitter</code> instance, <code>V8Emitter</code> or <code>JSCEmitter</code>. Additionally there are some helpers: <code>Template</code>, for templated code generation, and <code>JSEmitterState</code>, which is used to manage state information during AST traversal. This rough map shall make it easier to find a way through this huge source file:</p>
+<div class="code">
+<pre>
+// module wide defines
+
+#define NAME "name"
+...
+
+// ###############################
+// # Helper class declarations
+
+class JSEmitterState { ... };
+
+class Template { ... };
+
+// ###############################
+// # JSEmitter declaration
+
+class JSEmitter { ... };
+
+// Emitter factory declarations
+
+JSEmitter *swig_javascript_create_JSCEmitter();
+JSEmitter *swig_javascript_create_V8Emitter();
+
+// ###############################
+// # Javascript module
+
+// Javascript module declaration
+
+class JAVASCRIPT:public Language { ... };
+
+// Javascript module implementation
+
+int JAVASCRIPT::functionWrapper(Node *n) { ... }
+...
+
+// Module factory implementation
+
+static Language *new_swig_javascript() { ... }
+
+extern "C" Language *swig_javascript(void) { ... }
+
+// ###############################
+// # JSEmitter base implementation
+
+JSEmitter::JSEmitter() { ... }
+
+Template JSEmitter::getTemplate(const String *name) { ... }
+...
+
+// ###############################
+// # JSCEmitter
+
+// JSCEmitter declaration
+
+class JSCEmitter: public JSEmitter { ... };
+
+// JSCEmitter implementation
+
+JSCEmitter::JSCEmitter() { ... }
+
+void JSCEmitter::marshalInputArgs(Node *n, ParmList *parms, Wrapper *wrapper, MarshallingMode mode, bool is_member, bool is_static) { ... }
+...
+
+// JSCEmitter factory
+
+JSEmitter *swig_javascript_create_JSCEmitter() { ... }
+
+
+// ###############################
+// # V8Emitter
+
+// V8Emitter declaration
+
+class V8Emitter: public JSEmitter { ... };
+
+// V8Emitter implementation
+
+V8Emitter::V8Emitter() { ... }
+
+int V8Emitter::initialize(Node *n) { ... }
+
+// V8Emitter factory
+
+JSEmitter *swig_javascript_create_V8Emitter() { ... }
+
+
+// ###############################
+// # Helper implementation (JSEmitterState, Template)
+
+JSEmitterState::JSEmitterState() { ... }
+...
+
+Template::Template(const String *code_) { ... }
+...</pre>
+</div>
+
+<H3><a name="Javascript_code_templates">26.5.2 Code Templates</a></H3>
+
+
+<p>All generated code is created on the basis of code templates. The templates for <em>JavascriptCore</em> can be found in <code>Lib/javascript/jsc/javascriptcode.swg</code>, for <em>v8</em> in <code>Lib/javascript/v8/javascriptcode.swg</code>.</p>
+<p>To track the originating code template for generated code you can run</p>
+<div class="shell">
+<pre>
+$ swig -javascript -jsc -debug-codetemplates</pre>
+</div>
+<p>which wraps generated code with a descriptive comment</p>
+<div class="code">
+<pre>
+/* begin fragment("template_name") */
+
+...generated code ...
+
+/* end fragment("template_name") */</pre>
+</div>
+<p>The Template class is used like this:</p>
+<div class="code">
+<pre>
+Template t_register = getTemplate("jsv8_register_static_variable");
+t_register.replace("$jsparent", state.clazz(NAME_MANGLED))
+ .replace("$jsname", state.variable(NAME))
+ .replace("$jsgetter", state.variable(GETTER))
+ .replace("$jssetter", state.variable(SETTER))
+ .trim().
+ print(f_init_static_wrappers);</pre>
+</div>
+<p>A code template is registered with the <em>JSEmitter</em> via <code>fragment(name, "template")</code>, e.g.,</p>
+<div class="code">
+<pre>
+%fragment ("jsc_variable_declaration", "templates")
+%{
+ {"$jsname", $jsgetter, $jssetter, kJSPropertyAttributeNone},
+%}</pre>
+</div>
+<p><code>Template</code> creates a copy of that string and <code>Template::replace</code> uses Swig's <code>Replaceall</code> to replace variables in the template. <code>Template::trim</code> can be used to eliminate leading and trailing whitespaces. <code>Template::print</code> is used to write the final template string to a Swig <code>DOH</code> (based on <code>Printv</code>). All methods allow chaining.</p>
+
+<H3><a name="Javascript_emitter">26.5.3 Emitter</a></H3>
+
+
+<p>The Javascript module delegates code generation to a <code>JSEmitter</code> instance. The following extract shows the essential interface:</p>
+<div class="code">
+<pre>
+class JSEmitter {
+ ...
+
+ /**
+ * Opens output files and temporary output DOHs.
+ */
+ virtual int initialize(Node *n);
+
+ /**
+ * Writes all collected code into the output file(s).
+ */
+ virtual int dump(Node *n) = 0;
+
+ /**
+ * Cleans up all open output DOHs.
+ */
+ virtual int close() = 0;
+
+ ...
+
+ /**
+ * Invoked at the beginning of the classHandler.
+ */
+ virtual int enterClass(Node *);
+
+ /**
+ * Invoked at the end of the classHandler.
+ */
+ virtual int exitClass(Node *) {
+ return SWIG_OK;
+ }
+
+ /**
+ * Invoked at the beginning of the variableHandler.
+ */
+ virtual int enterVariable(Node *);
+
+ /**
+ * Invoked at the end of the variableHandler.
+ */
+ virtual int exitVariable(Node *) {
+ return SWIG_OK;
+ }
+
+ /**
+ * Invoked at the beginning of the functionHandler.
+ */
+ virtual int enterFunction(Node *);
+
+ /**
+ * Invoked at the end of the functionHandler.
+ */
+ virtual int exitFunction(Node *) {
+ return SWIG_OK;
+ }
+
+ /**
+ * Invoked by functionWrapper callback after call to Language::functionWrapper.
+ */
+ virtual int emitWrapperFunction(Node *n);
+
+ /**
+ * Invoked from constantWrapper after call to Language::constantWrapper.
+ **/
+ virtual int emitConstant(Node *n);
+
+ /**
+ * Registers a given code snippet for a given key name.
+ *
+ * This method is called by the fragmentDirective handler
+ * of the JAVASCRIPT language module.
+ **/
+ int registerTemplate(const String *name, const String *code);
+
+ /**
+ * Retrieve the code template registered for a given name.
+ */
+ Template getTemplate(const String *name);
+
+ State &getState();
+
+ ...
+
+}</pre>
+</div>
+<p>The module calls <code>initialize</code>, <code>dump</code>, and <code>close</code> from within the <code>top</code> method:</p>
+<div class="code">
+<pre>
+int JAVASCRIPT::top(Node *n) {
+ emitter->initialize(n);
+
+ Language::top(n);
+
+ emitter->dump(n);
+ emitter->close();
+
+ return SWIG_OK;
+}</pre>
+</div>
+<p>The methods <code>enterClass</code> and <code>exitClass</code> are called from within the <code>classHandler</code> method:</p>
+<div class="code">
+<pre>
+int JAVASCRIPT::classHandler(Node *n) {
+
+ emitter->enterClass(n);
+ Language::classHandler(n);
+ emitter->exitClass(n);
+
+ return SWIG_OK;
+}</pre>
+</div>
+<p>In <code>enterClass</code> the emitter stores state information that is necessary when processing class members. In <code>exitClass</code> the wrapper code for the whole class is generated.</p>
+
+<H3><a name="Javascript_emitter_states">26.5.4 Emitter states</a></H3>
+
+
+<p>For storing information during the AST traversal the emitter provides a <code>JSEmitterState</code> with different slots to store data representing the scopes global, class, function, and variable.</p>
+<div class="code">
+<pre>
+class JSEmitterState {
+
+public:
+
+ JSEmitterState();
+
+ ~JSEmitterState();
+
+ DOH *global();
+
+ DOH *global(const char* key, DOH *initial = 0);
+
+ DOH *clazz(bool reset = false);
+
+ DOH *clazz(const char* key, DOH *initial = 0);
+
+ DOH *function(bool reset = false);
+
+ DOH *function(const char* key, DOH *initial = 0);
+
+ DOH *variable(bool reset = false);
+
+ DOH *variable(const char* key, DOH *initial = 0);
+
+ static int IsSet(DOH *val);
+
+ ...
+};</pre>
+</div>
+<p>When entering a scope, such as in <code>enterClass</code>, the corresponding state is reset and new data is stored:</p>
+<div class="code">
+<pre>
+state.clazz(RESET);
+state.clazz(NAME, Getattr(n, "sym:name"));</pre>
+</div>
+<p>State information can be retrieved using <code>state.clazz(NAME)</code> or with <code>Getattr</code> on <code>state.clazz()</code> which actually returns a <code>Hash</code> instance.</p>
+
+
+<H3><a name="Javascript_jsc_exceptions">26.5.5 Handling Exceptions in JavascriptCore</a></H3>
+
+
+<p>Applications with an embedded JavascriptCore should be able to present detailed exception messages that occur in the Javascript engine. Below is an example derived from code provided by Brian Barnes on how these exception details can be extracted.</p>
+<div class="code">
+<pre>
+void script_exception_to_string(JSContextRef js_context,JSValueRef exception_value_ref,char* return_error_string, int return_error_string_max_length)
+{
+ JSObjectRef exception_object;
+ JSValueRef value_ref;
+ JSStringRef jsstring_property_name = NULL;
+ JSValueRef temporary_exception = NULL;
+ JSStringRef js_return_string = NULL;
+ size_t bytes_needed;
+ char* c_result_string = NULL;
+ exception_object = JSValueToObject(js_context, exception_value_ref, NULL);
+
+ /* source url */
+ strcpy(return_error_string,"[");
+ jsstring_property_name = JSStringCreateWithUTF8CString("sourceURL");
+ value_ref = JSObjectGetProperty(js_context, exception_object, jsstring_property_name, &temporary_exception);
+ JSStringRelease(jsstring_property_name);
+ js_return_string = JSValueToStringCopy(js_context, value_ref, NULL);
+ bytes_needed = JSStringGetMaximumUTF8CStringSize(js_return_string);
+ c_result_string = (char*)calloc(bytes_needed, sizeof(char));
+ JSStringGetUTF8CString(js_return_string, c_result_string, bytes_needed);
+ JSStringRelease(js_return_string);
+ strncat(return_error_string, c_result_string, return_error_string_max_length-1);
+ free(c_result_string);
+
+ strncat(return_error_string, ":", return_error_string_max_length-1);
+
+ /* line number */
+
+ jsstring_property_name = JSStringCreateWithUTF8CString("line");
+ value_ref = JSObjectGetProperty(js_context, exception_object, jsstring_property_name, &temporary_exception);
+ JSStringRelease(jsstring_property_name);
+ js_return_string = JSValueToStringCopy(js_context, value_ref, NULL);
+ bytes_needed = JSStringGetMaximumUTF8CStringSize(js_return_string);
+ c_result_string = (char*)calloc(bytes_needed, sizeof(char));
+ JSStringGetUTF8CString(js_return_string, c_result_string, bytes_needed);
+ JSStringRelease(js_return_string);
+ strncat(return_error_string, c_result_string, return_error_string_max_length-1);
+ free(c_result_string);
+
+ strncat(return_error_string, "]", return_error_string_max_length-1);
+
+ /* error message */
+
+ jsstring_property_name = JSStringCreateWithUTF8CString("message");
+ value_ref = JSObjectGetProperty(js_context, exception_object, jsstring_property_name, &temporary_exception);
+ JSStringRelease(jsstring_property_name);
+ if(NULL == value_ref)
+ {
+ strncat(return_error_string, "Unknown Error", return_error_string_max_length-1);
+ }
+ else
+ {
+ js_return_string = JSValueToStringCopy(js_context, value_ref, NULL);
+ bytes_needed = JSStringGetMaximumUTF8CStringSize(js_return_string);
+ c_result_string = (char*)calloc(bytes_needed, sizeof(char));
+ JSStringGetUTF8CString(js_return_string, c_result_string, bytes_needed);
+ JSStringRelease(js_return_string);
+ strncat(return_error_string, c_result_string, return_error_string_max_length-1);
+ free(c_result_string);
+ }
+}</pre>
+</div>
+
+<p>It would be used in the following way:</p>
+<div class="code">
+<pre>
+if(js_exception)
+{
+ char return_error_string[256];
+ script_exception_to_string(js_context, js_exception, return_error_string, 256);
+ printf("Compile error is %s", return_error_string);
+}</pre>
+</div>
+
+</body>
+</html>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG Library</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Library"></a>8 SWIG library</H1>
+<H1><a name="Library">9 SWIG library</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#Library_std_vector">std::vector</a>
<li><a href="#Library_stl_exceptions">STL exceptions</a>
<li><a href="#Library_std_shared_ptr">shared_ptr smart pointer</a>
+<li><a href="#Library_std_auto_ptr">auto_ptr smart pointer</a>
</ul>
<li><a href="#Library_nn16">Utility Libraries</a>
<ul>
carefully if you used the old libraries.
</p>
-<H2><a name="Library_nn2"></a>8.1 The %include directive and library search path</H2>
+<H2><a name="Library_nn2">9.1 The %include directive and library search path</a></H2>
<p>
The directories that are searched are displayed when using <tt>-verbose</tt> commandline option.
</p>
-<H2><a name="Library_nn3"></a>8.2 C Arrays and Pointers</H2>
+<H2><a name="Library_nn3">9.2 C Arrays and Pointers</a></H2>
<p>
memory, their use is potentially unsafe and you should exercise caution.
</p>
-<H3><a name="Library_nn4"></a>8.2.1 cpointer.i</H3>
+<H3><a name="Library_nn4">9.2.1 cpointer.i</a></H3>
<p>
<b>Note:</b> When working with simple pointers, typemaps can often be used to provide more seamless operation.
</p>
-<H3><a name="Library_carrays"></a>8.2.2 carrays.i</H3>
+<H3><a name="Library_carrays">9.2.2 carrays.i</a></H3>
<p>
used with types of <tt>char</tt> or <tt>char *</tt>.
</p>
-<H3><a name="Library_nn6"></a>8.2.3 cmalloc.i</H3>
+<H3><a name="Library_nn6">9.2.3 cmalloc.i</a></H3>
<p>
</pre>
</div>
-<H3><a name="Library_nn7"></a>8.2.4 cdata.i</H3>
+<H3><a name="Library_nn7">9.2.4 cdata.i</a></H3>
<p>
Clearly they are unsafe.
</p>
-<H2><a name="Library_nn8"></a>8.3 C String Handling</H2>
+<H2><a name="Library_nn8">9.3 C String Handling</a></H2>
<p>
for manipulating raw C strings.
</p>
-<H3><a name="Library_nn9"></a>8.3.1 Default string handling</H3>
+<H3><a name="Library_nn9">9.3.1 Default string handling</a></H3>
<p>
not work well with binary data. Instead, strings are assumed to be NULL-terminated.
</p>
-<H3><a name="Library_nn10"></a>8.3.2 Passing binary data</H3>
+<H3><a name="Library_nn10">9.3.2 Passing binary data</a></H3>
<p>
The <tt>(char *STRING, int LENGTH)</tt> multi-argument typemap is also available in addition to <tt>(char *STRING, size_t LENGTH)</tt>.
</p>
-<H3><a name="Library_nn11"></a>8.3.3 Using %newobject to release memory</H3>
+<H3><a name="Library_nn11">9.3.3 Using %newobject to release memory</a></H3>
<p>
See <a href="Customization.html#Customization_ownership">Object ownership and %newobject</a> for more details.
</p>
-<H3><a name="Library_nn12"></a>8.3.4 cstring.i</H3>
+<H3><a name="Library_nn12">9.3.4 cstring.i</a></H3>
<p>
</li>
</ul>
-<H2><a name="Library_stl_cpp_library"></a>8.4 STL/C++ Library</H2>
+<H2><a name="Library_stl_cpp_library">9.4 STL/C++ Library</a></H2>
<p>
<td><b>SWIG Interface library file</b></td>
</tr>
+<tr> <td>std::auto_ptr</td> <td>memory</td> <td>std_auto_ptr.i</td> </tr>
<tr> <td>std::deque</td> <td>deque</td> <td>std_deque.i</td> </tr>
<tr> <td>std::list</td> <td>list</td> <td>std_list.i</td> </tr>
<tr> <td>std::map</td> <td>map</td> <td>std_map.i</td> </tr>
<tr> <td>std::set</td> <td>set</td> <td>std_set.i</td> </tr>
<tr> <td>std::string</td> <td>string</td> <td>std_string.i</td> </tr>
<tr> <td>std::vector</td> <td>vector</td> <td>std_vector.i</td> </tr>
-<tr> <td>std::shared_ptr</td> <td>shared_ptr</td> <td>std_shared_ptr.i</td> </tr>
+<tr> <td>std::array</td> <td>array (C++11)</td> <td>std_array.i</td> </tr>
+<tr> <td>std::shared_ptr</td> <td>shared_ptr (C++11)</td> <td>std_shared_ptr.i</td> </tr>
</table>
</p>
-<H3><a name="Library_std_string"></a>8.4.1 std::string</H3>
+<H3><a name="Library_std_string">9.4.1 std::string</a></H3>
<p>
</pre>
</div>
-<H3><a name="Library_std_vector"></a>8.4.2 std::vector</H3>
+<H3><a name="Library_std_vector">9.4.2 std::vector</a></H3>
<p>
details and the public API exposed to the interpreter vary.
</p>
-<H3><a name="Library_stl_exceptions"></a>8.4.3 STL exceptions</H3>
+<H3><a name="Library_stl_exceptions">9.4.3 STL exceptions</a></H3>
<p>
Any thrown STL exceptions will then be gracefully handled instead of causing a crash.
</p>
-<H3><a name="Library_std_shared_ptr"></a>8.4.4 shared_ptr smart pointer</H3>
+<H3><a name="Library_std_shared_ptr">9.4.4 shared_ptr smart pointer</a></H3>
<p>
-Some target languages have support for handling the widely used <tt>boost::shared_ptr</tt> smart pointer.
-This smart pointer is also available as <tt>std::tr1::shared_ptr</tt> before it becomes fully standardized as <tt>std::shared_ptr</tt>.
-The <tt>boost_shared_ptr.i</tt> library provides support for <tt>boost::shared_ptr</tt> and <tt>std_shared_ptr.i</tt> provides support for <tt>std::shared_ptr</tt>, but if the following macro is defined as shown, it can be used for <tt>std::tr1::shared_ptr</tt>:
+Some target languages have support for handling the shared_ptr reference counted smart pointer.
+This smart pointer is available in the standard C++11 library as <tt>std::shared_ptr</tt>.
+It was also in TR1 as <tt>std::tr1::shared_ptr</tt> before it was fully standardized.
+Support for the widely used <tt>boost::shared_ptr</tt> is also available.
+</p>
+
+<p>
+In order to use <tt>std::shared_ptr</tt>, the <tt>std_shared_ptr.i</tt> library file should be included:
+</p>
+
+<div class="code">
+<pre>
+%include <std_shared_ptr.i>
+</pre>
+</div>
+
+<p>
+The pre-standard <tt>std::tr1::shared_ptr</tt> can be used by including the following macro before including the <tt>std_shared_ptr.i</tt> library file:
</p>
<div class="code">
</div>
<p>
+In order to use <tt>boost::shared_ptr</tt>, the <tt>boost_shared_ptr.i</tt> library file should be included:
+</p>
+
+<div class="code">
+<pre>
+%include <boost_shared_ptr.i>
+</pre>
+</div>
+
+<p>
You can only use one of these variants of shared_ptr in your interface file at a time.
and all three variants must be used in conjunction with the <tt>%shared_ptr(T)</tt> macro,
where <tt>T</tt> is the underlying pointer type equating to usage <tt>shared_ptr<T></tt>.
</pre>
</div>
-<b>Note:</b> There is currently no support for <tt>%shared_ptr</tt> and the director feature.
+<p>
+<b>Note:</b> There is somewhat limited support for <tt>%shared_ptr</tt> and the director feature
+and the degress of success varies among the different target languages.
+Please help to improve this support by providing patches with improvements.
+</p>
+
+
+<H3><a name="Library_std_auto_ptr">9.4.5 auto_ptr smart pointer</a></H3>
+
+
+<p>
+While <tt>std::auto_ptr</tt> is deprecated in C++11, some existing code may
+still be using it, so SWIG provides limited support for this class:
+<tt>std_auto_ptr.i</tt> defines the typemaps which apply to the functions
+returning objects of this type. Any other use of <tt>std_auto_ptr.i</tt> is not
+directly supported.
+</p>
+
+<p>
+A typical example of use would be
+</p>
+<div class="code">
+<pre>
+%include <std_auto_ptr.i>
+
+%auto_ptr(Klass)
+%inline %{
+class Klass {
+public:
+ // Factory function creating objects of this class:
+ static std::auto_ptr<Klass> Create(int value) {
+ return std::auto_ptr<Klass>(new Klass(value));
+ }
+
+ int getValue() const { return m_value; }
+
+private:
+ DerivedIntValue(int value) : m_value(value) {}
+ int m_value;
+};
+%}
+</pre>
+</div>
+
+<p>
+The returned objects can be used naturally from the target language, e.g. from
+C#:
+</p>
+
+<div class="targetlang">
+<pre>
+Klass k = Klass.Create(17);
+int value = k.getValue();
+</pre>
+</div>
-<H2><a name="Library_nn16"></a>8.5 Utility Libraries</H2>
+<H2><a name="Library_nn16">9.5 Utility Libraries</a></H2>
-<H3><a name="Library_nn17"></a>8.5.1 exception.i</H3>
+<H3><a name="Library_nn17">9.5.1 exception.i</a></H3>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Common Lisp</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Lisp"></a>25 SWIG and Common Lisp</H1>
+<H1><a name="Lisp">27 SWIG and Common Lisp</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
Lisp, Common Foreign Function Interface(CFFI), CLisp and UFFI
foreign function interfaces.
</p>
-<H2><a name="Lisp_nn2"></a>25.1 Allegro Common Lisp</H2>
+<H2><a name="Lisp_nn2">27.1 Allegro Common Lisp</a></H2>
<p>
<a href="Allegrocl.html#Allegrocl">here</a>
</p>
-<H2><a name="Lisp_nn3"></a>25.2 Common Foreign Function Interface(CFFI)</H2>
+<H2><a name="Lisp_nn3">27.2 Common Foreign Function Interface(CFFI)</a></H2>
<p>
files and the various things which you can do with them.
</p>
-<H3><a name="Lisp_nn4"></a>25.2.1 Additional Commandline Options </H3>
+<H3><a name="Lisp_nn4">27.2.1 Additional Commandline Options </a></H3>
<p>
</table>
-<H3><a name="Lisp_nn5"></a>25.2.2 Generating CFFI bindings</H3>
+<H3><a name="Lisp_nn5">27.2.2 Generating CFFI bindings</a></H3>
As we mentioned earlier the ideal way to use SWIG is to use interface
- files. To illustrate the use of it, lets assume that we have a
+ files. To illustrate the use of it, let's assume that we have a
file named <i>test.h</i> with the following C code:
<div class="code"><pre>
(cl:defconstant x (cl:ash 5 -1))
(cffi:defcstruct bar
- (p :short)
- (q :short)
- (a :char)
- (b :char)
- (z :pointer)
- (n :pointer))
+ (p :short)
+ (q :short)
+ (a :char)
+ (b :char)
+ (z :pointer)
+ (n :pointer))
(cffi:defcvar ("my_struct" my_struct)
:pointer)
(cffi:defcstruct foo
- (a :int)
- (b :pointer))
+ (a :int)
+ (b :pointer))
(cffi:defcfun ("pointer_func" pointer_func) :int
(ClosureFun :pointer)
(array :pointer))
(cffi:defcenum color
- :RED
- :BLUE
- :GREEN)
+ :RED
+ :BLUE
+ :GREEN)
</pre></div>
<p>
%feature("export");
%feature("inline") lispsort_double;
-
%feature("intern_function", "my-lispify") lispsort_double;
+%feature("export", package="'some-other-package") lispsort_double;
+
%rename func123 renamed_cool_func;
+
%ignore "pointer_func";
%include "test.h"
lispsort_double;</i>, here we are using an additional feature
which allows us to use our lispify function.
</p>
-<p>The <i>export</i> feature allows us to export the symbols. The <i>inline</i>
- feature declaims the declared function as inline. The <i>rename</i>
- directive allows us to change the name(it is useful when
- generating C wrapper code for handling overloaded
- functions). The <i>ignore</i> directive ignores a certain
- declaration.
+<p>The <i>export</i> feature allows us to export the symbols. If
+ the <i>package</i> argument is given, then the symbol will be exported to
+ the specified Lisp package. The <i>inline</i> feature declaims the
+ declared function as inline. The <i>rename</i> directive allows us to
+ change the name(it is useful when generating C wrapper code for handling
+ overloaded functions). The <i>ignore</i> directive ignores a certain
+ declaration.
</p>
<p>There are several other things which are possible, to see some
example of usage of SWIG look at the Lispbuilder and wxCL
(cl:export '#.(swig-lispify "x" 'constant))
(cffi:defcstruct #.(swig-lispify "bar" 'classname)
- (#.(swig-lispify "p" 'slotname) :short)
- (#.(swig-lispify "q" 'slotname) :short)
- (#.(swig-lispify "a" 'slotname) :char)
- (#.(swig-lispify "b" 'slotname) :char)
- (#.(swig-lispify "z" 'slotname) :pointer)
- (#.(swig-lispify "n" 'slotname) :pointer))
+ (#.(swig-lispify "p" 'slotname) :short)
+ (#.(swig-lispify "q" 'slotname) :short)
+ (#.(swig-lispify "a" 'slotname) :char)
+ (#.(swig-lispify "b" 'slotname) :char)
+ (#.(swig-lispify "z" 'slotname) :pointer)
+ (#.(swig-lispify "n" 'slotname) :pointer))
(cl:export '#.(swig-lispify "bar" 'classname))
(cl:export '#.(swig-lispify "my_struct" 'variable))
(cffi:defcstruct #.(swig-lispify "foo" 'classname)
- (#.(swig-lispify "a" 'slotname) :int)
- (#.(swig-lispify "b" 'slotname) :pointer))
+ (#.(swig-lispify "a" 'slotname) :int)
+ (#.(swig-lispify "b" 'slotname) :pointer))
(cl:export '#.(swig-lispify "foo" 'classname))
(n :int)
(array :pointer))
-(cl:export '#.(my-lispify "lispsort_double" 'function))
+(cl:export '#.(my-lispify "lispsort_double" 'function) 'some-other-package)
(cffi:defcenum #.(swig-lispify "color" 'enumname)
- #.(swig-lispify "RED" 'enumvalue :keyword)
- #.(swig-lispify "BLUE" 'enumvalue :keyword)
- #.(swig-lispify "GREEN" 'enumvalue :keyword))
+ #.(swig-lispify "RED" 'enumvalue :keyword)
+ #.(swig-lispify "BLUE" 'enumvalue :keyword)
+ #.(swig-lispify "GREEN" 'enumvalue :keyword))
(cl:export '#.(swig-lispify "color" 'enumname))
</pre></div>
-<H3><a name="Lisp_nn6"></a>25.2.3 Generating CFFI bindings for C++ code</H3>
+<H3><a name="Lisp_nn6">27.2.3 Generating CFFI bindings for C++ code</a></H3>
<p>This feature to SWIG (for CFFI) is very new and still far from
module feel free to contact us on the SWIG mailing list, and
also please add a "[CFFI]" tag in the subject line.
-<H3><a name="Lisp_nn7"></a>25.2.4 Inserting user code into generated files</H3>
+<H3><a name="Lisp_nn7">27.2.4 Inserting user code into generated files</a></H3>
<p>
</p>
-<H2><a name="Lisp_nn8"></a>25.3 CLISP</H2>
+<H2><a name="Lisp_nn8">27.3 CLISP</a></H2>
<p>
interface file for the CLISP module. The CLISP module tries to
produce code which is both human readable and easily modifyable.
</p>
-<H3><a name="Lisp_nn9"></a>25.3.1 Additional Commandline Options </H3>
+<H3><a name="Lisp_nn9">27.3.1 Additional Commandline Options </a></H3>
<p>
<td>-extern-all</td>
<td>If this option is given then clisp definitions for all the functions<br/>
and global variables will be created otherwise only definitions for<br/>
- externed functions and variables are created.
+externed functions and variables are created.
</td>
</tr>
<tr>
<td>-generate-typedef</td>
<td>If this option is given then def-c-type will be used to generate<br/>
- shortcuts according to the typedefs in the input.
+shortcuts according to the typedefs in the input.
</td>
</tr>
</table>
-<H3><a name="Lisp_nn10"></a>25.3.2 Details on CLISP bindings</H3>
+<H3><a name="Lisp_nn10">27.3.2 Details on CLISP bindings</a></H3>
<p>
As mentioned earlier the CLISP bindings generated by SWIG may need
- some modifications. The clisp module creates a lisp file with
- the same name as the module name. This
- lisp file contains a 'defpackage' declaration, with the
- package name same as the module name. This package uses the
- 'common-lisp' and 'ffi' packages. Also, package exports all
- the functions, structures and variables for which an ffi
- binding was generated.<br/>
- After generating the defpackage statement, the clisp module also
- sets the default language.
+some modifications. The clisp module creates a lisp file with
+the same name as the module name. This
+lisp file contains a 'defpackage' declaration, with the
+package name same as the module name. This package uses the
+'common-lisp' and 'ffi' packages. Also, package exports all
+the functions, structures and variables for which an ffi
+binding was generated.<br/>
+After generating the defpackage statement, the clisp module also
+sets the default language.
<div class="targetlang"><pre>
(defpackage :test
(ffi:def-call-out pointer_func
(:name "pointer_func")
(:arguments (ClosureFun (ffi:c-function (:arguments (arg0 (ffi:c-pointer NIL))
- (arg1 (ffi:c-pointer NIL))
- (arg2 (ffi:c-pointer NIL)))
- (:return-type NIL)))
- (y ffi:int))
+ (arg1 (ffi:c-pointer NIL))
+ (arg2 (ffi:c-pointer NIL)))
+ (:return-type NIL)))
+ (y ffi:int))
(:return-type ffi:int)
(:library +library-name+))
(ffi:def-call-out func123
(:name "func123")
(:arguments (x (ffi:c-pointer div_t))
- (z (ffi:c-ptr (ffi:c-array (ffi:c-ptr (ffi:c-ptr ffi:int)) 100)))
- (y (ffi:c-ptr (ffi:c-ptr (ffi:c-array ffi:int (1000 10))))))
+ (z (ffi:c-ptr (ffi:c-array (ffi:c-ptr (ffi:c-ptr ffi:int)) 100)))
+ (y (ffi:c-ptr (ffi:c-ptr (ffi:c-array ffi:int (1000 10))))))
(:return-type ffi:int)
(:library +library-name+))
(ffi:def-call-out lispsort_double
(:name "lispsort_double")
(:arguments (n ffi:int)
- (array (ffi:c-ptr DOUBLE-FLOAT)))
+ (array (ffi:c-ptr DOUBLE-FLOAT)))
(:return-type NIL)
(:library +library-name+))
(ffi:def-call-out test123
(:name "test")
(:arguments (x SINGLE-FLOAT)
- (y DOUBLE-FLOAT))
+ (y DOUBLE-FLOAT))
(:return-type NIL)
(:library +library-name+))
</pre></div>
-<H2><a name="Lisp_nn11"></a>25.4 UFFI </H2>
+<H2><a name="Lisp_nn11">27.4 UFFI </a></H2>
</body>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Lua</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Lua"></a>26 SWIG and Lua</H1>
+<H1><a name="Lua">28 SWIG and Lua</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#Lua_nn9">Functions</a>
<li><a href="#Lua_nn10">Global variables</a>
<li><a href="#Lua_nn11">Constants and enums</a>
+<ul>
+<li><a href="#Lua_nn13">Constants/enums and classes/structures</a>
+</ul>
<li><a href="#Lua_nn12">Pointers</a>
-<li><a href="#Lua_nn13">Structures</a>
+<li><a href="#Lua_structures">Structures</a>
<li><a href="#Lua_nn14">C++ classes</a>
<li><a href="#Lua_nn15">C++ inheritance</a>
<li><a href="#Lua_nn16">Pointers, references, values, and arrays</a>
<li><a href="#Lua_nn21">C++ templates</a>
<li><a href="#Lua_nn22">C++ Smart Pointers</a>
<li><a href="#Lua_nn23">C++ Exceptions</a>
+<li><a href="#Lua_namespaces">Namespaces </a>
+<ul>
+<li><a href="#Lua_nn27">Compatibility Note </a>
+<li><a href="#Lua_nn29">Names </a>
+<li><a href="#Lua_nn30">Inheritance </a>
+</ul>
</ul>
<li><a href="#Lua_nn24">Typemaps</a>
<ul>
<li><a href="#Lua_nn25">What is a typemap?</a>
<li><a href="#Lua_nn26">Using typemaps</a>
-<li><a href="#Lua_nn27">Typemaps and arrays</a>
-<li><a href="#Lua_nn28">Typemaps and pointer-pointer functions</a>
+<li><a href="#Lua_typemap_arrays">Typemaps and arrays</a>
+<li><a href="#Lua_typemaps_ptr_ptr_functions">Typemaps and pointer-pointer functions</a>
</ul>
-<li><a href="#Lua_nn29">Writing typemaps</a>
+<li><a href="#Lua_writing_typemaps">Writing typemaps</a>
<ul>
-<li><a href="#Lua_nn30">Typemaps you can write</a>
+<li><a href="#Lua_typemaps_write">Typemaps you can write</a>
<li><a href="#Lua_nn31">SWIG's Lua-C API</a>
</ul>
<li><a href="#Lua_nn32">Customization of your Bindings</a>
eLua stands for Embedded Lua (can be thought of as a flavor of Lua) and offers the full implementation of the Lua programming language to the embedded world, extending it with specific features for efficient and portable software embedded development. eLua runs on smaller devices like microcontrollers and provides the full features of the regular Lua desktop version. More information on eLua can be found here: <a href="http://www.eluaproject.net">http://www.eluaproject.net</a>
</p>
-<H2><a name="Lua_nn2"></a>26.1 Preliminaries</H2>
+<H2><a name="Lua_nn2">28.1 Preliminaries</a></H2>
<p>
-The current SWIG implementation is designed to work with Lua 5.0.x, 5.1.x and 5.2.x. It should work with later versions of Lua, but certainly not with Lua 4.0 due to substantial API changes. It is possible to either static link or dynamic link a Lua module into the interpreter (normally Lua static links its libraries, as dynamic linking is not available on all platforms). SWIG also supports eLua and works with eLua 0.8. SWIG generated code for eLua has been tested on Stellaris ARM Cortex-M3 LM3S and Infineon TriCore.
+The current SWIG implementation is designed to work with Lua 5.0.x, 5.1.x and 5.2.x. It should work with later versions of Lua, but certainly not with Lua 4.0 due to substantial API changes. It is possible to either static link or dynamic link a Lua module into the interpreter (normally Lua static links its libraries, as dynamic linking is not available on all platforms). SWIG also has support for eLua starting from eLua 0.8. Due to substantial changes between SWIG 2.x and SWIG 3.0 and unavailability of testing platform, eLua status was downgraded to 'experimental'.
</p>
-<H2><a name="Lua_nn3"></a>26.2 Running SWIG</H2>
+<H2><a name="Lua_nn3">28.2 Running SWIG</a></H2>
<p>
The <tt>-elua</tt> option puts all the C function wrappers and variable get/set wrappers in rotables. It also generates a metatable which will control the access to these variables from eLua. It also offers a significant amount of module size compression. On the other hand, the <tt>-eluac</tt> option puts all the wrappers in a single rotable. With this option, no matter how huge the module, it will consume no additional microcontroller SRAM (crass compression). There is a catch though: Metatables are not generated with <tt>-eluac</tt>. To access any value from eLua, one must directly call the wrapper function associated with that value.
</p>
-<H3><a name="Lua_commandline"></a>26.2.1 Additional command line options</H3>
+<H3><a name="Lua_commandline">28.2.1 Additional command line options</a></H3>
<p>
<td>Do not register the module name as a global variable but return the module table from calls to require.</td>
</tr>
+<tr>
+ <td>-no-old-metatable-bindings</td>
+ <td>Disable backward compatibility: old-style binding names generations and a few other things. Explanations are included in appropriate later sections.</td>
+</tr>
+<tr>
+ <td>-squash-bases</td>
+ <td>Squashes symbols from all inheritance tree of a given class into itself. Emulates pre-SWIG3.0 inheritance. Insignificantly speeds things up, but increases memory consumption.</td>
+</tr>
</table>
-<H3><a name="Lua_nn4"></a>26.2.2 Compiling and Linking and Interpreter</H3>
+<H3><a name="Lua_nn4">28.2.2 Compiling and Linking and Interpreter</a></H3>
<p>
return 0;
}
L=lua_open();
- luaopen_base(L); // load basic libs (eg. print)
- luaopen_example(L); // load the wrapped module
+ luaopen_base(L); // load basic libs (eg. print)
+ luaopen_example(L); // load the wrapped module
if (luaL_loadfile(L,argv[1])==0) // load and run the file
lua_pcall(L,0,0,0);
else
More information on building and configuring eLua can be found here: <a href="http://www.eluaproject.net/doc/v0.8/en_building.html">http://www.eluaproject.net/doc/v0.8/en_building.html</a>
</p>
-<H3><a name="Lua_nn5"></a>26.2.3 Compiling a dynamic module</H3>
+<H3><a name="Lua_nn5">28.2.3 Compiling a dynamic module</a></H3>
<p>
</p>
<div class="shell"><pre>
$ swig -lua example.i -o example_wrap.c
-$ gcc -I/usr/include/lua -c example_wrap.c -o example_wrap.o
-$ gcc -c example.c -o example.o
+$ gcc -fPIC -I/usr/include/lua -c example_wrap.c -o example_wrap.o
+$ gcc -fPIC -c example.c -o example.o
$ gcc -shared -I/usr/include/lua -L/usr/lib/lua example_wrap.o example.o -o example.so
</pre></div>
<p>
-<H3><a name="Lua_nn6"></a>26.2.4 Using your module</H3>
+<H3><a name="Lua_nn6">28.2.4 Using your module</a></H3>
<p>
>
</pre></div>
-<H2><a name="Lua_nn7"></a>26.3 A tour of basic C/C++ wrapping</H2>
+<H2><a name="Lua_nn7">28.3 A tour of basic C/C++ wrapping</a></H2>
<p>
By default, SWIG tries to build a very natural Lua interface to your C/C++ code. This section briefly covers the essential aspects of this wrapping.
</p>
-<H3><a name="Lua_nn8"></a>26.3.1 Modules</H3>
+<H3><a name="Lua_nn8">28.3.1 Modules</a></H3>
<p>
The SWIG module directive specifies the name of the Lua module. If you specify `module example', then everything is wrapped into a Lua table 'example' containing all the functions and variables. When choosing a module name, make sure you don't use the same name as a built-in Lua command or standard module name.
</p>
-<H3><a name="Lua_nn9"></a>26.3.2 Functions</H3>
+<H3><a name="Lua_nn9">28.3.2 Functions</a></H3>
<p>
>
</pre></div>
<p>
-To avoid name collisions, SWIG create a Lua table which it keeps all the functions and global variables in. It is possible to copy the functions out of this and into the global environment with the following code. This can easily overwrite existing functions, so this must be used with care.
+To avoid name collisions, SWIG create a Lua table which keeps all the functions, constants, classes and global variables in.
+It is possible to copy the functions, constants and classes (but not variables) out of this and into the global environment with the following code.
+This can easily overwrite existing functions, so this must be used with care.
+This option is considered deprecated and will be removed in the near future.
</p>
<div class="targetlang"><pre>
> for k,v in pairs(example) do _G[k]=v end
24
</pre></div>
-<H3><a name="Lua_nn10"></a>26.3.3 Global variables</H3>
+<H3><a name="Lua_nn10">28.3.3 Global variables</a></H3>
<p>
In general, functions of the form <tt>"variable_get()"</tt> and <tt>"variable_set()"</tt> are automatically generated by SWIG for use with <tt>-eluac</tt>.
</p>
-<H3><a name="Lua_nn11"></a>26.3.4 Constants and enums</H3>
+<H3><a name="Lua_nn11">28.3.4 Constants and enums</a></H3>
<p>
> print(example.const.SCONST)
Hello World
</pre></div>
-<H3><a name="Lua_nn12"></a>26.3.5 Pointers</H3>
+
+<H4><a name="Lua_nn13">28.3.4.1 Constants/enums and classes/structures</a></H4>
+
+
+<p>
+Enums are exported into a class table. For example, given some enums:
+</p>
+<div class="code"><pre>%module example
+enum Days { SUNDAY = 0, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY };
+struct Test {
+ enum { TEST1 = 10, TEST2 = 20 };
+#ifdef __cplusplus // There are no static members in C
+ static const int ICONST = 12;
+#endif
+};
+</pre></div>
+<p>
+There is a slight difference in behaviour wrapping C and C++ code due to the different scoping rules of C and C++.
+The wrapped C++ code is used as follows from Lua code:
+</p>
+<div class="targetlang"><pre>
+> print(example.SUNDAY)
+0
+> print(example.Test.TEST1)
+10
+> print(example.Test.ICONST)
+12
+</pre></div>
+
+<p>Enums within a C struct are in the global namespace and are used as follows from Lua</p>
+<div class="targetlang"><pre>
+> print(example.SUNDAY)
+0
+> -- See the difference here
+> print(example.TEST1)
+10
+</pre></div>
+
+<p>
+<b>Compatibility Note:</b> Versions of SWIG prior to SWIG-3.0.0 did not generate the class table members above.
+There is no change in the C wrappers, but
+the following code was the only way to access these constants/enums when wrapping C++ member constants:
+</p>
+<div class="targetlang"><pre>
+> print(example.Test_TEST1)
+10
+> print(example.Test_ICONST)
+12
+</pre></div>
+<p>
+The old-style bindings are still generated in addition to the new ones.
+If the <tt>-no-old-metatable-bindings</tt> option is used, then these old-style bindings are not generated.
+</p>
+<p>
+It is worth mentioning, that <tt>example.Test.TEST1</tt> and <tt>example.Test_TEST1</tt> are different entities and changing one does not change the other.
+Given the fact that these are constantes and they are not supposed to be changed, it is up to you to avoid such issues.
+</p>
+<H3><a name="Lua_nn12">28.3.5 Pointers</a></H3>
<p>
nil
</pre></div>
-<H3><a name="Lua_nn13"></a>26.3.6 Structures</H3>
+<H3><a name="Lua_structures">28.3.6 Structures</a></H3>
<p>
</pre></div>
<p>
Similar access is provided for unions and the data members of C++ classes.<br>
-C structures are created using a function <tt>new_Point()</tt>, but for C++ classes are created using just the name <tt>Point()</tt>.
+C structures can be created using a function <tt>new_Point()</tt>, and both C structures and C++ classes can be created using just the name <tt>Point()</tt>.
</p>
<p>
If you print out the value of p in the above example, you will see something like this:
In general, functions of the form <tt>"new_struct()"</tt>, <tt>"struct_member_get()"</tt>, <tt>"struct_member_set()"</tt> and <tt>"free_struct()"</tt> are automatically generated by SWIG for each structure defined in C. (Please note: This doesn't apply for modules generated with the <tt>-elua</tt> option)
</p>
-<H3><a name="Lua_nn14"></a>26.3.7 C++ classes</H3>
+<H3><a name="Lua_nn14">28.3.7 C++ classes</a></H3>
<p>
};
</pre></div>
<p>
-In Lua, the static members can be accessed as follows:
+In Lua, C++ static members can be accessed as follows:
</p>
<div class="code"><pre>
-> example.Spam_foo() -- calling Spam::foo()
-> a=example.Spam_bar -- reading Spam::bar
-> example.Spam_bar=b -- writing to Spam::bar
+> example.Spam.foo() -- calling Spam::foo()
+> a=example.Spam.bar -- reading Spam::bar
+> example.Spam.bar=b -- writing to Spam::bar
</pre></div>
<p>
It is not (currently) possible to access static members of an instance:
-- does NOT work
</pre></div>
-<H3><a name="Lua_nn15"></a>26.3.8 C++ inheritance</H3>
+<p>
+<b>Compatibility Note:</b> In versions prior to SWIG-3.0.0 only the following names would work:
+</p>
+
+<div class="code"><pre>
+> example.Spam_foo() -- calling Spam::foo()
+> a=example.Spam_bar -- reading Spam::bar
+> example.Spam_bar=b -- writing to Spam::bar
+</pre></div>
+
+<p>
+Both style names are generated by default now.
+However, if the <tt>-no-old-metatable-bindings</tt> option is used, then the backward compatible names are not generated in addition to ordinary ones.
+</p>
+
+<H3><a name="Lua_nn15">28.3.8 C++ inheritance</a></H3>
<p>
<p>
It is safe to use multiple inheritance with SWIG.
</p>
-<H3><a name="Lua_nn16"></a>26.3.9 Pointers, references, values, and arrays</H3>
+<H3><a name="Lua_nn16">28.3.9 Pointers, references, values, and arrays</a></H3>
<p>
<p>
then all three functions will return a pointer to some Foo object. Since the third function (spam7) returns a value, newly allocated memory is used to hold the result and a pointer is returned (Lua will release this memory when the return value is garbage collected). The other two are pointers which are assumed to be managed by the C code and so will not be garbage collected.
</p>
-<H3><a name="Lua_nn17"></a>26.3.10 C++ overloaded functions</H3>
+<H3><a name="Lua_nn17">28.3.10 C++ overloaded functions</a></H3>
<p>
<p>
or
</p>
-<DIV CLASS="CODE"><PRE>VOID FOO(bAR *B);
+<div class="code"><pre>void foo(Bar *b);
void foo(Bar &b);
</pre></div>
<p>
<p>
Dealing with the Lua coercion mechanism, the priority is roughly (integers, floats, strings, userdata). But it is better to rename the functions rather than rely upon the ordering.
</p>
-<H3><a name="Lua_nn18"></a>26.3.11 C++ operators</H3>
+<H3><a name="Lua_nn18">28.3.11 C++ operators</a></H3>
<p>
<li><tt>__sub__</tt> operator-
<li><tt>__mul__</tt> operator *
<li><tt>__div__</tt> operator/
-<li><tt>__neg__</tt> unary minus
+<li><tt>__unm__</tt> unary minus
<li><tt>__call__</tt> operator<tt>()</tt> (often used in functor classes)
<li><tt>__pow__</tt> the exponential fn (no C++ equivalent, Lua uses <tt>^</tt>)
-<li><tt>__concat__</tt> the concatenation operator (SWIG maps C++'s <tt>~</tt> to Lua's <tt>..</tt>)
+<li><tt>__concat__</tt> the concatenation operator (Lua's <tt>..</tt>)
<li><tt>__eq__</tt> operator<tt>==</tt>
<li><tt>__lt__</tt> operator<tt><</tt>
<li><tt>__le__</tt> operator<tt><=</tt>
void __setitem__(int i,double d); // i is the index, d is the data
};
</pre></div>
-
-<H3><a name="Lua_nn19"></a>26.3.12 Class extension with %extend</H3>
+<p>
+C++ operators are mapped to Lua predefined metafunctions. Class inherits from its bases the following list of metafunctions ( thus inheriting the folloging
+operators and pseudo-operators):</p>
+<ul>
+<li><tt>__add__</tt>
+<li><tt>__sub__</tt>
+<li><tt>__mul__</tt>
+<li><tt>__div__</tt>
+<li><tt>__unm__</tt>
+<li><tt>__mod__</tt>
+<li><tt>__call__</tt>
+<li><tt>__pow__</tt>
+<li><tt>__concat__</tt>
+<li><tt>__eq__</tt>
+<li><tt>__lt__</tt>
+<li><tt>__le__</tt>
+<li><tt>__len__</tt>
+<li><tt>__getitem__</tt>
+<li><tt>__setitem__</tt>
+<li><tt>__tostring</tt> used internally by Lua for tostring() function. __str__ is mapped to this function
+</ul>
+<p>No other lua metafunction is inherited. For example, __gc is not inherited and must be redefined in every class. <tt>__tostring</tt> is subject to a special handling. If absent in class and in class bases, a default one will be provided by SWIG.
+</p>
+<H3><a name="Lua_nn19">28.3.12 Class extension with %extend</a></H3>
<p>
return tmp;
}
bool operator==(const Complex& c)
- { return ($self->re()==c.re() && $self->im()==c.im();}
+ { return ($self->re()==c.re() && $self->im()==c.im());}
};
</pre></div>
<p>
Extend works with both C and C++ code, on classes and structs. It does not modify the underlying object in any way---the extensions only show up in the Lua interface. The only item to take note of is the code has to use the '$self' instead of 'this', and that you cannot access protected/private members of the code (as you are not officially part of the class).
</p>
-<H3><a name="Lua_nn20"></a>26.3.13 Using %newobject to release memory</H3>
+<H3><a name="Lua_nn20">28.3.13 Using %newobject to release memory</a></H3>
<p> If you have a function that allocates memory like this,</p>
</div>
<p> This will release the allocated memory.</p>
-<H3><a name="Lua_nn21"></a>26.3.14 C++ templates</H3>
+<H3><a name="Lua_nn21">28.3.14 C++ templates</a></H3>
<p>
<p>
Obviously, there is more to template wrapping than shown in this example. More details can be found in the SWIG and C++ chapter. Some more complicated examples will appear later.
</p>
-<H3><a name="Lua_nn22"></a>26.3.15 C++ Smart Pointers</H3>
+<H3><a name="Lua_nn22">28.3.15 C++ Smart Pointers</a></H3>
<p>
> f = p:__deref__() -- Returns underlying Foo *
</pre></div>
-<H3><a name="Lua_nn23"></a>26.3.16 C++ Exceptions</H3>
+<H3><a name="Lua_nn23">28.3.16 C++ Exceptions</a></H3>
<p>
add exception specification to functions or globally (respectively).
</p>
+<H3><a name="Lua_namespaces">28.3.17 Namespaces </a></H3>
+
+
+<p>
+Since SWIG-3.0.0 C++ namespaces are supported via the %nspace feature.
+</p>
+<p> Namespaces are mapped into Lua tables. Each of those tables contains names that were defined within appropriate namespace. Namespaces structure (a.k.a nested namespaces) is preserved. Consider the following C++ code:
+</p>
+<div class="code"><pre>%module example
+%nspace MyWorld::Nested::Dweller;
+%nspace MyWorld::World;
+
+int module_function() { return 7; }
+int module_variable = 9;
+
+namespace MyWorld {
+ class World {
+ public:
+ World() : world_max_count(9) {}
+ int create_world() { return 17; }
+ const int world_max_count; // = 9
+ };
+ namespace Nested {
+ class Dweller {
+ public:
+ enum Gender { MALE = 0, FEMALE = 1 };
+ static int count() { return 19; }
+ };
+ }
+}
+</pre></div>
+
+<p>
+Now, from Lua usage is as follows:
+</p>
+
+<div class="targetlang"><pre>
+> print(example.module_function())
+7
+> print(example.module_variable)
+9
+> print(example.MyWorld.World():create_world())
+17
+> print(example.MyWorld.World.world_max_count)
+9
+> print(example.MyWorld.Nested.Dweller.MALE)
+0
+> print(example.MyWorld.Nested.Dweller.count())
+19
+>
+</pre></div>
+<H4><a name="Lua_nn27">28.3.17.1 Compatibility Note </a></H4>
+
+
+<p>
+If SWIG is running in a backwards compatible way, i.e. without the <tt>-no-old-metatable-bindings</tt> option, then additional old-style names are generated (notice the underscore):
+</p>
+<div class="targetlang"><pre>
+9
+> print(example.MyWorld.Nested.Dweller_MALE)
+0
+> print(example.MyWorld.Nested.Dweller_count())
+11
+>
+</pre></div>
+
+
+<H4><a name="Lua_nn29">28.3.17.2 Names </a></H4>
+
+
+<p> If SWIG is launched without <tt>-no-old-metatable-bindings</tt> option, then it enters backward-compatible mode. While in this mode, it tries
+to generate additional names for static functions, class static constants and class enums.
+Those names are in a form <tt>$classname_$symbolname</tt> and are added to the scope surrounding the class.
+If %nspace is enabled, then class namespace is taken as scope. If there is no namespace, or %nspace is disabled,
+then module is considered a class namespace.</p>
+<p> Consider the following C++ code </p>
+<div class="code"><pre>%module example
+%nspace MyWorld::Test;
+namespace MyWorld {
+class Test {
+ public:
+ enum { TEST1 = 10, TEST2 }
+ static const int ICONST = 12;
+};
+class Test2 {
+ public:
+ enum { TEST3 = 20, TEST4 }
+ static const int ICONST2 = 23;
+}
+</pre></div>
+<p> When in backward compatible mode, in addition to the usual names, the following ones will be generated (notice the underscore):</p>
+<div class="targetlang"><pre>
+9
+> print(example.MyWorld.Test_TEST1) -- Test has %nspace enabled
+10
+> print(example.MyWorld.Test_ICONST) -- Test has %nspace enabled
+12
+> print(example.Test2_TEST3) -- Test2 doesn't have %nspace enabled
+20
+> print(example.Test2_ICONST2) -- Test2 doesn't have %nspace enabled
+23
+>
+</pre></div>
+<p> There is a slight difference with enums when in C mode. As per C standard, enums from C structures are exported to
+surrounding scope without any prefixing. Pretending that Test2 is a struct, not class, that would be:</p>
+<div class="targetlang"><pre>
+> print(example.TEST3) -- NOT Test2_TEST3
+20
+>
+</pre></div>
+
+<H4><a name="Lua_nn30">28.3.17.3 Inheritance </a></H4>
+
+
+<p> The internal organization of inheritance has changed.
+Consider the following C++ code:</p>
+<div class="code"><pre>%module example
+class Base {
+ public:
+ int base_func()
+};
+class Derived : public Base {
+ public:
+ int derived_func()
+}
+</pre></div>
+<p>Lets assume for a moment that class member functions are stored in <tt>.fn</tt> table. Previously, when classes
+were exported to Lua during module initialization, for every derived class all service tables <tt>ST(i.e. ".fn")</tt>
+were squashed and added to corresponding derived class <tt>ST</tt>: Everything from <tt>.fn</tt> table of class Base
+was copied to <tt>.fn</tt> table of class Derived and so on. This was a recursive procedure, so in the end the whole
+inheritance tree of derived class was squashed into derived class. </p>
+<p> That means that any changes done to class Base after module initialization wouldn't affect class Derived:</p>
+<div class="targetlang"><pre>
+base = example.Base()
+der = example.Derived()
+> print(base.base_func)
+function: 0x1367940
+> getmetatable(base)[".fn"].new_func = function (x) return x -- Adding new function to class Base (to class, not to an instance!)
+> print(base.new_func) -- Checking this function
+function
+> print(der.new_func) -- Wouldn't work. Derived doesn't check Base any more.
+nil
+>
+</pre></div>
+<p> This behaviour was changed. Now unless -squash-bases option is provided, Derived store a list of it's bases and if some symbol is not found in it's own service tables
+then its bases are searched for it. Option -squash-bases will effectively return old behaviour.
+<div class="targetlang"><pre>
+> print(der.new_func) -- Now it works
+function
+>
+</pre></div>
-<H2><a name="Lua_nn24"></a>26.4 Typemaps</H2>
+<H2><a name="Lua_nn24">28.4 Typemaps</a></H2>
<p>This section explains what typemaps are and how to use them. The default wrapping behaviour of SWIG is enough in most cases. However sometimes SWIG may need a little additional assistance to know which typemap to apply to provide the best wrapping. This section will be explaining how to use typemaps to best effect</p>
-<H3><a name="Lua_nn25"></a>26.4.1 What is a typemap?</H3>
+<H3><a name="Lua_nn25">28.4.1 What is a typemap?</a></H3>
<p>A typemap is nothing more than a code generation rule that is attached to a specific C datatype. For example, to convert integers from Lua to C, you might define a typemap like this:</p>
<div class="code"><pre>%module example
%typemap(in) int {
- $1 = (int) lua_tonumber(L,$input);
- printf("Received an integer : %d\n",$1);
+ $1 = (int) lua_tonumber(L,$input);
+ printf("Received an integer : %d\n",$1);
}
%inline %{
extern int fact(int n);
720
</pre></div>
-<H3><a name="Lua_nn26"></a>26.4.2 Using typemaps</H3>
+<H3><a name="Lua_nn26">28.4.2 Using typemaps</a></H3>
<p>There are many ready written typemaps built into SWIG for all common types (int, float, short, long, char*, enum and more), which SWIG uses automatically, with no effort required on your part.</p>
<p>Note: C++ references must be handled exactly the same way. However SWIG will automatically wrap a <tt>const int&</tt> as an input parameter (since that it obviously input).</p>
-<H3><a name="Lua_nn27"></a>26.4.3 Typemaps and arrays</H3>
+<H3><a name="Lua_typemap_arrays">28.4.3 Typemaps and arrays</a></H3>
<p>Arrays present a challenge for SWIG, because like pointers SWIG does not know whether these are input or output values, nor
<p>Note: SWIG also can support arrays of pointers in a similar manner.</p>
-<H3><a name="Lua_nn28"></a>26.4.4 Typemaps and pointer-pointer functions</H3>
+<H3><a name="Lua_typemaps_ptr_ptr_functions">28.4.4 Typemaps and pointer-pointer functions</a></H3>
<p>Several C++ libraries use a pointer-pointer functions to create its objects. These functions require a pointer to a pointer which is then filled with the pointer to the new object. Microsoft's COM and DirectX as well as many other libraries have this kind of function. An example is given below:</p>
ptr=nil -- the iMath* will be GC'ed as normal
</pre></div>
-<H2><a name="Lua_nn29"></a>26.5 Writing typemaps</H2>
+<H2><a name="Lua_writing_typemaps">28.5 Writing typemaps</a></H2>
<p>This section describes how you can modify SWIG's default wrapping behavior for various C/C++ datatypes using the <tt>%typemap</tt> directive. This is an advanced topic that assumes familiarity with the Lua C API as well as the material in the "<a href="Typemaps.html#Typemaps">Typemaps</a>" chapter.</p>
<p>Before proceeding, you should read the previous section on using typemaps, and look at the existing typemaps found in luatypemaps.swg and typemaps.i. These are both well documented and fairly easy to read. You should not attempt to write your own typemaps until you have read and can understand both of these files (they may well also give you an idea to base your work on).</p>
-<H3><a name="Lua_nn30"></a>26.5.1 Typemaps you can write</H3>
+<H3><a name="Lua_typemaps_write">28.5.1 Typemaps you can write</a></H3>
<p>There are many different types of typemap that can be written, the full list can be found in the "<a href="Typemaps.html#Typemaps">Typemaps</a>" chapter. However the following are the most commonly used ones.</p>
(the syntax for the typecheck is different from the typemap, see typemaps for details).</li>
</ul>
-<H3><a name="Lua_nn31"></a>26.5.2 SWIG's Lua-C API</H3>
+<H3><a name="Lua_nn31">28.5.2 SWIG's Lua-C API</a></H3>
<p>This section explains the SWIG specific Lua-C API. It does not cover the main Lua-C api, as this is well documented and not worth covering.</p>
<div class="indent">
Similar to SWIG_fail_arg, except that it will display the swig_type_info information instead.</div>
-<H2><a name="Lua_nn32"></a>26.6 Customization of your Bindings</H2>
+<H2><a name="Lua_nn32">28.6 Customization of your Bindings</a></H2>
<p>
-<H3><a name="Lua_nn33"></a>26.6.1 Writing your own custom wrappers</H3>
+<H3><a name="Lua_nn33">28.6.1 Writing your own custom wrappers</a></H3>
<p>
The <tt>%native</tt> directive in the above example, tells SWIG that there is a function <tt>int native_function(lua_State*L);</tt> which is to be added into the module under the name '<tt>my_func</tt>'. SWIG will not add any wrapper for this function, beyond adding it into the function table. How you write your code is entirely up to you.
</p>
-<H3><a name="Lua_nn34"></a>26.6.2 Adding additional Lua code</H3>
+<H3><a name="Lua_nn34">28.6.2 Adding additional Lua code</a></H3>
<p>
See Examples/lua/arrays for an example of this code.
</p>
-<H2><a name="Lua_nn35"></a>26.7 Details on the Lua binding</H2>
+<H2><a name="Lua_nn35">28.7 Details on the Lua binding</a></H2>
<p>
</i>
</p>
-<H3><a name="Lua_nn36"></a>26.7.1 Binding global data into the module.</H3>
+<H3><a name="Lua_nn36">28.7.1 Binding global data into the module.</a></H3>
<p>
<p>
That way when you call '<tt>a=example.Foo</tt>', the interpreter looks at the table 'example' sees that there is no field 'Foo' and calls __index. This will in turn check in '.get' table and find the existence of 'Foo' and then return the value of the C function call 'Foo_get()'. Similarly for the code '<tt>example.Foo=10</tt>', the interpreter will check the table, then call the __newindex which will then check the '.set' table and call the C function 'Foo_set(10)'.
</p>
-<H3><a name="Lua_nn37"></a>26.7.2 Userdata and Metatables</H3>
+<H3><a name="Lua_nn37">28.7.2 Userdata and Metatables</a></H3>
<p>
<p>
Note: Operator overloads are basically done in the same way, by adding functions such as '__add' & '__call' to the class' metatable. The current implementation is a bit rough as it will add any member function beginning with '__' into the metatable too, assuming its an operator overload.
</p>
-<H3><a name="Lua_nn38"></a>26.7.3 Memory management</H3>
+<H3><a name="Lua_nn38">28.7.3 Memory management</a></H3>
<p>
# validation.
#
# Additional html validation can be done using the validate target.
-# Additional link checking can be done using the linkchecker target.
+# Additional link checking can be done using the linkchecker1 and linkchecker2 target.
#
# Note the # and " are escaped
all: maketoc check generate
-maketoc: CCache.html
+maketoc:
python maketoc.py
+# Use this to regenerate CCache.html should this ever be needed
CCache.html: ../../CCache/ccache.yo
yodl2html -o CCache.html ../../CCache/ccache.yo
+# Tabs in the html files will stop the build as wkhtmltopdf does not expand them correctly - replace them with the appropriate number of tabs
# Use htmltidy to warn about some HTML errors. Note that it is not used to clean/tidy the HTML,
# it is just used as a primitive HTML checker.
# CCache.html is generated by yodl2html and has a few insignificant problems, so we don't put it through tidy
check:
- tidy -errors --gnu-emacs yes -quiet index.html
- tidy -errors --gnu-emacs yes -quiet Sections.html
- all=`sed '/^#/d' chapters | grep -v CCache.html`; for a in $$all; do tidy -errors --gnu-emacs yes -quiet $$a; done;
+ all="index.html Sections.html `sed '/^#/d' chapters | grep -v CCache.html`" && for a in $$all; do echo "Check for tabs $$a" && if grep -P '\t' $$a; then echo "Please delete the tabs from the lines above" && exit 1; fi; done && for a in $$all; do echo "HTML tidy check $$a" && tidy -errors --gnu-emacs yes -quiet $$a; done;
-generate: swightml.book swigpdf.book
+# Note wkhtmltopdf limitations for generating pdf docs:
+# 1) <H1><a name="X"></a>Text</H1> style links don't work and need changing to
+# <H1><a name="X">Text</a></H1>
+# 2) Tabs in <pre> elements should be expanded to 8 spaces by default, but
+# are expanded to just one space and css tab-size is not working.
+# 3) <pre> <tt> <code> elements do not always select a fixed-width font - try installing the
+# Courier font to fix - these have been added to style.css.
+generate: SWIGDocumentation.html
+ wkhtmltopdf --version | grep "with patched qt" || (echo "wkhtmltopdf is not the patched qt version and so cannot be used - download it from http://wkhtmltopdf.org/downloads.html" && false)
+ wkhtmltopdf --margin-top 20mm --margin-bottom 20mm --margin-left 10mm --margin-right 10mm --header-font-size 6 --footer-font-size 6 --header-spacing 6 --footer-spacing 6 --header-center '[doctitle]' --footer-left '[subsection]' --footer-right '[page]' SWIGDocumentation.html SWIGDocumentation.pdf
+
+SWIGDocumentation.html: swightml.book
htmldoc --batch swightml.book || true
- htmldoc --batch swigpdf.book || true
python fixstyle.py SWIGDocumentation.html
-swigpdf.book: chapters Sections.html
- echo "#HTMLDOC 1.8.24" > swigpdf.book
- echo -t pdf13 -f SWIGDocumentation.pdf $(HTMLDOC_OPTIONS) --stylesheet style.css >> swigpdf.book
- echo "Sections.html" >> swigpdf.book
- cat chapters >> swigpdf.book
-
swightml.book: chapters Sections.html
echo "#HTMLDOC 1.8.24" > swightml.book
echo -t html -f SWIGDocumentation.html $(HTMLDOC_OPTIONS) >> swightml.book
maintainer-clean: clean-baks
rm -f swightml.book
- rm -f swigpdf.book
- rm -f CCache.html
rm -f SWIGDocumentation.html
rm -f SWIGDocumentation.pdf
+ rm -rf linkchecker-tmp
clean-baks:
rm -f *.bak
validate:
all=`sed '/^#/d' chapters`; for a in $$all; do validate --emacs $$a; done;
-# Link checking using linkchecker
-linkchecker:
+# Link checking using linkchecker of the index.html only file (including anchors)
+linkchecker1:
@echo -----------------------------------------------------------------------
@echo Note linkchecker versions prior to 6.1 do not work properly wrt anchors
@echo -----------------------------------------------------------------------
- linkchecker --config=./linkchecker.config index.html
+ linkchecker --config=./linkchecker.config --anchors index.html
+
+# Check for links which don't work including those generated from the individual .html files into SWIGDocumentation.html
+linkchecker2:
+ rm -rf linkchecker-tmp
+ mkdir linkchecker-tmp
+ cp SWIGDocumentation.html linkchecker-tmp
+ cp *.png linkchecker-tmp
+ (cd linkchecker-tmp && linkchecker --config=../linkchecker.config -F text --no-warnings SWIGDocumentation.html)
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Modula-3</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#FFFFFF">
-<H1><a name="Modula3"></a>27 SWIG and Modula-3</H1>
+<H1><a name="Modula3">29 SWIG and Modula-3</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<p>
-This chapter describes SWIG's support of
+This chapter describes SWIG's support for
<a href="http://modula3.org/">Modula-3</a>.
You should be familiar with the
<a href="SWIG.html#SWIG">basics</a>
<a href="Typemaps.html#Typemaps">typemaps</a>.
</p>
-<H2><a name="Modula3_modula3_overview"></a>27.1 Overview</H2>
+<H2><a name="Modula3_modula3_overview">29.1 Overview</a></H2>
<p>
</li>
</ol>
-<H3><a name="Modula3_motivation"></a>27.1.1 Motivation</H3>
+<H3><a name="Modula3_motivation">29.1.1 Motivation</a></H3>
<p>
<p>
If the library API is ill designed
-writing appropriate typemaps can be still time-consuming.
+writing appropriate typemaps can still be time-consuming.
E.g. C programmers are very creative to work-around
missing data types like (real) enumerations and sets.
You should turn such work-arounds back to the Modula-3 way
Without SWIG you would probably never consider trying to call C++ libraries
from Modula-3, but with SWIG this is becomes feasible.
SWIG can generate C wrappers to C++ functions and object methods
-that may throw exceptions, and then wrap these C wrappers for Module-3.
+that may throw exceptions, and then wrap these C wrappers for Modula-3.
To make it complete you can then hide the C interface with Modula-3 classes and
exceptions.
</p>
<p>
SWIG allows you to call C and C++ libraries from Modula-3 (even with call back
-functions), but it doesn't allow you to easily integrate a Module-3 module into
+functions), but it doesn't allow you to easily integrate a Modula-3 module into
a C/C++ project.
</p>
-<H2><a name="Modula3_conception"></a>27.2 Conception</H2>
+<H2><a name="Modula3_conception">29.2 Conception</a></H2>
-<H3><a name="Modula3_cinterface"></a>27.2.1 Interfaces to C libraries</H3>
+<H3><a name="Modula3_cinterface">29.2.1 Interfaces to C libraries</a></H3>
<p>
</p>
-<H3><a name="Modula3_cppinterface"></a>27.2.2 Interfaces to C++ libraries</H3>
+<H3><a name="Modula3_cppinterface">29.2.2 Interfaces to C++ libraries</a></H3>
<p>
so I'm not sure if this is possible or sensible, yet.
</p>
-<H2><a name="Modula3_preliminaries"></a>27.3 Preliminaries</H2>
+<H2><a name="Modula3_preliminaries">29.3 Preliminaries</a></H2>
-<H3><a name="Modula3_compilers"></a>27.3.1 Compilers</H3>
+<H3><a name="Modula3_compilers">29.3.1 Compilers</a></H3>
<p>
</p>
-<H3><a name="Modula3_commandline"></a>27.3.2 Additional Commandline Options</H3>
+<H3><a name="Modula3_commandline">29.3.2 Additional Commandline Options</a></H3>
<p>
</tr>
</table>
-<H2><a name="Modula3_typemaps"></a>27.4 Modula-3 typemaps</H2>
+<H2><a name="Modula3_typemaps">29.4 Modula-3 typemaps</a></H2>
-<H3><a name="Modula3_inoutparam"></a>27.4.1 Inputs and outputs</H3>
+<H3><a name="Modula3_inoutparam">29.4.1 Inputs and outputs</a></H3>
<p>
</table>
-<H3><a name="Modula3_ordinals"></a>27.4.2 Subranges, Enumerations, Sets</H3>
+<H3><a name="Modula3_ordinals">29.4.2 Subranges, Enumerations, Sets</a></H3>
<p>
</p>
-<H3><a name="Modula3_class"></a>27.4.3 Objects</H3>
+<H3><a name="Modula3_class">29.4.3 Objects</a></H3>
<p>
</p>
-<H3><a name="Modula3_imports"></a>27.4.4 Imports</H3>
+<H3><a name="Modula3_imports">29.4.4 Imports</a></H3>
<p>
</pre></div>
-<H3><a name="Modula3_exceptions"></a>27.4.5 Exceptions</H3>
+<H3><a name="Modula3_exceptions">29.4.5 Exceptions</a></H3>
<p>
<tt>%typemap("m3wrapinconv:throws") blah * %{OSError.E%}</tt>.
</p>
-<H3><a name="Modula3_typemap_example"></a>27.4.6 Example</H3>
+<H3><a name="Modula3_typemap_example">29.4.6 Example</a></H3>
<p>
</pre></div>
-<H2><a name="Modula3_hints"></a>27.5 More hints to the generator</H2>
+<H2><a name="Modula3_hints">29.5 More hints to the generator</a></H2>
-<H3><a name="Modula3_features"></a>27.5.1 Features</H3>
+<H3><a name="Modula3_features">29.5.1 Features</a></H3>
<table border summary="Modula-3 features">
</tr>
</table>
-<H3><a name="Modula3_pragmas"></a>27.5.2 Pragmas</H3>
+<H3><a name="Modula3_pragmas">29.5.2 Pragmas</a></H3>
<table border summary="Modula-3 pragmas">
</tr>
</table>
-<H2><a name="Modula3_remarks"></a>27.6 Remarks</H2>
+<H2><a name="Modula3_remarks">29.6 Remarks</a></H2>
<ul>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Working with Modules</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Modules"></a>15 Working with Modules</H1>
+<H1><a name="Modules">16 Working with Modules</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
-<H2><a name="Modules_introduction"></a>15.1 Modules Introduction</H2>
+<H2><a name="Modules_introduction">16.1 Modules Introduction</a></H2>
<p>
Each module in the collection is created via separate invocations of SWIG.
</p>
-<H2><a name="Modules_nn1"></a>15.2 Basics</H2>
+<H2><a name="Modules_nn1">16.2 Basics</a></H2>
<p>
<p>To create the wrapper properly, module <tt>derived_module</tt> needs to know about the
<tt>base</tt> class and that its interface is covered in another module. The
-line <tt>%import "base_module.i"</tt> lets SWIG know exactly that. Oftentimes
+line <tt>%import "base_module.i"</tt> lets SWIG know exactly that. Often
the <tt>.h</tt> file is passed to <tt>%import</tt> instead of the <tt>.i</tt>,
which unfortunately doesn't work for all language modules. For example, Python requires the
name of module that the base class exists in so that the proxy classes can fully inherit the
issue, read on.
</p>
-<H2><a name="Modules_nn2"></a>15.3 The SWIG runtime code</H2>
+<H2><a name="Modules_nn2">16.3 The SWIG runtime code</a></H2>
<p>
is empty. Only modules compiled with the same pair will share type information.
</p>
-<H2><a name="Modules_external_run_time"></a>15.4 External access to the runtime</H2>
+<H2><a name="Modules_external_run_time">16.4 External access to the runtime</a></H2>
<p>As described in <a href="Typemaps.html#Typemaps_runtime_type_checker">The run-time type checker</a>,
to be called. Calling these functions from a typemap is supported, since the typemap code
is embedded into the <tt>_wrap.c</tt> file, which has those declarations available. If you need
to call the SWIG run-time functions from another C file, there is one header you need
-to include. To generate the header that needs to be included, run the following command:
+to include. To generate the header that needs to be included, SWIG can be run in a different
+mode via <tt>-external-runtime</tt> to generate the run-time instead of the normal mode of
+processing an input interface file. For example:
<div class="shell"><pre>
$ swig -python -external-runtime <filename>
access.
</p>
-<H2><a name="Modules_nn4"></a>15.5 A word of caution about static libraries</H2>
+<H2><a name="Modules_nn4">16.5 A word of caution about static libraries</a></H2>
<p>
behavior. When working with dynamically loadable modules, you should try to work exclusively with shared libraries.
</p>
-<H2><a name="Modules_nn5"></a>15.6 References</H2>
+<H2><a name="Modules_nn5">16.6 References</a></H2>
<p>
an outside reference. John Levine's "Linkers and Loaders" is highly recommended.
</p>
-<H2><a name="Modules_nn6"></a>15.7 Reducing the wrapper file size</H2>
+<H2><a name="Modules_nn6">16.7 Reducing the wrapper file size</a></H2>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<!-- Hand-written HTML -->
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and MzScheme/Racket</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Mzscheme"></a>28 SWIG and MzScheme/Racket</H1>
+<H1><a name="Mzscheme">30 SWIG and MzScheme/Racket</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<p>
This section contains information on SWIG's support of Racket, formally known as MzScheme.
-<H2><a name="MzScheme_nn2"></a>28.1 Creating native structures</H2>
+<H2><a name="MzScheme_nn2">30.1 Creating native structures</a></H2>
<p>
<div class="code">
<pre>
- ; suppose a function created a struct foo as
- ; (define foo (make-diag-cntrs (#x1 #x2 #x3) (make-inspector))
- ; Then you can do
- (format "0x~x" (diag-cntrs-field1 foo))
- (format "0x~x" (diag-cntrs-field2 foo))
- ;etc...
+ ; suppose a function created a struct foo as
+ ; (define foo (make-diag-cntrs (#x1 #x2 #x3) (make-inspector))
+ ; Then you can do
+ (format "0x~x" (diag-cntrs-field1 foo))
+ (format "0x~x" (diag-cntrs-field2 foo))
+ ;etc...
</pre>
</div>
-<H2><a name="MzScheme_simple"></a>28.2 Simple example</H2>
+<H2><a name="MzScheme_simple">30.2 Simple example</a></H2>
<p>
<li> The above requests mzc to create an extension using the CGC garbage-collector. The alternative -- the 3m collector -- has generally better performance, but work is still required for SWIG to emit code which is compatible with it.
</ul>
-<H2><a name="MzScheme_external_docs"></a>28.3 External documentation</H2>
+<H2><a name="MzScheme_external_docs">30.3 External documentation</a></H2>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
- <title>SWIG and Ocaml</title>
+<title>SWIG and Ocaml</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
- <body bgcolor="#ffffff">
- <a name="n1"></a>
-<H1><a name="Ocaml"></a>29 SWIG and Ocaml</H1>
+
+<body bgcolor="#ffffff">
+<H1><a name="Ocaml">31 SWIG and Ocaml</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#Ocaml_nn24">Overriding Methods in Ocaml</a>
<li><a href="#Ocaml_nn25">Director Usage Example</a>
<li><a href="#Ocaml_nn26">Creating director objects</a>
-<li><a href="#Ocaml_nn27">Typemaps for directors, <tt>directorin, directorout, directorargout</tt></a>
-<li><a href="#Ocaml_nn28"><tt>directorin</tt> typemap</a>
-<li><a href="#Ocaml_nn29"><tt>directorout</tt> typemap</a>
-<li><a href="#Ocaml_nn30"><tt>directorargout</tt> typemap</a>
+<li><a href="#Ocaml_nn27">Typemaps for directors, directorin, directorout, directorargout</a>
+<li><a href="#Ocaml_nn28">typemap</a>
+<li><a href="#Ocaml_nn29">directorout typemap</a>
+<li><a href="#Ocaml_nn30">directorargout typemap</a>
</ul>
<li><a href="#Ocaml_nn31">Exceptions</a>
</ul>
<p>
- This chapter describes SWIG's
-support of Ocaml. Ocaml is a relatively recent addition to the ML family,
-and is a recent addition to SWIG. It's the second compiled, typed
-language to be added. Ocaml has widely acknowledged benefits for engineers,
-mostly derived from a sophisticated type system, compile-time checking
-which eliminates several classes of common programming errors, and good
-native performance. While all of this is wonderful, there are well-written
-C and C++ libraries that Ocaml users will want to take advantage of as
-part of their arsenal (such as SSL and gdbm), as well as their own mature
-C and C++ code. SWIG allows this code to be used in a natural, type-safe
-way with Ocaml, by providing the necessary, but repetitive glue code
-which creates and uses Ocaml values to communicate with C and C++ code.
- In addition, SWIG also produces the needed Ocaml source that binds
-variants, functions, classes, etc.
+This chapter describes SWIG's support of Ocaml.
+</p>
+
+<p>
+Ocaml is a relatively recent addition to the ML family,
+and is a recent addition to SWIG. It's the second compiled, typed
+language to be added. Ocaml has widely acknowledged benefits for engineers,
+mostly derived from a sophisticated type system, compile-time checking
+which eliminates several classes of common programming errors, and good
+native performance. While all of this is wonderful, there are well-written
+C and C++ libraries that Ocaml users will want to take advantage of as
+part of their arsenal (such as SSL and gdbm), as well as their own mature
+C and C++ code. SWIG allows this code to be used in a natural, type-safe
+way with Ocaml, by providing the necessary, but repetitive glue code
+which creates and uses Ocaml values to communicate with C and C++ code.
+In addition, SWIG also produces the needed Ocaml source that binds
+variants, functions, classes, etc.
</p>
<p>
If you're not familiar with the Objective Caml language, you can visit
-<a href="http://www.ocaml.org/">The Ocaml Website</a>.
+<a href="http://ocaml.org/">The Ocaml Website</a>.
</p>
-<H2><a name="Ocaml_nn2"></a>29.1 Preliminaries</H2>
+<H2><a name="Ocaml_nn2">31.1 Preliminaries</a></H2>
<p>
- SWIG 1.3 works with Ocaml 3.04 and above. Given the choice,
- you should use the latest stable release. The SWIG Ocaml module has
-been tested on Linux (x86,PPC,Sparc) and Cygwin on Windows. The
-best way to determine whether your system will work is to compile the
-examples and test-suite which come with SWIG. You can do this by running
-<tt>make check</tt> from the SWIG root directory after installing SWIG.
- The Ocaml module has been tested using the system's dynamic linking (the
-usual -lxxx against libxxx.so, as well as with Gerd Stolpmann's
-<a
- href="http://download.camlcity.org/download/">Dl package
-</a>. The ocaml_dynamic and ocaml_dynamic_cpp targets in the
+SWIG 3.0 works with Ocaml 3.08.3 and above. Given the choice,
+you should use the latest stable release. The SWIG Ocaml module has
+been tested on Linux (x86,PPC,Sparc) and Cygwin on Windows. The
+best way to determine whether your system will work is to compile the
+examples and test-suite which come with SWIG. You can do this by running
+<tt>make check</tt> from the SWIG root directory after installing SWIG.
+The Ocaml module has been tested using the system's dynamic linking (the
+usual -lxxx against libxxx.so, as well as with Gerd Stolpmann's
+<a href="http://download.camlcity.org/download/">Dl package</a>.
+The ocaml_dynamic and ocaml_dynamic_cpp targets in the
file Examples/Makefile illustrate how to compile and link SWIG modules that
will be loaded dynamically. This has only been tested on Linux so far.
</p>
-<H3><a name="Ocaml_nn3"></a>29.1.1 Running SWIG</H3>
+<H3><a name="Ocaml_nn3">31.1.1 Running SWIG</a></H3>
<p>
- The basics of getting a SWIG Ocaml module up and running
- can be seen from one of SWIG's example Makefiles, but is also described
- here. To build an Ocaml module, run SWIG using the <tt>-ocaml</tt>
-option.
+The basics of getting a SWIG Ocaml module up and running
+can be seen from one of SWIG's example Makefiles, but is also described
+here. To build an Ocaml module, run SWIG using the <tt>-ocaml</tt>
+option.
</p>
-<div class="code">
+<div class="code">
+<pre>
%swig -ocaml example.i
- </pre>
+</pre>
</div>
-
-<p> This will produce 3 files. The file <tt>example_wrap.c</tt> contains
+
+<p>This will produce 3 files. The file <tt>example_wrap.c</tt> contains
all of the C code needed to build an Ocaml module. To build the module,
-you will compile the file <tt>example_wrap.c</tt> with <tt>ocamlc</tt> or
+you will compile the file <tt>example_wrap.c</tt> with <tt>ocamlc</tt> or
<tt>ocamlopt</tt> to create the needed .o file. You will need to compile
the resulting .ml and .mli files as well, and do the final link with -custom
-(not needed for native link). </p>
-
-<H3><a name="Ocaml_nn4"></a>29.1.2 Compiling the code</H3>
+(not needed for native link).</p>
+
+<H3><a name="Ocaml_nn4">31.1.2 Compiling the code</a></H3>
<p>
-The OCaml SWIG module now requires you to compile a module (<tt>Swig</tt>)
+The OCaml SWIG module now requires you to compile a module (<tt>Swig</tt>)
separately. In addition to aggregating common SWIG functionality, the Swig
module contains the data structure that represents C/C++ values. This allows
easier data sharing between modules if two or more are combined, because
also allows SWIG to acquire new conversions painlessly, as well as giving
the user more freedom with respect to custom typing.
- Use <tt>ocamlc</tt> or <tt>ocamlopt</tt> to compile your
- SWIG interface like:
+Use <tt>ocamlc</tt> or <tt>ocamlopt</tt> to compile your SWIG interface like:
</p>
-
-<div class="code">
+
+<div class="code">
+<pre>
% swig -ocaml -co swig.mli ; swig -ocaml co swig.ml
% ocamlc -c swig.mli ; ocamlc -c swig.ml
% ocamlc -c -ccopt "-I/usr/include/foo" example_wrap.c
% ocamlc -c example.mli
% ocamlc -c example.ml
- </pre>
+</pre>
</div>
-
-<p> <tt>ocamlc</tt> is aware of .c files and knows how to handle them. Unfortunately,
- it does not know about .cxx, .cc, or .cpp files, so when SWIG is invoked
- in C++ mode, you must: </p>
-
-<div class="code">
- <pre>
-% cp example_wrap.cxx example_wrap.cxx.c<br>% ocamlc -c ... -ccopt -xc++ example_wrap.cxx.c<br>% ...<br>
- </pre>
+
+<p><tt>ocamlc</tt> is aware of .c files and knows how to handle them. Unfortunately,
+it does not know about .cxx, .cc, or .cpp files, so when SWIG is invoked
+in C++ mode, you must:</p>
+
+<div class="code">
+<pre>
+% cp example_wrap.cxx example_wrap.cxx.c
+% ocamlc -c ... -ccopt -xc++ example_wrap.cxx.c
+% ...
+</pre>
</div>
-<H3><a name="Ocaml_nn5"></a>29.1.3 The camlp4 module</H3>
+<H3><a name="Ocaml_nn5">31.1.3 The camlp4 module</a></H3>
<p>
The camlp4 module (swigp4.ml -> swigp4.cmo) contains a simple rewriter which
-makes C++ code blend more seamlessly with objective caml code. It's use is
+makes C++ code blend more seamlessly with objective caml code. Its use is
optional, but encouraged. The source file is included in the Lib/ocaml
-directory of the SWIG source distribution. You can checkout this file with
-<tt>"swig -ocaml -co swigp4.ml"</tt>. You should compile the file with
+directory of the SWIG source distribution. You can checkout this file with
+<tt>"swig -ocaml -co swigp4.ml"</tt>. You should compile the file with
<tt>"ocamlc -I `camlp4 -where` -pp 'camlp4o pa_extend.cmo q_MLast.cmo' -c swigp4.ml"</tt>
</p>
<td>
(invoke object) "+=" argument as in<br>
(invoke a) "+=" b<td></tr>
-<tr><th colspan=2>Note that because camlp4 always recognizes <<
+<tr><th colspan=2>Note that because camlp4 always recognizes <<
and >>, they are replaced by lsl and lsr in operator names.
<tr><td>
<i>'unop</i> object as in<br>
</td></tr>
</table>
-<H3><a name="Ocaml_nn6"></a>29.1.4 Using your module</H3>
+<H3><a name="Ocaml_nn6">31.1.4 Using your module</a></H3>
<p>
You can test-drive your module by building a
toplevel ocaml interpreter. Consult the ocaml manual for details.
</p>
-
+
<p>
When linking any ocaml bytecode with your module, use the -custom
- option to build your functions into the primitive list. This
- option is not needed when you build native code.
+option to build your functions into the primitive list. This
+option is not needed when you build native code.
</p>
-<H3><a name="Ocaml_nn7"></a>29.1.5 Compilation problems and compiling with C++</H3>
+<H3><a name="Ocaml_nn7">31.1.5 Compilation problems and compiling with C++</a></H3>
<p>
Most code meant to be compiled as C++ will not have problems.
</p>
-<H2><a name="Ocaml_nn8"></a>29.2 The low-level Ocaml/C interface</H2>
+<H2><a name="Ocaml_nn8">31.2 The low-level Ocaml/C interface</a></H2>
<p>
writer, there is a value, swig_result, that always contains the
current return data. It is a list, and must be appended with the
caml_list_append function, or with functions and macros provided by
-objective caml.<br>
+objective caml.
</p>
-
+
<div class="code"><pre>
type c_obj =
C_void
</pre></div>
<p>
- A few functions exist which generate and return these:
+A few functions exist which generate and return these:
</p>
-
+
<ul>
- <li>caml_ptr_val receives a c_obj and returns a void *. This
- should be used for all pointer purposes.</li>
- <li>caml_long_val receives a c_obj and returns a long. This
- should be used for most integral purposes.<br>
- </li>
- <li>caml_val_ptr receives a void * and returns a c_obj.</li>
- <li>caml_val_bool receives a C int and returns a c_obj representing
- it's bool value.</li>
- <li>caml_val_(u)?(char|short|int|long|float|double) receives an
-appropriate C value and returns a c_obj representing it.</li>
- <li>caml_val_string receives a char * and returns a string value.</li>
- <li>caml_val_string_len receives a char * and a length and returns
- a string value.</li>
- <li>caml_val_obj receives a void * and an object type and returns
- a C_obj, which contains a closure giving method access.</li>
-
+ <li>caml_ptr_val receives a c_obj and returns a void *. This
+ should be used for all pointer purposes.</li>
+ <li>caml_long_val receives a c_obj and returns a long. This
+ should be used for most integral purposes.</li>
+ <li>caml_val_ptr receives a void * and returns a c_obj.</li>
+ <li>caml_val_bool receives a C int and returns a c_obj representing
+ its bool value.</li>
+ <li>caml_val_(u)?(char|short|int|long|float|double) receives an
+ appropriate C value and returns a c_obj representing it.</li>
+ <li>caml_val_string receives a char * and returns a string value.</li>
+ <li>caml_val_string_len receives a char * and a length and returns
+ a string value.</li>
+ <li>caml_val_obj receives a void * and an object type and returns
+ a C_obj, which contains a closure giving method access.</li>
</ul>
<p>
Because of this style, a typemap can return any kind of value it
-wants from a function. This enables out typemaps and inout typemaps
-to work well. The one thing to remember about outputting values
-is that you must append them to the return list with swig_result = caml_list_append(swig_result,v).
-</p>
-
-<p>
- This function will return a new list that has your element
- appended. Upon return to caml space, the fnhelper function
- beautifies the result. A list containing a single item degrades to
- only that item (i.e. [ C_int 3 ] -> C_int 3), and a list
- containing more than one item is wrapped in C_list (i.e. [ C_char
- 'a' ; C_char 'b' -> C_list [ C_char 'a' ; C_char b
- ]). This is in order to make return values easier to handle
- when functions have only one return value, such as constructors,
- and operators. In addition, string, pointer, and object
- values are interchangeable with respect to caml_ptr_val, so you can
- allocate memory as caml strings and still use the resulting
- pointers for C purposes, even using them to construct simple objects
- on. Note, though, that foreign C++ code does not respect the garbage
- collector, although the SWIG interface does.</p>
-
- <p>
- The wild card type that you can use in lots of different ways is
- C_obj. It allows you to wrap any type of thing you like as an
- object using the same mechanism that the ocaml module
- does. When evaluated in caml_ptr_val, the returned value is
- the result of a call to the object's "&" operator, taken as a pointer.
- </p>
- <p>
- You should only construct values using objective caml, or using the
- functions caml_val_* functions provided as static functions to a SWIG
- ocaml module, as well as the caml_list_* functions. These functions
- provide everything a typemap needs to produce values. In addition,
- value items pass through directly, but you must make your own type
- signature for a function that uses value in this way.
- </p>
-
-<H3><a name="Ocaml_nn9"></a>29.2.1 The generated module</H3>
+wants from a function. This enables out typemaps and inout typemaps
+to work well. The one thing to remember about outputting values
+is that you must append them to the return list with swig_result = caml_list_append(swig_result,v).
+</p>
+
+<p>
+This function will return a new list that has your element
+appended. Upon return to caml space, the fnhelper function
+beautifies the result. A list containing a single item degrades to
+only that item (i.e. [ C_int 3 ] -> C_int 3), and a list
+containing more than one item is wrapped in C_list (i.e. [ C_char
+'a' ; C_char 'b' -> C_list [ C_char 'a' ; C_char b
+]). This is in order to make return values easier to handle
+when functions have only one return value, such as constructors,
+and operators. In addition, string, pointer, and object
+values are interchangeable with respect to caml_ptr_val, so you can
+allocate memory as caml strings and still use the resulting
+pointers for C purposes, even using them to construct simple objects
+on. Note, though, that foreign C++ code does not respect the garbage
+collector, although the SWIG interface does.</p>
+
+<p>
+The wild card type that you can use in lots of different ways is
+C_obj. It allows you to wrap any type of thing you like as an
+object using the same mechanism that the ocaml module
+does. When evaluated in caml_ptr_val, the returned value is
+the result of a call to the object's "&" operator, taken as a pointer.
+</p>
+
+<p>
+You should only construct values using objective caml, or using the
+functions caml_val_* functions provided as static functions to a SWIG
+ocaml module, as well as the caml_list_* functions. These functions
+provide everything a typemap needs to produce values. In addition,
+value items pass through directly, but you must make your own type
+signature for a function that uses value in this way.
+</p>
+
+<H3><a name="Ocaml_nn9">31.2.1 The generated module</a></H3>
<p>
You can introduce extra code into the output wherever you like with SWIG.
These are the places you can introduce code:
<table border="1" summary="Extra code sections">
-<tr><td>"header"</td><td>This code is inserted near the beginning of the
+<tr><td>"header"</td><td>This code is inserted near the beginning of the
C wrapper file, before any function definitions.</td></tr>
<tr><td>"wrapper"</td><td>This code is inserted in the function definition
section.</td></tr>
<tr><td>"mli"</td><td>This code is inserted into the caml interface file.
Special signatures should be inserted here.
</td></tr>
-<tr><td>"ml"</td><td>This code is inserted in the caml code defining the
+<tr><td>"ml"</td><td>This code is inserted in the caml code defining the
interface to your C code. Special caml code, as well as any initialization
which should run when the module is loaded may be inserted here.
-</td></tr>
+</td></tr>
<tr><td>"classtemplate"</td><td>The "classtemplate" place is special because
it describes the output SWIG will generate for class definitions.
</td></tr>
</table>
-
-<H3><a name="Ocaml_nn10"></a>29.2.2 Enums</H3>
+
+<H3><a name="Ocaml_nn10">31.2.2 Enums</a></H3>
<p>
SWIG will wrap enumerations as polymorphic variants in the output
-Ocaml code, as above in C_enum. In order to support all
+Ocaml code, as above in C_enum. In order to support all
C++-style uses of enums, the function int_to_enum and enum_to_int are
provided for ocaml code to produce and consume these values as
-integers. Other than that, correct uses of enums will not have
-a problem. Since enum labels may overlap between enums, the
+integers. Other than that, correct uses of enums will not have
+a problem. Since enum labels may overlap between enums, the
enum_to_int and int_to_enum functions take an enum type label as an
argument. Example:
</p>
enum c_enum_type { a = 1, b, c = 4, d = 8 };
</pre></div>
-<p>
+<p>
The output mli contains:
-</p>
+</p>
<div class="code"><pre>
type c_enum_type = [
val int_to_enum c_enum_type -> int -> c_obj
val enum_to_int c_enum_type -> c_obj -> c_obj
</pre>
- </div>
+</div>
<p>
- So it's possible to do this:
+So it's possible to do this:
</p>
-<div class="code">
+<div class="code">
+<pre>
bash-2.05a$ ocamlmktop -custom enum_test_wrap.o enum_test.cmo -o enum_test_top
-bash-2.05a$ ./enum_test_top
+bash-2.05a$ ./enum_test_top
Objective Caml version 3.04
# open Enum_test ;;
# int_to_enum `c_enum_type 4 ;;
- : Enum_test.c_obj = C_enum `c
</pre>
- </div>
+</div>
-<H4><a name="Ocaml_nn11"></a>29.2.2.1 Enum typing in Ocaml</H4>
+<H4><a name="Ocaml_nn11">31.2.2.1 Enum typing in Ocaml</a></H4>
<p>
values using the swig_val function before sharing them with another module.
</p>
-<H3><a name="Ocaml_nn12"></a>29.2.3 Arrays</H3>
+<H3><a name="Ocaml_nn12">31.2.3 Arrays</a></H3>
-<H4><a name="Ocaml_nn13"></a>29.2.3.1 Simple types of bounded arrays</H4>
+<H4><a name="Ocaml_nn13">31.2.3.1 Simple types of bounded arrays</a></H4>
<p>
<p>
By including "carray.i", you will get access to some macros that help you
-create typemaps for array types fairly easily.
+create typemaps for array types fairly easily.
</p>
<p>
for arrays whose bounds are completely specified.
</p>
-<H4><a name="Ocaml_nn14"></a>29.2.3.2 Complex and unbounded arrays</H4>
+<H4><a name="Ocaml_nn14">31.2.3.2 Complex and unbounded arrays</a></H4>
<p>
so you have to specify it for yourself in the form of a typemap.
</p>
-<H4><a name="Ocaml_nn15"></a>29.2.3.3 Using an object</H4>
+<H4><a name="Ocaml_nn15">31.2.3.3 Using an object</a></H4>
<p>
such as using a required sentinel, etc.
</p>
-<H4><a name="Ocaml_nn16"></a>29.2.3.4 Example typemap for a function taking float * and int</H4>
+<H4><a name="Ocaml_nn16">31.2.3.4 Example typemap for a function taking float * and int</a></H4>
<p>
#include <stdio.h>
void printfloats( float *tab, int len ) {
- int i;
+ int i;
- for( i = 0; i < len; i++ ) {
- printf( "%f ", tab[i] );
- }
+ for( i = 0; i < len; i++ ) {
+ printf( "%f ", tab[i] );
+ }
- printf( "\n" );
+ printf( "\n" );
}
%}
%typemap(in) (float *tab, int len) {
- int i;
- /* $*1_type */
- $2 = caml_array_len($input);
- $1 = ($*1_type *)malloc( $2 * sizeof( float ) );
- for( i = 0; i < $2; i++ ) {
- $1[i] = caml_double_val(caml_array_nth($input,i));
- }
+ int i;
+ /* $*1_type */
+ $2 = caml_array_len($input);
+ $1 = ($*1_type *)malloc( $2 * sizeof( float ) );
+ for( i = 0; i < $2; i++ ) {
+ $1[i] = caml_double_val(caml_array_nth($input,i));
+ }
}
void printfloats( float *tab, int len );
</pre></td></tr></table>
-<H3><a name="Ocaml_nn17"></a>29.2.4 C++ Classes</H3>
+<H3><a name="Ocaml_nn17">31.2.4 C++ Classes</a></H3>
<p>
C++ classes, along with structs and unions are represented by C_obj
-(string -> c_obj -> c_obj) wrapped closures. These objects
+(string -> c_obj -> c_obj) wrapped closures. These objects
contain a method list, and a type, which allow them to be used like
C++ objects. When passed into typemaps that use pointers, they
-degrade to pointers through their "&" method. Every method
+degrade to pointers through their "&" method. Every method
an object has is represented as a string in the object's method table,
-and each method table exists in memory only once. In addition
+and each method table exists in memory only once. In addition
to any other operators an object might have, certain builtin ones are
-provided by SWIG: (all of these take no arguments (C_void))
+provided by SWIG: (all of these take no arguments (C_void))
</p>
<table summary="SWIG provided operators">
<tr><td>"~"</td><td>Delete this object</td></tr>
-<tr><td>"&"</td><td>Return an ordinary C_ptr value representing this
+<tr><td>"&"</td><td>Return an ordinary C_ptr value representing this
object's address</td></tr>
<tr><td>"sizeof"</td><td>If enabled with ("sizeof"="1") on the module node,
return the object's size in char.</td></tr>
<tr><td>":methods"</td><td>Returns a list of strings containing the names of
the methods this object contains</td></tr>
-<tr><td>":classof"</td><td>Returns the name of the class this object belongs
+<tr><td>":classof"</td><td>Returns the name of the class this object belongs
to.</td></tr>
<tr><td>":parents"</td><td>Returns a list of all direct parent classes which
have been wrapped by SWIG.</td></tr>
indicated parent class. This is mainly used internally by the SWIG module,
but may be useful to client programs.</td></tr>
<tr><td>"[member-variable]"</td><td>Each member variable is wrapped as a
-method with an optional parameter.
-Called with one argument, the member variable is set to the value of the
+method with an optional parameter.
+Called with one argument, the member variable is set to the value of the
argument. With zero arguments, the value is returned.
</td></tr>
</table>
returned value for the same object.
</p>
-<H4><a name="Ocaml_nn18"></a>29.2.4.1 STL vector and string Example</H4>
+<H4><a name="Ocaml_nn18">31.2.4.1 STL vector and string Example</a></H4>
<p>
%include <stl.i>
namespace std {
- %template(StringVector) std::vector < string >;
+ %template(StringVector) std::vector < string >;
};
%include "example.h"
<p>
Here's a sample transcript of an interactive session using a string vector
-after making a toplevel (make toplevel). This example uses the camlp4
+after making a toplevel (make toplevel). This example uses the camlp4
module.
</p>
<div class="code"><pre>
-bash-2.05a$ ./example_top
+bash-2.05a$ ./example_top
Objective Caml version 3.06
Camlp4 Parsing version 3.06
- : Example.c_obj = C_void
# x '[1] ;;
- : Example.c_obj = C_string "spam"
-# for i = 0 to (x -> size() as int) - 1 do
- print_endline ((x '[i to int]) as string)
+# for i = 0 to (x -> size() as int) - 1 do
+ print_endline ((x '[i to int]) as string)
done ;;
foo
bar
baz
- : unit = ()
-#
+#
</pre></div>
-<H4><a name="Ocaml_nn19"></a>29.2.4.2 C++ Class Example</H4>
+<H4><a name="Ocaml_nn19">31.2.4.2 C++ Class Example</a></H4>
<p>
</p>
<table border="1" bgcolor="#dddddd" summary="Qt Library example">
- <tr><th><center>qt.i</center></th></tr>
+<tr><th><center>qt.i</center></th></tr>
<tr><td><pre>
%module qt
%{
%}
class QApplication {
public:
- QApplication( int argc, char **argv );
- void setMainWidget( QWidget *widget );
- void exec();
+ QApplication( int argc, char **argv );
+ void setMainWidget( QWidget *widget );
+ void exec();
};
class QPushButton {
public:
- QPushButton( char *str, QWidget *w );
- void resize( int x, int y );
- void show();
+ QPushButton( char *str, QWidget *w );
+ void resize( int x, int y );
+ void show();
};
</pre></td></tr></table>
-<H4><a name="Ocaml_nn20"></a>29.2.4.3 Compiling the example</H4>
+<H4><a name="Ocaml_nn20">31.2.4.3 Compiling the example</a></H4>
<div class="code"><pre>
bash-2.05a$ for file in swig.mli swig.ml swigp4.ml ; do swig -ocaml -co $file ; done
bash-2.05a$ ocamlc -c swig.mli ; ocamlc -c swig.ml
bash-2.05a$ ocamlc -I `camlp4 -where` -pp "camlp4o pa_extend.cmo q_MLast.cmo" -c swigp4.ml
-bash-2.05a$ swig -ocaml -c++ -I$QTPATH/include qt.i
+bash-2.05a$ swig -ocaml -c++ -I$QTPATH/include qt.i
bash-2.05a$ mv qt_wrap.cxx qt_wrap.c
-bash-2.05a$ ocamlc -c -ccopt -xc++ -ccopt -g -g -ccopt -I$QTPATH/include qt_wrap.c
+bash-2.05a$ ocamlc -c -ccopt -xc++ -ccopt -g -g -ccopt -I$QTPATH/include qt_wrap.c
bash-2.05a$ ocamlc -c qt.mli
bash-2.05a$ ocamlc -c qt.ml
bash-2.05a$ ocamlmktop -custom swig.cmo -I `camlp4 -where` \
-L$QTPATH/lib -cclib -lqt
</pre></div>
-<H4><a name="Ocaml_nn21"></a>29.2.4.4 Sample Session</H4>
+<H4><a name="Ocaml_nn21">31.2.4.4 Sample Session</a></H4>
<div class="code"><pre>
-bash-2.05a$ ./qt_top
+bash-2.05a$ ./qt_top
Objective Caml version 3.06
Camlp4 Parsing version 3.06
<p>
Assuming you have a working installation of QT, you will see a window
-containing the string "hi" in a button.
+containing the string "hi" in a button.
</p>
-<H3><a name="Ocaml_nn22"></a>29.2.5 Director Classes</H3>
+<H3><a name="Ocaml_nn22">31.2.5 Director Classes</a></H3>
-<H4><a name="Ocaml_nn23"></a>29.2.5.1 Director Introduction</H4>
+<H4><a name="Ocaml_nn23">31.2.5.1 Director Introduction</a></H4>
<p>
};
</pre></div>
-<H4><a name="Ocaml_nn24"></a>29.2.5.2 Overriding Methods in Ocaml</H4>
+<H4><a name="Ocaml_nn24">31.2.5.2 Overriding Methods in Ocaml</a></H4>
<p>
an overloaded class. This example is contained in Examples/ocaml/shapes.
</p>
-<H4><a name="Ocaml_nn25"></a>29.2.5.3 Director Usage Example</H4>
+<H4><a name="Ocaml_nn25">31.2.5.3 Director Usage Example</a></H4>
<table border="1" bgcolor="#dddddd" summary="Director usage example">
"cover" ->
(match args with
C_list [ x_arg ; y_arg ] ->
- let xa = x_arg as float
- and ya = y_arg as float in
- (point_in_triangle pts xa ya) to bool
+ let xa = x_arg as float
+ and ya = y_arg as float in
+ (point_in_triangle pts xa ya) to bool
| _ -> raise (Failure "cover needs two double arguments."))
| _ -> (invoke ob) meth args ;;
let triangle =
- new_derived_object
+ new_derived_object
new_shape
(triangle_class ((0.0,0.0),(0.5,1.0),(1.0,0.0)))
'() ;;
program in C++.
</p>
-<H4><a name="Ocaml_nn26"></a>29.2.5.4 Creating director objects</H4>
+<H4><a name="Ocaml_nn26">31.2.5.4 Creating director objects</a></H4>
<p>
<div class="code"><pre>
let triangle =
- new_derived_object
+ new_derived_object
new_shape
(triangle_class ((0.0,0.0),(0.5,1.0),(1.0,0.0)))
'()
<p>
The first argument to <tt>new_derived_object</tt>, new_shape is the method
-which returns a shape instance. This function will be invoked with the
+which returns a shape instance. This function will be invoked with the
third argument will be appended to the argument list [ C_void ]. In the
example, the actual argument list is sent as (C_list [ C_void ; C_void ]).
The augmented constructor for a director class needs the first argument
to determine whether it is being constructed as a derived object, or as
an object of the indicated type only (in this case <tt>shape</tt>). The
-Second argument is a closure that will be added to the final C_obj.
+Second argument is a closure that will be added to the final C_obj.
</p>
<p>
properly.
</p>
-<H4><a name="Ocaml_nn27"></a>29.2.5.5 Typemaps for directors, <tt>directorin, directorout, directorargout</tt></H4>
+<H4><a name="Ocaml_nn27">31.2.5.5 Typemaps for directors, directorin, directorout, directorargout</a></H4>
<p>
and to receive arguments the same way you normally receive function returns.
</p>
-<H4><a name="Ocaml_nn28"></a>29.2.5.6 <tt>directorin</tt> typemap</H4>
+<H4><a name="Ocaml_nn28">31.2.5.6 typemap</a></H4>
<p>
can use the same body as a simple <tt>out</tt> typemap.
</p>
-<H4><a name="Ocaml_nn29"></a>29.2.5.7 <tt>directorout</tt> typemap</H4>
+<H4><a name="Ocaml_nn29">31.2.5.7 directorout typemap</a></H4>
<p>
ownership, etc.
</p>
-<H4><a name="Ocaml_nn30"></a>29.2.5.8 <tt>directorargout</tt> typemap</H4>
+<H4><a name="Ocaml_nn30">31.2.5.8 directorargout typemap</a></H4>
<p>
values will read zero, and struct or object returns have undefined results.
</p>
-<H3><a name="Ocaml_nn31"></a>29.2.6 Exceptions</H3>
+<H3><a name="Ocaml_nn31">31.2.6 Exceptions</a></H3>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Octave</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Octave"></a>30 SWIG and Octave</H1>
+<H1><a name="Octave">32 SWIG and Octave</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#Octave_nn19">Class extension with %extend</a>
<li><a href="#Octave_nn20">C++ templates</a>
<li><a href="#Octave_nn21">C++ Smart Pointers</a>
+<ul>
+<li><a href="#Octave_smart_pointers_shared_ptr">The shared_ptr Smart Pointer</a>
+<li><a href="#Octave_smart_pointers_generic">Generic Smart Pointers</a>
+</ul>
<li><a href="#Octave_nn22">Directors (calling Octave from C++ code)</a>
<li><a href="#Octave_nn23">Threads</a>
<li><a href="#Octave_nn24">Memory management</a>
Also, there are a dozen or so examples in the Examples/octave directory, and hundreds in the test suite (Examples/test-suite and Examples/test-suite/octave).
</p>
-<H2><a name="Octave_nn2"></a>30.1 Preliminaries</H2>
+<H2><a name="Octave_nn2">32.1 Preliminaries</a></H2>
<p>
-As of SWIG 3.0.0, the Octave module has been tested with Octave versions 3.0.5, 3.2.4, 3.4.3, 3.6.4, and 3.8.0.
-Use of Octave versions older than 3.x.x is not recommended, as these versions are no longer tested with SWIG.
+As of SWIG 3.0.7, the Octave module is regularly tested with Octave versions 3.2.4, 3.8.1, and 4.0.0.
+Use of older Octave versions is not recommended, as these versions are no longer tested with SWIG.
+The SWIG runtime exports the function <tt>swig_octave_prereq()</tt> for checking the version of Octave.
</p>
-<H2><a name="Octave_nn3"></a>30.2 Running SWIG</H2>
+<H2><a name="Octave_nn3">32.2 Running SWIG</a></H2>
<p>
This creates a C++ source file "example_wrap.cpp". A C++ file is generated even when wrapping C code as Octave is itself written in C++ and requires wrapper code to be in the same language. The generated C++ source file contains the low-level wrappers that need to be compiled and linked with the rest of your C/C++ application (in this case, the gcd implementation) to create an extension module.
</p>
-<H3><a name="Octave_nn4"></a>30.2.1 Command-line options</H3>
+<H3><a name="Octave_nn4">32.2.1 Command-line options</a></H3>
<p>
The <em>-opprefix</em> options sets the prefix of the names of global/friend <a href="#Octave_nn18">operator</a> functions.
</p>
-<H3><a name="Octave_nn5"></a>30.2.2 Compiling a dynamic module</H3>
+<H3><a name="Octave_nn5">32.2.2 Compiling a dynamic module</a></H3>
<p>
<div class="targetlang"><pre>octave:1> swigexample</pre></div>
-<H3><a name="Octave_nn6"></a>30.2.3 Using your module</H3>
+<H3><a name="Octave_nn6">32.2.3 Using your module</a></H3>
<p>
octave:5> swigexample.cvar.Foo
ans = 4 </pre></div>
-<H2><a name="Octave_nn7"></a>30.3 A tour of basic C/C++ wrapping</H2>
+<H2><a name="Octave_nn7">32.3 A tour of basic C/C++ wrapping</a></H2>
-<H3><a name="Octave_nn8"></a>30.3.1 Modules</H3>
+<H3><a name="Octave_nn8">32.3.1 Modules</a></H3>
<p>
ans = 2
</pre></div>
-<H3><a name="Octave_nn9"></a>30.3.2 Functions</H3>
+<H3><a name="Octave_nn9">32.3.2 Functions</a></H3>
<p>
<div class="targetlang"><pre>octave:1> swigexample.fact(4)
24 </pre></div>
-<H3><a name="Octave_nn10"></a>30.3.3 Global variables</H3>
+<H3><a name="Octave_nn10">32.3.3 Global variables</a></H3>
<p>
octave:3> swigexample.PI
ans = 3.1420 </pre></div>
-<H3><a name="Octave_nn11"></a>30.3.4 Constants and enums</H3>
+<H3><a name="Octave_nn11">32.3.4 Constants and enums</a></H3>
<p>
swigexample.SUNDAY=0
.... </pre></div>
-<H3><a name="Octave_nn12"></a>30.3.5 Pointers</H3>
+<H3><a name="Octave_nn12">32.3.5 Pointers</a></H3>
<p>
</pre></div>
<p>
- Simply printing the value of a wrapped C++ type will print it's typename. E.g.,
+ Simply printing the value of a wrapped C++ type will print its typename. E.g.,
</p>
<div class="targetlang"><pre>octave:1> swigexample;
error: value on right hand side of assignment is undefined
error: evaluating assignment expression near line 2, column 2 </pre></div>
-<H3><a name="Octave_nn13"></a>30.3.6 Structures and C++ classes</H3>
+<H3><a name="Octave_nn13">32.3.6 Structures and C++ classes</a></H3>
<p>
Depending on the ownership setting of a <tt>swig_ref</tt>, it may call C++ destructors when its reference count goes to zero. See the section on memory management below for details.
</p>
-<H3><a name="Octave_nn15"></a>30.3.7 C++ inheritance</H3>
+<H3><a name="Octave_nn15">32.3.7 C++ inheritance</a></H3>
<p>
the tree is walked to find a match in the current class as well as any of its bases. The lookup is then cached in the <tt>swig_ref</tt>.
</p>
-<H3><a name="Octave_nn17"></a>30.3.8 C++ overloaded functions</H3>
+<H3><a name="Octave_nn17">32.3.8 C++ overloaded functions</a></H3>
<p>
<tt>typecheck</tt> typemaps are used to analyze each argument, as well as assign precedence. See the chapter on typemaps for details.
</p>
-<H3><a name="Octave_nn18"></a>30.3.9 C++ operators</H3>
+<H3><a name="Octave_nn18">32.3.9 C++ operators</a></H3>
<p>
The <tt>swig_ref</tt> type supports all unary and binary operators between itself and all other types that exist in the system at module load time. When an operator is used (where one of the operands is a <tt>swig_ref</tt>), the runtime routes the call to either a member function of the given object, or to a global function whose named is derived from the types of the operands (either both or just the lhs or rhs).
</p>
<p>
-For example, if <tt>a</tt> and <tt>b</tt> are SWIG variables in Octave, <tt>a+b</tt> becomes <tt>a.__add(b)</tt>. The wrapper is then free to implement __add to do whatever it wants. A wrapper may define the <tt>__add</tt> function manually, %rename some other function to it, or %rename a C++ operator to it.
+For example, if <tt>a</tt> and <tt>b</tt> are SWIG variables in Octave, <tt>a+b</tt> becomes <tt>a.__add__(b)</tt>. The wrapper is then free to implement __add__ to do whatever it wants. A wrapper may define the <tt>__add__</tt> function manually, %rename some other function to it, or %rename a C++ operator to it.
</p>
<p>
By default the C++ operators are renamed to their corresponding Octave operators. So without doing any work, the following interface
Octave operators are mapped in the following way:
</p>
<div class="code"><pre>
-__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
+__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
</pre></div>
<p>
On the C++ side, the default mappings are as follows:
</p>
<div class="code"><pre>
-%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[];
+%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[];
</pre></div>
<p>
Octave can also utilise friend (i.e. non-member) operators with a simple %rename: see the example in the Examples/octave/operator directory.
</p>
-<H3><a name="Octave_nn19"></a>30.3.10 Class extension with %extend</H3>
+<H3><a name="Octave_nn19">32.3.10 Class extension with %extend</a></H3>
<p>
The %extend directive works the same as in other modules.
</p>
<p>
-You can use it to define special behavior, like for example defining Octave operators not mapped to C++ operators, or defining certain Octave mechanisms such as how an object prints. For example, the <tt>octave_value::{is_string,string_value,print}</tt> functions are routed to a special method <tt>__str</tt> that can be defined inside an %extend.
+You can use it to define special behavior, like for example defining Octave operators not mapped to C++ operators, or defining certain Octave mechanisms such as how an object prints. For example, the <tt>octave_value::{is_string,string_value,print}</tt> functions are routed to a special method <tt>__str__</tt> that can be defined inside an %extend.
</p>
<div class="code"><pre>
%extend A {
-string __str() {
+string __str__() {
stringstream sout;
sout<<$self->value;
return sout.str();
a = 4
octave:3> printf("%s\n",a);
4
-octave:4> a.__str()
+octave:4> a.__str__()
4
</pre></div>
-<H3><a name="Octave_nn20"></a>30.3.11 C++ templates</H3>
+
+<p>
+Similarly, Octave can use the <tt>__float__</tt> method to convert an object to a numeric value.
+</p>
+
+<p>
+Octave 3.8.0 and later versions will also map unary functions X() to the corresponding <tt>__X__</tt> method, where X includes: abs(), acos(), acosh(), angle(), arg(), asin(), asinh(), atan(), atanh(), cbrt(), ceil(), conj(), cos(), cosh(), dawson(), erf(), erfc(), erfcinv(), erfcx(), erfi(), erfinv(), exp(), expm1(), finite(), fix(), floor(), gamma(), imag(), isalnum(), isalpha(), isascii(), iscntrl(), isdigit(), isgraph(), isinf(), islower(), isna(), isnan(), isprint(), ispunct(), isspace(), isupper(), isxdigit(), lgamma(), log(), log10(), log1p(), log2(), real(), round(), roundb(), signbit(), signum(), sin(), sinh(), sqrt(), tan(), tanh(), toascii(), tolower(), toupper()
+</p>
+
+<H3><a name="Octave_nn20">32.3.11 C++ templates</a></H3>
<p>
s+=_s;
return *this;
}
- std::string __str() const {
+ std::string __str__() const {
std::stringstream sout;
sout<<s;
return sout.str();
</pre></div>
-<H3><a name="Octave_nn21"></a>30.3.12 C++ Smart Pointers</H3>
+<H3><a name="Octave_nn21">32.3.12 C++ Smart Pointers</a></H3>
+
+
+<H4><a name="Octave_smart_pointers_shared_ptr">32.3.12.1 The shared_ptr Smart Pointer</a></H4>
+
+
+<p>
+The C++11 standard provides <tt>std::shared_ptr</tt> which was derived from the Boost
+implementation, <tt>boost::shared_ptr</tt>.
+Both of these are available for Octave in the SWIG library and usage is outlined
+in the <a href="Library.html#Library_std_shared_ptr">shared_ptr smart pointer</a> library section.
+</p>
+
+
+<H4><a name="Octave_smart_pointers_generic">32.3.12.2 Generic Smart Pointers</a></H4>
<p>
C++ smart pointers are fully supported as in other modules.
</p>
-<H3><a name="Octave_nn22"></a>30.3.13 Directors (calling Octave from C++ code)</H3>
+<H3><a name="Octave_nn22">32.3.13 Directors (calling Octave from C++ code)</a></H3>
<p>
octave-side routine called
</pre></div>
-<H3><a name="Octave_nn23"></a>30.3.14 Threads</H3>
+<H3><a name="Octave_nn23">32.3.14 Threads</a></H3>
<p>
The use of threads in wrapped Director code is not supported; i.e., an Octave-side implementation of a C++ class must be called from the Octave interpreter's thread. Anything fancier (apartment/queue model, whatever) is left to the user. Without anything fancier, this amounts to the limitation that Octave must drive the module... like, for example, an optimization package that calls Octave to evaluate an objective function.
</p>
-<H3><a name="Octave_nn24"></a>30.3.15 Memory management</H3>
+<H3><a name="Octave_nn24">32.3.15 Memory management</a></H3>
<p>
In the case where one wishes for the C++ side to own an object that was created in Octave (especially a Director object), one can use the __disown() method to invert this logic. Then letting the Octave reference count go to zero will not destroy the object, but destroying the object will invalidate the Octave-side object if it still exists (and call destructors of other C++ bases in the case of multiple inheritance/<tt>subclass()</tt>'ing).
</p>
-<H3><a name="Octave_nn25"></a>30.3.16 STL support</H3>
+<H3><a name="Octave_nn25">32.3.16 STL support</a></H3>
<p>
Various STL library files are provided for wrapping STL containers.
</p>
-<H3><a name="Octave_nn26"></a>30.3.17 Matrix typemaps</H3>
+<H3><a name="Octave_nn26">32.3.17 Matrix typemaps</a></H3>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Perl5</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Perl5"></a>31 SWIG and Perl5</H1>
+<H1><a name="Perl5">33 SWIG and Perl5</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#Perl5_nn46">Modifying the proxy methods</a>
</ul>
<li><a href="#Perl5_nn47">Adding additional Perl code</a>
+<li><a href="#Perl5_directors">Cross language polymorphism</a>
+<ul>
+<li><a href="#Perl5_nn48">Enabling directors</a>
+<li><a href="#Perl5_nn49">Director classes</a>
+<li><a href="#Perl5_nn50">Ownership and object destruction</a>
+<li><a href="#Perl5_nn51">Exception unrolling</a>
+<li><a href="#Perl5_nn52">Overhead and code bloat</a>
+<li><a href="#Perl5_nn53">Typemaps</a>
+</ul>
</ul>
</div>
<!-- INDEX -->
Perl 5.6 seems to mostly work, while older versions don't.
</p>
-<H2><a name="Perl5_nn2"></a>31.1 Overview</H2>
+<H2><a name="Perl5_nn2">33.1 Overview</a></H2>
<p>
options are found near the end of the chapter.
</p>
-<H2><a name="Perl5_nn3"></a>31.2 Preliminaries</H2>
+<H2><a name="Perl5_nn3">33.2 Preliminaries</a></H2>
<p>
<tt>example_wrap.c</tt> and link it with the rest of your program.
</p>
-<H3><a name="Perl5_nn4"></a>31.2.1 Getting the right header files</H3>
+<H3><a name="Perl5_nn4">33.2.1 Getting the right header files</a></H3>
<p>
</pre>
</div>
-<H3><a name="Perl5_nn5"></a>31.2.2 Compiling a dynamic module</H3>
+<H3><a name="Perl5_nn5">33.2.2 Compiling a dynamic module</a></H3>
<p>
`<tt>example.sl</tt>', or the appropriate dynamic module name on your system.
</p>
-<H3><a name="Perl5_nn6"></a>31.2.3 Building a dynamic module with MakeMaker</H3>
+<H3><a name="Perl5_nn6">33.2.3 Building a dynamic module with MakeMaker</a></H3>
<p>
# File : Makefile.PL
use ExtUtils::MakeMaker;
WriteMakefile(
- `NAME' => `example', # Name of package
- `LIBS' => [`-lm'], # Name of custom libraries
- `OBJECT' => `example.o example_wrap.o' # Object files
+ `NAME' => `example', # Name of package
+ `LIBS' => [`-lm'], # Name of custom libraries
+ `OBJECT' => `example.o example_wrap.o' # Object files
);
</pre></div>
found in "Programming Perl, 2nd ed." by Larry Wall, Tom Christiansen,
and Randal Schwartz.</p>
-<H3><a name="Perl5_nn7"></a>31.2.4 Building a static version of Perl</H3>
+<H3><a name="Perl5_nn7">33.2.4 Building a static version of Perl</a></H3>
<p>
<div class="code"><pre>
$ gcc example.o example_wrap.o -L/usr/lib/perl/5.14/CORE \
- -lperl -lsocket -lnsl -lm -o myperl
+ -lperl -lsocket -lnsl -lm -o myperl
</pre></div>
<p>
additional libraries such as <tt>-lsocket, -lnsl, -ldl</tt>, etc.
</p>
-<H3><a name="Perl5_nn8"></a>31.2.5 Using the module</H3>
+<H3><a name="Perl5_nn8">33.2.5 Using the module</a></H3>
<p>
read the man pages).
</p>
-<H3><a name="Perl5_nn9"></a>31.2.6 Compilation problems and compiling with C++</H3>
+<H3><a name="Perl5_nn9">33.2.6 Compilation problems and compiling with C++</a></H3>
<p>
<div class="code"><pre>
$ swig -c++ -perl example.i
-$ CC -c example.cxx
-$ CC -c example_wrap.cxx -I/usr/lib/perl/5.14/i386-linux/CORE
+$ CC -Kpic -c example.cxx
+$ CC -Kpic -c example_wrap.cxx -I/usr/lib/perl/5.14/i386-linux/CORE
$ CC -shared example.o example_wrap.o -o example.so <b>-lCrun</b>
</pre></div>
any conflicting macros you find to <a href="http://www.swig.org/mail.html">swig-user mailing list</a>.
</p>
-<H3><a name="Perl5_nn10"></a>31.2.7 Compiling for 64-bit platforms</H3>
+<H3><a name="Perl5_nn10">33.2.7 Compiling for 64-bit platforms</a></H3>
<p>
linking standard (e.g., -o32 and -n32 on Irix).
</p>
-<H2><a name="Perl5_nn11"></a>31.3 Building Perl Extensions under Windows</H2>
+<H2><a name="Perl5_nn11">33.3 Building Perl Extensions under Windows</a></H2>
<p>
although the procedure may be similar with other compilers.
</p>
-<H3><a name="Perl5_nn12"></a>31.3.1 Running SWIG from Developer Studio</H3>
+<H3><a name="Perl5_nn12">33.3.1 Running SWIG from Developer Studio</a></H3>
<p>
</pre></div>
-<H3><a name="Perl5_nn13"></a>31.3.2 Using other compilers</H3>
+<H3><a name="Perl5_nn13">33.3.2 Using other compilers</a></H3>
<p>
For general hints and suggestions refer to the <a href="Windows.html#Windows">Windows</a> chapter.
</p>
-<H2><a name="Perl5_nn14"></a>31.4 The low-level interface</H2>
+<H2><a name="Perl5_nn14">33.4 The low-level interface</a></H2>
<p>
construct more user-friendly proxy classes as described in the next section.
</p>
-<H3><a name="Perl5_nn15"></a>31.4.1 Functions</H3>
+<H3><a name="Perl5_nn15">33.4.1 Functions</a></H3>
<p>
$a = &example::fact(2);
</pre></div>
-<H3><a name="Perl5_nn16"></a>31.4.2 Global variables</H3>
+<H3><a name="Perl5_nn16">33.4.2 Global variables</a></H3>
<p>
</pre>
</div>
-<H3><a name="Perl5_nn17"></a>31.4.3 Constants</H3>
+<H3><a name="Perl5_nn17">33.4.3 Constants</a></H3>
<p>
</pre>
</div>
-<H3><a name="Perl5_nn18"></a>31.4.4 Pointers</H3>
+<H3><a name="Perl5_nn18">33.4.4 Pointers</a></H3>
<p>
<div class="targetlang"><pre>
if (defined($ptr)) {
- print "Not a NULL pointer.";
+ print "Not a NULL pointer.";
} else {
- print "Is a NULL pointer.";
+ print "Is a NULL pointer.";
}
</pre></div>
<div class="targetlang"><pre>
if ($$a == $$b) {
- print "a and b point to the same thing in C";
+ print "a and b point to the same thing in C";
} else {
- print "a and b point to different objects.";
+ print "a and b point to different objects.";
}
</pre></div>
SWIG and XS, this is no longer supported.
</p>
-<H3><a name="Perl5_nn19"></a>31.4.5 Structures</H3>
+<H3><a name="Perl5_nn19">33.4.5 Structures</a></H3>
<p>
<div class="code"><pre>
struct Vector {
- double x,y,z;
+ double x,y,z;
};
</pre></div>
</div>
-<H3><a name="Perl5_nn20"></a>31.4.6 C++ classes</H3>
+<H3><a name="Perl5_nn20">33.4.6 C++ classes</a></H3>
<p>
can be built using these low-level accessors. This is described shortly.
</p>
-<H3><a name="Perl5_nn21"></a>31.4.7 C++ classes and type-checking</H3>
+<H3><a name="Perl5_nn21">33.4.7 C++ classes and type-checking</a></H3>
<p>
multiple inheritance is used).
</p>
-<H3><a name="Perl5_nn22"></a>31.4.8 C++ overloaded functions</H3>
+<H3><a name="Perl5_nn22">33.4.8 C++ overloaded functions</a></H3>
<p>
Please refer to the "SWIG Basics" chapter for more information.
</p>
-<H3><a name="Perl5_nn23"></a>31.4.9 Operators</H3>
+<H3><a name="Perl5_nn23">33.4.9 Operators</a></H3>
<p>
</p>
<ul>
-<li>operator++ </li>
-<li>operator-- </li>
-<li>operator+ </li>
-<li>operator- </li>
-<li>operator* </li>
-<li>operator/ </li>
-<li>operator== </li>
-<li>operator!= </li>
-<li>operator% </li>
-<li>operator> </li>
-<li>operator< </li>
+<li>operator++</li>
+<li>operator--</li>
+<li>operator+</li>
+<li>operator-</li>
+<li>operator*</li>
+<li>operator/</li>
+<li>operator==</li>
+<li>operator!=</li>
+<li>operator%</li>
+<li>operator></li>
+<li>operator<</li>
<li>operator and </li>
<li>operator or </li>
</ul>
-<H3><a name="Perl5_nn24"></a>31.4.10 Modules and packages</H3>
+<H3><a name="Perl5_nn24">33.4.10 Modules and packages</a></H3>
<p>
</pre></div>
-->
-<H2><a name="Perl5_nn25"></a>31.5 Input and output parameters</H2>
+<H2><a name="Perl5_nn25">33.5 Input and output parameters</a></H2>
<p>
<b>Note:</b> The <tt>REFERENCE</tt> feature is only currently supported for numeric types (integers and floating point).
</p>
-<H2><a name="Perl5_nn26"></a>31.6 Exception handling</H2>
+<H2><a name="Perl5_nn26">33.6 Exception handling</a></H2>
<p>
functionality, but it has additional capabilities that make it more powerful.
</p>
-<H2><a name="Perl5_nn27"></a>31.7 Remapping datatypes with typemaps</H2>
+<H2><a name="Perl5_nn27">33.7 Remapping datatypes with typemaps</a></H2>
<p>
C-Perl interface.
</p>
-<H3><a name="Perl5_nn28"></a>31.7.1 A simple typemap example</H3>
+<H3><a name="Perl5_nn28">33.7.1 A simple typemap example</a></H3>
<p>
%module example
%typemap(in) int {
- $1 = (int) SvIV($input);
- printf("Received an integer : %d\n", $1);
+ $1 = (int) SvIV($input);
+ printf("Received an integer : %d\n", $1);
}
...
%inline %{
<div class="targetlang">
<pre>
%typemap(in) int n {
- $1 = (int) SvIV($input);
- printf("n = %d\n",$1);
+ $1 = (int) SvIV($input);
+ printf("n = %d\n",$1);
}
%inline %{
typedef int Integer;
</div>
-<H3><a name="Perl5_nn29"></a>31.7.2 Perl5 typemaps</H3>
+<H3><a name="Perl5_nn29">33.7.2 Perl5 typemaps</a></H3>
<p>
Check value of input parameter.
</div>
-<H3><a name="Perl5_nn30"></a>31.7.3 Typemap variables</H3>
+<H3><a name="Perl5_nn30">33.7.3 Typemap variables</a></H3>
<p>
The Perl name of the wrapper function being created.
</div>
-<H3><a name="Perl5_nn31"></a>31.7.4 Useful functions</H3>
+<H3><a name="Perl5_nn31">33.7.4 Useful functions</a></H3>
<p>
</div>
-<H2><a name="Perl5_nn32"></a>31.8 Typemap Examples</H2>
+<H2><a name="Perl5_nn32">33.8 Typemap Examples</a></H2>
<p>
the SWIG library.
</p>
-<H3><a name="Perl5_nn33"></a>31.8.1 Converting a Perl5 array to a char **</H3>
+<H3><a name="Perl5_nn33">33.8.1 Converting a Perl5 array to a char **</a></H3>
<p>
// This tells SWIG to treat char ** as a special case
%typemap(in) char ** {
- AV *tempav;
- I32 len;
- int i;
- SV **tv;
- if (!SvROK($input))
- croak("Argument $argnum is not a reference.");
- if (SvTYPE(SvRV($input)) != SVt_PVAV)
- croak("Argument $argnum is not an array.");
- tempav = (AV*)SvRV($input);
- len = av_len(tempav);
- $1 = (char **) malloc((len+2)*sizeof(char *));
- for (i = 0; i <= len; i++) {
- tv = av_fetch(tempav, i, 0);
- $1[i] = (char *) SvPV(*tv,PL_na);
- }
- $1[i] = NULL;
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK($input))
+ croak("Argument $argnum is not a reference.");
+ if (SvTYPE(SvRV($input)) != SVt_PVAV)
+ croak("Argument $argnum is not an array.");
+ tempav = (AV*)SvRV($input);
+ len = av_len(tempav);
+ $1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ $1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ $1[i] = NULL;
};
// This cleans up the char ** array after the function call
%typemap(freearg) char ** {
- free($1);
+ free($1);
}
// Creates a new Perl array and places a NULL-terminated char ** into it
%typemap(out) char ** {
- AV *myav;
- SV **svs;
- int i = 0,len = 0;
- /* Figure out how many elements we have */
- while ($1[len])
- len++;
- svs = (SV **) malloc(len*sizeof(SV *));
- for (i = 0; i < len ; i++) {
- svs[i] = sv_newmortal();
- sv_setpv((SV*)svs[i],$1[i]);
- };
- myav = av_make(len,svs);
- free(svs);
- $result = newRV_noinc((SV*)myav);
- sv_2mortal($result);
- argvi++;
+ AV *myav;
+ SV **svs;
+ int i = 0,len = 0;
+ /* Figure out how many elements we have */
+ while ($1[len])
+ len++;
+ svs = (SV **) malloc(len*sizeof(SV *));
+ for (i = 0; i < len ; i++) {
+ svs[i] = sv_newmortal();
+ sv_setpv((SV*)svs[i],$1[i]);
+ };
+ myav = av_make(len,svs);
+ free(svs);
+ $result = newRV_noinc((SV*)myav);
+ sv_2mortal($result);
+ argvi++;
}
// Now a few test functions
</pre></div>
-<H3><a name="Perl5_nn34"></a>31.8.2 Return values</H3>
+<H3><a name="Perl5_nn34">33.8.2 Return values</a></H3>
<p>
<div class="code"><pre>
%typemap(argout) int *OUTPUT {
- if (argvi >= items) {
- EXTEND(sp,1); /* Extend the stack by 1 object */
- }
- $result = sv_newmortal();
- sv_setiv($target,(IV) *($1));
- argvi++;
+ if (argvi >= items) {
+ EXTEND(sp,1); /* Extend the stack by 1 object */
+ }
+ $result = sv_newmortal();
+ sv_setiv($target,(IV) *($1));
+ argvi++;
}
</pre></div>
-<H3><a name="Perl5_nn35"></a>31.8.3 Returning values from arguments</H3>
+<H3><a name="Perl5_nn35">33.8.3 Returning values from arguments</a></H3>
<p>
// an output value.
%typemap(argout) double *OUTPUT {
- $result = sv_newmortal();
- sv_setnv($result, *$input);
- argvi++; /* Increment return count -- important! */
+ $result = sv_newmortal();
+ sv_setnv($result, *$input);
+ argvi++; /* Increment return count -- important! */
}
// We don't care what the input value is. Ignore, but set to a temporary variable
%typemap(in,numinputs=0) double *OUTPUT(double junk) {
- $1 = &junk;
+ $1 = &junk;
}
// Now a function to test it
%{
/* Returns the first two input arguments */
int multout(double a, double b, double *out1, double *out2) {
- *out1 = a;
- *out2 = b;
- return 0;
+ *out1 = a;
+ *out2 = b;
+ return 0;
};
%}
($x,$y) = multout(7,13);
</pre></div>
-<H3><a name="Perl5_nn36"></a>31.8.4 Accessing array structure members</H3>
+<H3><a name="Perl5_nn36">33.8.4 Accessing array structure members</a></H3>
<p>
to copy the converted array into a C data structure.
</p>
-<H3><a name="Perl5_nn37"></a>31.8.5 Turning Perl references into C pointers</H3>
+<H3><a name="Perl5_nn37">33.8.5 Turning Perl references into C pointers</a></H3>
<p>
<div class="code"><pre>
void add(double a, double b, double *c) {
- *c = a + b;
+ *c = a + b;
}
</pre></div>
</pre></div>
-<H3><a name="Perl5_nn38"></a>31.8.6 Pointer handling</H3>
+<H3><a name="Perl5_nn38">33.8.6 Pointer handling</a></H3>
<p>
</pre>
</div>
-<H2><a name="Perl5_nn39"></a>31.9 Proxy classes</H2>
+<H2><a name="Perl5_nn39">33.9 Proxy classes</a></H2>
<p>
details of the proxy interface.
</p>
-<H3><a name="Perl5_nn40"></a>31.9.1 Preliminaries</H3>
+<H3><a name="Perl5_nn40">33.9.1 Preliminaries</a></H3>
<p>
high level wrappers. The wrappers, in turn, interact with the low-level procedural module.
</p>
-<H3><a name="Perl5_nn41"></a>31.9.2 Structure and class wrappers</H3>
+<H3><a name="Perl5_nn41">33.9.2 Structure and class wrappers</a></H3>
<p>
<div class="code"><pre>
%module example
struct Vector {
- Vector(double x, double y, double z);
- ~Vector();
- double x,y,z;
+ Vector(double x, double y, double z);
+ ~Vector();
+ double x,y,z;
};
</pre></div>
my $self = tied(%{$_[0]});
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- examplec::delete_Vector($self));
- delete $OWNER{$self};
+ examplec::delete_Vector($self));
+ delete $OWNER{$self};
+ }
}
sub FETCH {
# Assignment of all members
%$v = ( x=>3,
- y=>9,
- z=>-2);
+ y=>9,
+ z=>-2);
# Reading members
$x = $v->{x};
</pre></div>
-<H3><a name="Perl5_nn42"></a>31.9.3 Object Ownership</H3>
+<H3><a name="Perl5_nn42">33.9.3 Object Ownership</a></H3>
<p>
<div class="code"><pre>
Vector *Vector_get(Vector *v, int index) {
- return &v[i];
+ return &v[i];
}
</pre></div>
<div class="code"><pre>
Vector *new_Vector(double x, double y, double z) {
- Vector *v;
- v = new Vector(x,y,z); // Call C++ constructor
- return v;
+ Vector *v;
+ v = new Vector(x,y,z); // Call C++ constructor
+ return v;
}
</pre></div>
sophisticated languages.
</p>
-<H3><a name="Perl5_nn43"></a>31.9.4 Nested Objects</H3>
+<H3><a name="Perl5_nn43">33.9.4 Nested Objects</a></H3>
<p>
<div class="code"><pre>
struct Particle {
- Vector r;
- Vector v;
- Vector f;
- int type;
+ Vector r;
+ Vector v;
+ Vector f;
+ int type;
}
</pre></div>
package Particle;
...
%BLESSEDMEMBERS = (
- r => `Vector',
- v => `Vector',
- f => `Vector',
+ r => `Vector',
+ v => `Vector',
+ f => `Vector',
);
</pre></div>
%${$p->{v}} = ( x=>0, y=>0, z=>0);
</pre></div>
-<H3><a name="Perl5_nn44"></a>31.9.5 Proxy Functions</H3>
+<H3><a name="Perl5_nn44">33.9.5 Proxy Functions</a></H3>
<p>
identical manner.
</p>
-<H3><a name="Perl5_nn45"></a>31.9.6 Inheritance</H3>
+<H3><a name="Perl5_nn45">33.9.6 Inheritance</a></H3>
<p>
class Shape {
public:
- virtual double area() = 0;
- virtual double perimeter() = 0;
- void set_location(double x, double y);
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
+ void set_location(double x, double y);
};
class Circle : public Shape {
public:
- Circle(double radius);
- ~Circle();
- double area();
- double perimeter();
+ Circle(double radius);
+ ~Circle();
+ double area();
+ double perimeter();
};
class Square : public Shape {
public:
- Square(double size);
- ~Square();
- double area();
- double perimeter();
+ Square(double size);
+ ~Square();
+ double area();
+ double perimeter();
}
</pre></div>
not even sure if it really works).
</p>
-<H3><a name="Perl5_nn46"></a>31.9.7 Modifying the proxy methods</H3>
+<H3><a name="Perl5_nn46">33.9.7 Modifying the proxy methods</a></H3>
<p>
};
</pre></div>
-<H2><a name="Perl5_nn47"></a>31.10 Adding additional Perl code</H2>
+<H2><a name="Perl5_nn47">33.10 Adding additional Perl code</a></H2>
<p>
</pre>
</div>
+<H2><a name="Perl5_directors">33.11 Cross language polymorphism</a></H2>
+
+
+<p>
+Proxy classes provide a more natural, object-oriented way to access
+extension classes. As described above, each proxy instance has an
+associated C++ instance, and method calls to the proxy are passed to the
+C++ instance transparently via C wrapper functions.
+</p>
+
+<p>
+This arrangement is asymmetric in the sense that no corresponding
+mechanism exists to pass method calls down the inheritance chain from
+C++ to Perl. In particular, if a C++ class has been extended in Perl
+(by extending the proxy class), these extensions will not be visible
+from C++ code. Virtual method calls from C++ are thus not able access
+the lowest implementation in the inheritance chain.
+</p>
+
+<p>
+Changes have been made to SWIG to address this problem and
+make the relationship between C++ classes and proxy classes more
+symmetric. To achieve this goal, new classes called directors are
+introduced at the bottom of the C++ inheritance chain. The job of the
+directors is to route method calls correctly, either to C++
+implementations higher in the inheritance chain or to Perl
+implementations lower in the inheritance chain. The upshot is that C++
+classes can be extended in Perl and from C++ these extensions look
+exactly like native C++ classes. Neither C++ code nor Perl code needs
+to know where a particular method is implemented: the combination of
+proxy classes, director classes, and C wrapper functions takes care of
+all the cross-language method routing transparently.
+</p>
+
+<H3><a name="Perl5_nn48">33.11.1 Enabling directors</a></H3>
+
+
+<p>
+The director feature is disabled by default. To use directors you
+must make two changes to the interface file. First, add the "directors"
+option to the %module directive, like this:
+</p>
+
+<div class="code">
+<pre>
+%module(directors="1") modulename
+</pre>
+</div>
+
+<p>
+Without this option no director code will be generated. Second, you
+must use the %feature("director") directive to tell SWIG which classes
+and methods should get directors. The %feature directive can be applied
+globally, to specific classes, and to specific methods, like this:
+</p>
+
+<div class="code">
+<pre>
+// generate directors for all classes that have virtual methods
+%feature("director");
+
+// generate directors for all virtual methods in class Foo
+%feature("director") Foo;
+</pre>
+</div>
+
+<p>
+You can use the %feature("nodirector") directive to turn off
+directors for specific classes or methods. So for example,
+</p>
+
+<div class="code">
+<pre>
+%feature("director") Foo;
+%feature("nodirector") Foo::bar;
+</pre>
+</div>
+
+<p>
+will generate directors for all virtual methods of class Foo except
+bar().
+</p>
+
+<p>
+Directors can also be generated implicitly through inheritance.
+In the following, class Bar will get a director class that handles
+the methods one() and two() (but not three()):
+</p>
+
+<div class="code">
+<pre>
+%feature("director") Foo;
+class Foo {
+public:
+ Foo(int foo);
+ virtual void one();
+ virtual void two();
+};
+
+class Bar: public Foo {
+public:
+ virtual void three();
+};
+</pre>
+</div>
+
+<p>
+then at the Perl side you can define
+</p>
+
+<div class="targetlang">
+<pre>
+use mymodule;
+
+package MyFoo;
+use base 'mymodule::Foo';
+
+sub one {
+ print "one from Perl\n";
+}
+</pre>
+</div>
+
+
+<H3><a name="Perl5_nn49">33.11.2 Director classes</a></H3>
+
+
+
+
+
+<p>
+For each class that has directors enabled, SWIG generates a new class
+that derives from both the class in question and a special
+<tt>Swig::Director</tt> class. These new classes, referred to as director
+classes, can be loosely thought of as the C++ equivalent of the Perl
+proxy classes. The director classes store a pointer to their underlying
+Perl object and handle various issues related to object ownership.
+</p>
+
+<p>
+For simplicity let's ignore the <tt>Swig::Director</tt> class and refer to the
+original C++ class as the director's base class. By default, a director
+class extends all virtual methods in the inheritance chain of its base
+class (see the preceding section for how to modify this behavior).
+Thus all virtual method calls, whether they originate in C++ or in
+Perl via proxy classes, eventually end up in at the implementation in
+the director class. The job of the director methods is to route these
+method calls to the appropriate place in the inheritance chain. By
+"appropriate place" we mean the method that would have been called if
+the C++ base class and its extensions in Perl were seamlessly
+integrated. That seamless integration is exactly what the director
+classes provide, transparently skipping over all the messy extension API
+glue that binds the two languages together.
+</p>
+
+<p>
+In reality, the "appropriate place" is one of only two possibilities:
+C++ or Perl. Once this decision is made, the rest is fairly easy. If
+the correct implementation is in C++, then the lowest implementation of
+the method in the C++ inheritance chain is called explicitly. If the
+correct implementation is in Perl, the Perl API is used to call the
+method of the underlying Perl object (after which the usual virtual
+method resolution in Perl automatically finds the right
+implementation).
+</p>
+
+<p>
+Now how does the director decide which language should handle the method call?
+The basic rule is to handle the method in Perl, unless there's a good
+reason not to. The reason for this is simple: Perl has the most
+"extended" implementation of the method. This assertion is guaranteed,
+since at a minimum the Perl proxy class implements the method. If the
+method in question has been extended by a class derived from the proxy
+class, that extended implementation will execute exactly as it should.
+If not, the proxy class will route the method call into a C wrapper
+function, expecting that the method will be resolved in C++. The wrapper
+will call the virtual method of the C++ instance, and since the director
+extends this the call will end up right back in the director method. Now
+comes the "good reason not to" part. If the director method were to blindly
+call the Perl method again, it would get stuck in an infinite loop. We avoid this
+situation by adding special code to the C wrapper function that tells
+the director method to not do this. The C wrapper function compares the
+pointer to the Perl object that called the wrapper function to the
+pointer stored by the director. If these are the same, then the C
+wrapper function tells the director to resolve the method by calling up
+the C++ inheritance chain, preventing an infinite loop.
+</p>
+
+<p>
+One more point needs to be made about the relationship between director
+classes and proxy classes. When a proxy class instance is created in
+Perl, SWIG creates an instance of the original C++ class.
+This is exactly what happens without directors and
+is true even if directors are enabled for the particular class in
+question. When a class <i>derived</i> from a proxy class is created,
+however, SWIG then creates an instance of the corresponding C++ director
+class. The reason for this difference is that user-defined subclasses
+may override or extend methods of the original class, so the director
+class is needed to route calls to these methods correctly. For
+unmodified proxy classes, all methods are ultimately implemented in C++
+so there is no need for the extra overhead involved with routing the
+calls through Perl.
+</p>
+
+<H3><a name="Perl5_nn50">33.11.3 Ownership and object destruction</a></H3>
+
+
+<p>
+Memory management issues are slightly more complicated with directors
+than for proxy classes alone. Perl instances hold a pointer to the
+associated C++ director object, and the director in turn holds a pointer
+back to a Perl object. By default, proxy classes own their C++
+director object and take care of deleting it when they are garbage
+collected.
+</p>
+
+<p>
+This relationship can be reversed by calling the special
+<tt>DISOWN()</tt> method of the proxy class. After calling this
+method the director
+class increments the reference count of the Perl object. When the
+director class is deleted it decrements the reference count. Assuming no
+outstanding references to the Perl object remain, the Perl object
+will be destroyed at the same time. This is a good thing, since
+directors and proxies refer to each other and so must be created and
+destroyed together. Destroying one without destroying the other will
+likely cause your program to segfault.
+</p>
+
+<p>
+Also note that due to the proxy implementation, the <tt>DESTROY()</tt>
+method on directors can be called for several reasons, many of which
+have little to do with the teardown of an object instance. To help
+disambiguate this, a second argument is added to the <tt>DESTROY()</tt>
+call when a C++ director object is being released. So, to avoid running
+your clean-up code when an object is not really going away, or after it
+has already been reclaimed, it is suggested that custom destructors in
+Perl subclasses looks something like:
+</p>
+
+<div class="targetlang">
+<pre>
+sub DESTROY {
+ my($self, $final) = @_;
+ if($final) {
+ # real teardown code
+ }
+ shift->SUPER::DESTROY(@_);
+}
+</pre>
+</div>
+
+
+<H3><a name="Perl5_nn51">33.11.4 Exception unrolling</a></H3>
+
+
+<p>
+With directors routing method calls to Perl, and proxies routing them
+to C++, the handling of exceptions is an important concern. By default, the
+directors ignore exceptions that occur during method calls that are
+resolved in Perl. To handle such exceptions correctly, it is necessary
+to temporarily translate them into C++ exceptions. This can be done with
+the %feature("director:except") directive. The following code should
+suffice in most cases:
+</p>
+
+<div class="code">
+<pre>
+%feature("director:except") {
+ if ($error != NULL) {
+ throw Swig::DirectorMethodException();
+ }
+}
+</pre>
+</div>
+
+<p>
+This code will check the Perl error state after each method call from
+a director into Perl, and throw a C++ exception if an error occurred.
+This exception can be caught in C++ to implement an error handler.
+</p>
+
+<p>
+It may be the case that a method call originates in Perl, travels up
+to C++ through a proxy class, and then back into Perl via a director
+method. If an exception occurs in Perl at this point, it would be nice
+for that exception to find its way back to the original caller. This can
+be done by combining a normal %exception directive with the
+<tt>director:except</tt> handler shown above. Here is an example of a
+suitable exception handler:
+</p>
+
+<div class="code">
+<pre>
+%exception {
+ try { $action }
+ catch (Swig::DirectorException &e) { SWIG_fail; }
+}
+</pre>
+</div>
+
+<p>
+The class Swig::DirectorException used in this example is actually a
+base class of Swig::DirectorMethodException, so it will trap this
+exception. Because the Perl error state is still set when
+Swig::DirectorMethodException is thrown, Perl will register the
+exception as soon as the C wrapper function returns.
+</p>
+
+<H3><a name="Perl5_nn52">33.11.5 Overhead and code bloat</a></H3>
+
+
+<p>
+Enabling directors for a class will generate a new director method for
+every virtual method in the class' inheritance chain. This alone can
+generate a lot of code bloat for large hierarchies. Method arguments
+that require complex conversions to and from target language types can
+result in large director methods. For this reason it is recommended that
+you selectively enable directors only for specific classes that are
+likely to be extended in Perl and used in C++.
+</p>
+
+<p>
+Compared to classes that do not use directors, the call routing in the
+director methods does add some overhead. In particular, at least one
+dynamic cast and one extra function call occurs per method call from
+Perl. Relative to the speed of Perl execution this is probably
+completely negligible. For worst case routing, a method call that
+ultimately resolves in C++ may take one extra detour through Perl in
+order to ensure that the method does not have an extended Perl
+implementation. This could result in a noticeable overhead in some cases.
+</p>
+
+<p>
+Although directors make it natural to mix native C++ objects with Perl
+objects (as director objects) via a common base class pointer, one
+should be aware of the obvious fact that method calls to Perl objects
+will be much slower than calls to C++ objects. This situation can be
+optimized by selectively enabling director methods (using the %feature
+directive) for only those methods that are likely to be extended in
+Perl.
+</p>
+
+<H3><a name="Perl5_nn53">33.11.6 Typemaps</a></H3>
+
+
+<p>
+Typemaps for input and output of most of the basic types from director
+classes have been written. These are roughly the reverse of the usual
+input and output typemaps used by the wrapper code. The typemap
+operation names are 'directorin', 'directorout', and 'directorargout'.
+The director code does not currently use any of the other kinds of typemaps.
+It is not clear at this point which kinds are appropriate and
+need to be supported.
+</p>
+
+
</body>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<!-- Hand crafted HTML -->
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and PHP</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Php"></a>32 SWIG and PHP</H1>
+<H1><a name="Php">34 SWIG and PHP</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#Php_nn2_5">Pointers and References</a>
<li><a href="#Php_nn2_6">Structures and C++ classes</a>
<ul>
-<li><a href="#Php_nn2_6_1">Using <tt>-noproxy</tt></a>
+<li><a href="#Php_nn2_6_1">Using -noproxy</a>
<li><a href="#Php_nn2_6_2">Constructors and Destructors</a>
<li><a href="#Php_nn2_6_3">Static Member Variables</a>
<li><a href="#Php_nn2_6_4">Static Member Functions</a>
+<li><a href="#Php_nn2_6_5">Specifying Implemented Interfaces</a>
</ul>
<li><a href="#Php_nn2_7">PHP Pragmas, Startup and Shutdown code</a>
</ul>
available.
</p>
-<H2><a name="Php_nn1"></a>32.1 Generating PHP Extensions</H2>
+<H2><a name="Php_nn1">34.1 Generating PHP Extensions</a></H2>
<p>
<p>
The usual (and recommended) way is to build the extension as a separate
dynamically loaded module (which is supported by all modern operating
-systems). You can then specify that this be loaded
-automatically in <tt>php.ini</tt> or load it explicitly for any script which
-needs it.
+systems).
</p>
<p>
this approach, or provide explicit support for it.
</p>
-<H3><a name="Php_nn1_1"></a>32.1.1 Building a loadable extension</H3>
+<H3><a name="Php_nn1_1">34.1.1 Building a loadable extension</a></H3>
<p>
</p>
<div class="code"><pre>
- gcc `php-config --includes` -fpic -c example_wrap.c
- gcc -shared example_wrap.o -o example.so
+ gcc `php-config --includes` -fpic -c example_wrap.c example.c
+ gcc -shared example_wrap.o example.o -o example.so
</pre></div>
-<H3><a name="Php_nn1_3"></a>32.1.2 Using PHP Extensions</H3>
+<H3><a name="Php_nn1_3">34.1.2 Using PHP Extensions</a></H3>
<p>
-To test the extension from a PHP script, you need to load it first. You
-can load it for every script by adding this line to the <tt>[PHP]</tt> section of
+To test the extension from a PHP script, you first need to tell PHP to
+load it. To do this, add a line like this to the <tt>[PHP]</tt> section of
<tt>php.ini</tt>:
</p>
<div class="code"><pre>
- extension=/path/to/modulename.so
+ extension=/path/to/modulename.so
</pre></div>
<p>
-Alternatively, you can load it explicitly only for scripts which need it
-by adding this line to the start of each such PHP script::
+If the module is in PHP's default extension directory, you can omit the path.
+</p>
+
+<p>
+For some SAPIs (for example, the CLI SAPI) you can instead use the
+<a href="http://php.net/manual/en/function.dl.php">dl() function</a> to load
+an extension at run time, by adding a like like this to the start of each
+PHP script which uses your extension:
</p>
<div class="code"><pre>
- dl("/path/to/modulename.so"); // Load the module
+ dl("/path/to/modulename.so"); // Load the module
</pre></div>
<p>
-SWIG also generates a php module, which
-attempts to do the <tt>dl()</tt> call for you:
+But note that this doesn't work when running PHP through a webserver in PHP5.3
+and later - you'll need to use <tt>extension</tt> in <tt>php.ini</tt> as
+described above.
+</p>
+
+<p>
+The PHP module which SWIG generates will also attempt to do the <tt>dl()</tt>
+call for you if the extension isn't already loaded:
</p>
<div class="code"><pre>
- include("example.php");
+ include("example.php");
</pre></div>
-<H2><a name="Php_nn2"></a>32.2 Basic PHP interface</H2>
+<p>
+This PHP module also defines the PHP classes for the wrapped API, so you'll
+almost certainly want to include it anyway.
+</p>
+
+<H2><a name="Php_nn2">34.2 Basic PHP interface</a></H2>
<p>
SWIG doesn't have support for the namespace feature added in PHP 5.3.
</p>
-<H3><a name="Php_nn2_1"></a>32.2.1 Constants</H3>
+<H3><a name="Php_nn2_1">34.2.1 Constants</a></H3>
<p>
<p>
There's one peculiarity of how constants work in PHP which it is useful
to note (this is not specific to SWIG though) - if you try to use an undeclared
-constant, PHP will issue a warning and then expand the constant to a string
-version of the constant's name. The warning will often be missed though as
-if you're using PHP in a webserver, it will probably end up in error.log or
+constant, PHP will emit a notice and then expand the constant to a string
+version of the constant's name. Unfortunately it is easy to miss the notice
+if you're using PHP in a webserver, as it will probably end up in error.log or
similar.
</p>
<div class="code"><pre>
%module example
-#define EASY_TO_MISPELL 0
+#define EASY_TO_MISPELL 0
</pre>
</div>
include("example.php");
if(EASY_TO_MISPEL) {
- ....
+ ...
} else {
- ....
+ ...
}
</pre>
would be treated as false!
</p>
-<H3><a name="Php_nn2_2"></a>32.2.2 Global Variables</H3>
+<H3><a name="Php_nn2_2">34.2.2 Global Variables</a></H3>
<p>
<div class="code"><pre>
include("example.php");
print seki_get();
-seki_set( seki_get() * 2); # The C variable is now 4.
+seki_set( seki_get() * 2); # The C variable is now 4.
print seki_get();
</pre></div>
At this time SWIG does not support custom accessor methods.
</p>
-<H3><a name="Php_nn2_3"></a>32.2.3 Functions</H3>
+<H3><a name="Php_nn2_3">34.2.3 Functions</a></H3>
<p>
include("example.php");
$a = foo(2);
$b = bar(3.5, -1.5);
-$c = bar(3.5); # Use default argument for 2nd parameter
+$c = bar(3.5); # Use default argument for 2nd parameter
</pre></div>
-->
-<H3><a name="Php_nn2_4"></a>32.2.4 Overloading</H3>
+<H3><a name="Php_nn2_4">34.2.4 Overloading</a></H3>
<p>
</p>
-->
-<H3><a name="Php_nn2_5"></a>32.2.5 Pointers and References</H3>
+<H3><a name="Php_nn2_5">34.2.5 Pointers and References</a></H3>
<p>
Because PHP has a native concept of reference, it may seem more natural
to the PHP developer to use references to pass pointers. To enable
this, one needs to include <b>phppointers.i</b> which defines the
-named typemap REFERENCE.
+named typemap REF.
+</p>
+
+<p>
+Prior to SWIG 3.0, the REF typemaps relied on PHP's call-time
+pass-by-reference, which was deprecated in PHP 5.3 and removed in PHP 5.4.
+So if you use these REF typemaps, you should ensure that SWIG≥3.0 is
+used to generate wrappers from your interface file.
</p>
<p>
-However, this relies on call-time pass-by-reference, which has been
-deprecated in PHP for some time, and was finally <b>removed in PHP 5.4</b>.
-So you should avoid creating new wrappers which rely on this approach.
+In case you write your own typemaps, SWIG supports an attribute called
+<tt>byref</tt>: if you set that, then SWIG will make sure that the generated
+wrapper function will want the input parameter as a reference.
</p>
<div class="code"><pre>
$in1 = 3;
$in2 = 5;
$result = 0;
-add(&$in1,&$in2,&$result);
+add($in1,$in2,$result);
echo "The sum $in1 + $in2 = $result\n";
?>
variable, or assigning <tt>NULL</tt> to a variable.
</p>
-<H3><a name="Php_nn2_6"></a>32.2.6 Structures and C++ classes</H3>
+<H3><a name="Php_nn2_6">34.2.6 Structures and C++ classes</a></H3>
<p>
class Vector {
public:
- double x,y,z;
- Vector();
- ~Vector();
- double magnitude();
+ double x,y,z;
+ Vector();
+ ~Vector();
+ double magnitude();
};
struct Complex {
Member variables and methods are accessed using the <tt>-></tt> operator.
</p>
-<H4><a name="Php_nn2_6_1"></a>32.2.6.1 Using <tt>-noproxy</tt></H4>
+<H4><a name="Php_nn2_6_1">34.2.6.1 Using -noproxy</a></H4>
<p>
Complex_im_get($obj);
</pre></div>
-<H4><a name="Php_nn2_6_2"></a>32.2.6.2 Constructors and Destructors</H4>
+<H4><a name="Php_nn2_6_2">34.2.6.2 Constructors and Destructors</a></H4>
<p>
<tt>unset($v)</tt>
</p>
-<H4><a name="Php_nn2_6_3"></a>32.2.6.3 Static Member Variables</H4>
+<H4><a name="Php_nn2_6_3">34.2.6.3 Static Member Variables</a></H4>
<p>
%module example
class Ko {
- static int threats;
+ static int threats;
};
</pre></div>
echo "There have now been " . Ko::threats() . " threats\n";
</pre></div>
-<H4><a name="Php_nn2_6_4"></a>32.2.6.4 Static Member Functions</H4>
+<H4><a name="Php_nn2_6_4">34.2.6.4 Static Member Functions</a></H4>
<p>
</pre></div>
-<H3><a name="Php_nn2_7"></a>32.2.7 PHP Pragmas, Startup and Shutdown code</H3>
+<H4><a name="Php_nn2_6_5">34.2.6.5 Specifying Implemented Interfaces</a></H4>
+
+
+<p>
+PHP supports the concept of abstract interfaces which a class can implement.
+Since SWIG 3.0.3, you can tell SWIG that a wrapped class (for example
+<code>MyIterator</code>) implements the <code>Iterator</code> interface like
+so:
+</p>
+
+<div class="code"><pre>
+%typemap("phpinterfaces") MyIterator "Iterator";
+</pre></div>
+
+<p>
+If there are multiple interfaces, just list them separated by commas.
+</p>
+
+<H3><a name="Php_nn2_7">34.2.7 PHP Pragmas, Startup and Shutdown code</a></H3>
<p>
into the request init (PHP_RINIT_FUNCTION) and request shutdown (PHP_RSHUTDOWN_FUNCTION) code respectively.
</p>
-<H2><a name="Php_nn3"></a>32.3 Cross language polymorphism</H2>
+<H2><a name="Php_nn3">34.3 Cross language polymorphism</a></H2>
<p>
transparently.
</p>
-<H3><a name="Php_nn3_1"></a>32.3.1 Enabling directors</H3>
+<H3><a name="Php_nn3_1">34.3.1 Enabling directors</a></H3>
<p>
</div>
-<H3><a name="Php_nn3_2"></a>32.3.2 Director classes</H3>
+<H3><a name="Php_nn3_2">34.3.2 Director classes</a></H3>
calls through PHP.
</p>
-<H3><a name="Php_nn3_3"></a>32.3.3 Ownership and object destruction</H3>
+<H3><a name="Php_nn3_3">34.3.3 Ownership and object destruction</a></H3>
<p>
deleting all the Foo pointers it contains at some point.
</p>
-<H3><a name="Php_nn3_4"></a>32.3.4 Exception unrolling</H3>
+<H3><a name="Php_nn3_4">34.3.4 Exception unrolling</a></H3>
<p>
as soon as the C wrapper function returns.
</p>
-<H3><a name="Php_nn3_5"></a>32.3.5 Overhead and code bloat</H3>
+<H3><a name="Php_nn3_5">34.3.5 Overhead and code bloat</a></H3>
<p>
directive) for only those methods that are likely to be extended in PHP.
</p>
-<H3><a name="Php_nn3_6"></a>32.3.6 Typemaps</H3>
+<H3><a name="Php_nn3_6">34.3.6 Typemaps</a></H3>
<p>
</p>
-<H3><a name="Php_nn3_7"></a>32.3.7 Miscellaneous</H3>
+<H3><a name="Php_nn3_7">34.3.7 Miscellaneous</a></H3>
<p> Director typemaps for STL classes are mostly in place, and hence you
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Pike</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Pike"></a>33 SWIG and Pike</H1>
+<H1><a name="Pike">35 SWIG and Pike</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
chapter.<br>
</p>
-<H2><a name="Pike_nn2"></a>33.1 Preliminaries</H2>
+<H2><a name="Pike_nn2">35.1 Preliminaries</a></H2>
-<H3><a name="Pike_nn3"></a>33.1.1 Running SWIG</H3>
+<H3><a name="Pike_nn3">35.1.1 Running SWIG</a></H3>
<p>
<div class="code">
<pre>$ <b>swig -pike -o pseudonym.c example.i</b><br></pre>
</div>
-<H3><a name="Pike_nn4"></a>33.1.2 Getting the right header files</H3>
+<H3><a name="Pike_nn4">35.1.2 Getting the right header files</a></H3>
<p>
and so on.
</p>
-<H3><a name="Pike_nn5"></a>33.1.3 Using your module</H3>
+<H3><a name="Pike_nn5">35.1.3 Using your module</a></H3>
<p>
(1) Result: 24
</pre></div>
-<H2><a name="Pike_nn6"></a>33.2 Basic C/C++ Mapping</H2>
+<H2><a name="Pike_nn6">35.2 Basic C/C++ Mapping</a></H2>
-<H3><a name="Pike_nn7"></a>33.2.1 Modules</H3>
+<H3><a name="Pike_nn7">35.2.1 Modules</a></H3>
<p>
significance.
</p>
-<H3><a name="Pike_nn8"></a>33.2.2 Functions</H3>
+<H3><a name="Pike_nn8">35.2.2 Functions</a></H3>
<p>
(1) Result: 24
</pre></div>
-<H3><a name="Pike_nn9"></a>33.2.3 Global variables</H3>
+<H3><a name="Pike_nn9">35.2.3 Global variables</a></H3>
<p>
(3) Result: 3.141590
</pre></div>
-<H3><a name="Pike_nn10"></a>33.2.4 Constants and enumerated types</H3>
+<H3><a name="Pike_nn10">35.2.4 Constants and enumerated types</a></H3>
<p>
not as Pike enums.
</p>
-<H3><a name="Pike_nn11"></a>33.2.5 Constructors and Destructors</H3>
+<H3><a name="Pike_nn11">35.2.5 Constructors and Destructors</a></H3>
<p>
wrapped as <tt>destroy()</tt> methods, for Pike classes.
</p>
-<H3><a name="Pike_nn12"></a>33.2.6 Static Members</H3>
+<H3><a name="Pike_nn12">35.2.6 Static Members</a></H3>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Preface</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Preface"></a>1 Preface</H1>
+<H1><a name="Preface">1 Preface</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
-<H2><a name="Preface_nn2"></a>1.1 Introduction</H2>
+<H2><a name="Preface_nn2">1.1 Introduction</a></H2>
<p>
variety of applications--in fact almost anything where C/C++ programming
is involved.
-<H2><a name="Preface_nn4"></a>1.2 SWIG Versions</H2>
+<H2><a name="Preface_nn4">1.2 SWIG Versions</a></H2>
<p>
license changes and this gave rise to version 2.0.0 in 2010.
</p>
-<H2><a name="Preface_license"></a>1.3 SWIG License</H2>
+<H2><a name="Preface_license">1.3 SWIG License</a></H2>
<p>
source was placed under the GNU General Public License version 3.
</p>
-<H2><a name="Preface_nn5"></a>1.4 SWIG resources</H2>
+<H2><a name="Preface_nn5">1.4 SWIG resources</a></H2>
<p>
-<H2><a name="Preface_nn6"></a>1.5 Prerequisites</H2>
+<H2><a name="Preface_nn6">1.5 Prerequisites</a></H2>
<p>
of the gory details, you will almost certainly want to consult a good C++ reference. If you don't program
in C++, you may just want to skip those parts of the manual.
-<H2><a name="Preface_nn7"></a>1.6 Organization of this manual</H2>
+<H2><a name="Preface_nn7">1.6 Organization of this manual</a></H2>
<p>
to know.
</p>
-<H2><a name="Preface_nn8"></a>1.7 How to avoid reading the manual</H2>
+<H2><a name="Preface_nn8">1.7 How to avoid reading the manual</a></H2>
<p>
examples that illustrate different topics.
</p>
-<H2><a name="Preface_nn9"></a>1.8 Backwards compatibility</H2>
+<H2><a name="Preface_nn9">1.8 Backwards compatibility</a></H2>
<p>
wrapper file. The SWIG preprocessor has defined SWIG_VERSION since SWIG-1.3.11.
</p>
-<H2><a name="Preface_release_notes"></a>1.9 Release notes</H2>
+<H2><a name="Preface_release_notes">1.9 Release notes</a></H2>
<p>
detailed release notes for previous releases and summary release notes from SWIG-1.3.22 onwards.
</p>
-<H2><a name="Preface_nn10"></a>1.10 Credits</H2>
+<H2><a name="Preface_nn10">1.10 Credits</a></H2>
<p>
are mentioned either in the COPYRIGHT file or CHANGES files shipped with SWIG or in submitted bugs.
</p>
-<H2><a name="Preface_nn11"></a>1.11 Bug reports</H2>
+<H2><a name="Preface_nn11">1.11 Bug reports</a></H2>
<p>
can only fix bugs if we know about them.
</p>
-<H2><a name="Preface_installation"></a>1.12 Installation</H2>
+<H2><a name="Preface_installation">1.12 Installation</a></H2>
-<H3><a name="Preface_windows_installation"></a>1.12.1 Windows installation</H3>
+<H3><a name="Preface_windows_installation">1.12.1 Windows installation</a></H3>
<p>
-Please see the dedicated <a href="Windows.html">Windows chapter</a> for instructions on installing
+Please see the dedicated <a href="Windows.html#Windows">Windows chapter</a> for instructions on installing
SWIG on Windows and running the examples. The Windows distribution is
called swigwin and includes a prebuilt SWIG executable, swig.exe, included in
the top level directory. Otherwise it is exactly the same as
the main SWIG distribution. There is no need to download anything else.
</p>
-<H3><a name="Preface_unix_installation"></a>1.12.2 Unix installation</H3>
+<H3><a name="Preface_unix_installation">1.12.2 Unix installation</a></H3>
<p>
+These installation instructions are for using the distributed tarball,
+for example, <tt>swig-3.0.8.tar.gz</tt>.
+If you wish to build and install from source on Github, extra steps are required.
+Please see the <a href="http://swig.org/svn.html">Bleeding Edge</a> page on the SWIG website.
+</p>
+
+<p>
You must use <a href="http://www.gnu.org/software/make/">GNU make</a> to build and install SWIG.
</p>
SWIG used to include a set of runtime libraries for some languages for working
with multiple modules. These are no longer built during the installation stage.
However, users can build them just like any wrapper module as described in
-the <a href="Modules.html">Modules chapter</a>.
+the <a href="Modules.html#Modules">Modules chapter</a>.
The CHANGES file shipped with SWIG in the top level directory
also lists some examples which build the runtime library.
</p>
</li>
</ul>
-<H3><a name="Preface_osx_installation"></a>1.12.3 Macintosh OS X installation</H3>
+<H3><a name="Preface_osx_installation">1.12.3 Macintosh OS X installation</a></H3>
<p>
technique for building larger extension modules. Instead, you should utilize
Darwin's two-level namespaces. Some details about this can be found here
-<a href="http://developer.apple.com/documentation/ReleaseNotes/DeveloperTools/TwoLevelNamespaces.html">http://developer.apple.com/documentation/ReleaseNotes/DeveloperTools/TwoLevelNamespaces.html</a>.
+<a href="https://developer.apple.com/library/mac/documentation/Porting/Conceptual/PortingUnix/compiling/compiling.html#//apple_ref/doc/uid/TP40002850-BCIHJBBF">Understanding Two-Level Namespaces</a>.
</p>
Needless to say, you might have to experiment a bit to get things working at first.
</p>
-<H3><a name="Preface_testing"></a>1.12.4 Testing</H3>
+<H3><a name="Preface_testing">1.12.4 Testing</a></H3>
<p>
might take more than an hour to run the test-suite.
</p>
-<H3><a name="Preface_examples"></a>1.12.5 Examples</H3>
+<H3><a name="Preface_examples">1.12.5 Examples</a></H3>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG Preprocessor</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Preprocessor"></a>7 Preprocessing</H1>
+<H1><a name="Preprocessor">8 Preprocessing</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
chapter describes some of these modifications.
</p>
-<H2><a name="Preprocessor_nn2"></a>7.1 File inclusion</H2>
+<H2><a name="Preprocessor_nn2">8.1 File inclusion</a></H2>
<p>
is that you often don't want SWIG to try and wrap everything included
in standard header system headers and auxiliary files.
-<H2><a name="Preprocessor_nn3"></a>7.2 File imports</H2>
+<H2><a name="Preprocessor_nn3">8.2 File imports</a></H2>
<p>
as imports. This might be useful if you want to extract type definitions from system
header files without generating any wrappers.
-<H2><a name="Preprocessor_condition_compilation"></a>7.3 Conditional Compilation</H2>
+<H2><a name="Preprocessor_condition_compilation">8.3 Conditional Compilation</a></H2>
<p>
SWIGCSHARP Defined when using C#
SWIGGUILE Defined when using Guile
SWIGJAVA Defined when using Java
+SWIGJAVASCRIPT Defined when using Javascript
+SWIG_JAVASCRIPT_JSC Defined when using Javascript for JavascriptCore
+SWIG_JAVASCRIPT_V8 Defined when using Javascript for v8 or node.js
SWIGLUA Defined when using Lua
SWIGMODULA3 Defined when using Modula-3
-SWIGMZSCHEME Defined when using Mzscheme
+SWIGMZSCHEME Defined when using Mzscheme
SWIGOCAML Defined when using Ocaml
SWIGOCTAVE Defined when using Octave
SWIGPERL Defined when using Perl
SWIGPYTHON Defined when using Python
SWIGR Defined when using R
SWIGRUBY Defined when using Ruby
+SWIGSCILAB Defined when using Scilab
SWIGSEXP Defined when using S-expressions
SWIGTCL Defined when using Tcl
SWIGXML Defined when using XML
within the SWIG compiler).
</p>
-<H2><a name="Preprocessor_nn5"></a>7.4 Macro Expansion</H2>
+<H2><a name="Preprocessor_nn5">8.4 Macro Expansion</a></H2>
<p>
</li>
</ul>
-<H2><a name="Preprocessor_nn6"></a>7.5 SWIG Macros</H2>
+<H2><a name="Preprocessor_nn6">8.5 SWIG Macros</a></H2>
<p>
support).
</p>
-<H2><a name="Preprocessor_nn7"></a>7.6 C99 and GNU Extensions</H2>
+<H2><a name="Preprocessor_nn7">8.6 C99 and GNU Extensions</a></H2>
<p>
SWIG directives and are provided to make SWIG more compatible with C99 code.
</p>
-<H2><a name="Preprocessor_delimiters"></a>7.7 Preprocessing and delimiters</H2>
+<H2><a name="Preprocessor_delimiters">8.7 Preprocessing and delimiters</a></H2>
<p>
The preprocessor handles { }, " " and %{ %} delimiters differently.
</p>
-<H3><a name="Preprocessor_nn8"></a>7.7.1 Preprocessing and %{ ... %} & " ... " delimiters</H3>
+<H3><a name="Preprocessor_nn8">8.7.1 Preprocessing and %{ ... %} & " ... " delimiters</a></H3>
<p>
modification to the output (including all preprocessor directives).
</p>
-<H3><a name="Preprocessor_nn9"></a>7.7.2 Preprocessing and { ... } delimiters</H3>
+<H3><a name="Preprocessor_nn9">8.7.2 Preprocessing and { ... } delimiters</a></H3>
<p>
SWIG will strip the extra <tt>%</tt> and leave the preprocessor directive in the code.
</p>
-<H2><a name="Preprocessor_typemap_delimiters"></a>7.8 Preprocessor and Typemaps</H2>
+<H2><a name="Preprocessor_typemap_delimiters">8.8 Preprocessor and Typemaps</a></H2>
<p>
</div>
-<H2><a name="Preprocessor_nn10"></a>7.9 Viewing preprocessor output</H2>
+<H2><a name="Preprocessor_nn10">8.9 Viewing preprocessor output</a></H2>
<p>
This might be useful as an aid to debugging and viewing the results of macro expansions.
</p>
-<H2><a name="Preprocessor_warning_error"></a>7.10 The #error and #warning directives</H2>
+<H2><a name="Preprocessor_warning_error">8.10 The #error and #warning directives</a></H2>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Python</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Python"></a>34 SWIG and Python</H1>
+<H1><a name="Python">36 SWIG and Python</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#Python_nn25">C++ namespaces</a>
<li><a href="#Python_nn26">C++ templates</a>
<li><a href="#Python_nn27">C++ Smart Pointers</a>
+<ul>
+<li><a href="#Python_smart_pointers_shared_ptr">The shared_ptr Smart Pointer</a>
+<li><a href="#Python_smart_pointers_generic">Generic Smart Pointers</a>
+</ul>
<li><a href="#Python_nn27a">C++ reference counted objects</a>
</ul>
<li><a href="#Python_nn28">Further details on the Python class interface</a>
<li><a href="#Python_nn47">Simple pointers</a>
<li><a href="#Python_nn48">Unbounded C Arrays</a>
<li><a href="#Python_nn49">String handling</a>
+<li><a href="#Python_default_args">Default arguments</a>
</ul>
<li><a href="#Python_nn53">Typemaps</a>
<ul>
<li><a href="#Python_nn71">%feature("docstring")</a>
</ul>
<li><a href="#Python_nn72">Python Packages</a>
+<ul>
+<li><a href="#Python_modulepackage">Setting the Python package</a>
+<li><a href="#Python_absrelimports">Absolute and relative imports</a>
+<li><a href="#Python_absimport">Enforcing absolute import semantics</a>
+<li><a href="#Python_importfrominit">Importing from __init__.py</a>
+<li><a href="#Python_implicit_namespace_packages">Implicit Namespace Packages</a>
+<li><a href="#Python_package_search">Searching for the wrapper module</a>
+<ul>
+<li><a href="#Python_package_search_both_package_modules">Both modules in the same package</a>
+<li><a href="#Python_package_search_wrapper_split">Split modules</a>
+<li><a href="#Python_package_search_both_global_modules">Both modules are global</a>
+<li><a href="#Python_package_search_static">Statically linked C modules</a>
+</ul>
+</ul>
<li><a href="#Python_python3support">Python 3 Support</a>
<ul>
<li><a href="#Python_nn74">Function annotation</a>
<li><a href="#Python_nn75">Buffer interface</a>
<li><a href="#Python_nn76">Abstract base classes</a>
+<li><a href="#Python_nn77">Byte string output conversion</a>
+<li><a href="#Python_2_unicode">Python 2 Unicode</a>
</ul>
</ul>
</div>
Basics</a>" chapter.
</p>
-<H2><a name="Python_nn2"></a>34.1 Overview</H2>
+<H2><a name="Python_nn2">36.1 Overview</a></H2>
<p>
details.
</p>
-<H2><a name="Python_nn3"></a>34.2 Preliminaries</H2>
+<H2><a name="Python_nn3">36.2 Preliminaries</a></H2>
-<H3><a name="Python_nn4"></a>34.2.1 Running SWIG</H3>
+<H3><a name="Python_nn4">36.2.1 Running SWIG</a></H3>
<p>
</div>
<p>
-The <tt> #define SWIG_FILE_WITH_INIT </tt> line inserts a macro that specifies that the
+The <tt>#define SWIG_FILE_WITH_INIT</tt> line inserts a macro that specifies that the
resulting C file should be built as a python extension, inserting the module
<tt>init</tt> code. This <tt>.i</tt> file wraps the following simple C file:
</p>
how you might go about compiling and using the generated files.
</p>
-<H3><a name="Python_nn6"></a>34.2.2 Using distutils</H3>
+<H3><a name="Python_nn6">36.2.2 Using distutils</a></H3>
<p>
The preferred approach to building an extension module for python is to compile it with
distutils, which comes with all recent versions of python
-(<a href="http://docs.python.org/distutils/index.html">Distutils Docs</a>).
+(<a href="https://docs.python.org/library/distutils.html">Distutils Docs</a>).
</p>
<p>
can even build extensions to the standard Windows Python using MingGW)
</p>
-<H3><a name="Python_nn7"></a>34.2.3 Hand compiling a dynamic module</H3>
+<H3><a name="Python_nn7">36.2.3 Hand compiling a dynamic module</a></H3>
<p>
name of the corresponding object file should be
"<tt>_example.so</tt>" or "<tt>_examplemodule.so</tt>".
The name of the module is specified using the <tt>%module</tt> directive or the
-<tt> -module</tt> command line option.
+<tt>-module</tt> command line option.
</p>
<p>
</p>
-<H3><a name="Python_nn8"></a>34.2.4 Static linking</H3>
+<H3><a name="Python_nn8">36.2.4 Static linking</a></H3>
<p>
</p>
<div class="shell"><pre>
-$ swig -python example.i
+$ swig -python -lembed.i example.i
$ gcc example.c example_wrap.c \
-Xlinker -export-dynamic \
- -DHAVE_CONFIG_H -I/usr/local/include/python2.1 \
- -I/usr/local/lib/python2.1/config \
- -L/usr/local/lib/python2.1/config -lpython2.1 -lm -ldl \
- -o mypython
-
+ -DHAVE_CONFIG_H -I/usr/include/python2.7 \
+ -I/usr/lib/python2.7/config-x86_64-linux-gnu \
+ -I/usr/lib/python2.7/config \
+ -L/usr/lib/python2.7/config -lpython2.7 -lm -ldl \
+ -o mypython
</pre></div>
<p>
You will need to supply the same libraries that were used to build Python the first
<p>
<b>Compatibility note:</b> The <tt>embed.i</tt> library file is
-deprecated and has not been maintained for several years. Even though it
-appears to "work" with Python 2.1, no future support is guaranteed.
+deprecated and has not been actively maintained for many years. Even though it
+appears to "work" with Python 2.7, no future support is guaranteed.
If using static linking, you might want to rely on a different approach
(perhaps using distutils).
</p>
-<H3><a name="Python_nn9"></a>34.2.5 Using your module</H3>
+<H3><a name="Python_nn9">36.2.5 Using your module</a></H3>
<p>
read the man pages).
</p>
-<H3><a name="Python_nn10"></a>34.2.6 Compilation of C++ extensions</H3>
+<H3><a name="Python_nn10">36.2.6 Compilation of C++ extensions</a></H3>
<p>
might want to investigate using a more formal standard such as COM.
</p>
-<H3><a name="Python_nn11"></a>34.2.7 Compiling for 64-bit platforms</H3>
+<H3><a name="Python_nn11">36.2.7 Compiling for 64-bit platforms</a></H3>
<p>
extension.
</p>
-<H3><a name="Python_nn12"></a>34.2.8 Building Python Extensions under Windows</H3>
+<H3><a name="Python_nn12">36.2.8 Building Python Extensions under Windows</a></H3>
<p>
the process used with Unix. Using the distutils, it is essentially
identical. If you have the same version of the MS compiler that Python
was built with (the python2.4 and python2.5 distributed by python.org
-are built with Visual Studio 2003), the standard <tt> python setup.py
-build </tt> should just work.
+are built with Visual Studio 2003), the standard <tt>python setup.py
+build</tt> should just work.
</p>
<p>
</p>
-<H2><a name="Python_nn13"></a>34.3 A tour of basic C/C++ wrapping</H2>
+<H2><a name="Python_nn13">36.3 A tour of basic C/C++ wrapping</a></H2>
<p>
This section briefly covers the essential aspects of this wrapping.
</p>
-<H3><a name="Python_nn14"></a>34.3.1 Modules</H3>
+<H3><a name="Python_nn14">36.3.1 Modules</a></H3>
<p>
Python command or standard module name.
</p>
-<H3><a name="Python_nn15"></a>34.3.2 Functions</H3>
+<H3><a name="Python_nn15">36.3.2 Functions</a></H3>
<p>
>>>
</pre></div>
-<H3><a name="Python_nn16"></a>34.3.3 Global variables</H3>
+<H3><a name="Python_nn16">36.3.3 Global variables</a></H3>
<p>
if there are no global variables in a module.
</p>
-<H3><a name="Python_nn17"></a>34.3.4 Constants and enums</H3>
+<H3><a name="Python_nn17">36.3.4 Constants and enums</a></H3>
<p>
generate code that prevents this. You will just have to be careful.
</p>
-<H3><a name="Python_nn18"></a>34.3.5 Pointers</H3>
+<H3><a name="Python_nn18">36.3.5 Pointers</a></H3>
<p>
<div class="targetlang">
<pre>
>>> import example
->>> f = example.fopen("junk","w")
+>>> f = example.fopen("junk", "w")
>>> example.fputs("Hello World\n", f)
>>> example.fclose(f)
</pre>
<tt>None</tt> if the conversion can't be performed.
</p>
-<H3><a name="Python_nn19"></a>34.3.6 Structures</H3>
+<H3><a name="Python_nn19">36.3.6 Structures</a></H3>
<p>
<div class="code"><pre>
struct Vector {
- double x,y,z;
+ double x,y,z;
};
</pre></div>
</pre>
</div>
-<H3><a name="Python_nn20"></a>34.3.7 C++ classes</H3>
+<H3><a name="Python_nn20">36.3.7 C++ classes</a></H3>
<p>
</pre>
</div>
-<H3><a name="Python_nn21"></a>34.3.8 C++ inheritance</H3>
+<H3><a name="Python_nn21">36.3.8 C++ inheritance</a></H3>
<p>
It is safe to use multiple inheritance with SWIG.
</p>
-<H3><a name="Python_nn22"></a>34.3.9 Pointers, references, values, and arrays</H3>
+<H3><a name="Python_nn22">36.3.9 Pointers, references, values, and arrays</a></H3>
<p>
allocation/deallocation process.
</p>
-<H3><a name="Python_nn23"></a>34.3.10 C++ overloaded functions</H3>
+<H3><a name="Python_nn23">36.3.10 C++ overloaded functions</a></H3>
<p>
Please refer to the "SWIG and C++" chapter for more information about overloading.
</p>
-<H3><a name="Python_nn24"></a>34.3.11 C++ operators</H3>
+<H3><a name="Python_nn24">36.3.11 C++ operators</a></H3>
<p>
overloaded assignment operators don't map to Python semantics and will be ignored.
</p>
-<H3><a name="Python_nn25"></a>34.3.12 C++ namespaces</H3>
+<H3><a name="Python_nn25">36.3.12 C++ namespaces</a></H3>
<p>
identical symbol names, well, then you get what you deserve.
</p>
-<H3><a name="Python_nn26"></a>34.3.13 C++ templates</H3>
+<H3><a name="Python_nn26">36.3.13 C++ templates</a></H3>
<p>
examples will appear later.
</p>
-<H3><a name="Python_nn27"></a>34.3.14 C++ Smart Pointers</H3>
+<H3><a name="Python_nn27">36.3.14 C++ Smart Pointers</a></H3>
+
+
+<H4><a name="Python_smart_pointers_shared_ptr">36.3.14.1 The shared_ptr Smart Pointer</a></H4>
+
+
+<p>
+The C++11 standard provides <tt>std::shared_ptr</tt> which was derived from the Boost
+implementation, <tt>boost::shared_ptr</tt>.
+Both of these are available for Python in the SWIG library and usage is outlined
+in the <a href="Library.html#Library_std_shared_ptr">shared_ptr smart pointer</a> library section.
+</p>
+
+
+<H4><a name="Python_smart_pointers_generic">36.3.14.2 Generic Smart Pointers</a></H4>
<p>
</pre>
</div>
-<H3><a name="Python_nn27a"></a>34.3.15 C++ reference counted objects</H3>
+<H3><a name="Python_nn27a">36.3.15 C++ reference counted objects</a></H3>
<p>
</p>
-<H2><a name="Python_nn28"></a>34.4 Further details on the Python class interface</H2>
+<H2><a name="Python_nn28">36.4 Further details on the Python class interface</a></H2>
<p>
section.
</p>
-<H3><a name="Python_nn29"></a>34.4.1 Proxy classes</H3>
+<H3><a name="Python_nn29">36.4.1 Proxy classes</a></H3>
<p>
import _example
class Foo(object):
- def __init__(self):
- self.this = _example.new_Foo()
- self.thisown = 1
- def __del__(self):
- if self.thisown:
- _example.delete_Foo(self.this)
- def spam(self,arg1):
- return _example.Foo_spam(self.this,arg1)
- x = property(_example.Foo_x_get, _example.Foo_x_set)
+ def __init__(self):
+ self.this = _example.new_Foo()
+ self.thisown = 1
+ def __del__(self):
+ if self.thisown:
+ _example.delete_Foo(self.this)
+ def spam(self,arg1):
+ return _example.Foo_spam(self.this,arg1)
+ x = property(_example.Foo_x_get, _example.Foo_x_set)
</pre>
</div>
by Python built-in types until Python 2.2).
</p>
-<H3><a name="Python_builtin_types"></a>34.4.2 Built-in Types</H3>
+<H3><a name="Python_builtin_types">36.4.2 Built-in Types</a></H3>
<p>
<div class="targetlang">
<pre>
class Foo(object):
- def __init__(self):
- self.this = _example.new_Foo()
- self.thisown = 1
+ def __init__(self):
+ self.this = _example.new_Foo()
+ self.thisown = 1
</pre>
</div>
<p><a href="http://docs.python.org/extending/newtypes.html">http://docs.python.org/extending/newtypes.html</a></p>
-<H4><a name="Python_builtin_limitations"></a>34.4.2.1 Limitations</H4>
+<H4><a name="Python_builtin_limitations">36.4.2.1 Limitations</a></H4>
<p>Use of the <tt>-builtin</tt> option implies a couple of limitations:
<div class="targetlang">
<pre>
-class MyPyException (Exception) :
- def __init__(self, msg, *args) :
+class MyPyException(Exception):
+ def __init__(self, msg, *args):
Exception.__init__(self, *args)
self.myexc = MyException(msg)
- def what (self) :
+ def what(self):
return self.myexc.what()
</pre>
</div>
</li>
</ul>
-<H4><a name="Python_builtin_overloads"></a>34.4.2.2 Operator overloads -- use them!</H4>
+<H4><a name="Python_builtin_overloads">36.4.2.2 Operator overloads -- use them!</a></H4>
<p>The entire justification for the <tt>-builtin</tt> option is improved
</p>
-<H3><a name="Python_nn30"></a>34.4.3 Memory management</H3>
+<H3><a name="Python_nn30">36.4.3 Memory management</a></H3>
<p>NOTE: Although this section refers to proxy objects, everything here also applies
typemaps--an advanced topic discussed later.
</p>
-<H3><a name="Python_nn31"></a>34.4.4 Python 2.2 and classic classes</H3>
+<H3><a name="Python_nn31">36.4.4 Python 2.2 and classic classes</a></H3>
<p>
This new-style class system offers many enhancements including static
member functions, properties (managed attributes), and class methods.
Details about all of these changes can be found on <a
-href="http://www.python.org">www.python.org</a> and is not repeated here.
+href="https://www.python.org">www.python.org</a> and is not repeated here.
</p>
<p>
<p>
This dual-nature of the wrapper code means that you can create extension
modules with SWIG and those modules will work with all versions of Python
-ranging from Python-1.4 to the very latest release. Moreover, the wrappers take
+ranging from Python-2.0 to the very latest release. Moreover, the wrappers take
advantage of Python-2.2 features when available.
</p>
function or through an instance (see the earlier section).
</p>
-<H2><a name="Python_directors"></a>34.5 Cross language polymorphism</H2>
+<H2><a name="Python_directors">36.5 Cross language polymorphism</a></H2>
<p>
all the cross-language method routing transparently.
</p>
-<H3><a name="Python_nn33"></a>34.5.1 Enabling directors</H3>
+<H3><a name="Python_nn33">36.5.1 Enabling directors</a></H3>
<p>
class Foo {
public:
Foo(int foo);
+ virtual ~Foo();
virtual void one();
virtual void two();
};
import mymodule
class MyFoo(mymodule.Foo):
- def __init__(self, foo):
- mymodule.Foo(self, foo)
+ def __init__(self, foo):
+ mymodule.Foo.__init__(self, foo)
+# super().__init__(foo) # Alternative construction for Python3
- def one(self):
- print "one from python"
+ def one(self):
+ print "one from python"
</pre>
</div>
-<H3><a name="Python_nn34"></a>34.5.2 Director classes</H3>
+<H3><a name="Python_nn34">36.5.2 Director classes</a></H3>
calls through Python.
</p>
-<H3><a name="Python_nn35"></a>34.5.3 Ownership and object destruction</H3>
+<H3><a name="Python_nn35">36.5.3 Ownership and object destruction</a></H3>
<p>
references to the Foo objects remain in Python.
</p>
-<H3><a name="Python_nn36"></a>34.5.4 Exception unrolling</H3>
+<H3><a name="Python_nn36">36.5.4 Exception unrolling</a></H3>
<p>
exception as soon as the C wrapper function returns.
</p>
-<H3><a name="Python_nn37"></a>34.5.5 Overhead and code bloat</H3>
+<H3><a name="Python_nn37">36.5.5 Overhead and code bloat</a></H3>
<p>
Python.
</p>
-<H3><a name="Python_nn38"></a>34.5.6 Typemaps</H3>
+<H3><a name="Python_nn38">36.5.6 Typemaps</a></H3>
<p>
</p>
-<H3><a name="Python_nn39"></a>34.5.7 Miscellaneous</H3>
+<H3><a name="Python_nn39">36.5.7 Miscellaneous</a></H3>
<p>
</p>
-<H2><a name="Python_nn40"></a>34.6 Common customization features</H2>
+<H2><a name="Python_nn40">36.6 Common customization features</a></H2>
<p>
improve your the interface to an extension module.
</p>
-<H3><a name="Python_nn41"></a>34.6.1 C/C++ helper functions</H3>
+<H3><a name="Python_nn41">36.6.1 C/C++ helper functions</a></H3>
<p>
customization features as covered in later sections.
</p>
-<H3><a name="Python_nn42"></a>34.6.2 Adding additional Python code</H3>
+<H3><a name="Python_nn42">36.6.2 Adding additional Python code</a></H3>
<p>
</pre>
</div>
+<p>When using <tt>%pythoncode</tt> and <tt>%pythonbegin</tt> you generally
+want to make sure that the block is delimited by <tt>%{</tt> and <tt>%}</tt>.
+If you delimit it with <tt>{</tt> and <tt>}</tt> then any lines with a
+leading <tt>#</tt> will be handled by SWIG as preprocessor directives, when
+you probably meant them as Python comments. Prior to SWIG 3.0.3, invalid
+preprocessor directives were silently ignored, so generally using the wrong
+delimiters resulted in such comments not appearing in the generated output
+(though a comment starting with a valid preprocessor directive could cause
+problems, for example: <tt># error handling</tt>). SWIG 3.0.3 and later report
+an error for invalid preprocessor directives, so you may have to update
+existing interface files to delimit blocks of Python code correctly.</p>
+
+<p>As an alternative to providing a block containing Python code, you can
+include python code from a file. The code is inserted exactly as in the
+file, so this avoids any issues with the SWIG preprocessor. It's a good
+approach if you have a non-trivial chunk of Python code to insert. To
+use this feature you specify a filename in double quotes, for example:</p>
+
+<div class="code">
+<pre>
+%pythoncode "somecode.py"
+</pre>
+</div>
+
<p>Sometimes you may want to replace or modify the wrapper function
that SWIG creates in the proxy <tt>.py</tt> file. The Python module
in SWIG provides some features that enable you to do this. First, to
class Foo {
public:
int bar(int x);
-}
+};
</pre>
</div>
class Foo {
public:
int bar(int x);
-}
+};
</pre>
</div>
class Foo {
public:
int bar(int x);
-}
+};
</pre>
</div>
public:
int bar(int x);
int bar();
-}
+};
</pre>
</div>
</p>
-<H3><a name="Python_nn43"></a>34.6.3 Class extension with %extend</H3>
+<H3><a name="Python_nn43">36.6.3 Class extension with %extend</a></H3>
<p>
in any way---the extensions only show up in the Python interface.
</p>
-<H3><a name="Python_nn44"></a>34.6.4 Exception handling with %exception</H3>
+<H3><a name="Python_nn44">36.6.4 Exception handling with %exception</a></H3>
<p>
to raise exceptions. See the <a href="Library.html#Library">SWIG Library</a> chapter.
</p>
-<H2><a name="Python_nn45"></a>34.7 Tips and techniques</H2>
+<H2><a name="Python_nn45">36.7 Tips and techniques</a></H2>
<p>
solving these problems.
</p>
-<H3><a name="Python_nn46"></a>34.7.1 Input and output parameters</H3>
+<H3><a name="Python_nn46">36.7.1 Input and output parameters</a></H3>
<p>
may not have the intended effect since <tt>typemaps.i</tt> does not define an OUTPUT rule for <tt>Bar</tt>.
</p>
-<H3><a name="Python_nn47"></a>34.7.2 Simple pointers</H3>
+<H3><a name="Python_nn47">36.7.2 Simple pointers</a></H3>
<p>
See the <a href="Library.html#Library">SWIG Library</a> chapter for further details.
</p>
-<H3><a name="Python_nn48"></a>34.7.3 Unbounded C Arrays</H3>
+<H3><a name="Python_nn48">36.7.3 Unbounded C Arrays</a></H3>
<p>
package binary data, etc.
</p>
-<H3><a name="Python_nn49"></a>34.7.4 String handling</H3>
+<H3><a name="Python_nn49">36.7.4 String handling</a></H3>
<p>
also be used to extra binary data from arbitrary pointers.
</p>
-<H2><a name="Python_nn53"></a>34.8 Typemaps</H2>
+
+<H3><a name="Python_default_args">36.7.5 Default arguments</a></H3>
+
+
+<p>
+C++ default argument code generation is documented in the main
+<a href="SWIGPlus.html#SWIGPlus_default_args">Default arguments</a> section.
+There is also an optional Python specific feature that can be used called the <tt>python:cdefaultargs</tt>
+<a href="Customization.html#Customization_feature_flags">feature flag</a>.
+By default, SWIG attempts to convert C++ default argument values
+into Python values and generates code into the Python layer containing these values.
+For example:
+</p>
+
+<div class="code">
+<pre>
+struct CDA {
+ int fff(int a = 1, bool b = false);
+};
+</pre>
+</div>
+
+<p>
+From Python this can be called as follows:
+</p>
+
+<div class="targetlang">
+<pre>
+>>> CDA().fff() # C++ layer receives a=1 and b=false
+>>> CDA().fff(2) # C++ layer receives a=2 and b=false
+>>> CDA().fff(3, True) # C++ layer receives a=3 and b=true
+</pre>
+</div>
+
+<p>
+The default code generation in the Python layer is:
+</p>
+
+<div class="targetlang">
+<pre>
+class CDA(object):
+ ...
+ def fff(self, a=1, b=False):
+ return _default_args.CDA_fff(self, a, b)
+</pre>
+</div>
+
+<p>
+Adding the feature:
+</p>
+
+<div class="code">
+<pre>
+%feature("python:cdefaultargs") CDA::fff;
+struct CDA {
+ int fff(int a = 1, bool b = false);
+</pre>
+</div>
+
+<p>
+results in identical behaviour when called from Python, however, it results in different code generation:
+</p>
+
+<div class="targetlang">
+<pre>
+class CDA(object):
+ ...
+ def fff(self, *args):
+ return _default_args.CDA_fff(self, *args)
+</pre>
+</div>
+
+<p>
+The default arguments are obtained in the C++ wrapper layer instead of the Python layer.
+Some code generation modes are quite different, eg <tt>-builtin</tt> and <tt>-fastproxy</tt>,
+and are unaffected by <tt>python:cdefaultargs</tt> as the default values are always obtained from the C++ layer.
+</p>
+
+<p>
+Note that not all default arguments can be converted into a Python equivalent.
+When SWIG does not convert them, it will generate code to obtain them from the C++ layer as if
+<tt>python:cdefaultargs</tt> was specified.
+This will happen if just one argument cannot be converted into a Python equivalent.
+This occurs typically when the argument is not fully numeric, such as <tt>int(1)</tt>:
+</p>
+
+<div class="code">
+<pre>
+struct CDA {
+ int fff(int a = int(1), bool b = false);
+};
+</pre>
+</div>
+
+<p>
+<b>Compatibility Note:</b> SWIG-3.0.6 introduced the <tt>python:cdefaultargs</tt> feature.
+Versions of SWIG prior to this varied in their ability to convert C++ default values into
+equivalent Python default argument values.
+</p>
+
+<H2><a name="Python_nn53">36.8 Typemaps</a></H2>
<p>
C-Python interface or if you want to elevate your guru status.
</p>
-<H3><a name="Python_nn54"></a>34.8.1 What is a typemap?</H3>
+<H3><a name="Python_nn54">36.8.1 What is a typemap?</a></H3>
<p>
%module example
%typemap(in) int {
- $1 = (int) PyLong_AsLong($input);
- printf("Received an integer : %d\n",$1);
+ $1 = (int) PyLong_AsLong($input);
+ printf("Received an integer : %d\n",$1);
}
%inline %{
extern int fact(int n);
%module example
%typemap(in) int nonnegative {
- $1 = (int) PyLong_AsLong($input);
- if ($1 < 0) {
- PyErr_SetString(PyExc_ValueError,"Expected a nonnegative value.");
- return NULL;
- }
+ $1 = (int) PyLong_AsLong($input);
+ if ($1 < 0) {
+ PyErr_SetString(PyExc_ValueError,"Expected a nonnegative value.");
+ return NULL;
+ }
}
%inline %{
extern int fact(int nonnegative);
<div class="code">
<pre>
%typemap(in) int n {
- $1 = (int) PyLong_AsLong($input);
- printf("n = %d\n",$1);
+ $1 = (int) PyLong_AsLong($input);
+ printf("n = %d\n",$1);
}
%inline %{
typedef int Integer;
</pre>
</div>
-<H3><a name="Python_nn55"></a>34.8.2 Python typemaps</H3>
+<H3><a name="Python_nn55">36.8.2 Python typemaps</a></H3>
<p>
</p>
-<H3><a name="Python_nn56"></a>34.8.3 Typemap variables</H3>
+<H3><a name="Python_nn56">36.8.3 Typemap variables</a></H3>
<p>
The Python name of the wrapper function being created.
</div>
-<H3><a name="Python_nn57"></a>34.8.4 Useful Python Functions</H3>
+<H3><a name="Python_nn57">36.8.4 Useful Python Functions</a></H3>
<p>
</pre>
</div>
-<H2><a name="Python_nn58"></a>34.9 Typemap Examples</H2>
+<H2><a name="Python_nn58">36.9 Typemap Examples</a></H2>
<p>
the SWIG library.
</p>
-<H3><a name="Python_nn59"></a>34.9.1 Converting Python list to a char ** </H3>
+<H3><a name="Python_nn59">36.9.1 Converting Python list to a char ** </a></H3>
<p>
for (i = 0; i < size; i++) {
PyObject *o = PyList_GetItem($input,i);
if (PyString_Check(o))
- $1[i] = PyString_AsString(PyList_GetItem($input,i));
+ $1[i] = PyString_AsString(PyList_GetItem($input,i));
else {
- PyErr_SetString(PyExc_TypeError,"list must contain strings");
- free($1);
- return NULL;
+ PyErr_SetString(PyExc_TypeError,"list must contain strings");
+ free($1);
+ return NULL;
}
}
$1[i] = 0;
<div class="targetlang"><pre>
>>> from argv import *
->>> print_args(["Dave","Mike","Mary","Jane","John"])
+>>> print_args(["Dave", "Mike", "Mary", "Jane", "John"])
argv[0] = Dave
argv[1] = Mike
argv[2] = Mary
the C function.
</p>
-<H3><a name="Python_nn60"></a>34.9.2 Expanding a Python object into multiple arguments</H3>
+<H3><a name="Python_nn60">36.9.2 Expanding a Python object into multiple arguments</a></H3>
<p>
<div class="targetlang">
<pre>
->>> foo(4, ["foo","bar","spam","1"])
+>>> foo(4, ["foo", "bar", "spam", "1"])
</pre>
</div>
for (i = 0; i < $1; i++) {
PyObject *o = PyList_GetItem($input,i);
if (PyString_Check(o))
- $2[i] = PyString_AsString(PyList_GetItem($input,i));
+ $2[i] = PyString_AsString(PyList_GetItem($input,i));
else {
- PyErr_SetString(PyExc_TypeError,"list must contain strings");
- free($2);
- return NULL;
+ PyErr_SetString(PyExc_TypeError,"list must contain strings");
+ free($2);
+ return NULL;
}
}
$2[i] = 0;
<div class="targetlang">
<pre>
->>> foo(["foo","bar","spam","1"])
+>>> foo(["foo", "bar", "spam", "1"])
+</pre>
+</div>
+
+<p>
+If your function is overloaded in C++, for example:
+</p>
+
+<div class="code">
+<pre>
+int foo(int argc, char **argv);
+int foo();
+</pre>
+</div>
+
+<p>
+don't forget to also provide a suitable <a href="Typemaps.html#Typemaps_overloading">typecheck typemap for overloading</a>
+such as:
+</p>
+
+<div class="code">
+<pre>
+%typecheck(SWIG_TYPECHECK_STRING_ARRAY) (int argc, char **argv) {
+ $1 = PyList_Check($input) ? 1 : 0;
+}
+</pre>
+</div>
+
+<p>
+If you don't you'll get an error message along the lines of:
+</p>
+
+<div class="shell">
+<pre>
+Traceback (most recent call last):
+ File "runme.py", line 3, in >module<
+ example.foo(["foo", "bar", "spam", "1"])
+NotImplementedError: Wrong number or type of arguments for overloaded function 'foo'.
+ Possible C/C++ prototypes are:
+ foo(int,char **)
+ foo()
</pre>
</div>
-<H3><a name="Python_nn61"></a>34.9.3 Using typemaps to return arguments</H3>
+<H3><a name="Python_nn61">36.9.3 Using typemaps to return arguments</a></H3>
<p>
<div class="code"><pre>
/* Returns a status value and two values in out1 and out2 */
int spam(double a, double b, double *out1, double *out2) {
- ... Do a bunch of stuff ...
- *out1 = result1;
- *out2 = result2;
- return status;
-};
-
+ ... Do a bunch of stuff ...
+ *out1 = result1;
+ *out2 = result2;
+ return status;
+}
</pre></div>
<p>
// is guaranteed to be a List object by SWIG.
%typemap(argout) double *OutValue {
- PyObject *o, *o2, *o3;
- o = PyFloat_FromDouble(*$1);
- if ((!$result) || ($result == Py_None)) {
- $result = o;
- } else {
- if (!PyTuple_Check($result)) {
- PyObject *o2 = $result;
- $result = PyTuple_New(1);
- PyTuple_SetItem(target,0,o2);
- }
- o3 = PyTuple_New(1);
- PyTuple_SetItem(o3,0,o);
- o2 = $result;
- $result = PySequence_Concat(o2,o3);
- Py_DECREF(o2);
- Py_DECREF(o3);
+ PyObject *o, *o2, *o3;
+ o = PyFloat_FromDouble(*$1);
+ if ((!$result) || ($result == Py_None)) {
+ $result = o;
+ } else {
+ if (!PyTuple_Check($result)) {
+ PyObject *o2 = $result;
+ $result = PyTuple_New(1);
+ PyTuple_SetItem($result,0,o2);
}
+ o3 = PyTuple_New(1);
+ PyTuple_SetItem(o3,0,o);
+ o2 = $result;
+ $result = PySequence_Concat(o2,o3);
+ Py_DECREF(o2);
+ Py_DECREF(o3);
+ }
}
int spam(double a, double b, double *OutValue, double *OutValue);
>>>
</pre></div>
-<H3><a name="Python_nn62"></a>34.9.4 Mapping Python tuples into small arrays</H3>
+<H3><a name="Python_nn62">36.9.4 Mapping Python tuples into small arrays</a></H3>
<p>
for small structures, this approach works fine.
</p>
-<H3><a name="Python_nn63"></a>34.9.5 Mapping sequences to C arrays</H3>
+<H3><a name="Python_nn63">36.9.5 Mapping sequences to C arrays</a></H3>
<p>
</pre>
</div>
-<H3><a name="Python_nn64"></a>34.9.6 Pointer handling</H3>
+<H3><a name="Python_nn64">36.9.6 Pointer handling</a></H3>
<p>
-<H2><a name="Python_nn65"></a>34.10 Docstring Features</H2>
+<H2><a name="Python_nn65">36.10 Docstring Features</a></H2>
<p>
</p>
-<H3><a name="Python_nn66"></a>34.10.1 Module docstring</H3>
+<H3><a name="Python_nn66">36.10.1 Module docstring</a></H3>
<p>
</div>
-<H3><a name="Python_nn67"></a>34.10.2 %feature("autodoc")</H3>
+<H3><a name="Python_nn67">36.10.2 %feature("autodoc")</a></H3>
<p>
feature, <tt>%feature("autodoc", "<i>level</i>")</tt>.
The four values for <i>level</i> are covered in the following sub-sections.
-<H4><a name="Python_nn68"></a>34.10.2.1 %feature("autodoc", "0")</H4>
+<H4><a name="Python_nn68">36.10.2.1 %feature("autodoc", "0")</a></H4>
<p>
</div>
-<H4><a name="Python_nn69"></a>34.10.2.2 %feature("autodoc", "1")</H4>
+<H4><a name="Python_nn69">36.10.2.2 %feature("autodoc", "1")</a></H4>
<p>
</div>
-<H4><a name="Python_autodoc2"></a>34.10.2.3 %feature("autodoc", "2")</H4>
+<H4><a name="Python_autodoc2">36.10.2.3 %feature("autodoc", "2")</a></H4>
<p>
Level "2" results in the function prototype as per level "0". In addition, a line of
-documentation is generated for each parameter. Using the previous example, the generated
-code will be:
+documentation is generated for each parameter using <a href="https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt">numpydoc</a> style.
+Using the previous example, the generated code will be:
</p>
<div class="targetlang">
"""
function_name(x, y, foo=None, bar=None) -> bool
- Parameters:
- x: int
- y: int
- foo: Foo *
- bar: Bar *
+ Parameters
+ ----------
+ x: int
+ y: int
+ foo: Foo *
+ bar: Bar *
"""
...
"""
function_name(x, y, foo=None, bar=None) -> bool
- Parameters:
- x (C++ type: int) -- Input x dimension
- y: int
- foo: Foo *
- bar: Bar *
+ Parameters
+ ----------
+ x (C++ type: int) -- Input x dimension
+ y: int
+ foo: Foo *
+ bar: Bar *
"""
</pre>
</div>
-<H4><a name="Python_autodoc3"></a>34.10.2.4 %feature("autodoc", "3")</H4>
+<H4><a name="Python_autodoc3">36.10.2.4 %feature("autodoc", "3")</a></H4>
<p>
"""
function_name(int x, int y, Foo foo=None, Bar bar=None) -> bool
- Parameters:
- x: int
- y: int
- foo: Foo *
- bar: Bar *
+ Parameters
+ ----------
+ x: int
+ y: int
+ foo: Foo *
+ bar: Bar *
"""
...
</div>
-<H4><a name="Python_nn70"></a>34.10.2.5 %feature("autodoc", "docstring")</H4>
+<H4><a name="Python_nn70">36.10.2.5 %feature("autodoc", "docstring")</a></H4>
<p>
</div>
-<H3><a name="Python_nn71"></a>34.10.3 %feature("docstring")</H3>
+<H3><a name="Python_nn71">36.10.3 %feature("docstring")</a></H3>
<p>
</pre>
</div>
-<H2><a name="Python_nn72"></a>34.11 Python Packages</H2>
+<H2><a name="Python_nn72">36.11 Python Packages</a></H2>
-<p>
-Using the <tt>package</tt> option of the <tt>%module</tt> directive
-allows you to specify what Python package that the module will be
-living in when installed.
-</p>
+<p>Python has concepts of modules and packages. Modules are separate units of
+code and may be grouped together to form a package. Packages may be nested,
+that is they may contain subpackages. This leads to tree-like hierarchy, with
+packages as intermediate nodes and modules as leaf nodes.</p>
-<div class="code">
+<p>The hierarchy of Python packages/modules follows the hierarchy of
+<tt>*.py</tt> files found in a source tree (or, more generally, in the Python path).
+Normally, the developer creates new module by placing a <tt>*.py</tt> file
+somewhere under Python path; the module is then named after that <tt>*.py</tt>
+file. A package is created by placing an <tt>__init__.py</tt> file within a
+directory; the package is then named after that directory. For example, the
+following source tree:</p>
+
+<div class="diagram">
<pre>
-%module(package="wx") xrc
+mod1.py
+pkg1/__init__.py
+pkg1/mod2.py
+pkg1/pkg2/__init__.py
+pkg1/pkg2/mod3.py
</pre>
</div>
<p>
-This is useful when the <tt>.i</tt> file is <tt>%import</tt>ed by
-another <tt>.i</tt> file. By default SWIG will assume that the
-importer is able to find the importee with just the module name, but
-if they live in separate Python packages then that won't work.
-However if the importee specifies what its package is with the
-<tt>%module</tt> option then the Python code generated for the
-importer will use that package name when importing the other module
-and also in base class declarations, etc. if the package name is
-different than its own.
+defines the following Python packages and modules:
</p>
-<H2><a name="Python_python3support"></a>34.12 Python 3 Support</H2>
-
+<div class="diagram">
+<pre>
+pkg1 # package
+pkg1.pkg2 # package
+mod1 # module
+pkg1.mod2 # module
+pkg1.pkg2.mod3 # module
+</pre>
+</div>
<p>
-SWIG is able to support Python 3.0. The wrapper code generated by
-SWIG can be compiled with both Python 2.x or 3.0. Further more, by
-passing the <tt>-py3</tt> command line option to SWIG, wrapper code
-with some Python 3 specific features can be generated (see below
-subsections for details of these features). The <tt>-py3</tt> option also
-disables some incompatible features for Python 3, such as
-<tt>-classic</tt>.
+The purpose of an <tt>__init__.py</tt> file is two-fold. First, the existence of
+<tt>__init__.py</tt> in a directory informs the Python interpreter that this
+directory contains a Python package. Second, the code in <tt>__init__.py</tt> is
+loaded/executed automatically when the package is initialized (when it or its
+submodule/subpackage gets <tt>import</tt>'ed). By default, SWIG generates
+proxy Python code – one <tt>*.py</tt> file for each <tt>*.i</tt>
+interface. The <tt>__init__.py</tt> files, however, are not generated by SWIG.
+They should be created by other means. Both files (module <tt>*.py</tt> and
+<tt>__init__.py</tt>) should be installed in appropriate destination
+directories in order to obtain a desirable package/module hierarchy.
+</p>
<p>
-There is a list of known-to-be-broken features in Python 3:
+Python3 adds another option for packages with
+<a href="https://www.python.org/dev/peps/pep-0420/">PEP 0420</a> (implicit
+namespace packages). Implicit namespace packages no longer use
+__init__.py files. SWIG generated Python modules support implicit
+namespace packages. See
+<a href="#Python_implicit_namespace_packages">36.11.5 Implicit Namespace
+Packages</a> for more information.
</p>
-<ul>
- <li>No more support for FILE* typemaps, because PyFile_AsFile has been dropped
- in Python 3.</li>
- <li>The <tt>-apply</tt> command line option is removed and generating
- code using apply() is no longer supported.</li>
-</ul>
<p>
-The following are Python 3.0 new features that are currently supported by
-SWIG.
+If you place a SWIG generated module into a Python package then there
+are details concerning the way SWIG
+<a href="#Python_package_search">searches for the wrapper module</a>
+that you may want to familiarize yourself with.
</p>
-<H3><a name="Python_nn74"></a>34.12.1 Function annotation</H3>
-
+<p>The way Python defines its modules and packages impacts SWIG users. Some
+users may need to use special features such as the <tt>package</tt> option in the
+<tt>%module</tt> directive or import related command line options. These are
+explained in the following sections.</p>
-<p>
-The <tt>-py3</tt> option will enable function annotation support. When used
-SWIG is able to generate proxy method definitions like this:
-</p>
+<H3><a name="Python_modulepackage">36.11.1 Setting the Python package</a></H3>
-<div class="code"><pre>
- def foo(self, bar : "int"=0) -> "void" : ...
-</pre></div>
<p>
-Also, even if without passing SWIG the <tt>-py3</tt> option, the parameter list
-still could be generated:
+Using the <tt>package</tt> option in the <tt>%module</tt> directive allows you
+to specify a Python package that the module will be in when installed.
</p>
-<div class="code"><pre>
- def foo(self, bar=0): ...
-</pre></div>
+<div class="code">
+<pre>
+%module(package="wx") xrc
+</pre>
+</div>
<p>
-But for overloaded function or method, the parameter list would fallback to
-<tt>*args</tt> or <tt>self, *args</tt>, and <tt>**kwargs</tt> may be append
-depend on whether you enabled the keyword argument. This fallback is due to
-all overloaded functions share the same function in SWIG generated proxy class.
+This is useful when the <tt>.i</tt> file is <tt>%import</tt>ed by
+another <tt>.i</tt> file. By default SWIG will assume that the
+importer is able to find the importee with just the module name, but
+if they live in separate Python packages then this won't work.
+However if the importee specifies what its package is with the
+<tt>%module</tt> option then the Python code generated for the
+importer will use that package name when importing the other module
+and in base class declarations, etc..
</p>
-<p>
-For detailed usage of function annotation, see
-<a href="http://www.python.org/dev/peps/pep-3107/">PEP 3107</a>.
+<p>SWIG assumes that the <tt>package</tt> option provided to <tt>%module</tt>
+together with the <tt>module</tt> name (that is, <tt>wx.xrc</tt> in the above
+example) forms a fully qualified (absolute) name of a module (in Python terms).
+This is important especially for Python 3, where absolute imports are used by
+default. It's up to you to place the generated module files (<tt>.py</tt>,
+<tt>.so</tt>) in appropriate subdirectories. For example, if you have an
+interface file <tt>foo.i</tt> with:
</p>
-<H3><a name="Python_nn75"></a>34.12.2 Buffer interface</H3>
-
+<div class="code">
+<pre>
+%module(package="pkg1.pkg2") foo
+</pre>
+</div>
<p>
-Buffer protocols were revised in Python 3. SWIG also gains a series of
-new typemaps to support buffer interfaces. These typemap macros are
-defined in <tt>pybuffer.i</tt>, which must be included in order to use them.
-By using these typemaps, your wrapped function will be able to
-accept any Python object that exposes a suitable buffer interface.
+then the resulting directory layout should be
</p>
-<p>
-For example, the <tt>get_path()</tt> function puts the path string
-into the memory pointed to by its argument:
-</p>
+<div class="diagram">
+<pre>
+pkg1/
+pkg1/__init__.py
+pkg1/pkg2/__init__.py
+pkg1/pkg2/foo.py # (generated by SWIG)
+pkg1/pkg2/_foo.so # (shared library built from C/C++ code generated by SWIG)
+</pre>
+</div>
-<div class="code"><pre>
-void get_path(char *s);
-</pre></div>
+<H3><a name="Python_absrelimports">36.11.2 Absolute and relative imports</a></H3>
-<p>
-Then you can write a typemap like this: (the following example is
-applied to both Python 3.0 and 2.6, since the <tt>bytearray</tt> type
-is backported to 2.6.
-</p>
+<p>Suppose, we have the following hierarchy of files:</p>
-<div class="code"><pre>
-%include <pybuffer.i>
-%pybuffer_mutable_string(char *str);
-void get_path(char *s);
-</pre></div>
+<div class="diagram">
+<pre>
+pkg1/
+pkg1/__init__.py
+pkg1/mod2.py
+pkg1/pkg2/__init__.py
+pkg1/pkg2/mod3.py
+</pre>
+</div>
+
+<p>Let the contents of <tt>pkg1/pkg2/mod3.py</tt> be</p>
+<div class="targetlang">
+<pre>
+class M3: pass
+</pre>
+</div>
<p>
-And then on the Python side the wrapped <tt>get_path</tt> could be used in this
-way:
+We edit <tt>pkg1/mod2.py</tt> and want to import module
+<tt>pkg1/pkg2/mod3.py</tt> in order to derive from class <tt>M3</tt>. We can
+write appropriate Python code in several ways, for example:
</p>
-<div class="targetlang"><pre>
->>> p = bytearray(10)
->>> get_path(p)
->>> print(p)
-bytearray(b'/Foo/Bar/\x00')
-</pre></div>
+<ol>
+ <li><p>Using "<tt>import <></tt>" syntax with absolute package name:</p>
+ <div class="targetlang">
+<pre>
+# pkg1/mod2.py
+import pkg1.pkg2.mod3
+class M2(pkg1.pkg2.mod3.M3): pass
+</pre>
+ </div>
+ </li>
-<p>
-The macros defined in <tt>pybuffer.i</tt> are similar to those in
-<tt>cstring.i</tt>:
-</p>
+ <li><p>Using "<tt>import <></tt>" syntax with package name relative to
+ <tt>pkg1</tt> (only in Python 2.7 and earlier):</p>
+ <div class="targetlang">
+<pre>
+# pkg1/mod2.py
+import pkg2.mod3
+class M2(pkg2.mod3.M3): pass
+</pre>
+ </div>
+ </li>
-<p>
-<b>%pybuffer_mutable_binary(parm, size_parm)</b>
-</p>
+ <li><p>Using "<tt>from <> import <></tt>" syntax (relative import
+ syntax, only in Python 2.5 and later):</p>
+ <div class="targetlang">
+<pre>
+# pkg1/mod2.py
+from .pkg2 import mod3
+class M2(mod3.M3): pass
+</pre>
+ </div>
+ </li>
-<div class="indent">
+ <li><p>Other variants, for example the following construction in order to
+ have the <tt>pkg2.mod3.M3</tt> symbol available in <tt>mod2</tt> as
+ in point 2 above (but now under Python 3):</p>
+ <div class="targetlang">
+<pre>
+# pkg1/mod2.py
+from . import pkg2
+from .pkg2 import mod3
+class M2(pkg2.mod3.M3): pass
+</pre>
+ </div>
+ </li>
-<p>
+</ol>
+
+<p>Now suppose we have <tt>mod2.i</tt> with</p>
+
+<div class="code">
+<pre>
+// mod2.i
+%module (package="pkg1") mod2
+%import "mod3.i"
+// ...
+</pre>
+</div>
+
+<p>and <tt>mod3.i</tt> with</p>
+
+<div class="code">
+<pre>
+// mod3.i
+%module (package="pkg1.pkg2") mod3
+// ...
+</pre>
+</div>
+
+<p>By default, SWIG would generate <tt>mod2.py</tt> proxy file with
+<tt>import</tt> directive as in point 1. This can be changed with the
+<tt>-relativeimport</tt> command line option. The <tt>-relativeimport</tt> instructs
+SWIG to organize imports as in point 2 (for Python < 2.7.0) or as in point 4
+for Python 2.7.0 and newer. This is a check done at the time the module is
+imported. In short, if you have
+<tt>mod2.i</tt> and <tt>mod3.i</tt> as above, then without
+<tt>-relativeimport</tt> SWIG will write</p>
+
+<div class="targetlang">
+<pre>
+import pkg1.pkg2.mod3
+</pre>
+</div>
+
+<p>to <tt>mod2.py</tt> proxy file, and with <tt>-relativeimport</tt> it will
+write</p>
+
+<div class="targetlang">
+ <pre>
+from sys import version_info
+if version_info >= (2, 7, 0):
+ from . import pkg2
+ import pkg1.pkg2.mod3
+else:
+ import pkg2.mod3
+del version_info
+</pre>
+</div>
+
+<p>You should avoid using relative imports and use absolute ones whenever
+possible. There are some cases, however, when relative imports may be
+necessary. The first example is, when some (legacy) Python code refers entities
+imported by proxy files generated by SWIG, and it assumes that the proxy file
+uses relative imports. Second case is, when one puts import directives in
+<tt>__init__.py</tt> to import symbols from submodules or subpackages and the
+submodule depends on other submodules (discussed later).</p>
+
+<H3><a name="Python_absimport">36.11.3 Enforcing absolute import semantics</a></H3>
+
+
+<p>As you may know, there is an incompatibility in import semantics (for the
+<tt>import <></tt> syntax) between Python 2 and 3. In Python 2.4 and
+earlier it is not clear whether</p>
+
+<div class="targetlang">
+<pre>
+import foo
+</pre>
+</div>
+<p>refers to a top-level module or to another module inside the current
+package. In Python 3 it always refers to a top-level module
+(see <a href="https://www.python.org/dev/peps/pep-0328/">PEP 328</a>).
+To instruct Python 2.5 through 2.7 to use new semantics (that is <tt>import
+foo</tt> is interpreted as absolute import), one has to put the following
+line
+</p>
+
+<div class="targetlang">
+<pre>
+from __future__ import absolute_import
+</pre>
+</div>
+
+<p>at the very beginning of his proxy <tt>*.py</tt> file. In SWIG, it may be
+accomplished with <tt>%pythonbegin</tt> directive as follows:</p>
+
+<div class="code">
+<pre>
+%pythonbegin %{
+from __future__ import absolute_import
+%}
+</pre>
+</div>
+
+<H3><a name="Python_importfrominit">36.11.4 Importing from __init__.py</a></H3>
+
+
+<p>Imports in <tt>__init__.py</tt> are handy when you want to populate a
+package's namespace with names imported from other modules. In SWIG based
+projects this approach may also be used to split large pieces of code into
+smaller modules, compile them in parallel and then re-assemble everything at
+runtime by importing submodules' contents in <tt>__init__.py</tt>, for
+example.</p>
+
+<p>Unfortunately import directives in <tt>__init__.py</tt> may cause problems,
+especially if they refer to a package's submodules. This is caused by the way
+Python initializes packages. If you spot problems with imports from
+<tt>__init__.py</tt> try using <tt>-relativeimport</tt> option. Below we
+explain in detail one issue, for which the <tt>-relativeimport</tt> workaround
+may be helpful.</p>
+
+<p>Consider the following example (Python 3):</p>
+
+<div class="diagram">
+<pre>
+pkg1/__init__.py # (empty)
+pkg1/pkg2/__init__.py # (imports something from bar.py)
+pkg1/pkg2/foo.py
+pkg1/pkg2/bar.py # (imports foo.py)
+</pre>
+</div>
+
+<p>If the file contents are:</p>
+
+<ul>
+ <li> <p><tt>pkg1/pkg2/__init__.py:</tt></p>
+ <div class="targetlang">
+<pre>
+# pkg1/pkg2/__init__.py
+from .bar import Bar
+</pre>
+ </div>
+ </li>
+
+ <li> <p><tt>pkg1/pkg2/foo.py:</tt></p>
+ <div class="targetlang">
+<pre>
+# pkg1/pkg2/foo.py
+class Foo: pass
+</pre>
+ </div>
+ </li>
+
+ <li> <p><tt>pkg1/pkg2/bar.py:</tt></p>
+ <div class="targetlang">
+<pre>
+# pkg1/pkg2/bar.py
+import pkg1.pkg2.foo
+class Bar(pkg1.pkg2.foo.Foo): pass
+</pre>
+ </div>
+ </li>
+</ul>
+
+<p>Now if one simply used <tt>import pkg1.pkg2</tt>, it will usually fail:</p>
+
+<div class="diagram">
+<pre>
+>>> import pkg1.pkg2
+Traceback (most recent call last):
+ File "<stdin>", line 1, in <module>
+ File "./pkg1/pkg2/__init__.py", line 2, in <module>
+ from .bar import Bar
+ File "./pkg1/pkg2/bar.py", line 3, in <module>
+ class Bar(pkg1.pkg2.foo.Foo): pass
+AttributeError: 'module' object has no attribute 'pkg2'
+</pre>
+</div>
+
+<p>Surprisingly, if we execute the <tt>import pkg1.pkg2</tt> directive for the
+second time, it succeeds. The reason seems to be following: when Python spots
+the <tt>from .bar import Bar</tt> directive in <tt>pkg1/pkg2/__init__.py</tt>
+it starts loading <tt>pkg1/pkg2/bar.py</tt>. This module imports
+<tt>pkg1.pkg2.foo</tt> in turn and tries to use <tt>pkg1.pkg2.foo.Foo</tt>, but
+the package <tt>pkg1</tt> is not fully initialized yet (the initialization
+procedure is actually in progress) and it seems like the effect of the already seen
+<tt>import pkg1.pkg2.pkg3.foo</tt> is "delayed" or ignored. Exactly the
+same may happen to a proxy module generated by SWIG.</p>
+
+<p>One workaround for this case is to use a relative
+import in <tt>pkg1/pkg2/bar.py</tt>. If we change <tt>bar.py</tt> to be:</p>
+
+<div class="targetlang">
+<pre>
+from .pkg3 import foo
+class Bar(foo.Foo): pass
+</pre>
+</div>
+
+<p>or</p>
+
+<div class="targetlang">
+<pre>
+from . import pkg3
+from .pkg3 import foo
+class Bar(pkg3.foo.Foo): pass
+</pre>
+</div>
+
+<p>then the example works again. With SWIG, you need to enable the
+<tt>-relativeimport</tt> option in order to have the above workaround in
+effect (note, that the Python 2 case also needs the <tt>-relativeimport</tt>
+workaround).</p>
+
+<H3><a name="Python_implicit_namespace_packages">36.11.5 Implicit Namespace Packages</a></H3>
+
+
+<p> Python 3.3 introduced
+<a href="https://www.python.org/dev/peps/pep-0420/">PEP 0420</a> which
+implements implicit namespace packages. In a nutshell, implicit namespace
+packages remove the requirement of an __init__.py file and allow packages
+to be split across multiple PATH elements. For example:
+</p>
+
+<div class="diagram">
+<pre>
+/fragment1/pkg1/mod1.py
+/fragment2/pkg1/mod2.py
+/fragment3/pkg1/mod3.py
+</pre>
+</div>
+
+<p>If PYTHONPATH is set to "/fragment1:/fragment2:/fragment3", then mod1, mod2
+and mod3 will be part of pkg1. This allows for splitting of packages into
+separate pieces. This can be useful for SWIG generated wrappers in the
+following way.
+</p>
+
+<p> Suppose you create a SWIG wrapper for a module called robin. The SWIG
+generated code consists of two files robin.py and _robin.so. You wish to
+make these modules part of a subpackage (brave.sir). With implicit namespace
+packages you can place these files in the following configurations:
+</p>
+
+<p>Using PYTHONPATH="/some/path"</p>
+<div class="diagram">
+<pre>
+/some/path/brave/sir/robin.py
+/some/path/brave/sir/_robin.so
+</pre>
+</div>
+
+<p>Using PYTHONPATH="/some/path:/some/other/path"
+
+<div class="diagram">
+<pre>
+/some/path/brave/sir/robin.py
+/some/other/path/brave/sir/_robin.so
+</pre>
+</div>
+
+<p> Finally suppose that your pure python code is stored in a .zip file or
+some other way (database, web service connection, etc). Python can load the
+robin.py module using a custom importer. But the _robin.so module will need
+to be located on a file system. Implicit namespace packages make this
+possible. For example, using PYTHONPATH="/some/path/foo.zip:/some/other/path"
+
+<p> Contents of foo.zip</p>
+<div class="diagram">
+<pre>
+brave/
+brave/sir/
+brave/sir/robin.py
+</pre>
+</div>
+
+<p> File system contents</p>
+<div class="diagram">
+<pre>
+/some/other/path/brave/sir/_robin.so
+</pre>
+</div>
+
+<p>Support for implicit namespace packages was added to python-3.3. The
+zipimporter requires python-3.5.1 or newer to work with subpackages.
+</p>
+
+<p>
+<b>Compatibility Note:</b> Support for implicit namespace packages was added in SWIG-3.0.9.
+</p>
+
+
+<H3><a name="Python_package_search">36.11.6 Searching for the wrapper module</a></H3>
+
+
+<p>
+When SWIG creates wrappers from an interface file, say foo.i, two Python modules are
+created. There is a pure Python module module (foo.py) and C/C++ code which is
+built and linked into a dynamically (or statically) loaded module _foo
+(see the <a href="Python.html#Python_nn3">Preliminaries section</a> for details). So, the interface
+file really defines two Python modules. How these two modules are loaded is
+covered next.
+</p>
+
+<p>
+The pure Python module needs to load the C/C++ module in order to link
+to the wrapped C/C++ methods. To do this it must make some assumptions
+about what package the C/C++ module may be located in. The approach the
+pure Python module uses to find the C/C++ module is as follows:
+</p>
+
+<ol>
+ <li><p>The pure Python module, foo.py, tries to load the C/C++ module, _foo, from the same package foo.py is
+ located in. The package name is determined from the <tt>__name__</tt>
+ attribute given to foo.py by the Python loader that imported
+ foo.py. If foo.py is not in a package then _foo is loaded
+ as a global module.</p>
+ </li>
+ <li><p>If the above import of _foo results in an ImportError
+ being thrown, then foo.py makes a final attempt to load _foo
+ as a global module.</p>
+ </li>
+</ol>
+
+<p>
+As an example suppose foo.i is compiled into foo.py and _foo.so. Assuming
+/dir is on PYTHONPATH, then the two modules can be installed and used in the
+following ways:
+</p>
+
+
+<H4><a name="Python_package_search_both_package_modules">36.11.6.1 Both modules in the same package</a></H4>
+
+
+<p>Both modules are in one package:</p>
+<div class="diagram">
+<pre>
+/dir/package/foo.py
+/dir/package/__init__.py
+/dir/package/_foo.so
+</pre>
+</div>
+<p>And imported with</p>
+<div class="diagram">
+<pre>
+from package import foo
+</pre>
+</div>
+
+
+<H4><a name="Python_package_search_wrapper_split">36.11.6.2 Split modules</a></H4>
+
+
+<p>The pure python module is in a package and the C/C++ module is global:</p>
+<div class="diagram">
+<pre>
+/dir/package/foo.py
+/dir/package/__init__.py
+/dir/_foo.so
+</pre>
+</div>
+<p>And imported with</p>
+<div class="diagram">
+<pre>
+from package import foo
+</pre>
+</div>
+
+
+<H4><a name="Python_package_search_both_global_modules">36.11.6.3 Both modules are global</a></H4>
+
+
+<p>Both modules are global:</p>
+<div class="diagram">
+<pre>
+/dir/foo.py
+/dir/_foo.so
+</pre>
+</div>
+<p>And imported with</p>
+<div class="diagram">
+<pre>
+import foo
+</pre>
+</div>
+
+<p>
+If _foo is statically linked into an embedded Python interpreter, then it may or
+may not be in a Python package. This depends in the exact way the module was
+loaded statically. The above search order will still be used for statically
+loaded modules. So, one may place the module either globally or in a package
+as desired.
+</p>
+
+<H4><a name="Python_package_search_static">36.11.6.4 Statically linked C modules</a></H4>
+
+
+<p>It is strongly recommended to use dynamically linked modules for the C
+portion of your pair of Python modules.
+If for some reason you still need
+to link the C module of the pair of Python modules generated by SWIG into
+your interpreter, then this section provides some details on how this impacts
+the pure Python modules ability to locate the other part of the pair.
+Please also see the <a href="Python.html#Python_nn8">Static Linking</a> section.
+</p>
+
+<p>When Python is extended with C code the Python interpreter needs to be
+informed about details of the new C functions that have been linked into
+the executable. The code to do this is created by SWIG and is automatically
+called in the correct way when the module is dynamically loaded. However
+when the code is not dynamically loaded (because it is statically linked)
+Then the initialization method for the module created by SWIG is not
+called automatically and the Python interpreter has no idea that the
+new SWIG C module exists.
+</p>
+
+<p>Before Python 3, one could simply call the init method created by SWIG
+which would have normally been called when the shared object was dynamically
+loaded. The specific name of this method is not given here because statically
+linked modules are not encouraged with SWIG
+(<a href="Python.html#Python_nn8">Static Linking</a>). However one can find this
+init function in the C file generated by SWIG.
+</p>
+
+<p>If you are really keen on static linking there are two ways
+to initialize the SWIG generated C module with the init method. Which way
+you use depends on what version of Python your module is being linked with.
+Python 2 and Python 3 treat this init function differently. And the way
+they treat it affects how the pure Python module will be able to
+locate the C module.
+</p>
+
+<p>The details concerning this are covered completly in the documentation
+for Python itself. Links to the relavent sections follow:
+</p>
+
+<ul>
+ <li><a href="https://docs.python.org/2/extending/extending.html#methodtable">Extending in python2</a></li>
+ <li><a href="https://docs.python.org/3.6/extending/extending.html#the-module-s-method-table-and-initialization-function">Extending in python3</a></li>
+</ul>
+
+<p>There are two keys things to understand. The first is that in
+Python 2 the init() function returns void. In Python 3 the init() function
+returns a PyObject * which points to the new module. Secondly, when
+you call the init() method manually, you are the Python importer. So, you
+determine which package the C module will be located in.
+</p>
+
+<p>So, if you are using Python 3 it is important that you follow what is
+described in the Python documentation linked above. In particular, you can't
+simply call the init() function generated by SWIG and cast the PyObject
+pointer it returns over the side. If you do then Python 3 will have no
+idea that your C module exists and the pure Python half of your wrapper will
+not be able to find it. You need to register your module with the Python
+interpreter as described in the Python docs.
+</p>
+
+<p>With Python 2 things are somewhat more simple. In this case the init function
+returns void. Calling it will register your new C module as a <b>global</b>
+module. The pure Python part of the SWIG wrapper will be able to find it
+because it tries both the pure Python module it is part of and the global
+module. If you wish not to have the statically linked module be a global
+module then you will either need to refer to the Python documentation on how
+to do this (remember you are now the Python importer) or use dynamic linking.
+</p>
+
+<H2><a name="Python_python3support">36.12 Python 3 Support</a></H2>
+
+
+<p>
+SWIG is able to support Python 3.0. The wrapper code generated by
+SWIG can be compiled with both Python 2.x or 3.0. Further more, by
+passing the <tt>-py3</tt> command line option to SWIG, wrapper code
+with some Python 3 specific features can be generated (see below
+subsections for details of these features). The <tt>-py3</tt> option also
+disables some incompatible features for Python 3, such as
+<tt>-classic</tt>.
+
+<p>
+There is a list of known-to-be-broken features in Python 3:
+</p>
+<ul>
+ <li>No more support for FILE* typemaps, because PyFile_AsFile has been dropped
+ in Python 3.</li>
+ <li>The <tt>-apply</tt> command line option is removed and generating
+ code using apply() is no longer supported.</li>
+</ul>
+
+<p>
+The following are Python 3.0 new features that are currently supported by
+SWIG.
+</p>
+
+<H3><a name="Python_nn74">36.12.1 Function annotation</a></H3>
+
+
+<p>
+The <tt>-py3</tt> option will enable function annotation support. When used
+SWIG is able to generate proxy method definitions like this:
+</p>
+
+<div class="code"><pre>
+ def foo(self, bar : "int"=0) -> "void" : ...
+</pre></div>
+
+<p>
+Also, even if without passing SWIG the <tt>-py3</tt> option, the parameter list
+still could be generated:
+</p>
+
+<div class="code"><pre>
+ def foo(self, bar=0): ...
+</pre></div>
+
+<p>
+But for overloaded function or method, the parameter list would fallback to
+<tt>*args</tt> or <tt>self, *args</tt>, and <tt>**kwargs</tt> may be append
+depend on whether you enabled the keyword argument. This fallback is due to
+all overloaded functions share the same function in SWIG generated proxy class.
+</p>
+
+<p>
+For detailed usage of function annotation, see
+<a href="https://www.python.org/dev/peps/pep-3107/">PEP 3107</a>.
+</p>
+
+<H3><a name="Python_nn75">36.12.2 Buffer interface</a></H3>
+
+
+<p>
+Buffer protocols were revised in Python 3. SWIG also gains a series of
+new typemaps to support buffer interfaces. These typemap macros are
+defined in <tt>pybuffer.i</tt>, which must be included in order to use them.
+By using these typemaps, your wrapped function will be able to
+accept any Python object that exposes a suitable buffer interface.
+</p>
+
+<p>
+For example, the <tt>get_path()</tt> function puts the path string
+into the memory pointed to by its argument:
+</p>
+
+<div class="code"><pre>
+void get_path(char *s);
+</pre></div>
+
+<p>
+Then you can write a typemap like this: (the following example is
+applied to both Python 3.0 and 2.6, since the <tt>bytearray</tt> type
+is backported to 2.6.
+</p>
+
+
+<div class="code"><pre>
+%include <pybuffer.i>
+%pybuffer_mutable_string(char *str);
+void get_path(char *s);
+</pre></div>
+
+<p>
+And then on the Python side the wrapped <tt>get_path</tt> could be used in this
+way:
+</p>
+
+<div class="targetlang"><pre>
+>>> p = bytearray(10)
+>>> get_path(p)
+>>> print(p)
+bytearray(b'/Foo/Bar/\x00')
+</pre></div>
+
+<p>
+The macros defined in <tt>pybuffer.i</tt> are similar to those in
+<tt>cstring.i</tt>:
+</p>
+
+<p>
+<b>%pybuffer_mutable_binary(parm, size_parm)</b>
+</p>
+
+<div class="indent">
+
+<p>
The macro can be used to generate a typemap which maps a buffer of an
object to a pointer provided by <tt>parm</tt> and a size argument
provided by <tt>size_parm</tt>. For example:
</div>
-<H3><a name="Python_nn76"></a>34.12.3 Abstract base classes</H3>
+<H3><a name="Python_nn76">36.12.3 Abstract base classes</a></H3>
<p>
<p>
For details of abstract base class, please see
-<a href="http://www.python.org/dev/peps/pep-3119/">PEP 3119</a>.
+<a href="https://www.python.org/dev/peps/pep-3119/">PEP 3119</a>.
+</p>
+
+<H3><a name="Python_nn77">36.12.4 Byte string output conversion</a></H3>
+
+
+<p>
+By default, any byte string (<tt>char*</tt> or <tt>std::string</tt>) returned
+from C or C++ code is decoded to text as UTF-8. This decoding uses the
+<tt>surrogateescape</tt> error handler under Python 3.1 or higher -- this
+error handler decodes invalid byte sequences to high surrogate characters
+in the range U+DC80 to U+DCFF.
+
+As an example, consider the following SWIG interface, which exposes a byte
+string that cannot be completely decoded as UTF-8:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%include <std_string.i>
+
+%inline %{
+
+const char* non_utf8_c_str(void) {
+ return "h\xe9llo w\xc3\xb6rld";
+}
+
+%}
+</pre></div>
+
+<p>
+When this method is called from Python 3, the return value is the following
+text string:
+</p>
+
+<div class="targetlang"><pre>
+>>> s = example.non_utf8_c_str()
+>>> s
+'h\udce9llo wörld'
+</pre></div>
+
+<p>
+Since the C string contains bytes that cannot be decoded as UTF-8, those raw
+bytes are represented as high surrogate characters that can be used to obtain
+the original byte sequence:
+</p>
+
+<div class="targetlang"><pre>
+>>> b = s.encode('utf-8', errors='surrogateescape')
+>>> b
+b'h\xe9llo w\xc3\xb6rld'
+</pre></div>
+
+<p>
+One can then attempt a different encoding, if desired (or simply leave the
+byte string as a raw sequence of bytes for use in binary protocols):
+</p>
+
+<div class="targetlang"><pre>
+>>> b.decode('latin-1')
+'héllo wörld'
+</pre></div>
+
+<p>
+Note, however, that text strings containing surrogate characters are rejected
+with the default <tt>strict</tt> codec error handler. For example:
+</p>
+
+<div class="targetlang"><pre>
+>>> with open('test', 'w') as f:
+... print(s, file=f)
+...
+Traceback (most recent call last):
+ File "<stdin>", line 2, in <module>
+UnicodeEncodeError: 'utf-8' codec can't encode character '\udce9' in position 1: surrogates not allowed
+</pre></div>
+
+<p>
+This requires the user to check most strings returned by SWIG bindings, but
+the alternative is for a non-UTF8 byte string to be completely inaccessible
+in Python 3 code.
+</p>
+
+<p>
+For more details about the <tt>surrogateescape</tt> error handler, please see
+<a href="https://www.python.org/dev/peps/pep-0383/">PEP 383</a>.
+</p>
+
+<p>
+In some cases, users may wish to instead handle all byte strings as bytes
+objects in Python 3. This can be accomplished by adding
+<tt>SWIG_PYTHON_STRICT_BYTE_CHAR</tt> to the generated code:
+</p>
+
+<div class="code"><pre>
+%module char_to_bytes
+%begin %{
+#define SWIG_PYTHON_STRICT_BYTE_CHAR
+%}
+
+char *charstring(char *s) {
+ return s;
+}
+</pre></div>
+
+<p>
+This will modify the behavior so that only Python 3 bytes objects will be
+accepted and converted to a C/C++ string, and any string returned from C/C++
+will be converted to a bytes object in Python 3:
+</p>
+
+<div class="targetlang"><pre>
+>>> from char_to_bytes import *
+>>> charstring(b"hi") # Byte string
+b'hi'
+>>> charstring("hi") # Unicode string
+Traceback (most recent call last):
+ File "<stdin>", line 1, in ?
+TypeError: in method 'charstring', argument 1 of type 'char *'
+</pre></div>
+
+<p>
+Note that in Python 2, defining <tt>SWIG_PYTHON_STRICT_BYTE_CHAR</tt> has no
+effect, since strings in Python 2 are equivalent to Python 3 bytes objects.
+However, there is a similar capability to force unicode-only handling for
+wide characters C/C++ strings (<tt>wchar_t *</tt> or <tt>std::wstring</tt>
+types) in Python 2. By default, in Python 2 both strings and unicode strings
+are converted to C/C++ wide strings, and returned wide strings are converted
+to a Python unicode string. To instead only convert unicode strings to wide
+strings, users can add <tt>SWIG_PYTHON_STRICT_UNICODE_WCHAR</tt> to the
+generated code:
+</p>
+
+<div class="code"><pre>
+%module wchar_to_unicode
+%begin %{
+#define SWIG_PYTHON_STRICT_UNICODE_WCHAR
+%}
+
+wchar_t *wcharstring(wchar_t *s) {
+ return s;
+}
+</pre></div>
+
+<p>
+This ensures that only unicode strings are accepted by wcharstring in both
+Python 2 and Python 3:
+</p>
+
+<div class="targetlang"><pre>
+>>> from wchar_to_unicode import *
+>>> wcharstring(u"hi") # Unicode string
+u'hi'
+>>> wcharstring(b"hi") # Byte string
+Traceback (most recent call last):
+ File "<stdin>", line 1, in ?
+TypeError: in method 'charstring', argument 1 of type 'wchar_t *'
+</pre></div>
+
+<p>
+By defining both <tt>SWIG_PYTHON_STRICT_BYTE_CHAR</tt> and
+<tt>SWIG_PYTHON_STRICT_UNICODE_WCHAR</tt>, Python wrapper code can support
+overloads taking both std::string (as Python bytes) and std::wstring
+(as Python unicode).
+</p>
+
+<H3><a name="Python_2_unicode">36.12.5 Python 2 Unicode</a></H3>
+
+
+<p>
+A Python 3 string is a Unicode string so by default a Python 3 string that contains Unicode
+characters passed to C/C++ will be accepted and converted to a C/C++ string
+(<tt>char *</tt> or <tt>std::string</tt> types).
+A Python 2 string is not a unicode string by default and should a Unicode string be
+passed to C/C++ it will fail to convert to a C/C++ string
+(<tt>char *</tt> or <tt>std::string</tt> types).
+The Python 2 behavior can be made more like Python 3 by defining
+<tt>SWIG_PYTHON_2_UNICODE</tt> when compiling the generated C/C++ code.
+By default when the following is wrapped:
+</p>
+
+<div class="code"><pre>
+%module unicode_strings
+char *charstring(char *s) {
+ return s;
+}
+</pre></div>
+
+<p>
+An error will occur when using Unicode strings in Python 2:
+</p>
+
+<div class="targetlang"><pre>
+>>> from unicode_strings import *
+>>> charstring("hi")
+'hi'
+>>> charstring(u"hi")
+Traceback (most recent call last):
+ File "<stdin>", line 1, in ?
+TypeError: in method 'charstring', argument 1 of type 'char *'
+</pre></div>
+
+<p>
+When the <tt>SWIG_PYTHON_2_UNICODE</tt> macro is added to the generated code:
+</p>
+
+<div class="code"><pre>
+%module unicode_strings
+%begin %{
+#define SWIG_PYTHON_2_UNICODE
+%}
+
+char *charstring(char *s) {
+ return s;
+}
+</pre></div>
+
+<p>
+Unicode strings will be successfully accepted and converted from UTF-8,
+but note that they are returned as a normal Python 2 string:
+</p>
+
+<div class="targetlang"><pre>
+>>> from unicode_strings import *
+>>> charstring("hi")
+'hi'
+>>> charstring(u"hi")
+'hi'
+>>>
+</pre></div>
+
+<p>
+Note that defining both <tt>SWIG_PYTHON_2_UNICODE</tt> and
+<tt>SWIG_PYTHON_STRICT_BYTE_CHAR</tt> at the same time is not allowed, since
+the first is allowing unicode conversion and the second is explicitly
+prohibiting it.
</p>
</body>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and R</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="R"></a>35 SWIG and R</H1>
+<H1><a name="R">37 SWIG and R</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
with gcc. The R bindings also work on Microsoft Windows using Visual C++.
</p>
-<H2><a name="R_nn2"></a>35.1 Bugs</H2>
+<H2><a name="R_nn2">37.1 Bugs</a></H2>
<p>
<li>C Array wrappings
</ul>
-<H2><a name="R_nn3"></a>35.2 Using R and SWIG</H2>
+<H2><a name="R_nn3">37.2 Using R and SWIG</a></H2>
<p>
These two files can be loaded in any order
</p>
-<H2><a name="R_nn4"></a>35.3 Precompiling large R files</H2>
+<p>
+ If you are compiling code yourself (not using R itself), there are a few things to watch out for:
+</p>
+
+<ul>
+<li>The output shared library name (to the left of the file extension) MUST match the module name, or alternatively, you can also set the -package NAME command line argument. See swig -r -help for more information
+<li>If you do not set the output file name appropriately, you might see errors like
+<div class="shell">
+<pre>
+> fact(4)
+Error in .Call("R_swig_fact", s_arg1, as.logical(.copy), PACKAGE = "example") :
+ "R_swig_fact" not available for .Call() for package "example"
+</pre>
+</div>
+<li>Make sure the architecture of the shared library(x64 for instance), matches the architecture of the R program you want to load your shared library into
+</ul>
+
+<H2><a name="R_nn4">37.3 Precompiling large R files</a></H2>
In cases where the R file is large, one make save a lot of loading
-<H2><a name="R_nn5"></a>35.4 General policy</H2>
+<H2><a name="R_nn5">37.4 General policy</a></H2>
<p>
to provide R syntax.
</p>
-<H2><a name="R_language_conventions"></a>35.5 Language conventions</H2>
+<H2><a name="R_language_conventions">37.5 Language conventions</a></H2>
<p>
slices)
</p>
-<H2><a name="R_nn6"></a>35.6 C++ classes</H2>
+<H2><a name="R_nn6">37.6 C++ classes</a></H2>
<p>
of the proxy class baggage you see in other languages.
</p>
-<H2><a name="R_nn7"></a>35.7 Enumerations</H2>
+<H2><a name="R_nn7">37.7 Enumerations</a></H2>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
- <title>SWIG and Ruby</title>
- <link rel="stylesheet" type="text/css" href="style.css">
+<title>SWIG and Ruby</title>
+<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Ruby"></a>36 SWIG and Ruby</H1>
+<H1><a name="Ruby">38 SWIG and Ruby</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#Ruby_C_STL_Functors">C++ STL Functors</a>
<li><a href="#Ruby_C_Iterators">C++ STL Iterators</a>
<li><a href="#Ruby_nn24">C++ Smart Pointers</a>
+<ul>
+<li><a href="#Ruby_smart_pointers_shared_ptr">The shared_ptr Smart Pointer</a>
+<li><a href="#Ruby_smart_pointers_generic">Generic Smart Pointers</a>
+</ul>
<li><a href="#Ruby_nn25">Cross-Language Polymorphism</a>
<ul>
<li><a href="#Ruby_nn26">Exception Unrolling</a>
<p>This chapter describes SWIG's support of Ruby.</p>
-<H2><a name="Ruby_nn2"></a>36.1 Preliminaries</H2>
+<H2><a name="Ruby_nn2">38.1 Preliminaries</a></H2>
-<p> SWIG 1.3 is known to work with Ruby versions 1.6 and later.
+<p> SWIG 3.0 is known to work with Ruby versions 1.8 and later.
Given the choice, you should use the latest stable version of Ruby. You
should also determine if your system supports shared libraries and
dynamic loading. SWIG will work with or without dynamic loading, but
chapter. It is also assumed that the reader has a basic understanding
of Ruby. </p>
-<H3><a name="Ruby_nn3"></a>36.1.1 Running SWIG</H3>
+<H3><a name="Ruby_nn3">38.1.1 Running SWIG</a></H3>
<p> To build a Ruby module, run SWIG using the <tt>-ruby</tt>
build a Ruby extension module. To finish building the module, you need
to compile this file and link it with the rest of your program. </p>
-<H3><a name="Ruby_nn4"></a>36.1.2 Getting the right header files</H3>
+<H3><a name="Ruby_nn4">38.1.2 Getting the right header files</a></H3>
<p> In order to compile the wrapper code, the compiler needs the <tt>ruby.h</tt>
<div class="code shell diagram">
<pre>/usr/lib/ruby/1.8/x86_64-linux-gnu/ruby.h
-/usr/local/lib/ruby/1.6/i686-linux/ruby.h
+/usr/include/ruby-2.1.0/ruby.h
</pre>
</div>
<div class="code shell">
<pre>$ ruby -e 'puts $:.join("\n")'
-/usr/local/lib/ruby/site_ruby/1.6 /usr/local/lib/ruby/site_ruby/1.6/i686-linux
-/usr/local/lib/ruby/site_ruby /usr/local/lib/ruby/1.6 /usr/local/lib/ruby/1.6/i686-linux .
+/usr/local/lib/site_ruby/2.1.0
+/usr/local/lib/x86_64-linux-gnu/site_ruby
+/usr/local/lib/site_ruby
+/usr/lib/ruby/vendor_ruby/2.1.0
+/usr/lib/x86_64-linux-gnu/ruby/vendor_ruby/2.1.0
+/usr/lib/ruby/vendor_ruby
+/usr/lib/ruby/2.1.0
+/usr/lib/x86_64-linux-gnu/ruby/2.1.0
</pre>
</div>
-<H3><a name="Ruby_nn5"></a>36.1.3 Compiling a dynamic module</H3>
+<H3><a name="Ruby_nn5">38.1.3 Compiling a dynamic module</a></H3>
<p> Ruby extension modules are typically compiled into shared
<div class="code shell">
<pre>$ swig -ruby example.i
-$ gcc -c example.c
-$ gcc -c example_wrap.c -I/usr/local/lib/ruby/1.6/i686-linux
+$ gcc -O2 -fPIC -c example.c
+$ gcc -O2 -fPIC -c example_wrap.c -I/usr/include/ruby-2.1.0
$ gcc -shared example.o example_wrap.o -o example.so
</pre>
</div>
-<p> For other platforms it may be necessary to compile with the <tt>-fPIC</tt>
-option to generate position-independent code. If in doubt, consult the
+<p>
+The -fPIC option tells GCC to generate position-independent code (PIC)
+which is required for most architectures (it's not vital on x86, but
+still a good idea as it allows code pages from the library to be shared between
+processes). Other compilers may need a different option specified instead of
+-fPIC.
+</p>
+
+<p>
+If in doubt, consult the
manual pages for your compiler and linker to determine the correct set
of options. You might also check the <a href="http://www.dabeaz.com/cgi-bin/wiki.pl">SWIG Wiki</a>
for additional information. </p>
-<H3><a name="Ruby_nn6"></a>36.1.4 Using your module</H3>
+<H3><a name="Ruby_nn6">38.1.4 Using your module</a></H3>
<p> Ruby <i>module</i> names must be capitalized,
<p> will result in an extension module using the feature name
"example" and Ruby module name "Example". </p>
-<H3><a name="Ruby_nn7"></a>36.1.5 Static linking</H3>
+<H3><a name="Ruby_nn7">38.1.5 Static linking</a></H3>
<p> An alternative approach to dynamic linking is to rebuild the
file, adding your directory to the list of extensions in the file, and
finally rebuilding Ruby. </p>
-<H3><a name="Ruby_nn8"></a>36.1.6 Compilation of C++ extensions</H3>
+<H3><a name="Ruby_nn8">38.1.6 Compilation of C++ extensions</a></H3>
<p> On most machines, C++ extension modules should be linked
<div class="code shell">
<pre>
$ swig -c++ -ruby example.i
-$ g++ -c example.cxx
-$ g++ -c example_wrap.cxx -I/usr/local/lib/ruby/1.6/i686-linux
+$ g++ -fPIC -c example.cxx
+$ g++ -fPIC -c example_wrap.cxx -I/usr/include/ruby-2.1.0
$ g++ -shared example.o example_wrap.o -o example.so
</pre>
</div>
create_makefile('example')</pre>
</div>
-<H2><a name="Ruby_nn9"></a>36.2 Building Ruby Extensions under Windows 95/NT</H2>
+<H2><a name="Ruby_nn9">38.2 Building Ruby Extensions under Windows 95/NT</a></H2>
<p> Building a SWIG extension to Ruby under Windows 95/NT is
distribution to the Ruby package, as you will need the Ruby header
files. </p>
-<H3><a name="Ruby_nn10"></a>36.2.1 Running SWIG from Developer Studio</H3>
+<H3><a name="Ruby_nn10">38.2.1 Running SWIG from Developer Studio</a></H3>
<p> If you are developing your application within Microsoft
</pre>
</div>
-<H2><a name="Ruby_nn11"></a>36.3 The Ruby-to-C/C++ Mapping</H2>
+<H2><a name="Ruby_nn11">38.3 The Ruby-to-C/C++ Mapping</a></H2>
<p> This section describes the basics of how SWIG maps C or C++
declarations in your SWIG interface files to Ruby constructs. </p>
-<H3><a name="Ruby_nn12"></a>36.3.1 Modules</H3>
+<H3><a name="Ruby_nn12">38.3.1 Modules</a></H3>
<p> The SWIG <tt>%module</tt> directive specifies
names of your constants, classes and methods don't conflict with any of
Ruby's built-in names. </p>
-<H3><a name="Ruby_nn13"></a>36.3.2 Functions</H3>
+<H3><a name="Ruby_nn13">38.3.2 Functions</a></H3>
<p> Global functions are wrapped as Ruby module methods. For
24</pre>
</div>
-<H3><a name="Ruby_nn14"></a>36.3.3 Variable Linking</H3>
+<H3><a name="Ruby_nn14">38.3.3 Variable Linking</a></H3>
<p> C/C++ global variables are wrapped as a pair of singleton
effect until it is explicitly disabled using <tt>%mutable</tt>.
</p>
-<H3><a name="Ruby_nn15"></a>36.3.4 Constants</H3>
+<H3><a name="Ruby_nn15">38.3.4 Constants</a></H3>
<p> C/C++ constants are wrapped as module constants initialized
3.14159</pre>
</div>
-<H3><a name="Ruby_nn16"></a>36.3.5 Pointers</H3>
+<H3><a name="Ruby_nn16">38.3.5 Pointers</a></H3>
<p> "Opaque" pointers to arbitrary C/C++ types (i.e. types that
<p> A <tt>NULL</tt> pointer is always represented by
the Ruby <tt>nil</tt> object. </p>
-<H3><a name="Ruby_nn17"></a>36.3.6 Structures</H3>
+<H3><a name="Ruby_nn17">38.3.6 Structures</a></H3>
<p> C/C++ structs are wrapped as Ruby classes, with accessor
</div>
<p> gets wrapped as a <tt>Vector</tt> class, with
-Ruby instance methods <tt>x</tt>, <tt> x=</tt>,
+Ruby instance methods <tt>x</tt>, <tt>x=</tt>,
<tt>y</tt> and <tt>y=</tt>. These methods can
be used to access structure data from Ruby as follows: </p>
}</pre>
</div>
-<H3><a name="Ruby_nn18"></a>36.3.7 C++ classes</H3>
+<H3><a name="Ruby_nn18">38.3.7 C++ classes</a></H3>
<p> Like structs, C++ classes are wrapped by creating a new Ruby
3</pre>
</div>
-<H3><a name="Ruby_nn19"></a>36.3.8 C++ Inheritance</H3>
+<H3><a name="Ruby_nn19">38.3.8 C++ Inheritance</a></H3>
<p> The SWIG type-checker is fully aware of C++ inheritance.
(i.e. they exhibit <a href="http://c2.com/cgi/wiki?DuckTyping">"Duck
Typing"</a>). </p>
-<H3><a name="Ruby_nn20"></a>36.3.9 C++ Overloaded Functions</H3>
+<H3><a name="Ruby_nn20">38.3.9 C++ Overloaded Functions</a></H3>
<p> C++ overloaded functions, methods, and constructors are
<p>Please refer to the <a href="SWIGPlus.html#SWIGPlus">"SWIG
and C++"</a> chapter for more information about overloading. </p>
-<H3><a name="Ruby_nn21"></a>36.3.10 C++ Operators</H3>
+<H3><a name="Ruby_nn21">38.3.10 C++ Operators</a></H3>
<p> For the most part, overloaded operators are handled
is discussed in the <a href="#Ruby_operator_overloading">section
on operator overloading</a>. </p>
-<H3><a name="Ruby_nn22"></a>36.3.11 C++ namespaces</H3>
+<H3><a name="Ruby_nn22">38.3.11 C++ namespaces</a></H3>
<p> SWIG is aware of C++ namespaces, but namespace names do not
program utilizes thousands of small deeply nested namespaces each with
identical symbol names, well, then you get what you deserve. </p>
-<H3><a name="Ruby_nn23"></a>36.3.12 C++ templates</H3>
+<H3><a name="Ruby_nn23">38.3.12 C++ templates</a></H3>
<p> C++ templates don't present a huge problem for SWIG. However,
4</pre>
</div>
-<H3><a name="Ruby_nn23_1"></a>36.3.13 C++ Standard Template Library (STL)</H3>
+<H3><a name="Ruby_nn23_1">38.3.13 C++ Standard Template Library (STL)</a></H3>
<p> On a related note, the standard SWIG library contains a
shown in these examples. More details can be found in the <a href="SWIGPlus.html#SWIGPlus">SWIG and C++</a>
chapter.</p>
-<H3><a name="Ruby_C_STL_Functors"></a>36.3.14 C++ STL Functors</H3>
+<H3><a name="Ruby_C_STL_Functors">38.3.14 C++ STL Functors</a></H3>
<p>Some containers in the STL allow you to modify their default
behavior by using so called functors or function objects.
-Functors are often just a very simple struct with<tt> operator()</tt>
+Functors are often just a very simple struct with <tt>operator()</tt>
redefined or an actual C/C++ function. This allows you, for
example, to always keep the sort order of a STL container to your
liking.</p>
<tt>std::multiset</tt>
and <tt>std::multimap</tt>.</p>
-<p>The functors in swig are called<tt> swig::UnaryFunction</tt>
+<p>The functors in swig are called <tt>swig::UnaryFunction</tt>
and <tt>swig::BinaryFunction</tt>.
For C++ predicates (ie. functors that must return bool as a result) <tt>swig::UnaryPredicate</tt>
%include <std_set.i>
-%typemap(IntSet) std::set< int, swig::BinaryPredicate >;
+%template(IntSet) std::set< int, swig::BinaryPredicate >;
</pre></div>
<p>You can then use the set from Ruby with or without a proc
</pre>
</div>
-<H3><a name="Ruby_C_Iterators"></a>36.3.15 C++ STL Iterators</H3>
+<H3><a name="Ruby_C_Iterators">38.3.15 C++ STL Iterators</a></H3>
<p>The STL is well known for the use of iterators. There
modify the values.</p>
<p>The Ruby STL wrappings support both type of iterators by using
-a proxy class in-between. This proxy class is <tt>swig::Iterator or
-swig::ConstIterator. </tt> Derived from them are template
+a proxy class in-between. This proxy class is <tt>swig::Iterator</tt> or
+<tt>swig::ConstIterator</tt>. Derived from them are template
classes that need to be initialized with the actual iterator for the
container you are wrapping and often times with the beginning and
ending points of the iteration range.</p>
</pre>
</div>
-<p>If you'd rather have STL classes without any iterators, you should define<tt> -DSWIG_NO_EXPORT_ITERATOR_METHODS </tt>when running swig.</p>
+<p>If you'd rather have STL classes without any iterators, you should define <tt>-DSWIG_NO_EXPORT_ITERATOR_METHODS</tt> when running swig.</p>
+
+<H3><a name="Ruby_nn24">38.3.16 C++ Smart Pointers</a></H3>
+
+
+<H4><a name="Ruby_smart_pointers_shared_ptr">38.3.16.1 The shared_ptr Smart Pointer</a></H4>
+
+
+<p>
+The C++11 standard provides <tt>std::shared_ptr</tt> which was derived from the Boost
+implementation, <tt>boost::shared_ptr</tt>.
+Both of these are available for Ruby in the SWIG library and usage is outlined
+in the <a href="Library.html#Library_std_shared_ptr">shared_ptr smart pointer</a> library section.
+</p>
+
-<H3><a name="Ruby_nn24"></a>36.3.16 C++ Smart Pointers</H3>
+<H4><a name="Ruby_smart_pointers_generic">38.3.16.2 Generic Smart Pointers</a></H4>
<p> In certain C++ programs, it is common to use classes that
<pre>irb(main):004:0> <b>f = p.__deref__()</b> # Returns underlying Foo *</pre>
</div>
-<H3><a name="Ruby_nn25"></a>36.3.17 Cross-Language Polymorphism</H3>
+<H3><a name="Ruby_nn25">38.3.17 Cross-Language Polymorphism</a></H3>
<p> SWIG's Ruby module supports cross-language polymorphism
section just notes the differences that you need to be aware of when
using this feature with Ruby. </p>
-<H4><a name="Ruby_nn26"></a>36.3.17.1 Exception Unrolling</H4>
+<H4><a name="Ruby_nn26">38.3.17.1 Exception Unrolling</a></H4>
<p> Whenever a C++ director class routes one of its virtual
function from Ruby's C API. If any Ruby exception is raised, it will be
caught here and a C++ exception is raised in its place. </p>
-<H2><a name="Ruby_nn27"></a>36.4 Naming</H2>
+<H2><a name="Ruby_nn27">38.4 Naming</a></H2>
<p>Ruby has several common naming conventions. Constants are
by SWIG, it is turned off by default in SWIG 1.3.28. However, it is
planned to become the default option in future releases.</p>
-<H3><a name="Ruby_nn28"></a>36.4.1 Defining Aliases</H3>
+<H3><a name="Ruby_nn28">38.4.1 Defining Aliases</a></H3>
<p> It's a fairly common practice in the Ruby built-ins and
on <a href="Customization.html#Customization">"Customization
Features"</a>) for more details).</p>
-<H3><a name="Ruby_nn29"></a>36.4.2 Predicate Methods</H3>
+<H3><a name="Ruby_nn29">38.4.2 Predicate Methods</a></H3>
<p> Ruby methods that return a boolean value and end in a
used for other kinds of features apply (see the chapter on <a href="Customization.html#Customization">"Customization
Features"</a>) for more details). </p>
-<H3><a name="Ruby_nn30"></a>36.4.3 Bang Methods</H3>
+<H3><a name="Ruby_nn30">38.4.3 Bang Methods</a></H3>
<p> Ruby methods that modify an object in-place and end in an
used for other kinds of features apply (see the chapter on <a href="Customization.html#Customization">"Customization
Features"</a>) for more details). </p>
-<H3><a name="Ruby_nn31"></a>36.4.4 Getters and Setters</H3>
+<H3><a name="Ruby_nn31">38.4.4 Getters and Setters</a></H3>
<p> Often times a C++ library will expose properties through
%rename("value=") Foo::setValue(int value);</pre>
</div>
-<H2><a name="Ruby_nn32"></a>36.5 Input and output parameters</H2>
+<H2><a name="Ruby_nn32">38.5 Input and output parameters</a></H2>
<p> A common problem in some C programs is handling parameters
<pre>r, c = Example.get_dimensions(m)</pre>
</div>
-<H2><a name="Ruby_nn33"></a>36.6 Exception handling </H2>
+<H2><a name="Ruby_nn33">38.6 Exception handling </a></H2>
-<H3><a name="Ruby_nn34"></a>36.6.1 Using the %exception directive </H3>
+<H3><a name="Ruby_nn34">38.6.1 Using the %exception directive </a></H3>
<p>The SWIG <tt>%exception</tt> directive can be
limited to C++ exception handling. See the chapter on <a href="Customization.html#Customization">Customization
Features</a> for more examples.</p>
-<H3><a name="Ruby_nn34_2"></a>36.6.2 Handling Ruby Blocks </H3>
+<H3><a name="Ruby_nn34_2">38.6.2 Handling Ruby Blocks </a></H3>
<p>One of the highlights of Ruby and most of its standard library
<p>For more information on typemaps, see <a href="#Ruby_nn37">Typemaps</a>.</p>
-<H3><a name="Ruby_nn35"></a>36.6.3 Raising exceptions </H3>
+<H3><a name="Ruby_nn35">38.6.3 Raising exceptions </a></H3>
<p>There are three ways to raise exceptions from C++ code to
is the exception type. You can raise a custom exception type or one of
the built-in Ruby exception types.</p>
-<H3><a name="Ruby_nn36"></a>36.6.4 Exception classes </H3>
+<H3><a name="Ruby_nn36">38.6.4 Exception classes </a></H3>
<p>Starting with SWIG 1.3.28, the Ruby module supports the <tt>%exceptionclass</tt>
<p>For another example look at swig/Examples/ruby/exception_class.
</p>
-<H2><a name="Ruby_nn37"></a>36.7 Typemaps</H2>
+<H2><a name="Ruby_nn37">38.7 Typemaps</a></H2>
<p> This section describes how you can modify SWIG's default
in most cases. Typemaps are only used if you want to change some aspect
of the primitive C-Ruby interface.</p>
-<H3><a name="Ruby_nn38"></a>36.7.1 What is a typemap?</H3>
+<H3><a name="Ruby_nn38">38.7.1 What is a typemap?</a></H3>
<p> A typemap is nothing more than a code generation rule that is
2</pre>
</div>
-<H3><a name="Ruby_Typemap_scope"></a>36.7.2 Typemap scope</H3>
+<H3><a name="Ruby_Typemap_scope">38.7.2 Typemap scope</a></H3>
<p> Once defined, a typemap remains in effect for all of the
};</pre>
</div>
-<H3><a name="Ruby_Copying_a_typemap"></a>36.7.3 Copying a typemap</H3>
+<H3><a name="Ruby_Copying_a_typemap">38.7.3 Copying a typemap</a></H3>
<p> A typemap is copied by using assignment. For example:</p>
%apply (char *buf, int len) { (char *buffer, int size) }; // Multiple arguments</pre>
</div>
-<H3><a name="Ruby_Deleting_a_typemap"></a>36.7.4 Deleting a typemap</H3>
+<H3><a name="Ruby_Deleting_a_typemap">38.7.4 Deleting a typemap</a></H3>
<p> A typemap can be deleted by simply defining no code. For
will make that type unusable unless you also define a new set of
typemaps immediately after the clear operation.</p>
-<H3><a name="Ruby_Placement_of_typemaps"></a>36.7.5 Placement of typemaps</H3>
+<H3><a name="Ruby_Placement_of_typemaps">38.7.5 Placement of typemaps</a></H3>
<p> Typemap declarations can be declared in the global scope,
string</tt>
.</p>
-<H3><a name="Ruby_nn39"></a>36.7.6 Ruby typemaps</H3>
+<H3><a name="Ruby_nn39">38.7.6 Ruby typemaps</a></H3>
<p>The following list details all of the typemap methods that
can be used by the Ruby module: </p>
-<H4><a name="Ruby_in_typemap"></a>36.7.6.1 "in" typemap</H4>
+<H4><a name="Ruby_in_typemap">38.7.6.1 "in" typemap</a></H4>
<p>Converts Ruby objects to input
<p> At this time, only zero or one arguments may be converted.</p>
-<H4><a name="Ruby_typecheck_typemap"></a>36.7.6.2 "typecheck" typemap</H4>
+<H4><a name="Ruby_typecheck_typemap">38.7.6.2 "typecheck" typemap</a></H4>
<p> The "typecheck" typemap is used to support overloaded
"typecheck" typemaps. More details about this follow in a later section
on "Typemaps and Overloading."</p>
-<H4><a name="Ruby_out_typemap"></a>36.7.6.3 "out" typemap</H4>
+<H4><a name="Ruby_out_typemap">38.7.6.3 "out" typemap</a></H4>
<p>Converts return value of a C function
</table>
</div>
-<H4><a name="Ruby_arginit_typemap"></a>36.7.6.4 "arginit" typemap</H4>
+<H4><a name="Ruby_arginit_typemap">38.7.6.4 "arginit" typemap</a></H4>
<p> The "arginit" typemap is used to set the initial value of a
}</pre>
</div>
-<H4><a name="Ruby_default_typemap"></a>36.7.6.5 "default" typemap</H4>
+<H4><a name="Ruby_default_typemap">38.7.6.5 "default" typemap</a></H4>
<p> The "default" typemap is used to turn an argument into a
the value specified by this typemap as all arguments must be given.</p>
<p> Once a default typemap has been applied to an argument, all
-arguments that follow must have default values. See the <a href="http://www.swig.org/Doc1.3/SWIGDocumentation.html#SWIG_default_args">
+arguments that follow must have default values. See the <a href="SWIG.html#SWIG_default_args">
Default/optional arguments</a> section for further information on
default argument wrapping.</p>
-<H4><a name="Ruby_check_typemap"></a>36.7.6.6 "check" typemap</H4>
+<H4><a name="Ruby_check_typemap">38.7.6.6 "check" typemap</a></H4>
<p> The "check" typemap is used to supply value checking code
}</pre>
</div>
-<H4><a name="Ruby_argout_typemap_"></a>36.7.6.7 "argout" typemap</H4>
+<H4><a name="Ruby_argout_typemap_">38.7.6.7 "argout" typemap</a></H4>
<p> The "argout" typemap is used to return values from arguments.
<p> See the <tt>typemaps.i</tt> library for examples.</p>
-<H4><a name="Ruby_freearg_typemap_"></a>36.7.6.8 "freearg" typemap</H4>
+<H4><a name="Ruby_freearg_typemap_">38.7.6.8 "freearg" typemap</a></H4>
<p> The "freearg" typemap is used to cleanup argument data. It is
that may be used in other typemaps whenever a wrapper function needs to
abort prematurely.</p>
-<H4><a name="Ruby_newfree_typemap"></a>36.7.6.9 "newfree" typemap</H4>
+<H4><a name="Ruby_newfree_typemap">38.7.6.9 "newfree" typemap</a></H4>
<p> The "newfree" typemap is used in conjunction with the <tt>%newobject</tt>
<p> See <a href="Customization.html#Customization_ownership">Object
ownership and %newobject</a> for further details.</p>
-<H4><a name="Ruby_memberin_typemap"></a>36.7.6.10 "memberin" typemap</H4>
+<H4><a name="Ruby_memberin_typemap">38.7.6.10 "memberin" typemap</a></H4>
<p> The "memberin" typemap is used to copy data from<em> an
already provides a default implementation for arrays, strings, and
other objects.</p>
-<H4><a name="Ruby_varin_typemap"></a>36.7.6.11 "varin" typemap</H4>
+<H4><a name="Ruby_varin_typemap">38.7.6.11 "varin" typemap</a></H4>
<p> The "varin" typemap is used to convert objects in the target
language to C for the purposes of assigning to a C/C++ global variable.
This is implementation specific.</p>
-<H4><a name="Ruby_varout_typemap_"></a>36.7.6.12 "varout" typemap</H4>
+<H4><a name="Ruby_varout_typemap_">38.7.6.12 "varout" typemap</a></H4>
<p> The "varout" typemap is used to convert a C/C++ object to an
object in the target language when reading a C/C++ global variable.
This is implementation specific.</p>
-<H4><a name="Ruby_throws_typemap"></a>36.7.6.13 "throws" typemap</H4>
+<H4><a name="Ruby_throws_typemap">38.7.6.13 "throws" typemap</a></H4>
<p> The "throws" typemap is only used when SWIG parses a C++
<p> Note that if your methods do not have an exception
specification yet they do throw exceptions, SWIG cannot know how to
-deal with them. For a neat way to handle these, see the <a href="http://www.swig.org/Doc1.3/SWIGDocumentation.html#exception">Exception
+deal with them. For a neat way to handle these, see the <a href="Customization.html#Customization_exception">Exception
handling with %exception</a> section.</p>
-<H4><a name="Ruby_directorin_typemap"></a>36.7.6.14 directorin typemap</H4>
+<H4><a name="Ruby_directorin_typemap">38.7.6.14 directorin typemap</a></H4>
<p>Converts C++ objects in director
</table>
</div>
-<H4><a name="Ruby_directorout_typemap"></a>36.7.6.15 directorout typemap</H4>
+<H4><a name="Ruby_directorout_typemap">38.7.6.15 directorout typemap</a></H4>
<p>Converts Ruby objects in director
</p>
-<H4><a name="Ruby_directorargout_typemap"></a>36.7.6.16 directorargout typemap</H4>
+<H4><a name="Ruby_directorargout_typemap">38.7.6.16 directorargout typemap</a></H4>
<p>Output argument processing in director
</table>
</div>
-<H4><a name="Ruby_ret_typemap"></a>36.7.6.17 ret typemap</H4>
+<H4><a name="Ruby_ret_typemap">38.7.6.17 ret typemap</a></H4>
<p>Cleanup of function return values
</p>
-<H4><a name="Ruby_globalin_typemap"></a>36.7.6.18 globalin typemap</H4>
+<H4><a name="Ruby_globalin_typemap">38.7.6.18 globalin typemap</a></H4>
<p>Setting of C global variables
</p>
-<H3><a name="Ruby_nn40"></a>36.7.7 Typemap variables</H3>
+<H3><a name="Ruby_nn40">38.7.7 Typemap variables</a></H3>
<p>
<div class="indent">The Ruby name of the wrapper function
being created. </div>
-<H3><a name="Ruby_nn41"></a>36.7.8 Useful Functions</H3>
+<H3><a name="Ruby_nn41">38.7.8 Useful Functions</a></H3>
<p> When you write a typemap, you usually have to work directly
That should help you avoid having to rewrite a lot of typemaps
across multiple languages.</p>
-<H4><a name="Ruby_nn42"></a>36.7.8.1 C Datatypes to Ruby Objects</H4>
+<H4><a name="Ruby_nn42">38.7.8.1 C Datatypes to Ruby Objects</a></H4>
<div class="diagram">
</table>
</div>
-<H4><a name="Ruby_nn43"></a>36.7.8.2 Ruby Objects to C Datatypes</H4>
+<H4><a name="Ruby_nn43">38.7.8.2 Ruby Objects to C Datatypes</a></H4>
<p>Here, while the Ruby versions return the value directly, the SWIG
</table>
</div>
-<H4><a name="Ruby_nn44"></a>36.7.8.3 Macros for VALUE</H4>
+<H4><a name="Ruby_nn44">38.7.8.3 Macros for VALUE</a></H4>
<p> <tt>RSTRING_LEN(str)</tt> </p>
<div class="indent">pointer to array storage</div>
-<H4><a name="Ruby_nn45"></a>36.7.8.4 Exceptions</H4>
+<H4><a name="Ruby_nn45">38.7.8.4 Exceptions</a></H4>
<p> <tt>void rb_raise(VALUE exception, const char *fmt,
flag. The given format string <i>fmt</i> and remaining
arguments are interpreted as with <tt>printf()</tt>. </div>
-<H4><a name="Ruby_nn46"></a>36.7.8.5 Iterators</H4>
+<H4><a name="Ruby_nn46">38.7.8.5 Iterators</a></H4>
<p> <tt>void rb_iter_break()</tt> </p>
<div class="indent"> Equivalent to Ruby's <tt>throw</tt>.
</div>
-<H3><a name="Ruby_nn47"></a>36.7.9 Typemap Examples</H3>
+<H3><a name="Ruby_nn47">38.7.9 Typemap Examples</a></H3>
<p> This section includes a few examples of typemaps. For more
examples, you might look at the examples in the <tt>Example/ruby</tt>
directory. </p>
-<H3><a name="Ruby_nn48"></a>36.7.10 Converting a Ruby array to a char **</H3>
+<H3><a name="Ruby_nn48">38.7.10 Converting a Ruby array to a char **</a></H3>
<p> A common problem in many C programs is the processing of
the array, the "freearg" typemap is used to later release this memory
after the execution of the C function. </p>
-<H3><a name="Ruby_nn49"></a>36.7.11 Collecting arguments in a hash</H3>
+<H3><a name="Ruby_nn49">38.7.11 Collecting arguments in a hash</a></H3>
<p> Ruby's solution to the "keyword arguments" capability of some
program that uses the extension, can be found in the <tt>Examples/ruby/hashargs</tt>
directory of the SWIG distribution. </p>
-<H3><a name="Ruby_nn50"></a>36.7.12 Pointer handling</H3>
+<H3><a name="Ruby_nn50">38.7.12 Pointer handling</a></H3>
<p> Occasionally, it might be necessary to convert pointer values
}</pre>
</div>
-<H4><a name="Ruby_nn51"></a>36.7.12.1 Ruby Datatype Wrapping</H4>
+<H4><a name="Ruby_nn51">38.7.12.1 Ruby Datatype Wrapping</a></H4>
<p> <tt>VALUE Data_Wrap_Struct(VALUE class, void
type <i>c-type</i> from the data object <i>obj</i>
and assigns that pointer to <i>ptr</i>. </div>
-<H3><a name="Ruby_nn52"></a>36.7.13 Example: STL Vector to Ruby Array</H3>
+<H3><a name="Ruby_nn52">38.7.13 Example: STL Vector to Ruby Array</a></H3>
<p>Another use for macros and type maps is to create a Ruby array
which does much more than this. Refer to the section called
the<a href="#Ruby_nn23_1"> C++ Standard Template Library</a>.
-<H2><a name="Ruby_nn65"></a>36.8 Docstring Features</H2>
+<H2><a name="Ruby_nn65">38.8 Docstring Features</a></H2>
<p>
$ rdoc -r file_wrap.c
</pre></div>
-<H3><a name="Ruby_nn66"></a>36.8.1 Module docstring</H3>
+<H3><a name="Ruby_nn66">38.8.1 Module docstring</a></H3>
<p>
%module(docstring=DOCSTRING) xrc</pre>
</div>
-<H3><a name="Ruby_nn67"></a>36.8.2 %feature("autodoc")</H3>
+<H3><a name="Ruby_nn67">38.8.2 %feature("autodoc")</a></H3>
<p>Since SWIG does know everything about the function it wraps,
feature, described below.
</p>
-<H4><a name="Ruby_nn68"></a>36.8.2.1 %feature("autodoc", "0")</H4>
+<H4><a name="Ruby_nn68">38.8.2.1 %feature("autodoc", "0")</a></H4>
<p>
...</pre>
</div>
-<H4><a name="Ruby_autodoc1"></a>36.8.2.2 %feature("autodoc", "1")</H4>
+<H4><a name="Ruby_autodoc1">38.8.2.2 %feature("autodoc", "1")</a></H4>
<p>
...</pre>
</div>
-<H4><a name="Ruby_autodoc2"></a>36.8.2.3 %feature("autodoc", "2")</H4>
+<H4><a name="Ruby_autodoc2">38.8.2.3 %feature("autodoc", "2")</a></H4>
<p>
this:
</p>
-<H4><a name="Ruby_feature_autodoc3"></a>36.8.2.4 %feature("autodoc", "3")</H4>
+<H4><a name="Ruby_feature_autodoc3">38.8.2.4 %feature("autodoc", "3")</a></H4>
<p>
<pre>function_name(int x, int y, Foo foo=nil, Bar bar=nil) -> bool
Parameters:
- x - int
- y - int
- foo - Foo
- bar - Bar</pre>
+ x - int
+ y - int
+ foo - Foo
+ bar - Bar</pre>
</div>
-<H4><a name="Ruby_nn70"></a>36.8.2.5 %feature("autodoc", "docstring")</H4>
+<H4><a name="Ruby_nn70">38.8.2.5 %feature("autodoc", "docstring")</a></H4>
<p>
void GetPosition(int* OUTPUT, int* OUTPUT);</pre>
</div>
-<H3><a name="Ruby_nn71"></a>36.8.3 %feature("docstring")</H3>
+<H3><a name="Ruby_nn71">38.8.3 %feature("docstring")</a></H3>
<p>
If an item already has an autodoc string then it is combined with the
docstring and they are output together. </p>
-<H2><a name="Ruby_nn53"></a>36.9 Advanced Topics</H2>
+<H2><a name="Ruby_nn53">38.9 Advanced Topics</a></H2>
-<H3><a name="Ruby_operator_overloading"></a>36.9.1 Operator overloading</H3>
+<H3><a name="Ruby_operator_overloading">38.9.1 Operator overloading</a></H3>
<p> SWIG allows operator overloading with, by using the <tt>%extend</tt>
parses the expression <i>a != b</i> as <i>!(a == b)</i>.
</p>
-<H3><a name="Ruby_nn55"></a>36.9.2 Creating Multi-Module Packages</H3>
+<H3><a name="Ruby_nn55">38.9.2 Creating Multi-Module Packages</a></H3>
<p> The chapter on <a href="Modules.html#Modules">Working
<pre>$ <b>ruby extconf.rb</b>
creating Makefile
$ <b>make</b>
-g++ -fPIC -g -O2 -I. -I/usr/local/lib/ruby/1.7/i686-linux \
+g++ -fPIC -g -O2 -I. -I/usr/include/ruby-2.1.0 \
-I. -c shape_wrap.cxx
gcc -shared -L/usr/local/lib -o shape.so shape_wrap.o -L. \
-lruby -lruby -lc</pre>
5.0</pre>
</div>
-<H3><a name="Ruby_nn56"></a>36.9.3 Specifying Mixin Modules</H3>
+<H3><a name="Ruby_nn56">38.9.3 Specifying Mixin Modules</a></H3>
<p> The Ruby language doesn't support multiple inheritance, but
on <a href="Customization.html#Customization">"Customization
Features"</a>) for more details). </p>
-<H2><a name="Ruby_nn57"></a>36.10 Memory Management</H2>
+<H2><a name="Ruby_nn57">38.10 Memory Management</a></H2>
<p>One of the most common issues in generating SWIG bindings for
invoked. Clearly, developing a SWIG wrapper requires a thorough
understanding of how the underlying library manages memory.</p>
-<H3><a name="Ruby_nn58"></a>36.10.1 Mark and Sweep Garbage Collector </H3>
+<H3><a name="Ruby_nn58">38.10.1 Mark and Sweep Garbage Collector </a></H3>
<p>Ruby uses a mark and sweep garbage collector. When the garbage
reference other objects. This process will continue until all active
objects have been "marked." After the mark phase comes the sweep phase.
In the sweep phase, all objects that have not been marked will be
-garbage collected. For more information about the Ruby garbage
-collector please refer to <a href="http://rubygarden.org/ruby/ruby?GCAndExtensions"> <span style="text-decoration: underline;">http://rubygarden.org/ruby/ruby?GCAndExtensions</span></a>.</p>
+garbage collected. </p>
<p>The Ruby C/API provides extension developers two hooks into
the garbage collector - a "mark" function and a "sweep" function. By
C++ struct, then a "free" function must be defined that deallocates
this memory. </p>
-<H3><a name="Ruby_nn59"></a>36.10.2 Object Ownership</H3>
+<H3><a name="Ruby_nn59">38.10.2 Object Ownership</a></H3>
<p>As described above, memory management depends on clearly
C++ constructor, thus creating a new <tt>foo</tt> object.
By default, SWIG will assign the new Ruby object a "free" function.
When the Ruby object is garbage collected, the "free" function will be
-called. It in turn will call <tt>Foo's</tt> destructor.</p>
+called. It in turn will call <tt>Foo</tt>'s destructor.</p>
<p>Next, consider this code: </p>
<p> This code can be seen in swig/examples/ruby/tracking.</p>
-<H3><a name="Ruby_nn60"></a>36.10.3 Object Tracking</H3>
+<H3><a name="Ruby_nn60">38.10.3 Object Tracking</a></H3>
<p>The remaining parts of this section will use the class library
class Zoo
{
protected:
- std::vector<animal *=""> animals;
+ std::vector<Animal *> animals;
public:
// Construct an empty zoo
<b>/* Tell SWIG that create_animal creates a new object */</b>
<b>%newobject Zoo::create_animal;</b>
-<b>/* Tell SWIG to keep track of mappings between C/C++ structs/classes. */</b><b>%trackobjects;</b>
+<b>/* Tell SWIG to keep track of mappings between C/C++ structs/classes. */</b>
+<b>%trackobjects;</b>
%include "example.h"</pre>
</div>
<p>In general, you will only need to use the <tt>SWIG_RubyInstanceFor</tt>,
which is required for implementing mark functions as shown below.
However, if you implement your own free functions (see below) you may
-also have to call the<tt> SWIG_RubyRemoveTracking</tt> and <tt>RubyUnlinkObjects</tt>
+also have to call the <tt>SWIG_RubyRemoveTracking</tt> and <tt>RubyUnlinkObjects</tt>
methods.</p>
-<H3><a name="Ruby_nn61"></a>36.10.4 Mark Functions</H3>
+<H3><a name="Ruby_nn61">38.10.4 Mark Functions</a></H3>
<p>With a bit more testing, we see that our class library still
<p> Note the <tt>mark</tt> function is dependent on
the <tt>SWIG_RUBY_InstanceFor</tt> method, and thus
requires that <tt>%trackobjects</tt> is enabled. For more
-information, please refer to the track_object.i test case in the SWIG
+information, please refer to the ruby_track_objects.i test case in the SWIG
test suite.</p>
<p>When this code is compiled we now see:</p>
<p>This code can be seen in swig/examples/ruby/mark_function.</p>
-<H3><a name="Ruby_nn62"></a>36.10.5 Free Functions</H3>
+<H3><a name="Ruby_nn62">38.10.5 Free Functions</a></H3>
<p>By default, SWIG creates a "free" function that is called when
<p>To show how to use the <tt>%freefunc</tt>
directive, let's slightly change our example. Assume that the zoo
-object is responsible for freeing animal that it contains. This means
+object is responsible for freeing any animal that it contains. This means
that the <tt>Zoo::add_animal</tt>
function should be marked with a <tt>DISOWN</tt> typemap
and the destructor should be updated as below:</p>
<div class="code">
-<pre>Zoo::~Zoo() {
- IterType iter = this->animals.begin();
- IterType end = this->animals.end();
-
- for(iter; iter != end; ++iter) {
- Animal* animal = *iter;
- delete animal;
- }
-}</pre>
+<pre>
+Zoo::~Zoo() {
+ IterType iter = this->animals.begin();
+ IterType end = this->animals.end();
+
+ for(iter; iter != end; ++iter) {
+ Animal* animal = *iter;
+ delete animal;
+ }
+}
+</pre>
</div>
<p>When we use these objects in IRB we see:</p>
#include "example.h"
%}
-/* Specify that ownership is transferred to the zoo
- when calling add_animal */
+/* Specify that ownership is transferred to the zoo when calling add_animal */
%apply SWIGTYPE *DISOWN { Animal* animal };
/* Track objects */
<p>This code can be seen in swig/examples/ruby/free_function.</p>
-<H3><a name="Ruby_nn63"></a>36.10.6 Embedded Ruby and the C++ Stack</H3>
+<H3><a name="Ruby_nn63">38.10.6 Embedded Ruby and the C++ Stack</a></H3>
<p>As has been said, the Ruby GC runs and marks objects before
<p>To solve the problem, SWIG can now generate code with director
functions containing the optional macros SWIG_INIT_STACK and
SWIG_RELEASE_STACK. These macros will try to force Ruby to
-reinitiliaze the beginning of the stack the first time a
+reinitialize the beginning of the stack the first time a
director
function is called. This will lead Ruby to measure and not
collect any VALUE objects defined from that point on. </p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG Basics</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="SWIG"></a>5 SWIG Basics</H1>
+<H1><a name="SWIG">5 SWIG Basics</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#SWIG_nn10">Basic Type Handling</a>
<li><a href="#SWIG_nn11">Global Variables</a>
<li><a href="#SWIG_nn12">Constants</a>
-<li><a href="#SWIG_nn13">A brief word about <tt>const</tt></a>
-<li><a href="#SWIG_nn14">A cautionary tale of <tt>char *</tt></a>
+<li><a href="#SWIG_nn13">A brief word about const</a>
+<li><a href="#SWIG_nn14">A cautionary tale of char *</a>
</ul>
<li><a href="#SWIG_nn15">Pointers and complex objects</a>
<ul>
<li><a href="#SWIG_nn22">Passing structures by value</a>
<li><a href="#SWIG_nn23">Return by value</a>
<li><a href="#SWIG_nn24">Linking to structure variables</a>
-<li><a href="#SWIG_nn25">Linking to <tt>char *</tt></a>
+<li><a href="#SWIG_nn25">Linking to char *</a>
<li><a href="#SWIG_nn26">Arrays</a>
<li><a href="#SWIG_readonly_variables">Creating read-only variables</a>
<li><a href="#SWIG_rename_ignore">Renaming and ignoring declarations</a>
chapters.
</p>
-<H2><a name="SWIG_nn2"></a>5.1 Running SWIG</H2>
+<H2><a name="SWIG_nn2">5.1 Running SWIG</a></H2>
<p>
Below is a subset of <em>options</em> that can be used.
Additional options are also defined for each target language. A full list
can be obtained by typing <tt>swig -help</tt> or <tt>swig
--<em>lang</em> -help</tt>.
+<em>-<lang></em> -help</tt> for language <em><lang></em> specific options.
</p>
<div class="shell"><pre>
-clisp Generate CLISP wrappers
-cffi Generate CFFI wrappers
-csharp Generate C# wrappers
+-d Generate D wrappers
-go Generate Go wrappers
-guile Generate Guile wrappers
-java Generate Java wrappers
+-javascript Generate Javascript wrappers
-lua Generate Lua wrappers
-modula3 Generate Modula 3 wrappers
-mzscheme Generate Mzscheme wrappers
-ocaml Generate Ocaml wrappers
+-octave Generate Octave wrappers
-perl Generate Perl wrappers
-php Generate PHP wrappers
-pike Generate Pike wrappers
-python Generate Python wrappers
-r Generate R (aka GNU S) wrappers
-ruby Generate Ruby wrappers
+-scilab Generate Scilab wrappers
-sexp Generate Lisp S-Expressions wrappers
-tcl Generate Tcl wrappers
-uffi Generate Common Lisp / UFFI wrappers
-xml Generate XML wrappers
-c++ Enable C++ parsing
+-cppext <em>ext</em> Change file extension of C++ generated files to <em>ext</em>
+ (default is cxx, except for PHP which uses cpp)
-D<em>symbol</em> Define a preprocessor symbol
-Fstandard Display error/warning messages in commonly used format
-Fmicrosoft Display error/warning messages in Microsoft format
-I<em>dir</em> Add a directory to the file include path
-l<em>file</em> Include a SWIG library file.
-module <em>name</em> Set the name of the SWIG module
--o <em>outfile</em> Name of output file
--outcurrentdir Set default output dir to current dir instead of input file's path
+-o <em>outfile</em> Set name of C/C++ output file to <outfile>
+-oh <em>headfile</em> Set name of C++ output header file for directors to <headfile>
+-outcurrentdir Set default output dir to current dir instead of input file's path
-outdir <em>dir</em> Set language specific files output directory
-pcreversion Display PCRE version information
-swiglib Show location of SWIG library
</pre></div>
-<H3><a name="SWIG_nn3"></a>5.1.1 Input format</H3>
+<H3><a name="SWIG_nn3">5.1.1 Input format</a></H3>
<p>
used in input files to parser generation tools such as yacc or bison.
</p>
-<H3><a name="SWIG_output"></a>5.1.2 SWIG Output</H3>
+<H3><a name="SWIG_output">5.1.2 SWIG Output</a></H3>
<p>
with the name <tt>file.i</tt> is transformed into a file
<tt>file_wrap.c</tt> or <tt>file_wrap.cxx</tt> (depending on whether
or not the <tt>-c++</tt> option has been used). The name of the
-output file can be changed using the <tt>-o</tt> option. In certain
+output C/C++ file can be changed using the <tt>-o</tt> option. In certain
cases, file suffixes are used by the compiler to determine the source
language (C, C++, etc.). Therefore, you have to use the
<tt>-o</tt> option to change the suffix of the SWIG-generated wrapper
<p>
The C/C++ output file created by SWIG often
-contains everything that is needed to construct a extension module
+contains everything that is needed to construct an extension module
for the target scripting language. SWIG is not a stub compiler nor is it
usually necessary to edit the output file (and if you look at the output,
you probably won't want to). To build the final extension module, the
</p>
<p>
-Many target languages will also generate proxy class files in the
+For many target languages SWIG will also generate proxy class files in the
target language. The default output directory for these language
specific files is the same directory as the generated C/C++ file. This
can be modified using the <tt>-outdir</tt> option. For example:
If <tt>-o</tt> and
<tt>-outcurrentdir</tt> are used together, <tt>-outcurrentdir</tt> is effectively ignored
as the output directory for the language files is the same directory as the
-generated C/C++ file if not overidden with <tt>-outdir</tt>.
+generated C/C++ file if not overridden with <tt>-outdir</tt>.
</p>
-<H3><a name="SWIG_nn5"></a>5.1.3 Comments</H3>
+<H3><a name="SWIG_nn5">5.1.3 Comments</a></H3>
<p>
and will reappear in a later SWIG release.
</p>
-<H3><a name="SWIG_nn6"></a>5.1.4 C Preprocessor</H3>
+<H3><a name="SWIG_nn6">5.1.4 C Preprocessor</a></H3>
<p>
extensions are described in the "<a href="Preprocessor.html#Preprocessor">Preprocessor</a>" chapter.
</p>
-<H3><a name="SWIG_nn7"></a>5.1.5 SWIG Directives</H3>
+<H3><a name="SWIG_nn7">5.1.5 SWIG Directives</a></H3>
<p>
it is parsing an input file.
</p>
-<H3><a name="SWIG_nn8"></a>5.1.6 Parser Limitations</H3>
+<H3><a name="SWIG_nn8">5.1.6 Parser Limitations</a></H3>
<p>
described on p. 234 of K&R).
</p>
-<H2><a name="SWIG_nn9"></a>5.2 Wrapping Simple C Declarations</H2>
+<H2><a name="SWIG_nn9">5.2 Wrapping Simple C Declarations</a></H2>
<p>
Whenever possible, SWIG creates an interface that closely matches the underlying C/C++
code. However, due to subtle differences between languages, run-time
environments, and semantics, it is not always possible to do so. The
-next few sections describes various aspects of this mapping.
+next few sections describe various aspects of this mapping.
</p>
-<H3><a name="SWIG_nn10"></a>5.2.1 Basic Type Handling</H3>
+<H3><a name="SWIG_nn10">5.2.1 Basic Type Handling</a></H3>
<p>
You may need to write some special conversion functions.
</p>
-<H3><a name="SWIG_nn11"></a>5.2.2 Global Variables</H3>
+<H3><a name="SWIG_nn11">5.2.2 Global Variables</a></H3>
<p>
constants instead.
</p>
-<H3><a name="SWIG_nn12"></a>5.2.3 Constants</H3>
+<H3><a name="SWIG_nn12">5.2.3 Constants</a></H3>
<p>
<div class="code">
<pre>
-#define F_CONST (double) 5 // A floating pointer constant with cast
+#define F_CONST (double) 5 // A floating point constant with cast
</pre>
</div>
<p>
The <tt>%constant</tt> directive is used to more precisely create
constants corresponding to different C datatypes. Although it is not
-usually not needed for simple values, it is more useful when working
+usually needed for simple values, it is more useful when working
with pointers and other more complex datatypes. Typically, <tt>%constant</tt>
is only used when you want to add constants to the scripting language
interface that are not defined in the original header file.
</p>
-<H3><a name="SWIG_nn13"></a>5.2.4 A brief word about <tt>const</tt></H3>
+<H3><a name="SWIG_nn13">5.2.4 A brief word about const</a></H3>
<p>
</pre>
</div>
-<H3><a name="SWIG_nn14"></a>5.2.5 A cautionary tale of <tt>char *</tt></H3>
+<H3><a name="SWIG_nn14">5.2.5 A cautionary tale of char *</a></H3>
<p>
points to string data stored inside the interpreter. It is almost
always a really bad idea to modify this data. Furthermore, some
languages may explicitly disallow it. For instance, in Python,
-strings are supposed be immutable. If you violate this, you will probably
+strings are supposed to be immutable. If you violate this, you will probably
receive a vast amount of wrath when you unleash your module on the world.
</p>
using <a href="Typemaps.html#Typemaps">typemaps</a>.
</p>
-<H2><a name="SWIG_nn15"></a>5.3 Pointers and complex objects</H2>
+<H2><a name="SWIG_nn15">5.3 Pointers and complex objects</a></H2>
<p>
discusses the handling of these datatypes.
</p>
-<H3><a name="SWIG_nn16"></a>5.3.1 Simple pointers</H3>
+<H3><a name="SWIG_nn16">5.3.1 Simple pointers</a></H3>
<p>
</li>
</ul>
-<H3><a name="SWIG_nn17"></a>5.3.2 Run time pointer type checking</H3>
+<H3><a name="SWIG_nn17">5.3.2 Run time pointer type checking</a></H3>
<p>
SWIG leaves NULL pointer checking up to the application.
</p>
-<H3><a name="SWIG_nn18"></a>5.3.3 Derived types, structs, and classes</H3>
+<H3><a name="SWIG_nn18">5.3.3 Derived types, structs, and classes</a></H3>
<p>
<div class="targetlang"><pre>
# Copy a file
def filecopy(source,target):
- f1 = fopen(source,"r")
- f2 = fopen(target,"w")
- buffer = malloc(8192)
- nbytes = fread(buffer,8192,1,f1)
- while (nbytes > 0):
- fwrite(buffer,8192,1,f2)
- nbytes = fread(buffer,8192,1,f1)
- free(buffer)
-
+ f1 = fopen(source,"r")
+ f2 = fopen(target,"w")
+ buffer = malloc(8192)
+ nbytes = fread(buffer,8192,1,f1)
+ while (nbytes > 0):
+ fwrite(buffer,8192,1,f2)
+ nbytes = fread(buffer,8192,1,f1)
+ free(buffer)
</pre></div>
<p>
-In this case <tt>f1</tt>,<tt> f2</tt>, and <tt>buffer</tt> are all
+In this case <tt>f1</tt>, <tt>f2</tt>, and <tt>buffer</tt> are all
opaque objects containing C pointers. It doesn't matter what value
they contain--our program works just fine without this knowledge.</p>
-<H3><a name="SWIG_nn19"></a>5.3.4 Undefined datatypes</H3>
+<H3><a name="SWIG_nn19">5.3.4 Undefined datatypes</a></H3>
<p>
<!-- We might want to add an error reporting flag to swig -->
-<H3><a name="SWIG_nn20"></a>5.3.5 Typedef</H3>
+<H3><a name="SWIG_nn20">5.3.5 Typedef</a></H3>
<p>
type <tt>unsigned int *</tt> or <tt>size_t *</tt>.
</p>
-<H2><a name="SWIG_nn21"></a>5.4 Other Practicalities</H2>
+<H2><a name="SWIG_nn21">5.4 Other Practicalities</a></H2>
<p>
some of these issues.
</p>
-<H3><a name="SWIG_nn22"></a>5.4.1 Passing structures by value</H3>
+<H3><a name="SWIG_nn22">5.4.1 Passing structures by value</a></H3>
<p>
is transparent so you might not notice.
</p>
-<H3><a name="SWIG_nn23"></a>5.4.2 Return by value</H3>
+<H3><a name="SWIG_nn23">5.4.2 Return by value</a></H3>
<p>
constructor. The section on SWIG and C++ has more information about this case.
</p>
-<H3><a name="SWIG_nn24"></a>5.4.3 Linking to structure variables</H3>
+<H3><a name="SWIG_nn24">5.4.3 Linking to structure variables</a></H3>
<p>
<div class="code"><pre>
Vector *unit_i_get() {
- return &unit_i;
+ return &unit_i;
}
void unit_i_set(Vector *value) {
- unit_i = *value;
+ unit_i = *value;
}
</pre></div>
assignment to work correctly.
</p>
-<H3><a name="SWIG_nn25"></a>5.4.4 Linking to <tt>char *</tt></H3>
+<H3><a name="SWIG_nn25">5.4.4 Linking to char *</a></H3>
<p>
-<H3><a name="SWIG_nn26"></a>5.4.5 Arrays</H3>
+<H3><a name="SWIG_nn26">5.4.5 Arrays</a></H3>
<p>
<p>
Like C, SWIG does not perform array bounds checking.
It is up to the
-user to make sure the pointer points a suitably allocated region of memory.
+user to make sure the pointer points to a suitably allocated region of memory.
</p>
<p>
In the target language, the value can be set like a normal variable.
</p>
-<H3><a name="SWIG_readonly_variables"></a>5.4.6 Creating read-only variables</H3>
+<H3><a name="SWIG_readonly_variables">5.4.6 Creating read-only variables</a></H3>
<p>
<div class="code"><pre>
// File : interface.i
-int a; // Can read/write
+int a; // Can read/write
%immutable;
-int b,c,d // Read only variables
+int b,c,d; // Read only variables
%mutable;
-double x,y // read/write
+double x,y; // read/write
</pre></div>
<p>
<tt>%mutable;</tt> to silence the warning. Don't forget the extra semicolon!
</p>
-<H3><a name="SWIG_rename_ignore"></a>5.4.7 Renaming and ignoring declarations</H3>
+<H3><a name="SWIG_rename_ignore">5.4.7 Renaming and ignoring declarations</a></H3>
-<H4><a name="SWIG_nn29"></a>5.4.7.1 Simple renaming of specific identifiers</H4>
+<H4><a name="SWIG_nn29">5.4.7.1 Simple renaming of specific identifiers</a></H4>
<p>
</pre></div>
<p>
-<tt>%rename </tt>applies a renaming operation to all future
+<tt>%rename</tt> applies a renaming operation to all future
occurrences of a name. The renaming applies to functions, variables,
class and structure names, member functions, and member data. For
example, if you had two-dozen C++ classes, all with a member function
directive is more powerful and better supports wrapping of raw header file information.
</p>
-<H4><a name="SWIG_advanced_renaming"></a>5.4.7.2 Advanced renaming support</H4>
+<H4><a name="SWIG_advanced_renaming">5.4.7.2 Advanced renaming support</a></H4>
<p>
<td><tt>wxPrint</tt></td><td><tt>Print</tt></td>
</tr>
<tr>
+ <td><tt>rstrip:[suffix]</tt></td>
+ <td>String without the given suffix or the original string if it doesn't
+ end with this suffix. Note that square brackets should be used
+ literally, e.g. <tt>%rename("rstrip:[Cls]")</tt></td>
+ <td><tt>PrintCls</tt></td><td><tt>Print</tt></td>
+</tr>
+<tr>
<td><span style="white-space: nowrap;"><tt>regex:/pattern/subst/</tt></span></td>
<td>String after (Perl-like) regex substitution operation. This function
allows to apply arbitrary regular expressions to the identifier names. The
<i>pattern</i> part is a regular expression in Perl syntax (as supported
by the <a href="http://www.pcre.org/">Perl Compatible Regular Expressions (PCRE)</a>)
library and the <i>subst</i> string
- can contain back-references introduced by <tt>'\'</tt> or, as backslashes need
- to be escaped in C strings, rather by <tt>"\\"</tt>. For example, to remove
- any alphabetic prefix before an underscore you could use the following directive:
- <tt>%rename("regex:/(\\w+)_(.*)/\\2/")</tt></td>
- <td><tt>Prefix_Print</tt></td><td><tt>Print</tt></td>
+ can contain back-references of the form <tt>\N</tt> where <tt>N</tt> is a digit
+ from 0 to 9, or one of the following escape sequences: <tt>\l</tt>, <tt>\L</tt>,
+ <tt>\u</tt>, <tt>\U</tt> or <tt>\E</tt>. The back-references are replaced with the
+ contents of the corresponding capture group while the escape sequences perform the
+ case conversion in the substitution string: <tt>\l</tt> and <tt>\L</tt> convert to
+ the lower case, while <tt>\u</tt> and <tt>\U</tt> convert to the upper case. The
+ difference between the elements of each pair is that <tt>\l</tt> and <tt>\u</tt>
+ change the case of the next character only, while <tt>\L</tt> and <tt>\U</tt> do
+ it for all the remaining characters or until <tt>\E</tt> is encountered.
+
+ Finally please notice that backslashes need to be escaped in C strings, so in
+ practice <tt>"\\"</tt> must be used in all these escape sequences. For example,
+ to remove any alphabetic prefix before an underscore and capitalize the remaining
+ part you could use the following directive:
+ <tt>%rename("regex:/(\\w+)_(.*)/\\u\\2/")</tt></td>
+ <td><tt>prefix_print</tt></td><td><tt>Print</tt></td>
</tr>
<tr>
<td><tt>command:cmd</tt></td>
multiple declarations using the previously described matching possibilities.
</p>
-<H4><a name="SWIG_limiting_renaming"></a>5.4.7.3 Limiting global renaming rules</H4>
+<H4><a name="SWIG_limiting_renaming">5.4.7.3 Limiting global renaming rules</a></H4>
<p>
</p>
-<H4><a name="SWIG_chosen_unignore"></a>5.4.7.4 Ignoring everything then wrapping a few selected symbols</H4>
+<H4><a name="SWIG_chosen_unignore">5.4.7.4 Ignoring everything then wrapping a few selected symbols</a></H4>
<p>
</div>
-<H3><a name="SWIG_default_args"></a>5.4.8 Default/optional arguments</H3>
+<H3><a name="SWIG_default_args">5.4.8 Default/optional arguments</a></H3>
<p>
used in Tcl as follows :</p>
<div class="targetlang"><pre>
-% plot -3.4 7.5 # Use default value
-% plot -3.4 7.5 10 # set color to 10 instead
+% plot -3.4 7.5 # Use default value
+% plot -3.4 7.5 10 # set color to 10 instead
</pre></div>
in the C++ chapter for further details.
</p>
-<H3><a name="SWIG_nn30"></a>5.4.9 Pointers to functions and callbacks</H3>
+<H3><a name="SWIG_nn30">5.4.9 Pointers to functions and callbacks</a></H3>
<p>
<p>
Notice that when the function is used as a callback, special names
-such as <tt>add_cb</tt> is used instead. To call the function
+such as <tt>add_cb</tt> are used instead. To call the function
normally, just use the original function name such as <tt>add()</tt>.
</p>
and individual target language chapters for more on callbacks and the 'director' feature.
</p>
-<H2><a name="SWIG_nn31"></a>5.5 Structures and unions</H2>
+<H2><a name="SWIG_nn31">5.5 Structures and unions</a></H2>
<p>
If SWIG encounters the definition of a structure or union, it
creates a set of accessor functions. Although SWIG does not need
structure definitions to build an interface, providing definitions
-make it possible to access structure members. The accessor functions
+makes it possible to access structure members. The accessor functions
generated by SWIG simply take a pointer to an object and allow access
to an individual member. For example, the declaration :</p>
<div class="code"><pre>
struct Vector {
- double x,y,z;
+ double x,y,z;
}
</pre></div>
<div class="code"><pre>
double Vector_x_get(struct Vector *obj) {
- return obj->x;
+ return obj->x;
}
double Vector_y_get(struct Vector *obj) {
- return obj->y;
+ return obj->y;
}
double Vector_z_get(struct Vector *obj) {
- return obj->z;
+ return obj->z;
}
void Vector_x_set(struct Vector *obj, double value) {
- obj->x = value;
+ obj->x = value;
}
void Vector_y_set(struct Vector *obj, double value) {
- obj->y = value;
+ obj->y = value;
}
void Vector_z_set(struct Vector *obj, double value) {
- obj->z = value;
+ obj->z = value;
}
</pre></div>
However, most of SWIG's language modules also provide a high-level interface that is more convenient. Keep reading.
</p>
-<H3><a name="SWIG_nn32"></a>5.5.1 Typedef and structures</H3>
+<H3><a name="SWIG_nn32">5.5.1 Typedef and structures</a></H3>
<p>
<div class="code"><pre>
typedef struct {
- double x,y,z;
+ double x,y,z;
} Vector;
</pre></div>
<div class="code">
<pre>
double Vector_x_get(Vector *obj) {
- return obj->x;
+ return obj->x;
}
</pre>
</div>
<div class="code"><pre>
typedef struct vector_struct {
- double x,y,z;
+ double x,y,z;
} Vector;
</pre></div>
<tt>Vector</tt> and it generates the appropriate type-checking code.
</p>
-<H3><a name="SWIG_nn33"></a>5.5.2 Character strings and structures</H3>
+<H3><a name="SWIG_nn33">5.5.2 Character strings and structures</a></H3>
<p>
Structures involving character strings require some care. SWIG assumes
that all members of type <tt>char *</tt> have been dynamically
allocated using <tt>malloc()</tt> and that they are NULL-terminated
-ASCII strings. When such a member is modified, the previously contents
+ASCII strings. When such a member is modified, the previous contents
will be released, and the new contents allocated. For example :</p>
<div class="code"><pre>
%module mymodule
...
struct Foo {
- char *name;
- ...
+ char *name;
+ ...
}
</pre></div>
<div class="code"><pre>
char *Foo_name_get(Foo *obj) {
- return Foo->name;
+ return Foo->name;
}
char *Foo_name_set(Foo *obj, char *c) {
- if (obj->name) free(obj->name);
- obj->name = (char *) malloc(strlen(c)+1);
- strcpy(obj->name,c);
- return obj->name;
+ if (obj->name)
+ free(obj->name);
+ obj->name = (char *) malloc(strlen(c)+1);
+ strcpy(obj->name,c);
+ return obj->name;
}
</pre></div>
perform memory allocation.
</p>
-<H3><a name="SWIG_nn34"></a>5.5.3 Array members</H3>
+<H3><a name="SWIG_nn34">5.5.3 Array members</a></H3>
<p>
harmless.
</p>
-<H3><a name="SWIG_structure_data_members"></a>5.5.4 Structure data members</H3>
+<H3><a name="SWIG_structure_data_members">5.5.4 Structure data members</a></H3>
<p>
<p>
When a structure member is wrapped, it is handled as a pointer, unless the <tt>%naturalvar</tt> directive
is used where it is handled more like a C++ reference (see <a href="SWIGPlus.html#SWIGPlus_member_data">C++ Member data</a>).
-The accessors to the member variable as a pointer is effectively wrapped as follows:
+The accessors to the member variable as a pointer are effectively wrapped as follows:
</p>
<div class="code">
datatype is really a struct, simply use a forward struct declaration such as <tt>"struct Foo;"</tt>.
</p>
-<H3><a name="SWIG_nn36"></a>5.5.5 C constructors and destructors</H3>
+<H3><a name="SWIG_nn36">5.5.5 C constructors and destructors</a></H3>
<p>
<p>
-Since ignoring the implicit or default destructors most of the times
-produce memory leaks, SWIG will always try to generate them. If
+Since ignoring the implicit or default destructors most of the time
+produces memory leaks, SWIG will always try to generate them. If
needed, however, you can selectively disable the generation of the
default/implicit destructor by using <tt>%nodefaultdtor</tt>
</p>
<b>Note:</b> There are also the <tt>-nodefault</tt> option and
<tt>%nodefault</tt> directive, which disable both the default or
implicit destructor generation. This could lead to memory leaks across
-the target languages, and is highly recommended you don't use them.
+the target languages, and it is highly recommended you don't use them.
</p>
-<H3><a name="SWIG_adding_member_functions"></a>5.5.6 Adding member functions to C structures</H3>
+<H3><a name="SWIG_adding_member_functions">5.5.6 Adding member functions to C structures</a></H3>
<p>
/* file : vector.h */
...
typedef struct Vector {
- double x,y,z;
+ double x,y,z;
} Vector;
</pre></div>
%include "vector.h" // Just grab original C header file
%extend Vector { // Attach these functions to struct Vector
- Vector(double x, double y, double z) {
- Vector *v;
- v = (Vector *) malloc(sizeof(Vector));
- v->x = x;
- v->y = y;
- v->z = z;
- return v;
- }
- ~Vector() {
- free($self);
- }
- double magnitude() {
- return sqrt($self->x*$self->x+$self->y*$self->y+$self->z*$self->z);
- }
- void print() {
- printf("Vector [%g, %g, %g]\n", $self->x,$self->y,$self->z);
- }
+ Vector(double x, double y, double z) {
+ Vector *v;
+ v = (Vector *) malloc(sizeof(Vector));
+ v->x = x;
+ v->y = y;
+ v->z = z;
+ return v;
+ }
+ ~Vector() {
+ free($self);
+ }
+ double magnitude() {
+ return sqrt($self->x*$self->x+$self->y*$self->y+$self->z*$self->z);
+ }
+ void print() {
+ printf("Vector [%g, %g, %g]\n", $self->x,$self->y,$self->z);
+ }
};
</pre></div>
%}
typedef struct Vector {
- double x,y,z;
- %extend {
- Vector(double x, double y, double z) { ... }
- ~Vector() { ... }
- ...
- }
+ double x,y,z;
+ %extend {
+ Vector(double x, double y, double z) { ... }
+ ~Vector() { ... }
+ ...
+ }
} Vector;
</pre></div>
/* Vector methods */
#include "vector.h"
Vector *new_Vector(double x, double y, double z) {
- Vector *v;
- v = (Vector *) malloc(sizeof(Vector));
- v->x = x;
- v->y = y;
- v->z = z;
- return v;
+ Vector *v;
+ v = (Vector *) malloc(sizeof(Vector));
+ v->x = x;
+ v->y = y;
+ v->z = z;
+ return v;
}
void delete_Vector(Vector *v) {
- free(v);
+ free(v);
}
double Vector_magnitude(Vector *v) {
- return sqrt(v->x*v->x+v->y*v->y+v->z*v->z);
+ return sqrt(v->x*v->x+v->y*v->y+v->z*v->z);
}
// File : vector.i
%}
typedef struct Vector {
- double x,y,z;
- %extend {
- Vector(int,int,int); // This calls new_Vector()
- ~Vector(); // This calls delete_Vector()
- double magnitude(); // This will call Vector_magnitude()
- ...
- }
+ double x,y,z;
+ %extend {
+ Vector(int,int,int); // This calls new_Vector()
+ ~Vector(); // This calls delete_Vector()
+ double magnitude(); // This will call Vector_magnitude()
+ ...
+ }
} Vector;
</pre>
</div>
<div class="code"><pre>
typedef struct Integer {
- int value;
+ int value;
} Int;
%extend Integer { ... } /* Correct name */
%extend Int { ... } /* Incorrect name */
struct Float {
- float value;
+ float value;
};
typedef struct Float FloatValue;
%extend Float { ... } /* Correct name */
<div class="code"><pre>
typedef struct {
- double value;
+ double value;
} Double;
%extend Double { ... } /* Okay */
</pre></div>
directive name has been chosen.
</p>
-<H3><a name="SWIG_nested_structs"></a>5.5.7 Nested structures</H3>
+<H3><a name="SWIG_nested_structs">5.5.7 Nested structures</a></H3>
<p>
<div class="code"><pre>
typedef struct Object {
- int objtype;
- union {
- int ivalue;
- double dvalue;
- char *strvalue;
- void *ptrvalue;
- } intRep;
+ int objtype;
+ union {
+ int ivalue;
+ double dvalue;
+ char *strvalue;
+ void *ptrvalue;
+ } intRep;
} Object;
</pre></div>
<div class="code"><pre>
typedef union {
- int ivalue;
- double dvalue;
- char *strvalue;
- void *ptrvalue;
+ int ivalue;
+ double dvalue;
+ char *strvalue;
+ void *ptrvalue;
} Object_intRep;
typedef struct Object {
- int objType;
- Object_intRep intRep;
+ int objType;
+ Object_intRep intRep;
} Object;
</pre></div>
<div class="code"><pre>
Object_intRep *Object_intRep_get(Object *o) {
- return (Object_intRep *) &o->intRep;
+ return (Object_intRep *) &o->intRep;
}
int Object_intRep_ivalue_get(Object_intRep *o) {
- return o->ivalue;
+ return o->ivalue;
}
int Object_intRep_ivalue_set(Object_intRep *o, int value) {
- return (o->ivalue = value);
+ return (o->ivalue = value);
}
double Object_intRep_dvalue_get(Object_intRep *o) {
- return o->dvalue;
+ return o->dvalue;
}
... etc ...
see <a href="SWIGPlus.html#SWIGPlus_nested_classes">Nested classes</a>.
</p>
-<H3><a name="SWIG_nn39"></a>5.5.8 Other things to note about structure wrapping</H3>
+<H3><a name="SWIG_nn39">5.5.8 Other things to note about structure wrapping</a></H3>
<p>
some way or another.
</p>
-<H2><a name="SWIG_nn40"></a>5.6 Code Insertion</H2>
+<H2><a name="SWIG_nn40">5.6 Code Insertion</a></H2>
<p>
There are four common ways to insert code, but it's useful to know how the
output of SWIG is structured first.</p>
-<H3><a name="SWIG_nn41"></a>5.6.1 The output of SWIG</H3>
+<H3><a name="SWIG_nn41">5.6.1 The output of SWIG</a></H3>
<p>
</li>
</ul>
-<H3><a name="SWIG_nn42"></a>5.6.2 Code insertion blocks</H3>
+<H3><a name="SWIG_nn42">5.6.2 Code insertion blocks</a></H3>
<p>
%{
/* Create a new vector */
static Vector *new_Vector() {
- return (Vector *) malloc(sizeof(Vector));
+ return (Vector *) malloc(sizeof(Vector));
}
%}
Vector *new_Vector();
</pre></div>
-<H3><a name="SWIG_nn43"></a>5.6.3 Inlined code blocks</H3>
+<H3><a name="SWIG_nn43">5.6.3 Inlined code blocks</a></H3>
<p>
%inline %{
/* Create a new vector */
Vector *new_Vector() {
- return (Vector *) malloc(sizeof(Vector));
+ return (Vector *) malloc(sizeof(Vector));
}
%}
is given to both the C compiler and SWIG, it is illegal to include any
SWIG directives inside a <tt>%{ ... %}</tt> block.</p>
-<H3><a name="SWIG_nn44"></a>5.6.4 Initialization blocks</H3>
+<H3><a name="SWIG_nn44">5.6.4 Initialization blocks</a></H3>
<p>
<div class="code"><pre>
%init %{
- init_variables();
+ init_variables();
%}
</pre></div>
-<H2><a name="SWIG_nn45"></a>5.7 An Interface Building Strategy</H2>
+<H2><a name="SWIG_nn45">5.7 An Interface Building Strategy</a></H2>
<p>
-This section describes the general approach for building interface
+This section describes the general approach for building interfaces
with SWIG. The specifics related to a particular scripting language
are found in later chapters.</p>
-<H3><a name="SWIG_nn46"></a>5.7.1 Preparing a C program for SWIG</H3>
+<H3><a name="SWIG_nn46">5.7.1 Preparing a C program for SWIG</a></H3>
<p>
<ul>
<li>Identify the functions that you want to wrap. It's probably not
-necessary to access every single function in a C program--thus, a
+necessary to access every single function of a C program--thus, a
little forethought can dramatically simplify the resulting scripting
-language interface. C header files are particularly good source for
+language interface. C header files are a particularly good source for
finding things to wrap.
<li>Create a new interface file to describe the scripting language
if the full type information is not available if it is needed, whereas
SWIG will usually not warn or error out as it is designed to work without
full type information. However, if type information is not specified
-correctly, the wrappers can be sub-optimal and even result in uncompileable C/C++ code.
+correctly, the wrappers can be sub-optimal and even result in uncompilable C/C++ code.
<li>If your program has a main() function, you may need to rename it
(read on).
<a href="http://www.swig.org/bugs.html">SWIG bug tracker</a>.
</p>
-<H3><a name="SWIG_nn47"></a>5.7.2 The SWIG interface file</H3>
+<H3><a name="SWIG_nn47">5.7.2 The SWIG interface file</a></H3>
<p>
-The preferred method of using SWIG is to generate separate interface
+The preferred method of using SWIG is to generate a separate interface
file. Suppose you have the following C header file :</p>
<div class="code"><pre>
In more complex projects, an interface file containing numerous <tt>%include</tt> and <tt>#include</tt> statements like this is one of the most common approaches to interface file design due to lower maintenance overhead.
</p>
-<H3><a name="SWIG_nn48"></a>5.7.3 Why use separate interface files?</H3>
+<H3><a name="SWIG_nn48">5.7.3 Why use separate interface files?</a></H3>
<p>
header files.
</ul>
-<H3><a name="SWIG_nn49"></a>5.7.4 Getting the right header files</H3>
+<H3><a name="SWIG_nn49">5.7.4 Getting the right header files</a></H3>
<p>
#include <GL/glu.h>
%}
-// Put rest of declarations here
+// Put the rest of the declarations here
...
</pre></div>
-<H3><a name="SWIG_nn50"></a>5.7.5 What to do with main()</H3>
+<H3><a name="SWIG_nn50">5.7.5 What to do with main()</a></H3>
<p>
or Tcl script.</p>
<p>
-<b>Note:</b> If some cases, you might be inclined to create a
+<b>Note:</b> In some cases, you might be inclined to create a
scripting language wrapper for <tt>main()</tt>. If you do this, the
compilation will probably work and your module might even load
correctly. The only trouble is that when you call your
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
<HTML>
<HEAD>
-<TITLE>SWIG-2.0 Documentation</TITLE>
+<TITLE>SWIG-3.0 Documentation</TITLE>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=iso-iso-8859-1">
<STYLE TYPE="text/css"><!--
+
div.sectiontoc {
border-style: dotted;
border-width: 2px;
margin-left: 4em;
margin-right: 4em;
background-color: #F0FFFF;
+ font-family: "Courier New", Courier, "Courier 10 Pitch", monospace;
}
div.targetlang {
margin-left: 4em;
margin-right: 4em;
background-color: #d7f6bb;
+ font-family: "Courier New", Courier, "Courier 10 Pitch", monospace;
}
-
div.shell {
border-style: solid;
border-width: 1px;
margin-left: 4em;
margin-right: 4em;
background-color: #DCDCDC;
+ font-family: "Courier New", Courier, "Courier 10 Pitch", monospace;
}
div.diagram {
margin-left: 4em;
margin-right: 4em;
background-color: #FFEBCD;
+ font-family: "Courier New", Courier, "Courier 10 Pitch", monospace;
}
ul li p {
margin-right: 0;
}
+pre, code, tt {
+ font-family: "Courier New", Courier, "Courier 10 Pitch", monospace;
+}
+
+body { font-family: serif; }
-BODY { font-family: serif }
-H1 { font-family: sans-serif }
-H2 { font-family: sans-serif }
-H3 { font-family: sans-serif }
-H4 { font-family: sans-serif }
-H5 { font-family: sans-serif }
-H6 { font-family: sans-serif }
-SUB { font-size: smaller }
-SUP { font-size: smaller }
-PRE { font-family: monospace }
--></STYLE>
</HEAD>
<BODY BGCOLOR="#ffffff" LINK="#0000ff" VLINK="#0000ff" ALINK="#0000ff">
-<CENTER><A HREF="#CONTENTS"><IMG SRC="swig16.png" BORDER="0" WIDTH="167" HEIGHT="85" ALT="SWIG-2.0 Documentation"><BR>
-<H1>SWIG-2.0 Documentation</H1></A><BR>
+<CENTER><A HREF="#CONTENTS"><IMG SRC="swig16.png" BORDER="0" WIDTH="167" HEIGHT="85" ALT="SWIG-3.0 Documentation"><BR>
+<H1>SWIG-3.0 Documentation</H1></A><BR>
</CENTER>
<HR NOSHADE>
<H1 ALIGN="CENTER"><A NAME="CONTENTS">Table of Contents</A></H1>
<BR>
-<BR><B><A HREF="#Sections">SWIG-2.0 Documentation</A></B>
+<BR><B><A HREF="#Sections">SWIG-3.0 Documentation</A></B>
<UL>
-<LI><A HREF="#1_1">Sections</A>
+<LI><A HREF="#Sections_Sections">Sections</A>
<UL>
-<LI><A HREF="#1_1_1">SWIG Core Documentation</A></LI>
-<LI><A HREF="#1_1_2">Language Module Documentation</A></LI>
-<LI><A HREF="#1_1_3">Developer Documentation</A></LI>
+<LI><A HREF="#Sections_core_docs">SWIG Core Documentation</A></LI>
+<LI><A HREF="#Sections_language_modules">Language Module Documentation</A>
+</LI>
+<LI><A HREF="#Sections_developers_docs">Developer Documentation</A></LI>
</UL>
</LI>
</UL>
</LI>
<LI><A HREF="#SWIGPlus_nn42">6.29 Where to go for more information</A></LI>
</UL>
-<B><A HREF="#Preprocessor">7 Preprocessing</A></B>
-<UL>
-<LI><A HREF="#Preprocessor_nn2">7.1 File inclusion</A></LI>
-<LI><A HREF="#Preprocessor_nn3">7.2 File imports</A></LI>
-<LI><A HREF="#Preprocessor_condition_compilation">7.3 Conditional
+<B><A HREF="#CPlusPlus11">7 SWIG and C++11</A></B>
+<UL>
+<LI><A HREF="#CPlusPlus11_introduction">7.1 Introduction</A></LI>
+<LI><A HREF="#CPlusPlus11_core_language_changes">7.2 Core language
+ changes</A>
+<UL>
+<LI><A HREF="#CPlusPlus11_rvalue_reference_and_move_semantics">7.2.1
+ Rvalue reference and move semantics</A></LI>
+<LI><A HREF="#CPlusPlus11_generalized_constant_expressions">7.2.2
+ Generalized constant expressions</A></LI>
+<LI><A HREF="#CPlusPlus11_extern_template">7.2.3 Extern template</A></LI>
+<LI><A HREF="#CPlusPlus11_initializer_lists">7.2.4 Initializer lists</A></LI>
+<LI><A HREF="#CPlusPlus11_uniform_initialization">7.2.5 Uniform
+ initialization</A></LI>
+<LI><A HREF="#CPlusPlus11_type_inference">7.2.6 Type inference</A></LI>
+<LI><A HREF="#CPlusPlus11_range_based_for_loop">7.2.7 Range-based
+ for-loop</A></LI>
+<LI><A HREF="#CPlusPlus11_lambda_functions_and_expressions">7.2.8 Lambda
+ functions and expressions</A></LI>
+<LI><A HREF="#CPlusPlus11_alternate_function_syntax">7.2.9 Alternate
+ function syntax</A></LI>
+<LI><A HREF="#CPlusPlus11_object_construction_improvement">7.2.10 Object
+ construction improvement</A></LI>
+<LI><A HREF="#CPlusPlus11_explicit_overrides_final">7.2.11 Explicit
+ overrides and final</A></LI>
+<LI><A HREF="#CPlusPlus11_null_pointer_constant">7.2.12 Null pointer
+ constant</A></LI>
+<LI><A HREF="#CPlusPlus11_strongly_typed_enumerations">7.2.13 Strongly
+ typed enumerations</A></LI>
+<LI><A HREF="#CPlusPlus11_double_angle_brackets">7.2.14 Double angle
+ brackets</A></LI>
+<LI><A HREF="#CPlusPlus11_explicit_conversion_operators">7.2.15 Explicit
+ conversion operators</A></LI>
+<LI><A HREF="#CPlusPlus11_alias_templates">7.2.16 Alias templates</A></LI>
+<LI><A HREF="#CPlusPlus11_unrestricted_unions">7.2.17 Unrestricted
+ unions</A></LI>
+<LI><A HREF="#CPlusPlus11_variadic_templates">7.2.18 Variadic templates</A>
+</LI>
+<LI><A HREF="#CPlusPlus11_new_string_literals">7.2.19 New string
+ literals</A></LI>
+<LI><A HREF="#CPlusPlus11_user_defined_literals">7.2.20 User-defined
+ literals</A></LI>
+<LI><A HREF="#CPlusPlus11_thread_local_storage">7.2.21 Thread-local
+ storage</A></LI>
+<LI><A HREF="#CPlusPlus11_defaulted_deleted">7.2.22 Explicitly defaulted
+ functions and deleted functions</A></LI>
+<LI><A HREF="#CPlusPlus11_type_long_long_int">7.2.23 Type long long int</A>
+</LI>
+<LI><A HREF="#CPlusPlus11_static_assertions">7.2.24 Static assertions</A>
+</LI>
+<LI><A HREF="#CPlusPlus11_sizeof">7.2.25 Allow sizeof to work on members
+ of classes without an explicit object</A></LI>
+<LI><A HREF="#CPlusPlus11_noexcept">7.2.26 Exception specifications and
+ noexcept</A></LI>
+<LI><A HREF="#CPlusPlus11_alignment">7.2.27 Control and query object
+ alignment</A></LI>
+<LI><A HREF="#CPlusPlus11_attributes">7.2.28 Attributes</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#CPlusPlus11_standard_library_changes">7.3 Standard library
+ changes</A>
+<UL>
+<LI><A HREF="#CPlusPlus11_threading_facilities">7.3.1 Threading
+ facilities</A></LI>
+<LI><A HREF="#CPlusPlus11_tuple_types">7.3.2 Tuple types</A></LI>
+<LI><A HREF="#CPlusPlus11_hash_tables">7.3.3 Hash tables</A></LI>
+<LI><A HREF="#CPlusPlus11_regular_expressions">7.3.4 Regular expressions</A>
+</LI>
+<LI><A HREF="#CPlusPlus11_general_purpose_smart_pointers">7.3.5
+ General-purpose smart pointers</A></LI>
+<LI><A HREF="#CPlusPlus11_extensible_random_number_facility">7.3.6
+ Extensible random number facility</A></LI>
+<LI><A HREF="#CPlusPlus11_wrapper_reference">7.3.7 Wrapper reference</A></LI>
+<LI><A HREF="#CPlusPlus11_polymorphous_wrappers_for_function_objects">
+7.3.8 Polymorphous wrappers for function objects</A></LI>
+<LI><A HREF="#CPlusPlus11_type_traits_for_metaprogramming">7.3.9 Type
+ traits for metaprogramming</A></LI>
+<LI><A HREF="#CPlusPlus11_uniform_method_for_computing_return_type_of_function_objects">
+7.3.10 Uniform method for computing return type of function objects</A></LI>
+</UL>
+</LI>
+</UL>
+<B><A HREF="#Preprocessor">8 Preprocessing</A></B>
+<UL>
+<LI><A HREF="#Preprocessor_nn2">8.1 File inclusion</A></LI>
+<LI><A HREF="#Preprocessor_nn3">8.2 File imports</A></LI>
+<LI><A HREF="#Preprocessor_condition_compilation">8.3 Conditional
Compilation</A></LI>
-<LI><A HREF="#Preprocessor_nn5">7.4 Macro Expansion</A></LI>
-<LI><A HREF="#Preprocessor_nn6">7.5 SWIG Macros</A></LI>
-<LI><A HREF="#Preprocessor_nn7">7.6 C99 and GNU Extensions</A></LI>
-<LI><A HREF="#Preprocessor_delimiters">7.7 Preprocessing and delimiters</A>
+<LI><A HREF="#Preprocessor_nn5">8.4 Macro Expansion</A></LI>
+<LI><A HREF="#Preprocessor_nn6">8.5 SWIG Macros</A></LI>
+<LI><A HREF="#Preprocessor_nn7">8.6 C99 and GNU Extensions</A></LI>
+<LI><A HREF="#Preprocessor_delimiters">8.7 Preprocessing and delimiters</A>
<UL>
-<LI><A HREF="#Preprocessor_nn8">7.7.1 Preprocessing and %{ ... %} & "
+<LI><A HREF="#Preprocessor_nn8">8.7.1 Preprocessing and %{ ... %} & "
... " delimiters</A></LI>
-<LI><A HREF="#Preprocessor_nn9">7.7.2 Preprocessing and { ... }
+<LI><A HREF="#Preprocessor_nn9">8.7.2 Preprocessing and { ... }
delimiters</A></LI>
</UL>
</LI>
-<LI><A HREF="#Preprocessor_typemap_delimiters">7.8 Preprocessor and
+<LI><A HREF="#Preprocessor_typemap_delimiters">8.8 Preprocessor and
Typemaps</A></LI>
-<LI><A HREF="#Preprocessor_nn10">7.9 Viewing preprocessor output</A></LI>
-<LI><A HREF="#Preprocessor_warning_error">7.10 The #error and #warning
+<LI><A HREF="#Preprocessor_nn10">8.9 Viewing preprocessor output</A></LI>
+<LI><A HREF="#Preprocessor_warning_error">8.10 The #error and #warning
directives</A></LI>
</UL>
-<B><A HREF="#Library">8 SWIG library</A></B>
+<B><A HREF="#Library">9 SWIG library</A></B>
<UL>
-<LI><A HREF="#Library_nn2">8.1 The %include directive and library search
+<LI><A HREF="#Library_nn2">9.1 The %include directive and library search
path</A></LI>
-<LI><A HREF="#Library_nn3">8.2 C Arrays and Pointers</A>
+<LI><A HREF="#Library_nn3">9.2 C Arrays and Pointers</A>
<UL>
-<LI><A HREF="#Library_nn4">8.2.1 cpointer.i</A></LI>
-<LI><A HREF="#Library_carrays">8.2.2 carrays.i</A></LI>
-<LI><A HREF="#Library_nn6">8.2.3 cmalloc.i</A></LI>
-<LI><A HREF="#Library_nn7">8.2.4 cdata.i</A></LI>
+<LI><A HREF="#Library_nn4">9.2.1 cpointer.i</A></LI>
+<LI><A HREF="#Library_carrays">9.2.2 carrays.i</A></LI>
+<LI><A HREF="#Library_nn6">9.2.3 cmalloc.i</A></LI>
+<LI><A HREF="#Library_nn7">9.2.4 cdata.i</A></LI>
</UL>
</LI>
-<LI><A HREF="#Library_nn8">8.3 C String Handling</A>
+<LI><A HREF="#Library_nn8">9.3 C String Handling</A>
<UL>
-<LI><A HREF="#Library_nn9">8.3.1 Default string handling</A></LI>
-<LI><A HREF="#Library_nn10">8.3.2 Passing binary data</A></LI>
-<LI><A HREF="#Library_nn11">8.3.3 Using %newobject to release memory</A></LI>
-<LI><A HREF="#Library_nn12">8.3.4 cstring.i</A></LI>
+<LI><A HREF="#Library_nn9">9.3.1 Default string handling</A></LI>
+<LI><A HREF="#Library_nn10">9.3.2 Passing binary data</A></LI>
+<LI><A HREF="#Library_nn11">9.3.3 Using %newobject to release memory</A></LI>
+<LI><A HREF="#Library_nn12">9.3.4 cstring.i</A></LI>
</UL>
</LI>
-<LI><A HREF="#Library_stl_cpp_library">8.4 STL/C++ Library</A>
+<LI><A HREF="#Library_stl_cpp_library">9.4 STL/C++ Library</A>
<UL>
-<LI><A HREF="#Library_std_string">8.4.1 std::string</A></LI>
-<LI><A HREF="#Library_std_vector">8.4.2 std::vector</A></LI>
-<LI><A HREF="#Library_stl_exceptions">8.4.3 STL exceptions</A></LI>
-<LI><A HREF="#Library_std_shared_ptr">8.4.4 shared_ptr smart pointer</A></LI>
+<LI><A HREF="#Library_std_string">9.4.1 std::string</A></LI>
+<LI><A HREF="#Library_std_vector">9.4.2 std::vector</A></LI>
+<LI><A HREF="#Library_stl_exceptions">9.4.3 STL exceptions</A></LI>
+<LI><A HREF="#Library_std_shared_ptr">9.4.4 shared_ptr smart pointer</A></LI>
+<LI><A HREF="#Library_std_auto_ptr">9.4.5 auto_ptr smart pointer</A></LI>
</UL>
</LI>
-<LI><A HREF="#Library_nn16">8.5 Utility Libraries</A>
+<LI><A HREF="#Library_nn16">9.5 Utility Libraries</A>
<UL>
-<LI><A HREF="#Library_nn17">8.5.1 exception.i</A></LI>
+<LI><A HREF="#Library_nn17">9.5.1 exception.i</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#Arguments">9 Argument Handling</A></B>
+<B><A HREF="#Arguments">10 Argument Handling</A></B>
<UL>
-<LI><A HREF="#Arguments_nn2">9.1 The typemaps.i library</A>
+<LI><A HREF="#Arguments_nn2">10.1 The typemaps.i library</A>
<UL>
-<LI><A HREF="#Arguments_nn3">9.1.1 Introduction</A></LI>
-<LI><A HREF="#Arguments_nn4">9.1.2 Input parameters</A></LI>
-<LI><A HREF="#Arguments_nn5">9.1.3 Output parameters</A></LI>
-<LI><A HREF="#Arguments_nn6">9.1.4 Input/Output parameters</A></LI>
-<LI><A HREF="#Arguments_nn7">9.1.5 Using different names</A></LI>
+<LI><A HREF="#Arguments_nn3">10.1.1 Introduction</A></LI>
+<LI><A HREF="#Arguments_nn4">10.1.2 Input parameters</A></LI>
+<LI><A HREF="#Arguments_nn5">10.1.3 Output parameters</A></LI>
+<LI><A HREF="#Arguments_nn6">10.1.4 Input/Output parameters</A></LI>
+<LI><A HREF="#Arguments_nn7">10.1.5 Using different names</A></LI>
</UL>
</LI>
-<LI><A HREF="#Arguments_nn8">9.2 Applying constraints to input values</A>
+<LI><A HREF="#Arguments_nn8">10.2 Applying constraints to input values</A>
<UL>
-<LI><A HREF="#Arguments_nn9">9.2.1 Simple constraint example</A></LI>
-<LI><A HREF="#Arguments_nn10">9.2.2 Constraint methods</A></LI>
-<LI><A HREF="#Arguments_nn11">9.2.3 Applying constraints to new
+<LI><A HREF="#Arguments_nn9">10.2.1 Simple constraint example</A></LI>
+<LI><A HREF="#Arguments_nn10">10.2.2 Constraint methods</A></LI>
+<LI><A HREF="#Arguments_nn11">10.2.3 Applying constraints to new
datatypes</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#Typemaps">10 Typemaps</A></B>
+<B><A HREF="#Typemaps">11 Typemaps</A></B>
<UL>
-<LI><A HREF="#Typemaps_nn2">10.1 Introduction</A>
+<LI><A HREF="#Typemaps_nn2">11.1 Introduction</A>
<UL>
-<LI><A HREF="#Typemaps_nn3">10.1.1 Type conversion</A></LI>
-<LI><A HREF="#Typemaps_nn4">10.1.2 Typemaps</A></LI>
-<LI><A HREF="#Typemaps_nn5">10.1.3 Pattern matching</A></LI>
-<LI><A HREF="#Typemaps_nn6">10.1.4 Reusing typemaps</A></LI>
-<LI><A HREF="#Typemaps_nn7">10.1.5 What can be done with typemaps?</A></LI>
-<LI><A HREF="#Typemaps_nn8">10.1.6 What can't be done with typemaps?</A></LI>
-<LI><A HREF="#Typemaps_aspects">10.1.7 Similarities to Aspect Oriented
+<LI><A HREF="#Typemaps_nn3">11.1.1 Type conversion</A></LI>
+<LI><A HREF="#Typemaps_nn4">11.1.2 Typemaps</A></LI>
+<LI><A HREF="#Typemaps_nn5">11.1.3 Pattern matching</A></LI>
+<LI><A HREF="#Typemaps_nn6">11.1.4 Reusing typemaps</A></LI>
+<LI><A HREF="#Typemaps_nn7">11.1.5 What can be done with typemaps?</A></LI>
+<LI><A HREF="#Typemaps_nn8">11.1.6 What can't be done with typemaps?</A></LI>
+<LI><A HREF="#Typemaps_aspects">11.1.7 Similarities to Aspect Oriented
Programming</A></LI>
-<LI><A HREF="#Typemaps_nn9">10.1.8 The rest of this chapter</A></LI>
+<LI><A HREF="#Typemaps_nn9">11.1.8 The rest of this chapter</A></LI>
</UL>
</LI>
-<LI><A HREF="#Typemaps_nn10">10.2 Typemap specifications</A>
+<LI><A HREF="#Typemaps_nn10">11.2 Typemap specifications</A>
<UL>
-<LI><A HREF="#Typemaps_defining">10.2.1 Defining a typemap</A></LI>
-<LI><A HREF="#Typemaps_nn12">10.2.2 Typemap scope</A></LI>
-<LI><A HREF="#Typemaps_nn13">10.2.3 Copying a typemap</A></LI>
-<LI><A HREF="#Typemaps_nn14">10.2.4 Deleting a typemap</A></LI>
-<LI><A HREF="#Typemaps_nn15">10.2.5 Placement of typemaps</A></LI>
+<LI><A HREF="#Typemaps_defining">11.2.1 Defining a typemap</A></LI>
+<LI><A HREF="#Typemaps_nn12">11.2.2 Typemap scope</A></LI>
+<LI><A HREF="#Typemaps_nn13">11.2.3 Copying a typemap</A></LI>
+<LI><A HREF="#Typemaps_nn14">11.2.4 Deleting a typemap</A></LI>
+<LI><A HREF="#Typemaps_nn15">11.2.5 Placement of typemaps</A></LI>
</UL>
</LI>
-<LI><A HREF="#Typemaps_pattern_matching">10.3 Pattern matching rules</A>
+<LI><A HREF="#Typemaps_pattern_matching">11.3 Pattern matching rules</A>
<UL>
-<LI><A HREF="#Typemaps_nn17">10.3.1 Basic matching rules</A></LI>
-<LI><A HREF="#Typemaps_typedef_reductions">10.3.2 Typedef reductions
+<LI><A HREF="#Typemaps_nn17">11.3.1 Basic matching rules</A></LI>
+<LI><A HREF="#Typemaps_typedef_reductions">11.3.2 Typedef reductions
matching</A></LI>
-<LI><A HREF="#Typemaps_nn19">10.3.3 Default typemap matching rules</A></LI>
-<LI><A HREF="#Typemaps_multi_argument_typemaps_patterns">10.3.4
+<LI><A HREF="#Typemaps_nn19">11.3.3 Default typemap matching rules</A></LI>
+<LI><A HREF="#Typemaps_multi_argument_typemaps_patterns">11.3.4
Multi-arguments typemaps</A></LI>
-<LI><A HREF="#Typemaps_matching_template_comparison">10.3.5 Matching
+<LI><A HREF="#Typemaps_matching_template_comparison">11.3.5 Matching
rules compared to C++ templates</A></LI>
-<LI><A HREF="#Typemaps_debugging_search">10.3.6 Debugging typemap
+<LI><A HREF="#Typemaps_debugging_search">11.3.6 Debugging typemap
pattern matching</A></LI>
</UL>
</LI>
-<LI><A HREF="#Typemaps_nn21">10.4 Code generation rules</A>
+<LI><A HREF="#Typemaps_nn21">11.4 Code generation rules</A>
<UL>
-<LI><A HREF="#Typemaps_nn22">10.4.1 Scope</A></LI>
-<LI><A HREF="#Typemaps_nn23">10.4.2 Declaring new local variables</A></LI>
-<LI><A HREF="#Typemaps_special_variables">10.4.3 Special variables</A></LI>
-<LI><A HREF="#Typemaps_special_variable_macros">10.4.4 Special variable
+<LI><A HREF="#Typemaps_nn22">11.4.1 Scope</A></LI>
+<LI><A HREF="#Typemaps_nn23">11.4.2 Declaring new local variables</A></LI>
+<LI><A HREF="#Typemaps_special_variables">11.4.3 Special variables</A></LI>
+<LI><A HREF="#Typemaps_special_variable_macros">11.4.4 Special variable
macros</A>
<UL>
-<LI><A HREF="#Typemaps_special_macro_descriptor">10.4.4.1
+<LI><A HREF="#Typemaps_special_macro_descriptor">11.4.4.1
$descriptor(type)</A></LI>
-<LI><A HREF="#Typemaps_special_macro_typemap">10.4.4.2 $typemap(method,
+<LI><A HREF="#Typemaps_special_macro_typemap">11.4.4.2 $typemap(method,
typepattern)</A></LI>
</UL>
</LI>
+<LI><A HREF="#Typemaps_special_variable_attributes">11.4.5 Special
+ variables and typemap attributes</A></LI>
+<LI><A HREF="#Typemaps_special_variables_and_macros">11.4.6 Special
+ variables combined with special variable macros</A></LI>
</UL>
</LI>
-<LI><A HREF="#Typemaps_nn25">10.5 Common typemap methods</A>
+<LI><A HREF="#Typemaps_nn25">11.5 Common typemap methods</A>
<UL>
-<LI><A HREF="#Typemaps_nn26">10.5.1 "in" typemap</A></LI>
-<LI><A HREF="#Typemaps_nn27">10.5.2 "typecheck" typemap</A></LI>
-<LI><A HREF="#Typemaps_nn28">10.5.3 "out" typemap</A></LI>
-<LI><A HREF="#Typemaps_nn29">10.5.4 "arginit" typemap</A></LI>
-<LI><A HREF="#Typemaps_nn30">10.5.5 "default" typemap</A></LI>
-<LI><A HREF="#Typemaps_nn31">10.5.6 "check" typemap</A></LI>
-<LI><A HREF="#Typemaps_nn32">10.5.7 "argout" typemap</A></LI>
-<LI><A HREF="#Typemaps_nn33">10.5.8 "freearg" typemap</A></LI>
-<LI><A HREF="#Typemaps_nn34">10.5.9 "newfree" typemap</A></LI>
-<LI><A HREF="#Typemaps_nn35">10.5.10 "memberin" typemap</A></LI>
-<LI><A HREF="#Typemaps_nn36">10.5.11 "varin" typemap</A></LI>
-<LI><A HREF="#Typemaps_nn37">10.5.12 "varout" typemap</A></LI>
-<LI><A HREF="#throws_typemap">10.5.13 "throws" typemap</A></LI>
+<LI><A HREF="#Typemaps_nn26">11.5.1 "in" typemap</A></LI>
+<LI><A HREF="#Typemaps_nn27">11.5.2 "typecheck" typemap</A></LI>
+<LI><A HREF="#Typemaps_nn28">11.5.3 "out" typemap</A></LI>
+<LI><A HREF="#Typemaps_nn29">11.5.4 "arginit" typemap</A></LI>
+<LI><A HREF="#Typemaps_nn30">11.5.5 "default" typemap</A></LI>
+<LI><A HREF="#Typemaps_nn31">11.5.6 "check" typemap</A></LI>
+<LI><A HREF="#Typemaps_nn32">11.5.7 "argout" typemap</A></LI>
+<LI><A HREF="#Typemaps_nn33">11.5.8 "freearg" typemap</A></LI>
+<LI><A HREF="#Typemaps_nn34">11.5.9 "newfree" typemap</A></LI>
+<LI><A HREF="#Typemaps_nn35">11.5.10 "memberin" typemap</A></LI>
+<LI><A HREF="#Typemaps_nn36">11.5.11 "varin" typemap</A></LI>
+<LI><A HREF="#Typemaps_nn37">11.5.12 "varout" typemap</A></LI>
+<LI><A HREF="#throws_typemap">11.5.13 "throws" typemap</A></LI>
</UL>
</LI>
-<LI><A HREF="#Typemaps_nn39">10.6 Some typemap examples</A>
+<LI><A HREF="#Typemaps_nn39">11.6 Some typemap examples</A>
<UL>
-<LI><A HREF="#Typemaps_nn40">10.6.1 Typemaps for arrays</A></LI>
-<LI><A HREF="#Typemaps_nn41">10.6.2 Implementing constraints with
+<LI><A HREF="#Typemaps_nn40">11.6.1 Typemaps for arrays</A></LI>
+<LI><A HREF="#Typemaps_nn41">11.6.2 Implementing constraints with
typemaps</A></LI>
</UL>
</LI>
-<LI><A HREF="#Typemaps_nn43">10.7 Typemaps for multiple target languages</A>
+<LI><A HREF="#Typemaps_nn43">11.7 Typemaps for multiple target languages</A>
</LI>
-<LI><A HREF="#Typemaps_optimal">10.8 Optimal code generation when
+<LI><A HREF="#Typemaps_optimal">11.8 Optimal code generation when
returning by value</A></LI>
-<LI><A HREF="#Typemaps_multi_argument_typemaps">10.9 Multi-argument
+<LI><A HREF="#Typemaps_multi_argument_typemaps">11.9 Multi-argument
typemaps</A></LI>
-<LI><A HREF="#Typemaps_warnings">10.10 Typemap warnings</A></LI>
-<LI><A HREF="#Typemaps_fragments">10.11 Typemap fragments</A>
+<LI><A HREF="#Typemaps_warnings">11.10 Typemap warnings</A></LI>
+<LI><A HREF="#Typemaps_fragments">11.11 Typemap fragments</A>
<UL>
-<LI><A HREF="#Typemaps_fragment_type_specialization">10.11.1 Fragment
+<LI><A HREF="#Typemaps_fragment_type_specialization">11.11.1 Fragment
type specialization</A></LI>
-<LI><A HREF="#Typemaps_automatic_specialization">10.11.2 Fragments and
+<LI><A HREF="#Typemaps_automatic_specialization">11.11.2 Fragments and
automatic typemap specialization</A></LI>
</UL>
</LI>
-<LI><A HREF="#Typemaps_runtime_type_checker">10.12 The run-time type
+<LI><A HREF="#Typemaps_runtime_type_checker">11.12 The run-time type
checker</A>
<UL>
-<LI><A HREF="#Typemaps_nn45">10.12.1 Implementation</A></LI>
-<LI><A HREF="#Typemaps_runtime_type_checker_usage">10.12.2 Usage</A></LI>
+<LI><A HREF="#Typemaps_nn45">11.12.1 Implementation</A></LI>
+<LI><A HREF="#Typemaps_runtime_type_checker_usage">11.12.2 Usage</A></LI>
</UL>
</LI>
-<LI><A HREF="#Typemaps_overloading">10.13 Typemaps and overloading</A></LI>
-<LI><A HREF="#Typemaps_nn48">10.14 More about %apply and %clear</A></LI>
-<LI><A HREF="#Typemaps_nn47">10.15 Passing data between typemaps</A></LI>
-<LI><A HREF="#Typemaps_nn52">10.16 C++ "this" pointer</A></LI>
-<LI><A HREF="#Typemaps_nn51">10.17 Where to go for more information?</A></LI>
+<LI><A HREF="#Typemaps_overloading">11.13 Typemaps and overloading</A></LI>
+<LI><A HREF="#Typemaps_nn48">11.14 More about %apply and %clear</A></LI>
+<LI><A HREF="#Typemaps_nn47">11.15 Passing data between typemaps</A></LI>
+<LI><A HREF="#Typemaps_nn52">11.16 C++ "this" pointer</A></LI>
+<LI><A HREF="#Typemaps_nn51">11.17 Where to go for more information?</A></LI>
</UL>
-<B><A HREF="#Customization">11 Customization Features</A></B>
+<B><A HREF="#Customization">12 Customization Features</A></B>
<UL>
-<LI><A HREF="#Customization_exception">11.1 Exception handling with
+<LI><A HREF="#Customization_exception">12.1 Exception handling with
%exception</A>
<UL>
-<LI><A HREF="#Customization_nn3">11.1.1 Handling exceptions in C code</A>
+<LI><A HREF="#Customization_nn3">12.1.1 Handling exceptions in C code</A>
</LI>
-<LI><A HREF="#Customization_nn4">11.1.2 Exception handling with
+<LI><A HREF="#Customization_nn4">12.1.2 Exception handling with
longjmp()</A></LI>
-<LI><A HREF="#Customization_nn5">11.1.3 Handling C++ exceptions</A></LI>
-<LI><A HREF="#Customization_allowexcept">11.1.4 Exception handlers for
+<LI><A HREF="#Customization_nn5">12.1.3 Handling C++ exceptions</A></LI>
+<LI><A HREF="#Customization_allowexcept">12.1.4 Exception handlers for
variables</A></LI>
-<LI><A HREF="#Customization_nn6">11.1.5 Defining different exception
+<LI><A HREF="#Customization_nn6">12.1.5 Defining different exception
handlers</A></LI>
-<LI><A HREF="#Customization_exception_special_variables">11.1.6 Special
+<LI><A HREF="#Customization_exception_special_variables">12.1.6 Special
variables for %exception</A></LI>
-<LI><A HREF="#Customization_nn7">11.1.7 Using The SWIG exception library</A>
+<LI><A HREF="#Customization_nn7">12.1.7 Using The SWIG exception library</A>
</LI>
</UL>
</LI>
-<LI><A HREF="#Customization_ownership">11.2 Object ownership and
+<LI><A HREF="#Customization_ownership">12.2 Object ownership and
%newobject</A></LI>
-<LI><A HREF="#Customization_features">11.3 Features and the %feature
+<LI><A HREF="#Customization_features">12.3 Features and the %feature
directive</A>
<UL>
-<LI><A HREF="#Customization_feature_attributes">11.3.1 Feature
+<LI><A HREF="#Customization_feature_attributes">12.3.1 Feature
attributes</A></LI>
-<LI><A HREF="#Customization_feature_flags">11.3.2 Feature flags</A></LI>
-<LI><A HREF="#Customization_clearing_features">11.3.3 Clearing features</A>
+<LI><A HREF="#Customization_feature_flags">12.3.2 Feature flags</A></LI>
+<LI><A HREF="#Customization_clearing_features">12.3.3 Clearing features</A>
</LI>
-<LI><A HREF="#Customization_features_default_args">11.3.4 Features and
+<LI><A HREF="#Customization_features_default_args">12.3.4 Features and
default arguments</A></LI>
-<LI><A HREF="#Customization_features_example">11.3.5 Feature example</A></LI>
+<LI><A HREF="#Customization_features_example">12.3.5 Feature example</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#Contract">12 Contracts</A></B>
+<B><A HREF="#Contract">13 Contracts</A></B>
<UL>
-<LI><A HREF="#Contract_nn2">12.1 The %contract directive</A></LI>
-<LI><A HREF="#Contract_nn3">12.2 %contract and classes</A></LI>
-<LI><A HREF="#Contract_nn4">12.3 Constant aggregation and
+<LI><A HREF="#Contract_nn2">13.1 The %contract directive</A></LI>
+<LI><A HREF="#Contract_nn3">13.2 %contract and classes</A></LI>
+<LI><A HREF="#Contract_nn4">13.3 Constant aggregation and
%aggregate_check</A></LI>
-<LI><A HREF="#Contract_nn5">12.4 Notes</A></LI>
-</UL>
-<B><A HREF="#Varargs">13 Variable Length Arguments</A></B>
-<UL>
-<LI><A HREF="#Varargs_nn2">13.1 Introduction</A></LI>
-<LI><A HREF="#Varargs_nn3">13.2 The Problem</A></LI>
-<LI><A HREF="#Varargs_nn4">13.3 Default varargs support</A></LI>
-<LI><A HREF="#Varargs_nn5">13.4 Argument replacement using %varargs</A></LI>
-<LI><A HREF="#Varargs_nn6">13.5 Varargs and typemaps</A></LI>
-<LI><A HREF="#Varargs_nn7">13.6 Varargs wrapping with libffi</A></LI>
-<LI><A HREF="#Varargs_nn8">13.7 Wrapping of va_list</A></LI>
-<LI><A HREF="#Varargs_nn9">13.8 C++ Issues</A></LI>
-<LI><A HREF="#Varargs_nn10">13.9 Discussion</A></LI>
-</UL>
-<B><A HREF="#Warnings">14 Warning Messages</A></B>
-<UL>
-<LI><A HREF="#Warnings_nn2">14.1 Introduction</A></LI>
-<LI><A HREF="#Warnings_suppression">14.2 Warning message suppression</A></LI>
-<LI><A HREF="#Warnings_nn4">14.3 Enabling extra warnings</A></LI>
-<LI><A HREF="#Warnings_nn5">14.4 Issuing a warning message</A></LI>
-<LI><A HREF="#Warnings_symbolic_symbols">14.5 Symbolic symbols</A></LI>
-<LI><A HREF="#Warnings_nn6">14.6 Commentary</A></LI>
-<LI><A HREF="#Warnings_nn7">14.7 Warnings as errors</A></LI>
-<LI><A HREF="#Warnings_nn8">14.8 Message output format</A></LI>
-<LI><A HREF="#Warnings_nn9">14.9 Warning number reference</A>
-<UL>
-<LI><A HREF="#Warnings_nn10">14.9.1 Deprecated features (100-199)</A></LI>
-<LI><A HREF="#Warnings_nn11">14.9.2 Preprocessor (200-299)</A></LI>
-<LI><A HREF="#Warnings_nn12">14.9.3 C/C++ Parser (300-399)</A></LI>
-<LI><A HREF="#Warnings_nn13">14.9.4 Types and typemaps (400-499)</A></LI>
-<LI><A HREF="#Warnings_nn14">14.9.5 Code generation (500-599)</A></LI>
-<LI><A HREF="#Warnings_nn15">14.9.6 Language module specific (700-899)</A>
-</LI>
-<LI><A HREF="#Warnings_nn16">14.9.7 User defined (900-999)</A></LI>
-</UL>
-</LI>
-<LI><A HREF="#Warnings_nn17">14.10 History</A></LI>
-</UL>
-<B><A HREF="#Modules">15 Working with Modules</A></B>
-<UL>
-<LI><A HREF="#Modules_introduction">15.1 Modules Introduction</A></LI>
-<LI><A HREF="#Modules_nn1">15.2 Basics</A></LI>
-<LI><A HREF="#Modules_nn2">15.3 The SWIG runtime code</A></LI>
-<LI><A HREF="#Modules_external_run_time">15.4 External access to the
+<LI><A HREF="#Contract_nn5">13.4 Notes</A></LI>
+</UL>
+<B><A HREF="#Varargs">14 Variable Length Arguments</A></B>
+<UL>
+<LI><A HREF="#Varargs_nn2">14.1 Introduction</A></LI>
+<LI><A HREF="#Varargs_nn3">14.2 The Problem</A></LI>
+<LI><A HREF="#Varargs_nn4">14.3 Default varargs support</A></LI>
+<LI><A HREF="#Varargs_nn5">14.4 Argument replacement using %varargs</A></LI>
+<LI><A HREF="#Varargs_nn6">14.5 Varargs and typemaps</A></LI>
+<LI><A HREF="#Varargs_nn7">14.6 Varargs wrapping with libffi</A></LI>
+<LI><A HREF="#Varargs_nn8">14.7 Wrapping of va_list</A></LI>
+<LI><A HREF="#Varargs_nn9">14.8 C++ Issues</A></LI>
+<LI><A HREF="#Varargs_nn10">14.9 Discussion</A></LI>
+</UL>
+<B><A HREF="#Warnings">15 Warning Messages</A></B>
+<UL>
+<LI><A HREF="#Warnings_nn2">15.1 Introduction</A></LI>
+<LI><A HREF="#Warnings_suppression">15.2 Warning message suppression</A></LI>
+<LI><A HREF="#Warnings_nn4">15.3 Enabling extra warnings</A></LI>
+<LI><A HREF="#Warnings_nn5">15.4 Issuing a warning message</A></LI>
+<LI><A HREF="#Warnings_symbolic_symbols">15.5 Symbolic symbols</A></LI>
+<LI><A HREF="#Warnings_nn6">15.6 Commentary</A></LI>
+<LI><A HREF="#Warnings_nn7">15.7 Warnings as errors</A></LI>
+<LI><A HREF="#Warnings_nn8">15.8 Message output format</A></LI>
+<LI><A HREF="#Warnings_nn9">15.9 Warning number reference</A>
+<UL>
+<LI><A HREF="#Warnings_nn10">15.9.1 Deprecated features (100-199)</A></LI>
+<LI><A HREF="#Warnings_nn11">15.9.2 Preprocessor (200-299)</A></LI>
+<LI><A HREF="#Warnings_nn12">15.9.3 C/C++ Parser (300-399)</A></LI>
+<LI><A HREF="#Warnings_nn13">15.9.4 Types and typemaps (400-499)</A></LI>
+<LI><A HREF="#Warnings_nn14">15.9.5 Code generation (500-599)</A></LI>
+<LI><A HREF="#Warnings_nn15">15.9.6 Language module specific (700-899)</A>
+</LI>
+<LI><A HREF="#Warnings_nn16">15.9.7 User defined (900-999)</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Warnings_nn17">15.10 History</A></LI>
+</UL>
+<B><A HREF="#Modules">16 Working with Modules</A></B>
+<UL>
+<LI><A HREF="#Modules_introduction">16.1 Modules Introduction</A></LI>
+<LI><A HREF="#Modules_nn1">16.2 Basics</A></LI>
+<LI><A HREF="#Modules_nn2">16.3 The SWIG runtime code</A></LI>
+<LI><A HREF="#Modules_external_run_time">16.4 External access to the
runtime</A></LI>
-<LI><A HREF="#Modules_nn4">15.5 A word of caution about static libraries</A>
+<LI><A HREF="#Modules_nn4">16.5 A word of caution about static libraries</A>
</LI>
-<LI><A HREF="#Modules_nn5">15.6 References</A></LI>
-<LI><A HREF="#Modules_nn6">15.7 Reducing the wrapper file size</A></LI>
+<LI><A HREF="#Modules_nn5">16.6 References</A></LI>
+<LI><A HREF="#Modules_nn6">16.7 Reducing the wrapper file size</A></LI>
</UL>
-<B><A HREF="#CCache">16 Using SWIG with ccache - ccache-swig(1) manpage</A>
+<B><A HREF="#CCache">17 Using SWIG with ccache - ccache-swig(1) manpage</A>
</B>
<UL>
-<LI><A HREF="#CCache_nn2">16.1 NAME</A></LI>
-<LI><A HREF="#CCache_nn3">16.2 SYNOPSIS</A></LI>
-<LI><A HREF="#CCache_nn4">16.3 DESCRIPTION</A></LI>
-<LI><A HREF="#CCache_nn5">16.4 OPTIONS SUMMARY</A></LI>
-<LI><A HREF="#CCache_nn6">16.5 OPTIONS</A></LI>
-<LI><A HREF="#CCache_nn7">16.6 INSTALLATION</A></LI>
-<LI><A HREF="#CCache_nn8">16.7 EXTRA OPTIONS</A></LI>
-<LI><A HREF="#CCache_nn9">16.8 ENVIRONMENT VARIABLES</A></LI>
-<LI><A HREF="#CCache_nn10">16.9 CACHE SIZE MANAGEMENT</A></LI>
-<LI><A HREF="#CCache_nn11">16.10 CACHE COMPRESSION</A></LI>
-<LI><A HREF="#CCache_nn12">16.11 HOW IT WORKS</A></LI>
-<LI><A HREF="#CCache_nn13">16.12 USING CCACHE WITH DISTCC</A></LI>
-<LI><A HREF="#CCache_nn14">16.13 SHARING A CACHE</A></LI>
-<LI><A HREF="#CCache_nn15">16.14 HISTORY</A></LI>
-<LI><A HREF="#CCache_nn16">16.15 DIFFERENCES FROM COMPILERCACHE</A></LI>
-<LI><A HREF="#CCache_nn17">16.16 CREDITS</A></LI>
-<LI><A HREF="#CCache_nn18">16.17 AUTHOR</A></LI>
-</UL>
-<B><A HREF="#Allegrocl">17 SWIG and Allegro Common Lisp</A></B>
-<UL>
-<LI><A HREF="#Allegrocl_nn2">17.1 Basics</A>
-<UL>
-<LI><A HREF="#Allegrocl_nn3">17.1.1 Running SWIG</A></LI>
-<LI><A HREF="#Allegrocl_nn4">17.1.2 Command Line Options</A></LI>
-<LI><A HREF="#Allegrocl_nn5">17.1.3 Inserting user code into generated
+<LI><A HREF="#CCache_nn2">17.1 NAME</A></LI>
+<LI><A HREF="#CCache_nn3">17.2 SYNOPSIS</A></LI>
+<LI><A HREF="#CCache_nn4">17.3 DESCRIPTION</A></LI>
+<LI><A HREF="#CCache_nn5">17.4 OPTIONS SUMMARY</A></LI>
+<LI><A HREF="#CCache_nn6">17.5 OPTIONS</A></LI>
+<LI><A HREF="#CCache_nn7">17.6 INSTALLATION</A></LI>
+<LI><A HREF="#CCache_nn8">17.7 EXTRA OPTIONS</A></LI>
+<LI><A HREF="#CCache_nn9">17.8 ENVIRONMENT VARIABLES</A></LI>
+<LI><A HREF="#CCache_nn10">17.9 CACHE SIZE MANAGEMENT</A></LI>
+<LI><A HREF="#CCache_nn11">17.10 CACHE COMPRESSION</A></LI>
+<LI><A HREF="#CCache_nn12">17.11 HOW IT WORKS</A></LI>
+<LI><A HREF="#CCache_nn13">17.12 USING CCACHE WITH DISTCC</A></LI>
+<LI><A HREF="#CCache_nn14">17.13 SHARING A CACHE</A></LI>
+<LI><A HREF="#CCache_nn15">17.14 HISTORY</A></LI>
+<LI><A HREF="#CCache_nn16">17.15 DIFFERENCES FROM COMPILERCACHE</A></LI>
+<LI><A HREF="#CCache_nn17">17.16 CREDITS</A></LI>
+<LI><A HREF="#CCache_nn18">17.17 AUTHOR</A></LI>
+</UL>
+<B><A HREF="#Allegrocl">18 SWIG and Allegro Common Lisp</A></B>
+<UL>
+<LI><A HREF="#Allegrocl_nn2">18.1 Basics</A>
+<UL>
+<LI><A HREF="#Allegrocl_nn3">18.1.1 Running SWIG</A></LI>
+<LI><A HREF="#Allegrocl_nn4">18.1.2 Command Line Options</A></LI>
+<LI><A HREF="#Allegrocl_nn5">18.1.3 Inserting user code into generated
files</A></LI>
</UL>
</LI>
-<LI><A HREF="#Allegrocl_nn6">17.2 Wrapping Overview</A>
+<LI><A HREF="#Allegrocl_nn6">18.2 Wrapping Overview</A>
<UL>
-<LI><A HREF="#Allegrocl_nn7">17.2.1 Function Wrapping</A></LI>
-<LI><A HREF="#Allegrocl_nn8">17.2.2 Foreign Wrappers</A></LI>
-<LI><A HREF="#Allegrocl_nn9">17.2.3 FFI Wrappers</A></LI>
-<LI><A HREF="#Allegrocl_nn10">17.2.4 Non-overloaded Defuns</A></LI>
-<LI><A HREF="#Allegrocl_nn11">17.2.5 Overloaded Defuns</A></LI>
-<LI><A HREF="#Allegrocl_nn12">17.2.6 What about constant and variable
+<LI><A HREF="#Allegrocl_nn7">18.2.1 Function Wrapping</A></LI>
+<LI><A HREF="#Allegrocl_nn8">18.2.2 Foreign Wrappers</A></LI>
+<LI><A HREF="#Allegrocl_nn9">18.2.3 FFI Wrappers</A></LI>
+<LI><A HREF="#Allegrocl_nn10">18.2.4 Non-overloaded Defuns</A></LI>
+<LI><A HREF="#Allegrocl_nn11">18.2.5 Overloaded Defuns</A></LI>
+<LI><A HREF="#Allegrocl_nn12">18.2.6 What about constant and variable
access?</A></LI>
-<LI><A HREF="#Allegrocl_nn13">17.2.7 Object Wrapping</A></LI>
+<LI><A HREF="#Allegrocl_nn13">18.2.7 Object Wrapping</A></LI>
</UL>
</LI>
-<LI><A HREF="#Allegrocl_nn14">17.3 Wrapping Details</A>
+<LI><A HREF="#Allegrocl_nn14">18.3 Wrapping Details</A>
<UL>
-<LI><A HREF="#Allegrocl_nn15">17.3.1 Namespaces</A></LI>
-<LI><A HREF="#Allegrocl_nn16">17.3.2 Constants</A></LI>
-<LI><A HREF="#Allegrocl_nn17">17.3.3 Variables</A></LI>
-<LI><A HREF="#Allegrocl_nn18">17.3.4 Enumerations</A></LI>
-<LI><A HREF="#Allegrocl_nn19">17.3.5 Arrays</A></LI>
-<LI><A HREF="#Allegrocl_nn20">17.3.6 Classes and Structs and Unions (oh
+<LI><A HREF="#Allegrocl_nn15">18.3.1 Namespaces</A></LI>
+<LI><A HREF="#Allegrocl_nn16">18.3.2 Constants</A></LI>
+<LI><A HREF="#Allegrocl_nn17">18.3.3 Variables</A></LI>
+<LI><A HREF="#Allegrocl_nn18">18.3.4 Enumerations</A></LI>
+<LI><A HREF="#Allegrocl_nn19">18.3.5 Arrays</A></LI>
+<LI><A HREF="#Allegrocl_nn20">18.3.6 Classes and Structs and Unions (oh
my!)</A>
<UL>
-<LI><A HREF="#Allegrocl_nn21">17.3.6.1 CLOS wrapping of</A></LI>
-<LI><A HREF="#Allegrocl_nn22">17.3.6.2 CLOS Inheritance</A></LI>
-<LI><A HREF="#Allegrocl_nn23">17.3.6.3 Member fields and functions</A></LI>
-<LI><A HREF="#Allegrocl_nn24">17.3.6.4 Why not directly access C++
+<LI><A HREF="#Allegrocl_nn21">18.3.6.1 CLOS wrapping of</A></LI>
+<LI><A HREF="#Allegrocl_nn22">18.3.6.2 CLOS Inheritance</A></LI>
+<LI><A HREF="#Allegrocl_nn23">18.3.6.3 Member fields and functions</A></LI>
+<LI><A HREF="#Allegrocl_nn24">18.3.6.4 Why not directly access C++
classes using foreign types?</A></LI>
</UL>
</LI>
-<LI><A HREF="#Allegrocl_nn25">17.3.7 Templates</A>
+<LI><A HREF="#Allegrocl_nn25">18.3.7 Templates</A>
<UL>
-<LI><A HREF="#Allegrocl_nn26">17.3.7.1 Generating wrapper code for
+<LI><A HREF="#Allegrocl_nn26">18.3.7.1 Generating wrapper code for
templates</A></LI>
-<LI><A HREF="#Allegrocl_nn27">17.3.7.2 Implicit Template instantiation</A>
+<LI><A HREF="#Allegrocl_nn27">18.3.7.2 Implicit Template instantiation</A>
</LI>
</UL>
</LI>
-<LI><A HREF="#Allegrocl_nn28">17.3.8 Typedef, Templates, and Synonym
+<LI><A HREF="#Allegrocl_nn28">18.3.8 Typedef, Templates, and Synonym
Types</A>
<UL>
-<LI><A HREF="#Allegrocl_nn29">17.3.8.1 Choosing a primary type</A></LI>
+<LI><A HREF="#Allegrocl_nn29">18.3.8.1 Choosing a primary type</A></LI>
</UL>
</LI>
-<LI><A HREF="#Allegrocl_nn30">17.3.9 Function overloading/Parameter
+<LI><A HREF="#Allegrocl_nn30">18.3.9 Function overloading/Parameter
defaulting</A></LI>
-<LI><A HREF="#Allegrocl_nn31">17.3.10 Operator wrapping and Operator
+<LI><A HREF="#Allegrocl_nn31">18.3.10 Operator wrapping and Operator
overloading</A></LI>
-<LI><A HREF="#Allegrocl_nn32">17.3.11 Varargs</A></LI>
-<LI><A HREF="#Allegrocl_nn33">17.3.12 C++ Exceptions</A></LI>
-<LI><A HREF="#Allegrocl_nn34">17.3.13 Pass by value, pass by reference</A>
+<LI><A HREF="#Allegrocl_nn32">18.3.11 Varargs</A></LI>
+<LI><A HREF="#Allegrocl_nn33">18.3.12 C++ Exceptions</A></LI>
+<LI><A HREF="#Allegrocl_nn34">18.3.13 Pass by value, pass by reference</A>
</LI>
</UL>
</LI>
-<LI><A HREF="#Allegrocl_nn35">17.4 Typemaps</A>
+<LI><A HREF="#Allegrocl_nn35">18.4 Typemaps</A>
<UL>
-<LI><A HREF="#Allegrocl_nn36">17.4.1 Code Generation in the C++ Wrapper</A>
+<LI><A HREF="#Allegrocl_nn36">18.4.1 Code Generation in the C++ Wrapper</A>
<UL>
-<LI><A HREF="#Allegrocl_nn37">17.4.1.1 IN Typemap</A></LI>
-<LI><A HREF="#Allegrocl_nn38">17.4.1.2 OUT Typemap</A></LI>
-<LI><A HREF="#Allegrocl_nn39">17.4.1.3 CTYPE Typemap</A></LI>
+<LI><A HREF="#Allegrocl_nn37">18.4.1.1 IN Typemap</A></LI>
+<LI><A HREF="#Allegrocl_nn38">18.4.1.2 OUT Typemap</A></LI>
+<LI><A HREF="#Allegrocl_nn39">18.4.1.3 CTYPE Typemap</A></LI>
</UL>
</LI>
-<LI><A HREF="#Allegrocl_nn40">17.4.2 Code generation in Lisp wrappers</A>
+<LI><A HREF="#Allegrocl_nn40">18.4.2 Code generation in Lisp wrappers</A>
<UL>
-<LI><A HREF="#Allegrocl_nn41">17.4.2.1 LIN Typemap</A></LI>
-<LI><A HREF="#Allegrocl_nn42">17.4.2.2 LOUT Typemap</A></LI>
-<LI><A HREF="#Allegrocl_nn43">17.4.2.3 FFITYPE Typemap</A></LI>
-<LI><A HREF="#Allegrocl_nn44">17.4.2.4 LISPTYPE Typemap</A></LI>
-<LI><A HREF="#Allegrocl_nn45">17.4.2.5 LISPCLASS Typemap</A></LI>
+<LI><A HREF="#Allegrocl_nn41">18.4.2.1 LIN Typemap</A></LI>
+<LI><A HREF="#Allegrocl_nn42">18.4.2.2 LOUT Typemap</A></LI>
+<LI><A HREF="#Allegrocl_nn43">18.4.2.3 FFITYPE Typemap</A></LI>
+<LI><A HREF="#Allegrocl_nn44">18.4.2.4 LISPTYPE Typemap</A></LI>
+<LI><A HREF="#Allegrocl_nn45">18.4.2.5 LISPCLASS Typemap</A></LI>
</UL>
</LI>
-<LI><A HREF="#Allegrocl_nn46">17.4.3 Modifying SWIG behavior using
+<LI><A HREF="#Allegrocl_nn46">18.4.3 Modifying SWIG behavior using
typemaps</A></LI>
</UL>
</LI>
-<LI><A HREF="#Allegrocl_nn47">17.5 Identifier Converter functions</A>
+<LI><A HREF="#Allegrocl_nn47">18.5 Identifier Converter functions</A>
<UL>
-<LI><A HREF="#Allegrocl_nn48">17.5.1 Creating symbols in the lisp
+<LI><A HREF="#Allegrocl_nn48">18.5.1 Creating symbols in the lisp
environment</A></LI>
-<LI><A HREF="#Allegrocl_nn49">17.5.2 Existing identifier-converter
+<LI><A HREF="#Allegrocl_nn49">18.5.2 Existing identifier-converter
functions</A>
<UL>
-<LI><A HREF="#Allegrocl_nn50">17.5.2.1 identifier-convert-null</A></LI>
-<LI><A HREF="#Allegrocl_nn51">17.5.2.2 identifier-convert-lispify</A></LI>
-<LI><A HREF="#Allegrocl_nn52">17.5.2.3 Default identifier to symbol
+<LI><A HREF="#Allegrocl_nn50">18.5.2.1 identifier-convert-null</A></LI>
+<LI><A HREF="#Allegrocl_nn51">18.5.2.2 identifier-convert-lispify</A></LI>
+<LI><A HREF="#Allegrocl_nn52">18.5.2.3 Default identifier to symbol
conversions</A></LI>
</UL>
</LI>
-<LI><A HREF="#Allegrocl_nn53">17.5.3 Defining your own
+<LI><A HREF="#Allegrocl_nn53">18.5.3 Defining your own
identifier-converter</A></LI>
-<LI><A HREF="#Allegrocl_nn54">17.5.4 Instructing SWIG to use a
+<LI><A HREF="#Allegrocl_nn54">18.5.4 Instructing SWIG to use a
particular identifier-converter</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#Android">18 SWIG and Android</A></B>
+<B><A HREF="#Android">19 SWIG and Android</A></B>
<UL>
-<LI><A HREF="#Android_overview">18.1 Overview</A></LI>
-<LI><A HREF="#Android_examples">18.2 Android examples</A>
+<LI><A HREF="#Android_overview">19.1 Overview</A></LI>
+<LI><A HREF="#Android_examples">19.2 Android examples</A>
<UL>
-<LI><A HREF="#Android_examples_intro">18.2.1 Examples introduction</A></LI>
-<LI><A HREF="#Android_example_simple">18.2.2 Simple C example</A></LI>
-<LI><A HREF="#Android_example_class">18.2.3 C++ class example</A></LI>
-<LI><A HREF="#Android_examples_other">18.2.4 Other examples</A></LI>
+<LI><A HREF="#Android_examples_intro">19.2.1 Examples introduction</A></LI>
+<LI><A HREF="#Android_example_simple">19.2.2 Simple C example</A></LI>
+<LI><A HREF="#Android_example_class">19.2.3 C++ class example</A></LI>
+<LI><A HREF="#Android_examples_other">19.2.4 Other examples</A></LI>
</UL>
</LI>
-<LI><A HREF="#Android_stl">18.3 C++ STL</A></LI>
+<LI><A HREF="#Android_stl">19.3 C++ STL</A></LI>
</UL>
-<B><A HREF="#CSharp">19 SWIG and C#</A></B>
+<B><A HREF="#CSharp">20 SWIG and C#</A></B>
<UL>
-<LI><A HREF="#CSharp_introduction">19.1 Introduction</A></LI>
-<LI><A HREF="#CSharp_differences_java">19.2 Differences to the Java
+<LI><A HREF="#CSharp_introduction">20.1 Introduction</A>
+<UL>
+<LI><A HREF="#CSharp_introduction_swig2_compatibility">20.1.1 SWIG 2
+ Compatibility</A></LI>
+<LI><A HREF="#CSharp_commandline">20.1.2 Additional command line options</A>
+</LI>
+</UL>
+</LI>
+<LI><A HREF="#CSharp_differences_java">20.2 Differences to the Java
module</A></LI>
-<LI><A HREF="#CSharp_void_pointers">19.3 Void pointers</A></LI>
-<LI><A HREF="#CSharp_arrays">19.4 C# Arrays</A>
+<LI><A HREF="#CSharp_void_pointers">20.3 Void pointers</A></LI>
+<LI><A HREF="#CSharp_arrays">20.4 C# Arrays</A>
<UL>
-<LI><A HREF="#CSharp_arrays_swig_library">19.4.1 The SWIG C arrays
+<LI><A HREF="#CSharp_arrays_swig_library">20.4.1 The SWIG C arrays
library</A></LI>
-<LI><A HREF="#CSharp_arrays_pinvoke_default_array_marshalling">19.4.2
+<LI><A HREF="#CSharp_arrays_pinvoke_default_array_marshalling">20.4.2
Managed arrays using P/Invoke default array marshalling</A></LI>
-<LI><A HREF="#CSharp_arrays_pinning">19.4.3 Managed arrays using pinning</A>
+<LI><A HREF="#CSharp_arrays_pinning">20.4.3 Managed arrays using pinning</A>
</LI>
</UL>
</LI>
-<LI><A HREF="#CSharp_exceptions">19.5 C# Exceptions</A>
+<LI><A HREF="#CSharp_exceptions">20.5 C# Exceptions</A>
<UL>
-<LI><A HREF="#CSharp_exception_example_check_typemap">19.5.1 C#
+<LI><A HREF="#CSharp_exception_example_check_typemap">20.5.1 C#
exception example using "check" typemap</A></LI>
-<LI><A HREF="#CSharp_exception_example_percent_exception">19.5.2 C#
+<LI><A HREF="#CSharp_exception_example_percent_exception">20.5.2 C#
exception example using %exception</A></LI>
-<LI><A HREF="#CSharp_exception_example_exception_specifications">19.5.3
+<LI><A HREF="#CSharp_exception_example_exception_specifications">20.5.3
C# exception example using exception specifications</A></LI>
-<LI><A HREF="#CSharp_custom_application_exception">19.5.4 Custom C#
+<LI><A HREF="#CSharp_custom_application_exception">20.5.4 Custom C#
ApplicationException example</A></LI>
</UL>
</LI>
-<LI><A HREF="#CSharp_directors">19.6 C# Directors</A>
+<LI><A HREF="#CSharp_directors">20.6 C# Directors</A>
<UL>
-<LI><A HREF="#CSharp_directors_example">19.6.1 Directors example</A></LI>
-<LI><A HREF="#CSharp_directors_implementation">19.6.2 Directors
+<LI><A HREF="#CSharp_directors_example">20.6.1 Directors example</A></LI>
+<LI><A HREF="#CSharp_directors_implementation">20.6.2 Directors
implementation</A></LI>
-<LI><A HREF="#CSharp_director_caveats">19.6.3 Director caveats</A></LI>
+<LI><A HREF="#CSharp_director_caveats">20.6.3 Director caveats</A></LI>
</UL>
</LI>
-<LI><A HREF="#CSharp_multiple_modules">19.7 Multiples modules</A></LI>
-<LI><A HREF="#CSharp_typemap_examples">19.8 C# Typemap examples</A>
+<LI><A HREF="#CSharp_multiple_modules">20.7 Multiple modules</A></LI>
+<LI><A HREF="#CSharp_typemap_examples">20.8 C# Typemap examples</A>
<UL>
-<LI><A HREF="#CSharp_memory_management_member_variables">19.8.1 Memory
+<LI><A HREF="#CSharp_memory_management_member_variables">20.8.1 Memory
management when returning references to member variables</A></LI>
-<LI><A HREF="#CSharp_memory_management_objects">19.8.2 Memory management
+<LI><A HREF="#CSharp_memory_management_objects">20.8.2 Memory management
for objects passed to the C++ layer</A></LI>
-<LI><A HREF="#CSharp_date_marshalling">19.8.3 Date marshalling using the
+<LI><A HREF="#CSharp_date_marshalling">20.8.3 Date marshalling using the
csin typemap and associated attributes</A></LI>
-<LI><A HREF="#CSharp_date_properties">19.8.4 A date example
+<LI><A HREF="#CSharp_date_properties">20.8.4 A date example
demonstrating marshalling of C# properties</A></LI>
-<LI><A HREF="#CSharp_date_pre_post_directors">19.8.5 Date example
+<LI><A HREF="#CSharp_date_pre_post_directors">20.8.5 Date example
demonstrating the 'pre' and 'post' typemap attributes for directors</A></LI>
-<LI><A HREF="#CSharp_partial_classes">19.8.6 Turning wrapped classes
+<LI><A HREF="#CSharp_partial_classes">20.8.6 Turning wrapped classes
into partial classes</A></LI>
-<LI><A HREF="#CSharp_extending_proxy_class">19.8.7 Extending proxy
+<LI><A HREF="#CSharp_extending_proxy_class">20.8.7 Extending proxy
classes with additional C# code</A></LI>
-<LI><A HREF="#CSharp_enum_underlying_type">19.8.8 Underlying type for
+<LI><A HREF="#CSharp_enum_underlying_type">20.8.8 Underlying type for
enums</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#Chicken">20 SWIG and Chicken</A></B>
+<B><A HREF="#Chicken">21 SWIG and Chicken</A></B>
<UL>
-<LI><A HREF="#Chicken_nn2">20.1 Preliminaries</A>
+<LI><A HREF="#Chicken_nn2">21.1 Preliminaries</A>
<UL>
-<LI><A HREF="#Chicken_nn3">20.1.1 Running SWIG in C mode</A></LI>
-<LI><A HREF="#Chicken_nn4">20.1.2 Running SWIG in C++ mode</A></LI>
+<LI><A HREF="#Chicken_nn3">21.1.1 Running SWIG in C mode</A></LI>
+<LI><A HREF="#Chicken_nn4">21.1.2 Running SWIG in C++ mode</A></LI>
</UL>
</LI>
-<LI><A HREF="#Chicken_nn5">20.2 Code Generation</A>
+<LI><A HREF="#Chicken_nn5">21.2 Code Generation</A>
<UL>
-<LI><A HREF="#Chicken_nn6">20.2.1 Naming Conventions</A></LI>
-<LI><A HREF="#Chicken_nn7">20.2.2 Modules</A></LI>
-<LI><A HREF="#Chicken_nn8">20.2.3 Constants and Variables</A></LI>
-<LI><A HREF="#Chicken_nn9">20.2.4 Functions</A></LI>
-<LI><A HREF="#Chicken_nn10">20.2.5 Exceptions</A></LI>
+<LI><A HREF="#Chicken_nn6">21.2.1 Naming Conventions</A></LI>
+<LI><A HREF="#Chicken_nn7">21.2.2 Modules</A></LI>
+<LI><A HREF="#Chicken_nn8">21.2.3 Constants and Variables</A></LI>
+<LI><A HREF="#Chicken_nn9">21.2.4 Functions</A></LI>
+<LI><A HREF="#Chicken_nn10">21.2.5 Exceptions</A></LI>
</UL>
</LI>
-<LI><A HREF="#Chicken_nn11">20.3 TinyCLOS</A></LI>
-<LI><A HREF="#Chicken_nn12">20.4 Linkage</A>
+<LI><A HREF="#Chicken_nn11">21.3 TinyCLOS</A></LI>
+<LI><A HREF="#Chicken_nn12">21.4 Linkage</A>
<UL>
-<LI><A HREF="#Chicken_nn13">20.4.1 Static binary or shared library
+<LI><A HREF="#Chicken_nn13">21.4.1 Static binary or shared library
linked at compile time</A></LI>
-<LI><A HREF="#Chicken_nn14">20.4.2 Building chicken extension libraries</A>
+<LI><A HREF="#Chicken_nn14">21.4.2 Building chicken extension libraries</A>
</LI>
-<LI><A HREF="#Chicken_nn15">20.4.3 Linking multiple SWIG modules with
+<LI><A HREF="#Chicken_nn15">21.4.3 Linking multiple SWIG modules with
TinyCLOS</A></LI>
</UL>
</LI>
-<LI><A HREF="#Chicken_nn16">20.5 Typemaps</A></LI>
-<LI><A HREF="#Chicken_nn17">20.6 Pointers</A>
+<LI><A HREF="#Chicken_nn16">21.5 Typemaps</A></LI>
+<LI><A HREF="#Chicken_nn17">21.6 Pointers</A>
<UL>
-<LI><A HREF="#Chicken_collection">20.6.1 Garbage collection</A></LI>
+<LI><A HREF="#Chicken_collection">21.6.1 Garbage collection</A></LI>
</UL>
</LI>
-<LI><A HREF="#Chicken_nn18">20.7 Unsupported features and known problems</A>
+<LI><A HREF="#Chicken_nn18">21.7 Unsupported features and known problems</A>
<UL>
-<LI><A HREF="#Chicken_nn19">20.7.1 TinyCLOS problems with Chicken
+<LI><A HREF="#Chicken_nn19">21.7.1 TinyCLOS problems with Chicken
version <= 1.92</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#D">21 SWIG and D</A></B>
+<B><A HREF="#D">22 SWIG and D</A></B>
<UL>
-<LI><A HREF="#D_introduction">21.1 Introduction</A></LI>
-<LI><A HREF="#D_command_line_invocation">21.2 Command line invocation</A>
+<LI><A HREF="#D_introduction">22.1 Introduction</A></LI>
+<LI><A HREF="#D_command_line_invocation">22.2 Command line invocation</A>
</LI>
-<LI><A HREF="#D_typemaps">21.3 Typemaps</A>
+<LI><A HREF="#D_typemaps">22.3 Typemaps</A>
<UL>
-<LI><A HREF="#D_typemap_name_comparison">21.3.1 C# <-> D name comparison</A>
+<LI><A HREF="#D_typemap_name_comparison">22.3.1 C# <-> D name comparison</A>
</LI>
-<LI><A HREF="#D_ctype_imtype_dtype">21.3.2 ctype, imtype, dtype</A></LI>
-<LI><A HREF="#D_in_out_directorin_direcetorout">21.3.3 in, out,
+<LI><A HREF="#D_ctype_imtype_dtype">22.3.2 ctype, imtype, dtype</A></LI>
+<LI><A HREF="#D_in_out_directorin_direcetorout">22.3.3 in, out,
directorin, directorout</A></LI>
-<LI><A HREF="#D_din_dout_ddirectorin_ddirectorout">21.3.4 din, dout,
+<LI><A HREF="#D_din_dout_ddirectorin_ddirectorout">22.3.4 din, dout,
ddirectorin, ddirectorout</A></LI>
-<LI><A HREF="#D_typecheck_typemaps">21.3.5 typecheck typemaps</A></LI>
-<LI><A HREF="#D_code_injection_typemaps">21.3.6 Code injection typemaps</A>
+<LI><A HREF="#D_typecheck_typemaps">22.3.5 typecheck typemaps</A></LI>
+<LI><A HREF="#D_code_injection_typemaps">22.3.6 Code injection typemaps</A>
</LI>
-<LI><A HREF="#D_special_variables">21.3.7 Special variable macros</A></LI>
+<LI><A HREF="#D_special_variables">22.3.7 Special variable macros</A></LI>
</UL>
</LI>
-<LI><A HREF="#D_features">21.4 %features</A></LI>
-<LI><A HREF="#D_pragmas">21.5 Pragmas</A></LI>
-<LI><A HREF="#D_exceptions">21.6 D Exceptions</A></LI>
-<LI><A HREF="#D_directors">21.7 D Directors</A></LI>
-<LI><A HREF="#D_other_features">21.8 Other features</A>
+<LI><A HREF="#D_features">22.4 D and %feature</A></LI>
+<LI><A HREF="#D_pragmas">22.5 Pragmas</A></LI>
+<LI><A HREF="#D_exceptions">22.6 D Exceptions</A></LI>
+<LI><A HREF="#D_directors">22.7 D Directors</A></LI>
+<LI><A HREF="#D_other_features">22.8 Other features</A>
<UL>
-<LI><A HREF="#D_nspace">21.8.1 Extended namespace support (nspace)</A></LI>
-<LI><A HREF="#D_native_pointer_support">21.8.2 Native pointer support</A>
+<LI><A HREF="#D_nspace">22.8.1 Extended namespace support (nspace)</A></LI>
+<LI><A HREF="#D_native_pointer_support">22.8.2 Native pointer support</A>
</LI>
-<LI><A HREF="#D_operator_overloading">21.8.3 Operator overloading</A></LI>
-<LI><A HREF="#D_test_suite">21.8.4 Running the test-suite</A></LI>
+<LI><A HREF="#D_operator_overloading">22.8.3 Operator overloading</A></LI>
+<LI><A HREF="#D_test_suite">22.8.4 Running the test-suite</A></LI>
</UL>
</LI>
-<LI><A HREF="#D_typemap_examples">21.9 D Typemap examples</A></LI>
-<LI><A HREF="#D_planned_features">21.10 Work in progress and planned
+<LI><A HREF="#D_typemap_examples">22.9 D Typemap examples</A></LI>
+<LI><A HREF="#D_planned_features">22.10 Work in progress and planned
features</A></LI>
</UL>
-<B><A HREF="#Go">22 SWIG and Go</A></B>
+<B><A HREF="#Go">23 SWIG and Go</A></B>
<UL>
-<LI><A HREF="#Go_overview">22.1 Overview</A></LI>
-<LI><A HREF="#Go_running_swig">22.2 Running SWIG with Go</A>
+<LI><A HREF="#Go_overview">23.1 Overview</A></LI>
+<LI><A HREF="#Go_examples">23.2 Examples</A></LI>
+<LI><A HREF="#Go_running_swig">23.3 Running SWIG with Go</A>
<UL>
-<LI><A HREF="#Go_commandline">22.2.1 Additional Commandline Options</A></LI>
-<LI><A HREF="#Go_outputs">22.2.2 Go Output Files</A></LI>
+<LI><A HREF="#Go_commandline">23.3.1 Go-specific Commandline Options</A></LI>
+<LI><A HREF="#Go_outputs">23.3.2 Generated Wrapper Files</A></LI>
</UL>
</LI>
-<LI><A HREF="#Go_basic_tour">22.3 A tour of basic C/C++ wrapping</A>
+<LI><A HREF="#Go_basic_tour">23.4 A tour of basic C/C++ wrapping</A>
<UL>
-<LI><A HREF="#Go_package">22.3.1 Go Package Name</A></LI>
-<LI><A HREF="#Go_names">22.3.2 Go Names</A></LI>
-<LI><A HREF="#Go_constants">22.3.3 Go Constants</A></LI>
-<LI><A HREF="#Go_enumerations">22.3.4 Go Enumerations</A></LI>
-<LI><A HREF="#Go_classes">22.3.5 Go Classes</A>
+<LI><A HREF="#Go_package">23.4.1 Go Package Name</A></LI>
+<LI><A HREF="#Go_names">23.4.2 Go Names</A></LI>
+<LI><A HREF="#Go_constants">23.4.3 Go Constants</A></LI>
+<LI><A HREF="#Go_enumerations">23.4.4 Go Enumerations</A></LI>
+<LI><A HREF="#Go_classes">23.4.5 Go Classes</A>
+<UL>
+<LI><A HREF="#Go_class_memory">23.4.5.1 Go Class Memory Management</A></LI>
+<LI><A HREF="#Go_class_inheritance">23.4.5.2 Go Class Inheritance</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Go_templates">23.4.6 Go Templates</A></LI>
+<LI><A HREF="#Go_director_classes">23.4.7 Go Director Classes</A>
<UL>
-<LI><A HREF="#Go_class_inheritance">22.3.5.1 Go Class Inheritance</A></LI>
+<LI><A HREF="#Go_director_example_cpp_code">23.4.7.1 Example C++ code</A>
+</LI>
+<LI><A HREF="#Go_director_enable">23.4.7.2 Enable director feature</A></LI>
+<LI><A HREF="#Go_director_ctor_dtor">23.4.7.3 Constructor and destructor</A>
+</LI>
+<LI><A HREF="#Go_director_overriding">23.4.7.4 Override virtual methods</A>
+</LI>
+<LI><A HREF="#Go_director_base_methods">23.4.7.5 Call base methods</A></LI>
+<LI><A HREF="#Go_director_subclass">23.4.7.6 Subclass via embedding</A></LI>
+<LI><A HREF="#Go_director_finalizer">23.4.7.7 Memory management with
+ runtime.SetFinalizer</A></LI>
+<LI><A HREF="#Go_director_foobargo_class">23.4.7.8 Complete FooBarGo
+ example class</A></LI>
</UL>
</LI>
-<LI><A HREF="#Go_templates">22.3.6 Go Templates</A></LI>
-<LI><A HREF="#Go_director_classes">22.3.7 Go Director Classes</A></LI>
-<LI><A HREF="#Go_primitive_type_mappings">22.3.8 Default Go primitive
+<LI><A HREF="#Go_primitive_type_mappings">23.4.8 Default Go primitive
type mappings</A></LI>
-<LI><A HREF="#Go_output_arguments">22.3.9 Output arguments</A></LI>
-<LI><A HREF="#Go_adding_additional_code">22.3.10 Adding additional go
+<LI><A HREF="#Go_output_arguments">23.4.9 Output arguments</A></LI>
+<LI><A HREF="#Go_adding_additional_code">23.4.10 Adding additional go
code</A></LI>
+<LI><A HREF="#Go_typemaps">23.4.11 Go typemaps</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#Guile">23 SWIG and Guile</A></B>
+<B><A HREF="#Guile">24 SWIG and Guile</A></B>
<UL>
-<LI><A HREF="#Guile_nn1">23.1 Supported Guile Versions</A></LI>
-<LI><A HREF="#Guile_nn2">23.2 Meaning of "Module"</A></LI>
-<LI><A HREF="#Guile_nn3">23.3 Old GH Guile API</A></LI>
-<LI><A HREF="#Guile_nn4">23.4 Linkage</A>
+<LI><A HREF="#Guile_nn1">24.1 Supported Guile Versions</A></LI>
+<LI><A HREF="#Guile_nn2">24.2 Meaning of "Module"</A></LI>
+<LI><A HREF="#Guile_nn3">24.3 Old GH Guile API</A></LI>
+<LI><A HREF="#Guile_nn4">24.4 Linkage</A>
<UL>
-<LI><A HREF="#Guile_nn5">23.4.1 Simple Linkage</A></LI>
-<LI><A HREF="#Guile_nn6">23.4.2 Passive Linkage</A></LI>
-<LI><A HREF="#Guile_nn7">23.4.3 Native Guile Module Linkage</A></LI>
-<LI><A HREF="#Guile_nn8">23.4.4 Old Auto-Loading Guile Module Linkage</A>
+<LI><A HREF="#Guile_nn5">24.4.1 Simple Linkage</A></LI>
+<LI><A HREF="#Guile_nn6">24.4.2 Passive Linkage</A></LI>
+<LI><A HREF="#Guile_nn7">24.4.3 Native Guile Module Linkage</A></LI>
+<LI><A HREF="#Guile_nn8">24.4.4 Old Auto-Loading Guile Module Linkage</A>
</LI>
-<LI><A HREF="#Guile_nn9">23.4.5 Hobbit4D Linkage</A></LI>
+<LI><A HREF="#Guile_nn9">24.4.5 Hobbit4D Linkage</A></LI>
</UL>
</LI>
-<LI><A HREF="#Guile_nn10">23.5 Underscore Folding</A></LI>
-<LI><A HREF="#Guile_nn11">23.6 Typemaps</A></LI>
-<LI><A HREF="#Guile_nn12">23.7 Representation of pointers as smobs</A>
+<LI><A HREF="#Guile_nn10">24.5 Underscore Folding</A></LI>
+<LI><A HREF="#Guile_nn11">24.6 Typemaps</A></LI>
+<LI><A HREF="#Guile_nn12">24.7 Representation of pointers as smobs</A>
<UL>
-<LI><A HREF="#Guile_nn14">23.7.1 Smobs</A></LI>
-<LI><A HREF="#Guile_nn15">23.7.2 Garbage Collection</A></LI>
+<LI><A HREF="#Guile_nn14">24.7.1 Smobs</A></LI>
+<LI><A HREF="#Guile_nn15">24.7.2 Garbage Collection</A></LI>
</UL>
</LI>
-<LI><A HREF="#Guile_nn16">23.8 Exception Handling</A></LI>
-<LI><A HREF="#Guile_nn17">23.9 Procedure documentation</A></LI>
-<LI><A HREF="#Guile_nn18">23.10 Procedures with setters</A></LI>
-<LI><A HREF="#Guile_nn19">23.11 GOOPS Proxy Classes</A>
+<LI><A HREF="#Guile_nn16">24.8 Exception Handling</A></LI>
+<LI><A HREF="#Guile_nn17">24.9 Procedure documentation</A></LI>
+<LI><A HREF="#Guile_nn18">24.10 Procedures with setters</A></LI>
+<LI><A HREF="#Guile_nn19">24.11 GOOPS Proxy Classes</A>
<UL>
-<LI><A HREF="#Guile_nn20">23.11.1 Naming Issues</A></LI>
-<LI><A HREF="#Guile_nn21">23.11.2 Linking</A></LI>
+<LI><A HREF="#Guile_nn20">24.11.1 Naming Issues</A></LI>
+<LI><A HREF="#Guile_nn21">24.11.2 Linking</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#Java">24 SWIG and Java</A></B>
+<B><A HREF="#Java">25 SWIG and Java</A></B>
<UL>
-<LI><A HREF="#Java_overview">24.1 Overview</A></LI>
-<LI><A HREF="#Java_preliminaries">24.2 Preliminaries</A>
+<LI><A HREF="#Java_overview">25.1 Overview</A></LI>
+<LI><A HREF="#Java_preliminaries">25.2 Preliminaries</A>
<UL>
-<LI><A HREF="#Java_running_swig">24.2.1 Running SWIG</A></LI>
-<LI><A HREF="#Java_commandline">24.2.2 Additional Commandline Options</A>
+<LI><A HREF="#Java_running_swig">25.2.1 Running SWIG</A></LI>
+<LI><A HREF="#Java_commandline">25.2.2 Additional Commandline Options</A>
</LI>
-<LI><A HREF="#Java_getting_right_headers">24.2.3 Getting the right
+<LI><A HREF="#Java_getting_right_headers">25.2.3 Getting the right
header files</A></LI>
-<LI><A HREF="#Java_compiling_dynamic">24.2.4 Compiling a dynamic module</A>
+<LI><A HREF="#Java_compiling_dynamic">25.2.4 Compiling a dynamic module</A>
</LI>
-<LI><A HREF="#Java_using_module">24.2.5 Using your module</A></LI>
-<LI><A HREF="#Java_dynamic_linking_problems">24.2.6 Dynamic linking
+<LI><A HREF="#Java_using_module">25.2.5 Using your module</A></LI>
+<LI><A HREF="#Java_dynamic_linking_problems">25.2.6 Dynamic linking
problems</A></LI>
-<LI><A HREF="#Java_compilation_problems_cpp">24.2.7 Compilation problems
+<LI><A HREF="#Java_compilation_problems_cpp">25.2.7 Compilation problems
and compiling with C++</A></LI>
-<LI><A HREF="#Java_building_windows">24.2.8 Building on Windows</A>
+<LI><A HREF="#Java_building_windows">25.2.8 Building on Windows</A>
<UL>
-<LI><A HREF="#Java_visual_studio">24.2.8.1 Running SWIG from Visual
+<LI><A HREF="#Java_visual_studio">25.2.8.1 Running SWIG from Visual
Studio</A></LI>
-<LI><A HREF="#Java_nmake">24.2.8.2 Using NMAKE</A></LI>
+<LI><A HREF="#Java_nmake">25.2.8.2 Using NMAKE</A></LI>
</UL>
</LI>
</UL>
</LI>
-<LI><A HREF="#Java_basic_tour">24.3 A tour of basic C/C++ wrapping</A>
+<LI><A HREF="#Java_basic_tour">25.3 A tour of basic C/C++ wrapping</A>
<UL>
-<LI><A HREF="#Java_module_packages_classes">24.3.1 Modules, packages and
+<LI><A HREF="#Java_module_packages_classes">25.3.1 Modules, packages and
generated Java classes</A></LI>
-<LI><A HREF="#Java_functions">24.3.2 Functions</A></LI>
-<LI><A HREF="#Java_global_variables">24.3.3 Global variables</A></LI>
-<LI><A HREF="#Java_constants">24.3.4 Constants</A></LI>
-<LI><A HREF="#Java_enumerations">24.3.5 Enumerations</A>
-<UL>
-<LI><A HREF="#Java_anonymous_enums">24.3.5.1 Anonymous enums</A></LI>
-<LI><A HREF="#Java_typesafe_enums">24.3.5.2 Typesafe enums</A></LI>
-<LI><A HREF="#Java_proper_enums">24.3.5.3 Proper Java enums</A></LI>
-<LI><A HREF="#Java_typeunsafe_enums">24.3.5.4 Type unsafe enums</A></LI>
-<LI><A HREF="#Java_simple_enums">24.3.5.5 Simple enums</A></LI>
-</UL>
-</LI>
-<LI><A HREF="#Java_pointers">24.3.6 Pointers</A></LI>
-<LI><A HREF="#Java_structures">24.3.7 Structures</A></LI>
-<LI><A HREF="#Java_classes">24.3.8 C++ classes</A></LI>
-<LI><A HREF="#Java_inheritance">24.3.9 C++ inheritance</A></LI>
-<LI><A HREF="#Java_pointers_refs_arrays">24.3.10 Pointers, references,
+<LI><A HREF="#Java_functions">25.3.2 Functions</A></LI>
+<LI><A HREF="#Java_global_variables">25.3.3 Global variables</A></LI>
+<LI><A HREF="#Java_constants">25.3.4 Constants</A></LI>
+<LI><A HREF="#Java_enumerations">25.3.5 Enumerations</A>
+<UL>
+<LI><A HREF="#Java_anonymous_enums">25.3.5.1 Anonymous enums</A></LI>
+<LI><A HREF="#Java_typesafe_enums">25.3.5.2 Typesafe enums</A></LI>
+<LI><A HREF="#Java_proper_enums">25.3.5.3 Proper Java enums</A></LI>
+<LI><A HREF="#Java_typeunsafe_enums">25.3.5.4 Type unsafe enums</A></LI>
+<LI><A HREF="#Java_simple_enums">25.3.5.5 Simple enums</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Java_pointers">25.3.6 Pointers</A></LI>
+<LI><A HREF="#Java_structures">25.3.7 Structures</A></LI>
+<LI><A HREF="#Java_classes">25.3.8 C++ classes</A></LI>
+<LI><A HREF="#Java_inheritance">25.3.9 C++ inheritance</A></LI>
+<LI><A HREF="#Java_pointers_refs_arrays">25.3.10 Pointers, references,
arrays and pass by value</A>
<UL>
-<LI><A HREF="#Java_null_pointers">24.3.10.1 Null pointers</A></LI>
+<LI><A HREF="#Java_null_pointers">25.3.10.1 Null pointers</A></LI>
</UL>
</LI>
-<LI><A HREF="#Java_overloaded_functions">24.3.11 C++ overloaded
+<LI><A HREF="#Java_overloaded_functions">25.3.11 C++ overloaded
functions</A></LI>
-<LI><A HREF="#Java_default_arguments">24.3.12 C++ default arguments</A></LI>
-<LI><A HREF="#Java_namespaces">24.3.13 C++ namespaces</A></LI>
-<LI><A HREF="#Java_templates">24.3.14 C++ templates</A></LI>
-<LI><A HREF="#Java_smart_pointers">24.3.15 C++ Smart Pointers</A></LI>
+<LI><A HREF="#Java_default_arguments">25.3.12 C++ default arguments</A></LI>
+<LI><A HREF="#Java_namespaces">25.3.13 C++ namespaces</A></LI>
+<LI><A HREF="#Java_templates">25.3.14 C++ templates</A></LI>
+<LI><A HREF="#Java_smart_pointers">25.3.15 C++ Smart Pointers</A>
+<UL>
+<LI><A HREF="#Java_smart_pointers_shared_ptr">25.3.15.1 The shared_ptr
+ Smart Pointer</A></LI>
+<LI><A HREF="#Java_smart_pointers_generic">25.3.15.2 Generic Smart
+ Pointers</A></LI>
+</UL>
+</LI>
</UL>
</LI>
-<LI><A HREF="#Java_further_details">24.4 Further details on the
+<LI><A HREF="#Java_further_details">25.4 Further details on the
generated Java classes</A>
<UL>
-<LI><A HREF="#Java_imclass">24.4.1 The intermediary JNI class</A>
+<LI><A HREF="#Java_imclass">25.4.1 The intermediary JNI class</A>
<UL>
-<LI><A HREF="#Java_imclass_pragmas">24.4.1.1 The intermediary JNI class
+<LI><A HREF="#Java_imclass_pragmas">25.4.1.1 The intermediary JNI class
pragmas</A></LI>
</UL>
</LI>
-<LI><A HREF="#Java_module_class">24.4.2 The Java module class</A>
+<LI><A HREF="#Java_module_class">25.4.2 The Java module class</A>
<UL>
-<LI><A HREF="#Java_module_class_pragmas">24.4.2.1 The Java module class
+<LI><A HREF="#Java_module_class_pragmas">25.4.2.1 The Java module class
pragmas</A></LI>
</UL>
</LI>
-<LI><A HREF="#Java_proxy_classes">24.4.3 Java proxy classes</A>
+<LI><A HREF="#Java_proxy_classes">25.4.3 Java proxy classes</A>
<UL>
-<LI><A HREF="#Java_memory_management">24.4.3.1 Memory management</A></LI>
-<LI><A HREF="#Java_inheritance_mirroring">24.4.3.2 Inheritance</A></LI>
-<LI><A HREF="#Java_proxy_classes_gc">24.4.3.3 Proxy classes and garbage
+<LI><A HREF="#Java_memory_management">25.4.3.1 Memory management</A></LI>
+<LI><A HREF="#Java_inheritance_mirroring">25.4.3.2 Inheritance</A></LI>
+<LI><A HREF="#Java_proxy_classes_gc">25.4.3.3 Proxy classes and garbage
collection</A></LI>
-<LI><A HREF="#Java_pgcpp">24.4.3.4 The premature garbage collection
+<LI><A HREF="#Java_pgcpp">25.4.3.4 The premature garbage collection
prevention parameter for proxy class marshalling</A></LI>
-<LI><A HREF="#Java_multithread_libraries">24.4.3.5 Single threaded
+<LI><A HREF="#Java_multithread_libraries">25.4.3.5 Single threaded
applications and thread safety</A></LI>
</UL>
</LI>
-<LI><A HREF="#Java_type_wrapper_classes">24.4.4 Type wrapper classes</A></LI>
-<LI><A HREF="#Java_enum_classes">24.4.5 Enum classes</A>
+<LI><A HREF="#Java_type_wrapper_classes">25.4.4 Type wrapper classes</A></LI>
+<LI><A HREF="#Java_enum_classes">25.4.5 Enum classes</A>
<UL>
-<LI><A HREF="#Java_typesafe_enums_classes">24.4.5.1 Typesafe enum
+<LI><A HREF="#Java_typesafe_enums_classes">25.4.5.1 Typesafe enum
classes</A></LI>
-<LI><A HREF="#Java_proper_enums_classes">24.4.5.2 Proper Java enum
+<LI><A HREF="#Java_proper_enums_classes">25.4.5.2 Proper Java enum
classes</A></LI>
-<LI><A HREF="#Java_typeunsafe_enums_classes">24.4.5.3 Type unsafe enum
+<LI><A HREF="#Java_typeunsafe_enums_classes">25.4.5.3 Type unsafe enum
classes</A></LI>
</UL>
</LI>
+<LI><A HREF="#Java_interfaces">25.4.6 Interfaces</A></LI>
</UL>
</LI>
-<LI><A HREF="#Java_directors">24.5 Cross language polymorphism using
+<LI><A HREF="#Java_directors">25.5 Cross language polymorphism using
directors</A>
<UL>
-<LI><A HREF="#Java_enabling_directors">24.5.1 Enabling directors</A></LI>
-<LI><A HREF="#Java_directors_classes">24.5.2 Director classes</A></LI>
-<LI><A HREF="#Java_directors_overhead">24.5.3 Overhead and code bloat</A>
+<LI><A HREF="#Java_enabling_directors">25.5.1 Enabling directors</A></LI>
+<LI><A HREF="#Java_directors_classes">25.5.2 Director classes</A></LI>
+<LI><A HREF="#Java_directors_overhead">25.5.3 Overhead and code bloat</A>
</LI>
-<LI><A HREF="#Java_directors_example">24.5.4 Simple directors example</A>
+<LI><A HREF="#Java_directors_example">25.5.4 Simple directors example</A>
</LI>
-<LI><A HREF="#Java_directors_threading">24.5.5 Director threading issues</A>
+<LI><A HREF="#Java_directors_threading">25.5.5 Director threading issues</A>
</LI>
-<LI><A HREF="#Java_directors_performance">24.5.6 Director performance
+<LI><A HREF="#Java_directors_performance">25.5.6 Director performance
tuning</A></LI>
+<LI><A HREF="#Java_exceptions_from_directors">25.5.7 Java exceptions
+ from directors</A></LI>
</UL>
</LI>
-<LI><A HREF="#Java_allprotected">24.6 Accessing protected members</A></LI>
-<LI><A HREF="#Java_common_customization">24.7 Common customization
+<LI><A HREF="#Java_allprotected">25.6 Accessing protected members</A></LI>
+<LI><A HREF="#Java_common_customization">25.7 Common customization
features</A>
<UL>
-<LI><A HREF="#Java_helper_functions">24.7.1 C/C++ helper functions</A></LI>
-<LI><A HREF="#Java_class_extension">24.7.2 Class extension with %extend</A>
+<LI><A HREF="#Java_helper_functions">25.7.1 C/C++ helper functions</A></LI>
+<LI><A HREF="#Java_class_extension">25.7.2 Class extension with %extend</A>
</LI>
-<LI><A HREF="#Java_exception_handling">24.7.3 Exception handling with
+<LI><A HREF="#Java_exception_handling">25.7.3 Exception handling with
%exception and %javaexception</A></LI>
-<LI><A HREF="#Java_method_access">24.7.4 Method access with
+<LI><A HREF="#Java_method_access">25.7.4 Method access with
%javamethodmodifiers</A></LI>
</UL>
</LI>
-<LI><A HREF="#Java_tips_techniques">24.8 Tips and techniques</A>
+<LI><A HREF="#Java_tips_techniques">25.8 Tips and techniques</A>
<UL>
-<LI><A HREF="#Java_input_output_parameters">24.8.1 Input and output
+<LI><A HREF="#Java_input_output_parameters">25.8.1 Input and output
parameters using primitive pointers and references</A></LI>
-<LI><A HREF="#Java_simple_pointers">24.8.2 Simple pointers</A></LI>
-<LI><A HREF="#Java_c_arrays">24.8.3 Wrapping C arrays with Java arrays</A>
+<LI><A HREF="#Java_simple_pointers">25.8.2 Simple pointers</A></LI>
+<LI><A HREF="#Java_c_arrays">25.8.3 Wrapping C arrays with Java arrays</A>
</LI>
-<LI><A HREF="#Java_unbounded_c_arrays">24.8.4 Unbounded C Arrays</A></LI>
-<LI><A HREF="#Java_binary_char">24.8.5 Binary data vs Strings</A></LI>
-<LI><A HREF="#Java_heap_allocations">24.8.6 Overriding new and delete to
+<LI><A HREF="#Java_unbounded_c_arrays">25.8.4 Unbounded C Arrays</A></LI>
+<LI><A HREF="#Java_binary_char">25.8.5 Binary data vs Strings</A></LI>
+<LI><A HREF="#Java_heap_allocations">25.8.6 Overriding new and delete to
allocate from Java heap</A></LI>
</UL>
</LI>
-<LI><A HREF="#Java_typemaps">24.9 Java typemaps</A>
+<LI><A HREF="#Java_typemaps">25.9 Java typemaps</A>
<UL>
-<LI><A HREF="#Java_default_primitive_type_mappings">24.9.1 Default
+<LI><A HREF="#Java_default_primitive_type_mappings">25.9.1 Default
primitive type mappings</A></LI>
-<LI><A HREF="#Java_default_non_primitive_typemaps">24.9.2 Default
+<LI><A HREF="#Java_default_non_primitive_typemaps">25.9.2 Default
typemaps for non-primitive types</A></LI>
-<LI><A HREF="#Java_jvm64">24.9.3 Sixty four bit JVMs</A></LI>
-<LI><A HREF="#Java_what_is_typemap">24.9.4 What is a typemap?</A></LI>
-<LI><A HREF="#Java_typemaps_c_to_java_types">24.9.5 Typemaps for mapping
+<LI><A HREF="#Java_jvm64">25.9.3 Sixty four bit JVMs</A></LI>
+<LI><A HREF="#Java_what_is_typemap">25.9.4 What is a typemap?</A></LI>
+<LI><A HREF="#Java_typemaps_c_to_java_types">25.9.5 Typemaps for mapping
C/C++ types to Java types</A></LI>
-<LI><A HREF="#Java_typemap_attributes">24.9.6 Java typemap attributes</A>
+<LI><A HREF="#Java_typemap_attributes">25.9.6 Java typemap attributes</A>
</LI>
-<LI><A HREF="#Java_special_variables">24.9.7 Java special variables</A></LI>
-<LI><A HREF="#Java_typemaps_for_c_and_cpp">24.9.8 Typemaps for both C
+<LI><A HREF="#Java_special_variables">25.9.7 Java special variables</A></LI>
+<LI><A HREF="#Java_typemaps_for_c_and_cpp">25.9.8 Typemaps for both C
and C++ compilation</A></LI>
-<LI><A HREF="#Java_code_typemaps">24.9.9 Java code typemaps</A></LI>
-<LI><A HREF="#Java_directors_typemaps">24.9.10 Director specific
+<LI><A HREF="#Java_code_typemaps">25.9.9 Java code typemaps</A></LI>
+<LI><A HREF="#Java_directors_typemaps">25.9.10 Director specific
typemaps</A></LI>
</UL>
</LI>
-<LI><A HREF="#Java_typemap_examples">24.10 Typemap Examples</A>
+<LI><A HREF="#Java_typemap_examples">25.10 Typemap Examples</A>
<UL>
-<LI><A HREF="#Java_simpler_enum_classes">24.10.1 Simpler Java enums for
+<LI><A HREF="#Java_simpler_enum_classes">25.10.1 Simpler Java enums for
enums without initializers</A></LI>
-<LI><A HREF="#Java_exception_typemap">24.10.2 Handling C++ exception
+<LI><A HREF="#Java_exception_typemap">25.10.2 Handling C++ exception
specifications as Java exceptions</A></LI>
-<LI><A HREF="#Java_nan_exception_typemap">24.10.3 NaN Exception -
+<LI><A HREF="#Java_nan_exception_typemap">25.10.3 NaN Exception -
exception handling for a particular type</A></LI>
-<LI><A HREF="#Java_converting_java_string_arrays">24.10.4 Converting
+<LI><A HREF="#Java_converting_java_string_arrays">25.10.4 Converting
Java String arrays to char **</A></LI>
-<LI><A HREF="#Java_expanding_java_object">24.10.5 Expanding a Java
+<LI><A HREF="#Java_expanding_java_object">25.10.5 Expanding a Java
object to multiple arguments</A></LI>
-<LI><A HREF="#Java_using_typemaps_return_arguments">24.10.6 Using
+<LI><A HREF="#Java_using_typemaps_return_arguments">25.10.6 Using
typemaps to return arguments</A></LI>
-<LI><A HREF="#Java_adding_downcasts">24.10.7 Adding Java downcasts to
+<LI><A HREF="#Java_adding_downcasts">25.10.7 Adding Java downcasts to
polymorphic return types</A></LI>
-<LI><A HREF="#Java_adding_equals_method">24.10.8 Adding an equals method
+<LI><A HREF="#Java_adding_equals_method">25.10.8 Adding an equals method
to the Java classes</A></LI>
-<LI><A HREF="#Java_void_pointers">24.10.9 Void pointers and a common
+<LI><A HREF="#Java_void_pointers">25.10.9 Void pointers and a common
Java base class</A></LI>
-<LI><A HREF="#Java_struct_pointer_pointer">24.10.10 Struct pointer to
+<LI><A HREF="#Java_struct_pointer_pointer">25.10.10 Struct pointer to
pointer</A></LI>
-<LI><A HREF="#Java_memory_management_member_variables">24.10.11 Memory
+<LI><A HREF="#Java_memory_management_member_variables">25.10.11 Memory
management when returning references to member variables</A></LI>
-<LI><A HREF="#Java_memory_management_objects">24.10.12 Memory management
+<LI><A HREF="#Java_memory_management_objects">25.10.12 Memory management
for objects passed to the C++ layer</A></LI>
-<LI><A HREF="#Java_date_marshalling">24.10.13 Date marshalling using the
+<LI><A HREF="#Java_date_marshalling">25.10.13 Date marshalling using the
javain typemap and associated attributes</A></LI>
</UL>
</LI>
-<LI><A HREF="#Java_directors_faq">24.11 Living with Java Directors</A></LI>
-<LI><A HREF="#Java_odds_ends">24.12 Odds and ends</A>
+<LI><A HREF="#Java_directors_faq">25.11 Living with Java Directors</A></LI>
+<LI><A HREF="#Java_odds_ends">25.12 Odds and ends</A>
<UL>
-<LI><A HREF="#Java_javadoc_comments">24.12.1 JavaDoc comments</A></LI>
-<LI><A HREF="#Java_functional_interface">24.12.2 Functional interface
+<LI><A HREF="#Java_javadoc_comments">25.12.1 JavaDoc comments</A></LI>
+<LI><A HREF="#Java_functional_interface">25.12.2 Functional interface
without proxy classes</A></LI>
-<LI><A HREF="#Java_using_own_jni_functions">24.12.3 Using your own JNI
+<LI><A HREF="#Java_using_own_jni_functions">25.12.3 Using your own JNI
functions</A></LI>
-<LI><A HREF="#Java_performance">24.12.4 Performance concerns and hints</A>
+<LI><A HREF="#Java_performance">25.12.4 Performance concerns and hints</A>
+</LI>
+<LI><A HREF="#Java_debugging">25.12.5 Debugging</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Java_examples">25.13 Java Examples</A></LI>
+</UL>
+<B><A HREF="#Javascript">26 SWIG and Javascript</A></B>
+<UL>
+<LI><A HREF="#Javascript_overview">26.1 Overview</A></LI>
+<LI><A HREF="#Javascript_preliminaries">26.2 Preliminaries</A>
+<UL>
+<LI><A HREF="#Javascript_running_swig">26.2.1 Running SWIG</A></LI>
+<LI><A HREF="#Javascript_running_tests_examples">26.2.2 Running Tests
+ and Examples</A></LI>
+<LI><A HREF="#Javascript_known_issues">26.2.3 Known Issues</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Javascript_integration">26.3 Integration</A>
+<UL>
+<LI><A HREF="#Javascript_node_extensions">26.3.1 Creating node.js
+ Extensions</A>
+<UL>
+<LI><A HREF="#Javascript_troubleshooting">26.3.1.1 Troubleshooting</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Javascript_embedded_webkit">26.3.2 Embedded Webkit</A>
+<UL>
+<LI><A HREF="#Javascript_osx">26.3.2.1 Mac OS X</A></LI>
+<LI><A HREF="#Javascript_gtk">26.3.2.2 GTK</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Javascript_applications_webkit">26.3.3 Creating
+ Applications with node-webkit</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Javascript_examples">26.4 Examples</A>
+<UL>
+<LI><A HREF="#Javascript_simple_example">26.4.1 Simple</A></LI>
+<LI><A HREF="#Javascript_class_example">26.4.2 Class</A></LI>
+</UL>
</LI>
-<LI><A HREF="#Java_debugging">24.12.5 Debugging</A></LI>
+<LI><A HREF="#Javascript_implementation">26.5 Implementation</A>
+<UL>
+<LI><A HREF="#Javascript_source_code">26.5.1 Source Code</A></LI>
+<LI><A HREF="#Javascript_code_templates">26.5.2 Code Templates</A></LI>
+<LI><A HREF="#Javascript_emitter">26.5.3 Emitter</A></LI>
+<LI><A HREF="#Javascript_emitter_states">26.5.4 Emitter states</A></LI>
+<LI><A HREF="#Javascript_jsc_exceptions">26.5.5 Handling Exceptions in
+ JavascriptCore</A></LI>
</UL>
</LI>
-<LI><A HREF="#Java_examples">24.13 Java Examples</A></LI>
</UL>
-<B><A HREF="#Lisp">25 SWIG and Common Lisp</A></B>
+<B><A HREF="#Lisp">27 SWIG and Common Lisp</A></B>
<UL>
-<LI><A HREF="#Lisp_nn2">25.1 Allegro Common Lisp</A></LI>
-<LI><A HREF="#Lisp_nn3">25.2 Common Foreign Function Interface(CFFI)</A>
+<LI><A HREF="#Lisp_nn2">27.1 Allegro Common Lisp</A></LI>
+<LI><A HREF="#Lisp_nn3">27.2 Common Foreign Function Interface(CFFI)</A>
<UL>
-<LI><A HREF="#Lisp_nn4">25.2.1 Additional Commandline Options</A></LI>
-<LI><A HREF="#Lisp_nn5">25.2.2 Generating CFFI bindings</A></LI>
-<LI><A HREF="#Lisp_nn6">25.2.3 Generating CFFI bindings for C++ code</A></LI>
-<LI><A HREF="#Lisp_nn7">25.2.4 Inserting user code into generated files</A>
+<LI><A HREF="#Lisp_nn4">27.2.1 Additional Commandline Options</A></LI>
+<LI><A HREF="#Lisp_nn5">27.2.2 Generating CFFI bindings</A></LI>
+<LI><A HREF="#Lisp_nn6">27.2.3 Generating CFFI bindings for C++ code</A></LI>
+<LI><A HREF="#Lisp_nn7">27.2.4 Inserting user code into generated files</A>
</LI>
</UL>
</LI>
-<LI><A HREF="#Lisp_nn8">25.3 CLISP</A>
+<LI><A HREF="#Lisp_nn8">27.3 CLISP</A>
<UL>
-<LI><A HREF="#Lisp_nn9">25.3.1 Additional Commandline Options</A></LI>
-<LI><A HREF="#Lisp_nn10">25.3.2 Details on CLISP bindings</A></LI>
+<LI><A HREF="#Lisp_nn9">27.3.1 Additional Commandline Options</A></LI>
+<LI><A HREF="#Lisp_nn10">27.3.2 Details on CLISP bindings</A></LI>
</UL>
</LI>
-<LI><A HREF="#Lisp_nn11">25.4 UFFI</A></LI>
+<LI><A HREF="#Lisp_nn11">27.4 UFFI</A></LI>
</UL>
-<B><A HREF="#Lua">26 SWIG and Lua</A></B>
+<B><A HREF="#Lua">28 SWIG and Lua</A></B>
<UL>
-<LI><A HREF="#Lua_nn2">26.1 Preliminaries</A></LI>
-<LI><A HREF="#Lua_nn3">26.2 Running SWIG</A>
+<LI><A HREF="#Lua_nn2">28.1 Preliminaries</A></LI>
+<LI><A HREF="#Lua_nn3">28.2 Running SWIG</A>
<UL>
-<LI><A HREF="#Lua_commandline">26.2.1 Additional command line options</A>
+<LI><A HREF="#Lua_commandline">28.2.1 Additional command line options</A>
</LI>
-<LI><A HREF="#Lua_nn4">26.2.2 Compiling and Linking and Interpreter</A></LI>
-<LI><A HREF="#Lua_nn5">26.2.3 Compiling a dynamic module</A></LI>
-<LI><A HREF="#Lua_nn6">26.2.4 Using your module</A></LI>
+<LI><A HREF="#Lua_nn4">28.2.2 Compiling and Linking and Interpreter</A></LI>
+<LI><A HREF="#Lua_nn5">28.2.3 Compiling a dynamic module</A></LI>
+<LI><A HREF="#Lua_nn6">28.2.4 Using your module</A></LI>
</UL>
</LI>
-<LI><A HREF="#Lua_nn7">26.3 A tour of basic C/C++ wrapping</A>
+<LI><A HREF="#Lua_nn7">28.3 A tour of basic C/C++ wrapping</A>
+<UL>
+<LI><A HREF="#Lua_nn8">28.3.1 Modules</A></LI>
+<LI><A HREF="#Lua_nn9">28.3.2 Functions</A></LI>
+<LI><A HREF="#Lua_nn10">28.3.3 Global variables</A></LI>
+<LI><A HREF="#Lua_nn11">28.3.4 Constants and enums</A>
<UL>
-<LI><A HREF="#Lua_nn8">26.3.1 Modules</A></LI>
-<LI><A HREF="#Lua_nn9">26.3.2 Functions</A></LI>
-<LI><A HREF="#Lua_nn10">26.3.3 Global variables</A></LI>
-<LI><A HREF="#Lua_nn11">26.3.4 Constants and enums</A></LI>
-<LI><A HREF="#Lua_nn12">26.3.5 Pointers</A></LI>
-<LI><A HREF="#Lua_nn13">26.3.6 Structures</A></LI>
-<LI><A HREF="#Lua_nn14">26.3.7 C++ classes</A></LI>
-<LI><A HREF="#Lua_nn15">26.3.8 C++ inheritance</A></LI>
-<LI><A HREF="#Lua_nn16">26.3.9 Pointers, references, values, and arrays</A>
+<LI><A HREF="#Lua_nn13">28.3.4.1 Constants/enums and classes/structures</A>
</LI>
-<LI><A HREF="#Lua_nn17">26.3.10 C++ overloaded functions</A></LI>
-<LI><A HREF="#Lua_nn18">26.3.11 C++ operators</A></LI>
-<LI><A HREF="#Lua_nn19">26.3.12 Class extension with %extend</A></LI>
-<LI><A HREF="#Lua_nn20">26.3.13 Using %newobject to release memory</A></LI>
-<LI><A HREF="#Lua_nn21">26.3.14 C++ templates</A></LI>
-<LI><A HREF="#Lua_nn22">26.3.15 C++ Smart Pointers</A></LI>
-<LI><A HREF="#Lua_nn23">26.3.16 C++ Exceptions</A></LI>
</UL>
</LI>
-<LI><A HREF="#Lua_nn24">26.4 Typemaps</A>
+<LI><A HREF="#Lua_nn12">28.3.5 Pointers</A></LI>
+<LI><A HREF="#Lua_structures">28.3.6 Structures</A></LI>
+<LI><A HREF="#Lua_nn14">28.3.7 C++ classes</A></LI>
+<LI><A HREF="#Lua_nn15">28.3.8 C++ inheritance</A></LI>
+<LI><A HREF="#Lua_nn16">28.3.9 Pointers, references, values, and arrays</A>
+</LI>
+<LI><A HREF="#Lua_nn17">28.3.10 C++ overloaded functions</A></LI>
+<LI><A HREF="#Lua_nn18">28.3.11 C++ operators</A></LI>
+<LI><A HREF="#Lua_nn19">28.3.12 Class extension with %extend</A></LI>
+<LI><A HREF="#Lua_nn20">28.3.13 Using %newobject to release memory</A></LI>
+<LI><A HREF="#Lua_nn21">28.3.14 C++ templates</A></LI>
+<LI><A HREF="#Lua_nn22">28.3.15 C++ Smart Pointers</A></LI>
+<LI><A HREF="#Lua_nn23">28.3.16 C++ Exceptions</A></LI>
+<LI><A HREF="#Lua_namespaces">28.3.17 Namespaces</A>
<UL>
-<LI><A HREF="#Lua_nn25">26.4.1 What is a typemap?</A></LI>
-<LI><A HREF="#Lua_nn26">26.4.2 Using typemaps</A></LI>
-<LI><A HREF="#Lua_nn27">26.4.3 Typemaps and arrays</A></LI>
-<LI><A HREF="#Lua_nn28">26.4.4 Typemaps and pointer-pointer functions</A>
+<LI><A HREF="#Lua_nn27">28.3.17.1 Compatibility Note</A></LI>
+<LI><A HREF="#Lua_nn29">28.3.17.2 Names</A></LI>
+<LI><A HREF="#Lua_nn30">28.3.17.3 Inheritance</A></LI>
+</UL>
+</LI>
+</UL>
</LI>
+<LI><A HREF="#Lua_nn24">28.4 Typemaps</A>
+<UL>
+<LI><A HREF="#Lua_nn25">28.4.1 What is a typemap?</A></LI>
+<LI><A HREF="#Lua_nn26">28.4.2 Using typemaps</A></LI>
+<LI><A HREF="#Lua_typemap_arrays">28.4.3 Typemaps and arrays</A></LI>
+<LI><A HREF="#Lua_typemaps_ptr_ptr_functions">28.4.4 Typemaps and
+ pointer-pointer functions</A></LI>
</UL>
</LI>
-<LI><A HREF="#Lua_nn29">26.5 Writing typemaps</A>
+<LI><A HREF="#Lua_writing_typemaps">28.5 Writing typemaps</A>
<UL>
-<LI><A HREF="#Lua_nn30">26.5.1 Typemaps you can write</A></LI>
-<LI><A HREF="#Lua_nn31">26.5.2 SWIG's Lua-C API</A></LI>
+<LI><A HREF="#Lua_typemaps_write">28.5.1 Typemaps you can write</A></LI>
+<LI><A HREF="#Lua_nn31">28.5.2 SWIG's Lua-C API</A></LI>
</UL>
</LI>
-<LI><A HREF="#Lua_nn32">26.6 Customization of your Bindings</A>
+<LI><A HREF="#Lua_nn32">28.6 Customization of your Bindings</A>
<UL>
-<LI><A HREF="#Lua_nn33">26.6.1 Writing your own custom wrappers</A></LI>
-<LI><A HREF="#Lua_nn34">26.6.2 Adding additional Lua code</A></LI>
+<LI><A HREF="#Lua_nn33">28.6.1 Writing your own custom wrappers</A></LI>
+<LI><A HREF="#Lua_nn34">28.6.2 Adding additional Lua code</A></LI>
</UL>
</LI>
-<LI><A HREF="#Lua_nn35">26.7 Details on the Lua binding</A>
+<LI><A HREF="#Lua_nn35">28.7 Details on the Lua binding</A>
<UL>
-<LI><A HREF="#Lua_nn36">26.7.1 Binding global data into the module.</A></LI>
-<LI><A HREF="#Lua_nn37">26.7.2 Userdata and Metatables</A></LI>
-<LI><A HREF="#Lua_nn38">26.7.3 Memory management</A></LI>
+<LI><A HREF="#Lua_nn36">28.7.1 Binding global data into the module.</A></LI>
+<LI><A HREF="#Lua_nn37">28.7.2 Userdata and Metatables</A></LI>
+<LI><A HREF="#Lua_nn38">28.7.3 Memory management</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#Modula3">27 SWIG and Modula-3</A></B>
+<B><A HREF="#Modula3">29 SWIG and Modula-3</A></B>
<UL>
-<LI><A HREF="#Modula3_modula3_overview">27.1 Overview</A>
+<LI><A HREF="#Modula3_modula3_overview">29.1 Overview</A>
<UL>
-<LI><A HREF="#Modula3_motivation">27.1.1 Motivation</A></LI>
+<LI><A HREF="#Modula3_motivation">29.1.1 Motivation</A></LI>
</UL>
</LI>
-<LI><A HREF="#Modula3_conception">27.2 Conception</A>
+<LI><A HREF="#Modula3_conception">29.2 Conception</A>
<UL>
-<LI><A HREF="#Modula3_cinterface">27.2.1 Interfaces to C libraries</A></LI>
-<LI><A HREF="#Modula3_cppinterface">27.2.2 Interfaces to C++ libraries</A>
+<LI><A HREF="#Modula3_cinterface">29.2.1 Interfaces to C libraries</A></LI>
+<LI><A HREF="#Modula3_cppinterface">29.2.2 Interfaces to C++ libraries</A>
</LI>
</UL>
</LI>
-<LI><A HREF="#Modula3_preliminaries">27.3 Preliminaries</A>
+<LI><A HREF="#Modula3_preliminaries">29.3 Preliminaries</A>
<UL>
-<LI><A HREF="#Modula3_compilers">27.3.1 Compilers</A></LI>
-<LI><A HREF="#Modula3_commandline">27.3.2 Additional Commandline Options</A>
+<LI><A HREF="#Modula3_compilers">29.3.1 Compilers</A></LI>
+<LI><A HREF="#Modula3_commandline">29.3.2 Additional Commandline Options</A>
</LI>
</UL>
</LI>
-<LI><A HREF="#Modula3_typemaps">27.4 Modula-3 typemaps</A>
+<LI><A HREF="#Modula3_typemaps">29.4 Modula-3 typemaps</A>
<UL>
-<LI><A HREF="#Modula3_inoutparam">27.4.1 Inputs and outputs</A></LI>
-<LI><A HREF="#Modula3_ordinals">27.4.2 Subranges, Enumerations, Sets</A></LI>
-<LI><A HREF="#Modula3_class">27.4.3 Objects</A></LI>
-<LI><A HREF="#Modula3_imports">27.4.4 Imports</A></LI>
-<LI><A HREF="#Modula3_exceptions">27.4.5 Exceptions</A></LI>
-<LI><A HREF="#Modula3_typemap_example">27.4.6 Example</A></LI>
+<LI><A HREF="#Modula3_inoutparam">29.4.1 Inputs and outputs</A></LI>
+<LI><A HREF="#Modula3_ordinals">29.4.2 Subranges, Enumerations, Sets</A></LI>
+<LI><A HREF="#Modula3_class">29.4.3 Objects</A></LI>
+<LI><A HREF="#Modula3_imports">29.4.4 Imports</A></LI>
+<LI><A HREF="#Modula3_exceptions">29.4.5 Exceptions</A></LI>
+<LI><A HREF="#Modula3_typemap_example">29.4.6 Example</A></LI>
</UL>
</LI>
-<LI><A HREF="#Modula3_hints">27.5 More hints to the generator</A>
+<LI><A HREF="#Modula3_hints">29.5 More hints to the generator</A>
<UL>
-<LI><A HREF="#Modula3_features">27.5.1 Features</A></LI>
-<LI><A HREF="#Modula3_pragmas">27.5.2 Pragmas</A></LI>
+<LI><A HREF="#Modula3_features">29.5.1 Features</A></LI>
+<LI><A HREF="#Modula3_pragmas">29.5.2 Pragmas</A></LI>
</UL>
</LI>
-<LI><A HREF="#Modula3_remarks">27.6 Remarks</A></LI>
+<LI><A HREF="#Modula3_remarks">29.6 Remarks</A></LI>
</UL>
-<B><A HREF="#Mzscheme">28 SWIG and MzScheme/Racket</A></B>
+<B><A HREF="#Mzscheme">30 SWIG and MzScheme/Racket</A></B>
<UL>
-<LI><A HREF="#MzScheme_nn2">28.1 Creating native structures</A></LI>
-<LI><A HREF="#MzScheme_simple">28.2 Simple example</A></LI>
-<LI><A HREF="#MzScheme_external_docs">28.3 External documentation</A></LI>
+<LI><A HREF="#MzScheme_nn2">30.1 Creating native structures</A></LI>
+<LI><A HREF="#MzScheme_simple">30.2 Simple example</A></LI>
+<LI><A HREF="#MzScheme_external_docs">30.3 External documentation</A></LI>
</UL>
-<B><A HREF="#Ocaml">29 SWIG and Ocaml</A></B>
+<B><A HREF="#Ocaml">31 SWIG and Ocaml</A></B>
<UL>
-<LI><A HREF="#Ocaml_nn2">29.1 Preliminaries</A>
+<LI><A HREF="#Ocaml_nn2">31.1 Preliminaries</A>
<UL>
-<LI><A HREF="#Ocaml_nn3">29.1.1 Running SWIG</A></LI>
-<LI><A HREF="#Ocaml_nn4">29.1.2 Compiling the code</A></LI>
-<LI><A HREF="#Ocaml_nn5">29.1.3 The camlp4 module</A></LI>
-<LI><A HREF="#Ocaml_nn6">29.1.4 Using your module</A></LI>
-<LI><A HREF="#Ocaml_nn7">29.1.5 Compilation problems and compiling with
+<LI><A HREF="#Ocaml_nn3">31.1.1 Running SWIG</A></LI>
+<LI><A HREF="#Ocaml_nn4">31.1.2 Compiling the code</A></LI>
+<LI><A HREF="#Ocaml_nn5">31.1.3 The camlp4 module</A></LI>
+<LI><A HREF="#Ocaml_nn6">31.1.4 Using your module</A></LI>
+<LI><A HREF="#Ocaml_nn7">31.1.5 Compilation problems and compiling with
C++</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ocaml_nn8">29.2 The low-level Ocaml/C interface</A>
+<LI><A HREF="#Ocaml_nn8">31.2 The low-level Ocaml/C interface</A>
<UL>
-<LI><A HREF="#Ocaml_nn9">29.2.1 The generated module</A></LI>
-<LI><A HREF="#Ocaml_nn10">29.2.2 Enums</A>
+<LI><A HREF="#Ocaml_nn9">31.2.1 The generated module</A></LI>
+<LI><A HREF="#Ocaml_nn10">31.2.2 Enums</A>
<UL>
-<LI><A HREF="#Ocaml_nn11">29.2.2.1 Enum typing in Ocaml</A></LI>
+<LI><A HREF="#Ocaml_nn11">31.2.2.1 Enum typing in Ocaml</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ocaml_nn12">29.2.3 Arrays</A>
+<LI><A HREF="#Ocaml_nn12">31.2.3 Arrays</A>
<UL>
-<LI><A HREF="#Ocaml_nn13">29.2.3.1 Simple types of bounded arrays</A></LI>
-<LI><A HREF="#Ocaml_nn14">29.2.3.2 Complex and unbounded arrays</A></LI>
-<LI><A HREF="#Ocaml_nn15">29.2.3.3 Using an object</A></LI>
-<LI><A HREF="#Ocaml_nn16">29.2.3.4 Example typemap for a function taking
+<LI><A HREF="#Ocaml_nn13">31.2.3.1 Simple types of bounded arrays</A></LI>
+<LI><A HREF="#Ocaml_nn14">31.2.3.2 Complex and unbounded arrays</A></LI>
+<LI><A HREF="#Ocaml_nn15">31.2.3.3 Using an object</A></LI>
+<LI><A HREF="#Ocaml_nn16">31.2.3.4 Example typemap for a function taking
float * and int</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ocaml_nn17">29.2.4 C++ Classes</A>
+<LI><A HREF="#Ocaml_nn17">31.2.4 C++ Classes</A>
<UL>
-<LI><A HREF="#Ocaml_nn18">29.2.4.1 STL vector and string Example</A></LI>
-<LI><A HREF="#Ocaml_nn19">29.2.4.2 C++ Class Example</A></LI>
-<LI><A HREF="#Ocaml_nn20">29.2.4.3 Compiling the example</A></LI>
-<LI><A HREF="#Ocaml_nn21">29.2.4.4 Sample Session</A></LI>
+<LI><A HREF="#Ocaml_nn18">31.2.4.1 STL vector and string Example</A></LI>
+<LI><A HREF="#Ocaml_nn19">31.2.4.2 C++ Class Example</A></LI>
+<LI><A HREF="#Ocaml_nn20">31.2.4.3 Compiling the example</A></LI>
+<LI><A HREF="#Ocaml_nn21">31.2.4.4 Sample Session</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ocaml_nn22">29.2.5 Director Classes</A>
+<LI><A HREF="#Ocaml_nn22">31.2.5 Director Classes</A>
<UL>
-<LI><A HREF="#Ocaml_nn23">29.2.5.1 Director Introduction</A></LI>
-<LI><A HREF="#Ocaml_nn24">29.2.5.2 Overriding Methods in Ocaml</A></LI>
-<LI><A HREF="#Ocaml_nn25">29.2.5.3 Director Usage Example</A></LI>
-<LI><A HREF="#Ocaml_nn26">29.2.5.4 Creating director objects</A></LI>
-<LI><A HREF="#Ocaml_nn27">29.2.5.5 Typemaps for directors, directorin,
+<LI><A HREF="#Ocaml_nn23">31.2.5.1 Director Introduction</A></LI>
+<LI><A HREF="#Ocaml_nn24">31.2.5.2 Overriding Methods in Ocaml</A></LI>
+<LI><A HREF="#Ocaml_nn25">31.2.5.3 Director Usage Example</A></LI>
+<LI><A HREF="#Ocaml_nn26">31.2.5.4 Creating director objects</A></LI>
+<LI><A HREF="#Ocaml_nn27">31.2.5.5 Typemaps for directors, directorin,
directorout, directorargout</A></LI>
-<LI><A HREF="#Ocaml_nn28">29.2.5.6 directorin typemap</A></LI>
-<LI><A HREF="#Ocaml_nn29">29.2.5.7 directorout typemap</A></LI>
-<LI><A HREF="#Ocaml_nn30">29.2.5.8 directorargout typemap</A></LI>
+<LI><A HREF="#Ocaml_nn28">31.2.5.6 typemap</A></LI>
+<LI><A HREF="#Ocaml_nn29">31.2.5.7 directorout typemap</A></LI>
+<LI><A HREF="#Ocaml_nn30">31.2.5.8 directorargout typemap</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ocaml_nn31">29.2.6 Exceptions</A></LI>
+<LI><A HREF="#Ocaml_nn31">31.2.6 Exceptions</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#Octave">30 SWIG and Octave</A></B>
+<B><A HREF="#Octave">32 SWIG and Octave</A></B>
<UL>
-<LI><A HREF="#Octave_nn2">30.1 Preliminaries</A></LI>
-<LI><A HREF="#Octave_nn3">30.2 Running SWIG</A>
+<LI><A HREF="#Octave_nn2">32.1 Preliminaries</A></LI>
+<LI><A HREF="#Octave_nn3">32.2 Running SWIG</A>
<UL>
-<LI><A HREF="#Octave_nn4">30.2.1 Command-line options</A></LI>
-<LI><A HREF="#Octave_nn5">30.2.2 Compiling a dynamic module</A></LI>
-<LI><A HREF="#Octave_nn6">30.2.3 Using your module</A></LI>
+<LI><A HREF="#Octave_nn4">32.2.1 Command-line options</A></LI>
+<LI><A HREF="#Octave_nn5">32.2.2 Compiling a dynamic module</A></LI>
+<LI><A HREF="#Octave_nn6">32.2.3 Using your module</A></LI>
</UL>
</LI>
-<LI><A HREF="#Octave_nn7">30.3 A tour of basic C/C++ wrapping</A>
+<LI><A HREF="#Octave_nn7">32.3 A tour of basic C/C++ wrapping</A>
+<UL>
+<LI><A HREF="#Octave_nn8">32.3.1 Modules</A></LI>
+<LI><A HREF="#Octave_nn9">32.3.2 Functions</A></LI>
+<LI><A HREF="#Octave_nn10">32.3.3 Global variables</A></LI>
+<LI><A HREF="#Octave_nn11">32.3.4 Constants and enums</A></LI>
+<LI><A HREF="#Octave_nn12">32.3.5 Pointers</A></LI>
+<LI><A HREF="#Octave_nn13">32.3.6 Structures and C++ classes</A></LI>
+<LI><A HREF="#Octave_nn15">32.3.7 C++ inheritance</A></LI>
+<LI><A HREF="#Octave_nn17">32.3.8 C++ overloaded functions</A></LI>
+<LI><A HREF="#Octave_nn18">32.3.9 C++ operators</A></LI>
+<LI><A HREF="#Octave_nn19">32.3.10 Class extension with %extend</A></LI>
+<LI><A HREF="#Octave_nn20">32.3.11 C++ templates</A></LI>
+<LI><A HREF="#Octave_nn21">32.3.12 C++ Smart Pointers</A>
<UL>
-<LI><A HREF="#Octave_nn8">30.3.1 Modules</A></LI>
-<LI><A HREF="#Octave_nn9">30.3.2 Functions</A></LI>
-<LI><A HREF="#Octave_nn10">30.3.3 Global variables</A></LI>
-<LI><A HREF="#Octave_nn11">30.3.4 Constants and enums</A></LI>
-<LI><A HREF="#Octave_nn12">30.3.5 Pointers</A></LI>
-<LI><A HREF="#Octave_nn13">30.3.6 Structures and C++ classes</A></LI>
-<LI><A HREF="#Octave_nn15">30.3.7 C++ inheritance</A></LI>
-<LI><A HREF="#Octave_nn17">30.3.8 C++ overloaded functions</A></LI>
-<LI><A HREF="#Octave_nn18">30.3.9 C++ operators</A></LI>
-<LI><A HREF="#Octave_nn19">30.3.10 Class extension with %extend</A></LI>
-<LI><A HREF="#Octave_nn20">30.3.11 C++ templates</A></LI>
-<LI><A HREF="#Octave_nn21">30.3.12 C++ Smart Pointers</A></LI>
-<LI><A HREF="#Octave_nn22">30.3.13 Directors (calling Octave from C++
+<LI><A HREF="#Octave_smart_pointers_shared_ptr">32.3.12.1 The shared_ptr
+ Smart Pointer</A></LI>
+<LI><A HREF="#Octave_smart_pointers_generic">32.3.12.2 Generic Smart
+ Pointers</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Octave_nn22">32.3.13 Directors (calling Octave from C++
code)</A></LI>
-<LI><A HREF="#Octave_nn23">30.3.14 Threads</A></LI>
-<LI><A HREF="#Octave_nn24">30.3.15 Memory management</A></LI>
-<LI><A HREF="#Octave_nn25">30.3.16 STL support</A></LI>
-<LI><A HREF="#Octave_nn26">30.3.17 Matrix typemaps</A></LI>
+<LI><A HREF="#Octave_nn23">32.3.14 Threads</A></LI>
+<LI><A HREF="#Octave_nn24">32.3.15 Memory management</A></LI>
+<LI><A HREF="#Octave_nn25">32.3.16 STL support</A></LI>
+<LI><A HREF="#Octave_nn26">32.3.17 Matrix typemaps</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#Perl5">31 SWIG and Perl5</A></B>
+<B><A HREF="#Perl5">33 SWIG and Perl5</A></B>
<UL>
-<LI><A HREF="#Perl5_nn2">31.1 Overview</A></LI>
-<LI><A HREF="#Perl5_nn3">31.2 Preliminaries</A>
+<LI><A HREF="#Perl5_nn2">33.1 Overview</A></LI>
+<LI><A HREF="#Perl5_nn3">33.2 Preliminaries</A>
<UL>
-<LI><A HREF="#Perl5_nn4">31.2.1 Getting the right header files</A></LI>
-<LI><A HREF="#Perl5_nn5">31.2.2 Compiling a dynamic module</A></LI>
-<LI><A HREF="#Perl5_nn6">31.2.3 Building a dynamic module with MakeMaker</A>
+<LI><A HREF="#Perl5_nn4">33.2.1 Getting the right header files</A></LI>
+<LI><A HREF="#Perl5_nn5">33.2.2 Compiling a dynamic module</A></LI>
+<LI><A HREF="#Perl5_nn6">33.2.3 Building a dynamic module with MakeMaker</A>
</LI>
-<LI><A HREF="#Perl5_nn7">31.2.4 Building a static version of Perl</A></LI>
-<LI><A HREF="#Perl5_nn8">31.2.5 Using the module</A></LI>
-<LI><A HREF="#Perl5_nn9">31.2.6 Compilation problems and compiling with
+<LI><A HREF="#Perl5_nn7">33.2.4 Building a static version of Perl</A></LI>
+<LI><A HREF="#Perl5_nn8">33.2.5 Using the module</A></LI>
+<LI><A HREF="#Perl5_nn9">33.2.6 Compilation problems and compiling with
C++</A></LI>
-<LI><A HREF="#Perl5_nn10">31.2.7 Compiling for 64-bit platforms</A></LI>
+<LI><A HREF="#Perl5_nn10">33.2.7 Compiling for 64-bit platforms</A></LI>
</UL>
</LI>
-<LI><A HREF="#Perl5_nn11">31.3 Building Perl Extensions under Windows</A>
+<LI><A HREF="#Perl5_nn11">33.3 Building Perl Extensions under Windows</A>
<UL>
-<LI><A HREF="#Perl5_nn12">31.3.1 Running SWIG from Developer Studio</A></LI>
-<LI><A HREF="#Perl5_nn13">31.3.2 Using other compilers</A></LI>
+<LI><A HREF="#Perl5_nn12">33.3.1 Running SWIG from Developer Studio</A></LI>
+<LI><A HREF="#Perl5_nn13">33.3.2 Using other compilers</A></LI>
</UL>
</LI>
-<LI><A HREF="#Perl5_nn14">31.4 The low-level interface</A>
+<LI><A HREF="#Perl5_nn14">33.4 The low-level interface</A>
<UL>
-<LI><A HREF="#Perl5_nn15">31.4.1 Functions</A></LI>
-<LI><A HREF="#Perl5_nn16">31.4.2 Global variables</A></LI>
-<LI><A HREF="#Perl5_nn17">31.4.3 Constants</A></LI>
-<LI><A HREF="#Perl5_nn18">31.4.4 Pointers</A></LI>
-<LI><A HREF="#Perl5_nn19">31.4.5 Structures</A></LI>
-<LI><A HREF="#Perl5_nn20">31.4.6 C++ classes</A></LI>
-<LI><A HREF="#Perl5_nn21">31.4.7 C++ classes and type-checking</A></LI>
-<LI><A HREF="#Perl5_nn22">31.4.8 C++ overloaded functions</A></LI>
-<LI><A HREF="#Perl5_nn23">31.4.9 Operators</A></LI>
-<LI><A HREF="#Perl5_nn24">31.4.10 Modules and packages</A></LI>
+<LI><A HREF="#Perl5_nn15">33.4.1 Functions</A></LI>
+<LI><A HREF="#Perl5_nn16">33.4.2 Global variables</A></LI>
+<LI><A HREF="#Perl5_nn17">33.4.3 Constants</A></LI>
+<LI><A HREF="#Perl5_nn18">33.4.4 Pointers</A></LI>
+<LI><A HREF="#Perl5_nn19">33.4.5 Structures</A></LI>
+<LI><A HREF="#Perl5_nn20">33.4.6 C++ classes</A></LI>
+<LI><A HREF="#Perl5_nn21">33.4.7 C++ classes and type-checking</A></LI>
+<LI><A HREF="#Perl5_nn22">33.4.8 C++ overloaded functions</A></LI>
+<LI><A HREF="#Perl5_nn23">33.4.9 Operators</A></LI>
+<LI><A HREF="#Perl5_nn24">33.4.10 Modules and packages</A></LI>
</UL>
</LI>
-<LI><A HREF="#Perl5_nn25">31.5 Input and output parameters</A></LI>
-<LI><A HREF="#Perl5_nn26">31.6 Exception handling</A></LI>
-<LI><A HREF="#Perl5_nn27">31.7 Remapping datatypes with typemaps</A>
+<LI><A HREF="#Perl5_nn25">33.5 Input and output parameters</A></LI>
+<LI><A HREF="#Perl5_nn26">33.6 Exception handling</A></LI>
+<LI><A HREF="#Perl5_nn27">33.7 Remapping datatypes with typemaps</A>
<UL>
-<LI><A HREF="#Perl5_nn28">31.7.1 A simple typemap example</A></LI>
-<LI><A HREF="#Perl5_nn29">31.7.2 Perl5 typemaps</A></LI>
-<LI><A HREF="#Perl5_nn30">31.7.3 Typemap variables</A></LI>
-<LI><A HREF="#Perl5_nn31">31.7.4 Useful functions</A></LI>
+<LI><A HREF="#Perl5_nn28">33.7.1 A simple typemap example</A></LI>
+<LI><A HREF="#Perl5_nn29">33.7.2 Perl5 typemaps</A></LI>
+<LI><A HREF="#Perl5_nn30">33.7.3 Typemap variables</A></LI>
+<LI><A HREF="#Perl5_nn31">33.7.4 Useful functions</A></LI>
</UL>
</LI>
-<LI><A HREF="#Perl5_nn32">31.8 Typemap Examples</A>
+<LI><A HREF="#Perl5_nn32">33.8 Typemap Examples</A>
<UL>
-<LI><A HREF="#Perl5_nn33">31.8.1 Converting a Perl5 array to a char **</A>
+<LI><A HREF="#Perl5_nn33">33.8.1 Converting a Perl5 array to a char **</A>
</LI>
-<LI><A HREF="#Perl5_nn34">31.8.2 Return values</A></LI>
-<LI><A HREF="#Perl5_nn35">31.8.3 Returning values from arguments</A></LI>
-<LI><A HREF="#Perl5_nn36">31.8.4 Accessing array structure members</A></LI>
-<LI><A HREF="#Perl5_nn37">31.8.5 Turning Perl references into C pointers</A>
+<LI><A HREF="#Perl5_nn34">33.8.2 Return values</A></LI>
+<LI><A HREF="#Perl5_nn35">33.8.3 Returning values from arguments</A></LI>
+<LI><A HREF="#Perl5_nn36">33.8.4 Accessing array structure members</A></LI>
+<LI><A HREF="#Perl5_nn37">33.8.5 Turning Perl references into C pointers</A>
</LI>
-<LI><A HREF="#Perl5_nn38">31.8.6 Pointer handling</A></LI>
+<LI><A HREF="#Perl5_nn38">33.8.6 Pointer handling</A></LI>
</UL>
</LI>
-<LI><A HREF="#Perl5_nn39">31.9 Proxy classes</A>
+<LI><A HREF="#Perl5_nn39">33.9 Proxy classes</A>
<UL>
-<LI><A HREF="#Perl5_nn40">31.9.1 Preliminaries</A></LI>
-<LI><A HREF="#Perl5_nn41">31.9.2 Structure and class wrappers</A></LI>
-<LI><A HREF="#Perl5_nn42">31.9.3 Object Ownership</A></LI>
-<LI><A HREF="#Perl5_nn43">31.9.4 Nested Objects</A></LI>
-<LI><A HREF="#Perl5_nn44">31.9.5 Proxy Functions</A></LI>
-<LI><A HREF="#Perl5_nn45">31.9.6 Inheritance</A></LI>
-<LI><A HREF="#Perl5_nn46">31.9.7 Modifying the proxy methods</A></LI>
+<LI><A HREF="#Perl5_nn40">33.9.1 Preliminaries</A></LI>
+<LI><A HREF="#Perl5_nn41">33.9.2 Structure and class wrappers</A></LI>
+<LI><A HREF="#Perl5_nn42">33.9.3 Object Ownership</A></LI>
+<LI><A HREF="#Perl5_nn43">33.9.4 Nested Objects</A></LI>
+<LI><A HREF="#Perl5_nn44">33.9.5 Proxy Functions</A></LI>
+<LI><A HREF="#Perl5_nn45">33.9.6 Inheritance</A></LI>
+<LI><A HREF="#Perl5_nn46">33.9.7 Modifying the proxy methods</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Perl5_nn47">33.10 Adding additional Perl code</A></LI>
+<LI><A HREF="#Perl5_directors">33.11 Cross language polymorphism</A>
+<UL>
+<LI><A HREF="#Perl5_nn48">33.11.1 Enabling directors</A></LI>
+<LI><A HREF="#Perl5_nn49">33.11.2 Director classes</A></LI>
+<LI><A HREF="#Perl5_nn50">33.11.3 Ownership and object destruction</A></LI>
+<LI><A HREF="#Perl5_nn51">33.11.4 Exception unrolling</A></LI>
+<LI><A HREF="#Perl5_nn52">33.11.5 Overhead and code bloat</A></LI>
+<LI><A HREF="#Perl5_nn53">33.11.6 Typemaps</A></LI>
</UL>
</LI>
-<LI><A HREF="#Perl5_nn47">31.10 Adding additional Perl code</A></LI>
</UL>
-<B><A HREF="#Php">32 SWIG and PHP</A></B>
+<B><A HREF="#Php">34 SWIG and PHP</A></B>
<UL>
-<LI><A HREF="#Php_nn1">32.1 Generating PHP Extensions</A>
+<LI><A HREF="#Php_nn1">34.1 Generating PHP Extensions</A>
<UL>
-<LI><A HREF="#Php_nn1_1">32.1.1 Building a loadable extension</A></LI>
-<LI><A HREF="#Php_nn1_3">32.1.2 Using PHP Extensions</A></LI>
+<LI><A HREF="#Php_nn1_1">34.1.1 Building a loadable extension</A></LI>
+<LI><A HREF="#Php_nn1_3">34.1.2 Using PHP Extensions</A></LI>
</UL>
</LI>
-<LI><A HREF="#Php_nn2">32.2 Basic PHP interface</A>
+<LI><A HREF="#Php_nn2">34.2 Basic PHP interface</A>
<UL>
-<LI><A HREF="#Php_nn2_1">32.2.1 Constants</A></LI>
-<LI><A HREF="#Php_nn2_2">32.2.2 Global Variables</A></LI>
-<LI><A HREF="#Php_nn2_3">32.2.3 Functions</A></LI>
-<LI><A HREF="#Php_nn2_4">32.2.4 Overloading</A></LI>
-<LI><A HREF="#Php_nn2_5">32.2.5 Pointers and References</A></LI>
-<LI><A HREF="#Php_nn2_6">32.2.6 Structures and C++ classes</A>
+<LI><A HREF="#Php_nn2_1">34.2.1 Constants</A></LI>
+<LI><A HREF="#Php_nn2_2">34.2.2 Global Variables</A></LI>
+<LI><A HREF="#Php_nn2_3">34.2.3 Functions</A></LI>
+<LI><A HREF="#Php_nn2_4">34.2.4 Overloading</A></LI>
+<LI><A HREF="#Php_nn2_5">34.2.5 Pointers and References</A></LI>
+<LI><A HREF="#Php_nn2_6">34.2.6 Structures and C++ classes</A>
<UL>
-<LI><A HREF="#Php_nn2_6_1">32.2.6.1 Using -noproxy</A></LI>
-<LI><A HREF="#Php_nn2_6_2">32.2.6.2 Constructors and Destructors</A></LI>
-<LI><A HREF="#Php_nn2_6_3">32.2.6.3 Static Member Variables</A></LI>
-<LI><A HREF="#Php_nn2_6_4">32.2.6.4 Static Member Functions</A></LI>
+<LI><A HREF="#Php_nn2_6_1">34.2.6.1 Using -noproxy</A></LI>
+<LI><A HREF="#Php_nn2_6_2">34.2.6.2 Constructors and Destructors</A></LI>
+<LI><A HREF="#Php_nn2_6_3">34.2.6.3 Static Member Variables</A></LI>
+<LI><A HREF="#Php_nn2_6_4">34.2.6.4 Static Member Functions</A></LI>
+<LI><A HREF="#Php_nn2_6_5">34.2.6.5 Specifying Implemented Interfaces</A>
+</LI>
</UL>
</LI>
-<LI><A HREF="#Php_nn2_7">32.2.7 PHP Pragmas, Startup and Shutdown code</A>
+<LI><A HREF="#Php_nn2_7">34.2.7 PHP Pragmas, Startup and Shutdown code</A>
</LI>
</UL>
</LI>
-<LI><A HREF="#Php_nn3">32.3 Cross language polymorphism</A>
+<LI><A HREF="#Php_nn3">34.3 Cross language polymorphism</A>
<UL>
-<LI><A HREF="#Php_nn3_1">32.3.1 Enabling directors</A></LI>
-<LI><A HREF="#Php_nn3_2">32.3.2 Director classes</A></LI>
-<LI><A HREF="#Php_nn3_3">32.3.3 Ownership and object destruction</A></LI>
-<LI><A HREF="#Php_nn3_4">32.3.4 Exception unrolling</A></LI>
-<LI><A HREF="#Php_nn3_5">32.3.5 Overhead and code bloat</A></LI>
-<LI><A HREF="#Php_nn3_6">32.3.6 Typemaps</A></LI>
-<LI><A HREF="#Php_nn3_7">32.3.7 Miscellaneous</A></LI>
+<LI><A HREF="#Php_nn3_1">34.3.1 Enabling directors</A></LI>
+<LI><A HREF="#Php_nn3_2">34.3.2 Director classes</A></LI>
+<LI><A HREF="#Php_nn3_3">34.3.3 Ownership and object destruction</A></LI>
+<LI><A HREF="#Php_nn3_4">34.3.4 Exception unrolling</A></LI>
+<LI><A HREF="#Php_nn3_5">34.3.5 Overhead and code bloat</A></LI>
+<LI><A HREF="#Php_nn3_6">34.3.6 Typemaps</A></LI>
+<LI><A HREF="#Php_nn3_7">34.3.7 Miscellaneous</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#Pike">33 SWIG and Pike</A></B>
+<B><A HREF="#Pike">35 SWIG and Pike</A></B>
<UL>
-<LI><A HREF="#Pike_nn2">33.1 Preliminaries</A>
+<LI><A HREF="#Pike_nn2">35.1 Preliminaries</A>
<UL>
-<LI><A HREF="#Pike_nn3">33.1.1 Running SWIG</A></LI>
-<LI><A HREF="#Pike_nn4">33.1.2 Getting the right header files</A></LI>
-<LI><A HREF="#Pike_nn5">33.1.3 Using your module</A></LI>
+<LI><A HREF="#Pike_nn3">35.1.1 Running SWIG</A></LI>
+<LI><A HREF="#Pike_nn4">35.1.2 Getting the right header files</A></LI>
+<LI><A HREF="#Pike_nn5">35.1.3 Using your module</A></LI>
</UL>
</LI>
-<LI><A HREF="#Pike_nn6">33.2 Basic C/C++ Mapping</A>
+<LI><A HREF="#Pike_nn6">35.2 Basic C/C++ Mapping</A>
<UL>
-<LI><A HREF="#Pike_nn7">33.2.1 Modules</A></LI>
-<LI><A HREF="#Pike_nn8">33.2.2 Functions</A></LI>
-<LI><A HREF="#Pike_nn9">33.2.3 Global variables</A></LI>
-<LI><A HREF="#Pike_nn10">33.2.4 Constants and enumerated types</A></LI>
-<LI><A HREF="#Pike_nn11">33.2.5 Constructors and Destructors</A></LI>
-<LI><A HREF="#Pike_nn12">33.2.6 Static Members</A></LI>
+<LI><A HREF="#Pike_nn7">35.2.1 Modules</A></LI>
+<LI><A HREF="#Pike_nn8">35.2.2 Functions</A></LI>
+<LI><A HREF="#Pike_nn9">35.2.3 Global variables</A></LI>
+<LI><A HREF="#Pike_nn10">35.2.4 Constants and enumerated types</A></LI>
+<LI><A HREF="#Pike_nn11">35.2.5 Constructors and Destructors</A></LI>
+<LI><A HREF="#Pike_nn12">35.2.6 Static Members</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#Python">34 SWIG and Python</A></B>
+<B><A HREF="#Python">36 SWIG and Python</A></B>
<UL>
-<LI><A HREF="#Python_nn2">34.1 Overview</A></LI>
-<LI><A HREF="#Python_nn3">34.2 Preliminaries</A>
+<LI><A HREF="#Python_nn2">36.1 Overview</A></LI>
+<LI><A HREF="#Python_nn3">36.2 Preliminaries</A>
<UL>
-<LI><A HREF="#Python_nn4">34.2.1 Running SWIG</A></LI>
-<LI><A HREF="#Python_nn6">34.2.2 Using distutils</A></LI>
-<LI><A HREF="#Python_nn7">34.2.3 Hand compiling a dynamic module</A></LI>
-<LI><A HREF="#Python_nn8">34.2.4 Static linking</A></LI>
-<LI><A HREF="#Python_nn9">34.2.5 Using your module</A></LI>
-<LI><A HREF="#Python_nn10">34.2.6 Compilation of C++ extensions</A></LI>
-<LI><A HREF="#Python_nn11">34.2.7 Compiling for 64-bit platforms</A></LI>
-<LI><A HREF="#Python_nn12">34.2.8 Building Python Extensions under
+<LI><A HREF="#Python_nn4">36.2.1 Running SWIG</A></LI>
+<LI><A HREF="#Python_nn6">36.2.2 Using distutils</A></LI>
+<LI><A HREF="#Python_nn7">36.2.3 Hand compiling a dynamic module</A></LI>
+<LI><A HREF="#Python_nn8">36.2.4 Static linking</A></LI>
+<LI><A HREF="#Python_nn9">36.2.5 Using your module</A></LI>
+<LI><A HREF="#Python_nn10">36.2.6 Compilation of C++ extensions</A></LI>
+<LI><A HREF="#Python_nn11">36.2.7 Compiling for 64-bit platforms</A></LI>
+<LI><A HREF="#Python_nn12">36.2.8 Building Python Extensions under
Windows</A></LI>
</UL>
</LI>
-<LI><A HREF="#Python_nn13">34.3 A tour of basic C/C++ wrapping</A>
+<LI><A HREF="#Python_nn13">36.3 A tour of basic C/C++ wrapping</A>
<UL>
-<LI><A HREF="#Python_nn14">34.3.1 Modules</A></LI>
-<LI><A HREF="#Python_nn15">34.3.2 Functions</A></LI>
-<LI><A HREF="#Python_nn16">34.3.3 Global variables</A></LI>
-<LI><A HREF="#Python_nn17">34.3.4 Constants and enums</A></LI>
-<LI><A HREF="#Python_nn18">34.3.5 Pointers</A></LI>
-<LI><A HREF="#Python_nn19">34.3.6 Structures</A></LI>
-<LI><A HREF="#Python_nn20">34.3.7 C++ classes</A></LI>
-<LI><A HREF="#Python_nn21">34.3.8 C++ inheritance</A></LI>
-<LI><A HREF="#Python_nn22">34.3.9 Pointers, references, values, and
+<LI><A HREF="#Python_nn14">36.3.1 Modules</A></LI>
+<LI><A HREF="#Python_nn15">36.3.2 Functions</A></LI>
+<LI><A HREF="#Python_nn16">36.3.3 Global variables</A></LI>
+<LI><A HREF="#Python_nn17">36.3.4 Constants and enums</A></LI>
+<LI><A HREF="#Python_nn18">36.3.5 Pointers</A></LI>
+<LI><A HREF="#Python_nn19">36.3.6 Structures</A></LI>
+<LI><A HREF="#Python_nn20">36.3.7 C++ classes</A></LI>
+<LI><A HREF="#Python_nn21">36.3.8 C++ inheritance</A></LI>
+<LI><A HREF="#Python_nn22">36.3.9 Pointers, references, values, and
arrays</A></LI>
-<LI><A HREF="#Python_nn23">34.3.10 C++ overloaded functions</A></LI>
-<LI><A HREF="#Python_nn24">34.3.11 C++ operators</A></LI>
-<LI><A HREF="#Python_nn25">34.3.12 C++ namespaces</A></LI>
-<LI><A HREF="#Python_nn26">34.3.13 C++ templates</A></LI>
-<LI><A HREF="#Python_nn27">34.3.14 C++ Smart Pointers</A></LI>
-<LI><A HREF="#Python_nn27a">34.3.15 C++ reference counted objects</A></LI>
+<LI><A HREF="#Python_nn23">36.3.10 C++ overloaded functions</A></LI>
+<LI><A HREF="#Python_nn24">36.3.11 C++ operators</A></LI>
+<LI><A HREF="#Python_nn25">36.3.12 C++ namespaces</A></LI>
+<LI><A HREF="#Python_nn26">36.3.13 C++ templates</A></LI>
+<LI><A HREF="#Python_nn27">36.3.14 C++ Smart Pointers</A>
+<UL>
+<LI><A HREF="#Python_smart_pointers_shared_ptr">36.3.14.1 The shared_ptr
+ Smart Pointer</A></LI>
+<LI><A HREF="#Python_smart_pointers_generic">36.3.14.2 Generic Smart
+ Pointers</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Python_nn27a">36.3.15 C++ reference counted objects</A></LI>
</UL>
</LI>
-<LI><A HREF="#Python_nn28">34.4 Further details on the Python class
+<LI><A HREF="#Python_nn28">36.4 Further details on the Python class
interface</A>
<UL>
-<LI><A HREF="#Python_nn29">34.4.1 Proxy classes</A></LI>
-<LI><A HREF="#Python_builtin_types">34.4.2 Built-in Types</A>
+<LI><A HREF="#Python_nn29">36.4.1 Proxy classes</A></LI>
+<LI><A HREF="#Python_builtin_types">36.4.2 Built-in Types</A>
<UL>
-<LI><A HREF="#Python_builtin_limitations">34.4.2.1 Limitations</A></LI>
-<LI><A HREF="#Python_builtin_overloads">34.4.2.2 Operator overloads --
+<LI><A HREF="#Python_builtin_limitations">36.4.2.1 Limitations</A></LI>
+<LI><A HREF="#Python_builtin_overloads">36.4.2.2 Operator overloads --
use them!</A></LI>
</UL>
</LI>
-<LI><A HREF="#Python_nn30">34.4.3 Memory management</A></LI>
-<LI><A HREF="#Python_nn31">34.4.4 Python 2.2 and classic classes</A></LI>
+<LI><A HREF="#Python_nn30">36.4.3 Memory management</A></LI>
+<LI><A HREF="#Python_nn31">36.4.4 Python 2.2 and classic classes</A></LI>
</UL>
</LI>
-<LI><A HREF="#Python_directors">34.5 Cross language polymorphism</A>
+<LI><A HREF="#Python_directors">36.5 Cross language polymorphism</A>
<UL>
-<LI><A HREF="#Python_nn33">34.5.1 Enabling directors</A></LI>
-<LI><A HREF="#Python_nn34">34.5.2 Director classes</A></LI>
-<LI><A HREF="#Python_nn35">34.5.3 Ownership and object destruction</A></LI>
-<LI><A HREF="#Python_nn36">34.5.4 Exception unrolling</A></LI>
-<LI><A HREF="#Python_nn37">34.5.5 Overhead and code bloat</A></LI>
-<LI><A HREF="#Python_nn38">34.5.6 Typemaps</A></LI>
-<LI><A HREF="#Python_nn39">34.5.7 Miscellaneous</A></LI>
+<LI><A HREF="#Python_nn33">36.5.1 Enabling directors</A></LI>
+<LI><A HREF="#Python_nn34">36.5.2 Director classes</A></LI>
+<LI><A HREF="#Python_nn35">36.5.3 Ownership and object destruction</A></LI>
+<LI><A HREF="#Python_nn36">36.5.4 Exception unrolling</A></LI>
+<LI><A HREF="#Python_nn37">36.5.5 Overhead and code bloat</A></LI>
+<LI><A HREF="#Python_nn38">36.5.6 Typemaps</A></LI>
+<LI><A HREF="#Python_nn39">36.5.7 Miscellaneous</A></LI>
</UL>
</LI>
-<LI><A HREF="#Python_nn40">34.6 Common customization features</A>
+<LI><A HREF="#Python_nn40">36.6 Common customization features</A>
<UL>
-<LI><A HREF="#Python_nn41">34.6.1 C/C++ helper functions</A></LI>
-<LI><A HREF="#Python_nn42">34.6.2 Adding additional Python code</A></LI>
-<LI><A HREF="#Python_nn43">34.6.3 Class extension with %extend</A></LI>
-<LI><A HREF="#Python_nn44">34.6.4 Exception handling with %exception</A></LI>
+<LI><A HREF="#Python_nn41">36.6.1 C/C++ helper functions</A></LI>
+<LI><A HREF="#Python_nn42">36.6.2 Adding additional Python code</A></LI>
+<LI><A HREF="#Python_nn43">36.6.3 Class extension with %extend</A></LI>
+<LI><A HREF="#Python_nn44">36.6.4 Exception handling with %exception</A></LI>
</UL>
</LI>
-<LI><A HREF="#Python_nn45">34.7 Tips and techniques</A>
+<LI><A HREF="#Python_nn45">36.7 Tips and techniques</A>
<UL>
-<LI><A HREF="#Python_nn46">34.7.1 Input and output parameters</A></LI>
-<LI><A HREF="#Python_nn47">34.7.2 Simple pointers</A></LI>
-<LI><A HREF="#Python_nn48">34.7.3 Unbounded C Arrays</A></LI>
-<LI><A HREF="#Python_nn49">34.7.4 String handling</A></LI>
+<LI><A HREF="#Python_nn46">36.7.1 Input and output parameters</A></LI>
+<LI><A HREF="#Python_nn47">36.7.2 Simple pointers</A></LI>
+<LI><A HREF="#Python_nn48">36.7.3 Unbounded C Arrays</A></LI>
+<LI><A HREF="#Python_nn49">36.7.4 String handling</A></LI>
+<LI><A HREF="#Python_default_args">36.7.5 Default arguments</A></LI>
</UL>
</LI>
-<LI><A HREF="#Python_nn53">34.8 Typemaps</A>
+<LI><A HREF="#Python_nn53">36.8 Typemaps</A>
<UL>
-<LI><A HREF="#Python_nn54">34.8.1 What is a typemap?</A></LI>
-<LI><A HREF="#Python_nn55">34.8.2 Python typemaps</A></LI>
-<LI><A HREF="#Python_nn56">34.8.3 Typemap variables</A></LI>
-<LI><A HREF="#Python_nn57">34.8.4 Useful Python Functions</A></LI>
+<LI><A HREF="#Python_nn54">36.8.1 What is a typemap?</A></LI>
+<LI><A HREF="#Python_nn55">36.8.2 Python typemaps</A></LI>
+<LI><A HREF="#Python_nn56">36.8.3 Typemap variables</A></LI>
+<LI><A HREF="#Python_nn57">36.8.4 Useful Python Functions</A></LI>
</UL>
</LI>
-<LI><A HREF="#Python_nn58">34.9 Typemap Examples</A>
+<LI><A HREF="#Python_nn58">36.9 Typemap Examples</A>
<UL>
-<LI><A HREF="#Python_nn59">34.9.1 Converting Python list to a char **</A>
+<LI><A HREF="#Python_nn59">36.9.1 Converting Python list to a char **</A>
</LI>
-<LI><A HREF="#Python_nn60">34.9.2 Expanding a Python object into
+<LI><A HREF="#Python_nn60">36.9.2 Expanding a Python object into
multiple arguments</A></LI>
-<LI><A HREF="#Python_nn61">34.9.3 Using typemaps to return arguments</A></LI>
-<LI><A HREF="#Python_nn62">34.9.4 Mapping Python tuples into small
+<LI><A HREF="#Python_nn61">36.9.3 Using typemaps to return arguments</A></LI>
+<LI><A HREF="#Python_nn62">36.9.4 Mapping Python tuples into small
arrays</A></LI>
-<LI><A HREF="#Python_nn63">34.9.5 Mapping sequences to C arrays</A></LI>
-<LI><A HREF="#Python_nn64">34.9.6 Pointer handling</A></LI>
+<LI><A HREF="#Python_nn63">36.9.5 Mapping sequences to C arrays</A></LI>
+<LI><A HREF="#Python_nn64">36.9.6 Pointer handling</A></LI>
</UL>
</LI>
-<LI><A HREF="#Python_nn65">34.10 Docstring Features</A>
+<LI><A HREF="#Python_nn65">36.10 Docstring Features</A>
+<UL>
+<LI><A HREF="#Python_nn66">36.10.1 Module docstring</A></LI>
+<LI><A HREF="#Python_nn67">36.10.2 %feature("autodoc")</A>
<UL>
-<LI><A HREF="#Python_nn66">34.10.1 Module docstring</A></LI>
-<LI><A HREF="#Python_nn67">34.10.2 %feature("autodoc")</A>
+<LI><A HREF="#Python_nn68">36.10.2.1 %feature("autodoc", "0")</A></LI>
+<LI><A HREF="#Python_nn69">36.10.2.2 %feature("autodoc", "1")</A></LI>
+<LI><A HREF="#Python_autodoc2">36.10.2.3 %feature("autodoc", "2")</A></LI>
+<LI><A HREF="#Python_autodoc3">36.10.2.4 %feature("autodoc", "3")</A></LI>
+<LI><A HREF="#Python_nn70">36.10.2.5 %feature("autodoc", "docstring")</A>
+</LI>
+</UL>
+</LI>
+<LI><A HREF="#Python_nn71">36.10.3 %feature("docstring")</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Python_nn72">36.11 Python Packages</A>
<UL>
-<LI><A HREF="#Python_nn68">34.10.2.1 %feature("autodoc", "0")</A></LI>
-<LI><A HREF="#Python_nn69">34.10.2.2 %feature("autodoc", "1")</A></LI>
-<LI><A HREF="#Python_autodoc2">34.10.2.3 %feature("autodoc", "2")</A></LI>
-<LI><A HREF="#Python_autodoc3">34.10.2.4 %feature("autodoc", "3")</A></LI>
-<LI><A HREF="#Python_nn70">34.10.2.5 %feature("autodoc", "docstring")</A>
+<LI><A HREF="#Python_modulepackage">36.11.1 Setting the Python package</A>
+</LI>
+<LI><A HREF="#Python_absrelimports">36.11.2 Absolute and relative
+ imports</A></LI>
+<LI><A HREF="#Python_absimport">36.11.3 Enforcing absolute import
+ semantics</A></LI>
+<LI><A HREF="#Python_importfrominit">36.11.4 Importing from __init__.py</A>
</LI>
+<LI><A HREF="#Python_implicit_namespace_packages">36.11.5 Implicit
+ Namespace Packages</A></LI>
+<LI><A HREF="#Python_package_search">36.11.6 Searching for the wrapper
+ module</A>
+<UL>
+<LI><A HREF="#Python_package_search_both_package_modules">36.11.6.1 Both
+ modules in the same package</A></LI>
+<LI><A HREF="#Python_package_search_wrapper_split">36.11.6.2 Split
+ modules</A></LI>
+<LI><A HREF="#Python_package_search_both_global_modules">36.11.6.3 Both
+ modules are global</A></LI>
+<LI><A HREF="#Python_package_search_static">36.11.6.4 Statically linked
+ C modules</A></LI>
</UL>
</LI>
-<LI><A HREF="#Python_nn71">34.10.3 %feature("docstring")</A></LI>
</UL>
</LI>
-<LI><A HREF="#Python_nn72">34.11 Python Packages</A></LI>
-<LI><A HREF="#Python_python3support">34.12 Python 3 Support</A>
+<LI><A HREF="#Python_python3support">36.12 Python 3 Support</A>
<UL>
-<LI><A HREF="#Python_nn74">34.12.1 Function annotation</A></LI>
-<LI><A HREF="#Python_nn75">34.12.2 Buffer interface</A></LI>
-<LI><A HREF="#Python_nn76">34.12.3 Abstract base classes</A></LI>
+<LI><A HREF="#Python_nn74">36.12.1 Function annotation</A></LI>
+<LI><A HREF="#Python_nn75">36.12.2 Buffer interface</A></LI>
+<LI><A HREF="#Python_nn76">36.12.3 Abstract base classes</A></LI>
+<LI><A HREF="#Python_nn77">36.12.4 Byte string output conversion</A></LI>
+<LI><A HREF="#Python_2_unicode">36.12.5 Python 2 Unicode</A></LI>
</UL>
</LI>
</UL>
-<B><A HREF="#R">35 SWIG and R</A></B>
+<B><A HREF="#R">37 SWIG and R</A></B>
<UL>
-<LI><A HREF="#R_nn2">35.1 Bugs</A></LI>
-<LI><A HREF="#R_nn3">35.2 Using R and SWIG</A></LI>
-<LI><A HREF="#R_nn4">35.3 Precompiling large R files</A></LI>
-<LI><A HREF="#R_nn5">35.4 General policy</A></LI>
-<LI><A HREF="#R_language_conventions">35.5 Language conventions</A></LI>
-<LI><A HREF="#R_nn6">35.6 C++ classes</A></LI>
-<LI><A HREF="#R_nn7">35.7 Enumerations</A></LI>
+<LI><A HREF="#R_nn2">37.1 Bugs</A></LI>
+<LI><A HREF="#R_nn3">37.2 Using R and SWIG</A></LI>
+<LI><A HREF="#R_nn4">37.3 Precompiling large R files</A></LI>
+<LI><A HREF="#R_nn5">37.4 General policy</A></LI>
+<LI><A HREF="#R_language_conventions">37.5 Language conventions</A></LI>
+<LI><A HREF="#R_nn6">37.6 C++ classes</A></LI>
+<LI><A HREF="#R_nn7">37.7 Enumerations</A></LI>
</UL>
-<B><A HREF="#Ruby">36 SWIG and Ruby</A></B>
+<B><A HREF="#Ruby">38 SWIG and Ruby</A></B>
<UL>
-<LI><A HREF="#Ruby_nn2">36.1 Preliminaries</A>
+<LI><A HREF="#Ruby_nn2">38.1 Preliminaries</A>
<UL>
-<LI><A HREF="#Ruby_nn3">36.1.1 Running SWIG</A></LI>
-<LI><A HREF="#Ruby_nn4">36.1.2 Getting the right header files</A></LI>
-<LI><A HREF="#Ruby_nn5">36.1.3 Compiling a dynamic module</A></LI>
-<LI><A HREF="#Ruby_nn6">36.1.4 Using your module</A></LI>
-<LI><A HREF="#Ruby_nn7">36.1.5 Static linking</A></LI>
-<LI><A HREF="#Ruby_nn8">36.1.6 Compilation of C++ extensions</A></LI>
+<LI><A HREF="#Ruby_nn3">38.1.1 Running SWIG</A></LI>
+<LI><A HREF="#Ruby_nn4">38.1.2 Getting the right header files</A></LI>
+<LI><A HREF="#Ruby_nn5">38.1.3 Compiling a dynamic module</A></LI>
+<LI><A HREF="#Ruby_nn6">38.1.4 Using your module</A></LI>
+<LI><A HREF="#Ruby_nn7">38.1.5 Static linking</A></LI>
+<LI><A HREF="#Ruby_nn8">38.1.6 Compilation of C++ extensions</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ruby_nn9">36.2 Building Ruby Extensions under Windows
+<LI><A HREF="#Ruby_nn9">38.2 Building Ruby Extensions under Windows
95/NT</A>
<UL>
-<LI><A HREF="#Ruby_nn10">36.2.1 Running SWIG from Developer Studio</A></LI>
+<LI><A HREF="#Ruby_nn10">38.2.1 Running SWIG from Developer Studio</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ruby_nn11">36.3 The Ruby-to-C/C++ Mapping</A>
+<LI><A HREF="#Ruby_nn11">38.3 The Ruby-to-C/C++ Mapping</A>
+<UL>
+<LI><A HREF="#Ruby_nn12">38.3.1 Modules</A></LI>
+<LI><A HREF="#Ruby_nn13">38.3.2 Functions</A></LI>
+<LI><A HREF="#Ruby_nn14">38.3.3 Variable Linking</A></LI>
+<LI><A HREF="#Ruby_nn15">38.3.4 Constants</A></LI>
+<LI><A HREF="#Ruby_nn16">38.3.5 Pointers</A></LI>
+<LI><A HREF="#Ruby_nn17">38.3.6 Structures</A></LI>
+<LI><A HREF="#Ruby_nn18">38.3.7 C++ classes</A></LI>
+<LI><A HREF="#Ruby_nn19">38.3.8 C++ Inheritance</A></LI>
+<LI><A HREF="#Ruby_nn20">38.3.9 C++ Overloaded Functions</A></LI>
+<LI><A HREF="#Ruby_nn21">38.3.10 C++ Operators</A></LI>
+<LI><A HREF="#Ruby_nn22">38.3.11 C++ namespaces</A></LI>
+<LI><A HREF="#Ruby_nn23">38.3.12 C++ templates</A></LI>
+<LI><A HREF="#Ruby_nn23_1">38.3.13 C++ Standard Template Library (STL)</A>
+</LI>
+<LI><A HREF="#Ruby_C_STL_Functors">38.3.14 C++ STL Functors</A></LI>
+<LI><A HREF="#Ruby_C_Iterators">38.3.15 C++ STL Iterators</A></LI>
+<LI><A HREF="#Ruby_nn24">38.3.16 C++ Smart Pointers</A>
<UL>
-<LI><A HREF="#Ruby_nn12">36.3.1 Modules</A></LI>
-<LI><A HREF="#Ruby_nn13">36.3.2 Functions</A></LI>
-<LI><A HREF="#Ruby_nn14">36.3.3 Variable Linking</A></LI>
-<LI><A HREF="#Ruby_nn15">36.3.4 Constants</A></LI>
-<LI><A HREF="#Ruby_nn16">36.3.5 Pointers</A></LI>
-<LI><A HREF="#Ruby_nn17">36.3.6 Structures</A></LI>
-<LI><A HREF="#Ruby_nn18">36.3.7 C++ classes</A></LI>
-<LI><A HREF="#Ruby_nn19">36.3.8 C++ Inheritance</A></LI>
-<LI><A HREF="#Ruby_nn20">36.3.9 C++ Overloaded Functions</A></LI>
-<LI><A HREF="#Ruby_nn21">36.3.10 C++ Operators</A></LI>
-<LI><A HREF="#Ruby_nn22">36.3.11 C++ namespaces</A></LI>
-<LI><A HREF="#Ruby_nn23">36.3.12 C++ templates</A></LI>
-<LI><A HREF="#Ruby_nn23_1">36.3.13 C++ Standard Template Library (STL)</A>
+<LI><A HREF="#Ruby_smart_pointers_shared_ptr">38.3.16.1 The shared_ptr
+ Smart Pointer</A></LI>
+<LI><A HREF="#Ruby_smart_pointers_generic">38.3.16.2 Generic Smart
+ Pointers</A></LI>
+</UL>
</LI>
-<LI><A HREF="#Ruby_C_STL_Functors">36.3.14 C++ STL Functors</A></LI>
-<LI><A HREF="#Ruby_C_Iterators">36.3.15 C++ STL Iterators</A></LI>
-<LI><A HREF="#Ruby_nn24">36.3.16 C++ Smart Pointers</A></LI>
-<LI><A HREF="#Ruby_nn25">36.3.17 Cross-Language Polymorphism</A>
+<LI><A HREF="#Ruby_nn25">38.3.17 Cross-Language Polymorphism</A>
<UL>
-<LI><A HREF="#Ruby_nn26">36.3.17.1 Exception Unrolling</A></LI>
+<LI><A HREF="#Ruby_nn26">38.3.17.1 Exception Unrolling</A></LI>
</UL>
</LI>
</UL>
</LI>
-<LI><A HREF="#Ruby_nn27">36.4 Naming</A>
+<LI><A HREF="#Ruby_nn27">38.4 Naming</A>
<UL>
-<LI><A HREF="#Ruby_nn28">36.4.1 Defining Aliases</A></LI>
-<LI><A HREF="#Ruby_nn29">36.4.2 Predicate Methods</A></LI>
-<LI><A HREF="#Ruby_nn30">36.4.3 Bang Methods</A></LI>
-<LI><A HREF="#Ruby_nn31">36.4.4 Getters and Setters</A></LI>
+<LI><A HREF="#Ruby_nn28">38.4.1 Defining Aliases</A></LI>
+<LI><A HREF="#Ruby_nn29">38.4.2 Predicate Methods</A></LI>
+<LI><A HREF="#Ruby_nn30">38.4.3 Bang Methods</A></LI>
+<LI><A HREF="#Ruby_nn31">38.4.4 Getters and Setters</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ruby_nn32">36.5 Input and output parameters</A></LI>
-<LI><A HREF="#Ruby_nn33">36.6 Exception handling</A>
+<LI><A HREF="#Ruby_nn32">38.5 Input and output parameters</A></LI>
+<LI><A HREF="#Ruby_nn33">38.6 Exception handling</A>
<UL>
-<LI><A HREF="#Ruby_nn34">36.6.1 Using the %exception directive</A></LI>
-<LI><A HREF="#Ruby_nn34_2">36.6.2 Handling Ruby Blocks</A></LI>
-<LI><A HREF="#Ruby_nn35">36.6.3 Raising exceptions</A></LI>
-<LI><A HREF="#Ruby_nn36">36.6.4 Exception classes</A></LI>
+<LI><A HREF="#Ruby_nn34">38.6.1 Using the %exception directive</A></LI>
+<LI><A HREF="#Ruby_nn34_2">38.6.2 Handling Ruby Blocks</A></LI>
+<LI><A HREF="#Ruby_nn35">38.6.3 Raising exceptions</A></LI>
+<LI><A HREF="#Ruby_nn36">38.6.4 Exception classes</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ruby_nn37">36.7 Typemaps</A>
+<LI><A HREF="#Ruby_nn37">38.7 Typemaps</A>
<UL>
-<LI><A HREF="#Ruby_nn38">36.7.1 What is a typemap?</A></LI>
-<LI><A HREF="#Ruby_Typemap_scope">36.7.2 Typemap scope</A></LI>
-<LI><A HREF="#Ruby_Copying_a_typemap">36.7.3 Copying a typemap</A></LI>
-<LI><A HREF="#Ruby_Deleting_a_typemap">36.7.4 Deleting a typemap</A></LI>
-<LI><A HREF="#Ruby_Placement_of_typemaps">36.7.5 Placement of typemaps</A>
+<LI><A HREF="#Ruby_nn38">38.7.1 What is a typemap?</A></LI>
+<LI><A HREF="#Ruby_Typemap_scope">38.7.2 Typemap scope</A></LI>
+<LI><A HREF="#Ruby_Copying_a_typemap">38.7.3 Copying a typemap</A></LI>
+<LI><A HREF="#Ruby_Deleting_a_typemap">38.7.4 Deleting a typemap</A></LI>
+<LI><A HREF="#Ruby_Placement_of_typemaps">38.7.5 Placement of typemaps</A>
</LI>
-<LI><A HREF="#Ruby_nn39">36.7.6 Ruby typemaps</A>
+<LI><A HREF="#Ruby_nn39">38.7.6 Ruby typemaps</A>
<UL>
-<LI><A HREF="#Ruby_in_typemap">36.7.6.1 "in" typemap</A></LI>
-<LI><A HREF="#Ruby_typecheck_typemap">36.7.6.2 "typecheck" typemap</A></LI>
-<LI><A HREF="#Ruby_out_typemap">36.7.6.3 "out" typemap</A></LI>
-<LI><A HREF="#Ruby_arginit_typemap">36.7.6.4 "arginit" typemap</A></LI>
-<LI><A HREF="#Ruby_default_typemap">36.7.6.5 "default" typemap</A></LI>
-<LI><A HREF="#Ruby_check_typemap">36.7.6.6 "check" typemap</A></LI>
-<LI><A HREF="#Ruby_argout_typemap_">36.7.6.7 "argout" typemap</A></LI>
-<LI><A HREF="#Ruby_freearg_typemap_">36.7.6.8 "freearg" typemap</A></LI>
-<LI><A HREF="#Ruby_newfree_typemap">36.7.6.9 "newfree" typemap</A></LI>
-<LI><A HREF="#Ruby_memberin_typemap">36.7.6.10 "memberin" typemap</A></LI>
-<LI><A HREF="#Ruby_varin_typemap">36.7.6.11 "varin" typemap</A></LI>
-<LI><A HREF="#Ruby_varout_typemap_">36.7.6.12 "varout" typemap</A></LI>
-<LI><A HREF="#Ruby_throws_typemap">36.7.6.13 "throws" typemap</A></LI>
-<LI><A HREF="#Ruby_directorin_typemap">36.7.6.14 directorin typemap</A></LI>
-<LI><A HREF="#Ruby_directorout_typemap">36.7.6.15 directorout typemap</A>
+<LI><A HREF="#Ruby_in_typemap">38.7.6.1 "in" typemap</A></LI>
+<LI><A HREF="#Ruby_typecheck_typemap">38.7.6.2 "typecheck" typemap</A></LI>
+<LI><A HREF="#Ruby_out_typemap">38.7.6.3 "out" typemap</A></LI>
+<LI><A HREF="#Ruby_arginit_typemap">38.7.6.4 "arginit" typemap</A></LI>
+<LI><A HREF="#Ruby_default_typemap">38.7.6.5 "default" typemap</A></LI>
+<LI><A HREF="#Ruby_check_typemap">38.7.6.6 "check" typemap</A></LI>
+<LI><A HREF="#Ruby_argout_typemap_">38.7.6.7 "argout" typemap</A></LI>
+<LI><A HREF="#Ruby_freearg_typemap_">38.7.6.8 "freearg" typemap</A></LI>
+<LI><A HREF="#Ruby_newfree_typemap">38.7.6.9 "newfree" typemap</A></LI>
+<LI><A HREF="#Ruby_memberin_typemap">38.7.6.10 "memberin" typemap</A></LI>
+<LI><A HREF="#Ruby_varin_typemap">38.7.6.11 "varin" typemap</A></LI>
+<LI><A HREF="#Ruby_varout_typemap_">38.7.6.12 "varout" typemap</A></LI>
+<LI><A HREF="#Ruby_throws_typemap">38.7.6.13 "throws" typemap</A></LI>
+<LI><A HREF="#Ruby_directorin_typemap">38.7.6.14 directorin typemap</A></LI>
+<LI><A HREF="#Ruby_directorout_typemap">38.7.6.15 directorout typemap</A>
</LI>
-<LI><A HREF="#Ruby_directorargout_typemap">36.7.6.16 directorargout
+<LI><A HREF="#Ruby_directorargout_typemap">38.7.6.16 directorargout
typemap</A></LI>
-<LI><A HREF="#Ruby_ret_typemap">36.7.6.17 ret typemap</A></LI>
-<LI><A HREF="#Ruby_globalin_typemap">36.7.6.18 globalin typemap</A></LI>
+<LI><A HREF="#Ruby_ret_typemap">38.7.6.17 ret typemap</A></LI>
+<LI><A HREF="#Ruby_globalin_typemap">38.7.6.18 globalin typemap</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Ruby_nn40">38.7.7 Typemap variables</A></LI>
+<LI><A HREF="#Ruby_nn41">38.7.8 Useful Functions</A>
+<UL>
+<LI><A HREF="#Ruby_nn42">38.7.8.1 C Datatypes to Ruby Objects</A></LI>
+<LI><A HREF="#Ruby_nn43">38.7.8.2 Ruby Objects to C Datatypes</A></LI>
+<LI><A HREF="#Ruby_nn44">38.7.8.3 Macros for VALUE</A></LI>
+<LI><A HREF="#Ruby_nn45">38.7.8.4 Exceptions</A></LI>
+<LI><A HREF="#Ruby_nn46">38.7.8.5 Iterators</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Ruby_nn47">38.7.9 Typemap Examples</A></LI>
+<LI><A HREF="#Ruby_nn48">38.7.10 Converting a Ruby array to a char **</A>
+</LI>
+<LI><A HREF="#Ruby_nn49">38.7.11 Collecting arguments in a hash</A></LI>
+<LI><A HREF="#Ruby_nn50">38.7.12 Pointer handling</A>
+<UL>
+<LI><A HREF="#Ruby_nn51">38.7.12.1 Ruby Datatype Wrapping</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Ruby_nn52">38.7.13 Example: STL Vector to Ruby Array</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Ruby_nn65">38.8 Docstring Features</A>
+<UL>
+<LI><A HREF="#Ruby_nn66">38.8.1 Module docstring</A></LI>
+<LI><A HREF="#Ruby_nn67">38.8.2 %feature("autodoc")</A>
+<UL>
+<LI><A HREF="#Ruby_nn68">38.8.2.1 %feature("autodoc", "0")</A></LI>
+<LI><A HREF="#Ruby_autodoc1">38.8.2.2 %feature("autodoc", "1")</A></LI>
+<LI><A HREF="#Ruby_autodoc2">38.8.2.3 %feature("autodoc", "2")</A></LI>
+<LI><A HREF="#Ruby_feature_autodoc3">38.8.2.4 %feature("autodoc", "3")</A>
+</LI>
+<LI><A HREF="#Ruby_nn70">38.8.2.5 %feature("autodoc", "docstring")</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ruby_nn40">36.7.7 Typemap variables</A></LI>
-<LI><A HREF="#Ruby_nn41">36.7.8 Useful Functions</A>
+<LI><A HREF="#Ruby_nn71">38.8.3 %feature("docstring")</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Ruby_nn53">38.9 Advanced Topics</A>
<UL>
-<LI><A HREF="#Ruby_nn42">36.7.8.1 C Datatypes to Ruby Objects</A></LI>
-<LI><A HREF="#Ruby_nn43">36.7.8.2 Ruby Objects to C Datatypes</A></LI>
-<LI><A HREF="#Ruby_nn44">36.7.8.3 Macros for VALUE</A></LI>
-<LI><A HREF="#Ruby_nn45">36.7.8.4 Exceptions</A></LI>
-<LI><A HREF="#Ruby_nn46">36.7.8.5 Iterators</A></LI>
+<LI><A HREF="#Ruby_operator_overloading">38.9.1 Operator overloading</A></LI>
+<LI><A HREF="#Ruby_nn55">38.9.2 Creating Multi-Module Packages</A></LI>
+<LI><A HREF="#Ruby_nn56">38.9.3 Specifying Mixin Modules</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ruby_nn47">36.7.9 Typemap Examples</A></LI>
-<LI><A HREF="#Ruby_nn48">36.7.10 Converting a Ruby array to a char **</A>
+<LI><A HREF="#Ruby_nn57">38.10 Memory Management</A>
+<UL>
+<LI><A HREF="#Ruby_nn58">38.10.1 Mark and Sweep Garbage Collector</A></LI>
+<LI><A HREF="#Ruby_nn59">38.10.2 Object Ownership</A></LI>
+<LI><A HREF="#Ruby_nn60">38.10.3 Object Tracking</A></LI>
+<LI><A HREF="#Ruby_nn61">38.10.4 Mark Functions</A></LI>
+<LI><A HREF="#Ruby_nn62">38.10.5 Free Functions</A></LI>
+<LI><A HREF="#Ruby_nn63">38.10.6 Embedded Ruby and the C++ Stack</A></LI>
+</UL>
</LI>
-<LI><A HREF="#Ruby_nn49">36.7.11 Collecting arguments in a hash</A></LI>
-<LI><A HREF="#Ruby_nn50">36.7.12 Pointer handling</A>
+</UL>
+<B><A HREF="#Scilab">39 SWIG and Scilab</A></B>
+<UL>
+<LI><A HREF="#Scilab_preliminaries">39.1 Preliminaries</A></LI>
+<LI><A HREF="#Scilab_running_swig">39.2 Running SWIG</A>
<UL>
-<LI><A HREF="#Ruby_nn51">36.7.12.1 Ruby Datatype Wrapping</A></LI>
+<LI><A HREF="#Scilab_running_swig_generating_module">39.2.1 Generating
+ the module</A></LI>
+<LI><A HREF="#Scilab_running_swig_building_module">39.2.2 Building the
+ module</A></LI>
+<LI><A HREF="#Scilab_running_swig_loading_module">39.2.3 Loading the
+ module</A></LI>
+<LI><A HREF="#Scilab_running_swig_using_module">39.2.4 Using the module</A>
+</LI>
+<LI><A HREF="#Scilab_running_swig_options">39.2.5 Scilab command line
+ options</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ruby_nn52">36.7.13 Example: STL Vector to Ruby Array</A></LI>
+<LI><A HREF="#Scilab_wrapping">39.3 A basic tour of C/C++ wrapping</A>
+<UL>
+<LI><A HREF="#Scilab_wrapping_overview">39.3.1 Overview</A></LI>
+<LI><A HREF="#Scilab_wrapping_identifiers">39.3.2 Identifiers</A></LI>
+<LI><A HREF="#Scilab_wrapping_functions">39.3.3 Functions</A>
+<UL>
+<LI><A HREF="#Scilab_nn13">39.3.3.1 Argument passing</A></LI>
+<LI><A HREF="#Scilab_nn14">39.3.3.2 Multiple output arguments</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ruby_nn65">36.8 Docstring Features</A>
+<LI><A HREF="#Scilab_wrapping_global_variables">39.3.4 Global variables</A>
+</LI>
+<LI><A HREF="#Scilab_wrapping_constants_and_enums">39.3.5 Constants and
+ enumerations</A>
<UL>
-<LI><A HREF="#Ruby_nn66">36.8.1 Module docstring</A></LI>
-<LI><A HREF="#Ruby_nn67">36.8.2 %feature("autodoc")</A>
+<LI><A HREF="#Scilab_wrapping_constants">39.3.5.1 Constants</A></LI>
+<LI><A HREF="#Scilab_wrapping_enums">39.3.5.2 Enumerations</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Scilab_wrapping_pointers">39.3.6 Pointers</A>
<UL>
-<LI><A HREF="#Ruby_nn68">36.8.2.1 %feature("autodoc", "0")</A></LI>
-<LI><A HREF="#Ruby_autodoc1">36.8.2.2 %feature("autodoc", "1")</A></LI>
-<LI><A HREF="#Ruby_autodoc2">36.8.2.3 %feature("autodoc", "2")</A></LI>
-<LI><A HREF="#Ruby_feature_autodoc3">36.8.2.4 %feature("autodoc", "3")</A>
+<LI><A HREF="#Scilab_wrapping_pointers_pointer_adresses">39.3.6.1
+ Utility functions</A></LI>
+<LI><A HREF="#Scilab_wrapping_pointers_null_pointers">39.3.6.2 Null
+ pointers:</A></LI>
+</UL>
+</LI>
+<LI><A HREF="#Scilab_wrapping_structs">39.3.7 Structures</A></LI>
+<LI><A HREF="#Scilab_wrapping_cpp_classes">39.3.8 C++ classes</A></LI>
+<LI><A HREF="#Scilab_wrapping_cpp_inheritance">39.3.9 C++ inheritance</A>
</LI>
-<LI><A HREF="#Ruby_nn70">36.8.2.5 %feature("autodoc", "docstring")</A></LI>
+<LI><A HREF="#Scilab_wrapping_cpp_overloading">39.3.10 C++ overloading</A>
+</LI>
+<LI><A HREF="#Scilab_wrapping_pointers_references_values_arrays">39.3.11
+ Pointers, references, values, and arrays</A></LI>
+<LI><A HREF="#Scilab_wrapping_cpp_templates">39.3.12 C++ templates</A></LI>
+<LI><A HREF="#Scilab_wrapping_cpp_operators">39.3.13 C++ operators</A></LI>
+<LI><A HREF="#Scilab_wrapping_cpp_namespaces">39.3.14 C++ namespaces</A></LI>
+<LI><A HREF="#Scilab_wrapping_cpp_exceptions">39.3.15 C++ exceptions</A></LI>
+<LI><A HREF="#Scilab_wrapping_cpp_stl">39.3.16 C++ STL</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ruby_nn71">36.8.3 %feature("docstring")</A></LI>
+<LI><A HREF="#Scilab_typemaps">39.4 Type mappings and libraries</A>
+<UL>
+<LI><A HREF="#Scilab_typemaps_primitive_types">39.4.1 Default primitive
+ type mappings</A></LI>
+<LI><A HREF="#Scilab_typemaps_arrays">39.4.2 Arrays</A></LI>
+<LI><A HREF="#Scilab_typemaps_pointer-to-pointers">39.4.3
+ Pointer-to-pointers</A></LI>
+<LI><A HREF="#Scilab_typemaps_matrices">39.4.4 Matrices</A></LI>
+<LI><A HREF="#Scilab_typemaps_stl">39.4.5 STL</A></LI>
</UL>
</LI>
-<LI><A HREF="#Ruby_nn53">36.9 Advanced Topics</A>
+<LI><A HREF="#Scilab_module_initialization">39.5 Module initialization</A>
+</LI>
+<LI><A HREF="#Scilab_building_modes">39.6 Building modes</A>
<UL>
-<LI><A HREF="#Ruby_operator_overloading">36.9.1 Operator overloading</A></LI>
-<LI><A HREF="#Ruby_nn55">36.9.2 Creating Multi-Module Packages</A></LI>
-<LI><A HREF="#Ruby_nn56">36.9.3 Specifying Mixin Modules</A></LI>
+<LI><A HREF="#Scilab_building_modes_nobuilder_mode">39.6.1 No-builder
+ mode</A></LI>
+<LI><A HREF="#Scilab_building_modes_builder_mode">39.6.2 Builder mode</A>
+</LI>
</UL>
</LI>
-<LI><A HREF="#Ruby_nn57">36.10 Memory Management</A>
+<LI><A HREF="#Scilab_generated_scripts">39.7 Generated scripts</A>
<UL>
-<LI><A HREF="#Ruby_nn58">36.10.1 Mark and Sweep Garbage Collector</A></LI>
-<LI><A HREF="#Ruby_nn59">36.10.2 Object Ownership</A></LI>
-<LI><A HREF="#Ruby_nn60">36.10.3 Object Tracking</A></LI>
-<LI><A HREF="#Ruby_nn61">36.10.4 Mark Functions</A></LI>
-<LI><A HREF="#Ruby_nn62">36.10.5 Free Functions</A></LI>
-<LI><A HREF="#Ruby_nn63">36.10.6 Embedded Ruby and the C++ Stack</A></LI>
+<LI><A HREF="#Scilab_generated_scripts_builder_script">39.7.1 Builder
+ script</A></LI>
+<LI><A HREF="#Scilab_generated_scripts_loader_script">39.7.2 Loader
+ script</A></LI>
</UL>
</LI>
+<LI><A HREF="#Scilab_other_resources">39.8 Other resources</A></LI>
</UL>
-<B><A HREF="#Tcl">37 SWIG and Tcl</A></B>
+<B><A HREF="#Tcl">40 SWIG and Tcl</A></B>
<UL>
-<LI><A HREF="#Tcl_nn2">37.1 Preliminaries</A>
+<LI><A HREF="#Tcl_nn2">40.1 Preliminaries</A>
<UL>
-<LI><A HREF="#Tcl_nn3">37.1.1 Getting the right header files</A></LI>
-<LI><A HREF="#Tcl_nn4">37.1.2 Compiling a dynamic module</A></LI>
-<LI><A HREF="#Tcl_nn5">37.1.3 Static linking</A></LI>
-<LI><A HREF="#Tcl_nn6">37.1.4 Using your module</A></LI>
-<LI><A HREF="#Tcl_nn7">37.1.5 Compilation of C++ extensions</A></LI>
-<LI><A HREF="#Tcl_nn8">37.1.6 Compiling for 64-bit platforms</A></LI>
-<LI><A HREF="#Tcl_nn9">37.1.7 Setting a package prefix</A></LI>
-<LI><A HREF="#Tcl_nn10">37.1.8 Using namespaces</A></LI>
+<LI><A HREF="#Tcl_nn3">40.1.1 Getting the right header files</A></LI>
+<LI><A HREF="#Tcl_nn4">40.1.2 Compiling a dynamic module</A></LI>
+<LI><A HREF="#Tcl_nn5">40.1.3 Static linking</A></LI>
+<LI><A HREF="#Tcl_nn6">40.1.4 Using your module</A></LI>
+<LI><A HREF="#Tcl_nn7">40.1.5 Compilation of C++ extensions</A></LI>
+<LI><A HREF="#Tcl_nn8">40.1.6 Compiling for 64-bit platforms</A></LI>
+<LI><A HREF="#Tcl_nn9">40.1.7 Setting a package prefix</A></LI>
+<LI><A HREF="#Tcl_nn10">40.1.8 Using namespaces</A></LI>
</UL>
</LI>
-<LI><A HREF="#Tcl_nn11">37.2 Building Tcl/Tk Extensions under Windows
+<LI><A HREF="#Tcl_nn11">40.2 Building Tcl/Tk Extensions under Windows
95/NT</A>
<UL>
-<LI><A HREF="#Tcl_nn12">37.2.1 Running SWIG from Developer Studio</A></LI>
-<LI><A HREF="#Tcl_nn13">37.2.2 Using NMAKE</A></LI>
+<LI><A HREF="#Tcl_nn12">40.2.1 Running SWIG from Developer Studio</A></LI>
+<LI><A HREF="#Tcl_nn13">40.2.2 Using NMAKE</A></LI>
</UL>
</LI>
-<LI><A HREF="#Tcl_nn14">37.3 A tour of basic C/C++ wrapping</A>
+<LI><A HREF="#Tcl_nn14">40.3 A tour of basic C/C++ wrapping</A>
<UL>
-<LI><A HREF="#Tcl_nn15">37.3.1 Modules</A></LI>
-<LI><A HREF="#Tcl_nn16">37.3.2 Functions</A></LI>
-<LI><A HREF="#Tcl_nn17">37.3.3 Global variables</A></LI>
-<LI><A HREF="#Tcl_nn18">37.3.4 Constants and enums</A></LI>
-<LI><A HREF="#Tcl_nn19">37.3.5 Pointers</A></LI>
-<LI><A HREF="#Tcl_nn20">37.3.6 Structures</A></LI>
-<LI><A HREF="#Tcl_nn21">37.3.7 C++ classes</A></LI>
-<LI><A HREF="#Tcl_nn22">37.3.8 C++ inheritance</A></LI>
-<LI><A HREF="#Tcl_nn23">37.3.9 Pointers, references, values, and arrays</A>
+<LI><A HREF="#Tcl_nn15">40.3.1 Modules</A></LI>
+<LI><A HREF="#Tcl_nn16">40.3.2 Functions</A></LI>
+<LI><A HREF="#Tcl_nn17">40.3.3 Global variables</A></LI>
+<LI><A HREF="#Tcl_nn18">40.3.4 Constants and enums</A></LI>
+<LI><A HREF="#Tcl_nn19">40.3.5 Pointers</A></LI>
+<LI><A HREF="#Tcl_nn20">40.3.6 Structures</A></LI>
+<LI><A HREF="#Tcl_nn21">40.3.7 C++ classes</A></LI>
+<LI><A HREF="#Tcl_nn22">40.3.8 C++ inheritance</A></LI>
+<LI><A HREF="#Tcl_nn23">40.3.9 Pointers, references, values, and arrays</A>
</LI>
-<LI><A HREF="#Tcl_nn24">37.3.10 C++ overloaded functions</A></LI>
-<LI><A HREF="#Tcl_nn25">37.3.11 C++ operators</A></LI>
-<LI><A HREF="#Tcl_nn26">37.3.12 C++ namespaces</A></LI>
-<LI><A HREF="#Tcl_nn27">37.3.13 C++ templates</A></LI>
-<LI><A HREF="#Tcl_nn28">37.3.14 C++ Smart Pointers</A></LI>
+<LI><A HREF="#Tcl_nn24">40.3.10 C++ overloaded functions</A></LI>
+<LI><A HREF="#Tcl_nn25">40.3.11 C++ operators</A></LI>
+<LI><A HREF="#Tcl_nn26">40.3.12 C++ namespaces</A></LI>
+<LI><A HREF="#Tcl_nn27">40.3.13 C++ templates</A></LI>
+<LI><A HREF="#Tcl_nn28">40.3.14 C++ Smart Pointers</A></LI>
</UL>
</LI>
-<LI><A HREF="#Tcl_nn29">37.4 Further details on the Tcl class interface</A>
+<LI><A HREF="#Tcl_nn29">40.4 Further details on the Tcl class interface</A>
<UL>
-<LI><A HREF="#Tcl_nn30">37.4.1 Proxy classes</A></LI>
-<LI><A HREF="#Tcl_nn31">37.4.2 Memory management</A></LI>
+<LI><A HREF="#Tcl_nn30">40.4.1 Proxy classes</A></LI>
+<LI><A HREF="#Tcl_nn31">40.4.2 Memory management</A></LI>
</UL>
</LI>
-<LI><A HREF="#Tcl_nn32">37.5 Input and output parameters</A></LI>
-<LI><A HREF="#Tcl_nn33">37.6 Exception handling</A></LI>
-<LI><A HREF="#Tcl_nn34">37.7 Typemaps</A>
+<LI><A HREF="#Tcl_nn32">40.5 Input and output parameters</A></LI>
+<LI><A HREF="#Tcl_nn33">40.6 Exception handling</A></LI>
+<LI><A HREF="#Tcl_nn34">40.7 Typemaps</A>
<UL>
-<LI><A HREF="#Tcl_nn35">37.7.1 What is a typemap?</A></LI>
-<LI><A HREF="#Tcl_nn36">37.7.2 Tcl typemaps</A></LI>
-<LI><A HREF="#Tcl_nn37">37.7.3 Typemap variables</A></LI>
-<LI><A HREF="#Tcl_nn38">37.7.4 Converting a Tcl list to a char **</A></LI>
-<LI><A HREF="#Tcl_nn39">37.7.5 Returning values in arguments</A></LI>
-<LI><A HREF="#Tcl_nn40">37.7.6 Useful functions</A></LI>
-<LI><A HREF="#Tcl_nn41">37.7.7 Standard typemaps</A></LI>
-<LI><A HREF="#Tcl_nn42">37.7.8 Pointer handling</A></LI>
+<LI><A HREF="#Tcl_nn35">40.7.1 What is a typemap?</A></LI>
+<LI><A HREF="#Tcl_nn36">40.7.2 Tcl typemaps</A></LI>
+<LI><A HREF="#Tcl_nn37">40.7.3 Typemap variables</A></LI>
+<LI><A HREF="#Tcl_nn38">40.7.4 Converting a Tcl list to a char **</A></LI>
+<LI><A HREF="#Tcl_nn39">40.7.5 Returning values in arguments</A></LI>
+<LI><A HREF="#Tcl_nn40">40.7.6 Useful functions</A></LI>
+<LI><A HREF="#Tcl_nn41">40.7.7 Standard typemaps</A></LI>
+<LI><A HREF="#Tcl_nn42">40.7.8 Pointer handling</A></LI>
</UL>
</LI>
-<LI><A HREF="#Tcl_nn43">37.8 Turning a SWIG module into a Tcl Package.</A>
+<LI><A HREF="#Tcl_nn43">40.8 Turning a SWIG module into a Tcl Package.</A>
</LI>
-<LI><A HREF="#Tcl_nn44">37.9 Building new kinds of Tcl interfaces (in
+<LI><A HREF="#Tcl_nn44">40.9 Building new kinds of Tcl interfaces (in
Tcl)</A>
<UL>
-<LI><A HREF="#Tcl_nn45">37.9.1 Proxy classes</A></LI>
+<LI><A HREF="#Tcl_nn45">40.9.1 Proxy classes</A></LI>
</UL>
</LI>
-<LI><A HREF="#Tcl_nn46">37.10 Tcl/Tk Stubs</A></LI>
+<LI><A HREF="#Tcl_nn46">40.10 Tcl/Tk Stubs</A></LI>
</UL>
-<B><A HREF="#Extending">38 Extending SWIG to support new languages</A></B>
+<B><A HREF="#Extending">41 Extending SWIG to support new languages</A></B>
<UL>
-<LI><A HREF="#Extending_nn2">38.1 Introduction</A></LI>
-<LI><A HREF="#Extending_nn3">38.2 Prerequisites</A></LI>
-<LI><A HREF="#Extending_nn4">38.3 The Big Picture</A></LI>
-<LI><A HREF="#Extending_nn5">38.4 Execution Model</A>
+<LI><A HREF="#Extending_nn2">41.1 Introduction</A></LI>
+<LI><A HREF="#Extending_nn3">41.2 Prerequisites</A></LI>
+<LI><A HREF="#Extending_nn4">41.3 The Big Picture</A></LI>
+<LI><A HREF="#Extending_nn5">41.4 Execution Model</A>
<UL>
-<LI><A HREF="#Extending_nn6">38.4.1 Preprocessing</A></LI>
-<LI><A HREF="#Extending_nn7">38.4.2 Parsing</A></LI>
-<LI><A HREF="#Extending_nn8">38.4.3 Parse Trees</A></LI>
-<LI><A HREF="#Extending_nn9">38.4.4 Attribute namespaces</A></LI>
-<LI><A HREF="#Extending_nn10">38.4.5 Symbol Tables</A></LI>
-<LI><A HREF="#Extending_nn11">38.4.6 The %feature directive</A></LI>
-<LI><A HREF="#Extending_nn12">38.4.7 Code Generation</A></LI>
-<LI><A HREF="#Extending_nn13">38.4.8 SWIG and XML</A></LI>
+<LI><A HREF="#Extending_nn6">41.4.1 Preprocessing</A></LI>
+<LI><A HREF="#Extending_nn7">41.4.2 Parsing</A></LI>
+<LI><A HREF="#Extending_nn8">41.4.3 Parse Trees</A></LI>
+<LI><A HREF="#Extending_nn9">41.4.4 Attribute namespaces</A></LI>
+<LI><A HREF="#Extending_nn10">41.4.5 Symbol Tables</A></LI>
+<LI><A HREF="#Extending_nn11">41.4.6 The %feature directive</A></LI>
+<LI><A HREF="#Extending_nn12">41.4.7 Code Generation</A></LI>
+<LI><A HREF="#Extending_nn13">41.4.8 SWIG and XML</A></LI>
</UL>
</LI>
-<LI><A HREF="#Extending_nn14">38.5 Primitive Data Structures</A>
+<LI><A HREF="#Extending_nn14">41.5 Primitive Data Structures</A>
<UL>
-<LI><A HREF="#Extending_nn15">38.5.1 Strings</A></LI>
-<LI><A HREF="#Extending_nn16">38.5.2 Hashes</A></LI>
-<LI><A HREF="#Extending_nn17">38.5.3 Lists</A></LI>
-<LI><A HREF="#Extending_nn18">38.5.4 Common operations</A></LI>
-<LI><A HREF="#Extending_nn19">38.5.5 Iterating over Lists and Hashes</A></LI>
-<LI><A HREF="#Extending_nn20">38.5.6 I/O</A></LI>
+<LI><A HREF="#Extending_nn15">41.5.1 Strings</A></LI>
+<LI><A HREF="#Extending_nn16">41.5.2 Hashes</A></LI>
+<LI><A HREF="#Extending_nn17">41.5.3 Lists</A></LI>
+<LI><A HREF="#Extending_nn18">41.5.4 Common operations</A></LI>
+<LI><A HREF="#Extending_nn19">41.5.5 Iterating over Lists and Hashes</A></LI>
+<LI><A HREF="#Extending_nn20">41.5.6 I/O</A></LI>
</UL>
</LI>
-<LI><A HREF="#Extending_nn21">38.6 Navigating and manipulating parse
+<LI><A HREF="#Extending_nn21">41.6 Navigating and manipulating parse
trees</A></LI>
-<LI><A HREF="#Extending_nn22">38.7 Working with attributes</A></LI>
-<LI><A HREF="#Extending_nn23">38.8 Type system</A>
+<LI><A HREF="#Extending_nn22">41.7 Working with attributes</A></LI>
+<LI><A HREF="#Extending_nn23">41.8 Type system</A>
<UL>
-<LI><A HREF="#Extending_nn24">38.8.1 String encoding of types</A></LI>
-<LI><A HREF="#Extending_nn25">38.8.2 Type construction</A></LI>
-<LI><A HREF="#Extending_nn26">38.8.3 Type tests</A></LI>
-<LI><A HREF="#Extending_nn27">38.8.4 Typedef and inheritance</A></LI>
-<LI><A HREF="#Extending_nn28">38.8.5 Lvalues</A></LI>
-<LI><A HREF="#Extending_nn29">38.8.6 Output functions</A></LI>
+<LI><A HREF="#Extending_nn24">41.8.1 String encoding of types</A></LI>
+<LI><A HREF="#Extending_nn25">41.8.2 Type construction</A></LI>
+<LI><A HREF="#Extending_nn26">41.8.3 Type tests</A></LI>
+<LI><A HREF="#Extending_nn27">41.8.4 Typedef and inheritance</A></LI>
+<LI><A HREF="#Extending_nn28">41.8.5 Lvalues</A></LI>
+<LI><A HREF="#Extending_nn29">41.8.6 Output functions</A></LI>
</UL>
</LI>
-<LI><A HREF="#Extending_nn30">38.9 Parameters</A></LI>
-<LI><A HREF="#Extending_nn31">38.10 Writing a Language Module</A>
+<LI><A HREF="#Extending_nn30">41.9 Parameters</A></LI>
+<LI><A HREF="#Extending_nn31">41.10 Writing a Language Module</A>
<UL>
-<LI><A HREF="#Extending_nn32">38.10.1 Execution model</A></LI>
-<LI><A HREF="#Extending_starting_out">38.10.2 Starting out</A></LI>
-<LI><A HREF="#Extending_nn34">38.10.3 Command line options</A></LI>
-<LI><A HREF="#Extending_nn35">38.10.4 Configuration and preprocessing</A>
+<LI><A HREF="#Extending_nn32">41.10.1 Execution model</A></LI>
+<LI><A HREF="#Extending_starting_out">41.10.2 Starting out</A></LI>
+<LI><A HREF="#Extending_nn34">41.10.3 Command line options</A></LI>
+<LI><A HREF="#Extending_nn35">41.10.4 Configuration and preprocessing</A>
</LI>
-<LI><A HREF="#Extending_nn36">38.10.5 Entry point to code generation</A></LI>
-<LI><A HREF="#Extending_nn37">38.10.6 Module I/O and wrapper skeleton</A>
+<LI><A HREF="#Extending_nn36">41.10.5 Entry point to code generation</A></LI>
+<LI><A HREF="#Extending_nn37">41.10.6 Module I/O and wrapper skeleton</A>
</LI>
-<LI><A HREF="#Extending_nn38">38.10.7 Low-level code generators</A></LI>
-<LI><A HREF="#Extending_configuration_files">38.10.8 Configuration files</A>
+<LI><A HREF="#Extending_nn38">41.10.7 Low-level code generators</A></LI>
+<LI><A HREF="#Extending_configuration_files">41.10.8 Configuration files</A>
</LI>
-<LI><A HREF="#Extending_nn40">38.10.9 Runtime support</A></LI>
-<LI><A HREF="#Extending_nn41">38.10.10 Standard library files</A></LI>
-<LI><A HREF="#Extending_nn42">38.10.11 User examples</A></LI>
-<LI><A HREF="#Extending_test_suite">38.10.12 Test driven development and
+<LI><A HREF="#Extending_nn40">41.10.9 Runtime support</A></LI>
+<LI><A HREF="#Extending_nn41">41.10.10 Standard library files</A></LI>
+<LI><A HREF="#Extending_nn42">41.10.11 User examples</A></LI>
+<LI><A HREF="#Extending_test_suite">41.10.12 Test driven development and
the test-suite</A>
<UL>
-<LI><A HREF="#Extending_running_test_suite">38.10.12.1 Running the
+<LI><A HREF="#Extending_running_test_suite">41.10.12.1 Running the
test-suite</A></LI>
</UL>
</LI>
-<LI><A HREF="#Extending_nn43">38.10.13 Documentation</A></LI>
-<LI><A HREF="#Extending_prerequisites">38.10.14 Prerequisites for adding
+<LI><A HREF="#Extending_nn43">41.10.13 Documentation</A></LI>
+<LI><A HREF="#Extending_prerequisites">41.10.14 Prerequisites for adding
a new language module to the SWIG distribution</A></LI>
-<LI><A HREF="#Extending_coding_style_guidelines">38.10.15 Coding style
+<LI><A HREF="#Extending_coding_style_guidelines">41.10.15 Coding style
guidelines</A></LI>
</UL>
</LI>
-<LI><A HREF="#Extending_debugging_options">38.11 Debugging Options</A></LI>
-<LI><A HREF="#Extending_nn46">38.12 Guide to parse tree nodes</A></LI>
-<LI><A HREF="#Extending_further_info">38.13 Further Development
+<LI><A HREF="#Extending_debugging_options">41.11 Debugging Options</A></LI>
+<LI><A HREF="#Extending_nn46">41.12 Guide to parse tree nodes</A></LI>
+<LI><A HREF="#Extending_further_info">41.13 Further Development
Information</A></LI>
</UL>
<HR NOSHADE>
-<H1><A name="Sections"></A>SWIG-2.0 Documentation</H1>
- Last update : SWIG-2.0.12 (9 Feb 2014)
-<H2><A NAME="1_1">Sections</A></H2>
-<H3><A NAME="1_1_1">SWIG Core Documentation</A></H3>
+<H1><A name="Sections">SWIG-3.0 Documentation</A></H1>
+<P> Last update : SWIG-3.0.10 (12 Jun 2016)</P>
+<H2><A name="Sections_Sections">Sections</A></H2>
+<H3><A name="Sections_core_docs">SWIG Core Documentation</A></H3>
<UL>
<LI><A href="#Preface">Preface</A></LI>
<LI><A href="#Introduction">Introduction</A></LI>
<LI><A href="#Scripting">Scripting</A></LI>
<LI><A href="#SWIG">SWIG Basics</A> (Read this!)</LI>
<LI><A href="#SWIGPlus">SWIG and C++</A></LI>
+<LI><A href="#CPlusPlus11">SWIG and C++11</A></LI>
<LI><A href="#Preprocessor">The SWIG preprocessor</A></LI>
<LI><A href="#Library">The SWIG library</A></LI>
<LI><A href="#Arguments">Argument handling</A></LI>
<LI><A href="#Modules">Working with Modules</A></LI>
<LI><A href="#CCache">Using SWIG with ccache</A></LI>
</UL>
-<H3><A NAME="1_1_2">Language Module Documentation</A></H3>
+<H3><A name="Sections_language_modules">Language Module Documentation</A>
+</H3>
<UL>
<LI><A href="#Allegrocl">Allegro Common Lisp support</A></LI>
<LI><A href="#Android">Android support</A></LI>
<LI><A href="#Go">Go support</A></LI>
<LI><A href="#Guile">Guile support</A></LI>
<LI><A href="#Java">Java support</A></LI>
+<LI><A href="#Javascript">Javascript support</A></LI>
<LI><A href="#Lisp">Common Lisp support</A></LI>
<LI><A href="#Lua">Lua support</A></LI>
<LI><A href="#Modula3">Modula3 support</A></LI>
<LI><A href="#Python">Python support</A></LI>
<LI><A href="#R">R support</A></LI>
<LI><A href="#Ruby">Ruby support</A></LI>
+<LI><A href="#Scilab">Scilab support</A></LI>
<LI><A href="#Tcl">Tcl support</A></LI>
</UL>
-<H3><A NAME="1_1_3">Developer Documentation</A></H3>
+<H3><A name="Sections_developers_docs">Developer Documentation</A></H3>
<UL>
<LI><A href="#Extending">Extending SWIG</A></LI>
</UL>
<HR NOSHADE>
-<H1><A name="Preface"></A>1 Preface</H1>
+<H1><A name="Preface">1 Preface</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
</UL>
</DIV>
<!-- INDEX -->
-<H2><A name="Preface_nn2"></A>1.1 Introduction</H2>
+<H2><A name="Preface_nn2">1.1 Introduction</A></H2>
<P> SWIG (Simplified Wrapper and Interface Generator) is a software
development tool for building scripting language interfaces to C and
C++ programs. Originally developed in 1995, SWIG was first used by
it has since evolved into a general purpose tool that is used in a wide
variety of applications--in fact almost anything where C/C++
programming is involved.</P>
-<H2><A name="Preface_nn4"></A>1.2 SWIG Versions</H2>
+<H2><A name="Preface_nn4">1.2 SWIG Versions</A></H2>
<P> In the late 1990's, the most stable version of SWIG was release
1.1p5. Versions 1.3.x were officially development versions and these
were released over a period of 10 years starting from the year 2000.
1.3.x series had been stable for many years. An official stable version
was released along with the decision to make SWIG license changes and
this gave rise to version 2.0.0 in 2010.</P>
-<H2><A name="Preface_license"></A>1.3 SWIG License</H2>
+<H2><A name="Preface_license">1.3 SWIG License</A></H2>
<P> The LICENSE file shipped with SWIG in the top level directory
contains the SWIG license. For further insight into the license
including the license of SWIG's output code, please visit the SWIG
SWIG generated could be distributed under license terms of the user's
choice/requirements and at the same time the SWIG source was placed
under the GNU General Public License version 3.</P>
-<H2><A name="Preface_nn5"></A>1.4 SWIG resources</H2>
+<H2><A name="Preface_nn5">1.4 SWIG resources</A></H2>
<P> The official location of SWIG related material is</P>
<DIV class="shell">
<PRE>
<A href="http://www.swig.org/svn.html">SWIG Bleeding Edge</A>
</PRE>
</DIV>
-<H2><A name="Preface_nn6"></A>1.5 Prerequisites</H2>
+<H2><A name="Preface_nn6">1.5 Prerequisites</A></H2>
<P> This manual assumes that you know how to write C/C++ programs and
that you have at least heard of scripting languages such as Tcl,
Python, and Perl. A detailed knowledge of these scripting languages is
of the gory details, you will almost certainly want to consult a good
C++ reference. If you don't program in C++, you may just want to skip
those parts of the manual.</P>
-<H2><A name="Preface_nn7"></A>1.6 Organization of this manual</H2>
+<H2><A name="Preface_nn7">1.6 Organization of this manual</A></H2>
<P> The first few chapters of this manual describe SWIG in general and
provide an overview of its capabilities. The remaining chapters are
devoted to specific SWIG language modules and are self contained. Thus,
if you are using SWIG to build Python interfaces, you can probably skip
to that chapter and find almost everything you need to know.</P>
-<H2><A name="Preface_nn8"></A>1.7 How to avoid reading the manual</H2>
+<H2><A name="Preface_nn8">1.7 How to avoid reading the manual</A></H2>
<P> If you hate reading manuals, glance at the "Introduction" which
contains a few simple examples. These examples contain about 95% of
everything you need to know to use SWIG. After that, simply use the
language-specific chapters as a reference. The SWIG distribution also
comes with a large directory of examples that illustrate different
topics.</P>
-<H2><A name="Preface_nn9"></A>1.8 Backwards compatibility</H2>
+<H2><A name="Preface_nn9">1.8 Backwards compatibility</A></H2>
<P> If you are a previous user of SWIG, don't expect SWIG to provide
complete backwards compatibility. Although the developers strive to the
utmost to keep backwards compatibility, this isn't always possible as
<P> Note: The version symbol is not defined in the generated SWIG
wrapper file. The SWIG preprocessor has defined SWIG_VERSION since
SWIG-1.3.11.</P>
-<H2><A name="Preface_release_notes"></A>1.9 Release notes</H2>
+<H2><A name="Preface_release_notes">1.9 Release notes</A></H2>
<P> The CHANGES.current, CHANGES and RELEASENOTES files shipped with
SWIG in the top level directory contain, respectively, detailed release
notes for the current version, detailed release notes for previous
releases and summary release notes from SWIG-1.3.22 onwards.</P>
-<H2><A name="Preface_nn10"></A>1.10 Credits</H2>
+<H2><A name="Preface_nn10">1.10 Credits</A></H2>
<P> SWIG is an unfunded project that would not be possible without the
contributions of many people working in their spare time. If you have
benefitted from using SWIG, please consider <A href="http://www.swig.org/donate.html">
varied number of people who have made contributions at all levels over
time. Contributors are mentioned either in the COPYRIGHT file or
CHANGES files shipped with SWIG or in submitted bugs.</P>
-<H2><A name="Preface_nn11"></A>1.11 Bug reports</H2>
+<H2><A name="Preface_nn11">1.11 Bug reports</A></H2>
<P> Although every attempt has been made to make SWIG bug-free, we are
also trying to make feature improvements that may introduce bugs. To
report a bug, either send mail to the SWIG developer list at the <A href="http://www.swig.org/mail.html">
occurred), corresponding portions of the SWIG interface file used, and
any important pieces of the SWIG generated wrapper code. We can only
fix bugs if we know about them.</P>
-<H2><A name="Preface_installation"></A>1.12 Installation</H2>
-<H3><A name="Preface_windows_installation"></A>1.12.1 Windows
- installation</H3>
-<P> Please see the dedicated <A href="Windows.html">Windows chapter</A>
- for instructions on installing SWIG on Windows and running the
- examples. The Windows distribution is called swigwin and includes a
- prebuilt SWIG executable, swig.exe, included in the top level
- directory. Otherwise it is exactly the same as the main SWIG
- distribution. There is no need to download anything else.</P>
-<H3><A name="Preface_unix_installation"></A>1.12.2 Unix installation</H3>
+<H2><A name="Preface_installation">1.12 Installation</A></H2>
+<H3><A name="Preface_windows_installation">1.12.1 Windows installation</A>
+</H3>
+<P> Please see the dedicated <A href="#Windows">Windows chapter</A> for
+ instructions on installing SWIG on Windows and running the examples.
+ The Windows distribution is called swigwin and includes a prebuilt SWIG
+ executable, swig.exe, included in the top level directory. Otherwise it
+ is exactly the same as the main SWIG distribution. There is no need to
+ download anything else.</P>
+<H3><A name="Preface_unix_installation">1.12.2 Unix installation</A></H3>
+<P> These installation instructions are for using the distributed
+ tarball, for example, <TT>swig-3.0.8.tar.gz</TT>. If you wish to build
+ and install from source on Github, extra steps are required. Please see
+ the <A href="http://swig.org/svn.html">Bleeding Edge</A> page on the
+ SWIG website.</P>
<P> You must use <A href="http://www.gnu.org/software/make/">GNU make</A>
to build and install SWIG.</P>
<P> <A href="http://www.pcre.org/">PCRE</A> needs to be installed on
<P> SWIG used to include a set of runtime libraries for some languages
for working with multiple modules. These are no longer built during the
installation stage. However, users can build them just like any wrapper
- module as described in the <A href="Modules.html">Modules chapter</A>.
- The CHANGES file shipped with SWIG in the top level directory also
- lists some examples which build the runtime library.</P>
+ module as described in the <A href="#Modules">Modules chapter</A>. The
+ CHANGES file shipped with SWIG in the top level directory also lists
+ some examples which build the runtime library.</P>
<P> Note:</P>
<UL>
<LI> If you checked the code out via Git, you will have to run <TT>
instructions at <A href="http://www.swig.org/svn.html">SWIG bleeding
edge</A>.</LI>
</UL>
-<H3><A name="Preface_osx_installation"></A>1.12.3 Macintosh OS X
- installation</H3>
+<H3><A name="Preface_osx_installation">1.12.3 Macintosh OS X
+ installation</A></H3>
<P> SWIG is known to work on various flavors of OS X. Follow the Unix
installation instructions above. However, as of this writing, there is
still great deal of inconsistency with how shared libaries are handled
installation of software you might have. However, this is generally not
the recommended technique for building larger extension modules.
Instead, you should utilize Darwin's two-level namespaces. Some details
- about this can be found here <A href="http://developer.apple.com/documentation/ReleaseNotes/DeveloperTools/TwoLevelNamespaces.html">
-http://developer.apple.com/documentation/ReleaseNotes/DeveloperTools/TwoLevelNamespaces.html
-</A>.</P>
+ about this can be found here <A href="https://developer.apple.com/library/mac/documentation/Porting/Conceptual/PortingUnix/compiling/compiling.html#//apple_ref/doc/uid/TP40002850-BCIHJBBF">
+Understanding Two-Level Namespaces</A>.</P>
<P> Needless to say, you might have to experiment a bit to get things
working at first.</P>
-<H3><A name="Preface_testing"></A>1.12.4 Testing</H3>
+<H3><A name="Preface_testing">1.12.4 Testing</A></H3>
<P> If you want to test SWIG after building it, a check can be performed
on Unix operating systems. Type the following:</P>
<DIV class="shell">
<P> Note: The test-suite currently contains over 500 tests. If you have
many different target languages installed and a slow machine, it might
take more than an hour to run the test-suite.</P>
-<H3><A name="Preface_examples"></A>1.12.5 Examples</H3>
+<H3><A name="Preface_examples">1.12.5 Examples</A></H3>
<P> The Examples directory contains a variety of examples of using SWIG
and it has some browsable documentation. Simply point your browser to
the file "Example/index.html".</P>
Visual Studio will convert these old style project files into a current
solution file.</P>
<HR NOSHADE>
-<H1><A name="Introduction"></A>2 Introduction</H1>
+<H1><A name="Introduction">2 Introduction</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
</UL>
</DIV>
<!-- INDEX -->
-<H2><A name="Introduction_nn2"></A>2.1 What is SWIG?</H2>
+<H2><A name="Introduction_nn2">2.1 What is SWIG?</A></H2>
<P> SWIG is a software development tool that simplifies the task of
interfacing different languages to C and C++ programs. In a nutshell,
SWIG is a compiler that takes C/C++ declarations and creates the
wrappers needed to access those declarations from other languages
- including including Perl, Python, Tcl, Ruby, Guile, and Java. SWIG
- normally requires no modifications to existing code and can often be
- used to build a usable interface in only a few minutes. Possible
- applications of SWIG include:</P>
+ including Perl, Python, Tcl, Ruby, Guile, and Java. SWIG normally
+ requires no modifications to existing code and can often be used to
+ build a usable interface in only a few minutes. Possible applications
+ of SWIG include:</P>
<UL>
<LI>Building interpreted interfaces to existing C programs.</LI>
<LI>Rapid prototyping and application development.</LI>
<LI>Interactive debugging.</LI>
-<LI>Reengineering or refactoring of legacy software into a scripting
+<LI>Reengineering or refactoring of legacy software into scripting
language components.</LI>
<LI>Making a graphical user interface (using Tk for example).</LI>
<LI>Testing of C libraries and programs (using scripts).</LI>
research and development work that is commonly found in scientific and
engineering projects. However, nowadays SWIG is known to be used in
many large open source and commercial projects.</P>
-<H2><A name="Introduction_nn3"></A>2.2 Why use SWIG?</H2>
+<H2><A name="Introduction_nn3">2.2 Why use SWIG?</A></H2>
<P> As stated in the previous section, the primary purpose of SWIG is to
simplify the task of integrating C/C++ with other programming
languages. However, why would anyone want to do that? To answer that
<LI>Testing is time consuming (the compile/debug cycle).</LI>
<LI>Not easy to reconfigure or customize without recompilation.</LI>
<LI>Modularization can be tricky.</LI>
-<LI>Security concerns (buffer overflow for instance).</LI>
+<LI>Security concerns (buffer overflows for instance).</LI>
</UL>
<P> To address these limitations, many programmers have arrived at the
conclusion that it is much easier to use different programming
Therefore, it provides a wide variety of customization features that
let you change almost every aspect of the language bindings. This is
the main reason why SWIG has such a large user manual ;-).</P>
-<H2><A name="Introduction_nn4"></A>2.3 A SWIG example</H2>
+<H2><A name="Introduction_nn4">2.3 A SWIG example</A></H2>
<P> The best way to illustrate SWIG is with a simple example. Consider
the following C code:</P>
<DIV class="code">
double My_variable = 3.0;
/* Compute factorial of n */
-int fact(int n) {
- if (n <= 1) return 1;
- else return n*fact(n-1);
+int fact(int n) {
+ if (n <= 1)
+ return 1;
+ else
+ return n*fact(n-1);
}
/* Compute n mod m */
int my_mod(int n, int m) {
- return(n % m);
+ return(n % m);
}
</PRE>
</DIV>
variable <TT>My_variable</TT> from Tcl. You start by making a SWIG
interface file as shown below (by convention, these files carry a .i
suffix) :</P>
-<H3><A name="Introduction_nn5"></A>2.3.1 SWIG interface file</H3>
+<H3><A name="Introduction_nn5">2.3.1 SWIG interface file</A></H3>
<DIV class="code">
<PRE>
/* File : example.i */
module that will be created by SWIG. The <TT>%{ %}</TT> block provides
a location for inserting additional code, such as C header files or
additional C declarations, into the generated C wrapper code.</P>
-<H3><A name="Introduction_nn6"></A>2.3.2 The swig command</H3>
+<H3><A name="Introduction_nn6">2.3.2 The swig command</A></H3>
<P> SWIG is invoked using the <TT>swig</TT> command. We can use this to
build a Tcl module (under Linux) as follows :</P>
<DIV class="shell">
loaded, Tcl can now access the functions and variables declared in the
SWIG interface. A look at the file <TT>example_wrap.c</TT> reveals a
hideous mess. However, you almost never need to worry about it.</P>
-<H3><A name="Introduction_nn7"></A>2.3.3 Building a Perl5 module</H3>
+<H3><A name="Introduction_nn7">2.3.3 Building a Perl5 module</A></H3>
<P> Now, let's turn these functions into a Perl5 module. Without making
any changes type the following (shown for Solaris):</P>
<DIV class="shell">
<PRE>
unix > <B>swig -perl5 example.i</B>
unix > <B>gcc -c example.c example_wrap.c \
- -I/usr/local/lib/perl5/sun4-solaris/5.003/CORE</B>
-unix > <B>ld -G example.o example_wrap.o -o example.so</B> # This is for Solaris
+ -I/usr/local/lib/perl5/sun4-solaris/5.003/CORE</B>
+unix > <B>ld -G example.o example_wrap.o -o example.so</B> # This is for Solaris
unix > <B>perl5.003
use example;
print example::fact(4), "\n";
unix >
</PRE>
</DIV>
-<H3><A name="Introduction_nn8"></A>2.3.4 Building a Python module</H3>
+<H3><A name="Introduction_nn8">2.3.4 Building a Python module</A></H3>
<P> Finally, let's build a module for Python (shown for Irix).</P>
<DIV class="shell">
<PRE>
7.5
</PRE>
</DIV>
-<H3><A name="Introduction_nn9"></A>2.3.5 Shortcuts</H3>
+<H3><A name="Introduction_nn9">2.3.5 Shortcuts</A></H3>
<P> To the truly lazy programmer, one may wonder why we needed the extra
interface file at all. As it turns out, you can often do without it.
For example, you could also build a Perl5 module by just running SWIG
<PRE>
unix > <B>swig -perl5 -module example example.h</B>
unix > <B>gcc -c example.c example_wrap.c \
- -I/usr/local/lib/perl5/sun4-solaris/5.003/CORE</B>
+ -I/usr/local/lib/perl5/sun4-solaris/5.003/CORE</B>
unix > <B>ld -G example.o example_wrap.o -o example.so</B>
unix > <B>perl5.003
use example;
7.5
</PRE>
</DIV>
-<H2><A name="Introduction_nn10"></A>2.4 Supported C/C++ language
- features</H2>
+<H2><A name="Introduction_nn10">2.4 Supported C/C++ language features</A>
+</H2>
<P> A primary goal of the SWIG project is to make the language binding
process extremely easy. Although a few simple examples have been shown,
SWIG is quite capable in supporting most of C++. Some of the major
<LI>Variable length arguments.</LI>
<LI>C++ smart pointers.</LI>
</UL>
-<P> Currently, the only major C++ feature not supported is nested
- classes--a limitation that should be removed in a future release, but
- has some workarounds for the moment.</P>
+<P> Most of C++11 is also supported. Details are in the <A href="#CPlusPlus11">
+C++11</A> section.</P>
<P> It is important to stress that SWIG is not a simplistic C++ lexing
tool like several apparently similar wrapper generation tools. SWIG not
only parses C++, it implements the full C++ type system and it is able
to understand C++ semantics. SWIG generates its wrappers with full
knowledge of this information. As a result, you will find SWIG to be
just as capable of dealing with nasty corner cases as it is in wrapping
- simple C++ code. In fact, SWIG is able handle C++ code that stresses
+ simple C++ code. In fact, SWIG is able to handle C++ code that stresses
the very limits of many C++ compilers.</P>
-<H2><A name="Introduction_nn11"></A>2.5 Non-intrusive interface building</H2>
+<H2><A name="Introduction_nn11">2.5 Non-intrusive interface building</A></H2>
<P> When used as intended, SWIG requires minimal (if any) modification
to existing C or C++ code. This makes SWIG extremely easy to use with
existing packages and promotes software reuse and modularity. By making
the interface and reuse the code in other applications. It is also
possible to support different types of interfaces depending on the
application.</P>
-<H2><A name="Introduction_build_system"></A>2.6 Incorporating SWIG into
- a build system</H2>
+<H2><A name="Introduction_build_system">2.6 Incorporating SWIG into a
+ build system</A></H2>
<P> SWIG is a command line tool and as such can be incorporated into any
build system that supports invoking external tools/compilers. SWIG is
most commonly invoked from within a Makefile, but is also known to be
Autoconf Archive</A> for further information on this and other Autoconf
macros.</P>
<P> There is growing support for SWIG in some build tools, for example <A
-href="http://www.cmake.org">CMake</A> is a cross-platform, open-source
- build manager with built in support for SWIG. CMake can detect the SWIG
+href="http://cmake.org">CMake</A> is a cross-platform, open-source build
+ manager with built in support for SWIG. CMake can detect the SWIG
executable and many of the target language libraries for linking
against. CMake knows how to build shared libraries and loadable modules
on many different operating systems. This allows easy cross platform
- SWIG development. It also can generate the custom commands necessary
- for driving SWIG from IDE's and makefiles. All of this can be done from
+ SWIG development. It can also generate the custom commands necessary
+ for driving SWIG from IDEs and makefiles. All of this can be done from
a single cross platform input file. The following example is a CMake
input file for creating a python wrapper for the SWIG interface file,
example.i:</P>
SWIG and compile the generated C++ files into _example.so (UNIX) or
_example.pyd (Windows). For other target languages on Windows a dll,
instead of a .pyd file, is usually generated.</P>
-<H2><A name="Introduction_nn12"></A>2.7 Hands off code generation</H2>
+<H2><A name="Introduction_nn12">2.7 Hands off code generation</A></H2>
<P> SWIG is designed to produce working code that needs no
hand-modification (in fact, if you look at the output, you probably
won't want to modify it). You should think of your target language
resulting output file. While this approach may limit flexibility for
hard-core hackers, it allows others to forget about the low-level
implementation details.</P>
-<H2><A name="Introduction_nn13"></A>2.8 SWIG and freedom</H2>
+<H2><A name="Introduction_nn13">2.8 SWIG and freedom</A></H2>
<P> No, this isn't a special section on the sorry state of world
politics. However, it may be useful to know that SWIG was written with
a certain "philosophy" about programming---namely that programmers are
On the other hand, this kind of freedom may be exactly what is needed
to work with complicated and unusual C/C++ applications.</P>
<P> Ironically, the freedom that SWIG provides is countered by an
- extremely conservative approach to code generation. At it's core, SWIG
+ extremely conservative approach to code generation. At its core, SWIG
tries to distill even the most advanced C++ code down to a small
well-defined set of interface building techniques based on ANSI C
programming. Because of this, you will find that SWIG interfaces can be
used on any platform. Again, this is an important part of staying out
of the programmer's way----the last thing any developer wants to do is
to spend their time debugging the output of a tool that relies on
- non-portable or unreliable programming features.</P>
+ non-portable or unreliable programming features. Dependencies are often
+ a source of incompatibilities and problems and so additional third
+ party libraries are not used in the generated code. SWIG will also
+ generally avoid generating code that introduces a dependency on the C++
+ Standard Template Library (STL). SWIG will generate code that depends
+ on the C libraries though.</P>
<HR NOSHADE>
-<H1><A name="Windows"></A>3 Getting started on Windows</H1>
+<H1><A name="Windows">3 Getting started on Windows</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
SWIG and running the examples is covered as well as building the SWIG
executable. Usage within the Unix like environments MinGW and Cygwin is
also detailed.</P>
-<H2><A name="Windows_installation"></A>3.1 Installation on Windows</H2>
+<H2><A name="Windows_installation">3.1 Installation on Windows</A></H2>
<P> SWIG does not come with the usual Windows type installation program,
however it is quite easy to get started. The main steps are:</P>
<UL>
SWIG Windows Examples</A> section in order to run examples using Visual
C++.</LI>
</UL>
-<H3><A name="Windows_executable"></A>3.1.1 Windows Executable</H3>
+<H3><A name="Windows_executable">3.1.1 Windows Executable</A></H3>
<P> The swigwin distribution contains the SWIG Windows executable,
swig.exe, which will run on 32 bit versions of Windows, ie Windows 95
and later. If you want to build your own swig.exe have a look at <A href="#Windows_swig_exe">
Building swig.exe on Windows</A>.</P>
-<H2><A name="Windows_examples"></A>3.2 SWIG Windows Examples</H2>
+<H2><A name="Windows_examples">3.2 SWIG Windows Examples</A></H2>
<P> Using Microsoft Visual C++ is the most common approach to compiling
and linking SWIG's output. The Examples directory has a few Visual C++
- project files (.dsp files). These were produced by Visual C++ 6. Later
- versions of Visual Studio should also be able to open and convert these
- project files. The C# examples come with .NET 2003 solution (.sln) and
- project files instead of Visual C++ 6 project files. The project files
- have been set up to execute SWIG in a custom build rule for the SWIG
- interface (.i) file. Alternatively run the <A href="#Windows_examples_cygwin">
+ project files (.dsp files). These were produced by Visual C++ 6. Newer
+ versions of Visual Studio should be able to open and convert these
+ project files. Each C# example comes with a Visual Studio 2005 solution
+ and associated project files instead of Visual C++ 6 project files. The
+ project files have been set up to execute SWIG in a custom build rule
+
for the SWIG interface (.i) file. Alternatively run the <A href="#Windows_examples_cygwin">
examples using Cygwin</A>.</P>
<P> More information on each of the examples is available with the
examples distributed with SWIG (Examples/index.html).</P>
-<H3><A name="Windows_visual_studio"></A>3.2.1 Instructions for using the
- Examples with Visual Studio</H3>
+<H3><A name="Windows_visual_studio">3.2.1 Instructions for using the
+ Examples with Visual Studio</A></H3>
<P> Ensure the SWIG executable is as supplied in the SWIG root directory
in order for the examples to work. Most languages require some
environment variables to be set<B> before</B> running Visual C++. Note
coded values. If you are interested in how the project files are set up
there is explanatory information in some of the language module's
documentation.</P>
-<H4><A name="Windows_csharp"></A>3.2.1.1 C#</H4>
+<H4><A name="Windows_csharp">3.2.1.1 C#</A></H4>
<P> The C# examples do not require any environment variables to be set
as a C# project file is included. Just open up the .sln solution file
in Visual Studio .NET 2003 or later, select Release Build, and do a
Rebuild All from the Build menu. The accompanying C# and C++ project
files are automatically used by the solution file.</P>
-<H4><A name="Windows_java"></A>3.2.1.2 Java</H4>
+<H4><A name="Windows_java">3.2.1.2 Java</A></H4>
<P><B> <TT>JAVA_INCLUDE</TT></B> : Set this to the directory containing
jni.h
<BR><B> <TT>JAVA_BIN</TT></B> : Set this to the bin directory containing
<BR> <TT>JAVA_INCLUDE: D:\jdk1.3\include
<BR> JAVA_BIN: D:\jdk1.3\bin
<BR></TT></P>
-<H4><A name="Windows_perl"></A>3.2.1.3 Perl</H4>
+<H4><A name="Windows_perl">3.2.1.3 Perl</A></H4>
<P><B> <TT>PERL5_INCLUDE</TT></B> : Set this to the directory containing
perl.h
<BR><B> <TT>PERL5_LIB</TT></B> : Set this to the Perl library including
<P> <TT>PERL5_INCLUDE: D:\nsPerl5.004_04\lib\CORE
<BR> PERL5_LIB: D:\nsPerl5.004_04\lib\CORE\perl.lib
<BR></TT></P>
-<H4><A name="Windows_python"></A>3.2.1.4 Python</H4>
+<H4><A name="Windows_python">3.2.1.4 Python</A></H4>
<P><B> <TT>PYTHON_INCLUDE</TT></B> : Set this to the directory that
contains Python.h
<BR><B> <TT>PYTHON_LIB</TT></B> : Set this to the python library
<BR> <TT>PYTHON_INCLUDE: D:\python21\include
<BR> PYTHON_LIB: D:\python21\libs\python21.lib
<BR></TT></P>
-<H4><A name="Windows_tcl"></A>3.2.1.5 TCL</H4>
+<H4><A name="Windows_tcl">3.2.1.5 TCL</A></H4>
<P><B> <TT>TCL_INCLUDE</TT></B> : Set this to the directory containing
tcl.h
<BR><B> <TT>TCL_LIB</TT></B> : Set this to the TCL library including
<BR> <TT>TCL_INCLUDE: D:\tcl\include
<BR> TCL_LIB: D:\tcl\lib\tcl83.lib
<BR></TT></P>
-<H4><A name="Windows_r"></A>3.2.1.6 R</H4>
+<H4><A name="Windows_r">3.2.1.6 R</A></H4>
<P><B> <TT>R_INCLUDE</TT></B> : Set this to the directory containing R.h
<BR><B> <TT>R_LIB</TT></B> : Set this to the R library (Rdll.lib)
including path for linking. The library needs to be built as described
<BR> <TT>R_INCLUDE: C:\Program Files\R\R-2.5.1\include
<BR> R_LIB: C:\Program Files\R\R-2.5.1\bin\Rdll.lib
<BR></TT></P>
-<H4><A name="Windows_ruby"></A>3.2.1.7 Ruby</H4>
+<H4><A name="Windows_ruby">3.2.1.7 Ruby</A></H4>
<P><B> <TT>RUBY_INCLUDE</TT></B> : Set this to the directory containing
ruby.h
<BR><B> <TT>RUBY_LIB</TT></B> : Set this to the ruby library including
<BR> <TT>RUBY_INCLUDE: D:\ruby\lib\ruby\1.6\i586-mswin32
<BR> RUBY_LIB: D:\ruby\lib\mswin32-ruby16.lib
<BR></TT></P>
-<H3><A name="Windows_other_compilers"></A>3.2.2 Instructions for using
- the Examples with other compilers</H3>
+<H3><A name="Windows_other_compilers">3.2.2 Instructions for using the
+ Examples with other compilers</A></H3>
<P> If you do not have access to Visual C++ you will have to set up
project files / Makefiles for your chosen compiler. There is a section
in each of the language modules detailing what needs setting up using
Visual C++ which may be of some guidance. Alternatively you may want to
use Cygwin as described in the following section.</P>
-<H2><A name="Windows_cygwin_mingw"></A>3.3 SWIG on Cygwin and MinGW</H2>
+<H2><A name="Windows_cygwin_mingw">3.3 SWIG on Cygwin and MinGW</A></H2>
<P> SWIG can also be compiled and run using <A href="http://www.cygwin.com">
Cygwin</A> or <A href="http://www.mingw.org">MinGW</A> which provides a
Unix like front end to Windows and comes free with gcc, an ANSI C/C++
compiler. However, this is not a recommended approach as the prebuilt
executable is supplied.</P>
-<H3><A name="Windows_swig_exe"></A>3.3.1 Building swig.exe on Windows</H3>
+<H3><A name="Windows_swig_exe">3.3.1 Building swig.exe on Windows</A></H3>
<P> If you want to replicate the build of swig.exe that comes with the
download, follow the MinGW instructions below. This is not necessary to
use the supplied swig.exe. This information is provided for those that
want to modify the SWIG source code in a Windows environment. Normally
this is not needed, so most people will want to ignore this section.</P>
-<H4><A name="Windows_mingw_msys"></A>3.3.1.1 Building swig.exe using
- MinGW and MSYS</H4>
+<H4><A name="Windows_mingw_msys">3.3.1.1 Building swig.exe using MinGW
+ and MSYS</A></H4>
<P> The short abbreviated instructions follow...</P>
<UL>
<LI>Install MinGW and MSYS from the <A href="http://www.mingw.org">MinGW</A>
<LI> Start the MSYS command prompt and execute:<DIV class="shell">
<PRE>
cd /
-tar -jxf msys-automake-1.8.2.tar.bz2
+tar -jxf msys-automake-1.8.2.tar.bz2
tar -jxf msys-autoconf-2.59.tar.bz2
-tar -zxf bison-2.0-MSYS.tar.gz
+tar -zxf bison-2.0-MSYS.tar.gz
</PRE>
</DIV></LI>
<LI> The very latest development version of SWIG is available from <A href="https://github.com/swig/swig">
</PRE>
</DIV></LI>
</OL>
-<H4><A name="Windows_cygwin"></A>3.3.1.2 Building swig.exe using Cygwin</H4>
+<H4><A name="Windows_cygwin">3.3.1.2 Building swig.exe using Cygwin</A></H4>
<P> Note that SWIG can also be built using Cygwin. However, SWIG will
then require the Cygwin DLL when executing. Follow the Unix
instructions in the README file in the SWIG root directory. Note that
generated files which are supplied with the release distribution. These
files are generated using the <TT>autogen.sh</TT> script and will only
need regenerating in circumstances such as changing the build system.</P>
-<H4><A name="Windows_building_alternatives"></A>3.3.1.3 Building
- swig.exe alternatives</H4>
+<H4><A name="Windows_building_alternatives">3.3.1.3 Building swig.exe
+ alternatives</A></H4>
<P> If you don't want to install Cygwin or MinGW, use a different
compiler to build SWIG. For example, all the source code files can be
added to a Visual C++ project file in order to build swig.exe from the
Visual C++ IDE.</P>
-<H3><A name="Windows_examples_cygwin"></A>3.3.2 Running the examples on
- Windows using Cygwin</H3>
+<H3><A name="Windows_examples_cygwin">3.3.2 Running the examples on
+ Windows using Cygwin</A></H3>
<P> The examples and test-suite work as successfully on Cygwin as on any
other Unix operating system. The modules which are known to work are
Python, Tcl, Perl, Ruby, Java and C#. Follow the Unix instructions in
the README file in the SWIG root directory to build the examples.</P>
-<H2><A name="Windows_interface_file"></A>3.4 Microsoft extensions and
- other Windows quirks</H2>
+<H2><A name="Windows_interface_file">3.4 Microsoft extensions and other
+ Windows quirks</A></H2>
<P> A common problem when using SWIG on Windows are the Microsoft
function calling conventions which are not in the C++ standard. SWIG
parses ISO C/C++ so cannot deal with proprietary conventions such as <TT>
__declspec(dllexport) ULONG __stdcall foo(DWORD, __int32);
</PRE>
+</DIV>
+<P>Note that if you follow Microsoft's recommendation of wrapping the <TT>
+__declspec</TT> calls in a preprocessor definition, you will need to
+ make sure that the definition is included by SWIG as well, by either
+ defining it manually or via a header. For example, if you have
+ specified the preprocessor definition in a header named <TT>
+export_lib.h</TT> and include other headers which depend on it, you
+ should use the <TT>%include</TT> directive to include the definition
+ explicitly. For example, if you had a header file, <TT>bar.h</TT>,
+ which depended on <TT>export_lib.h</TT>, your SWIG definition file
+ might look like:</P>
+<DIV class="code">
+<PRE>
+// bar.i
+%module bar
+%include <windows.i>
+%include "export_lib.h"
+%include "bar.h"
+</PRE>
+</DIV>
+<P> where export_lib.h may contain:</P>
+<DIV class="code">
+<PRE>
+// export_lib.h
+#define BAR_API __declspec(dllexport)
+</PRE>
+</DIV>
+<P> and bar.h may look like:</P>
+<DIV class="code">
+<PRE>
+// bar.h
+#include "export_lib.h"
+BAR_API void bar_function(int, double);
+</PRE>
+</DIV>
+<P> Using the preprocessor to remove BAR_API is a popular simpler
+ solution:</P>
+<DIV class="code">
+<PRE>
+// bar.i
+%module bar
+#define BAR_API
+%include "bar.h"
+</PRE>
</DIV><HR NOSHADE>
-<H1><A name="Scripting"></A>4 Scripting Languages</H1>
+<H1><A name="Scripting">4 Scripting Languages</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<P> This chapter provides a brief overview of scripting language
extension programming and the mechanisms by which scripting language
interpreters access C and C++ code.</P>
-<H2><A name="Scripting_nn2"></A>4.1 The two language view of the world</H2>
+<H2><A name="Scripting_nn2">4.1 The two language view of the world</A></H2>
<P> When a scripting language is used to control a C program, the
resulting system tends to look as follows:</P>
<CENTER><IMG alt="Scripting language input - C/C++ functions output" HEIGHT="149"
languages can be used for rapid prototyping, interactive debugging,
scripting, and access to high-level data structures such associative
arrays.</P>
-<H2><A name="Scripting_nn3"></A>4.2 How does a scripting language talk
- to C?</H2>
+<H2><A name="Scripting_nn3">4.2 How does a scripting language talk to C?</A>
+</H2>
<P> Scripting languages are built around a parser that knows how to
execute commands and scripts. Within this parser, there is a mechanism
for executing commands and accessing variables. Normally, this is used
information about the wrapper by providing details about the name of
the function, arguments, and so forth. The next few sections illustrate
the process.</P>
-<H3><A name="Scripting_nn4"></A>4.2.1 Wrapper functions</H3>
+<H3><A name="Scripting_nn4">4.2.1 Wrapper functions</A></H3>
<P> Suppose you have an ordinary C function like this :</P>
<DIV class="code">
<PRE>
int fact(int n) {
- if (n <= 1) return 1;
- else return n*fact(n-1);
+ if (n <= 1)
+ return 1;
+ else
+ return n*fact(n-1);
}
</PRE>
</DIV>
function above example might look like the following :</P>
<DIV class="code">
<PRE>
-int wrap_fact(ClientData clientData, Tcl_Interp *interp,
- int argc, char *argv[]) {
- int result;
- int arg0;
- if (argc != 2) {
- interp->result = "wrong # args";
- return TCL_ERROR;
- }
- arg0 = atoi(argv[1]);
- result = fact(arg0);
- sprintf(interp->result,"%d", result);
- return TCL_OK;
+int wrap_fact(ClientData clientData, Tcl_Interp *interp, int argc, char *argv[]) {
+ int result;
+ int arg0;
+ if (argc != 2) {
+ interp->result = "wrong # args";
+ return TCL_ERROR;
+ }
+ arg0 = atoi(argv[1]);
+ result = fact(arg0);
+ sprintf(interp->result,"%d", result);
+ return TCL_OK;
}
</PRE>
<DIV class="code">
<PRE>
int Wrap_Init(Tcl_Interp *interp) {
- Tcl_CreateCommand(interp, "fact", wrap_fact, (ClientData) NULL,
- (Tcl_CmdDeleteProc *) NULL);
- return TCL_OK;
+ Tcl_CreateCommand(interp, "fact", wrap_fact, (ClientData) NULL,
+ (Tcl_CmdDeleteProc *) NULL);
+ return TCL_OK;
}
</PRE>
</DIV>
illustrated, the procedure is almost identical for Perl and Python.
Both require special wrappers to be written and both need additional
initialization code. Only the specific details are different.</P>
-<H3><A name="Scripting_nn5"></A>4.2.2 Variable linking</H3>
+<H3><A name="Scripting_nn5">4.2.2 Variable linking</A></H3>
<P> Variable linking refers to the problem of mapping a C/C++ global
variable to a variable in the scripting language interpreter. For
example, suppose you had the following variable:</P>
such as <TT>$Foo</TT> might implicitly call the get function.
Similarly, typing <TT>$Foo = 4</TT> would call the underlying set
function to change the value.</P>
-<H3><A name="Scripting_nn6"></A>4.2.3 Constants</H3>
+<H3><A name="Scripting_nn6">4.2.3 Constants</A></H3>
<P> In many cases, a C program or library may define a large collection
of constants. For example:</P>
<DIV class="code">
$GREEN</TT>. Virtually all scripting languages provide C functions for
creating variables so installing constants is usually a trivial
exercise.</P>
-<H3><A name="Scripting_nn7"></A>4.2.4 Structures and classes</H3>
+<H3><A name="Scripting_nn7">4.2.4 Structures and classes</A></H3>
<P> Although scripting languages have no trouble accessing simple
functions and variables, accessing C/C++ structures and classes present
a different problem. This is because the implementation of structures
<DIV class="code">
<PRE>
struct Vector {
- Vector();
- ~Vector();
- double x,y,z;
+ Vector();
+ ~Vector();
+ double x,y,z;
};
</PRE>
<P> Since accessor functions provide a mechanism for accessing the
internals of an object, the interpreter does not need to know anything
about the actual representation of a <TT>Vector</TT>.</P>
-<H3><A name="Scripting_nn8"></A>4.2.5 Proxy classes</H3>
+<H3><A name="Scripting_nn8">4.2.5 Proxy classes</A></H3>
<P> In certain cases, it is possible to use the low-level accessor
functions to create a proxy class, also known as a shadow class. A
proxy class is a special kind of object that gets created in a
scripting language to access a C/C++ class (or struct) in a way that
looks like the original structure (that is, it proxies the real C++
- class). For example, if you have the following C definition :</P>
+ class). For example, if you have the following C++ definition :</P>
<DIV class="code">
<PRE>
class Vector {
public:
- Vector();
- ~Vector();
- double x,y,z;
+ Vector();
+ ~Vector();
+ double x,y,z;
};
</PRE>
</DIV>
<DIV class="targetlang">
<PRE>
Vector v
-v configure -x 3 -y 4 -z 13
+v configure -x 3 -y 4 -z -13
</PRE>
</DIV>
-<P> When proxy classes are used, two objects are at really work--one in
+<P> When proxy classes are used, two objects are really at work--one in
the scripting language, and an underlying C/C++ object. Operations
affect both objects equally and for all practical purposes, it appears
as if you are simply manipulating a C/C++ object.</P>
-<H2><A name="Scripting_nn9"></A>4.3 Building scripting language
- extensions</H2>
+<H2><A name="Scripting_nn9">4.3 Building scripting language extensions</A>
+</H2>
<P> The final step in using a scripting language with your C/C++
application is adding your extensions to the scripting language itself.
There are two primary approaches for doing this. The preferred
- technique is to build a dynamically loadable extension in the form a
+ technique is to build a dynamically loadable extension in the form of a
shared library. Alternatively, you can recompile the scripting language
interpreter with your extensions added to it.</P>
-<H3><A name="Scripting_nn10"></A>4.3.1 Shared libraries and dynamic
- loading</H3>
+<H3><A name="Scripting_nn10">4.3.1 Shared libraries and dynamic loading</A>
+</H3>
<P> To create a shared library or DLL, you often need to look at the
manual pages for your compiler and linker. However, the procedure for a
- few common machines is shown below:</P>
+ few common platforms is shown below:</P>
<DIV class="shell">
<PRE>
# Build a shared library for Solaris
-gcc -c example.c example_wrap.c -I/usr/local/include
+gcc -fpic -c example.c example_wrap.c -I/usr/local/include
ld -G example.o example_wrap.o -o example.so
# Build a shared library for Linux
gcc -fpic -c example.c example_wrap.c -I/usr/local/include
gcc -shared example.o example_wrap.o -o example.so
-
-# Build a shared library for Irix
-gcc -c example.c example_wrap.c -I/usr/local/include
-ld -shared example.o example_wrap.o -o example.so
-
</PRE>
</DIV>
<P> To use your shared library, you simply use the corresponding command
c++ -shared example.o example_wrap.o -o example.so
</PRE>
</DIV>
-<H3><A name="Scripting_nn11"></A>4.3.2 Linking with shared libraries</H3>
+<H3><A name="Scripting_nn11">4.3.2 Linking with shared libraries</A></H3>
<P> When building extensions as shared libraries, it is not uncommon for
your extension to rely upon other shared libraries on your machine. In
order for the extension to work, it needs to be able to find all of
Although this is an easy solution, it is not recommended. Consider
setting the path using linker options instead.</LI>
</UL>
-<H3><A name="Scripting_nn12"></A>4.3.3 Static linking</H3>
+<H3><A name="Scripting_nn12">4.3.3 Static linking</A></H3>
<P> With static linking, you rebuild the scripting language interpreter
with extensions. The process usually involves compiling a short main
program that adds your customized commands to the language and starts
fact, there are very few practical reasons for doing this--consider
using shared libraries instead.</P>
<HR NOSHADE>
-<H1><A name="SWIG"></A>5 SWIG Basics</H1>
+<H1><A name="SWIG">5 SWIG Basics</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<LI><A href="#SWIG_nn10">Basic Type Handling</A></LI>
<LI><A href="#SWIG_nn11">Global Variables</A></LI>
<LI><A href="#SWIG_nn12">Constants</A></LI>
-<LI><A href="#SWIG_nn13">A brief word about <TT>const</TT></A></LI>
-<LI><A href="#SWIG_nn14">A cautionary tale of <TT>char *</TT></A></LI>
+<LI><A href="#SWIG_nn13">A brief word about const</A></LI>
+<LI><A href="#SWIG_nn14">A cautionary tale of char *</A></LI>
</UL>
</LI>
<LI><A href="#SWIG_nn15">Pointers and complex objects</A>
<LI><A href="#SWIG_nn22">Passing structures by value</A></LI>
<LI><A href="#SWIG_nn23">Return by value</A></LI>
<LI><A href="#SWIG_nn24">Linking to structure variables</A></LI>
-<LI><A href="#SWIG_nn25">Linking to <TT>char *</TT></A></LI>
+<LI><A href="#SWIG_nn25">Linking to char *</A></LI>
<LI><A href="#SWIG_nn26">Arrays</A></LI>
<LI><A href="#SWIG_readonly_variables">Creating read-only variables</A></LI>
<LI><A href="#SWIG_rename_ignore">Renaming and ignoring declarations</A>
support is described in the next chapter. However, C++ programmers
should still read this chapter to understand the basics. Specific
details about each target language are described in later chapters.</P>
-<H2><A name="SWIG_nn2"></A>5.1 Running SWIG</H2>
+<H2><A name="SWIG_nn2">5.1 Running SWIG</A></H2>
<P> To run SWIG, use the <TT>swig</TT> command with options and a
filename like this:</P>
<DIV class="shell">
<P> where <TT>filename</TT> is a SWIG interface file or a C/C++ header
file. Below is a subset of<EM> options</EM> that can be used.
Additional options are also defined for each target language. A full
- list can be obtained by typing <TT>swig -help</TT> or <TT>swig -<EM>
-lang</EM> -help</TT>.</P>
+ list can be obtained by typing <TT>swig -help</TT> or <TT>swig<EM>
+ -<lang></EM> -help</TT> for language<EM> <lang></EM> specific options.</P>
<DIV class="shell">
<PRE>
-allegrocl Generate ALLEGROCL wrappers
-clisp Generate CLISP wrappers
-cffi Generate CFFI wrappers
-csharp Generate C# wrappers
+-d Generate D wrappers
-go Generate Go wrappers
-guile Generate Guile wrappers
-java Generate Java wrappers
+-javascript Generate Javascript wrappers
-lua Generate Lua wrappers
-modula3 Generate Modula 3 wrappers
-mzscheme Generate Mzscheme wrappers
-ocaml Generate Ocaml wrappers
+-octave Generate Octave wrappers
-perl Generate Perl wrappers
-php Generate PHP wrappers
-pike Generate Pike wrappers
-python Generate Python wrappers
-r Generate R (aka GNU S) wrappers
-ruby Generate Ruby wrappers
+-scilab Generate Scilab wrappers
-sexp Generate Lisp S-Expressions wrappers
-tcl Generate Tcl wrappers
-uffi Generate Common Lisp / UFFI wrappers
-xml Generate XML wrappers
-c++ Enable C++ parsing
+-cppext <EM>ext</EM> Change file extension of C++ generated files to <EM>ext</EM>
+ (default is cxx, except for PHP which uses cpp)
-D<EM>symbol</EM> Define a preprocessor symbol
-Fstandard Display error/warning messages in commonly used format
-Fmicrosoft Display error/warning messages in Microsoft format
-I<EM>dir</EM> Add a directory to the file include path
-l<EM>file</EM> Include a SWIG library file.
-module <EM>name</EM> Set the name of the SWIG module
--o <EM>outfile</EM> Name of output file
--outcurrentdir Set default output dir to current dir instead of input file's path
+-o <EM>outfile</EM> Set name of C/C++ output file to <outfile>
+-oh <EM>headfile</EM> Set name of C++ output header file for directors to <headfile>
+-outcurrentdir Set default output dir to current dir instead of input file's path
-outdir <EM>dir</EM> Set language specific files output directory
-pcreversion Display PCRE version information
-swiglib Show location of SWIG library
</PRE>
</DIV>
-<H3><A name="SWIG_nn3"></A>5.1.1 Input format</H3>
+<H3><A name="SWIG_nn3">5.1.1 Input format</A></H3>
<P> As input, SWIG expects a file containing ANSI C/C++ declarations and
special SWIG directives. More often than not, this is a special SWIG
interface file which is usually denoted with a special <TT>.i</TT> or <TT>
interpreted by SWIG. The <TT>%{...%}</TT> syntax and semantics in SWIG
is analogous to that of the declarations section used in input files to
parser generation tools such as yacc or bison.</P>
-<H3><A name="SWIG_output"></A>5.1.2 SWIG Output</H3>
+<H3><A name="SWIG_output">5.1.2 SWIG Output</A></H3>
<P> The output of SWIG is a C/C++ file that contains all of the wrapper
code needed to build an extension module. SWIG may generate some
additional files depending on the target language. By default, an input
file with the name <TT>file.i</TT> is transformed into a file <TT>
file_wrap.c</TT> or <TT>file_wrap.cxx</TT> (depending on whether or not
- the <TT>-c++</TT> option has been used). The name of the output file
- can be changed using the <TT>-o</TT> option. In certain cases, file
- suffixes are used by the compiler to determine the source language (C,
- C++, etc.). Therefore, you have to use the <TT>-o</TT> option to change
- the suffix of the SWIG-generated wrapper file if you want something
- different than the default. For example:</P>
+ the <TT>-c++</TT> option has been used). The name of the output C/C++
+ file can be changed using the <TT>-o</TT> option. In certain cases,
+ file suffixes are used by the compiler to determine the source language
+ (C, C++, etc.). Therefore, you have to use the <TT>-o</TT> option to
+ change the suffix of the SWIG-generated wrapper file if you want
+ something different than the default. For example:</P>
<DIV class="shell">
<PRE>
$ swig -c++ -python -o example_wrap.cpp example.i
</PRE>
</DIV>
<P> The C/C++ output file created by SWIG often contains everything that
- is needed to construct a extension module for the target scripting
+ is needed to construct an extension module for the target scripting
language. SWIG is not a stub compiler nor is it usually necessary to
edit the output file (and if you look at the output, you probably won't
want to). To build the final extension module, the SWIG output file is
compiled and linked with the rest of your C/C++ program to create a
shared library.</P>
-<P> Many target languages will also generate proxy class files in the
- target language. The default output directory for these language
+<P> For many target languages SWIG will also generate proxy class files
+ in the target language. The default output directory for these language
specific files is the same directory as the generated C/C++ file. This
can be modified using the <TT>-outdir</TT> option. For example:</P>
<DIV class="shell">
default output directory is the path to the input file. If <TT>-o</TT>
and <TT>-outcurrentdir</TT> are used together, <TT>-outcurrentdir</TT>
is effectively ignored as the output directory for the language files
- is the same directory as the generated C/C++ file if not overidden with
- <TT>-outdir</TT>.</P>
-<H3><A name="SWIG_nn5"></A>5.1.3 Comments</H3>
+ is the same directory as the generated C/C++ file if not overridden
+ with <TT>-outdir</TT>.</P>
+<H3><A name="SWIG_nn5">5.1.3 Comments</A></H3>
<P> C and C++ style comments may appear anywhere in interface files. In
previous versions of SWIG, comments were used to generate documentation
files. However, this feature is currently under repair and will
reappear in a later SWIG release.</P>
-<H3><A name="SWIG_nn6"></A>5.1.4 C Preprocessor</H3>
+<H3><A name="SWIG_nn6">5.1.4 C Preprocessor</A></H3>
<P> Like C, SWIG preprocesses all input files through an enhanced
version of the C preprocessor. All standard preprocessor features are
supported including file inclusion, conditional compilation and macros.
includes a number of macro handling enhancements that make it more
powerful than the normal C preprocessor. These extensions are described
in the "<A href="#Preprocessor">Preprocessor</A>" chapter.</P>
-<H3><A name="SWIG_nn7"></A>5.1.5 SWIG Directives</H3>
+<H3><A name="SWIG_nn7">5.1.5 SWIG Directives</A></H3>
<P> Most of SWIG's operation is controlled by special directives that
are always preceded by a "<TT>%</TT>" to distinguish them from normal C
declarations. These directives are used to give SWIG hints or to alter
</DIV>
<P> <TT>SWIG</TT> is a special preprocessing symbol defined by SWIG when
it is parsing an input file.</P>
-<H3><A name="SWIG_nn8"></A>5.1.6 Parser Limitations</H3>
+<H3><A name="SWIG_nn8">5.1.6 Parser Limitations</A></H3>
<P> Although SWIG can parse most C/C++ declarations, it does not provide
a complete C/C++ parser implementation. Most of these limitations
pertain to very complicated type declarations and certain advanced C++
primary complication in the implementation is that the SWIG parser does
not utilize a separate<EM> typedef-name</EM> terminal symbol as
described on p. 234 of K&R).</P>
-<H2><A name="SWIG_nn9"></A>5.2 Wrapping Simple C Declarations</H2>
+<H2><A name="SWIG_nn9">5.2 Wrapping Simple C Declarations</A></H2>
<P> SWIG wraps simple C declarations by creating an interface that
closely matches the way in which the declarations would be used in a C
program. For example, consider the following interface file:</P>
<P> Whenever possible, SWIG creates an interface that closely matches
the underlying C/C++ code. However, due to subtle differences between
languages, run-time environments, and semantics, it is not always
- possible to do so. The next few sections describes various aspects of
+ possible to do so. The next few sections describe various aspects of
this mapping.</P>
-<H3><A name="SWIG_nn10"></A>5.2.1 Basic Type Handling</H3>
+<H3><A name="SWIG_nn10">5.2.1 Basic Type Handling</A></H3>
<P> In order to build an interface, SWIG has to convert C/C++ datatypes
to equivalent types in the target language. Generally, scripting
languages provide a more limited set of primitive types than C.
Unicode characters in the target language will use the same internal
representation (e.g., UCS-2 vs. UCS-4). You may need to write some
special conversion functions.</P>
-<H3><A name="SWIG_nn11"></A>5.2.2 Global Variables</H3>
+<H3><A name="SWIG_nn11">5.2.2 Global Variables</A></H3>
<P> Whenever possible, SWIG maps C/C++ global variables into scripting
language variables. For example,</P>
<DIV class="code">
it only supports read-only access. Note: this behavior is new to
SWIG-1.3. Earlier versions of SWIG incorrectly handled <TT>const</TT>
and created constants instead.</P>
-<H3><A name="SWIG_nn12"></A>5.2.3 Constants</H3>
+<H3><A name="SWIG_nn12">5.2.3 Constants</A></H3>
<P> Constants can be created using <TT>#define</TT>, enumerations, or a
special <TT>%constant</TT> directive. The following interface file
shows a few valid constant declarations :</P>
reasons even a constant with a simple cast will be ignored, such as</P>
<DIV class="code">
<PRE>
-#define F_CONST (double) 5 // A floating pointer constant with cast
+#define F_CONST (double) 5 // A floating point constant with cast
</PRE>
</DIV>
<P> The use of constant expressions is allowed, but SWIG does not
values as assigned by the C compiler.</P>
<P> The <TT>%constant</TT> directive is used to more precisely create
constants corresponding to different C datatypes. Although it is not
- usually not needed for simple values, it is more useful when working
- with pointers and other more complex datatypes. Typically, <TT>
-%constant</TT> is only used when you want to add constants to the
- scripting language interface that are not defined in the original
- header file.</P>
-<H3><A name="SWIG_nn13"></A>5.2.4 A brief word about <TT>const</TT></H3>
+ usually needed for simple values, it is more useful when working with
+ pointers and other more complex datatypes. Typically, <TT>%constant</TT>
+ is only used when you want to add constants to the scripting language
+ interface that are not defined in the original header file.</P>
+<H3><A name="SWIG_nn13">5.2.4 A brief word about const</A></H3>
<P> A common confusion with C programming is the semantic meaning of the
<TT>const</TT> qualifier in declarations--especially when it is mixed
with pointers and other type modifiers. In fact, previous versions of
</PRE>
</DIV>
-<H3><A name="SWIG_nn14"></A>5.2.5 A cautionary tale of <TT>char *</TT></H3>
+<H3><A name="SWIG_nn14">5.2.5 A cautionary tale of char *</A></H3>
<P> Before going any further, there is one bit of caution involving <TT>
char *</TT> that must now be mentioned. When strings are passed from a
scripting language to a C <TT>char *</TT>, the pointer usually points
to string data stored inside the interpreter. It is almost always a
really bad idea to modify this data. Furthermore, some languages may
explicitly disallow it. For instance, in Python, strings are supposed
- be immutable. If you violate this, you will probably receive a vast
+ to be immutable. If you violate this, you will probably receive a vast
amount of wrath when you unleash your module on the world.</P>
<P> The primary source of problems are functions that might modify
string data in place. A classic example would be a function like this:</P>
<P> The bottom line: don't rely on <TT>char *</TT> for anything other
than read-only input values. However, it must be noted that you could
change the behavior of SWIG using <A href="#Typemaps">typemaps</A>.</P>
-<H2><A name="SWIG_nn15"></A>5.3 Pointers and complex objects</H2>
+<H2><A name="SWIG_nn15">5.3 Pointers and complex objects</A></H2>
<P> Most C programs manipulate arrays, structures, and other types of
objects. This section discusses the handling of these datatypes.</P>
-<H3><A name="SWIG_nn16"></A>5.3.1 Simple pointers</H3>
+<H3><A name="SWIG_nn16">5.3.1 Simple pointers</A></H3>
<P> Pointers to primitive C datatypes such as</P>
<DIV class="code">
<PRE>
<LI>By handling all pointers in a consistent manner, the implementation
of SWIG is greatly simplified and less prone to error.</LI>
</UL>
-<H3><A name="SWIG_nn17"></A>5.3.2 Run time pointer type checking</H3>
+<H3><A name="SWIG_nn17">5.3.2 Run time pointer type checking</A></H3>
<P> By allowing pointers to be manipulated from a scripting language,
extension modules effectively bypass compile-time type checking in the
C/C++ compiler. To prevent errors, a type signature is encoded into all
pointers are also sometimes used as sentinel values or to denote a
missing/empty value. Therefore, SWIG leaves NULL pointer checking up to
the application.</P>
-<H3><A name="SWIG_nn18"></A>5.3.3 Derived types, structs, and classes</H3>
+<H3><A name="SWIG_nn18">5.3.3 Derived types, structs, and classes</A></H3>
<P> For everything else (structs, classes, arrays, etc...) SWIG applies
a very simple rule :</P>
<CENTER><B> Everything else is a pointer</B></CENTER>
<PRE>
# Copy a file
def filecopy(source,target):
- f1 = fopen(source,"r")
- f2 = fopen(target,"w")
- buffer = malloc(8192)
- nbytes = fread(buffer,8192,1,f1)
- while (nbytes > 0):
- fwrite(buffer,8192,1,f2)
- nbytes = fread(buffer,8192,1,f1)
- free(buffer)
-
+ f1 = fopen(source,"r")
+ f2 = fopen(target,"w")
+ buffer = malloc(8192)
+ nbytes = fread(buffer,8192,1,f1)
+ while (nbytes > 0):
+ fwrite(buffer,8192,1,f2)
+ nbytes = fread(buffer,8192,1,f1)
+ free(buffer)
</PRE>
</DIV>
<P> In this case <TT>f1</TT>, <TT>f2</TT>, and <TT>buffer</TT> are all
opaque objects containing C pointers. It doesn't matter what value they
contain--our program works just fine without this knowledge.</P>
-<H3><A name="SWIG_nn19"></A>5.3.4 Undefined datatypes</H3>
+<H3><A name="SWIG_nn19">5.3.4 Undefined datatypes</A></H3>
<P> When SWIG encounters an undeclared datatype, it automatically
assumes that it is a structure or class. For example, suppose the
following function appeared in a SWIG input file:</P>
declare type names using <TT>typedef</TT>.</P>
<!-- We might want to add an error reporting flag to swig -->
-<H3><A name="SWIG_nn20"></A>5.3.5 Typedef</H3>
+<H3><A name="SWIG_nn20">5.3.5 Typedef</A></H3>
<P> Like C, <TT>typedef</TT> can be used to define new type names in
SWIG. For example:</P>
<DIV class="code">
</DIV>
<P> The corresponding wrapper function will accept arguments of type <TT>
unsigned int *</TT> or <TT>size_t *</TT>.</P>
-<H2><A name="SWIG_nn21"></A>5.4 Other Practicalities</H2>
+<H2><A name="SWIG_nn21">5.4 Other Practicalities</A></H2>
<P> So far, this chapter has presented almost everything you need to
know to use SWIG for simple interfaces. However, some C programs use
idioms that are somewhat more difficult to map to a scripting language
interface. This section describes some of these issues.</P>
-<H3><A name="SWIG_nn22"></A>5.4.1 Passing structures by value</H3>
+<H3><A name="SWIG_nn22">5.4.1 Passing structures by value</A></H3>
<P> Sometimes a C function takes structure parameters that are passed by
value. For example, consider the following function:</P>
<DIV class="code">
<P> In the target language, the <TT>dot_product()</TT> function now
accepts pointers to Vectors instead of Vectors. For the most part, this
transformation is transparent so you might not notice.</P>
-<H3><A name="SWIG_nn23"></A>5.4.2 Return by value</H3>
+<H3><A name="SWIG_nn23">5.4.2 Return by value</A></H3>
<P> C functions that return structures or classes datatypes by value are
more difficult to handle. Consider the following function:</P>
<DIV class="code">
C++ has some special cases. For example, the above code fragments don't
work correctly if <TT>Vector</TT> doesn't define a default constructor.
The section on SWIG and C++ has more information about this case.</P>
-<H3><A name="SWIG_nn24"></A>5.4.3 Linking to structure variables</H3>
+<H3><A name="SWIG_nn24">5.4.3 Linking to structure variables</A></H3>
<P> When global variables or class members involving structures are
encountered, SWIG handles them as pointers. For example, a global
variable like this</P>
<DIV class="code">
<PRE>
Vector *unit_i_get() {
- return &unit_i;
+ return &unit_i;
}
void unit_i_set(Vector *value) {
- unit_i = *value;
+ unit_i = *value;
}
</PRE>
</DIV>
would be an extremely bad idea to free or destroy such a pointer. Also,
C++ classes must supply a properly defined copy constructor in order
for assignment to work correctly.</P>
-<H3><A name="SWIG_nn25"></A>5.4.4 Linking to <TT>char *</TT></H3>
+<H3><A name="SWIG_nn25">5.4.4 Linking to char *</A></H3>
<P> When a global variable of type <TT>char *</TT> appears, SWIG uses <TT>
malloc()</TT> or <TT>new</TT> to allocate memory for the new value.
Specifically, if you have a variable like this</P>
pointer to point to the new value. However, repeated modifications of
the value will result in a memory leak since the old value is not
released.</P>
-<H3><A name="SWIG_nn26"></A>5.4.5 Arrays</H3>
+<H3><A name="SWIG_nn26">5.4.5 Arrays</A></H3>
<P> Arrays are fully supported by SWIG, but they are always handled as
pointers instead of mapping them to a special array object or list in
the target language. Thus, the following declarations :</P>
</PRE>
</DIV>
<P> Like C, SWIG does not perform array bounds checking. It is up to the
- user to make sure the pointer points a suitably allocated region of
+ user to make sure the pointer points to a suitably allocated region of
memory.</P>
<P> Multi-dimensional arrays are transformed into a pointer to an array
of one less dimension. For example:</P>
</PRE>
</DIV>
<P> In the target language, the value can be set like a normal variable.</P>
-<H3><A name="SWIG_readonly_variables"></A>5.4.6 Creating read-only
- variables</H3>
+<H3><A name="SWIG_readonly_variables">5.4.6 Creating read-only variables</A>
+</H3>
<P> A read-only variable can be created by using the <TT>%immutable</TT>
directive as shown :</P>
<DIV class="code">
<PRE>
// File : interface.i
-int a; // Can read/write
+int a; // Can read/write
%immutable;
-int b,c,d // Read only variables
+int b,c,d; // Read only variables
%mutable;
-double x,y // read/write
+double x,y; // read/write
</PRE>
</DIV>
<P> The <TT>%immutable</TT> directive enables read-only mode until it is
Although these directives still work, they generate a warning message.
Simply change the directives to <TT>%immutable;</TT> and <TT>%mutable;</TT>
to silence the warning. Don't forget the extra semicolon!</P>
-<H3><A name="SWIG_rename_ignore"></A>5.4.7 Renaming and ignoring
- declarations</H3>
-<H4><A name="SWIG_nn29"></A>5.4.7.1 Simple renaming of specific
- identifiers</H4>
+<H3><A name="SWIG_rename_ignore">5.4.7 Renaming and ignoring
+ declarations</A></H3>
+<H4><A name="SWIG_nn29">5.4.7.1 Simple renaming of specific identifiers</A>
+</H4>
<P> Normally, the name of a C declaration is used when that declaration
is wrapped into the target language. However, this may generate a
conflict with a keyword or already existing function in the scripting
<P> This directive is still supported, but it is deprecated and should
probably be avoided. The <TT>%rename</TT> directive is more powerful
and better supports wrapping of raw header file information.</P>
-<H4><A name="SWIG_advanced_renaming"></A>5.4.7.2 Advanced renaming
- support</H4>
+<H4><A name="SWIG_advanced_renaming">5.4.7.2 Advanced renaming support</A>
+</H4>
<P> While writing <TT>%rename</TT> for specific declarations is simple
enough, sometimes the same renaming rule needs to be applied to many,
maybe all, identifiers in the SWIG input. For example, it may be
square brackets should be used literally, e.g. <TT>
%rename("strip:[wx]")</TT></TD><TD><TT>wxPrint</TT></TD><TD><TT>Print</TT>
</TD></TR>
+<TR><TD><TT>rstrip:[suffix]</TT></TD><TD>String without the given suffix
+ or the original string if it doesn't end with this suffix. Note that
+ square brackets should be used literally, e.g. <TT>
+%rename("rstrip:[Cls]")</TT></TD><TD><TT>PrintCls</TT></TD><TD><TT>Print</TT>
+</TD></TR>
<TR><TD>
<!--span style="white-space: nowrap;"-->
<TT>regex:/pattern/subst/</TT></TD><TD>String after (Perl-like) regex
expressions to the identifier names. The<I> pattern</I> part is a
regular expression in Perl syntax (as supported by the <A href="http://www.pcre.org/">
Perl Compatible Regular Expressions (PCRE)</A>) library and the<I> subst</I>
- string can contain back-references introduced by <TT>'\'</TT> or, as
- backslashes need to be escaped in C strings, rather by <TT>"\\"</TT>.
- For example, to remove any alphabetic prefix before an underscore you
- could use the following directive: <TT>
-%rename("regex:/(\\w+)_(.*)/\\2/")</TT></TD><TD><TT>Prefix_Print</TT></TD><TD>
-<TT>Print</TT></TD></TR>
+ string can contain back-references of the form <TT>\N</TT> where <TT>N</TT>
+ is a digit from 0 to 9, or one of the following escape sequences: <TT>
+\l</TT>, <TT>\L</TT>, <TT>\u</TT>, <TT>\U</TT> or <TT>\E</TT>. The
+ back-references are replaced with the contents of the corresponding
+ capture group while the escape sequences perform the case conversion in
+ the substitution string: <TT>\l</TT> and <TT>\L</TT> convert to the
+ lower case, while <TT>\u</TT> and <TT>\U</TT> convert to the upper
+ case. The difference between the elements of each pair is that <TT>\l</TT>
+ and <TT>\u</TT> change the case of the next character only, while <TT>
+\L</TT> and <TT>\U</TT> do it for all the remaining characters or until <TT>
+\E</TT> is encountered. Finally please notice that backslashes need to
+ be escaped in C strings, so in practice <TT>"\\"</TT> must be used in
+ all these escape sequences. For example, to remove any alphabetic
+ prefix before an underscore and capitalize the remaining part you could
+ use the following directive: <TT>%rename("regex:/(\\w+)_(.*)/\\u\\2/")</TT>
+</TD><TD><TT>prefix_print</TT></TD><TD><TT>Print</TT></TD></TR>
<TR><TD><TT>command:cmd</TT></TD><TD>Output of an external command <TT>
cmd</TT> with the string passed to it as input. Notice that this
function is extremely slow compared to all the other ones as it
<P> are exactly equivalent and <TT>%rename</TT> can be used to
selectively ignore multiple declarations using the previously described
matching possibilities.</P>
-<H4><A name="SWIG_limiting_renaming"></A>5.4.7.3 Limiting global
- renaming rules</H4>
+<H4><A name="SWIG_limiting_renaming">5.4.7.3 Limiting global renaming
+ rules</A></H4>
<P> As explained in the previous sections, it is possible to either
rename individual declarations or apply a rename rule to all of them at
once. In practice, the latter is however rarely appropriate as there
methods or C++ methods which use default arguments. This is described
in the <A href="#SWIGPlus_ambiguity_resolution_renaming">Ambiguity
resolution and renaming</A> section in the C++ chapter.</P>
-<H4><A name="SWIG_chosen_unignore"></A>5.4.7.4 Ignoring everything then
- wrapping a few selected symbols</H4>
+<H4><A name="SWIG_chosen_unignore">5.4.7.4 Ignoring everything then
+ wrapping a few selected symbols</A></H4>
<P> Using the techniques described above it is possible to ignore
everything in a header and then selectively wrap a few chosen methods
or classes. For example, consider a header, <TT>myheader.h</TT> which
%include "myheader.h"
</PRE>
</DIV>
-<H3><A name="SWIG_default_args"></A>5.4.8 Default/optional arguments</H3>
+<H3><A name="SWIG_default_args">5.4.8 Default/optional arguments</A></H3>
<P> SWIG supports default arguments in both C and C++ code. For example:</P>
<DIV class="code">
<PRE>
function could be used in Tcl as follows :</P>
<DIV class="targetlang">
<PRE>
-% plot -3.4 7.5 # Use default value
-% plot -3.4 7.5 10 # set color to 10 instead
+% plot -3.4 7.5 # Use default value
+% plot -3.4 7.5 10 # set color to 10 instead
</PRE>
</DIV>
generated for each defaulted argument. Please refer to the section on <A
href="#SWIGPlus_default_args">default arguments</A> in the C++ chapter
for further details.</P>
-<H3><A name="SWIG_nn30"></A>5.4.9 Pointers to functions and callbacks</H3>
+<H3><A name="SWIG_nn30">5.4.9 Pointers to functions and callbacks</A></H3>
<P> Occasionally, a C library may include functions that expect to
receive pointers to functions--possibly to serve as callbacks. SWIG
provides full support for function pointers provided that the callback
</PRE>
</DIV>
<P> Notice that when the function is used as a callback, special names
- such as <TT>add_cb</TT> is used instead. To call the function normally,
- just use the original function name such as <TT>add()</TT>.</P>
+ such as <TT>add_cb</TT> are used instead. To call the function
+ normally, just use the original function name such as <TT>add()</TT>.</P>
<P> SWIG provides a number of extensions to standard C printf formatting
that may be useful in this context. For instance, the following
variation installs the callbacks as all upper case constants such as <TT>
advanced SWIG features. See the <A href="#Typemaps">Typemaps chapter</A>
for more about typemaps and individual target language chapters for
more on callbacks and the 'director' feature.</P>
-<H2><A name="SWIG_nn31"></A>5.5 Structures and unions</H2>
+<H2><A name="SWIG_nn31">5.5 Structures and unions</A></H2>
<P> This section describes the behavior of SWIG when processing ANSI C
structures and union declarations. Extensions to handle C++ are
described in the next section.</P>
<P> If SWIG encounters the definition of a structure or union, it
creates a set of accessor functions. Although SWIG does not need
- structure definitions to build an interface, providing definitions make
- it possible to access structure members. The accessor functions
+ structure definitions to build an interface, providing definitions
+ makes it possible to access structure members. The accessor functions
generated by SWIG simply take a pointer to an object and allow access
to an individual member. For example, the declaration :</P>
<DIV class="code">
<PRE>
struct Vector {
- double x,y,z;
+ double x,y,z;
}
</PRE>
<DIV class="code">
<PRE>
double Vector_x_get(struct Vector *obj) {
- return obj->x;
+ return obj->x;
}
double Vector_y_get(struct Vector *obj) {
- return obj->y;
+ return obj->y;
}
double Vector_z_get(struct Vector *obj) {
- return obj->z;
+ return obj->z;
}
void Vector_x_set(struct Vector *obj, double value) {
- obj->x = value;
+ obj->x = value;
}
void Vector_y_set(struct Vector *obj, double value) {
- obj->y = value;
+ obj->y = value;
}
void Vector_z_set(struct Vector *obj, double value) {
- obj->z = value;
+ obj->z = value;
}
</PRE>
</DIV>
</DIV>
<P> However, most of SWIG's language modules also provide a high-level
interface that is more convenient. Keep reading.</P>
-<H3><A name="SWIG_nn32"></A>5.5.1 Typedef and structures</H3>
+<H3><A name="SWIG_nn32">5.5.1 Typedef and structures</A></H3>
<P> SWIG supports the following construct which is quite common in C
programs :</P>
<DIV class="code">
<PRE>
typedef struct {
- double x,y,z;
+ double x,y,z;
} Vector;
</PRE>
<DIV class="code">
<PRE>
double Vector_x_get(Vector *obj) {
- return obj->x;
+ return obj->x;
}
</PRE>
</DIV>
<DIV class="code">
<PRE>
typedef struct vector_struct {
- double x,y,z;
+ double x,y,z;
} Vector;
</PRE>
later in the interface use the type <TT>struct vector_struct</TT>, SWIG
knows that this is the same as <TT>Vector</TT> and it generates the
appropriate type-checking code.</P>
-<H3><A name="SWIG_nn33"></A>5.5.2 Character strings and structures</H3>
+<H3><A name="SWIG_nn33">5.5.2 Character strings and structures</A></H3>
<P> Structures involving character strings require some care. SWIG
assumes that all members of type <TT>char *</TT> have been dynamically
allocated using <TT>malloc()</TT> and that they are NULL-terminated
- ASCII strings. When such a member is modified, the previously contents
+ ASCII strings. When such a member is modified, the previous contents
will be released, and the new contents allocated. For example :</P>
<DIV class="code">
<PRE>
%module mymodule
...
struct Foo {
- char *name;
- ...
+ char *name;
+ ...
}
</PRE>
<DIV class="code">
<PRE>
char *Foo_name_get(Foo *obj) {
- return Foo->name;
+ return Foo->name;
}
char *Foo_name_set(Foo *obj, char *c) {
- if (obj->name) free(obj->name);
- obj->name = (char *) malloc(strlen(c)+1);
- strcpy(obj->name,c);
- return obj->name;
+ if (obj->name)
+ free(obj->name);
+ obj->name = (char *) malloc(strlen(c)+1);
+ strcpy(obj->name,c);
+ return obj->name;
}
</PRE>
</DIV>
chapter for further details.</P>
<P> Note: If the <TT>-c++</TT> option is used, <TT>new</TT> and <TT>
delete</TT> are used to perform memory allocation.</P>
-<H3><A name="SWIG_nn34"></A>5.5.3 Array members</H3>
+<H3><A name="SWIG_nn34">5.5.3 Array members</A></H3>
<P> Arrays may appear as the members of structures, but they will be
read-only. SWIG will write an accessor function that returns the
pointer to the first element of the array, but will not write a
<P> To eliminate the warning message, typemaps can be used, but this is
discussed in a later chapter. In many cases, the warning message is
harmless.</P>
-<H3><A name="SWIG_structure_data_members"></A>5.5.4 Structure data
- members</H3>
+<H3><A name="SWIG_structure_data_members">5.5.4 Structure data members</A>
+</H3>
<P> Occasionally, a structure will contain data members that are
themselves structures. For example:</P>
<DIV class="code">
<P> When a structure member is wrapped, it is handled as a pointer,
unless the <TT>%naturalvar</TT> directive is used where it is handled
more like a C++ reference (see <A href="#SWIGPlus_member_data">C++
- Member data</A>). The accessors to the member variable as a pointer is
+ Member data</A>). The accessors to the member variable as a pointer are
effectively wrapped as follows:</P>
<DIV class="code">
<PRE>
existing code. However, if you need to tell SWIG that an undeclared
datatype is really a struct, simply use a forward struct declaration
such as <TT>"struct Foo;"</TT>.</P>
-<H3><A name="SWIG_nn36"></A>5.5.5 C constructors and destructors</H3>
+<H3><A name="SWIG_nn36">5.5.5 C constructors and destructors</A></H3>
<P> When wrapping structures, it is generally useful to have a mechanism
for creating and destroying objects. If you don't do anything, SWIG
will automatically generate functions for creating and destroying
};
</PRE>
</DIV>
-<P> Since ignoring the implicit or default destructors most of the times
- produce memory leaks, SWIG will always try to generate them. If needed,
- however, you can selectively disable the generation of the
+<P> Since ignoring the implicit or default destructors most of the time
+ produces memory leaks, SWIG will always try to generate them. If
+ needed, however, you can selectively disable the generation of the
default/implicit destructor by using <TT>%nodefaultdtor</TT></P>
<DIV class="code">
<PRE>
<P><B> Note:</B> There are also the <TT>-nodefault</TT> option and <TT>
%nodefault</TT> directive, which disable both the default or implicit
destructor generation. This could lead to memory leaks across the
- target languages, and is highly recommended you don't use them.</P>
-<H3><A name="SWIG_adding_member_functions"></A>5.5.6 Adding member
- functions to C structures</H3>
+ target languages, and it is highly recommended you don't use them.</P>
+<H3><A name="SWIG_adding_member_functions">5.5.6 Adding member functions
+ to C structures</A></H3>
<P> Most languages provide a mechanism for creating classes and
supporting object oriented programming. From a C standpoint, object
oriented programming really just boils down to the process of attaching
/* file : vector.h */
...
typedef struct Vector {
- double x,y,z;
+ double x,y,z;
} Vector;
</PRE>
%include "vector.h" // Just grab original C header file
%extend Vector { // Attach these functions to struct Vector
- Vector(double x, double y, double z) {
- Vector *v;
- v = (Vector *) malloc(sizeof(Vector));
- v->x = x;
- v->y = y;
- v->z = z;
- return v;
- }
- ~Vector() {
- free($self);
- }
- double magnitude() {
- return sqrt($self->x*$self->x+$self->y*$self->y+$self->z*$self->z);
- }
- void print() {
- printf("Vector [%g, %g, %g]\n", $self->x,$self->y,$self->z);
- }
+ Vector(double x, double y, double z) {
+ Vector *v;
+ v = (Vector *) malloc(sizeof(Vector));
+ v->x = x;
+ v->y = y;
+ v->z = z;
+ return v;
+ }
+ ~Vector() {
+ free($self);
+ }
+ double magnitude() {
+ return sqrt($self->x*$self->x+$self->y*$self->y+$self->z*$self->z);
+ }
+ void print() {
+ printf("Vector [%g, %g, %g]\n", $self->x,$self->y,$self->z);
+ }
};
</PRE>
%}
typedef struct Vector {
- double x,y,z;
- %extend {
- Vector(double x, double y, double z) { ... }
- ~Vector() { ... }
- ...
- }
+ double x,y,z;
+ %extend {
+ Vector(double x, double y, double z) { ... }
+ ~Vector() { ... }
+ ...
+ }
} Vector;
</PRE>
</DIV>
/* Vector methods */
#include "vector.h"
Vector *new_Vector(double x, double y, double z) {
- Vector *v;
- v = (Vector *) malloc(sizeof(Vector));
- v->x = x;
- v->y = y;
- v->z = z;
- return v;
+ Vector *v;
+ v = (Vector *) malloc(sizeof(Vector));
+ v->x = x;
+ v->y = y;
+ v->z = z;
+ return v;
}
void delete_Vector(Vector *v) {
- free(v);
+ free(v);
}
double Vector_magnitude(Vector *v) {
- return sqrt(v->x*v->x+v->y*v->y+v->z*v->z);
+ return sqrt(v->x*v->x+v->y*v->y+v->z*v->z);
}
// File : vector.i
%}
typedef struct Vector {
- double x,y,z;
- %extend {
- Vector(int,int,int); // This calls new_Vector()
- ~Vector(); // This calls delete_Vector()
- double magnitude(); // This will call Vector_magnitude()
- ...
- }
+ double x,y,z;
+ %extend {
+ Vector(int,int,int); // This calls new_Vector()
+ ~Vector(); // This calls delete_Vector()
+ double magnitude(); // This will call Vector_magnitude()
+ ...
+ }
} Vector;
</PRE>
</DIV>
<DIV class="code">
<PRE>
typedef struct Integer {
- int value;
+ int value;
} Int;
%extend Integer { ... } /* Correct name */
%extend Int { ... } /* Incorrect name */
struct Float {
- float value;
+ float value;
};
typedef struct Float FloatValue;
%extend Float { ... } /* Correct name */
<DIV class="code">
<PRE>
typedef struct {
- double value;
+ double value;
} Double;
%extend Double { ... } /* Okay */
</PRE>
name for the <TT>%addmethods</TT> directive. Since <TT>%addmethods</TT>
could be used to extend a structure with more than just methods, a more
suitable directive name has been chosen.</P>
-<H3><A name="SWIG_nested_structs"></A>5.5.7 Nested structures</H3>
+<H3><A name="SWIG_nested_structs">5.5.7 Nested structures</A></H3>
<P> Occasionally, a C program will involve structures like this :</P>
<DIV class="code">
<PRE>
typedef struct Object {
- int objtype;
- union {
- int ivalue;
- double dvalue;
- char *strvalue;
- void *ptrvalue;
- } intRep;
+ int objtype;
+ union {
+ int ivalue;
+ double dvalue;
+ char *strvalue;
+ void *ptrvalue;
+ } intRep;
} Object;
</PRE>
<DIV class="code">
<PRE>
typedef union {
- int ivalue;
- double dvalue;
- char *strvalue;
- void *ptrvalue;
+ int ivalue;
+ double dvalue;
+ char *strvalue;
+ void *ptrvalue;
} Object_intRep;
typedef struct Object {
- int objType;
- Object_intRep intRep;
+ int objType;
+ Object_intRep intRep;
} Object;
</PRE>
<DIV class="code">
<PRE>
Object_intRep *Object_intRep_get(Object *o) {
- return (Object_intRep *) &o->intRep;
+ return (Object_intRep *) &o->intRep;
}
int Object_intRep_ivalue_get(Object_intRep *o) {
- return o->ivalue;
+ return o->ivalue;
}
int Object_intRep_ivalue_set(Object_intRep *o, int value) {
- return (o->ivalue = value);
+ return (o->ivalue = value);
}
double Object_intRep_dvalue_get(Object_intRep *o) {
- return o->dvalue;
+ return o->dvalue;
}
... etc ...
in certain cases.</P>
<P> Finally, note that nesting is handled differently in C++ mode, see <A
href="#SWIGPlus_nested_classes">Nested classes</A>.</P>
-<H3><A name="SWIG_nn39"></A>5.5.8 Other things to note about structure
- wrapping</H3>
+<H3><A name="SWIG_nn39">5.5.8 Other things to note about structure
+ wrapping</A></H3>
<P> SWIG doesn't care if the declaration of a structure in a <TT>.i</TT>
file exactly matches that used in the underlying C code (except in the
case of nested structures). For this reason, there are no problems
choose to build a more advanced interface. Although you may never use
the low-level interface described here, most of SWIG's language modules
use it in some way or another.</P>
-<H2><A name="SWIG_nn40"></A>5.6 Code Insertion</H2>
+<H2><A name="SWIG_nn40">5.6 Code Insertion</A></H2>
<P> Sometimes it is necessary to insert special code into the resulting
wrapper file generated by SWIG. For example, you may want to include
additional C code to perform initialization or other operations. There
are four common ways to insert code, but it's useful to know how the
output of SWIG is structured first.</P>
-<H3><A name="SWIG_nn41"></A>5.6.1 The output of SWIG</H3>
+<H3><A name="SWIG_nn41">5.6.1 The output of SWIG</A></H3>
<P> When SWIG creates its output file, it is broken up into five
sections corresponding to runtime code, headers, wrapper functions, and
module initialization code (in that order).</P>
<BR> The function generated by SWIG to initialize the module upon
loading.</LI>
</UL>
-<H3><A name="SWIG_nn42"></A>5.6.2 Code insertion blocks</H3>
+<H3><A name="SWIG_nn42">5.6.2 Code insertion blocks</A></H3>
<P> Code is inserted into the appropriate code section by using one of
the code insertion directives listed below. The order of the sections
in the wrapper file is as shown:</P>
%{
/* Create a new vector */
static Vector *new_Vector() {
- return (Vector *) malloc(sizeof(Vector));
+ return (Vector *) malloc(sizeof(Vector));
}
%}
Vector *new_Vector();
</PRE>
</DIV>
-<H3><A name="SWIG_nn43"></A>5.6.3 Inlined code blocks</H3>
+<H3><A name="SWIG_nn43">5.6.3 Inlined code blocks</A></H3>
<P> Since the process of writing helper functions is fairly common,
there is a special inlined form of code block that is used as follows :</P>
<DIV class="code">
%inline %{
/* Create a new vector */
Vector *new_Vector() {
- return (Vector *) malloc(sizeof(Vector));
+ return (Vector *) malloc(sizeof(Vector));
}
%}
declaration. Since the code inside an <TT>%inline %{ ... %}</TT> block
is given to both the C compiler and SWIG, it is illegal to include any
SWIG directives inside a <TT>%{ ... %}</TT> block.</P>
-<H3><A name="SWIG_nn44"></A>5.6.4 Initialization blocks</H3>
+<H3><A name="SWIG_nn44">5.6.4 Initialization blocks</A></H3>
<P> When code is included in the <TT>%init</TT> section, it is copied
directly into the module initialization function. For example, if you
needed to perform some extra initialization on module loading, you
<DIV class="code">
<PRE>
%init %{
- init_variables();
+ init_variables();
%}
</PRE>
</DIV>
-<H2><A name="SWIG_nn45"></A>5.7 An Interface Building Strategy</H2>
-<P> This section describes the general approach for building interface
+<H2><A name="SWIG_nn45">5.7 An Interface Building Strategy</A></H2>
+<P> This section describes the general approach for building interfaces
with SWIG. The specifics related to a particular scripting language are
found in later chapters.</P>
-<H3><A name="SWIG_nn46"></A>5.7.1 Preparing a C program for SWIG</H3>
+<H3><A name="SWIG_nn46">5.7.1 Preparing a C program for SWIG</A></H3>
<P> SWIG doesn't require modifications to your C code, but if you feed
it a collection of raw C header files or source code, the results might
not be what you expect---in fact, they might be awful. Here's a series
of steps you can follow to make an interface for a C program :</P>
<UL>
<LI>Identify the functions that you want to wrap. It's probably not
- necessary to access every single function in a C program--thus, a
+ necessary to access every single function of a C program--thus, a
little forethought can dramatically simplify the resulting scripting
- language interface. C header files are particularly good source for
+ language interface. C header files are a particularly good source for
finding things to wrap.</LI>
<LI>Create a new interface file to describe the scripting language
interface to your program.</LI>
available if it is needed, whereas SWIG will usually not warn or error
out as it is designed to work without full type information. However,
if type information is not specified correctly, the wrappers can be
- sub-optimal and even result in uncompileable C/C++ code.</LI>
+ sub-optimal and even result in uncompilable C/C++ code.</LI>
<LI>If your program has a main() function, you may need to rename it
(read on).</LI>
<LI>Run SWIG and compile.</LI>
parser--you should report parsing errors to the <A href="http://www.swig.org/mail.html">
swig-devel mailing list</A> or to the <A href="http://www.swig.org/bugs.html">
SWIG bug tracker</A>.</P>
-<H3><A name="SWIG_nn47"></A>5.7.2 The SWIG interface file</H3>
-<P> The preferred method of using SWIG is to generate separate interface
- file. Suppose you have the following C header file :</P>
+<H3><A name="SWIG_nn47">5.7.2 The SWIG interface file</A></H3>
+<P> The preferred method of using SWIG is to generate a separate
+ interface file. Suppose you have the following C header file :</P>
<DIV class="code">
<PRE>
/* File : header.h */
complex projects, an interface file containing numerous <TT>%include</TT>
and <TT>#include</TT> statements like this is one of the most common
approaches to interface file design due to lower maintenance overhead.</P>
-<H3><A name="SWIG_nn48"></A>5.7.3 Why use separate interface files?</H3>
+<H3><A name="SWIG_nn48">5.7.3 Why use separate interface files?</A></H3>
<P> Although SWIG can parse many header files, it is more common to
write a special <TT>.i</TT> file defining the interface to a package.
There are several reasons why you might want to do this:</P>
interface file and immediately see what is available without having to
dig it out of header files.</LI>
</UL>
-<H3><A name="SWIG_nn49"></A>5.7.4 Getting the right header files</H3>
+<H3><A name="SWIG_nn49">5.7.4 Getting the right header files</A></H3>
<P> Sometimes, it is necessary to use certain header files in order for
the code generated by SWIG to compile properly. Make sure you include
certain header files by using a <TT>%{,%}</TT> block like this:</P>
#include <GL/glu.h>
%}
-// Put rest of declarations here
+// Put the rest of the declarations here
...
</PRE>
</DIV>
-<H3><A name="SWIG_nn50"></A>5.7.5 What to do with main()</H3>
+<H3><A name="SWIG_nn50">5.7.5 What to do with main()</A></H3>
<P> If your program defines a <TT>main()</TT> function, you may need to
get rid of it or rename it in order to use a scripting language. Most
scripting languages define their own <TT>main()</TT> procedure that is
by using a scripting language, you are probably trying to create a
program that is more interactive. In many cases, the old <TT>main()</TT>
program can be completely replaced by a Perl, Python, or Tcl script.</P>
-<P><B> Note:</B> If some cases, you might be inclined to create a
+<P><B> Note:</B> In some cases, you might be inclined to create a
scripting language wrapper for <TT>main()</TT>. If you do this, the
compilation will probably work and your module might even load
correctly. The only trouble is that when you call your <TT>main()</TT>
effect of the symbol binding mechanism used in the dynamic linker. The
bottom line: don't do this.</P>
<HR NOSHADE>
-<H1><A name="SWIGPlus"></A>6 SWIG and C++</H1>
+<H1><A name="SWIGPlus">6 SWIG and C++</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
Basics</A> to see how SWIG wraps ANSI C. Support for C++ builds upon
ANSI C wrapping and that material will be useful in understanding this
chapter.</P>
-<H2><A name="SWIGPlus_nn2"></A>6.1 Comments on C++ Wrapping</H2>
+<H2><A name="SWIGPlus_nn2">6.1 Comments on C++ Wrapping</A></H2>
<P> Because of its complexity and the fact that C++ can be difficult to
integrate with itself let alone other languages, SWIG only provides
support for a subset of C++ features. Fortunately, this is now a rather
complicates the problem of crossing language boundaries and provides
many opportunities to shoot yourself in the foot. You will just have to
be careful.</P>
-<H2><A name="SWIGPlus_nn3"></A>6.2 Approach</H2>
+<H2><A name="SWIGPlus_nn3">6.2 Approach</A></H2>
<P> To wrap C++, SWIG uses a layered approach to code generation. At the
lowest level, SWIG generates a collection of procedural ANSI-C style
wrappers. These wrappers take care of basic type conversion, type
mind that the target languages also provide the high-level OO interface
via proxy classes. More detailed coverage can be found in the
documentation for each target language.</P>
-<H2><A name="SWIGPlus_nn4"></A>6.3 Supported C++ features</H2>
+<H2><A name="SWIGPlus_nn4">6.3 Supported C++ features</A></H2>
<P> SWIG currently supports most C++ features including the following:</P>
<UL>
<LI>Classes</LI>
<P> The following C++ features are not currently supported:</P>
<UL>
<LI>Overloaded versions of certain operators (new, delete, etc.)</LI>
-<LI>Nested classes, see <A href="#SWIGPlus_nested_classes">Nested
- classes</A> for workarounds.</LI>
</UL>
<P> As a rule of thumb, SWIG should not be used on raw C++ source files,
use header files only.</P>
limitations may be lifted in future releases. However, we make no
promises. Also, submitting a bug report is a very good way to get
problems fixed (wink).</P>
-<H2><A name="SWIGPlus_nn5"></A>6.4 Command line options and compilation</H2>
+<H2><A name="SWIGPlus_nn5">6.4 Command line options and compilation</A></H2>
<P> When wrapping C++ code, it is critical that SWIG be called with the
`<TT>-c++</TT>' option. This changes the way a number of critical
features such as memory management are handled. It also enables the
<DIV class="shell">
<PRE>
$ swig -c++ -tcl example.i
-$ c++ -c example_wrap.cxx
+$ c++ -fPIC -c example_wrap.cxx
$ c++ example_wrap.o $(OBJS) -o example.so
</PRE>
</DIV>
flattened low-level C style API to C++ classes by default. The <TT>
-noproxy</TT> commandline option is recognised by many target languages
and will generate just this interface as in earlier versions.
-<H2><A name="SWIGPlus_nn38"></A>6.5 Proxy classes</H2>
+<H2><A name="SWIGPlus_nn38">6.5 Proxy classes</A></H2>
<P> In order to provide a natural mapping from C++ classes to the target
language classes, SWIG's target languages mostly wrap C++ classes with
special proxy classes. These proxy classes are typically implemented in
module, each C++ class is wrapped by a Python proxy class. Or if you're
building a Java module, each C++ class is wrapped by a Java proxy
class.</P>
-<H3><A name="SWIGPlus_nn39"></A>6.5.1 Construction of proxy classes</H3>
+<H3><A name="SWIGPlus_nn39">6.5.1 Construction of proxy classes</A></H3>
<P> Proxy classes are always constructed as an extra layer of wrapping
that uses low-level accessor functions. To illustrate, suppose you had
a C++ class like this:</P>
proxies try to take advantage of language features that are similar to
C++. This might include operator overloading, exception handling, and
other features.</P>
-<H3><A name="SWIGPlus_nn40"></A>6.5.2 Resource management in proxies</H3>
+<H3><A name="SWIGPlus_nn40">6.5.2 Resource management in proxies</A></H3>
<P> A major issue with proxies concerns the memory management of wrapped
objects. Consider the following C++ code:</P>
<DIV class="code">
management problem. However, proxies do provide a mechanism for manual
control that can be used (if necessary) to address some of the more
tricky memory management problems.</P>
-<H3><A name="SWIGPlus_nn41"></A>6.5.3 Language specific details</H3>
+<H3><A name="SWIGPlus_nn41">6.5.3 Language specific details</A></H3>
<P> Language specific details on proxy classes are contained in the
chapters describing each target language. This chapter has merely
introduced the topic in a very general way.</P>
-<H2><A name="SWIGPlus_nn6"></A>6.6 Simple C++ wrapping</H2>
+<H2><A name="SWIGPlus_nn6">6.6 Simple C++ wrapping</A></H2>
<P> The following code shows a SWIG interface file for a simple C++
class.</P>
<DIV class="code">
<P> To generate wrappers for this class, SWIG first reduces the class to
a collection of low-level C-style accessor functions which are then
used by the proxy classes.</P>
-<H3><A name="SWIGPlus_nn7"></A>6.6.1 Constructors and destructors</H3>
+<H3><A name="SWIGPlus_nn7">6.6.1 Constructors and destructors</A></H3>
<P> C++ constructors and destructors are translated into accessor
functions such as the following :</P>
<DIV class="code">
<PRE>
List * new_List(void) {
- return new List;
+ return new List;
}
void delete_List(List *l) {
- delete l;
+ delete l;
}
</PRE>
</DIV>
-<H3><A name="SWIGPlus_nn8"></A>6.6.2 Default constructors, copy
- constructors and implicit destructors</H3>
+<H3><A name="SWIGPlus_nn8">6.6.2 Default constructors, copy constructors
+ and implicit destructors</A></H3>
<P> Following the C++ rules for implicit constructor and destructors,
SWIG will automatically assume there is one even when they are not
explicitly declared in the class interface.</P>
options described above, which disable both the default constructor and
the implicit destructors, could lead to memory leaks, and so it is
strongly recommended to not use them.</P>
-<H3><A name="SWIGPlus_nn9"></A>6.6.3 When constructor wrappers aren't
- created</H3>
+<H3><A name="SWIGPlus_nn9">6.6.3 When constructor wrappers aren't
+ created</A></H3>
<P> If a class defines a constructor, SWIG normally tries to generate a
wrapper for it. However, SWIG will not generate a constructor wrapper
if it thinks that it will result in illegal wrapper code. There are
</DIV>
<P> More information about <TT>%feature</TT> can be found in the <A href="#Customization">
Customization features</A> chapter.</P>
-<H3><A name="SWIGPlus_nn10"></A>6.6.4 Copy constructors</H3>
+<H3><A name="SWIGPlus_nn10">6.6.4 Copy constructors</A></H3>
<P> If a class defines more than one constructor, its behavior depends
on the capabilities of the target language. If overloading is
supported, the copy constructor is accessible using the normal
copy-constructor handling if the constructor has been manually renamed.
For instance, in the above example, the name of the constructor is set
to <TT>new_CopyFoo()</TT>. This is the same as in older versions.</P>
-<H3><A name="SWIGPlus_nn11"></A>6.6.5 Member functions</H3>
+<H3><A name="SWIGPlus_nn11">6.6.5 Member functions</A></H3>
<P> All member functions are roughly translated into accessor functions
like this :</P>
<DIV class="code">
<PRE>
int List_search(List *obj, char *value) {
- return obj->search(value);
+ return obj->search(value);
}
</PRE>
wrapper functions. However, the name and calling convention of the
low-level procedural wrappers match the accessor function prototype
described above.</P>
-<H3><A name="SWIGPlus_nn12"></A>6.6.6 Static members</H3>
+<H3><A name="SWIGPlus_nn12">6.6.6 Static members</A></H3>
<P> Static member functions are called directly without making any
special transformations. For example, the static member function <TT>
print(List *l)</TT> directly invokes <TT>List::print(List *l)</TT> in
the generated wrapper code.</P>
-<H3><A name="SWIGPlus_member_data"></A>6.6.7 Member data</H3>
+<H3><A name="SWIGPlus_member_data">6.6.7 Member data</A></H3>
<P> Member data is handled in exactly the same manner as for C
structures. A pair of accessor functions are effectively created. For
example :</P>
<DIV class="code">
<PRE>
int List_length_get(List *obj) {
- return obj->length;
+ return obj->length;
}
int List_length_set(List *obj, int value) {
- obj->length = value;
- return value;
+ obj->length = value;
+ return value;
}
</PRE>
public:
...
%immutable;
- int length;
+ int length;
%mutable;
...
};
</DIV>
<P> Similarly, all data attributes declared as <TT>const</TT> are
wrapped as read-only members.</P>
-<P> There are some subtle issues when wrapping data members that are
- themselves classes. For instance, if you had another class like this,</P>
+<P> By default, SWIG uses the const reference typemaps for members that
+ are primitive types. There are some subtle issues when wrapping data
+ members that are not primitive types, such as classes. For instance, if
+ you had another class like this,</P>
<DIV class="code">
<PRE>
class Foo {
variables to be wrapped as a string in the target language, rather than
a pointer to this class. The const reference typemaps offer this type
of marshalling, so there is a feature to tell SWIG to use the const
- reference typemaps rather than the pointer typemaps. It is the <TT>
-%naturalvar</TT> directive and is used as follows:</P>
+ reference typemaps rather than the pointer typemaps. It is the
+ naturalvar feature and can be used to effectively change the way
+ accessors are generated to the following:</P>
+<DIV class="code">
+<PRE>
+const List &Foo_items_get(Foo *self) {
+ return self->items;
+}
+void Foo_items_set(Foo *self, const List &value) {
+ self->items = value;
+}
+</PRE>
+</DIV>
+<P> The <TT>%naturalvar</TT> directive is a macro for, and hence
+ equivalent to, <TT>%feature("naturalvar")</TT>. It can be used as
+ follows:</P>
<DIV class="code">
<PRE>
// All List variables will use const List& typemaps
List myList;
};
-// All variables will use const reference typemaps
+// All non-primitive types will use const reference typemaps
%naturalvar;
</PRE>
</DIV>
<P> The observant reader will notice that <TT>%naturalvar</TT> works
like any other <A href="#Customization_feature_flags">feature flag</A>
- directive, except it can also be attached to class types. The first of
- the example usages above show <TT>%naturalvar</TT> attaching to the <TT>
-List</TT> class. Effectively this feature changes the way accessors are
- generated to the following:</P>
-<DIV class="code">
-<PRE>
-const List &Foo_items_get(Foo *self) {
- return self->items;
-}
-void Foo_items_set(Foo *self, const List &value) {
- self->items = value;
-}
-</PRE>
-</DIV>
-<P> In fact it is generally a good idea to use this feature globally as
- the reference typemaps have extra NULL checking compared to the pointer
+ directive but with some extra flexibility. The first of the example
+ usages above shows <TT>%naturalvar</TT> attaching to the <TT>myList</TT>
+'s variable type, that is the <TT>List</TT> class. The second usage
+ shows <TT>%naturalvar</TT> attaching to the variable name. Hence the
+ naturalvar feature can be used on either the variable's name or type.
+ Note that using the naturalvar feature on a variable's name overrides
+ any naturalvar feature attached to the variable's type.</P>
+<P> It is generally a good idea to use this feature globally as the
+ reference typemaps have extra NULL checking compared to the pointer
typemaps. A pointer can be NULL, whereas a reference cannot, so the
extra checking ensures that the target language user does not pass in a
value that translates to a NULL pointer and thereby preventing any
potential NULL pointer dereferences. The <TT>%naturalvar</TT> feature
will apply to global variables in addition to member variables in some
language modules, eg C# and Java.</P>
-<P> Other alternatives for turning this feature on globally are to use
- the <TT>swig -naturalvar</TT> commandline option or the module mode
- option, <TT>%module(naturalvar=1)</TT></P>
+<P> The naturalvar behavior can also be turned on as a global setting
+ via the <TT>-naturalvar</TT> commandline option or the module mode
+ option, <TT>%module(naturalvar=1)</TT>. However, any use of <TT>
+%feature("naturalvar")</TT> will override the global setting.</P>
<P><B> Compatibility note:</B> The <TT>%naturalvar</TT> feature was
introduced in SWIG-1.3.28, prior to which it was necessary to manually
apply the const reference typemaps, eg <TT>%apply const std::string & {
involving <TT>size_t</TT>. This change is subtle, but it smooths over a
few problems related to structure wrapping and some of SWIG's
customization features.</P>
-<H2><A name="SWIGPlus_default_args"></A>6.7 Default arguments</H2>
+<H2><A name="SWIGPlus_default_args">6.7 Default arguments</A></H2>
<P> SWIG will wrap all types of functions that have default arguments.
For example member functions:</P>
<DIV class="code">
};
</PRE>
</DIV>
-<P> This produces uncompileable wrapper code because default values in
+<P> This produces uncompilable wrapper code because default values in
C++ are evaluated in the same scope as the member function whereas SWIG
evaluates them in the scope of a wrapper function (meaning that the
values have to be public).</P>
-<P> This feature is automatically turned on when wrapping <A href="#SWIG_default_args">
-C code with default arguments</A> and whenever keyword arguments
- (kwargs) are specified for either C or C++ code. Keyword arguments are
- a language feature of some scripting languages, for example Ruby and
- Python. SWIG is unable to support kwargs when wrapping overloaded
- methods, so the default approach cannot be used.</P>
-<H2><A name="SWIGPlus_nn15"></A>6.8 Protection</H2>
+<P> The <TT>compactdefaultargs</TT> feature is automatically turned on
+ when wrapping <A href="#SWIG_default_args">C code with default
+ arguments</A>. Some target languages will also automatically turn on
+ this feature if the keyword arguments feature (kwargs) is specified for
+ either C or C++ functions, and the target language supports kwargs, the
+ <TT>compactdefaultargs</TT> feature is also automatically turned on.
+ Keyword arguments are a language feature of some scripting languages,
+ for example Ruby and Python. SWIG is unable to support kwargs when
+ wrapping overloaded methods, so the default approach cannot be used.</P>
+<H2><A name="SWIGPlus_nn15">6.8 Protection</A></H2>
<P> SWIG wraps class members that are public following the C++
conventions, i.e., by explicit public declaration or by the use of the <TT>
using</TT> directive. In general, anything specified in a private or
<P> By default, members of a class definition are assumed to be private
until you explicitly give a `<TT>public:</TT>' declaration (This is the
same convention used by C++).</P>
-<H2><A name="SWIGPlus_nn16"></A>6.9 Enums and constants</H2>
+<H2><A name="SWIGPlus_nn16">6.9 Enums and constants</A></H2>
<P> Enumerations and constants are handled differently by the different
language modules and are described in detail in the appropriate
language chapter. However, many languages map enums and constants in a
<PRE>
class Swig {
public:
- enum {ALE, LAGER, PORTER, STOUT};
+ enum {ALE, LAGER, PORTER, STOUT};
};
</PRE>
</DIV>
<P> Members declared as <TT>const</TT> are wrapped as read-only members
and do not create constants.</P>
-<H2><A name="SWIGPlus_nn17"></A>6.10 Friends</H2>
+<H2><A name="SWIGPlus_nn17">6.10 Friends</A></H2>
<P> Friend declarations are recognised by SWIG. For example, if you have
this code:</P>
<DIV class="code">
</PRE>
</DIV>
<P> and a wrapper for the method 'blah' will not be generated.</P>
-<H2><A name="SWIGPlus_nn18"></A>6.11 References and pointers</H2>
+<H2><A name="SWIGPlus_nn18">6.11 References and pointers</A></H2>
<P> C++ references are supported, but SWIG transforms them back into
pointers. For example, a declaration like this :</P>
<DIV class="code">
<PRE>
class Foo {
public:
- double bar(double &a);
+ double bar(double &a);
}
</PRE>
</DIV>
<DIV class="code">
<PRE>
double Foo_bar(Foo *obj, double *a) {
- obj->bar(*a);
+ obj->bar(*a);
}
</PRE>
</DIV>
datatypes is necessary to provide more seamless integration with more
advanced C++ wrapping applications---especially related to templates
and the STL. This was first added in SWIG-1.3.12.</P>
-<H2><A name="SWIGPlus_nn19"></A>6.12 Pass and return by value</H2>
+<H2><A name="SWIGPlus_nn19">6.12 Pass and return by value</A></H2>
<P> Occasionally, a C++ program will pass and return class objects by
value. For example, a function like this might appear:</P>
<DIV class="code">
<P><B> Note:</B> The use of this template only occurs when objects are
passed or returned by value. It is not used for C++ pointers or
references.</P>
-<H2><A name="SWIGPlus_nn20"></A>6.13 Inheritance</H2>
+<H2><A name="SWIGPlus_nn20">6.13 Inheritance</A></H2>
<P> SWIG supports C++ inheritance of classes and allows both single and
multiple inheritance, as limited or allowed by the target language. The
SWIG type-checker knows about the relationship between base and derived
spirit, and target language capabilities, as possible. In most cases,
this means that SWIG will parse the non-public inheritance
declarations, but that will have no effect in the generated code,
- besides the implicit policies derived for constructor and destructors.</P>
+ besides the implicit policies derived for constructors and destructors.</P>
<P> The following example shows how SWIG handles inheritance. For
clarity, the full C++ code has been omitted.</P>
<DIV class="code">
class Shape {
public:
- double x,y;
- virtual double area() = 0;
- virtual double perimeter() = 0;
- void set_location(double x, double y);
+ double x,y;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
+ void set_location(double x, double y);
};
class Circle : public Shape {
public:
- Circle(double radius);
- ~Circle();
- double area();
- double perimeter();
+ Circle(double radius);
+ ~Circle();
+ double area();
+ double perimeter();
};
class Square : public Shape {
public:
- Square(double size);
- ~Square();
- double area();
- double perimeter();
+ Square(double size);
+ ~Square();
+ double area();
+ double perimeter();
}
</PRE>
</DIV>
using the <TT>-fvirtual</TT> option, which avoids the regenerating of
wrapper functions for virtual members that are already defined in a
base class.</P>
-<H2><A name="SWIGPlus_nn21"></A>6.14 A brief discussion of multiple
- inheritance, pointers, and type checking</H2>
+<H2><A name="SWIGPlus_nn21">6.14 A brief discussion of multiple
+ inheritance, pointers, and type checking</A></H2>
<P> When a target scripting language refers to a C++ object, it normally
uses a tagged pointer object that contains both the value of the
pointer and a type string. For example, in Tcl, a C++ pointer might be
</DIV>
<P> In practice, the pointer is held as an integral number in the target
language proxy class.</P>
-<H2><A name="SWIGPlus_overloaded_methods"></A>6.15 Wrapping Overloaded
- Functions and Methods</H2>
+<H2><A name="SWIGPlus_overloaded_methods">6.15 Wrapping Overloaded
+ Functions and Methods</A></H2>
<P> In many language modules, SWIG provides partial support for
overloaded functions, methods, and constructors. For example, if you
supply SWIG with overloaded functions like this:</P>
>>> f.bar("hello",2)
</PRE>
</DIV>
-<H3><A name="SWIGPlus_nn24"></A>6.15.1 Dispatch function generation</H3>
+<H3><A name="SWIGPlus_nn24">6.15.1 Dispatch function generation</A></H3>
<P> The implementation of overloaded functions and methods is somewhat
complicated due to the dynamic nature of scripting languages. Unlike
C++, which binds overloaded methods at compile time, SWIG must
appear in this ranking.</P>
<P> If you're still confused, don't worry about it---SWIG is probably
doing the right thing.</P>
-<H3><A name="SWIGPlus_nn25"></A>6.15.2 Ambiguity in Overloading</H3>
+<H3><A name="SWIGPlus_nn25">6.15.2 Ambiguity in Overloading</A></H3>
<P> Regrettably, SWIG is not able to support every possible use of valid
C++ overloading. Consider the following example:</P>
<DIV class="code">
they appear in the interface file. Therefore, earlier methods will
shadow methods that appear later.</P>
<P> When wrapping an overloaded function, there is a chance that you
- will get an error message like this:</P>
+ will get a warning message like this:</P>
<DIV class="shell">
<PRE>
-example.i:3: Warning 467: Overloaded foo(int) not supported (no type checking
-rule for 'int').
+example.i:3: Warning 467: Overloaded foo(int) not supported (incomplete type checking rule -
+no precedence level in typecheck typemap for 'int').
</PRE>
</DIV>
<P> This error means that the target language module supports
overloading, but for some reason there is no type-checking rule that
can be used to generate a working dispatch function. The resulting
behavior is then undefined. You should report this as a bug to the <A href="http://www.swig.org/bugs.html">
-SWIG bug tracking database</A>.</P>
+SWIG bug tracking database</A> if this is due to one of the typemaps
+ supplied with SWIG.</P>
<P> If you get an error message such as the following,</P>
<DIV class="shell">
<PRE>
<P> it means that the target language module has not yet implemented
support for overloaded functions and methods. The only way to fix the
problem is to read the next section.</P>
-<H3><A name="SWIGPlus_ambiguity_resolution_renaming"></A>6.15.3
- Ambiguity resolution and renaming</H3>
+<H3><A name="SWIGPlus_ambiguity_resolution_renaming">6.15.3 Ambiguity
+ resolution and renaming</A></H3>
<P> If an ambiguity in overload resolution occurs or if a module doesn't
allow overloading, there are a few strategies for dealing with the
problem. First, you can tell SWIG to ignore one of the methods. This is
<P> Currently no resolution is performed in order to match function
parameters. This means function parameter types must match exactly. For
example, namespace qualifiers and typedefs will not work. The following
- usage of typedefs demonstrates this:<DIV class="code">
+ usage of typedefs demonstrates this:</P>
+<DIV class="code">
<PRE>
typedef int Integer;
void foo(int); // Renamed to foo_i
};
</PRE>
-</DIV></P>
-</LI>
+</DIV></LI>
<LI>
<P> The name matching rules also use default arguments for finer control
when wrapping methods that have default arguments. Recall that methods
the changes to wrapping methods with default arguments was introduced.</P>
</LI>
</UL>
-<H3><A name="SWIGPlus_nn27"></A>6.15.4 Comments on overloading</H3>
+<H3><A name="SWIGPlus_nn27">6.15.4 Comments on overloading</A></H3>
<P> Support for overloaded methods was first added in SWIG-1.3.14. The
implementation is somewhat unusual when compared to similar tools. For
instance, the order in which declarations appear is largely irrelevant
support may vary from language to language. As a general rule,
statically typed languages like Java are able to provide more support
than dynamically typed languages like Perl, Python, Ruby, and Tcl.</P>
-<H2><A name="SWIGPlus_nn28"></A>6.16 Wrapping overloaded operators</H2>
+<H2><A name="SWIGPlus_nn28">6.16 Wrapping overloaded operators</A></H2>
<P> C++ overloaded operator declarations can be wrapped. For example,
consider a class like this:</P>
<DIV class="code">
}
Complex operator*(const Complex &c) const {
return Complex(rpart*c.rpart - ipart*c.ipart,
- rpart*c.ipart + c.rpart*ipart);
+ rpart*c.ipart + c.rpart*ipart);
}
Complex operator-() const {
return Complex(-rpart, -ipart);
<LI>The semantics of certain C++ operators may not match those in the
target language.</LI>
</UL>
-<H2><A name="SWIGPlus_class_extension"></A>6.17 Class extension</H2>
+<H2><A name="SWIGPlus_class_extension">6.17 Class extension</A></H2>
<P> New methods can be added to a class using the <TT>%extend</TT>
directive. This directive is primarily used in conjunction with proxy
classes to add additional functionality to an existing class. For
class Vector {
public:
- double x,y,z;
- Vector();
- ~Vector();
- ... bunch of C++ methods ...
- %extend {
- char *__str__() {
- static char temp[256];
- sprintf(temp,"[ %g, %g, %g ]", $self->x,$self->y,$self->z);
- return &temp[0];
- }
- }
+ double x,y,z;
+ Vector();
+ ~Vector();
+ ... bunch of C++ methods ...
+ %extend {
+ char *__str__() {
+ static char temp[256];
+ sprintf(temp,"[ %g, %g, %g ]", $self->x,$self->y,$self->z);
+ return &temp[0];
+ }
+ }
};
</PRE>
</DIV>
</DIV>
<P> The following special variables are expanded if used within a
%extend block: $name, $symname, $overname, $decl, $fulldecl,
- $parent
name and $parentsymname. The <A href="#Customization_exception_special_variables">
+ $parent
classname and $parentclasssymname. The <A href="#Customization_exception_special_variables">
Special variables</A> section provides more information each of these
special variables.</P>
<P> The <TT>%extend</TT> directive follows all of the same conventions
name for the <TT>%addmethods</TT> directive in SWIG1.1. Since <TT>
%addmethods</TT> could be used to extend a structure with more than just
methods, a more suitable directive name has been chosen.</P>
-<H2><A name="SWIGPlus_nn30"></A>6.18 Templates</H2>
+<H2><A name="SWIGPlus_nn30">6.18 Templates</A></H2>
<P> Template type names may appear anywhere a type is expected in an
interface file. For example:</P>
<DIV class="code">
template<class T> class List {
...
public:
- List() { };
+ List() { }
T get(int index);
...
};
point is that<B> SWIG does not perform extensive error checking of
templates!</B> Specifically, SWIG does not perform type checking nor
does it check to see if the actual contents of the template declaration
- make any sense. Since the C++ compiler will hopefully check this when
- it compiles the resulting wrapper file, there is no practical reason
- for SWIG to duplicate this functionality (besides, none of the SWIG
- developers are masochistic enough to want to implement this right now).</P>
+ make any sense. Since the C++ compiler checks this when it compiles the
+ resulting wrapper file, there is no practical reason for SWIG to
+ duplicate this functionality.</P>
+ <A name="SWIGPlus_template_nested_class_example"></A>
+<P> As SWIG's template support does not perform type checking <TT>
+%template</TT> can be used as early as after a template declaration. You
+ can, and rarely have to, use <TT>%template</TT> before the template
+ parameters have been declared. For example:</P>
+<DIV class="code">
+<PRE>
+template <class T> class OuterTemplateClass {};
+
+// The nested class OuterClass::InnerClass inherits from the template class
+// OuterTemplateClass<OuterClass::InnerStruct> and thus the template needs
+// to be expanded with %template before the OuterClass declaration.
+%template(OuterTemplateClass_OuterClass__InnerStruct)
+ OuterTemplateClass<OuterClass::InnerStruct>
+
+
+// Don't forget to use %feature("flatnested") for OuterClass::InnerStruct and
+// OuterClass::InnerClass if the target language doesn't support nested classes.
+class OuterClass {
+ public:
+ // Forward declarations:
+ struct InnerStruct;
+ class InnerClass;
+};
+
+struct OuterClass::InnerStruct {};
+
+// Expanding the template at this point with %template is too late as the
+// OuterClass::InnerClass declaration is processed inside OuterClass.
+
+class OuterClass::InnerClass : public OuterTemplateClass<InnerStruct> {};
+</PRE>
+</DIV>
<P><B> Compatibility Note</B>: The first implementation of template
support relied heavily on macro expansion in the preprocessor.
Templates have been more tightly integrated into the parser and type
</PRE>
</DIV>
<P> Similar changes apply to typemaps and other customization features.</P>
-<H2><A name="SWIGPlus_namespaces"></A>6.19 Namespaces</H2>
+<H2><A name="SWIGPlus_namespaces">6.19 Namespaces</A></H2>
<P> Support for C++ namespaces is comprehensive, but by default simple,
however, some target languages can turn on more advanced namespace
support via the <A href="#SWIGPlus_nspace">nspace feature</A>,
modules are currently programmed with any namespace awareness. In the
future, language modules may or may not provide more advanced namespace
support.</P>
-<H3><A name="SWIGPlus_nspace"></A>6.19.1 The nspace feature for
- namespaces</H3>
+<H3><A name="SWIGPlus_nspace">6.19.1 The nspace feature for namespaces</A>
+</H3>
<P> Some target languages provide support for the <TT>nspace</TT> <A href="#Customization_features">
feature</A>. The feature can be applied to any class, struct, union or
enum declared within a named namespace. The feature wraps the type
</DIV>
<P><B> Compatibility Note:</B> The nspace feature was first introduced
in SWIG-2.0.0.</P>
-<H2><A name="SWIGPlus_renaming_templated_types_namespaces"></A>6.20
- Renaming templated types in namespaces</H2>
+<H2><A name="SWIGPlus_renaming_templated_types_namespaces">6.20 Renaming
+ templated types in namespaces</A></H2>
<P> As has been mentioned, when %rename includes parameters, the
parameter types must match exactly (no typedef or namespace resolution
is performed). SWIG treats templated types slightly differently and has
%template(ABCXYZ) Space::ABC<Space::XYZ>;
</PRE>
</DIV>
-<H2><A name="SWIGPlus_exception_specifications"></A>6.21 Exception
- specifications</H2>
+<H2><A name="SWIGPlus_exception_specifications">6.21 Exception
+ specifications</A></H2>
<P> When C++ programs utilize exceptions, exceptional behavior is
sometimes specified as part of a function or method declaration. For
example:</P>
"<A href="#Customization_exception">Exception handling with %exception</A>
" section for details. The next section details a way of simulating an
exception specification or replacing an existing one.</P>
-<H2><A name="SWIGPlus_catches"></A>6.22 Exception handling with %catches</H2>
+<H2><A name="SWIGPlus_catches">6.22 Exception handling with %catches</A></H2>
<P> Exceptions are automatically handled for methods with an exception
specification. Similar handling can be achieved for methods without
exception specifications through the <TT>%catches</TT> feature. It is
single catch handler for the base class, <TT>EBase</TT> will be
generated to convert the C++ exception into a target language
error/exception.</P>
-<H2><A name="SWIGPlus_nn33"></A>6.23 Pointers to Members</H2>
+<H2><A name="SWIGPlus_nn33">6.23 Pointers to Members</A></H2>
<P> Starting with SWIG-1.3.7, there is limited parsing support for
pointers to C++ class members. For example:</P>
<DIV class="code">
with member pointers. Normally SWIG tries to keep track of inheritance
when checking types. However, no such support is currently provided for
member pointers.</P>
-<H2><A name="SWIGPlus_smart_pointers"></A>6.24 Smart pointers and
- operator->()</H2>
+<H2><A name="SWIGPlus_smart_pointers">6.24 Smart pointers and
+ operator->()</A></H2>
<P> In some C++ programs, objects are often encapsulated by
smart-pointers or proxy classes. This is sometimes done to implement
automatic memory management (reference counting) or persistence.
</PRE>
</DIV>
<P><B> Note:</B> Smart pointer support was first added in SWIG-1.3.14.</P>
-<H2><A name="SWIGPlus_ref_unref"></A>6.25 C++ reference counted objects
- - ref/unref feature</H2>
+<H2><A name="SWIGPlus_ref_unref">6.25 C++ reference counted objects -
+ ref/unref feature</A></H2>
<P> Another similar idiom in C++ is the use of reference counted
- objects. Consider for example:<DIV class="code">
+ objects. Consider for example:</P>
+<DIV class="code">
<PRE>
class RCObj {
// implement the ref counting mechanism
return add_ref();
}
- int unref() const {
+ int unref() const {
if (ref_count() == 0 || del_ref() == 0 ) {
- delete this;
- return 0;
- }
+ delete this;
+ return 0;
+ }
return ref_count();
}
};
a->unref(); // 'a' unref and deleted (count: 0)
}
</PRE>
-</DIV></P>
+</DIV>
<P> In the example above, the 'A' class instance 'a' is a reference
counted object, which can't be deleted arbitrarily since it is shared
between the objects 'b1' and 'b2'. 'A' is derived from a<I> Reference
exit # 'a' is released, SWIG unref 'a' called in the destructor wrapper (count: 0)
</PRE>
</DIV>
-<H2><A name="SWIGPlus_nn35"></A>6.26 Using declarations and inheritance</H2>
+<H2><A name="SWIGPlus_nn35">6.26 Using declarations and inheritance</A></H2>
<P> <TT>using</TT> declarations are sometimes used to adjust access to
members of base classes. For example:</P>
<DIV class="code">
</PRE>
</DIV></LI>
</UL>
-<H2><A name="SWIGPlus_nested_classes"></A>6.27 Nested classes</H2>
-<P> There is some support for nested structs and unions when wrapping C
- code, see <A href="#SWIG_nested_structs">Nested structures</A> for
- further details. The added complexity of C++ compared to C means this
- approach does not work well for C++ code (when using the -c++ command
- line option). For C++, a nested class is treated much like an opaque
- pointer, so anything useful within the nested class, such as its
- methods and variables, are not accessible from the target language.
- True nested class support may be added to SWIG in the future, however,
- until then some of the following workarounds can be applied to improve
- the situation.</P>
-<P> It might be possible to use partial class information as often you
- can accept that the nested class is not needed, especially if it is not
- actually used in any methods you need from the target language. Imagine
- you are wrapping the following <TT>Outer</TT> class which contains a
- nested class <TT>Inner</TT>. The easiest thing to do is turn a blind
- eye to the warning that SWIG generates, or simply suppress it:</P>
-<DIV class="code">
-<PRE>
-%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) Outer::Inner;
-
-class Outer {
-public:
- class Inner {
- public:
- ...
- };
- Inner getInner();
- void useInner(const Inner& inner);
- ...
-};
-</PRE>
-</DIV>
-<P> Note that if <TT>Inner</TT> can be used as an opaque type, the
- default wrapping approach suffices. For example, if the nested class
- does not need to be created from the target language, but can be
- obtained via a method call, such as the <TT>getInner()</TT> method
- above, the returned value can then be passed around, such as passed
- into the <TT>useInner()</TT> method.</P>
-<P> With some more effort the above situation can be improved somewhat
- and a nested class can be constructed and used from the target language
- much like any other non-nested class. Assuming we have the <TT>Outer</TT>
- class in a header file:</P>
-<DIV class="code">
-<PRE>
-// File outer.h
-class Outer {
-public:
- class Inner {
- public:
- int var;
- Inner(int v = 0) : var(v) {}
- };
- Inner getInner();
- void useInner(const Inner& inner);
-};
-</PRE>
-</DIV>
-<P> The following interface file works around the nested class
- limitations by redefining the nested class as a global class. A typedef
- for the compiler and the <TT>nestedworkaround</TT> <A href="#Customization_feature_flags">
-feature flag</A> is also required in order for the generated wrappers to
- compile. This flag simply removes all the type information from SWIG,
- so SWIG treats the nested class as if it had not been parsed at all.</P>
-<DIV class="code">
-<PRE>
-// File : example.i
-%module example
-
-// Redefine nested class in global scope in order for SWIG to generate
-// a proxy class. Only SWIG parses this definition.
-class Inner {
+<H2><A name="SWIGPlus_nested_classes">6.27 Nested classes</A></H2>
+<P> If the target language supports the nested classes concept (like
+ Java), the nested C++ classes are wrapped as nested target language
+ proxy classes. (In case of Java - "static" nested classes.) Only public
+ nested classes are wrapped. Otherwise there is little difference
+ between nested and normal classes.</P>
+<P> If the target language doesn't support nested classes directly, or
+ the support is not implemented in the language module (like for python
+ currently), then the visible nested classes are moved to the same name
+ space as the containing class (nesting hierarchy is "flattened"). The
+ same behaviour may be turned on for C# and Java by the %feature
+ ("flatnested"); If there is a class with the same name in the outer
+ namespace the inner class (or the global one) may be renamed or
+ ignored:</P>
+<DIV class="code">
+<PRE>
+%rename (Bar_Foo) Bar::Foo;
+class Foo {};
+class Bar {
public:
- int var;
- Inner(int v = 0) : var(v) {}
-};
-
-%nestedworkaround Outer::Inner;
-
-%{
-#include "outer.h"
-%}
-%include "outer.h"
-
-// We've fooled SWIG into thinking that Inner is a global class, so now we need
-// to trick the C++ compiler into understanding this apparent global type.
-%{
-typedef Outer::Inner Inner;
-%}
-</PRE>
-</DIV>
-<P> The downside to this approach is a more complex interface file and
- having to maintain two definitions of <TT>Inner</TT>, the real one and
- the one in the interface file that SWIG parses. However, the upside is
- that all the methods/variables in the nested class are available from
- the target language as a proxy class is generated instead of treating
- the nested class as an opaque type. The proxy class can be constructed
- from the target language and passed into any methods accepting the
- nested class. Also note that the original header file is parsed
- unmodified.</P>
-<P> Finally, conditional compilation can be used as a workaround to
- comment out nested class definitions in the actual headers, assuming
- you are able to modify them.</P>
-<DIV class="code">
+ class Foo {};
+};
+</PRE>
+</DIV>
+<P> If a nested class, within an outer class, has to be used as a
+ template parameter within the outer class, then the template will have
+ to be instantiated with <TT>%template</TT> before the beginning of the
+ outer class. An example can be found in the <A href="#SWIGPlus_template_nested_class_example">
+Templates</A> section.</P>
+<P><B> Compatibility Note:</B> Prior to SWIG-3.0.0, there was limited
+ nested class support. Nested classes were treated as opaque pointers.
+ However, there was a workaround for nested class support in these older
+ versions requiring the user to replicate the nested class in the global
+ scope, adding in a typedef for the nested class in the global scope and
+ using the "nestedworkaround" feature on the nested class. This resulted
+ in approximately the same behaviour as the "flatnested" feature. With
+ proper nested class support now available in SWIG-3.0.0, this feature
+ has been deprecated and no longer works requiring code changes. If you
+ see the following warning:</P>
+<DIV class="shell">
<PRE>
-// File outer.h
-class Outer {
-public:
-#ifndef SWIG
- class Inner {
- public:
- ...
- };
-#endif
- ...
-};
+example.i:8: Warning 126: The nestedworkaround feature is deprecated
</PRE>
</DIV>
-<P> This workaround used to be common when SWIG could not deal with
- nested classes particulary well. This should just be a last resort for
- unusual corner cases now as SWIG can parse nested classes and even
- handle nested template classes fairly well.</P>
-<P><B> Compatibility Note:</B> SWIG-1.3.40 and earlier versions did not
- have the <TT>nestedworkaround</TT> feature and the generated code
- resulting from parsing nested classes did not always compile. Nested
- class warnings could also not be suppressed using %warnfilter.</P>
-<H2><A name="SWIGPlus_const"></A>6.28 A brief rant about
- const-correctness</H2>
+<P> consider using the "flatnested" feature discussed above which
+ generates a non-nested proxy class, like the "nestedworkaround" feature
+ did. Alternatively, use the default nested class code generation, which
+ may generate an equivalent to a nested proxy class in the target
+ language, depending on the target language support.</P>
+<P> SWIG-1.3.40 and earlier versions did not have the <TT>
+nestedworkaround</TT> feature and the generated code resulting from
+ parsing nested classes did not always compile. Nested class warnings
+ could also not be suppressed using %warnfilter.</P>
+<H2><A name="SWIGPlus_const">6.28 A brief rant about const-correctness</A>
+</H2>
<P> A common issue when working with C++ programs is dealing with all
possible ways in which the <TT>const</TT> qualifier (or lack thereof)
will break your program, all programs linked against your program, and
a problem for most SWIG projects. Of course, you might want to consider
using another tool if maintaining constness is the most important part
of your project.</P>
-<H2><A name="SWIGPlus_nn42"></A>6.29 Where to go for more information</H2>
+<H2><A name="SWIGPlus_nn42">6.29 Where to go for more information</A></H2>
<P> If you're wrapping serious C++ code, you might want to pick up a
copy of "The Annotated C++ Reference Manual" by Ellis and Stroustrup.
This is the reference document we use to guide a lot of SWIG's C++
<!-- LocalWords: notabstract CopyFoo
-->
<HR NOSHADE>
-<H1><A name="Preprocessor"></A>7 Preprocessing</H1>
+<H1><A name="CPlusPlus11">7 SWIG and C++11</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<UL>
-<LI><A href="#Preprocessor_nn2">File inclusion</A></LI>
-<LI><A href="#Preprocessor_nn3">File imports</A></LI>
-<LI><A href="#Preprocessor_condition_compilation">Conditional
- Compilation</A></LI>
-<LI><A href="#Preprocessor_nn5">Macro Expansion</A></LI>
-<LI><A href="#Preprocessor_nn6">SWIG Macros</A></LI>
-<LI><A href="#Preprocessor_nn7">C99 and GNU Extensions</A></LI>
-<LI><A href="#Preprocessor_delimiters">Preprocessing and delimiters</A>
-<UL>
-<LI><A href="#Preprocessor_nn8">Preprocessing and %{ ... %} & " ... "
- delimiters</A></LI>
-<LI><A href="#Preprocessor_nn9">Preprocessing and { ... } delimiters</A></LI>
+<LI><A href="#CPlusPlus11_introduction">Introduction</A></LI>
+<LI><A href="#CPlusPlus11_core_language_changes">Core language changes</A>
+<UL>
+<LI><A href="#CPlusPlus11_rvalue_reference_and_move_semantics">Rvalue
+ reference and move semantics</A></LI>
+<LI><A href="#CPlusPlus11_generalized_constant_expressions">Generalized
+ constant expressions</A></LI>
+<LI><A href="#CPlusPlus11_extern_template">Extern template</A></LI>
+<LI><A href="#CPlusPlus11_initializer_lists">Initializer lists</A></LI>
+<LI><A href="#CPlusPlus11_uniform_initialization">Uniform initialization</A>
+</LI>
+<LI><A href="#CPlusPlus11_type_inference">Type inference</A></LI>
+<LI><A href="#CPlusPlus11_range_based_for_loop">Range-based for-loop</A></LI>
+<LI><A href="#CPlusPlus11_lambda_functions_and_expressions">Lambda
+ functions and expressions</A></LI>
+<LI><A href="#CPlusPlus11_alternate_function_syntax">Alternate function
+ syntax</A></LI>
+<LI><A href="#CPlusPlus11_object_construction_improvement">Object
+ construction improvement</A></LI>
+<LI><A href="#CPlusPlus11_explicit_overrides_final">Explicit overrides
+ and final</A></LI>
+<LI><A href="#CPlusPlus11_null_pointer_constant">Null pointer constant</A>
+</LI>
+<LI><A href="#CPlusPlus11_strongly_typed_enumerations">Strongly typed
+ enumerations</A></LI>
+<LI><A href="#CPlusPlus11_double_angle_brackets">Double angle brackets</A>
+</LI>
+<LI><A href="#CPlusPlus11_explicit_conversion_operators">Explicit
+ conversion operators</A></LI>
+<LI><A href="#CPlusPlus11_alias_templates">Alias templates</A></LI>
+<LI><A href="#CPlusPlus11_unrestricted_unions">Unrestricted unions</A></LI>
+<LI><A href="#CPlusPlus11_variadic_templates">Variadic templates</A></LI>
+<LI><A href="#CPlusPlus11_new_string_literals">New string literals</A></LI>
+<LI><A href="#CPlusPlus11_user_defined_literals">User-defined literals</A>
+</LI>
+<LI><A href="#CPlusPlus11_thread_local_storage">Thread-local storage</A></LI>
+<LI><A href="#CPlusPlus11_defaulted_deleted">Explicitly defaulted
+ functions and deleted functions</A></LI>
+<LI><A href="#CPlusPlus11_type_long_long_int">Type long long int</A></LI>
+<LI><A href="#CPlusPlus11_static_assertions">Static assertions</A></LI>
+<LI><A href="#CPlusPlus11_sizeof">Allow sizeof to work on members of
+ classes without an explicit object</A></LI>
+<LI><A href="#CPlusPlus11_noexcept">Exception specifications and
+ noexcept</A></LI>
+<LI><A href="#CPlusPlus11_alignment">Control and query object alignment</A>
+</LI>
+<LI><A href="#CPlusPlus11_attributes">Attributes</A></LI>
+</UL>
+</LI>
+<LI><A href="#CPlusPlus11_standard_library_changes">Standard library
+ changes</A>
+<UL>
+<LI><A href="#CPlusPlus11_threading_facilities">Threading facilities</A></LI>
+<LI><A href="#CPlusPlus11_tuple_types">Tuple types</A></LI>
+<LI><A href="#CPlusPlus11_hash_tables">Hash tables</A></LI>
+<LI><A href="#CPlusPlus11_regular_expressions">Regular expressions</A></LI>
+<LI><A href="#CPlusPlus11_general_purpose_smart_pointers">
+General-purpose smart pointers</A></LI>
+<LI><A href="#CPlusPlus11_extensible_random_number_facility">Extensible
+ random number facility</A></LI>
+<LI><A href="#CPlusPlus11_wrapper_reference">Wrapper reference</A></LI>
+<LI><A href="#CPlusPlus11_polymorphous_wrappers_for_function_objects">
+Polymorphous wrappers for function objects</A></LI>
+<LI><A href="#CPlusPlus11_type_traits_for_metaprogramming">Type traits
+ for metaprogramming</A></LI>
+<LI><A href="#CPlusPlus11_uniform_method_for_computing_return_type_of_function_objects">
+Uniform method for computing return type of function objects</A></LI>
</UL>
</LI>
-<LI><A href="#Preprocessor_typemap_delimiters">Preprocessor and Typemaps</A>
-</LI>
-<LI><A href="#Preprocessor_nn10">Viewing preprocessor output</A></LI>
-<LI><A href="#Preprocessor_warning_error">The #error and #warning
- directives</A></LI>
</UL>
</DIV>
<!-- INDEX -->
-<P> SWIG includes its own enhanced version of the C preprocessor. The
- preprocessor supports the standard preprocessor directives and macro
- expansion rules. However, a number of modifications and enhancements
- have been made. This chapter describes some of these modifications.</P>
-<H2><A name="Preprocessor_nn2"></A>7.1 File inclusion</H2>
-<P> To include another file into a SWIG interface, use the <TT>%include</TT>
- directive like this:</P>
+<H2><A name="CPlusPlus11_introduction">7.1 Introduction</A></H2>
+<P>This chapter gives you a brief overview about the SWIG implementation
+ of the C++11 standard. This part of SWIG is still a work in progress.</P>
+<P>SWIG supports the new C++ syntax changes with some minor limitations
+ in some areas such as decltype expressions and variadic templates.
+ Wrappers for the new STL types (unordered_ containers, result_of,
+ tuples) are incomplete. The wrappers for the new containers would work
+ much like the C++03 containers and users are welcome to help by
+ adapting the existing container interface files and submitting them as
+ a patch for inclusion in future versions of SWIG.</P>
+<H2><A name="CPlusPlus11_core_language_changes">7.2 Core language
+ changes</A></H2>
+<H3><A name="CPlusPlus11_rvalue_reference_and_move_semantics">7.2.1
+ Rvalue reference and move semantics</A></H3>
+<P> SWIG correctly parses the rvalue reference syntax '&&', for example
+ the typical usage of it in the move constructor and move assignment
+ operator below:</P>
<DIV class="code">
<PRE>
-%include "pointer.i"
+class MyClass {
+...
+ std::vector<int> numbers;
+public:
+ MyClass(MyClass &&other) : numbers(std::move(other.numbers)) {}
+ MyClass & operator=(MyClass &&other) {
+ numbers = std::move(other.numbers);
+ return *this;
+ }
+};
</PRE>
</DIV>
-<P> Unlike, <TT>#include</TT>, <TT>%include</TT> includes each file once
- (and will not reload the file on subsequent <TT>%include</TT>
- declarations). Therefore, it is not necessary to use include-guards in
- SWIG interfaces.</P>
-<P> By default, the <TT>#include</TT> is ignored unless you run SWIG
- with the <TT>-includeall</TT> option. The reason for ignoring
- traditional includes is that you often don't want SWIG to try and wrap
- everything included in standard header system headers and auxiliary
- files.</P>
-<H2><A name="Preprocessor_nn3"></A>7.2 File imports</H2>
-<P> SWIG provides another file inclusion directive with the <TT>%import</TT>
- directive. For example:</P>
+<P> Rvalue references are designed for C++ temporaries and so are not
+ very useful when used from non-C++ target languages. Generally you
+ would just ignore them via <TT>%ignore</TT> before parsing the class.
+ For example, ignore the move constructor:</P>
<DIV class="code">
<PRE>
-%import "foo.i"
+%ignore MyClass::MyClass(MyClass &&);
</PRE>
</DIV>
-<P> The purpose of <TT>%import</TT> is to collect certain information
- from another SWIG interface file or a header file without actually
- generating any wrapper code. Such information generally includes type
- declarations (e.g., <TT>typedef</TT>) as well as C++ classes that might
- be used as base-classes for class declarations in the interface. The
- use of <TT>%import</TT> is also important when SWIG is used to generate
- extensions as a collection of related modules. This is an advanced
- topic and is described in later in the <A href="#Modules">Working with
- Modules</A> chapter.</P>
-<P> The <TT>-importall</TT> directive tells SWIG to follow all <TT>
-#include</TT> statements as imports. This might be useful if you want to
- extract type definitions from system header files without generating
- any wrappers.</P>
-<H2><A name="Preprocessor_condition_compilation"></A>7.3 Conditional
- Compilation</H2>
-<P> SWIG fully supports the use of <TT>#if</TT>, <TT>#ifdef</TT>, <TT>
-#ifndef</TT>, <TT>#else</TT>, <TT>#endif</TT> to conditionally include
- parts of an interface. The following symbols are predefined by SWIG
- when it is parsing the interface:</P>
-<DIV class="code">
+<P> The plan is to ignore move constructors by default in a future
+ version of SWIG. Note that both normal assignment operators as well as
+ move assignment operators are ignored by default in most target
+ languages with the following warning:</P>
+<DIV class="shell">
<PRE>
-SWIG Always defined when SWIG is processing a file
-SWIGIMPORTED Defined when SWIG is importing a file with <TT>%import</TT>
-SWIG_VERSION Hexadecimal (binary-coded decimal) number containing SWIG version,
- such as 0x010311 (corresponding to SWIG-1.3.11).
-
-SWIGALLEGROCL Defined when using Allegro CL
-SWIGCFFI Defined when using CFFI
-SWIGCHICKEN Defined when using CHICKEN
-SWIGCLISP Defined when using CLISP
-SWIGCSHARP Defined when using C#
-SWIGGUILE Defined when using Guile
-SWIGJAVA Defined when using Java
-SWIGLUA Defined when using Lua
-SWIGMODULA3 Defined when using Modula-3
-SWIGMZSCHEME Defined when using Mzscheme
-SWIGOCAML Defined when using Ocaml
-SWIGOCTAVE Defined when using Octave
-SWIGPERL Defined when using Perl
-SWIGPHP Defined when using PHP
-SWIGPIKE Defined when using Pike
-SWIGPYTHON Defined when using Python
-SWIGR Defined when using R
-SWIGRUBY Defined when using Ruby
-SWIGSEXP Defined when using S-expressions
-SWIGTCL Defined when using Tcl
-SWIGXML Defined when using XML
+example.i:18: Warning 503: Can't wrap 'operator =' unless renamed to a valid identifier.
</PRE>
</DIV>
-<P> In addition, SWIG defines the following set of standard C/C++
- macros:</P>
+<H3><A name="CPlusPlus11_generalized_constant_expressions">7.2.2
+ Generalized constant expressions</A></H3>
+<P>SWIG parses and identifies the keyword <TT>constexpr</TT>, but cannot
+ fully utilise it. These C++ compile time constants are usable as
+ runtime constants from the target languages. Below shows example usage
+ for assigning a C++ compile time constant from a compile time constant
+ function:</P>
<DIV class="code">
<PRE>
-__LINE__ Current line number
-__FILE__ Current file name
-__STDC__ Defined to indicate ANSI C
-__cplusplus Defined when -c++ option used
+constexpr int XXX() { return 10; }
+constexpr int YYY = XXX() + 100;
</PRE>
</DIV>
-<P> Interface files can look at these symbols as necessary to change the
- way in which an interface is generated or to mix SWIG directives with C
- code. These symbols are also defined within the C code generated by
- SWIG (except for the symbol `<TT>SWIG</TT>' which is only defined
- within the SWIG compiler).</P>
-<H2><A name="Preprocessor_nn5"></A>7.4 Macro Expansion</H2>
-<P> Traditional preprocessor macros can be used in SWIG interfaces. Be
- aware that the <TT>#define</TT> statement is also used to try and
- detect constants. Therefore, if you have something like this in your
- file,</P>
+<P> When either of these is used from a target language, a runtime call
+ is made to obtain the underlying constant.</P>
+<H3><A name="CPlusPlus11_extern_template">7.2.3 Extern template</A></H3>
+<P>SWIG correctly parses the keywords <TT>extern template</TT>. However,
+ this template instantiation suppression in a translation unit has no
+ relevance outside of the C++ compiler and so is not used by SWIG. SWIG
+ only uses <TT>%template</TT> for instantiating and wrapping templates.</P>
<DIV class="code">
<PRE>
-#ifndef _FOO_H 1
-#define _FOO_H 1
-...
-#endif
+template class std::vector<int>; // C++03 explicit instantiation in C++
+extern template class std::vector<int>; // C++11 explicit instantiation suppression in C++
+%template(VectorInt) std::vector<int>; // SWIG instantiation
</PRE>
</DIV>
-<P> you may get some extra constants such as <TT>_FOO_H</TT> showing up
- in the scripting interface.</P>
-<P> More complex macros can be defined in the standard way. For example:</P>
-<DIV class="code">
+<H3><A name="CPlusPlus11_initializer_lists">7.2.4 Initializer lists</A></H3>
+<P> Initializer lists are very much a C++ compiler construct and are not
+ very accessible from wrappers as they are intended for compile time
+ initialization of classes using the special <TT>std::initializer_list</TT>
+ type. SWIG detects usage of initializer lists and will emit a special
+ informative warning each time one is used:</P>
+<DIV class="shell">
<PRE>
-#define EXTERN extern
-#ifdef __STDC__
-#define _ANSI(args) (args)
-#else
-#define _ANSI(args) ()
-#endif
+example.i:33: Warning 476: Initialization using std::initializer_list.
</PRE>
</DIV>
-<P> The following operators can appear in macro definitions:</P>
-<UL>
-<LI><TT>#x</TT>
-<BR> Converts macro argument <TT>x</TT> to a string surrounded by double
- quotes ("x").</LI>
-<LI><TT>x ## y</TT>
-<BR> Concatenates x and y together to form <TT>xy</TT>.</LI>
-<LI><TT>`x`</TT>
-<BR> If <TT>x</TT> is a string surrounded by double quotes, do nothing.
- Otherwise, turn into a string like <TT>#x</TT>. This is a non-standard
- SWIG extension.</LI>
-</UL>
-<H2><A name="Preprocessor_nn6"></A>7.5 SWIG Macros</H2>
-<P> SWIG provides an enhanced macro capability with the <TT>%define</TT>
- and <TT>%enddef</TT> directives. For example:</P>
+<P> Initializer lists usually appear in constructors but can appear in
+ any function or method. They often appear in constructors which are
+ overloaded with alternative approaches to initializing a class, such as
+ the std container's push_back method for adding elements to a
+ container. The recommended approach then is to simply ignore the
+ initializer-list constructor, for example:</P>
<DIV class="code">
<PRE>
-%define ARRAYHELPER(type,name)
-%inline %{
-type *new_ ## name (int nitems) {
- return (type *) malloc(sizeof(type)*nitems);
-}
-void delete_ ## name(type *t) {
- free(t);
-}
-type name ## _get(type *t, int index) {
- return t[index];
-}
-void name ## _set(type *t, int index, type val) {
- t[index] = val;
-}
-%}
-%enddef
-
-ARRAYHELPER(int, IntArray)
-ARRAYHELPER(double, DoubleArray)
+%ignore Container::Container(std::initializer_list<int>);
+class Container {
+public:
+ Container(std::initializer_list<int>); // initializer-list constructor
+ Container();
+ void push_back(const int &);
+ ...
+};
</PRE>
</DIV>
-<P> The primary purpose of <TT>%define</TT> is to define large macros of
- code. Unlike normal C preprocessor macros, it is not necessary to
- terminate each line with a continuation character (\)--the macro
- definition extends to the first occurrence of <TT>%enddef</TT>.
- Furthermore, when such macros are expanded, they are reparsed through
- the C preprocessor. Thus, SWIG macros can contain all other
- preprocessor directives except for nested <TT>%define</TT> statements.</P>
-<P> The SWIG macro capability is a very quick and easy way to generate
- large amounts of code. In fact, many of SWIG's advanced features and
- libraries are built using this mechanism (such as C++ template
- support).</P>
-<H2><A name="Preprocessor_nn7"></A>7.6 C99 and GNU Extensions</H2>
-<P> SWIG-1.3.12 and newer releases support variadic preprocessor macros.
- For example:</P>
+<P>Alternatively you could modify the class and add another constructor
+ for initialization by some other means, for example by a <TT>
+std::vector</TT>:</P>
<DIV class="code">
<PRE>
-#define DEBUGF(fmt,...) fprintf(stderr,fmt,__VA_ARGS__)
+%include <std_vector.i>
+class Container {
+public:
+ Container(const std::vector<int> &);
+ Container(std::initializer_list<int>); // initializer-list constructor
+ Container();
+ void push_back(const int &);
+ ...
+};
</PRE>
</DIV>
-<P> When used, any extra arguments to <TT>...</TT> are placed into the
- special variable <TT>__VA_ARGS__</TT>. This also works with special
- SWIG macros defined using <TT>%define</TT>.</P>
-<P> SWIG allows a variable number of arguments to be empty. However,
- this often results in an extra comma (,) and syntax error in the
- resulting expansion. For example:</P>
-<DIV class="code">
+<P>And then call this constructor from your target language, for
+ example, in Python, the following will call the constructor taking the <TT>
+std::vector</TT>:</P>
+<DIV class="targetlang">
<PRE>
-DEBUGF("hello"); --> fprintf(stderr,"hello",);
+>>> c = Container( [1,2,3,4] )
</PRE>
</DIV>
-<P> To get rid of the extra comma, use <TT>##</TT> like this:</P>
+<P> If you are unable to modify the class being wrapped, consider
+ ignoring the initializer-list constructor and using %extend to add in
+ an alternative constructor:</P>
<DIV class="code">
<PRE>
-#define DEBUGF(fmt,...) fprintf(stderr,fmt, ##__VA_ARGS__)
+%include <std_vector.i>
+%extend Container {
+ Container(const std::vector<int> &elements) {
+ Container *c = new Container();
+ for (int element : elements)
+ c->push_back(element);
+ return c;
+ }
+}
+
+%ignore Container::Container(std::initializer_list<int>);
+
+class Container {
+public:
+ Container(std::initializer_list<int>); // initializer-list constructor
+ Container();
+ void push_back(const int &);
+ ...
+};
</PRE>
</DIV>
-<P> SWIG also supports GNU-style variadic macros. For example:</P>
+<P> The above makes the wrappers look is as if the class had been
+ declared as follows:</P>
<DIV class="code">
<PRE>
-#define DEBUGF(fmt, args...) fprintf(stdout,fmt,args)
+%include <std_vector.i>
+class Container {
+public:
+ Container(const std::vector<int> &);
+// Container(std::initializer_list<int>); // initializer-list constructor (ignored)
+ Container();
+ void push_back(const int &);
+ ...
+};
</PRE>
</DIV>
-<P><B> Comment:</B> It's not entirely clear how variadic macros might be
- useful to interface building. However, they are used internally to
- implement a number of SWIG directives and are provided to make SWIG
- more compatible with C99 code.</P>
-<H2><A name="Preprocessor_delimiters"></A>7.7 Preprocessing and
- delimiters</H2>
-<P> The preprocessor handles { }, " " and %{ %} delimiters differently.</P>
-<H3><A name="Preprocessor_nn8"></A>7.7.1 Preprocessing and %{ ... %} & "
- ... " delimiters</H3>
-<P> The SWIG preprocessor does not process any text enclosed in a code
- block %{ ... %}. Therefore, if you write code like this,</P>
+<P> <TT>std::initializer_list</TT> is simply a container that can only
+ be initialized at compile time. As it is just a C++ type, it is
+ possible to write typemaps for a target language container to map onto <TT>
+std::initializer_list</TT>. However, this can only be done for a fixed
+ number of elements as initializer lists are not designed to be
+ constructed with a variable number of arguments at runtime. The example
+ below is a very simple approach which ignores any parameters passed in
+ and merely initializes with a fixed list of fixed integer values chosen
+ at compile time:</P>
<DIV class="code">
<PRE>
-%{
-#ifdef NEED_BLAH
-int blah() {
- ...
+%typemap(in) std::initializer_list<int> {
+ $1 = {10, 20, 30, 40, 50};
}
-#endif
-%}
+class Container {
+public:
+ Container(std::initializer_list<int>); // initializer-list constructor
+ Container();
+ void push_back(const int &);
+ ...
+};
</PRE>
</DIV>
-<P> the contents of the <TT>%{ ... %}</TT> block are copied without
- modification to the output (including all preprocessor directives).</P>
-<H3><A name="Preprocessor_nn9"></A>7.7.2 Preprocessing and { ... }
- delimiters</H3>
-<P> SWIG always runs the preprocessor on text appearing inside <TT>{ ...
- }</TT>. However, sometimes it is desirable to make a preprocessor
- directive pass through to the output file. For example:</P>
+<P> Any attempt at passing in values from the target language will be
+ ignored and be replaced by <TT>{10, 20, 30, 40, 50}</TT>. Needless to
+ say, this approach is very limited, but could be improved upon, but
+ only slightly. A typemap could be written to map a fixed number of
+ elements on to the <TT>std::initializer_list</TT>, but with values
+ decided at runtime. The typemaps would be target language specific.</P>
+<P> Note that the default typemap for <TT>std::initializer_list</TT>
+ does nothing but issue the warning and hence any user supplied typemaps
+ will override it and suppress the warning.</P>
+<H3><A name="CPlusPlus11_uniform_initialization">7.2.5 Uniform
+ initialization</A></H3>
+<P>The curly brackets {} for member initialization are fully supported
+ by SWIG:</P>
<DIV class="code">
<PRE>
-%extend Foo {
- void bar() {
- #ifdef DEBUG
- printf("I'm in bar\n");
- #endif
- }
-}
+struct BasicStruct {
+ int x;
+ double y;
+};
+
+struct AltStruct {
+ AltStruct(int x, double y) : x_{x}, y_{y} {}
+
+ int x_;
+ double y_;
+};
+
+BasicStruct var1{5, 3.2}; // only fills the struct components
+AltStruct var2{2, 4.3}; // calls the constructor
</PRE>
</DIV>
-<P> By default, SWIG will interpret the <TT>#ifdef DEBUG</TT> statement.
- However, if you really wanted that code to actually go into the wrapper
- file, prefix the preprocessor directives with <TT>%</TT> like this:</P>
-<DIV class="code">
+<P>Uniform initialization does not affect usage from the target
+ language, for example in Python:</P>
+<DIV class="targetlang">
<PRE>
-%extend Foo {
- void bar() {
- %#ifdef DEBUG
- printf("I'm in bar\n");
- %#endif
- }
-}
+>>> a = AltStruct(10, 142.15)
+>>> a.x_
+10
+>>> a.y_
+142.15
</PRE>
</DIV>
-<P> SWIG will strip the extra <TT>%</TT> and leave the preprocessor
- directive in the code.</P>
-<H2><A name="Preprocessor_typemap_delimiters"></A>7.8 Preprocessor and
- Typemaps</H2>
-<P> <A href="#Typemaps">Typemaps</A> support a special attribute called <TT>
-noblock</TT> where the { ... } delimiters can be used, but the
- delimiters are not actually generated into the code. The effect is then
- similar to using "" or %{ %} delimiters but the code<B> is</B> run
- through the preprocessor. For example:</P>
+<H3><A name="CPlusPlus11_type_inference">7.2.6 Type inference</A></H3>
+<P>SWIG supports <TT>decltype()</TT> with some limitations. Single
+ variables are allowed, however, expressions are not supported yet. For
+ example, the following code will work:</P>
<DIV class="code">
<PRE>
-#define SWIG_macro(CAST) (CAST)$input
-%typemap(in) Int {$1= SWIG_macro(int);}
+int i;
+decltype(i) j;
</PRE>
</DIV>
-<P> might generate</P>
+<P>However, using an expression inside the decltype results in syntax
+ error:</P>
<DIV class="code">
<PRE>
- {
- arg1=(int)jarg1;
- }
+int i; int j;
+decltype(i+j) k; // syntax error
</PRE>
</DIV>
-<P> whereas</P>
+<H3><A name="CPlusPlus11_range_based_for_loop">7.2.7 Range-based
+ for-loop</A></H3>
+<P>This feature is part of the implementation block only. SWIG ignores
+ it.</P>
+<H3><A name="CPlusPlus11_lambda_functions_and_expressions">7.2.8 Lambda
+ functions and expressions</A></H3>
+<P>SWIG correctly parses most of the Lambda functions syntax. For
+ example:</P>
<DIV class="code">
<PRE>
-#define SWIG_macro(CAST) (CAST)$input
-%typemap(in,noblock=1) Int {$1= SWIG_macro(int);}
+auto val = [] { return something; };
+auto sum = [](int x, int y) { return x+y; };
+auto sum = [](int x, int y) -> int { return x+y; };
</PRE>
</DIV>
-<P> might generate</P>
+<P>The lambda functions are removed from the wrappers for now, because
+ of the lack of support for closures (scope of the lambda functions) in
+ the target languages.</P>
+<P> Lambda functions used to create variables can also be parsed, but
+ due to limited support of <TT>auto</TT> when the type is deduced from
+ the expression, the variables are simply ignored.</P>
<DIV class="code">
<PRE>
- arg1=(int)jarg1;
+auto six = [](int x, int y) { return x+y; }(4, 2);
</PRE>
</DIV>
-<P> and</P>
+<P> Better support should be available in a later release.</P>
+<H3><A name="CPlusPlus11_alternate_function_syntax">7.2.9 Alternate
+ function syntax</A></H3>
+<P>SWIG fully supports the new definition of functions. For example:</P>
<DIV class="code">
<PRE>
-#define SWIG_macro(CAST) (CAST)$input
-%typemap(in) Int %{$1=SWIG_macro(int);%}
+struct SomeStruct {
+ int FuncName(int x, int y);
+};
</PRE>
</DIV>
-<P> would generate</P>
+<P>can now be written as in C++11:</P>
<DIV class="code">
<PRE>
- arg1=SWIG_macro(int);
+struct SomeStruct {
+ auto FuncName(int x, int y) -> int;
+};
+
+auto SomeStruct::FuncName(int x, int y) -> int {
+ return x + y;
+}
</PRE>
</DIV>
-<H2><A name="Preprocessor_nn10"></A>7.9 Viewing preprocessor output</H2>
-<P> Like many compilers, SWIG supports a <TT>-E</TT> command line option
- to display the output from the preprocessor. When the <TT>-E</TT>
- switch is used, SWIG will not generate any wrappers. Instead the
- results after the preprocessor has run are displayed. This might be
- useful as an aid to debugging and viewing the results of macro
- expansions.</P>
-<H2><A name="Preprocessor_warning_error"></A>7.10 The #error and
- #warning directives</H2>
-<P> SWIG supports the commonly used <TT>#warning</TT> and <TT>#error</TT>
- preprocessor directives. The <TT>#warning</TT> directive will cause
- SWIG to issue a warning then continue processing. The <TT>#error</TT>
- directive will cause SWIG to exit with a fatal error. Example usage:</P>
-<DIV class="code">
+<P>The usage in the target languages remains the same, for example in
+ Python:</P>
+<DIV class="targetlang">
<PRE>
-#error "This is a fatal error message"
-#warning "This is a warning message"
+>>> a = SomeStruct()
+>>> a.FuncName(10,5)
+15
</PRE>
</DIV>
-<P> The <TT>#error</TT> behaviour can be made to work like <TT>#warning</TT>
- if the <TT>-cpperraswarn</TT> commandline option is used.
- Alternatively, the <TT>#pragma</TT> directive can be used to the same
- effect, for example:</P>
+<P>SWIG will also deal with type inference for the return type, as per
+ the limitations described earlier. For example:</P>
<DIV class="code">
<PRE>
- /* Modified behaviour: #error does not cause SWIG to exit with error */
- #pragma SWIG cpperraswarn=1
- /* Normal behaviour: #error does cause SWIG to exit with error */
- #pragma SWIG cpperraswarn=0
+auto square(float a, float b) -> decltype(a);
</PRE>
-</DIV><HR NOSHADE>
-<H1><A name="Library"></A>8 SWIG library</H1>
-
-<!-- INDEX -->
-<DIV class="sectiontoc">
-<UL>
-<LI><A href="#Library_nn2">The %include directive and library search
- path</A></LI>
-<LI><A href="#Library_nn3">C Arrays and Pointers</A>
-<UL>
-<LI><A href="#Library_nn4">cpointer.i</A></LI>
-<LI><A href="#Library_carrays">carrays.i</A></LI>
-<LI><A href="#Library_nn6">cmalloc.i</A></LI>
-<LI><A href="#Library_nn7">cdata.i</A></LI>
-</UL>
-</LI>
-<LI><A href="#Library_nn8">C String Handling</A>
-<UL>
-<LI><A href="#Library_nn9">Default string handling</A></LI>
-<LI><A href="#Library_nn10">Passing binary data</A></LI>
-<LI><A href="#Library_nn11">Using %newobject to release memory</A></LI>
-<LI><A href="#Library_nn12">cstring.i</A></LI>
-</UL>
-</LI>
-<LI><A href="#Library_stl_cpp_library">STL/C++ Library</A>
-<UL>
-<LI><A href="#Library_std_string">std::string</A></LI>
-<LI><A href="#Library_std_vector">std::vector</A></LI>
-<LI><A href="#Library_stl_exceptions">STL exceptions</A></LI>
-<LI><A href="#Library_std_shared_ptr">shared_ptr smart pointer</A></LI>
-</UL>
-</LI>
-<LI><A href="#Library_nn16">Utility Libraries</A>
-<UL>
-<LI><A href="#Library_nn17">exception.i</A></LI>
-</UL>
-</LI>
-</UL>
-</DIV>
-<!-- INDEX -->
-<P> To help build extension modules, SWIG is packaged with a library of
- support files that you can include in your own interfaces. These files
- often define new SWIG directives or provide utility functions that can
- be used to access parts of the standard C and C++ libraries. This
- chapter provides a reference to the current set of supported library
- files.</P>
-<P><B> Compatibility note:</B> Older versions of SWIG included a number
- of library files for manipulating pointers, arrays, and other
- structures. Most these files are now deprecated and have been removed
- from the distribution. Alternative libraries provide similar
- functionality. Please read this chapter carefully if you used the old
- libraries.</P>
-<H2><A name="Library_nn2"></A>8.1 The %include directive and library
- search path</H2>
-<P> Library files are included using the <TT>%include</TT> directive.
- When searching for files, directories are searched in the following
- order:</P>
-<OL>
-<LI>The current directory</LI>
-<LI>Directories specified with the <TT>-I</TT> command line option</LI>
-<LI>.<TT>/swig_lib</TT></LI>
-<LI>SWIG library install location as reported by <TT>swig -swiglib</TT>,
- for example <TT>/usr/local/share/swig/1.3.30</TT></LI>
-<LI>On Windows, a directory <TT>Lib</TT> relative to the location of <TT>
-swig.exe</TT> is also searched.</LI>
-</OL>
-<P> Within directories mentioned in points 3-5, SWIG first looks for a
- subdirectory corresponding to a target language (e.g., <TT>python</TT>,
- <TT>tcl</TT>, etc.). If found, SWIG will search the language specific
- directory first. This allows for language-specific implementations of
- library files.</P>
-<P> You can ignore the installed SWIG library by setting the <TT>
-SWIG_LIB</TT> environment variable. Set the environment variable to hold
- an alternative library directory.</P>
-<P> The directories that are searched are displayed when using <TT>
--verbose</TT> commandline option.</P>
-<H2><A name="Library_nn3"></A>8.2 C Arrays and Pointers</H2>
-<P> This section describes library modules for manipulating low-level C
- arrays and pointers. The primary use of these modules is in supporting
- C declarations that manipulate bare pointers such as <TT>int *</TT>, <TT>
-double *</TT>, or <TT>void *</TT>. The modules can be used to allocate
- memory, manufacture pointers, dereference memory, and wrap pointers as
- class-like objects. Since these functions provide direct access to
- memory, their use is potentially unsafe and you should exercise
- caution.</P>
-<H3><A name="Library_nn4"></A>8.2.1 cpointer.i</H3>
-<P> The <TT>cpointer.i</TT> module defines macros that can be used to
- used to generate wrappers around simple C pointers. The primary use of
- this module is in generating pointers to primitive datatypes such as <TT>
-int</TT> and <TT>double</TT>.</P>
-<P><B> <TT>%pointer_functions(type,name)</TT></B></P>
-<DIV class="indent">
-<P>Generates a collection of four functions for manipulating a pointer <TT>
-type *</TT>:</P>
-<P> <TT>type *new_name()</TT></P>
-<DIV class="indent">
-<P> Creates a new object of type <TT>type</TT> and returns a pointer to
- it. In C, the object is created using <TT>calloc()</TT>. In C++, <TT>
-new</TT> is used.</P>
-</DIV>
-<P> <TT>type *copy_name(type value)</TT></P>
-<DIV class="indent">
-<P> Creates a new object of type <TT>type</TT> and returns a pointer to
- it. An initial value is set by copying it from <TT>value</TT>. In C,
- the object is created using <TT>calloc()</TT>. In C++, <TT>new</TT> is
- used.</P>
-</DIV>
-<P> <TT>type *delete_name(type *obj)</TT></P>
-<DIV class="indent">
-<P> Deletes an object type <TT>type</TT>.</P>
-</DIV>
-<P> <TT>void name_assign(type *obj, type value)</TT></P>
-<DIV class="indent">
-<P> Assigns <TT>*obj = value</TT>.</P>
</DIV>
-<P> <TT>type name_value(type *obj)</TT></P>
-<DIV class="indent">
-<P> Returns the value of <TT>*obj</TT>.</P>
-</DIV>
-<P> When using this macro, <TT>type</TT> may be any type and <TT>name</TT>
- must be a legal identifier in the target language. <TT>name</TT> should
- not correspond to any other name used in the interface file.</P>
-<P> Here is a simple example of using <TT>%pointer_functions()</TT>:</P>
+<H3><A name="CPlusPlus11_object_construction_improvement">7.2.10 Object
+ construction improvement</A></H3>
+<P> There are three parts to object construction improvement. The first
+ improvement is constructor delegation such as the following:</P>
<DIV class="code">
<PRE>
-%module example
-%include "cpointer.i"
+class A {
+public:
+ int a;
+ int b;
+ int c;
-/* Create some functions for working with "int *" */
-%pointer_functions(int, intp);
+ A() : A(10) {}
+ A(int aa) : A(aa, 20) {}
+ A(int aa, int bb) : A(aa, bb, 30) {}
+ A(int aa, int bb, int cc) { a=aa; b=bb; c=cc; }
+};
+</PRE>
+</DIV>
+<P> where peer constructors can be called. SWIG handles this without any
+ issue.</P>
+<P> The second improvement is constructor inheritance via a <TT>using</TT>
+ declaration. This is parsed correctly, but the additional constructors
+ are not currently added to the derived proxy class in the target
+ language. An example is shown below:
+<!--
+The extra constructors provided by the <tt>using</tt> syntax will add the appropriate constructors into the target language proxy derived classes.
+In the example below a wrapper for the <tt>DerivedClass(int)</tt> is added to <tt>DerivedClass</tt>:
+-->
+</P>
+<DIV class="code">
+<PRE>
+class BaseClass {
+public:
+ BaseClass(int iValue);
+};
-/* A function that uses an "int *" */
-void add(int x, int y, int *result);
+class DerivedClass: public BaseClass {
+ public:
+ using BaseClass::BaseClass; // Adds DerivedClass(int) constructor
+};
</PRE>
</DIV>
-<P> Now, in Python:</P>
-<DIV class="targetlang">
+<P> The final part is member initialization at the site of the
+ declaration. This kind of initialization is handled by SWIG.</P>
+<DIV class="code">
<PRE>
->>> import example
->>> c = example.new_intp() # Create an "int" for storing result
->>> example.add(3,4,c) # Call function
->>> example.intp_value(c) # Dereference
-7
->>> example.delete_intp(c) # Delete
+class SomeClass {
+public:
+ SomeClass() {}
+ explicit SomeClass(int new_value) : value(new_value) {}
+
+ int value = 5;
+};
</PRE>
-</DIV></DIV>
-<P><B> <TT>%pointer_class(type,name)</TT></B></P>
-<DIV class="indent">
-<P> Wraps a pointer of <TT>type *</TT> inside a class-based interface.
- This interface is as follows:</P>
+</DIV>
+<H3><A name="CPlusPlus11_explicit_overrides_final">7.2.11 Explicit
+ overrides and final</A></H3>
+<P> The special identifiers <TT>final</TT> and <TT>override</TT> can be
+ used on methods and destructors, such as in the following example:</P>
<DIV class="code">
<PRE>
-struct name {
- name(); // Create pointer object
- ~name(); // Delete pointer object
- void assign(type value); // Assign value
- type value(); // Get value
- type *cast(); // Cast the pointer to original type
- static name *frompointer(type *); // Create class wrapper from existing
- // pointer
+struct BaseStruct {
+ virtual void ab() const = 0;
+ virtual void cd();
+ virtual void ef();
+ virtual ~BaseStruct();
+};
+struct DerivedStruct : BaseStruct {
+ virtual void ab() const override;
+ virtual void cd() final;
+ virtual void ef() final override;
+ virtual ~DerivedStruct() override;
};
</PRE>
</DIV>
-<P> When using this macro, <TT>type</TT> is restricted to a simple type
- name like <TT>int</TT>, <TT>float</TT>, or <TT>Foo</TT>. Pointers and
- other complicated types are not allowed. <TT>name</TT> must be a valid
- identifier not already in use. When a pointer is wrapped as a class,
- the "class" may be transparently passed to any function that expects
- the pointer.</P>
-<P> If the target language does not support proxy classes, the use of
- this macro will produce the example same functions as <TT>
-%pointer_functions()</TT> macro.</P>
-<P> It should be noted that the class interface does introduce a new
- object or wrap a pointer inside a special structure. Instead, the raw
- pointer is used directly.</P>
-<P> Here is the same example using a class instead:</P>
+<H3><A name="CPlusPlus11_null_pointer_constant">7.2.12 Null pointer
+ constant</A></H3>
+<P>The <TT>nullptr</TT> constant is mostly unimportant in wrappers. In
+ the few places it has an effect, it is treated like <TT>NULL</TT>.</P>
+<H3><A name="CPlusPlus11_strongly_typed_enumerations">7.2.13 Strongly
+ typed enumerations</A></H3>
+<P>SWIG supports strongly typed enumerations and parses the new <TT>enum
+ class</TT> syntax and forward declarator for the enums, such as:</P>
<DIV class="code">
<PRE>
-%module example
-%include "cpointer.i"
-
-/* Wrap a class interface around an "int *" */
-%pointer_class(int, intp);
+enum class MyEnum : unsigned int;
+</PRE>
+</DIV>
+<P> Strongly typed enums are often used to avoid name clashes such as
+ the following:</P>
+<DIV class="code">
+<PRE>
+struct Color {
+ enum class RainbowColors : unsigned int {
+ Red, Orange, Yellow, Green, Blue, Indigo, Violet
+ };
+
+ enum class WarmColors {
+ Yellow, Orange, Red
+ };
-/* A function that uses an "int *" */
-void add(int x, int y, int *result);
+ // Note normal enum
+ enum PrimeColors {
+ Red=100, Green, Blue
+ };
+};
</PRE>
</DIV>
-<P> Now, in Python (using proxy classes)</P>
+<P> There are various ways that the target languages handle enums, so it
+ is not possible to precisely state how they are handled in this
+ section. However, generally, most scripting languages mangle in the
+ strongly typed enumeration's class name, but do not use any additional
+ mangling for normal enumerations. For example, in Python, the following
+ code</P>
<DIV class="targetlang">
<PRE>
->>> import example
->>> c = example.intp() # Create an "int" for storing result
->>> example.add(3,4,c) # Call function
->>> c.value() # Dereference
-7
+print Color.RainbowColors_Red, Color.WarmColors_Red, Color.Red
</PRE>
</DIV>
-<P> Of the two macros, <TT>%pointer_class</TT> is probably the most
- convenient when working with simple pointers. This is because the
- pointers are access like objects and they can be easily garbage
- collected (destruction of the pointer object destroys the underlying
- object).</P>
+<P> results in</P>
+<DIV class="shell">
+<PRE>
+0 2 100
+</PRE>
</DIV>
-<P><B> <TT>%pointer_cast(type1, type2, name)</TT></B></P>
-<DIV class="indent">
-<P> Creates a casting function that converts <TT>type1</TT> to <TT>type2</TT>
-. The name of the function is <TT>name</TT>. For example:</P>
-<DIV class="code">
+<P> The strongly typed languages often wrap normal enums into an enum
+ class and so treat normal enums and strongly typed enums the same. The
+ equivalent in Java is:</P>
+<DIV class="targetlang">
<PRE>
-%pointer_cast(int *, unsigned int *, int_to_uint);
+System.out.println(Color.RainbowColors.Red.swigValue() + " " + Color.WarmColors.Red.swigValue() + " " + Color.PrimeColors.Red.swigValue());
</PRE>
</DIV>
-<P> In this example, the function <TT>int_to_uint()</TT> would be used
- to cast types in the target language.</P>
+<H3><A name="CPlusPlus11_double_angle_brackets">7.2.14 Double angle
+ brackets</A></H3>
+<P>SWIG correctly parses the symbols >> as closing the template block,
+ if found inside it at the top level, or as the right shift operator >>
+ otherwise.</P>
+<DIV class="code">
+<PRE>
+std::vector<std::vector<int>> myIntTable;
+</PRE>
</DIV>
-<P><B> Note:</B> None of these macros can be used to safely work with
- strings (<TT>char *</TT> or <TT>char **</TT>).</P>
-<P><B> Note:</B> When working with simple pointers, typemaps can often
- be used to provide more seamless operation.</P>
-<H3><A name="Library_carrays"></A>8.2.2 carrays.i</H3>
-<P> This module defines macros that assist in wrapping ordinary C
- pointers as arrays. The module does not provide any safety or an extra
- layer of wrapping--it merely provides functionality for creating,
- destroying, and modifying the contents of raw C array data.</P>
-<P><B> <TT>%array_functions(type,name)</TT></B></P>
-<DIV class="indent">
-<P>Creates four functions.</P>
-<P> <TT>type *new_name(int nelements)</TT></P>
-<DIV class="indent">
-<P> Creates a new array of objects of type <TT>type</TT>. In C, the
- array is allocated using <TT>calloc()</TT>. In C++, <TT>new []</TT> is
- used.</P>
+<H3><A name="CPlusPlus11_explicit_conversion_operators">7.2.15 Explicit
+ conversion operators</A></H3>
+<P>SWIG correctly parses the keyword <TT>explicit</TT> for operators in
+ addition to constructors now. For example:</P>
+<DIV class="code">
+<PRE>
+class U {
+public:
+ int u;
+};
+
+class V {
+public:
+ int v;
+};
+
+class TestClass {
+public:
+ //implicit converting constructor
+ TestClass(U const &val) { t=val.u; }
+
+ // explicit constructor
+ explicit TestClass(V const &val) { t=val.v; }
+
+ int t;
+};
+
+struct Testable {
+ // explicit conversion operator
+ explicit operator bool() const {
+ return false;
+ }
+};
+</PRE>
</DIV>
-<P> <TT>type *delete_name(type *ary)</TT></P>
-<DIV class="indent">
-<P> Deletes an array. In C, <TT>free()</TT> is used. In C++, <TT>delete
- []</TT> is used.</P>
+<P> The effect of explicit constructors and operators has little
+ relevance for the proxy classes as target languages don't have the same
+ concepts of implicit conversions as C++. Conversion operators either
+ with or without <TT>explicit</TT> need renaming to a valid identifier
+ name in order to make them available as a normal proxy method.</P>
+<H3><A name="CPlusPlus11_alias_templates">7.2.16 Alias templates</A></H3>
+<P> The following is an example of an alias template:<DIV class="code">
+<PRE>
+template< typename T1, typename T2, int >
+class SomeType {
+public:
+ T1 a;
+ T2 b;
+ int c;
+};
+
+template< typename T2 >
+using TypedefName = SomeType<char*, T2, 5>;
+</PRE>
+</DIV></P>
+<P> These are partially supported as SWIG will parse these and identify
+ them, however, they are ignored as they are not added to the type
+ system. A warning such as the following is issued:</P>
+<DIV class="shell">
+<PRE>
+example.i:13: Warning 342: The 'using' keyword in template aliasing is not fully supported yet.
+</PRE>
</DIV>
-<P> <TT>type name_getitem(type *ary, int index)</TT></P>
-<DIV class="indent">
-<P> Returns the value <TT>ary[index]</TT>.</P>
+<P> Similarly for non-template type aliasing:</P>
+<DIV class="code">
+<PRE>
+using PFD = void (*)(double); // New introduced syntax
+</PRE>
</DIV>
-<P> <TT>void name_setitem(type *ary, int index, type value)</TT></P>
-<DIV class="indent">
-<P> Assigns <TT>ary[index] = value</TT>.</P>
+<P> A warning will be issued:</P>
+<DIV class="shell">
+<PRE>
+example.i:17: Warning 341: The 'using' keyword in type aliasing is not fully supported yet.
+</PRE>
</DIV>
-<P> When using this macro, <TT>type</TT> may be any type and <TT>name</TT>
- must be a legal identifier in the target language. <TT>name</TT> should
- not correspond to any other name used in the interface file.</P>
-<P> Here is an example of <TT>%array_functions()</TT>. Suppose you had a
- function like this:</P>
+<P>The equivalent old style typedefs can be used as a workaround:</P>
<DIV class="code">
<PRE>
-void print_array(double x[10]) {
- int i;
- for (i = 0; i < 10; i++) {
- printf("[%d] = %g\n", i, x[i]);
- }
-}
+typedef void (*PFD)(double); // The old style
</PRE>
</DIV>
-<P> To wrap it, you might write this:</P>
+<H3><A name="CPlusPlus11_unrestricted_unions">7.2.17 Unrestricted unions</A>
+</H3>
+<P>SWIG fully supports any type inside a union even if it does not
+ define a trivial constructor. For example, the wrapper for the
+ following code correctly provides access to all members in the union:</P>
<DIV class="code">
<PRE>
-%module example
-
-%include "carrays.i"
-%array_functions(double, doubleArray);
+struct point {
+ point() {}
+ point(int x, int y) : x_(x), y_(y) {}
+ int x_, y_;
+};
-void print_array(double x[10]);
+#include <new> // For placement 'new' in the constructor below
+union P {
+ int z;
+ double w;
+ point p; // Illegal in C++03; legal in C++11.
+ // Due to the point member, a constructor definition is required.
+ P() {
+ new(&p) point();
+ }
+} p1;
</PRE>
</DIV>
-<P> Now, in a scripting language, you might write this:</P>
+<H3><A name="CPlusPlus11_variadic_templates">7.2.18 Variadic templates</A>
+</H3>
+<P>SWIG supports the variadic templates syntax (inside the <> block,
+ variadic class inheritance and variadic constructor and initializers)
+ with some limitations. The following code is correctly parsed:</P>
<DIV class="code">
<PRE>
-a = new_doubleArray(10) # Create an array
-for i in range(0,10):
- doubleArray_setitem(a,i,2*i) # Set a value
-print_array(a) # Pass to C
-delete_doubleArray(a) # Destroy array
+template <typename... BaseClasses> class ClassName : public BaseClasses... {
+public:
+ ClassName (BaseClasses &&... baseClasses) : BaseClasses(baseClasses)... {}
+}
</PRE>
-</DIV></DIV>
-<P><B> <TT>%array_class(type,name)</TT></B></P>
-<DIV class="indent">
-<P> Wraps a pointer of <TT>type *</TT> inside a class-based interface.
- This interface is as follows:</P>
+</DIV>
+<P> For now however, the <TT>%template</TT> directive only accepts one
+ parameter substitution for the variable template parameters.</P>
<DIV class="code">
<PRE>
-struct name {
- name(int nelements); // Create an array
- ~name(); // Delete array
- type getitem(int index); // Return item
- void setitem(int index, type value); // Set item
- type *cast(); // Cast to original type
- static name *frompointer(type *); // Create class wrapper from
- // existing pointer
-};
+%template(MyVariant1) ClassName<> // zero argument not supported yet
+%template(MyVariant2) ClassName<int> // ok
+%template(MyVariant3) ClassName<int, int> // too many arguments not supported yet
</PRE>
</DIV>
-<P> When using this macro, <TT>type</TT> is restricted to a simple type
- name like <TT>int</TT> or <TT>float</TT>. Pointers and other
- complicated types are not allowed. <TT>name</TT> must be a valid
- identifier not already in use. When a pointer is wrapped as a class, it
- can be transparently passed to any function that expects the pointer.</P>
-<P> When combined with proxy classes, the <TT>%array_class()</TT> macro
- can be especially useful. For example:</P>
+<P>Support for the variadic <TT>sizeof()</TT> function is correctly
+ parsed:</P>
<DIV class="code">
<PRE>
-%module example
-%include "carrays.i"
-%array_class(double, doubleArray);
-
-void print_array(double x[10]);
+const int SIZE = sizeof...(ClassName<int, int>);
</PRE>
</DIV>
-<P> Allows you to do this:</P>
+<P> In the above example <TT>SIZE</TT> is of course wrapped as a
+ constant.</P>
+<H3><A name="CPlusPlus11_new_string_literals">7.2.19 New string literals</A>
+</H3>
+<P>SWIG supports wide string and Unicode string constants and raw string
+ literals.</P>
<DIV class="code">
<PRE>
-import example
-c = example.doubleArray(10) # Create double[10]
-for i in range(0,10):
- c[i] = 2*i # Assign values
-example.print_array(c) # Pass to C
+// New string literals
+wstring aa = L"Wide string";
+const char *bb = u8"UTF-8 string";
+const char16_t *cc = u"UTF-16 string";
+const char32_t *dd = U"UTF-32 string";
+
+// Raw string literals
+const char *xx = ")I'm an \"ascii\" \\ string.";
+const char *ee = R"XXX()I'm an "ascii" \ string.)XXX"; // same as xx
+wstring ff = LR"XXX(I'm a "raw wide" \ string.)XXX";
+const char *gg = u8R"XXX(I'm a "raw UTF-8" \ string.)XXX";
+const char16_t *hh = uR"XXX(I'm a "raw UTF-16" \ string.)XXX";
+const char32_t *ii = UR"XXX(I'm a "raw UTF-32" \ string.)XXX";
</PRE>
-</DIV></DIV>
-<P><B> Note:</B> These macros do not encapsulate C arrays inside a
- special data structure or proxy. There is no bounds checking or safety
- of any kind. If you want this, you should consider using a special
- array object rather than a bare pointer.</P>
-<P><B> Note:</B> <TT>%array_functions()</TT> and <TT>%array_class()</TT>
- should not be used with types of <TT>char</TT> or <TT>char *</TT>.</P>
-<H3><A name="Library_nn6"></A>8.2.3 cmalloc.i</H3>
-<P> This module defines macros for wrapping the low-level C memory
- allocation functions <TT>malloc()</TT>, <TT>calloc()</TT>, <TT>
-realloc()</TT>, and <TT>free()</TT>.</P>
-<P><B> <TT>%malloc(type [,name=type])</TT></B></P>
-<DIV class="indent">
-<P> Creates a wrapper around <TT>malloc()</TT> with the following
- prototype:</P>
+</DIV>
+<P> Non-ASCII string support varies quite a bit among the various target
+ languages though.</P>
+<P> Note: There is a bug currently where SWIG's preprocessor incorrectly
+ parses an odd number of double quotes inside raw string literals.</P>
+<H3><A name="CPlusPlus11_user_defined_literals">7.2.20 User-defined
+ literals</A></H3>
+<P> SWIG parses the declaration of user-defined literals, that is, the <TT>
+operator "" _mysuffix()</TT> function syntax.</P>
+<P> Some examples are the raw literal:</P>
<DIV class="code">
<PRE>
-<EM>type</EM> *malloc_<EM>name</EM>(int nbytes = sizeof(<EM>type</EM>));
+OutputType operator "" _myRawLiteral(const char * value);
</PRE>
</DIV>
-<P> If <TT>type</TT> is <TT>void</TT>, then the size parameter <TT>
-nbytes</TT> is required. The <TT>name</TT> parameter only needs to be
- specified when wrapping a type that is not a valid identifier (e.g., "<TT>
-int *</TT>", "<TT>double **</TT>", etc.).</P>
+<P> numeric cooked literals:</P>
+<DIV class="code">
+<PRE>
+OutputType operator "" _mySuffixIntegral(unsigned long long);
+OutputType operator "" _mySuffixFloat(long double);
+</PRE>
</DIV>
-<P><B> <TT>%calloc(type [,name=type])</TT></B></P>
-<DIV class="indent">
-<P> Creates a wrapper around <TT>calloc()</TT> with the following
- prototype:</P>
+<P> and cooked string literals:</P>
<DIV class="code">
<PRE>
-<EM>type</EM> *calloc_<EM>name</EM>(int nobj =1, int sz = sizeof(<EM>type</EM>));
+OutputType operator "" _mySuffix(const char * string_values, size_t num_chars);
+OutputType operator "" _mySuffix(const wchar_t * string_values, size_t num_chars);
+OutputType operator "" _mySuffix(const char16_t * string_values, size_t num_chars);
+OutputType operator "" _mySuffix(const char32_t * string_values, size_t num_chars);
</PRE>
</DIV>
-<P> If <TT>type</TT> is <TT>void</TT>, then the size parameter <TT>sz</TT>
- is required.</P>
+<P> Like other operators that SWIG parses, a warning is given about
+ renaming the operator in order for it to be wrapped:</P>
+<DIV class="shell">
+<PRE>
+example.i:27: Warning 503: Can't wrap 'operator "" _myRawLiteral' unless renamed to a valid identifier.
+</PRE>
</DIV>
-<P><B> <TT>%realloc(type [,name=type])</TT></B></P>
-<DIV class="indent">
-<P> Creates a wrapper around <TT>realloc()</TT> with the following
- prototype:</P>
+<P> If %rename is used, then it can be called like any other wrapped
+ method. Currently you need to specify the full declaration including
+ parameters for %rename:</P>
<DIV class="code">
<PRE>
-<EM>type</EM> *realloc_<EM>name</EM>(<EM>type</EM> *ptr, int nitems);
+%rename(MyRawLiteral) operator"" _myRawLiteral(const char * value);
</PRE>
</DIV>
-<P> Note: unlike the C <TT>realloc()</TT>, the wrapper generated by this
- macro implicitly includes the size of the corresponding type. For
- example, <TT>realloc_int(p, 100)</TT> reallocates <TT>p</TT> so that it
- holds 100 integers.</P>
-</DIV>
-<P><B> <TT>%free(type [,name=type])</TT></B></P>
-<DIV class="indent">
-<P> Creates a wrapper around <TT>free()</TT> with the following
- prototype:</P>
+<P> Or if you just wish to ignore it altogether:</P>
<DIV class="code">
<PRE>
-void free_<EM>name</EM>(<EM>type</EM> *ptr);
+%ignore operator "" _myRawLiteral(const char * value);
</PRE>
-</DIV></DIV>
-<P><B> <TT>%sizeof(type [,name=type])</TT></B></P>
-<DIV class="indent">
-<P> Creates the constant:</P>
+</DIV>
+<P> Note that use of user-defined literals such as the following still
+ give a syntax error:</P>
<DIV class="code">
<PRE>
-%constant int sizeof_<EM>name</EM> = sizeof(<EM>type</EM>);
+OutputType var1 = "1234"_suffix;
+OutputType var2 = 1234_suffix;
+OutputType var3 = 3.1416_suffix;
</PRE>
-</DIV></DIV>
-<P><B> <TT>%allocators(type [,name=type])</TT></B></P>
-<DIV class="indent">
-<P> Generates wrappers for all five of the above operations.</P>
</DIV>
-<P> Here is a simple example that illustrates the use of these macros:</P>
+<H3><A name="CPlusPlus11_thread_local_storage">7.2.21 Thread-local
+ storage</A></H3>
+<P>SWIG correctly parses the <TT>thread_local</TT> keyword. For example,
+ variables reachable by the current thread can be defined as:</P>
<DIV class="code">
<PRE>
-// SWIG interface
-%module example
-%include "cmalloc.i"
-
-%malloc(int);
-%free(int);
-
-%malloc(int *, intp);
-%free(int *, intp);
-
-%allocators(double);
+struct A {
+ static thread_local int val;
+};
+thread_local int global_val;
</PRE>
</DIV>
-<P> Now, in a script:</P>
-<DIV class="targetlang">
+<P> The use of the <TT>thread_local</TT> storage specifier does not
+ affect the wrapping process; it does not modify the wrapper code
+ compared to when it is not specified. A variable will be thread local
+ if accessed from different threads from the target language in the same
+ way that it will be thread local if accessed from C++ code.</P>
+<H3><A name="CPlusPlus11_defaulted_deleted">7.2.22 Explicitly defaulted
+ functions and deleted functions</A></H3>
+<P>SWIG handles explicitly defaulted functions, that is, <TT>= default</TT>
+ added to a function declaration. Deleted definitions, which are also
+ called deleted functions, have <TT>= delete</TT> added to the function
+ declaration. For example:</P>
+<DIV class="code">
<PRE>
->>> from example import *
->>> a = malloc_int()
->>> a
-'_000efa70_p_int'
->>> free_int(a)
->>> b = malloc_intp()
->>> b
-'_000efb20_p_p_int'
->>> free_intp(b)
->>> c = calloc_double(50)
->>> c
-'_000fab98_p_double'
->>> c = realloc_double(100000)
->>> free_double(c)
->>> print sizeof_double
-8
->>>
+struct NonCopyable {
+ NonCopyable & operator=(const NonCopyable &) = delete; /* Removes operator= */
+ NonCopyable(const NonCopyable &) = delete; /* Removes copy constructor */
+ NonCopyable() = default; /* Explicitly allows the empty constructor */
+};
</PRE>
</DIV>
-<H3><A name="Library_nn7"></A>8.2.4 cdata.i</H3>
-<P> The <TT>cdata.i</TT> module defines functions for converting raw C
- data to and from strings in the target language. The primary
- applications of this module would be packing/unpacking of binary data
- structures---for instance, if you needed to extract data from a buffer.
- The target language must support strings with embedded binary data in
- order for this to work.</P>
-<P><B> <TT>const char *cdata(void *ptr, size_t nbytes)</TT></B></P>
-<DIV class="indent">
-<P> Converts <TT>nbytes</TT> of data at <TT>ptr</TT> into a string. <TT>
-ptr</TT> can be any pointer.</P>
+<P> Wrappers for deleted functions will not be available in the target
+ language. Wrappers for defaulted functions will of course be available
+ in the target language. Explicitly defaulted functions have no direct
+ effect for SWIG wrapping as the declaration is handled much like any
+ other method declaration parsed by SWIG.</P>
+<P> Deleted functions are also designed to prevent implicit conversions
+ when calling the function. For example, the C++ compiler will not
+ compile any code which attempts to use an int as the type of the
+ parameter passed to <TT>f</TT> below:</P>
+<DIV class="code">
+<PRE>
+struct NoInt {
+ void f(double i);
+ void f(int) = delete;
+};
+</PRE>
</DIV>
-<P><B> <TT>void memmove(void *ptr, const char *s)</TT></B></P>
-<DIV class="indent">
-<P> Copies all of the string data in <TT>s</TT> into the memory pointed
- to by <TT>ptr</TT>. The string may contain embedded NULL bytes. This is
- actually a wrapper to the standard C library <TT>memmove</TT> function,
- which is declared as<B> <TT>void memmove(void *ptr, const void *src,
- size_t n)</TT></B>. The <TT>src</TT> and length <TT>n</TT> parameters
- are extracted from the language specific string <TT>s</TT> in the
- underlying wrapper code.</P>
+<P> This is a C++ compile time check and SWIG does not make any attempt
+ to detect if the target language is using an int instead of a double
+ though, so in this case it is entirely possible to pass an int instead
+ of a double to <TT>f</TT> from Java, Python etc.</P>
+<H3><A name="CPlusPlus11_type_long_long_int">7.2.23 Type long long int</A>
+</H3>
+<P>SWIG correctly parses and uses the new <TT>long long</TT> type
+ already introduced in C99 some time ago.</P>
+<H3><A name="CPlusPlus11_static_assertions">7.2.24 Static assertions</A></H3>
+<P> SWIG correctly parses the new <TT>static_assert</TT> declarations.
+ This is a C++ compile time directive so there isn't anything useful
+ that SWIG can do with it.</P>
+<DIV class="code">
+<PRE>
+template <typename T>
+struct Check {
+ static_assert(sizeof(int) <= sizeof(T), "not big enough");
+};
+</PRE>
</DIV>
-<P> One use of these functions is packing and unpacking data from
- memory. Here is a short example:</P>
+<H3><A name="CPlusPlus11_sizeof">7.2.25 Allow sizeof to work on members
+ of classes without an explicit object</A></H3>
+<P> SWIG can parse the new sizeof() on types as well as on objects. For
+ example:</P>
<DIV class="code">
<PRE>
-// SWIG interface
-%module example
-%include "carrays.i"
-%include "cdata.i"
+struct A {
+ int member;
+};
-%array_class(int, intArray);
+const int SIZE = sizeof(A::member); // does not work with C++03. Okay with C++11
</PRE>
</DIV>
-<P> Python example:</P>
+<P>In Python:</P>
<DIV class="targetlang">
<PRE>
->>> a = intArray(10)
->>> for i in range(0,10):
-... a[i] = i
->>> b = cdata(a,40)
->>> b
-'\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04
-\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\t'
->>> c = intArray(10)
->>> memmove(c,b)
->>> print c[4]
-4
->>>
+>>> SIZE
+8
</PRE>
</DIV>
-<P> Since the size of data is not always known, the following macro is
- also defined:</P>
-<P><B> <TT>%cdata(type [,name=type])</TT></B></P>
-<DIV class="indent">
-<P> Generates the following function for extracting C data for a given
- type.</P>
+<H3><A name="CPlusPlus11_noexcept">7.2.26 Exception specifications and
+ noexcept</A></H3>
+<P> C++11 added in the noexcept specification to exception
+ specifications to indicate that a function simply may or may not throw
+ an exception, without actually naming any exception. SWIG understands
+ these, although there isn't any useful way that this information can be
+ taken advantage of by target languages, so it is as good as ignored
+ during the wrapping process. Below are some examples of noexcept in
+ function declarations:</P>
<DIV class="code">
<PRE>
-char *cdata_<EM>name</EM>(type* ptr, int nitems)
+static void noex1() noexcept;
+int noex2(int) noexcept(true);
+int noex3(int, bool) noexcept(false);
</PRE>
</DIV>
-<P> <TT>nitems</TT> is the number of items of the given type to extract.</P>
-</DIV>
-<P><B> Note:</B> These functions provide direct access to memory and can
- be used to overwrite data. Clearly they are unsafe.</P>
-<H2><A name="Library_nn8"></A>8.3 C String Handling</H2>
-<P> A common problem when working with C programs is dealing with
- functions that manipulate raw character data using <TT>char *</TT>. In
- part, problems arise because there are different interpretations of <TT>
-char *</TT>---it could be a NULL-terminated string or it could point to
- binary data. Moreover, functions that manipulate raw strings may mutate
- data, perform implicit memory allocations, or utilize fixed-sized
- buffers.</P>
-<P> The problems (and perils) of using <TT>char *</TT> are well-known.
- However, SWIG is not in the business of enforcing morality. The modules
- in this section provide basic functionality for manipulating raw C
- strings.</P>
-<H3><A name="Library_nn9"></A>8.3.1 Default string handling</H3>
-<P> Suppose you have a C function with this prototype:</P>
-<DIV class="code">
+<H3><A name="CPlusPlus11_alignment">7.2.27 Control and query object
+ alignment</A></H3>
+<P> An <TT>alignof</TT> operator is used mostly within C++ to return
+ alignment in number of bytes, but could be used to initialize a
+ variable as shown below. The variable's value will be available for
+ access by the target language as any other variable's compile time
+ initialised value.<DIV class="code">
<PRE>
-char *foo(char *s);
+const int align1 = alignof(A::member);
+</PRE>
+</DIV></P>
+<P> The <TT>alignas</TT> specifier for variable alignment is not yet
+ supported. Example usage:</P>
+<DIV class="code">
+<PRE>
+struct alignas(16) S {
+ int num;
+};
+alignas(double) unsigned char c[sizeof(double)];
+</PRE>
+</DIV>
+<P> Use the preprocessor to work around this for now:</P>
+<DIV class="code">
+<PRE>
+#define alignas(T)
+</PRE>
+</DIV>
+<H3><A name="CPlusPlus11_attributes">7.2.28 Attributes</A></H3>
+<P> Attributes such as those shown below, are not yet supported and will
+ give a syntax error.</P>
+<DIV class="code">
+<PRE>
+int [[attr1]] i [[attr2, attr3]];
+
+[[noreturn, nothrow]] void f [[noreturn]] ();
+</PRE>
+</DIV>
+<H2><A name="CPlusPlus11_standard_library_changes">7.3 Standard library
+ changes</A></H2>
+<H3><A name="CPlusPlus11_threading_facilities">7.3.1 Threading
+ facilities</A></H3>
+<P>SWIG does not currently wrap or use any of the new threading classes
+ introduced (thread, mutex, locks, condition variables, task). The main
+ reason is that SWIG target languages offer their own threading
+ facilities so there is limited use for them.</P>
+<H3><A name="CPlusPlus11_tuple_types">7.3.2 Tuple types</A></H3>
+<P> SWIG does not provide library files for the new tuple types yet.
+ Variadic template support requires further work to provide substantial
+ tuple wrappers.</P>
+<H3><A name="CPlusPlus11_hash_tables">7.3.3 Hash tables</A></H3>
+<P> The new hash tables in the STL are <TT>unordered_set</TT>, <TT>
+unordered_multiset</TT>, <TT>unordered_map</TT>, <TT>unordered_multimap</TT>
+. These are not available in SWIG, but in principle should be easily
+ implemented by adapting the current STL containers.</P>
+<H3><A name="CPlusPlus11_regular_expressions">7.3.4 Regular expressions</A>
+</H3>
+<P> While SWIG could provide wrappers for the new C++11 regular
+ expressions classes, there is little need as the target languages have
+ their own regular expression facilities.</P>
+<H3><A name="CPlusPlus11_general_purpose_smart_pointers">7.3.5
+ General-purpose smart pointers</A></H3>
+<P> SWIG provides special smart pointer handling for <TT>std::shared_ptr</TT>
+ in the same way it has support for <TT>boost::shared_ptr</TT>. Please
+ see the <A href="#Library_std_shared_ptr">shared_ptr smart pointer</A>
+ library section. There is no special smart pointer handling available
+ for <TT>std::weak_ptr</TT> and <TT>std::unique_ptr</TT> yet.</P>
+<H3><A name="CPlusPlus11_extensible_random_number_facility">7.3.6
+ Extensible random number facility</A></H3>
+<P>This feature extends and standardizes the standard library only and
+ does not effect the C++ language nor SWIG.</P>
+<H3><A name="CPlusPlus11_wrapper_reference">7.3.7 Wrapper reference</A></H3>
+<P> Wrapper references are similar to normal C++ references but are
+ copy-constructible and copy-assignable. They could conceivably be used
+ in public APIs. There is no special support for <TT>
+std::reference_wrapper</TT> in SWIG though. Users would need to write
+ their own typemaps if wrapper references are being used and these would
+ be similar to the plain C++ reference typemaps.</P>
+<H3><A name="CPlusPlus11_polymorphous_wrappers_for_function_objects">
+7.3.8 Polymorphous wrappers for function objects</A></H3>
+<P> SWIG supports functor classes in a few languages in a very natural
+ way. However nothing is provided yet for the new <TT>std::function</TT>
+ template. SWIG will parse usage of the template like any other
+ template.</P>
+<DIV class="code">
+<PRE>
+%rename(__call__) Test::operator(); // Default renaming used for Python
+
+struct Test {
+ bool operator()(int x, int y); // function object
+};
+
+#include <functional>
+std::function<void (int, int)> pF = Test; // function template wrapper
+
</PRE>
</DIV>
-<P> The default wrapping behavior for this function is to set <TT>s</TT>
- to a raw <TT>char *</TT> that refers to the internal string data in the
- target language. In other words, if you were using a language like Tcl,
- and you wrote this,</P>
-<DIV class="code">
+<P> Example of supported usage of the plain functor from Python is shown
+ below. It does not involve <TT>std::function</TT>.</P>
+<DIV class="targetlang">
<PRE>
-% foo Hello
+t = Test()
+b = t(1,2) # invoke C++ function object
</PRE>
</DIV>
-<P> then <TT>s</TT> would point to the representation of "Hello" inside
- the Tcl interpreter. When returning a <TT>char *</TT>, SWIG assumes
- that it is a NULL-terminated string and makes a copy of it. This gives
- the target language its own copy of the result.</P>
-<P> There are obvious problems with the default behavior. First, since a
- <TT>char *</TT> argument points to data inside the target language, it
- is<B> NOT</B> safe for a function to modify this data (doing so may
- corrupt the interpreter and lead to a crash). Furthermore, the default
- behavior does not work well with binary data. Instead, strings are
- assumed to be NULL-terminated.</P>
-<H3><A name="Library_nn10"></A>8.3.2 Passing binary data</H3>
-<P> If you have a function that expects binary data,</P>
+<H3><A name="CPlusPlus11_type_traits_for_metaprogramming">7.3.9 Type
+ traits for metaprogramming</A></H3>
+<P>The type_traits functions to support C++ metaprogramming is useful at
+ compile time and is aimed specifically at C++ development:</P>
<DIV class="code">
<PRE>
-size_t parity(char *str, size_t len, size_t initial);
+#include <type_traits>
+
+// First way of operating.
+template< bool B > struct algorithm {
+ template< class T1, class T2 > static int do_it(T1 &, T2 &) { /*...*/ return 1; }
+};
+
+// Second way of operating.
+template<> struct algorithm<true> {
+ template< class T1, class T2 > static int do_it(T1, T2) { /*...*/ return 2; }
+};
+
+// Instantiating 'elaborate' will automatically instantiate the correct way to operate, depending on the types used.
+template< class T1, class T2 > int elaborate(T1 A, T2 B) {
+ // Use the second way only if 'T1' is an integer and if 'T2' is a floating point,
+ // otherwise use the first way.
+ return algorithm< std::is_integral<T1>::value && std::is_floating_point<T2>::value >::do_it(A, B);
+}
</PRE>
</DIV>
-<P> you can wrap the parameters <TT>(char *str, size_t len)</TT> as a
- single argument using a typemap. Just do this:</P>
+<P> SWIG correctly parses the template specialization, template types
+ etc. However, metaprogramming and the additional support in the
+ type_traits header is really for compile time and is not much use at
+ runtime for the target languages. For example, as SWIG requires
+ explicit instantiation of templates via <TT>%template</TT>, there isn't
+ much that <TT>std::is_integral<int></TT> is going to provide by itself.
+ However, template functions using such metaprogramming techniques might
+ be useful to wrap. For example, the following instantiations could be
+ made:</P>
<DIV class="code">
<PRE>
-%apply (char *STRING, size_t LENGTH) { (char *str, size_t len) };
-...
-size_t parity(char *str, size_t len, size_t initial);
+%template(Elaborate) elaborate<int, int>;
+%template(Elaborate) elaborate<int, double>;
</PRE>
</DIV>
-<P> Now, in the target language, you can use binary string data like
- this:</P>
-<DIV class="code">
+<P> Then the appropriate algorithm can be called for the subset of types
+ given by the above <TT>%template</TT> instantiations from a target
+ language, such as Python:</P>
+<DIV class="targetlang">
<PRE>
->>> s = "H\x00\x15eg\x09\x20"
->>> parity(s,0)
+>>> Elaborate(0, 0)
+1
+>>> Elaborate(0, 0.0)
+2
</PRE>
</DIV>
-<P> In the wrapper function, the passed string will be expanded to a
- pointer and length parameter. The <TT>(char *STRING, int LENGTH)</TT>
- multi-argument typemap is also available in addition to <TT>(char
- *STRING, size_t LENGTH)</TT>.</P>
-<H3><A name="Library_nn11"></A>8.3.3 Using %newobject to release memory</H3>
-<P> If you have a function that allocates memory like this,</P>
+<H3><A name="CPlusPlus11_uniform_method_for_computing_return_type_of_function_objects">
+7.3.10 Uniform method for computing return type of function objects</A></H3>
+<P> The new <TT>std::result_of</TT> class introduced in the <functional>
+ header provides a generic way to obtain the return type of a function
+ type via <TT>std::result_of::type</TT>. There isn't any library
+ interface file to support this type. With a bit of work, SWIG will
+ deduce the return type of functions when used in <TT>std::result_of</TT>
+ using the approach shown below. The technique basically forward
+ declares the <TT>std::result_of</TT> template class, then partially
+ specializes it for the function types of interest. SWIG will use the
+ partial specialization and hence correctly use the <TT>
+std::result_of::type</TT> provided in the partial specialization.</P>
<DIV class="code">
<PRE>
-char *foo() {
- char *result = (char *) malloc(...);
- ...
- return result;
+%inline %{
+#include <functional>
+typedef double(*fn_ptr)(double);
+%}
+
+namespace std {
+ // Forward declaration of result_of
+ template<typename Func> struct result_of;
+ // Add in a partial specialization of result_of
+ template<> struct result_of< fn_ptr(double) > {
+ typedef double type;
+ };
+}
+
+%template() std::result_of< fn_ptr(double) >;
+
+%inline %{
+
+double square(double x) {
+ return (x * x);
+}
+
+template<class Fun, class Arg>
+typename std::result_of<Fun(Arg)>::type test_result_impl(Fun fun, Arg arg) {
+ return fun(arg);
}
+%}
+
+%template(test_result) test_result_impl< fn_ptr, double >;
+%constant double (*SQUARE)(double) = square;
</PRE>
</DIV>
-<P> then the SWIG generated wrappers will have a memory leak--the
- returned data will be copied into a string object and the old contents
- ignored.</P>
-<P> To fix the memory leak, use the <TT>%newobject</TT> directive.</P>
-<DIV class="code">
+<P> Note the first use of <TT>%template</TT> which SWIG requires to
+ instantiate the template. The empty template instantiation suffices as
+ no proxy class is required for <TT>std::result_of<Fun(Arg)>::type</TT>
+ as this type is really just a <TT>double</TT>. The second <TT>%template</TT>
+ instantiates the template function which is being wrapped for use as a
+ callback. The <TT>%constant</TT> can then be used for any callback
+ function as described in <A href="#SWIG_nn30">Pointers to functions and
+ callbacks</A>.</P>
+<P> Example usage from Python should give the not too surprising result:</P>
+<DIV class="targetlang">
<PRE>
-%newobject foo;
-...
-char *foo();
+>>> test_result(SQUARE, 5.0)
+25.0
</PRE>
</DIV>
-<P> This will release the result if the appropriate target language
- support is available. SWIG provides the appropriate "newfree" typemap
- for <TT>char *</TT> so that the memory is released, however, you may
- need to provide your own "newfree" typemap for other types. See <A href="#Customization_ownership">
-Object ownership and %newobject</A> for more details.</P>
-<H3><A name="Library_nn12"></A>8.3.4 cstring.i</H3>
-<P> The <TT>cstring.i</TT> library file provides a collection of macros
- for dealing with functions that either mutate string arguments or which
- try to output string data through their arguments. An example of such a
- function might be this rather questionable implementation:</P>
-<DIV class="code">
-<PRE>
-void get_path(char *s) {
- // Potential buffer overflow---uh, oh.
- sprintf(s,"%s/%s", base_directory, sub_directory);
-}
-...
-// Somewhere else in the C program
-{
- char path[1024];
- ...
- get_path(path);
- ...
-}
-</PRE>
+<P> Phew, that is a lot of hard work to get a callback working. You
+ could just go with the more attractive option of just using <TT>double</TT>
+ as the return type in the function declaration instead of <TT>result_of</TT>
+!</P>
+<HR NOSHADE>
+<H1><A name="Preprocessor">8 Preprocessing</A></H1>
+
+<!-- INDEX -->
+<DIV class="sectiontoc">
+<UL>
+<LI><A href="#Preprocessor_nn2">File inclusion</A></LI>
+<LI><A href="#Preprocessor_nn3">File imports</A></LI>
+<LI><A href="#Preprocessor_condition_compilation">Conditional
+ Compilation</A></LI>
+<LI><A href="#Preprocessor_nn5">Macro Expansion</A></LI>
+<LI><A href="#Preprocessor_nn6">SWIG Macros</A></LI>
+<LI><A href="#Preprocessor_nn7">C99 and GNU Extensions</A></LI>
+<LI><A href="#Preprocessor_delimiters">Preprocessing and delimiters</A>
+<UL>
+<LI><A href="#Preprocessor_nn8">Preprocessing and %{ ... %} & " ... "
+ delimiters</A></LI>
+<LI><A href="#Preprocessor_nn9">Preprocessing and { ... } delimiters</A></LI>
+</UL>
+</LI>
+<LI><A href="#Preprocessor_typemap_delimiters">Preprocessor and Typemaps</A>
+</LI>
+<LI><A href="#Preprocessor_nn10">Viewing preprocessor output</A></LI>
+<LI><A href="#Preprocessor_warning_error">The #error and #warning
+ directives</A></LI>
+</UL>
</DIV>
-<P> (Off topic rant: If your program really has functions like this, you
- would be well-advised to replace them with safer alternatives involving
- bounds checking).</P>
-<P> The macros defined in this module all expand to various combinations
- of typemaps. Therefore, the same pattern matching rules and ideas
- apply.</P>
-<P><B> %cstring_bounded_output(parm, maxsize)</B></P>
-<DIV class="indent">
-<P> Turns parameter <TT><EM>parm</EM></TT> into an output value. The
- output string is assumed to be NULL-terminated and smaller than <TT><EM>
-maxsize</EM></TT> characters. Here is an example:</P>
+<!-- INDEX -->
+<P> SWIG includes its own enhanced version of the C preprocessor. The
+ preprocessor supports the standard preprocessor directives and macro
+ expansion rules. However, a number of modifications and enhancements
+ have been made. This chapter describes some of these modifications.</P>
+<H2><A name="Preprocessor_nn2">8.1 File inclusion</A></H2>
+<P> To include another file into a SWIG interface, use the <TT>%include</TT>
+ directive like this:</P>
<DIV class="code">
<PRE>
-%cstring_bounded_output(char *path, 1024);
-...
-void get_path(char *path);
+%include "pointer.i"
</PRE>
</DIV>
-<P> In the target language:</P>
-<DIV class="targetlang">
+<P> Unlike, <TT>#include</TT>, <TT>%include</TT> includes each file once
+ (and will not reload the file on subsequent <TT>%include</TT>
+ declarations). Therefore, it is not necessary to use include-guards in
+ SWIG interfaces.</P>
+<P> By default, the <TT>#include</TT> is ignored unless you run SWIG
+ with the <TT>-includeall</TT> option. The reason for ignoring
+ traditional includes is that you often don't want SWIG to try and wrap
+ everything included in standard header system headers and auxiliary
+ files.</P>
+<H2><A name="Preprocessor_nn3">8.2 File imports</A></H2>
+<P> SWIG provides another file inclusion directive with the <TT>%import</TT>
+ directive. For example:</P>
+<DIV class="code">
<PRE>
->>> get_path()
-/home/beazley/packages/Foo/Bar
->>>
+%import "foo.i"
</PRE>
</DIV>
-<P> Internally, the wrapper function allocates a small buffer (on the
- stack) of the requested size and passes it as the pointer value. Data
- stored in the buffer is then returned as a function return value. If
- the function already returns a value, then the return value and the
- output string are returned together (multiple return values).<B> If
- more than <TT><EM>maxsize</EM></TT> bytes are written, your program
- will crash with a buffer overflow!</B></P>
-</DIV>
-<P><B> %cstring_chunk_output(parm, chunksize)</B></P>
-<DIV class="indent">
-<P> Turns parameter <TT><EM>parm</EM></TT> into an output value. The
- output string is always <TT><EM>chunksize</EM></TT> and may contain
- binary data. Here is an example:</P>
+<P> The purpose of <TT>%import</TT> is to collect certain information
+ from another SWIG interface file or a header file without actually
+ generating any wrapper code. Such information generally includes type
+ declarations (e.g., <TT>typedef</TT>) as well as C++ classes that might
+ be used as base-classes for class declarations in the interface. The
+ use of <TT>%import</TT> is also important when SWIG is used to generate
+ extensions as a collection of related modules. This is an advanced
+ topic and is described in later in the <A href="#Modules">Working with
+ Modules</A> chapter.</P>
+<P> The <TT>-importall</TT> directive tells SWIG to follow all <TT>
+#include</TT> statements as imports. This might be useful if you want to
+ extract type definitions from system header files without generating
+ any wrappers.</P>
+<H2><A name="Preprocessor_condition_compilation">8.3 Conditional
+ Compilation</A></H2>
+<P> SWIG fully supports the use of <TT>#if</TT>, <TT>#ifdef</TT>, <TT>
+#ifndef</TT>, <TT>#else</TT>, <TT>#endif</TT> to conditionally include
+ parts of an interface. The following symbols are predefined by SWIG
+ when it is parsing the interface:</P>
<DIV class="code">
<PRE>
-%cstring_chunk_output(char *packet, PACKETSIZE);
-...
-void get_packet(char *packet);
+SWIG Always defined when SWIG is processing a file
+SWIGIMPORTED Defined when SWIG is importing a file with <TT>%import</TT>
+SWIG_VERSION Hexadecimal (binary-coded decimal) number containing SWIG version,
+ such as 0x010311 (corresponding to SWIG-1.3.11).
+
+SWIGALLEGROCL Defined when using Allegro CL
+SWIGCFFI Defined when using CFFI
+SWIGCHICKEN Defined when using CHICKEN
+SWIGCLISP Defined when using CLISP
+SWIGCSHARP Defined when using C#
+SWIGGUILE Defined when using Guile
+SWIGJAVA Defined when using Java
+SWIGJAVASCRIPT Defined when using Javascript
+SWIG_JAVASCRIPT_JSC Defined when using Javascript for JavascriptCore
+SWIG_JAVASCRIPT_V8 Defined when using Javascript for v8 or node.js
+SWIGLUA Defined when using Lua
+SWIGMODULA3 Defined when using Modula-3
+SWIGMZSCHEME Defined when using Mzscheme
+SWIGOCAML Defined when using Ocaml
+SWIGOCTAVE Defined when using Octave
+SWIGPERL Defined when using Perl
+SWIGPHP Defined when using PHP
+SWIGPIKE Defined when using Pike
+SWIGPYTHON Defined when using Python
+SWIGR Defined when using R
+SWIGRUBY Defined when using Ruby
+SWIGSCILAB Defined when using Scilab
+SWIGSEXP Defined when using S-expressions
+SWIGTCL Defined when using Tcl
+SWIGXML Defined when using XML
</PRE>
</DIV>
-<P> In the target language:</P>
-<DIV class="targetlang">
+<P> In addition, SWIG defines the following set of standard C/C++
+ macros:</P>
+<DIV class="code">
<PRE>
->>> get_packet()
-'\xa9Y:\xf6\xd7\xe1\x87\xdbH;y\x97\x7f\xd3\x99\x14V\xec\x06\xea\xa2\x88'
->>>
+__LINE__ Current line number
+__FILE__ Current file name
+__STDC__ Defined to indicate ANSI C
+__cplusplus Defined when -c++ option used
</PRE>
</DIV>
-<P> This macro is essentially identical to <TT>%cstring_bounded_output</TT>
-. The only difference is that the result is always <TT><EM>chunksize</EM>
-</TT> characters. Furthermore, the result can contain binary data.<B> If
- more than <TT><EM>maxsize</EM></TT> bytes are written, your program
- will crash with a buffer overflow!</B></P>
-</DIV>
-<P><B> %cstring_bounded_mutable(parm, maxsize)</B></P>
-<DIV class="indent">
-<P> Turns parameter <TT><EM>parm</EM></TT> into a mutable string
- argument. The input string is assumed to be NULL-terminated and smaller
- than <TT><EM>maxsize</EM></TT> characters. The output string is also
- assumed to be NULL-terminated and less than <TT><EM>maxsize</EM></TT>
- characters.</P>
+<P> Interface files can look at these symbols as necessary to change the
+ way in which an interface is generated or to mix SWIG directives with C
+ code. These symbols are also defined within the C code generated by
+ SWIG (except for the symbol `<TT>SWIG</TT>' which is only defined
+ within the SWIG compiler).</P>
+<H2><A name="Preprocessor_nn5">8.4 Macro Expansion</A></H2>
+<P> Traditional preprocessor macros can be used in SWIG interfaces. Be
+ aware that the <TT>#define</TT> statement is also used to try and
+ detect constants. Therefore, if you have something like this in your
+ file,</P>
<DIV class="code">
<PRE>
-%cstring_bounded_mutable(char *ustr, 1024);
+#ifndef _FOO_H 1
+#define _FOO_H 1
...
-void make_upper(char *ustr);
+#endif
</PRE>
</DIV>
-<P> In the target language:</P>
-<DIV class="targetlang">
+<P> you may get some extra constants such as <TT>_FOO_H</TT> showing up
+ in the scripting interface.</P>
+<P> More complex macros can be defined in the standard way. For example:</P>
+<DIV class="code">
<PRE>
->>> make_upper("hello world")
-'HELLO WORLD'
->>>
+#define EXTERN extern
+#ifdef __STDC__
+#define _ANSI(args) (args)
+#else
+#define _ANSI(args) ()
+#endif
</PRE>
</DIV>
-<P> Internally, this macro is almost exactly the same as <TT>
-%cstring_bounded_output</TT>. The only difference is that the parameter
- accepts an input value that is used to initialize the internal buffer.
- It is important to emphasize that this function does not mutate the
- string value passed---instead it makes a copy of the input value,
- mutates it, and returns it as a result.<B> If more than <TT><EM>maxsize</EM>
-</TT> bytes are written, your program will crash with a buffer overflow!</B>
-</P>
-</DIV>
-<P><B> %cstring_mutable(parm [, expansion])</B></P>
-<DIV class="indent">
-<P> Turns parameter <TT><EM>parm</EM></TT> into a mutable string
- argument. The input string is assumed to be NULL-terminated. An
- optional parameter <TT><EM>expansion</EM></TT> specifies the number of
- extra characters by which the string might grow when it is modified.
- The output string is assumed to be NULL-terminated and less than the
- size of the input string plus any expansion characters.</P>
+<P> The following operators can appear in macro definitions:</P>
+<UL>
+<LI><TT>#x</TT>
+<BR> Converts macro argument <TT>x</TT> to a string surrounded by double
+ quotes ("x").</LI>
+<LI><TT>x ## y</TT>
+<BR> Concatenates x and y together to form <TT>xy</TT>.</LI>
+<LI><TT>`x`</TT>
+<BR> If <TT>x</TT> is a string surrounded by double quotes, do nothing.
+ Otherwise, turn into a string like <TT>#x</TT>. This is a non-standard
+ SWIG extension.</LI>
+</UL>
+<H2><A name="Preprocessor_nn6">8.5 SWIG Macros</A></H2>
+<P> SWIG provides an enhanced macro capability with the <TT>%define</TT>
+ and <TT>%enddef</TT> directives. For example:</P>
<DIV class="code">
<PRE>
-%cstring_mutable(char *ustr);
-...
-void make_upper(char *ustr);
+%define ARRAYHELPER(type,name)
+%inline %{
+type *new_ ## name (int nitems) {
+ return (type *) malloc(sizeof(type)*nitems);
+}
+void delete_ ## name(type *t) {
+ free(t);
+}
+type name ## _get(type *t, int index) {
+ return t[index];
+}
+void name ## _set(type *t, int index, type val) {
+ t[index] = val;
+}
+%}
+%enddef
-%cstring_mutable(char *hstr, HEADER_SIZE);
-...
-void attach_header(char *hstr);
+ARRAYHELPER(int, IntArray)
+ARRAYHELPER(double, DoubleArray)
</PRE>
</DIV>
-<P> In the target language:</P>
-<DIV class="targetlang">
+<P> The primary purpose of <TT>%define</TT> is to define large macros of
+ code. Unlike normal C preprocessor macros, it is not necessary to
+ terminate each line with a continuation character (\)--the macro
+ definition extends to the first occurrence of <TT>%enddef</TT>.
+ Furthermore, when such macros are expanded, they are reparsed through
+ the C preprocessor. Thus, SWIG macros can contain all other
+ preprocessor directives except for nested <TT>%define</TT> statements.</P>
+<P> The SWIG macro capability is a very quick and easy way to generate
+ large amounts of code. In fact, many of SWIG's advanced features and
+ libraries are built using this mechanism (such as C++ template
+ support).</P>
+<H2><A name="Preprocessor_nn7">8.6 C99 and GNU Extensions</A></H2>
+<P> SWIG-1.3.12 and newer releases support variadic preprocessor macros.
+ For example:</P>
+<DIV class="code">
<PRE>
->>> make_upper("hello world")
-'HELLO WORLD'
->>> attach_header("Hello world")
-'header: Hello world'
->>>
+#define DEBUGF(fmt,...) fprintf(stderr,fmt,__VA_ARGS__)
</PRE>
</DIV>
-<P> This macro differs from <TT>%cstring_bounded_mutable()</TT> in that
- a buffer is dynamically allocated (on the heap using <TT>malloc/new</TT>
-). This buffer is always large enough to store a copy of the input value
- plus any expansion bytes that might have been requested. It is
- important to emphasize that this function does not directly mutate the
- string value passed---instead it makes a copy of the input value,
- mutates it, and returns it as a result.<B> If the function expands the
- result by more than <TT><EM>expansion</EM></TT> extra bytes, then the
- program will crash with a buffer overflow!</B></P>
-</DIV>
-<P><B> %cstring_output_maxsize(parm, maxparm)</B></P>
-<DIV class="indent">
-<P> This macro is used to handle bounded character output functions
- where both a <TT>char *</TT> and a maximum length parameter are
- provided. As input, a user simply supplies the maximum length. The
- return value is assumed to be a NULL-terminated string.</P>
+<P> When used, any extra arguments to <TT>...</TT> are placed into the
+ special variable <TT>__VA_ARGS__</TT>. This also works with special
+ SWIG macros defined using <TT>%define</TT>.</P>
+<P> SWIG allows a variable number of arguments to be empty. However,
+ this often results in an extra comma (,) and syntax error in the
+ resulting expansion. For example:</P>
<DIV class="code">
<PRE>
-%cstring_output_maxsize(char *path, int maxpath);
-...
-void get_path(char *path, int maxpath);
+DEBUGF("hello"); --> fprintf(stderr,"hello",);
</PRE>
</DIV>
-<P> In the target language:</P>
-<DIV class="targetlang">
+<P> To get rid of the extra comma, use <TT>##</TT> like this:</P>
+<DIV class="code">
<PRE>
->>> get_path(1024)
-'/home/beazley/Packages/Foo/Bar'
->>>
+#define DEBUGF(fmt,...) fprintf(stderr,fmt, ##__VA_ARGS__)
</PRE>
</DIV>
-<P> This macro provides a safer alternative for functions that need to
- write string data into a buffer. User supplied buffer size is used to
- dynamically allocate memory on heap. Results are placed into that
- buffer and returned as a string object.</P>
-</DIV>
-<P><B> %cstring_output_withsize(parm, maxparm)</B></P>
-<DIV class="indent">
-<P> This macro is used to handle bounded character output functions
- where both a <TT>char *</TT> and a pointer <TT>int *</TT> are passed.
- Initially, the <TT>int *</TT> parameter points to a value containing
- the maximum size. On return, this value is assumed to contain the
- actual number of bytes. As input, a user simply supplies the maximum
- length. The output value is a string that may contain binary data.</P>
+<P> SWIG also supports GNU-style variadic macros. For example:</P>
<DIV class="code">
<PRE>
-%cstring_output_withsize(char *data, int *maxdata);
-...
-void get_data(char *data, int *maxdata);
+#define DEBUGF(fmt, args...) fprintf(stdout,fmt,args)
</PRE>
</DIV>
-<P> In the target language:</P>
-<DIV class="targetlang">
+<P><B> Comment:</B> It's not entirely clear how variadic macros might be
+ useful to interface building. However, they are used internally to
+ implement a number of SWIG directives and are provided to make SWIG
+ more compatible with C99 code.</P>
+<H2><A name="Preprocessor_delimiters">8.7 Preprocessing and delimiters</A>
+</H2>
+<P> The preprocessor handles { }, " " and %{ %} delimiters differently.</P>
+<H3><A name="Preprocessor_nn8">8.7.1 Preprocessing and %{ ... %} & " ...
+ " delimiters</A></H3>
+<P> The SWIG preprocessor does not process any text enclosed in a code
+ block %{ ... %}. Therefore, if you write code like this,</P>
+<DIV class="code">
<PRE>
->>> get_data(1024)
-'x627388912'
->>> get_data(1024)
-'xyzzy'
->>>
+%{
+#ifdef NEED_BLAH
+int blah() {
+ ...
+}
+#endif
+%}
</PRE>
</DIV>
-<P> This macro is a somewhat more powerful version of <TT>
-%cstring_output_chunk()</TT>. Memory is dynamically allocated and can be
- arbitrary large. Furthermore, a function can control how much data is
- actually returned by changing the value of the <TT>maxparm</TT>
- argument.</P>
-</DIV>
-<P><B> %cstring_output_allocate(parm, release)</B></P>
-<DIV class="indent">
-<P> This macro is used to return strings that are allocated within the
- program and returned in a parameter of type <TT>char **</TT>. For
- example:</P>
+<P> the contents of the <TT>%{ ... %}</TT> block are copied without
+ modification to the output (including all preprocessor directives).</P>
+<H3><A name="Preprocessor_nn9">8.7.2 Preprocessing and { ... }
+ delimiters</A></H3>
+<P> SWIG always runs the preprocessor on text appearing inside <TT>{ ...
+ }</TT>. However, sometimes it is desirable to make a preprocessor
+ directive pass through to the output file. For example:</P>
<DIV class="code">
<PRE>
-void foo(char **s) {
- *s = (char *) malloc(64);
- sprintf(*s, "Hello world\n");
+%extend Foo {
+ void bar() {
+ #ifdef DEBUG
+ printf("I'm in bar\n");
+ #endif
+ }
}
</PRE>
</DIV>
-<P> The returned string is assumed to be NULL-terminated. <TT><EM>
-release</EM></TT> specifies how the allocated memory is to be released
- (if applicable). Here is an example:</P>
+<P> By default, SWIG will interpret the <TT>#ifdef DEBUG</TT> statement.
+ However, if you really wanted that code to actually go into the wrapper
+ file, prefix the preprocessor directives with <TT>%</TT> like this:</P>
<DIV class="code">
<PRE>
-%cstring_output_allocate(char **s, free(*$1));
-...
-void foo(char **s);
+%extend Foo {
+ void bar() {
+ %#ifdef DEBUG
+ printf("I'm in bar\n");
+ %#endif
+ }
+}
</PRE>
</DIV>
-<P> In the target language:</P>
-<DIV class="targetlang">
+<P> SWIG will strip the extra <TT>%</TT> and leave the preprocessor
+ directive in the code.</P>
+<H2><A name="Preprocessor_typemap_delimiters">8.8 Preprocessor and
+ Typemaps</A></H2>
+<P> <A href="#Typemaps">Typemaps</A> support a special attribute called <TT>
+noblock</TT> where the { ... } delimiters can be used, but the
+ delimiters are not actually generated into the code. The effect is then
+ similar to using "" or %{ %} delimiters but the code<B> is</B> run
+ through the preprocessor. For example:</P>
+<DIV class="code">
<PRE>
->>> foo()
-'Hello world\n'
->>>
+#define SWIG_macro(CAST) (CAST)$input
+%typemap(in) Int {$1= SWIG_macro(int);}
</PRE>
-</DIV></DIV>
-<P><B> %cstring_output_allocate_size(parm, szparm, release)</B></P>
-<DIV class="indent">
-<P> This macro is used to return strings that are allocated within the
- program and returned in two parameters of type <TT>char **</TT> and <TT>
-int *</TT>. For example:</P>
+</DIV>
+<P> might generate</P>
<DIV class="code">
<PRE>
-void foo(char **s, int *sz) {
- *s = (char *) malloc(64);
- *sz = 64;
- // Write some binary data
- ...
-}
+ {
+ arg1=(int)jarg1;
+ }
</PRE>
</DIV>
-<P> The returned string may contain binary data. <TT><EM>release</EM></TT>
- specifies how the allocated memory is to be released (if applicable).
- Here is an example:</P>
+<P> whereas</P>
<DIV class="code">
<PRE>
-%cstring_output_allocate_size(char **s, int *slen, free(*$1));
-...
-void foo(char **s, int *slen);
+#define SWIG_macro(CAST) (CAST)$input
+%typemap(in,noblock=1) Int {$1= SWIG_macro(int);}
</PRE>
</DIV>
-<P> In the target language:</P>
-<DIV class="targetlang">
+<P> might generate</P>
+<DIV class="code">
<PRE>
->>> foo()
-'\xa9Y:\xf6\xd7\xe1\x87\xdbH;y\x97\x7f\xd3\x99\x14V\xec\x06\xea\xa2\x88'
->>>
+ arg1=(int)jarg1;
</PRE>
</DIV>
-<P> This is the safest and most reliable way to return binary string
- data in SWIG. If you have functions that conform to another prototype,
- you might consider wrapping them with a helper function. For example,
- if you had this:</P>
+<P> and</P>
<DIV class="code">
<PRE>
-char *get_data(int *len);
+#define SWIG_macro(CAST) (CAST)$input
+%typemap(in) Int %{$1=SWIG_macro(int);%}
</PRE>
</DIV>
-<P> You could wrap it with a function like this:</P>
+<P> would generate</P>
<DIV class="code">
<PRE>
-void my_get_data(char **result, int *len) {
- *result = get_data(len);
-}
+ arg1=SWIG_macro(int);
</PRE>
-</DIV></DIV>
-<P><B> Comments:</B></P>
-<UL>
-<LI>Support for the <TT>cstring.i</TT> module depends on the target
- language. Not all SWIG modules currently support this library.</LI>
-<LI>Reliable handling of raw C strings is a delicate topic. There are
- many ways to accomplish this in SWIG. This library provides support for
- a few common techniques.</LI>
-<LI>If used in C++, this library uses <TT>new</TT> and <TT>delete []</TT>
- for memory allocation. If using ANSI C, the library uses <TT>malloc()</TT>
- and <TT>free()</TT>.</LI>
-<LI>Rather than manipulating <TT>char *</TT> directly, you might
- consider using a special string structure or class instead.</LI>
-</UL>
-<H2><A name="Library_stl_cpp_library"></A>8.4 STL/C++ Library</H2>
-<P> The library modules in this section provide access to parts of the
- standard C++ library including the STL. SWIG support for the STL is an
- ongoing effort. Support is quite comprehensive for some language
- modules but some of the lesser used modules do not have quite as much
- library code written.</P>
-<P> The following table shows which C++ classes are supported and the
- equivalent SWIG interface library file for the C++ library.</P>
-<TABLE BORDER summary="SWIG C++ library files">
-<TR VALIGN="TOP"><TD><B>C++ class</B></TD><TD><B>C++ Library file</B></TD><TD>
-<B>SWIG Interface library file</B></TD></TR>
-<TR><TD>std::deque</TD><TD>deque</TD><TD>std_deque.i</TD></TR>
-<TR><TD>std::list</TD><TD>list</TD><TD>std_list.i</TD></TR>
-<TR><TD>std::map</TD><TD>map</TD><TD>std_map.i</TD></TR>
-<TR><TD>std::pair</TD><TD>utility</TD><TD>std_pair.i</TD></TR>
-<TR><TD>std::set</TD><TD>set</TD><TD>std_set.i</TD></TR>
-<TR><TD>std::string</TD><TD>string</TD><TD>std_string.i</TD></TR>
-<TR><TD>std::vector</TD><TD>vector</TD><TD>std_vector.i</TD></TR>
-<TR><TD>std::shared_ptr</TD><TD>shared_ptr</TD><TD>std_shared_ptr.i</TD></TR>
-</TABLE>
-<P> The list is by no means complete; some language modules support a
- subset of the above and some support additional STL classes. Please
- look for the library files in the appropriate language library
- directory.</P>
-<H3><A name="Library_std_string"></A>8.4.1 std::string</H3>
-<P> The <TT>std_string.i</TT> library provides typemaps for converting
- C++ <TT>std::string</TT> objects to and from strings in the target
- scripting language. For example:</P>
+</DIV>
+<H2><A name="Preprocessor_nn10">8.9 Viewing preprocessor output</A></H2>
+<P> Like many compilers, SWIG supports a <TT>-E</TT> command line option
+ to display the output from the preprocessor. When the <TT>-E</TT>
+ switch is used, SWIG will not generate any wrappers. Instead the
+ results after the preprocessor has run are displayed. This might be
+ useful as an aid to debugging and viewing the results of macro
+ expansions.</P>
+<H2><A name="Preprocessor_warning_error">8.10 The #error and #warning
+ directives</A></H2>
+<P> SWIG supports the commonly used <TT>#warning</TT> and <TT>#error</TT>
+ preprocessor directives. The <TT>#warning</TT> directive will cause
+ SWIG to issue a warning then continue processing. The <TT>#error</TT>
+ directive will cause SWIG to exit with a fatal error. Example usage:</P>
<DIV class="code">
<PRE>
-%module example
-%include "std_string.i"
-
-std::string foo();
-void bar(const std::string &x);
+#error "This is a fatal error message"
+#warning "This is a warning message"
</PRE>
</DIV>
-<P> In the target language:</P>
-<DIV class="targetlang">
+<P> The <TT>#error</TT> behaviour can be made to work like <TT>#warning</TT>
+ if the <TT>-cpperraswarn</TT> commandline option is used.
+ Alternatively, the <TT>#pragma</TT> directive can be used to the same
+ effect, for example:</P>
+<DIV class="code">
<PRE>
-x = foo(); # Returns a string object
-bar("Hello World"); # Pass string as std::string
+ /* Modified behaviour: #error does not cause SWIG to exit with error */
+ #pragma SWIG cpperraswarn=1
+ /* Normal behaviour: #error does cause SWIG to exit with error */
+ #pragma SWIG cpperraswarn=0
</PRE>
+</DIV><HR NOSHADE>
+<H1><A name="Library">9 SWIG library</A></H1>
+
+<!-- INDEX -->
+<DIV class="sectiontoc">
+<UL>
+<LI><A href="#Library_nn2">The %include directive and library search
+ path</A></LI>
+<LI><A href="#Library_nn3">C Arrays and Pointers</A>
+<UL>
+<LI><A href="#Library_nn4">cpointer.i</A></LI>
+<LI><A href="#Library_carrays">carrays.i</A></LI>
+<LI><A href="#Library_nn6">cmalloc.i</A></LI>
+<LI><A href="#Library_nn7">cdata.i</A></LI>
+</UL>
+</LI>
+<LI><A href="#Library_nn8">C String Handling</A>
+<UL>
+<LI><A href="#Library_nn9">Default string handling</A></LI>
+<LI><A href="#Library_nn10">Passing binary data</A></LI>
+<LI><A href="#Library_nn11">Using %newobject to release memory</A></LI>
+<LI><A href="#Library_nn12">cstring.i</A></LI>
+</UL>
+</LI>
+<LI><A href="#Library_stl_cpp_library">STL/C++ Library</A>
+<UL>
+<LI><A href="#Library_std_string">std::string</A></LI>
+<LI><A href="#Library_std_vector">std::vector</A></LI>
+<LI><A href="#Library_stl_exceptions">STL exceptions</A></LI>
+<LI><A href="#Library_std_shared_ptr">shared_ptr smart pointer</A></LI>
+<LI><A href="#Library_std_auto_ptr">auto_ptr smart pointer</A></LI>
+</UL>
+</LI>
+<LI><A href="#Library_nn16">Utility Libraries</A>
+<UL>
+<LI><A href="#Library_nn17">exception.i</A></LI>
+</UL>
+</LI>
+</UL>
</DIV>
-<P> A common problem that people encounter is that of classes/structures
- containing a <TT>std::string</TT>. This can be overcome by defining a
- typemap. For example:</P>
+<!-- INDEX -->
+<P> To help build extension modules, SWIG is packaged with a library of
+ support files that you can include in your own interfaces. These files
+ often define new SWIG directives or provide utility functions that can
+ be used to access parts of the standard C and C++ libraries. This
+ chapter provides a reference to the current set of supported library
+ files.</P>
+<P><B> Compatibility note:</B> Older versions of SWIG included a number
+ of library files for manipulating pointers, arrays, and other
+ structures. Most these files are now deprecated and have been removed
+ from the distribution. Alternative libraries provide similar
+ functionality. Please read this chapter carefully if you used the old
+ libraries.</P>
+<H2><A name="Library_nn2">9.1 The %include directive and library search
+ path</A></H2>
+<P> Library files are included using the <TT>%include</TT> directive.
+ When searching for files, directories are searched in the following
+ order:</P>
+<OL>
+<LI>The current directory</LI>
+<LI>Directories specified with the <TT>-I</TT> command line option</LI>
+<LI>.<TT>/swig_lib</TT></LI>
+<LI>SWIG library install location as reported by <TT>swig -swiglib</TT>,
+ for example <TT>/usr/local/share/swig/1.3.30</TT></LI>
+<LI>On Windows, a directory <TT>Lib</TT> relative to the location of <TT>
+swig.exe</TT> is also searched.</LI>
+</OL>
+<P> Within directories mentioned in points 3-5, SWIG first looks for a
+ subdirectory corresponding to a target language (e.g., <TT>python</TT>,
+ <TT>tcl</TT>, etc.). If found, SWIG will search the language specific
+ directory first. This allows for language-specific implementations of
+ library files.</P>
+<P> You can ignore the installed SWIG library by setting the <TT>
+SWIG_LIB</TT> environment variable. Set the environment variable to hold
+ an alternative library directory.</P>
+<P> The directories that are searched are displayed when using <TT>
+-verbose</TT> commandline option.</P>
+<H2><A name="Library_nn3">9.2 C Arrays and Pointers</A></H2>
+<P> This section describes library modules for manipulating low-level C
+ arrays and pointers. The primary use of these modules is in supporting
+ C declarations that manipulate bare pointers such as <TT>int *</TT>, <TT>
+double *</TT>, or <TT>void *</TT>. The modules can be used to allocate
+ memory, manufacture pointers, dereference memory, and wrap pointers as
+ class-like objects. Since these functions provide direct access to
+ memory, their use is potentially unsafe and you should exercise
+ caution.</P>
+<H3><A name="Library_nn4">9.2.1 cpointer.i</A></H3>
+<P> The <TT>cpointer.i</TT> module defines macros that can be used to
+ used to generate wrappers around simple C pointers. The primary use of
+ this module is in generating pointers to primitive datatypes such as <TT>
+int</TT> and <TT>double</TT>.</P>
+<P><B> <TT>%pointer_functions(type,name)</TT></B></P>
+<DIV class="indent">
+<P>Generates a collection of four functions for manipulating a pointer <TT>
+type *</TT>:</P>
+<P> <TT>type *new_name()</TT></P>
+<DIV class="indent">
+<P> Creates a new object of type <TT>type</TT> and returns a pointer to
+ it. In C, the object is created using <TT>calloc()</TT>. In C++, <TT>
+new</TT> is used.</P>
+</DIV>
+<P> <TT>type *copy_name(type value)</TT></P>
+<DIV class="indent">
+<P> Creates a new object of type <TT>type</TT> and returns a pointer to
+ it. An initial value is set by copying it from <TT>value</TT>. In C,
+ the object is created using <TT>calloc()</TT>. In C++, <TT>new</TT> is
+ used.</P>
+</DIV>
+<P> <TT>type *delete_name(type *obj)</TT></P>
+<DIV class="indent">
+<P> Deletes an object type <TT>type</TT>.</P>
+</DIV>
+<P> <TT>void name_assign(type *obj, type value)</TT></P>
+<DIV class="indent">
+<P> Assigns <TT>*obj = value</TT>.</P>
+</DIV>
+<P> <TT>type name_value(type *obj)</TT></P>
+<DIV class="indent">
+<P> Returns the value of <TT>*obj</TT>.</P>
+</DIV>
+<P> When using this macro, <TT>type</TT> may be any type and <TT>name</TT>
+ must be a legal identifier in the target language. <TT>name</TT> should
+ not correspond to any other name used in the interface file.</P>
+<P> Here is a simple example of using <TT>%pointer_functions()</TT>:</P>
<DIV class="code">
<PRE>
%module example
-%include "std_string.i"
+%include "cpointer.i"
-%apply const std::string& {std::string* foo};
+/* Create some functions for working with "int *" */
+%pointer_functions(int, intp);
-struct my_struct
-{
- std::string foo;
-};
+/* A function that uses an "int *" */
+void add(int x, int y, int *result);
</PRE>
</DIV>
-<P> In the target language:</P>
+<P> Now, in Python:</P>
<DIV class="targetlang">
<PRE>
-x = my_struct();
-x.foo="Hello World"; # assign with string
-print x.foo; # print as string
+>>> import example
+>>> c = example.new_intp() # Create an "int" for storing result
+>>> example.add(3,4,c) # Call function
+>>> example.intp_value(c) # Dereference
+7
+>>> example.delete_intp(c) # Delete
+</PRE>
+</DIV></DIV>
+<P><B> <TT>%pointer_class(type,name)</TT></B></P>
+<DIV class="indent">
+<P> Wraps a pointer of <TT>type *</TT> inside a class-based interface.
+ This interface is as follows:</P>
+<DIV class="code">
+<PRE>
+struct name {
+ name(); // Create pointer object
+ ~name(); // Delete pointer object
+ void assign(type value); // Assign value
+ type value(); // Get value
+ type *cast(); // Cast the pointer to original type
+ static name *frompointer(type *); // Create class wrapper from existing
+ // pointer
+};
</PRE>
</DIV>
-<P> This module only supports types <TT>std::string</TT> and <TT>const
- std::string &</TT>. Pointers and non-const references are left
- unmodified and returned as SWIG pointers.</P>
-<P> This library file is fully aware of C++ namespaces. If you export <TT>
-std::string</TT> or rename it with a typedef, make sure you include
- those declarations in your interface. For example:</P>
+<P> When using this macro, <TT>type</TT> is restricted to a simple type
+ name like <TT>int</TT>, <TT>float</TT>, or <TT>Foo</TT>. Pointers and
+ other complicated types are not allowed. <TT>name</TT> must be a valid
+ identifier not already in use. When a pointer is wrapped as a class,
+ the "class" may be transparently passed to any function that expects
+ the pointer.</P>
+<P> If the target language does not support proxy classes, the use of
+ this macro will produce the example same functions as <TT>
+%pointer_functions()</TT> macro.</P>
+<P> It should be noted that the class interface does introduce a new
+ object or wrap a pointer inside a special structure. Instead, the raw
+ pointer is used directly.</P>
+<P> Here is the same example using a class instead:</P>
<DIV class="code">
<PRE>
%module example
-%include "std_string.i"
+%include "cpointer.i"
-using namespace std;
-typedef std::string String;
-...
-void foo(string s, const String &t); // std_string typemaps still applied
+/* Wrap a class interface around an "int *" */
+%pointer_class(int, intp);
+
+/* A function that uses an "int *" */
+void add(int x, int y, int *result);
</PRE>
</DIV>
-<H3><A name="Library_std_vector"></A>8.4.2 std::vector</H3>
-<P> The <TT>std_vector.i</TT> library provides support for the C++ <TT>
-std::vector</TT> class in the STL. Using this library involves the use
- of the <TT>%template</TT> directive. All you need to do is to
- instantiate different versions of <TT>vector</TT> for the types that
- you want to use. For example:</P>
+<P> Now, in Python (using proxy classes)</P>
+<DIV class="targetlang">
+<PRE>
+>>> import example
+>>> c = example.intp() # Create an "int" for storing result
+>>> example.add(3,4,c) # Call function
+>>> c.value() # Dereference
+7
+</PRE>
+</DIV>
+<P> Of the two macros, <TT>%pointer_class</TT> is probably the most
+ convenient when working with simple pointers. This is because the
+ pointers are access like objects and they can be easily garbage
+ collected (destruction of the pointer object destroys the underlying
+ object).</P>
+</DIV>
+<P><B> <TT>%pointer_cast(type1, type2, name)</TT></B></P>
+<DIV class="indent">
+<P> Creates a casting function that converts <TT>type1</TT> to <TT>type2</TT>
+. The name of the function is <TT>name</TT>. For example:</P>
<DIV class="code">
<PRE>
-%module example
-%include "std_vector.i"
-
-namespace std {
- %template(vectori) vector<int>;
- %template(vectord) vector<double>;
-};
+%pointer_cast(int *, unsigned int *, int_to_uint);
</PRE>
</DIV>
-<P> When a template <TT>vector<X></TT> is instantiated a number of
- things happen:</P>
-<UL>
-<LI>A class that exposes the C++ API is created in the target language .
- This can be used to create objects, invoke methods, etc. This class is
- currently a subset of the real STL vector class.</LI>
-<LI>Input typemaps are defined for <TT>vector<X></TT>, <TT>const
- vector<X> &</TT>, and <TT>const vector<X> *</TT>. For each of these, a
- pointer <TT>vector<X> *</TT> may be passed or a native list object in
- the target language.</LI>
-<LI>An output typemap is defined for <TT>vector<X></TT>. In this case,
- the values in the vector are expanded into a list object in the target
- language.</LI>
-<LI>For all other variations of the type, the wrappers expect to receive
- a <TT>vector<X> *</TT> object in the usual manner.</LI>
-<LI>An exception handler for <TT>std::out_of_range</TT> is defined.</LI>
-<LI>Optionally, special methods for indexing, item retrieval, slicing,
- and element assignment may be defined. This depends on the target
- language.</LI>
-</UL>
-<P> To illustrate the use of this library, consider the following
- functions:</P>
+<P> In this example, the function <TT>int_to_uint()</TT> would be used
+ to cast types in the target language.</P>
+</DIV>
+<P><B> Note:</B> None of these macros can be used to safely work with
+ strings (<TT>char *</TT> or <TT>char **</TT>).</P>
+<P><B> Note:</B> When working with simple pointers, typemaps can often
+ be used to provide more seamless operation.</P>
+<H3><A name="Library_carrays">9.2.2 carrays.i</A></H3>
+<P> This module defines macros that assist in wrapping ordinary C
+ pointers as arrays. The module does not provide any safety or an extra
+ layer of wrapping--it merely provides functionality for creating,
+ destroying, and modifying the contents of raw C array data.</P>
+<P><B> <TT>%array_functions(type,name)</TT></B></P>
+<DIV class="indent">
+<P>Creates four functions.</P>
+<P> <TT>type *new_name(int nelements)</TT></P>
+<DIV class="indent">
+<P> Creates a new array of objects of type <TT>type</TT>. In C, the
+ array is allocated using <TT>calloc()</TT>. In C++, <TT>new []</TT> is
+ used.</P>
+</DIV>
+<P> <TT>type *delete_name(type *ary)</TT></P>
+<DIV class="indent">
+<P> Deletes an array. In C, <TT>free()</TT> is used. In C++, <TT>delete
+ []</TT> is used.</P>
+</DIV>
+<P> <TT>type name_getitem(type *ary, int index)</TT></P>
+<DIV class="indent">
+<P> Returns the value <TT>ary[index]</TT>.</P>
+</DIV>
+<P> <TT>void name_setitem(type *ary, int index, type value)</TT></P>
+<DIV class="indent">
+<P> Assigns <TT>ary[index] = value</TT>.</P>
+</DIV>
+<P> When using this macro, <TT>type</TT> may be any type and <TT>name</TT>
+ must be a legal identifier in the target language. <TT>name</TT> should
+ not correspond to any other name used in the interface file.</P>
+<P> Here is an example of <TT>%array_functions()</TT>. Suppose you had a
+ function like this:</P>
<DIV class="code">
<PRE>
-/* File : example.h */
-
-#include <vector>
-#include <algorithm>
-#include <functional>
-#include <numeric>
-
-double average(std::vector<int> v) {
- return std::accumulate(v.begin(),v.end(),0.0)/v.size();
-}
-
-std::vector<double> half(const std::vector<double>& v) {
- std::vector<double> w(v);
- for (unsigned int i=0; i<w.size(); i++)
- w[i] /= 2.0;
- return w;
-}
-
-void halve_in_place(std::vector<double>& v) {
- std::transform(v.begin(),v.end(),v.begin(),
- std::bind2nd(std::divides<double>(),2.0));
+void print_array(double x[10]) {
+ int i;
+ for (i = 0; i < 10; i++) {
+ printf("[%d] = %g\n", i, x[i]);
+ }
}
</PRE>
</DIV>
-<P> To wrap with SWIG, you might write the following:</P>
+<P> To wrap it, you might write this:</P>
<DIV class="code">
<PRE>
%module example
-%{
-#include "example.h"
-%}
-%include "std_vector.i"
-// Instantiate templates used by example
-namespace std {
- %template(IntVector) vector<int>;
- %template(DoubleVector) vector<double>;
-}
+%include "carrays.i"
+%array_functions(double, doubleArray);
-// Include the header file with above prototypes
-%include "example.h"
+void print_array(double x[10]);
</PRE>
</DIV>
-<P> Now, to illustrate the behavior in the scripting interpreter,
- consider this Python example:</P>
-<DIV class="targetlang">
+<P> Now, in a scripting language, you might write this:</P>
+<DIV class="code">
<PRE>
->>> from example import *
->>> iv = IntVector(4) # Create an vector<int>
->>> for i in range(0,4):
-... iv[i] = i
->>> average(iv) # Call method
-1.5
->>> average([0,1,2,3]) # Call with list
-1.5
->>> half([1,2,3]) # Half a list
-(0.5,1.0,1.5)
->>> halve_in_place([1,2,3]) # Oops
-Traceback (most recent call last):
- File "<stdin>", line 1, in ?
-TypeError: Type error. Expected _p_std__vectorTdouble_t
->>> dv = DoubleVector(4)
->>> for i in range(0,4):
-... dv[i] = i
->>> halve_in_place(dv) # Ok
->>> for i in dv:
-... print i
-...
-0.0
-0.5
-1.0
-1.5
->>> dv[20] = 4.5
-Traceback (most recent call last):
- File "<stdin>", line 1, in ?
- File "example.py", line 81, in __setitem__
- def __setitem__(*args): return apply(examplec.DoubleVector___setitem__,args)
-IndexError: vector index out of range
->>>
+a = new_doubleArray(10) # Create an array
+for i in range(0,10):
+ doubleArray_setitem(a,i,2*i) # Set a value
+print_array(a) # Pass to C
+delete_doubleArray(a) # Destroy array
+</PRE>
+</DIV></DIV>
+<P><B> <TT>%array_class(type,name)</TT></B></P>
+<DIV class="indent">
+<P> Wraps a pointer of <TT>type *</TT> inside a class-based interface.
+ This interface is as follows:</P>
+<DIV class="code">
+<PRE>
+struct name {
+ name(int nelements); // Create an array
+ ~name(); // Delete array
+ type getitem(int index); // Return item
+ void setitem(int index, type value); // Set item
+ type *cast(); // Cast to original type
+ static name *frompointer(type *); // Create class wrapper from
+ // existing pointer
+};
</PRE>
</DIV>
-<P> This library module is fully aware of C++ namespaces. If you use
- vectors with other names, make sure you include the appropriate <TT>
-using</TT> or typedef directives. For example:</P>
+<P> When using this macro, <TT>type</TT> is restricted to a simple type
+ name like <TT>int</TT> or <TT>float</TT>. Pointers and other
+ complicated types are not allowed. <TT>name</TT> must be a valid
+ identifier not already in use. When a pointer is wrapped as a class, it
+ can be transparently passed to any function that expects the pointer.</P>
+<P> When combined with proxy classes, the <TT>%array_class()</TT> macro
+ can be especially useful. For example:</P>
<DIV class="code">
<PRE>
-%include "std_vector.i"
-
-namespace std {
- %template(IntVector) vector<int>;
-}
-
-using namespace std;
-typedef std::vector Vector;
+%module example
+%include "carrays.i"
+%array_class(double, doubleArray);
-void foo(vector<int> *x, const Vector &x);
+void print_array(double x[10]);
</PRE>
</DIV>
-<P><B> Note:</B> This module makes use of several advanced SWIG features
- including templatized typemaps and template partial specialization. If
- you are trying to wrap other C++ code with templates, you might look at
- the code contained in <TT>std_vector.i</TT>. Alternatively, you can
- show them the code if you want to make their head explode.</P>
-<P><B> Note:</B> This module is defined for all SWIG target languages.
- However argument conversion details and the public API exposed to the
- interpreter vary.</P>
-<H3><A name="Library_stl_exceptions"></A>8.4.3 STL exceptions</H3>
-<P> Many of the STL wrapper functions add parameter checking and will
- throw a language dependent error/exception should the values not be
- valid. The classic example is array bounds checking. The library
- wrappers are written to throw a C++ exception in the case of error. The
- C++ exception in turn gets converted into an appropriate
- error/exception for the target language. By and large this handling
- should not need customising, however, customisation can easily be
- achieved by supplying appropriate "throws" typemaps. For example:</P>
+<P> Allows you to do this:</P>
<DIV class="code">
<PRE>
-%module example
-%include "std_vector.i"
-%typemap(throws) std::out_of_range {
- // custom exception handler
-}
-%template(VectInt) std::vector<int>;
+import example
+c = example.doubleArray(10) # Create double[10]
+for i in range(0,10):
+ c[i] = 2*i # Assign values
+example.print_array(c) # Pass to C
</PRE>
-</DIV>
-<P> The custom exception handler might, for example, log the exception
- then convert it into a specific error/exception for the target
- language.</P>
-<P> When using the STL it is advisable to add in an exception handler to
- catch all STL exceptions. The <TT>%exception</TT> directive can be used
- by placing the following code before any other methods or libraries to
- be wrapped:</P>
+</DIV></DIV>
+<P><B> Note:</B> These macros do not encapsulate C arrays inside a
+ special data structure or proxy. There is no bounds checking or safety
+ of any kind. If you want this, you should consider using a special
+ array object rather than a bare pointer.</P>
+<P><B> Note:</B> <TT>%array_functions()</TT> and <TT>%array_class()</TT>
+ should not be used with types of <TT>char</TT> or <TT>char *</TT>.</P>
+<H3><A name="Library_nn6">9.2.3 cmalloc.i</A></H3>
+<P> This module defines macros for wrapping the low-level C memory
+ allocation functions <TT>malloc()</TT>, <TT>calloc()</TT>, <TT>
+realloc()</TT>, and <TT>free()</TT>.</P>
+<P><B> <TT>%malloc(type [,name=type])</TT></B></P>
+<DIV class="indent">
+<P> Creates a wrapper around <TT>malloc()</TT> with the following
+ prototype:</P>
<DIV class="code">
<PRE>
-%include "exception.i"
-
-%exception {
- try {
- $action
- } catch (const std::exception& e) {
- SWIG_exception(SWIG_RuntimeError, e.what());
- }
-}
+<EM>type</EM> *malloc_<EM>name</EM>(int nbytes = sizeof(<EM>type</EM>));
</PRE>
</DIV>
-<P> Any thrown STL exceptions will then be gracefully handled instead of
- causing a crash.</P>
-<H3><A name="Library_std_shared_ptr"></A>8.4.4 shared_ptr smart pointer</H3>
-<P> Some target languages have support for handling the widely used <TT>
-boost::shared_ptr</TT> smart pointer. This smart pointer is also
- available as <TT>std::tr1::shared_ptr</TT> before it becomes fully
- standardized as <TT>std::shared_ptr</TT>. The <TT>boost_shared_ptr.i</TT>
- library provides support for <TT>boost::shared_ptr</TT> and <TT>
-std_shared_ptr.i</TT> provides support for <TT>std::shared_ptr</TT>, but
- if the following macro is defined as shown, it can be used for <TT>
-std::tr1::shared_ptr</TT>:</P>
+<P> If <TT>type</TT> is <TT>void</TT>, then the size parameter <TT>
+nbytes</TT> is required. The <TT>name</TT> parameter only needs to be
+ specified when wrapping a type that is not a valid identifier (e.g., "<TT>
+int *</TT>", "<TT>double **</TT>", etc.).</P>
+</DIV>
+<P><B> <TT>%calloc(type [,name=type])</TT></B></P>
+<DIV class="indent">
+<P> Creates a wrapper around <TT>calloc()</TT> with the following
+ prototype:</P>
<DIV class="code">
<PRE>
-#define SWIG_SHARED_PTR_SUBNAMESPACE tr1
-%include <std_shared_ptr.i>
+<EM>type</EM> *calloc_<EM>name</EM>(int nobj =1, int sz = sizeof(<EM>type</EM>));
</PRE>
</DIV>
-<P> You can only use one of these variants of shared_ptr in your
- interface file at a time. and all three variants must be used in
- conjunction with the <TT>%shared_ptr(T)</TT> macro, where <TT>T</TT> is
- the underlying pointer type equating to usage <TT>shared_ptr<T></TT>.
- The type <TT>T</TT> must be non-primitive. A simple example
- demonstrates usage:</P>
+<P> If <TT>type</TT> is <TT>void</TT>, then the size parameter <TT>sz</TT>
+ is required.</P>
+</DIV>
+<P><B> <TT>%realloc(type [,name=type])</TT></B></P>
+<DIV class="indent">
+<P> Creates a wrapper around <TT>realloc()</TT> with the following
+ prototype:</P>
<DIV class="code">
<PRE>
-%module example
-%include <boost_shared_ptr.i>
-%shared_ptr(IntValue)
-
-%inline %{
-#include <boost/shared_ptr.hpp>
-
-struct IntValue {
- int value;
- IntValue(int v) : value(v) {}
-};
-
-static int extractValue(const IntValue &t) {
- return t.value;
-}
-
-static int extractValueSmart(boost::shared_ptr<IntValue> t) {
- return t->value;
-}
-%}
+<EM>type</EM> *realloc_<EM>name</EM>(<EM>type</EM> *ptr, int nitems);
</PRE>
</DIV>
-<P> Note that the <TT>%shared_ptr(IntValue)</TT> declaration occurs
- after the inclusion of the <TT>boost_shared_ptr.i</TT> library which
- provides the macro and, very importantly, before any usage or
- declaration of the type, <TT>IntValue</TT>. The <TT>%shared_ptr</TT>
- macro provides, a few things for handling this smart pointer, but
- mostly a number of typemaps. These typemaps override the default
- typemaps so that the underlying proxy class is stored and passed around
- as a pointer to a <TT>shared_ptr</TT> instead of a plain pointer to the
- underlying type. This approach means that any instantiation of the type
- can be passed to methods taking the type by value, reference, pointer
- or as a smart pointer. The interested reader might want to look at the
- generated code, however, usage is simple and no different handling is
- required from the target language. For example, a simple use case of
- the above code from Java would be:</P>
-<DIV class="targetlang">
-<PRE>
-IntValue iv = new IntValue(1234);
-int val1 = example.extractValue(iv);
-int val2 = example.extractValueSmart(iv);
-System.out.println(val1 + " " + val2);
-</PRE>
+<P> Note: unlike the C <TT>realloc()</TT>, the wrapper generated by this
+ macro implicitly includes the size of the corresponding type. For
+ example, <TT>realloc_int(p, 100)</TT> reallocates <TT>p</TT> so that it
+ holds 100 integers.</P>
</DIV>
-<P> This shared_ptr library works quite differently to SWIG's normal,
- but somewhat limited, <A href="#SWIGPlus_smart_pointers">smart pointer
- handling</A>. The shared_ptr library does not generate extra wrappers,
- just for smart pointer handling, in addition to the proxy class. The
- normal proxy class including inheritance relationships is generated as
- usual. The only real change introduced by the <TT>%shared_ptr</TT>
- macro is that the proxy class stores a pointer to the shared_ptr
- instance instead of a raw pointer to the instance. A proxy class
- derived from a base which is being wrapped with shared_ptr can and<B>
- must</B> be wrapped as a shared_ptr too. In other words all classes in
- an inheritance hierarchy must all be used with the <TT>%shared_ptr</TT>
- macro. For example the following code can be used with the base class
- shown earlier:</P>
+<P><B> <TT>%free(type [,name=type])</TT></B></P>
+<DIV class="indent">
+<P> Creates a wrapper around <TT>free()</TT> with the following
+ prototype:</P>
<DIV class="code">
<PRE>
-%shared_ptr(DerivedIntValue)
-%inline %{
-struct DerivedIntValue : IntValue {
- DerivedIntValue(int value) : IntValue(value) {}
- ...
-};
-%}
+void free_<EM>name</EM>(<EM>type</EM> *ptr);
</PRE>
-</DIV>
-<P> A shared_ptr of the derived class can now be passed to a method
- where the base is expected in the target language, just as it can in
- C++:</P>
-<DIV class="targetlang">
+</DIV></DIV>
+<P><B> <TT>%sizeof(type [,name=type])</TT></B></P>
+<DIV class="indent">
+<P> Creates the constant:</P>
+<DIV class="code">
<PRE>
-DerivedIntValue div = new DerivedIntValue(5678);
-int val3 = example.extractValue(div);
-int val4 = example.extractValueSmart(div);
+%constant int sizeof_<EM>name</EM> = sizeof(<EM>type</EM>);
</PRE>
+</DIV></DIV>
+<P><B> <TT>%allocators(type [,name=type])</TT></B></P>
+<DIV class="indent">
+<P> Generates wrappers for all five of the above operations.</P>
</DIV>
-<P> If the <TT>%shared_ptr</TT> macro is omitted for any class in the
- inheritance hierarchy, SWIG will warn about this and the generated code
- may or may not result in a C++ compilation error. For example, the
- following input:</P>
+<P> Here is a simple example that illustrates the use of these macros:</P>
<DIV class="code">
<PRE>
-%include "boost_shared_ptr.i"
-%shared_ptr(Parent);
+// SWIG interface
+%module example
+%include "cmalloc.i"
-%inline %{
- #include <boost/shared_ptr.hpp>
- struct GrandParent {
- virtual ~GrandParent() {}
- };
+%malloc(int);
+%free(int);
- struct Parent : GrandParent {
- virtual ~Parent() {}
- };
+%malloc(int *, intp);
+%free(int *, intp);
- struct Child : Parent {
- virtual ~Child() {}
- };
-%}
+%allocators(double);
</PRE>
</DIV>
-<P> warns about the missing smart pointer information:</P>
-<DIV class="shell">
+<P> Now, in a script:</P>
+<DIV class="targetlang">
<PRE>
-example.i:12: Warning 520: Base class 'GrandParent' of 'Parent' is not similarly marked as a smart pointer.
-example.i:16: Warning 520: Derived class 'Child' of 'Parent' is not similarly marked as a smart pointer.
+>>> from example import *
+>>> a = malloc_int()
+>>> a
+'_000efa70_p_int'
+>>> free_int(a)
+>>> b = malloc_intp()
+>>> b
+'_000efb20_p_p_int'
+>>> free_intp(b)
+>>> c = calloc_double(50)
+>>> c
+'_000fab98_p_double'
+>>> c = realloc_double(100000)
+>>> free_double(c)
+>>> print sizeof_double
+8
+>>>
</PRE>
</DIV>
-<P> Adding the missing <TT>%shared_ptr</TT> macros will fix this:</P>
-<DIV class="code">
-<PRE>
-%include "boost_shared_ptr.i"
-%shared_ptr(GrandParent);
-%shared_ptr(Parent);
-%shared_ptr(Child);
-
-... as before ...
-</PRE>
-</DIV><B> Note:</B> There is currently no support for <TT>%shared_ptr</TT>
- and the director feature.
-<H2><A name="Library_nn16"></A>8.5 Utility Libraries</H2>
-<H3><A name="Library_nn17"></A>8.5.1 exception.i</H3>
-<P> The <TT>exception.i</TT> library provides a language-independent
- function for raising a run-time exception in the target language. This
- library is largely used by the SWIG library writers. If possible, use
- the error handling scheme available to your target language as there is
- greater flexibility in what errors/exceptions can be thrown.</P>
-<P><B> <TT>SWIG_exception(int code, const char *message)</TT></B></P>
+<H3><A name="Library_nn7">9.2.4 cdata.i</A></H3>
+<P> The <TT>cdata.i</TT> module defines functions for converting raw C
+ data to and from strings in the target language. The primary
+ applications of this module would be packing/unpacking of binary data
+ structures---for instance, if you needed to extract data from a buffer.
+ The target language must support strings with embedded binary data in
+ order for this to work.</P>
+<P><B> <TT>const char *cdata(void *ptr, size_t nbytes)</TT></B></P>
<DIV class="indent">
-<P> Raises an exception in the target language. <TT>code</TT> is one of
- the following symbolic constants:</P>
-<DIV class="code">
-<PRE>
-SWIG_MemoryError
-SWIG_IOError
-SWIG_RuntimeError
-SWIG_IndexError
-SWIG_TypeError
-SWIG_DivisionByZero
-SWIG_OverflowError
-SWIG_SyntaxError
-SWIG_ValueError
-SWIG_SystemError
-</PRE>
-</DIV>
-<P> <TT>message</TT> is a string indicating more information about the
- problem.</P>
-</DIV>
-<P> The primary use of this module is in writing language-independent
- exception handlers. For example:</P>
-<DIV class="code">
-<PRE>
-%include "exception.i"
-%exception std::vector::getitem {
- try {
- $action
- } catch (std::out_of_range& e) {
- SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
- }
-}
-</PRE>
-</DIV><HR NOSHADE>
-<H1><A name="Arguments"></A>9 Argument Handling</H1>
-
-<!-- INDEX -->
-<DIV class="sectiontoc">
-<UL>
-<LI><A href="#Arguments_nn2">The typemaps.i library</A>
-<UL>
-<LI><A href="#Arguments_nn3">Introduction</A></LI>
-<LI><A href="#Arguments_nn4">Input parameters</A></LI>
-<LI><A href="#Arguments_nn5">Output parameters</A></LI>
-<LI><A href="#Arguments_nn6">Input/Output parameters</A></LI>
-<LI><A href="#Arguments_nn7">Using different names</A></LI>
-</UL>
-</LI>
-<LI><A href="#Arguments_nn8">Applying constraints to input values</A>
-<UL>
-<LI><A href="#Arguments_nn9">Simple constraint example</A></LI>
-<LI><A href="#Arguments_nn10">Constraint methods</A></LI>
-<LI><A href="#Arguments_nn11">Applying constraints to new datatypes</A></LI>
-</UL>
-</LI>
-</UL>
+<P> Converts <TT>nbytes</TT> of data at <TT>ptr</TT> into a string. <TT>
+ptr</TT> can be any pointer.</P>
</DIV>
-<!-- INDEX -->
-<P> In Chapter 3, SWIG's treatment of basic datatypes and pointers was
- described. In particular, primitive types such as <TT>int</TT> and <TT>
-double</TT> are mapped to corresponding types in the target language.
- For everything else, pointers are used to refer to structures, classes,
- arrays, and other user-defined datatypes. However, in certain
- applications it is desirable to change SWIG's handling of a specific
- datatype. For example, you might want to return multiple values through
- the arguments of a function. This chapter describes some of the
- techniques for doing this.</P>
-<H2><A name="Arguments_nn2"></A>9.1 The typemaps.i library</H2>
-<P> This section describes the <TT>typemaps.i</TT> library
- file--commonly used to change certain properties of argument
- conversion.</P>
-<H3><A name="Arguments_nn3"></A>9.1.1 Introduction</H3>
-<P> Suppose you had a C function like this:</P>
-<DIV class="code">
-<PRE>
-void add(double a, double b, double *result) {
- *result = a + b;
-}
-</PRE>
+<P><B> <TT>void memmove(void *ptr, const char *s)</TT></B></P>
+<DIV class="indent">
+<P> Copies all of the string data in <TT>s</TT> into the memory pointed
+ to by <TT>ptr</TT>. The string may contain embedded NULL bytes. This is
+ actually a wrapper to the standard C library <TT>memmove</TT> function,
+ which is declared as<B> <TT>void memmove(void *ptr, const void *src,
+ size_t n)</TT></B>. The <TT>src</TT> and length <TT>n</TT> parameters
+ are extracted from the language specific string <TT>s</TT> in the
+ underlying wrapper code.</P>
</DIV>
-<P> From reading the source code, it is clear that the function is
- storing a value in the <TT>double *result</TT> parameter. However,
- since SWIG does not examine function bodies, it has no way to know that
- this is the underlying behavior.</P>
-<P> One way to deal with this is to use the <TT>typemaps.i</TT> library
- file and write interface code like this:</P>
+<P> One use of these functions is packing and unpacking data from
+ memory. Here is a short example:</P>
<DIV class="code">
<PRE>
-// Simple example using typemaps
+// SWIG interface
%module example
-%include "typemaps.i"
+%include "carrays.i"
+%include "cdata.i"
-%apply double *OUTPUT { double *result };
-%inline %{
-extern void add(double a, double b, double *result);
-%}
+%array_class(int, intArray);
</PRE>
</DIV>
-<P> The <TT>%apply</TT> directive tells SWIG that you are going to apply
- a special type handling rule to a type. The "<TT>double *OUTPUT</TT>"
- specification is the name of a rule that defines how to return an
- output value from an argument of type <TT>double *</TT>. This rule gets
- applied to all of the datatypes listed in curly braces-- in this case "<TT>
-double *result</TT>".</P>
-<P> When the resulting module is created, you can now use the function
- like this (shown for Python):</P>
+<P> Python example:</P>
<DIV class="targetlang">
<PRE>
->>> a = add(3,4)
->>> print a
-7
+>>> a = intArray(10)
+>>> for i in range(0,10):
+... a[i] = i
+>>> b = cdata(a,40)
+>>> b
+'\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04
+\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\t'
+>>> c = intArray(10)
+>>> memmove(c,b)
+>>> print c[4]
+4
>>>
</PRE>
</DIV>
-<P> In this case, you can see how the output value normally returned in
- the third argument has magically been transformed into a function
- return value. Clearly this makes the function much easier to use since
- it is no longer necessary to manufacture a special <TT>double *</TT>
- object and pass it to the function somehow.</P>
-<P> Once a typemap has been applied to a type, it stays in effect for
- all future occurrences of the type and name. For example, you could
- write the following:</P>
+<P> Since the size of data is not always known, the following macro is
+ also defined:</P>
+<P><B> <TT>%cdata(type [,name=type])</TT></B></P>
+<DIV class="indent">
+<P> Generates the following function for extracting C data for a given
+ type.</P>
<DIV class="code">
<PRE>
-%module example
-%include "typemaps.i"
-
-%apply double *OUTPUT { double *result };
-
-%inline %{
-extern void add(double a, double b, double *result);
-extern void sub(double a, double b, double *result);
-extern void mul(double a, double b, double *result);
-extern void div(double a, double b, double *result);
-%}
-...
+char *cdata_<EM>name</EM>(type* ptr, int nitems)
</PRE>
</DIV>
-<P> In this case, the <TT>double *OUTPUT</TT> rule is applied to all of
- the functions that follow.</P>
-<P> Typemap transformations can even be extended to multiple return
- values. For example, consider this code:</P>
+<P> <TT>nitems</TT> is the number of items of the given type to extract.</P>
+</DIV>
+<P><B> Note:</B> These functions provide direct access to memory and can
+ be used to overwrite data. Clearly they are unsafe.</P>
+<H2><A name="Library_nn8">9.3 C String Handling</A></H2>
+<P> A common problem when working with C programs is dealing with
+ functions that manipulate raw character data using <TT>char *</TT>. In
+ part, problems arise because there are different interpretations of <TT>
+char *</TT>---it could be a NULL-terminated string or it could point to
+ binary data. Moreover, functions that manipulate raw strings may mutate
+ data, perform implicit memory allocations, or utilize fixed-sized
+ buffers.</P>
+<P> The problems (and perils) of using <TT>char *</TT> are well-known.
+ However, SWIG is not in the business of enforcing morality. The modules
+ in this section provide basic functionality for manipulating raw C
+ strings.</P>
+<H3><A name="Library_nn9">9.3.1 Default string handling</A></H3>
+<P> Suppose you have a C function with this prototype:</P>
<DIV class="code">
<PRE>
-%include "typemaps.i"
-%apply int *OUTPUT { int *width, int *height };
-
-// Returns a pair (width,height)
-void getwinsize(int winid, int *width, int *height);
+char *foo(char *s);
</PRE>
</DIV>
-<P> In this case, the function returns multiple values, allowing it to
- be used like this:</P>
-<DIV class="targetlang">
+<P> The default wrapping behavior for this function is to set <TT>s</TT>
+ to a raw <TT>char *</TT> that refers to the internal string data in the
+ target language. In other words, if you were using a language like Tcl,
+ and you wrote this,</P>
+<DIV class="code">
<PRE>
->>> w,h = genwinsize(wid)
->>> print w
-400
->>> print h
-300
->>>
+% foo Hello
</PRE>
</DIV>
-<P> It should also be noted that although the <TT>%apply</TT> directive
- is used to associate typemap rules to datatypes, you can also use the
- rule names directly in arguments. For example, you could write this:</P>
+<P> then <TT>s</TT> would point to the representation of "Hello" inside
+ the Tcl interpreter. When returning a <TT>char *</TT>, SWIG assumes
+ that it is a NULL-terminated string and makes a copy of it. This gives
+ the target language its own copy of the result.</P>
+<P> There are obvious problems with the default behavior. First, since a
+ <TT>char *</TT> argument points to data inside the target language, it
+ is<B> NOT</B> safe for a function to modify this data (doing so may
+ corrupt the interpreter and lead to a crash). Furthermore, the default
+ behavior does not work well with binary data. Instead, strings are
+ assumed to be NULL-terminated.</P>
+<H3><A name="Library_nn10">9.3.2 Passing binary data</A></H3>
+<P> If you have a function that expects binary data,</P>
<DIV class="code">
<PRE>
-// Simple example using typemaps
-%module example
-%include "typemaps.i"
-
-%{
-extern void add(double a, double b, double *OUTPUT);
-%}
-extern void add(double a, double b, double *OUTPUT);
+size_t parity(char *str, size_t len, size_t initial);
</PRE>
</DIV>
-<P> Typemaps stay in effect until they are explicitly deleted or
- redefined to something else. To clear a typemap, the <TT>%clear</TT>
- directive should be used. For example:</P>
+<P> you can wrap the parameters <TT>(char *str, size_t len)</TT> as a
+ single argument using a typemap. Just do this:</P>
<DIV class="code">
<PRE>
-%clear double *result; // Remove all typemaps for double *result
+%apply (char *STRING, size_t LENGTH) { (char *str, size_t len) };
+...
+size_t parity(char *str, size_t len, size_t initial);
</PRE>
</DIV>
-<H3><A name="Arguments_nn4"></A>9.1.2 Input parameters</H3>
-<P> The following typemaps instruct SWIG that a pointer really only
- holds a single input value:</P>
+<P> Now, in the target language, you can use binary string data like
+ this:</P>
<DIV class="code">
<PRE>
-int *INPUT
-short *INPUT
-long *INPUT
-unsigned int *INPUT
-unsigned short *INPUT
-unsigned long *INPUT
-double *INPUT
-float *INPUT
+>>> s = "H\x00\x15eg\x09\x20"
+>>> parity(s,0)
</PRE>
</DIV>
-<P> When used, it allows values to be passed instead of pointers. For
- example, consider this function:</P>
+<P> In the wrapper function, the passed string will be expanded to a
+ pointer and length parameter. The <TT>(char *STRING, int LENGTH)</TT>
+ multi-argument typemap is also available in addition to <TT>(char
+ *STRING, size_t LENGTH)</TT>.</P>
+<H3><A name="Library_nn11">9.3.3 Using %newobject to release memory</A></H3>
+<P> If you have a function that allocates memory like this,</P>
<DIV class="code">
<PRE>
-double add(double *a, double *b) {
- return *a+*b;
+char *foo() {
+ char *result = (char *) malloc(...);
+ ...
+ return result;
}
</PRE>
</DIV>
-<P> Now, consider this SWIG interface:</P>
+<P> then the SWIG generated wrappers will have a memory leak--the
+ returned data will be copied into a string object and the old contents
+ ignored.</P>
+<P> To fix the memory leak, use the <TT>%newobject</TT> directive.</P>
<DIV class="code">
<PRE>
-%module example
-%include "typemaps.i"
+%newobject foo;
...
-%{
-extern double add(double *, double *);
-%}
-extern double add(double *INPUT, double *INPUT);
-
-</PRE>
-</DIV>
-<P> When the function is used in the scripting language interpreter, it
- will work like this:</P>
-<DIV class="targetlang">
-<PRE>
-result = add(3,4)
+char *foo();
</PRE>
</DIV>
-<H3><A name="Arguments_nn5"></A>9.1.3 Output parameters</H3>
-<P> The following typemap rules tell SWIG that pointer is the output
- value of a function. When used, you do not need to supply the argument
- when calling the function. Instead, one or more output values are
- returned.</P>
+<P> This will release the result if the appropriate target language
+ support is available. SWIG provides the appropriate "newfree" typemap
+ for <TT>char *</TT> so that the memory is released, however, you may
+ need to provide your own "newfree" typemap for other types. See <A href="#Customization_ownership">
+Object ownership and %newobject</A> for more details.</P>
+<H3><A name="Library_nn12">9.3.4 cstring.i</A></H3>
+<P> The <TT>cstring.i</TT> library file provides a collection of macros
+ for dealing with functions that either mutate string arguments or which
+ try to output string data through their arguments. An example of such a
+ function might be this rather questionable implementation:</P>
<DIV class="code">
<PRE>
-int *OUTPUT
-short *OUTPUT
-long *OUTPUT
-unsigned int *OUTPUT
-unsigned short *OUTPUT
-unsigned long *OUTPUT
-double *OUTPUT
-float *OUTPUT
-
+void get_path(char *s) {
+ // Potential buffer overflow---uh, oh.
+ sprintf(s,"%s/%s", base_directory, sub_directory);
+}
+...
+// Somewhere else in the C program
+{
+ char path[1024];
+ ...
+ get_path(path);
+ ...
+}
</PRE>
</DIV>
-<P> These methods can be used as shown in an earlier example. For
- example, if you have this C function :</P>
+<P> (Off topic rant: If your program really has functions like this, you
+ would be well-advised to replace them with safer alternatives involving
+ bounds checking).</P>
+<P> The macros defined in this module all expand to various combinations
+ of typemaps. Therefore, the same pattern matching rules and ideas
+ apply.</P>
+<P><B> %cstring_bounded_output(parm, maxsize)</B></P>
+<DIV class="indent">
+<P> Turns parameter <TT><EM>parm</EM></TT> into an output value. The
+ output string is assumed to be NULL-terminated and smaller than <TT><EM>
+maxsize</EM></TT> characters. Here is an example:</P>
<DIV class="code">
<PRE>
-void add(double a, double b, double *c) {
- *c = a+b;
-}
+%cstring_bounded_output(char *path, 1024);
+...
+void get_path(char *path);
</PRE>
</DIV>
-<P> A SWIG interface file might look like this :</P>
-<DIV class="code">
+<P> In the target language:</P>
+<DIV class="targetlang">
<PRE>
-%module example
-%include "typemaps.i"
-...
-%inline %{
-extern void add(double a, double b, double *OUTPUT);
-%}
-
+>>> get_path()
+/home/beazley/packages/Foo/Bar
+>>>
</PRE>
</DIV>
-<P> In this case, only a single output value is returned, but this is
- not a restriction. An arbitrary number of output values can be returned
- by applying the output rules to more than one argument (as shown
- previously).</P>
-<P> If the function also returns a value, it is returned along with the
- argument. For example, if you had this:</P>
+<P> Internally, the wrapper function allocates a small buffer (on the
+ stack) of the requested size and passes it as the pointer value. Data
+ stored in the buffer is then returned as a function return value. If
+ the function already returns a value, then the return value and the
+ output string are returned together (multiple return values).<B> If
+ more than <TT><EM>maxsize</EM></TT> bytes are written, your program
+ will crash with a buffer overflow!</B></P>
+</DIV>
+<P><B> %cstring_chunk_output(parm, chunksize)</B></P>
+<DIV class="indent">
+<P> Turns parameter <TT><EM>parm</EM></TT> into an output value. The
+ output string is always <TT><EM>chunksize</EM></TT> and may contain
+ binary data. Here is an example:</P>
<DIV class="code">
<PRE>
-extern int foo(double a, double b, double *OUTPUT);
+%cstring_chunk_output(char *packet, PACKETSIZE);
+...
+void get_packet(char *packet);
</PRE>
</DIV>
-<P> The function will return two values like this:</P>
+<P> In the target language:</P>
<DIV class="targetlang">
<PRE>
-iresult, dresult = foo(3.5, 2)
+>>> get_packet()
+'\xa9Y:\xf6\xd7\xe1\x87\xdbH;y\x97\x7f\xd3\x99\x14V\xec\x06\xea\xa2\x88'
+>>>
</PRE>
</DIV>
-<H3><A name="Arguments_nn6"></A>9.1.4 Input/Output parameters</H3>
-<P> When a pointer serves as both an input and output value you can use
- the following typemaps :</P>
+<P> This macro is essentially identical to <TT>%cstring_bounded_output</TT>
+. The only difference is that the result is always <TT><EM>chunksize</EM>
+</TT> characters. Furthermore, the result can contain binary data.<B> If
+ more than <TT><EM>maxsize</EM></TT> bytes are written, your program
+ will crash with a buffer overflow!</B></P>
+</DIV>
+<P><B> %cstring_bounded_mutable(parm, maxsize)</B></P>
+<DIV class="indent">
+<P> Turns parameter <TT><EM>parm</EM></TT> into a mutable string
+ argument. The input string is assumed to be NULL-terminated and smaller
+ than <TT><EM>maxsize</EM></TT> characters. The output string is also
+ assumed to be NULL-terminated and less than <TT><EM>maxsize</EM></TT>
+ characters.</P>
<DIV class="code">
<PRE>
-int *INOUT
-short *INOUT
-long *INOUT
-unsigned int *INOUT
-unsigned short *INOUT
-unsigned long *INOUT
-double *INOUT
-float *INOUT
-
+%cstring_bounded_mutable(char *ustr, 1024);
+...
+void make_upper(char *ustr);
</PRE>
</DIV>
-<P> A C function that uses this might be something like this:</P>
-<DIV class="code">
+<P> In the target language:</P>
+<DIV class="targetlang">
<PRE>
-void negate(double *x) {
- *x = -(*x);
-}
-
+>>> make_upper("hello world")
+'HELLO WORLD'
+>>>
</PRE>
</DIV>
-<P> To make x function as both and input and output value, declare the
- function like this in an interface file :</P>
+<P> Internally, this macro is almost exactly the same as <TT>
+%cstring_bounded_output</TT>. The only difference is that the parameter
+ accepts an input value that is used to initialize the internal buffer.
+ It is important to emphasize that this function does not mutate the
+ string value passed---instead it makes a copy of the input value,
+ mutates it, and returns it as a result.<B> If more than <TT><EM>maxsize</EM>
+</TT> bytes are written, your program will crash with a buffer overflow!</B>
+</P>
+</DIV>
+<P><B> %cstring_mutable(parm [, expansion])</B></P>
+<DIV class="indent">
+<P> Turns parameter <TT><EM>parm</EM></TT> into a mutable string
+ argument. The input string is assumed to be NULL-terminated. An
+ optional parameter <TT><EM>expansion</EM></TT> specifies the number of
+ extra characters by which the string might grow when it is modified.
+ The output string is assumed to be NULL-terminated and less than the
+ size of the input string plus any expansion characters.</P>
<DIV class="code">
<PRE>
-%module example
-%include "typemaps.i"
+%cstring_mutable(char *ustr);
...
-%{
-extern void negate(double *);
-%}
-extern void negate(double *INOUT);
+void make_upper(char *ustr);
+%cstring_mutable(char *hstr, HEADER_SIZE);
+...
+void attach_header(char *hstr);
</PRE>
</DIV>
-<P> Now within a script, you can simply call the function normally :</P>
+<P> In the target language:</P>
<DIV class="targetlang">
<PRE>
-a = negate(3); # a = -3 after calling this
+>>> make_upper("hello world")
+'HELLO WORLD'
+>>> attach_header("Hello world")
+'header: Hello world'
+>>>
</PRE>
</DIV>
-<P> One subtle point of the <TT>INOUT</TT> rule is that many scripting
- languages enforce mutability constraints on primitive objects (meaning
- that simple objects like integers and strings aren't supposed to
- change). Because of this, you can't just modify the object's value in
- place as the underlying C function does in this example. Therefore, the
- <TT>INOUT</TT> rule returns the modified value as a new object rather
- than directly overwriting the value of the original input object.</P>
-<P><B> Compatibility note :</B> The <TT>INOUT</TT> rule used to be known
- as <TT>BOTH</TT> in earlier versions of SWIG. Backwards compatibility
- is preserved, but deprecated.</P>
-<H3><A name="Arguments_nn7"></A>9.1.5 Using different names</H3>
-<P> As previously shown, the <TT>%apply</TT> directive can be used to
- apply the <TT>INPUT</TT>, <TT>OUTPUT</TT>, and <TT>INOUT</TT> typemaps
- to different argument names. For example:</P>
+<P> This macro differs from <TT>%cstring_bounded_mutable()</TT> in that
+ a buffer is dynamically allocated (on the heap using <TT>malloc/new</TT>
+). This buffer is always large enough to store a copy of the input value
+ plus any expansion bytes that might have been requested. It is
+ important to emphasize that this function does not directly mutate the
+ string value passed---instead it makes a copy of the input value,
+ mutates it, and returns it as a result.<B> If the function expands the
+ result by more than <TT><EM>expansion</EM></TT> extra bytes, then the
+ program will crash with a buffer overflow!</B></P>
+</DIV>
+<P><B> %cstring_output_maxsize(parm, maxparm)</B></P>
+<DIV class="indent">
+<P> This macro is used to handle bounded character output functions
+ where both a <TT>char *</TT> and a maximum length parameter are
+ provided. As input, a user simply supplies the maximum length. The
+ return value is assumed to be a NULL-terminated string.</P>
<DIV class="code">
<PRE>
-// Make double *result an output value
-%apply double *OUTPUT { double *result };
-
-// Make Int32 *in an input value
-%apply int *INPUT { Int32 *in };
-
-// Make long *x inout
-%apply long *INOUT {long *x};
-
+%cstring_output_maxsize(char *path, int maxpath);
+...
+void get_path(char *path, int maxpath);
</PRE>
</DIV>
-<P> To clear a rule, the <TT>%clear</TT> directive is used:</P>
-<DIV class="code">
+<P> In the target language:</P>
+<DIV class="targetlang">
<PRE>
-%clear double *result;
-%clear Int32 *in, long *x;
+>>> get_path(1024)
+'/home/beazley/Packages/Foo/Bar'
+>>>
</PRE>
</DIV>
-<P> Typemap declarations are lexically scoped so a typemap takes effect
- from the point of definition to the end of the file or a matching <TT>
-%clear</TT> declaration.</P>
-<H2><A name="Arguments_nn8"></A>9.2 Applying constraints to input values</H2>
-<P> In addition to changing the handling of various input values, it is
- also possible to use typemaps to apply constraints. For example, maybe
- you want to insure that a value is positive, or that a pointer is
- non-NULL. This can be accomplished including the <TT>constraints.i</TT>
- library file.</P>
-<H3><A name="Arguments_nn9"></A>9.2.1 Simple constraint example</H3>
-<P> The constraints library is best illustrated by the following
- interface file :</P>
+<P> This macro provides a safer alternative for functions that need to
+ write string data into a buffer. User supplied buffer size is used to
+ dynamically allocate memory on heap. Results are placed into that
+ buffer and returned as a string object.</P>
+</DIV>
+<P><B> %cstring_output_withsize(parm, maxparm)</B></P>
+<DIV class="indent">
+<P> This macro is used to handle bounded character output functions
+ where both a <TT>char *</TT> and a pointer <TT>int *</TT> are passed.
+ Initially, the <TT>int *</TT> parameter points to a value containing
+ the maximum size. On return, this value is assumed to contain the
+ actual number of bytes. As input, a user simply supplies the maximum
+ length. The output value is a string that may contain binary data.</P>
<DIV class="code">
<PRE>
-// Interface file with constraints
-%module example
-%include "constraints.i"
-
-double exp(double x);
-double log(double POSITIVE); // Allow only positive values
-double sqrt(double NONNEGATIVE); // Non-negative values only
-double inv(double NONZERO); // Non-zero values
-void free(void *NONNULL); // Non-NULL pointers only
-
+%cstring_output_withsize(char *data, int *maxdata);
+...
+void get_data(char *data, int *maxdata);
</PRE>
</DIV>
-<P> The behavior of this file is exactly as you would expect. If any of
- the arguments violate the constraint condition, a scripting language
- exception will be raised. As a result, it is possible to catch bad
- values, prevent mysterious program crashes and so on.</P>
-<H3><A name="Arguments_nn10"></A>9.2.2 Constraint methods</H3>
-<P> The following constraints are currently available</P>
-<DIV class="code">
+<P> In the target language:</P>
+<DIV class="targetlang">
<PRE>
-POSITIVE Any number > 0 (not zero)
-NEGATIVE Any number < 0 (not zero)
-NONNEGATIVE Any number >= 0
-NONPOSITIVE Any number <= 0
-NONZERO Nonzero number
-NONNULL Non-NULL pointer (pointers only).
-
+>>> get_data(1024)
+'x627388912'
+>>> get_data(1024)
+'xyzzy'
+>>>
</PRE>
</DIV>
-<H3><A name="Arguments_nn11"></A>9.2.3 Applying constraints to new
- datatypes</H3>
-<P> The constraints library only supports the primitive C datatypes, but
- it is easy to apply it to new datatypes using <TT>%apply</TT>. For
- example :</P>
+<P> This macro is a somewhat more powerful version of <TT>
+%cstring_output_chunk()</TT>. Memory is dynamically allocated and can be
+ arbitrary large. Furthermore, a function can control how much data is
+ actually returned by changing the value of the <TT>maxparm</TT>
+ argument.</P>
+</DIV>
+<P><B> %cstring_output_allocate(parm, release)</B></P>
+<DIV class="indent">
+<P> This macro is used to return strings that are allocated within the
+ program and returned in a parameter of type <TT>char **</TT>. For
+ example:</P>
<DIV class="code">
<PRE>
-// Apply a constraint to a Real variable
-%apply Number POSITIVE { Real in };
-
-// Apply a constraint to a pointer type
-%apply Pointer NONNULL { Vector * };
-
+void foo(char **s) {
+ *s = (char *) malloc(64);
+ sprintf(*s, "Hello world\n");
+}
</PRE>
</DIV>
-<P> The special types of "Number" and "Pointer" can be applied to any
- numeric and pointer variable type respectively. To later remove a
- constraint, the <TT>%clear</TT> directive can be used :</P>
+<P> The returned string is assumed to be NULL-terminated. <TT><EM>
+release</EM></TT> specifies how the allocated memory is to be released
+ (if applicable). Here is an example:</P>
<DIV class="code">
<PRE>
-%clear Real in;
-%clear Vector *;
+%cstring_output_allocate(char **s, free(*$1));
+...
+void foo(char **s);
</PRE>
-</DIV><HR NOSHADE>
-<H1><A name="Typemaps"></A>10 Typemaps</H1>
-
-<!-- INDEX -->
-<DIV class="sectiontoc">
-<UL>
-<LI><A href="#Typemaps_nn2">Introduction</A>
-<UL>
-<LI><A href="#Typemaps_nn3">Type conversion</A></LI>
-<LI><A href="#Typemaps_nn4">Typemaps</A></LI>
-<LI><A href="#Typemaps_nn5">Pattern matching</A></LI>
-<LI><A href="#Typemaps_nn6">Reusing typemaps</A></LI>
-<LI><A href="#Typemaps_nn7">What can be done with typemaps?</A></LI>
-<LI><A href="#Typemaps_nn8">What can't be done with typemaps?</A></LI>
-<LI><A href="#Typemaps_aspects">Similarities to Aspect Oriented
- Programming</A></LI>
-<LI><A href="#Typemaps_nn9">The rest of this chapter</A></LI>
-</UL>
-</LI>
-<LI><A href="#Typemaps_nn10">Typemap specifications</A>
-<UL>
-<LI><A href="#Typemaps_defining">Defining a typemap</A></LI>
-<LI><A href="#Typemaps_nn12">Typemap scope</A></LI>
-<LI><A href="#Typemaps_nn13">Copying a typemap</A></LI>
-<LI><A href="#Typemaps_nn14">Deleting a typemap</A></LI>
-<LI><A href="#Typemaps_nn15">Placement of typemaps</A></LI>
-</UL>
-</LI>
-<LI><A href="#Typemaps_pattern_matching">Pattern matching rules</A>
-<UL>
-<LI><A href="#Typemaps_nn17">Basic matching rules</A></LI>
-<LI><A href="#Typemaps_typedef_reductions">Typedef reductions matching</A>
-</LI>
-<LI><A href="#Typemaps_nn19">Default typemap matching rules</A></LI>
-<LI><A href="#Typemaps_multi_argument_typemaps_patterns">Multi-arguments
- typemaps</A></LI>
-<LI><A href="#Typemaps_matching_template_comparison">Matching rules
- compared to C++ templates</A></LI>
-<LI><A href="#Typemaps_debugging_search">Debugging typemap pattern
- matching</A></LI>
-</UL>
-</LI>
-<LI><A href="#Typemaps_nn21">Code generation rules</A>
-<UL>
-<LI><A href="#Typemaps_nn22">Scope</A></LI>
-<LI><A href="#Typemaps_nn23">Declaring new local variables</A></LI>
-<LI><A href="#Typemaps_special_variables">Special variables</A></LI>
-<LI><A href="#Typemaps_special_variable_macros">Special variable macros</A>
-<UL>
-<LI><A href="#Typemaps_special_macro_descriptor">$descriptor(type)</A></LI>
-<LI><A href="#Typemaps_special_macro_typemap">$typemap(method,
- typepattern)</A></LI>
-</UL>
-</LI>
-</UL>
-</LI>
-<LI><A href="#Typemaps_nn25">Common typemap methods</A>
-<UL>
-<LI><A href="#Typemaps_nn26">"in" typemap</A></LI>
-<LI><A href="#Typemaps_nn27">"typecheck" typemap</A></LI>
-<LI><A href="#Typemaps_nn28">"out" typemap</A></LI>
-<LI><A href="#Typemaps_nn29">"arginit" typemap</A></LI>
-<LI><A href="#Typemaps_nn30">"default" typemap</A></LI>
-<LI><A href="#Typemaps_nn31">"check" typemap</A></LI>
-<LI><A href="#Typemaps_nn32">"argout" typemap</A></LI>
-<LI><A href="#Typemaps_nn33">"freearg" typemap</A></LI>
-<LI><A href="#Typemaps_nn34">"newfree" typemap</A></LI>
-<LI><A href="#Typemaps_nn35">"memberin" typemap</A></LI>
-<LI><A href="#Typemaps_nn36">"varin" typemap</A></LI>
-<LI><A href="#Typemaps_nn37">"varout" typemap</A></LI>
-<LI><A href="#throws_typemap">"throws" typemap</A></LI>
-</UL>
-</LI>
-<LI><A href="#Typemaps_nn39">Some typemap examples</A>
-<UL>
-<LI><A href="#Typemaps_nn40">Typemaps for arrays</A></LI>
-<LI><A href="#Typemaps_nn41">Implementing constraints with typemaps</A></LI>
-</UL>
-</LI>
-<LI><A href="#Typemaps_nn43">Typemaps for multiple target languages</A></LI>
-<LI><A href="#Typemaps_optimal">Optimal code generation when returning
- by value</A></LI>
-<LI><A href="#Typemaps_multi_argument_typemaps">Multi-argument typemaps</A>
-</LI>
-<LI><A href="#Typemaps_warnings">Typemap warnings</A></LI>
-<LI><A href="#Typemaps_fragments">Typemap fragments</A>
-<UL>
-<LI><A href="#Typemaps_fragment_type_specialization">Fragment type
- specialization</A></LI>
-<LI><A href="#Typemaps_automatic_specialization">Fragments and automatic
- typemap specialization</A></LI>
-</UL>
-</LI>
-<LI><A href="#Typemaps_runtime_type_checker">The run-time type checker</A>
-<UL>
-<LI><A href="#Typemaps_nn45">Implementation</A></LI>
-<LI><A href="#Typemaps_runtime_type_checker_usage">Usage</A></LI>
-</UL>
-</LI>
-<LI><A href="#Typemaps_overloading">Typemaps and overloading</A></LI>
-<LI><A href="#Typemaps_nn48">More about <TT>%apply</TT> and <TT>%clear</TT>
-</A></LI>
-<LI><A href="#Typemaps_nn47">Passing data between typemaps</A></LI>
-<LI><A href="#Typemaps_nn52">C++ "this" pointer</A></LI>
-<LI><A href="#Typemaps_nn51">Where to go for more information?</A></LI>
-</UL>
</DIV>
-<!-- INDEX -->
-<H2><A name="Typemaps_nn2"></A>10.1 Introduction</H2>
-<P> Chances are, you are reading this chapter for one of two reasons;
- you either want to customize SWIG's behavior or you overheard someone
- mumbling some incomprehensible drivel about "typemaps" and you asked
- yourself "typemaps, what are those?" That said, let's start with a
- short disclaimer that "typemaps" are an advanced customization feature
- that provide direct access to SWIG's low-level code generator. Not only
- that, they are an integral part of the SWIG C++ type system (a
- non-trivial topic of its own). Typemaps are generally<EM> not</EM> a
- required part of using SWIG. Therefore, you might want to re-read the
- earlier chapters if you have found your way to this chapter with only a
- vague idea of what SWIG already does by default.</P>
-<H3><A name="Typemaps_nn3"></A>10.1.1 Type conversion</H3>
-<P> One of the most important problems in wrapper code generation is the
- conversion or marshalling of datatypes between programming languages.
- Specifically, for every C/C++ declaration, SWIG must somehow generate
- wrapper code that allows values to be passed back and forth between
- languages. Since every programming language represents data
- differently, this is not a simple of matter of simply linking code
- together with the C linker. Instead, SWIG has to know something about
- how data is represented in each language and how it can be manipulated.</P>
-<P> To illustrate, suppose you had a simple C function like this:</P>
+<P> In the target language:</P>
+<DIV class="targetlang">
+<PRE>
+>>> foo()
+'Hello world\n'
+>>>
+</PRE>
+</DIV></DIV>
+<P><B> %cstring_output_allocate_size(parm, szparm, release)</B></P>
+<DIV class="indent">
+<P> This macro is used to return strings that are allocated within the
+ program and returned in two parameters of type <TT>char **</TT> and <TT>
+int *</TT>. For example:</P>
<DIV class="code">
<PRE>
-int factorial(int n);
+void foo(char **s, int *sz) {
+ *s = (char *) malloc(64);
+ *sz = 64;
+ // Write some binary data
+ ...
+}
</PRE>
</DIV>
-<P> To access this function from Python, a pair of Python API functions
- are used to convert integer values. For example:</P>
+<P> The returned string may contain binary data. <TT><EM>release</EM></TT>
+ specifies how the allocated memory is to be released (if applicable).
+ Here is an example:</P>
<DIV class="code">
<PRE>
-long PyInt_AsLong(PyObject *obj); /* Python --> C */
-PyObject *PyInt_FromLong(long x); /* C --> Python */
+%cstring_output_allocate_size(char **s, int *slen, free(*$1));
+...
+void foo(char **s, int *slen);
</PRE>
</DIV>
-<P> The first function is used to convert the input argument from a
- Python integer object to C <TT>long</TT>. The second function is used
- to convert a value from C back into a Python integer object.</P>
-<P> Inside the wrapper function, you might see these functions used like
- this:</P>
-<DIV class="code">
+<P> In the target language:</P>
+<DIV class="targetlang">
<PRE>
-PyObject *wrap_factorial(PyObject *self, PyObject *args) {
- int arg1;
- int result;
- PyObject *obj1;
- PyObject *resultobj;
-
- if (!PyArg_ParseTuple("O:factorial", &obj1)) return NULL;
- <B>arg1 = PyInt_AsLong(obj1);</B>
- result = factorial(arg1);
- <B>resultobj = PyInt_FromLong(result);</B>
- return resultobj;
-}
+>>> foo()
+'\xa9Y:\xf6\xd7\xe1\x87\xdbH;y\x97\x7f\xd3\x99\x14V\xec\x06\xea\xa2\x88'
+>>>
</PRE>
</DIV>
-<P> Every target language supported by SWIG has functions that work in a
- similar manner. For example, in Perl, the following functions are used:</P>
+<P> This is the safest and most reliable way to return binary string
+ data in SWIG. If you have functions that conform to another prototype,
+ you might consider wrapping them with a helper function. For example,
+ if you had this:</P>
<DIV class="code">
<PRE>
-IV SvIV(SV *sv); /* Perl --> C */
-void sv_setiv(SV *sv, IV val); /* C --> Perl */
+char *get_data(int *len);
</PRE>
</DIV>
-<P> In Tcl:</P>
+<P> You could wrap it with a function like this:</P>
<DIV class="code">
<PRE>
-int Tcl_GetLongFromObj(Tcl_Interp *interp, Tcl_Obj *obj, long *value);
-Tcl_Obj *Tcl_NewIntObj(long value);
+void my_get_data(char **result, int *len) {
+ *result = get_data(len);
+}
</PRE>
-</DIV>
-<P> The precise details are not so important. What is important is that
- all of the underlying type conversion is handled by collections of
- utility functions and short bits of C code like this---you simply have
- to read the extension documentation for your favorite language to know
- how it works (an exercise left to the reader).</P>
-<H3><A name="Typemaps_nn4"></A>10.1.2 Typemaps</H3>
-<P> Since type handling is so central to wrapper code generation, SWIG
- allows it to be completely defined (or redefined) by the user. To do
- this, a special <TT>%typemap</TT> directive is used. For example:</P>
+</DIV></DIV>
+<P><B> Comments:</B></P>
+<UL>
+<LI>Support for the <TT>cstring.i</TT> module depends on the target
+ language. Not all SWIG modules currently support this library.</LI>
+<LI>Reliable handling of raw C strings is a delicate topic. There are
+ many ways to accomplish this in SWIG. This library provides support for
+ a few common techniques.</LI>
+<LI>If used in C++, this library uses <TT>new</TT> and <TT>delete []</TT>
+ for memory allocation. If using ANSI C, the library uses <TT>malloc()</TT>
+ and <TT>free()</TT>.</LI>
+<LI>Rather than manipulating <TT>char *</TT> directly, you might
+ consider using a special string structure or class instead.</LI>
+</UL>
+<H2><A name="Library_stl_cpp_library">9.4 STL/C++ Library</A></H2>
+<P> The library modules in this section provide access to parts of the
+ standard C++ library including the STL. SWIG support for the STL is an
+ ongoing effort. Support is quite comprehensive for some language
+ modules but some of the lesser used modules do not have quite as much
+ library code written.</P>
+<P> The following table shows which C++ classes are supported and the
+ equivalent SWIG interface library file for the C++ library.</P>
+<TABLE BORDER summary="SWIG C++ library files">
+<TR VALIGN="TOP"><TD><B>C++ class</B></TD><TD><B>C++ Library file</B></TD><TD>
+<B>SWIG Interface library file</B></TD></TR>
+<TR><TD>std::auto_ptr</TD><TD>memory</TD><TD>std_auto_ptr.i</TD></TR>
+<TR><TD>std::deque</TD><TD>deque</TD><TD>std_deque.i</TD></TR>
+<TR><TD>std::list</TD><TD>list</TD><TD>std_list.i</TD></TR>
+<TR><TD>std::map</TD><TD>map</TD><TD>std_map.i</TD></TR>
+<TR><TD>std::pair</TD><TD>utility</TD><TD>std_pair.i</TD></TR>
+<TR><TD>std::set</TD><TD>set</TD><TD>std_set.i</TD></TR>
+<TR><TD>std::string</TD><TD>string</TD><TD>std_string.i</TD></TR>
+<TR><TD>std::vector</TD><TD>vector</TD><TD>std_vector.i</TD></TR>
+<TR><TD>std::array</TD><TD>array (C++11)</TD><TD>std_array.i</TD></TR>
+<TR><TD>std::shared_ptr</TD><TD>shared_ptr (C++11)</TD><TD>
+std_shared_ptr.i</TD></TR>
+</TABLE>
+<P> The list is by no means complete; some language modules support a
+ subset of the above and some support additional STL classes. Please
+ look for the library files in the appropriate language library
+ directory.</P>
+<H3><A name="Library_std_string">9.4.1 std::string</A></H3>
+<P> The <TT>std_string.i</TT> library provides typemaps for converting
+ C++ <TT>std::string</TT> objects to and from strings in the target
+ scripting language. For example:</P>
<DIV class="code">
<PRE>
-/* Convert from Python --> C */
-%typemap(in) int {
- $1 = PyInt_AsLong($input);
-}
+%module example
+%include "std_string.i"
-/* Convert from C --> Python */
-%typemap(out) int {
- $result = PyInt_FromLong($1);
-}
+std::string foo();
+void bar(const std::string &x);
</PRE>
</DIV>
-<P> At first glance, this code will look a little confusing. However,
- there is really not much to it. The first typemap (the "in" typemap) is
- used to convert a value from the target language to C. The second
- typemap (the "out" typemap) is used to convert in the other direction.
- The content of each typemap is a small fragment of code that is
- inserted directly into the SWIG generated wrapper functions. The code
- is usually C or C++ code which will be generated into the C/C++ wrapper
- functions. Note that this isn't always the case as some target language
- modules allow target language code within the typemaps which gets
- generated into target language specific files. Within this code, a
- number of special variables prefixed with a $ are expanded. These are
- really just placeholders for C/C++ variables that are generated in the
- course of creating the wrapper function. In this case, <TT>$input</TT>
- refers to an input object that needs to be converted to C/C++ and <TT>
-$result</TT> refers to an object that is going to be returned by a
- wrapper function. <TT>$1</TT> refers to a C/C++ variable that has the
- same type as specified in the typemap declaration (an <TT>int</TT> in
- this example).</P>
-<P> A short example might make this a little more clear. If you were
- wrapping a function like this:</P>
-<DIV class="code">
+<P> In the target language:</P>
+<DIV class="targetlang">
<PRE>
-int gcd(int x, int y);
+x = foo(); # Returns a string object
+bar("Hello World"); # Pass string as std::string
</PRE>
</DIV>
-<P> A wrapper function would look approximately like this:</P>
+<P> A common problem that people encounter is that of classes/structures
+ containing a <TT>std::string</TT>. This can be overcome by defining a
+ typemap. For example:</P>
<DIV class="code">
<PRE>
-PyObject *wrap_gcd(PyObject *self, PyObject *args) {
- int arg1;
- int arg2;
- int result;
- PyObject *obj1;
- PyObject *obj2;
- PyObject *resultobj;
-
- if (!PyArg_ParseTuple("OO:gcd", &obj1, &obj2)) return NULL;
+%module example
+%include "std_string.i"
- /* "in" typemap, argument 1 */<B>
- {
- arg1 = PyInt_AsLong(obj1);
- }
-</B>
- /* "in" typemap, argument 2 */<B>
- {
- arg2 = PyInt_AsLong(obj2);
- }
-</B>
- result = gcd(arg1,arg2);
+%apply const std::string& {std::string* foo};
- /* "out" typemap, return value */<B>
- {
- resultobj = PyInt_FromLong(result);
- }
-</B>
- return resultobj;
-}
+struct my_struct
+{
+ std::string foo;
+};
</PRE>
</DIV>
-<P> In this code, you can see how the typemap code has been inserted
- into the function. You can also see how the special $ variables have
- been expanded to match certain variable names inside the wrapper
- function. This is really the whole idea behind typemaps--they simply
- let you insert arbitrary code into different parts of the generated
- wrapper functions. Because arbitrary code can be inserted, it possible
- to completely change the way in which values are converted.</P>
-<H3><A name="Typemaps_nn5"></A>10.1.3 Pattern matching</H3>
-<P> As the name implies, the purpose of a typemap is to "map" C
- datatypes to types in the target language. Once a typemap is defined
- for a C datatype, it is applied to all future occurrences of that type
- in the input file. For example:</P>
+<P> In the target language:</P>
+<DIV class="targetlang">
+<PRE>
+x = my_struct();
+x.foo="Hello World"; # assign with string
+print x.foo; # print as string
+</PRE>
+</DIV>
+<P> This module only supports types <TT>std::string</TT> and <TT>const
+ std::string &</TT>. Pointers and non-const references are left
+ unmodified and returned as SWIG pointers.</P>
+<P> This library file is fully aware of C++ namespaces. If you export <TT>
+std::string</TT> or rename it with a typedef, make sure you include
+ those declarations in your interface. For example:</P>
<DIV class="code">
<PRE>
-/* Convert from Perl --> C */
-%typemap(in) <B>int</B> {
- $1 = SvIV($input);
-}
+%module example
+%include "std_string.i"
+using namespace std;
+typedef std::string String;
...
-int factorial(<B>int</B> n);
-int gcd(<B>int</B> x, <B>int</B> y);
-int count(char *s, char *t, <B>int</B> max);
+void foo(string s, const String &t); // std_string typemaps still applied
</PRE>
</DIV>
-<P> The matching of typemaps to C datatypes is more than a simple
- textual match. In fact, typemaps are fully built into the underlying
- type system. Therefore, typemaps are unaffected by <TT>typedef</TT>,
- namespaces, and other declarations that might hide the underlying type.
- For example, you could have code like this:</P>
+<H3><A name="Library_std_vector">9.4.2 std::vector</A></H3>
+<P> The <TT>std_vector.i</TT> library provides support for the C++ <TT>
+std::vector</TT> class in the STL. Using this library involves the use
+ of the <TT>%template</TT> directive. All you need to do is to
+ instantiate different versions of <TT>vector</TT> for the types that
+ you want to use. For example:</P>
<DIV class="code">
<PRE>
-/* Convert from Ruby--> C */
-%typemap(in) <B>int</B> {
- $1 = NUM2INT($input);
-}
-...
-typedef int Integer;
-namespace foo {
- typedef Integer Number;
-};
+%module example
+%include "std_vector.i"
-int foo(<B>int</B> x);
-int bar(<B>Integer</B> y);
-int spam(<B>foo::Number</B> a, <B>foo::Number</B> b);
+namespace std {
+ %template(vectori) vector<int>;
+ %template(vectord) vector<double>;
+};
</PRE>
</DIV>
-<P> In this case, the typemap is still applied to the proper arguments
- even though typenames don't always match the text "int". This ability
- to track types is a critical part of SWIG--in fact, all of the target
- language modules work merely define a set of typemaps for the basic
- types. Yet, it is never necessary to write new typemaps for typenames
- introduced by <TT>typedef</TT>.</P>
-<P> In addition to tracking typenames, typemaps may also be specialized
- to match against a specific argument name. For example, you could write
- a typemap like this:</P>
+<P> When a template <TT>vector<X></TT> is instantiated a number of
+ things happen:</P>
+<UL>
+<LI>A class that exposes the C++ API is created in the target language .
+ This can be used to create objects, invoke methods, etc. This class is
+ currently a subset of the real STL vector class.</LI>
+<LI>Input typemaps are defined for <TT>vector<X></TT>, <TT>const
+ vector<X> &</TT>, and <TT>const vector<X> *</TT>. For each of these, a
+ pointer <TT>vector<X> *</TT> may be passed or a native list object in
+ the target language.</LI>
+<LI>An output typemap is defined for <TT>vector<X></TT>. In this case,
+ the values in the vector are expanded into a list object in the target
+ language.</LI>
+<LI>For all other variations of the type, the wrappers expect to receive
+ a <TT>vector<X> *</TT> object in the usual manner.</LI>
+<LI>An exception handler for <TT>std::out_of_range</TT> is defined.</LI>
+<LI>Optionally, special methods for indexing, item retrieval, slicing,
+ and element assignment may be defined. This depends on the target
+ language.</LI>
+</UL>
+<P> To illustrate the use of this library, consider the following
+ functions:</P>
<DIV class="code">
<PRE>
-%typemap(in) <B>double nonnegative</B> {
- $1 = PyFloat_AsDouble($input);
- if ($1 < 0) {
- PyErr_SetString(PyExc_ValueError,"argument must be nonnegative.");
- return NULL;
- }
+/* File : example.h */
+
+#include <vector>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+
+double average(std::vector<int> v) {
+ return std::accumulate(v.begin(),v.end(),0.0)/v.size();
}
-...
-double sin(double x);
-double cos(double x);
-double sqrt(<B>double nonnegative</B>);
+std::vector<double> half(const std::vector<double>& v) {
+ std::vector<double> w(v);
+ for (unsigned int i=0; i<w.size(); i++)
+ w[i] /= 2.0;
+ return w;
+}
-typedef double Real;
-double log(<B>Real nonnegative</B>);
-...
+void halve_in_place(std::vector<double>& v) {
+ std::transform(v.begin(),v.end(),v.begin(),
+ std::bind2nd(std::divides<double>(),2.0));
+}
</PRE>
</DIV>
-<P> For certain tasks such as input argument conversion, typemaps can be
- defined for sequences of consecutive arguments. For example:</P>
+<P> To wrap with SWIG, you might write the following:</P>
<DIV class="code">
<PRE>
-%typemap(in) (<B>char *str, int len</B>) {
- $1 = PyString_AsString($input); /* char *str */
- $2 = PyString_Size($input); /* int len */
+%module example
+%{
+#include "example.h"
+%}
+
+%include "std_vector.i"
+// Instantiate templates used by example
+namespace std {
+ %template(IntVector) vector<int>;
+ %template(DoubleVector) vector<double>;
}
-...
-int count(<B>char *str, int len</B>, char c);
+
+// Include the header file with above prototypes
+%include "example.h"
</PRE>
</DIV>
-<P> In this case, a single input object is expanded into a pair of C
- arguments. This example also provides a hint to the unusual variable
- naming scheme involving <TT>$1</TT>, <TT>$2</TT>, and so forth.</P>
-<H3><A name="Typemaps_nn6"></A>10.1.4 Reusing typemaps</H3>
-<P> Typemaps are normally defined for specific type and argument name
- patterns. However, typemaps can also be copied and reused. One way to
- do this is to use assignment like this:</P>
-<DIV class="code">
+<P> Now, to illustrate the behavior in the scripting interpreter,
+ consider this Python example:</P>
+<DIV class="targetlang">
<PRE>
-%typemap(in) Integer = int;
-%typemap(in) (char *buffer, int size) = (char *str, int len);
+>>> from example import *
+>>> iv = IntVector(4) # Create an vector<int>
+>>> for i in range(0,4):
+... iv[i] = i
+>>> average(iv) # Call method
+1.5
+>>> average([0,1,2,3]) # Call with list
+1.5
+>>> half([1,2,3]) # Half a list
+(0.5,1.0,1.5)
+>>> halve_in_place([1,2,3]) # Oops
+Traceback (most recent call last):
+ File "<stdin>", line 1, in ?
+TypeError: Type error. Expected _p_std__vectorTdouble_t
+>>> dv = DoubleVector(4)
+>>> for i in range(0,4):
+... dv[i] = i
+>>> halve_in_place(dv) # Ok
+>>> for i in dv:
+... print i
+...
+0.0
+0.5
+1.0
+1.5
+>>> dv[20] = 4.5
+Traceback (most recent call last):
+ File "<stdin>", line 1, in ?
+ File "example.py", line 81, in __setitem__
+ def __setitem__(*args): return apply(examplec.DoubleVector___setitem__,args)
+IndexError: vector index out of range
+>>>
</PRE>
</DIV>
-<P> A more general form of copying is found in the <TT>%apply</TT>
- directive like this:</P>
+<P> This library module is fully aware of C++ namespaces. If you use
+ vectors with other names, make sure you include the appropriate <TT>
+using</TT> or typedef directives. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) int {
- /* Convert an integer argument */
- ...
-}
-%typemap(out) int {
- /* Return an integer value */
- ...
+%include "std_vector.i"
+
+namespace std {
+ %template(IntVector) vector<int>;
}
-/* Apply all of the integer typemaps to size_t */
-%apply int { size_t };
+using namespace std;
+typedef std::vector Vector;
+
+void foo(vector<int> *x, const Vector &x);
</PRE>
</DIV>
-<P> <TT>%apply</TT> merely takes<EM> all</EM> of the typemaps that are
- defined for one type and applies them to other types. Note: you can
- include a comma separated set of types in the <TT>{ ... }</TT> part of <TT>
-%apply</TT>.</P>
-<P> It should be noted that it is not necessary to copy typemaps for
- types that are related by <TT>typedef</TT>. For example, if you have
- this,</P>
+<P><B> Note:</B> This module makes use of several advanced SWIG features
+ including templatized typemaps and template partial specialization. If
+ you are trying to wrap other C++ code with templates, you might look at
+ the code contained in <TT>std_vector.i</TT>. Alternatively, you can
+ show them the code if you want to make their head explode.</P>
+<P><B> Note:</B> This module is defined for all SWIG target languages.
+ However argument conversion details and the public API exposed to the
+ interpreter vary.</P>
+<H3><A name="Library_stl_exceptions">9.4.3 STL exceptions</A></H3>
+<P> Many of the STL wrapper functions add parameter checking and will
+ throw a language dependent error/exception should the values not be
+ valid. The classic example is array bounds checking. The library
+ wrappers are written to throw a C++ exception in the case of error. The
+ C++ exception in turn gets converted into an appropriate
+ error/exception for the target language. By and large this handling
+ should not need customising, however, customisation can easily be
+ achieved by supplying appropriate "throws" typemaps. For example:</P>
<DIV class="code">
<PRE>
-typedef int size_t;
+%module example
+%include "std_vector.i"
+%typemap(throws) std::out_of_range {
+ // custom exception handler
+}
+%template(VectInt) std::vector<int>;
</PRE>
</DIV>
-<P> then SWIG already knows that the <TT>int</TT> typemaps apply. You
- don't have to do anything.</P>
-<H3><A name="Typemaps_nn7"></A>10.1.5 What can be done with typemaps?</H3>
-<P> The primary use of typemaps is for defining wrapper generation
- behavior at the level of individual C/C++ datatypes. There are
- currently six general categories of problems that typemaps address:</P>
-<P><B> Argument handling</B></P>
+<P> The custom exception handler might, for example, log the exception
+ then convert it into a specific error/exception for the target
+ language.</P>
+<P> When using the STL it is advisable to add in an exception handler to
+ catch all STL exceptions. The <TT>%exception</TT> directive can be used
+ by placing the following code before any other methods or libraries to
+ be wrapped:</P>
<DIV class="code">
<PRE>
-int foo(<B>int x, double y, char *s</B>);
+%include "exception.i"
+
+%exception {
+ try {
+ $action
+ } catch (const std::exception& e) {
+ SWIG_exception(SWIG_RuntimeError, e.what());
+ }
+}
</PRE>
</DIV>
-<UL>
-<LI>Input argument conversion ("in" typemap).</LI>
-<LI>Input argument type checking ("typecheck" typemap).</LI>
-<LI>Output argument handling ("argout" typemap).</LI>
-<LI>Input argument value checking ("check" typemap).</LI>
-<LI>Input argument initialization ("arginit" typemap).</LI>
-<LI>Default arguments ("default" typemap).</LI>
-<LI>Input argument resource management ("freearg" typemap).</LI>
-</UL>
-<P><B> Return value handling</B></P>
+<P> Any thrown STL exceptions will then be gracefully handled instead of
+ causing a crash.</P>
+<H3><A name="Library_std_shared_ptr">9.4.4 shared_ptr smart pointer</A></H3>
+<P> Some target languages have support for handling the shared_ptr
+ reference counted smart pointer. This smart pointer is available in the
+ standard C++11 library as <TT>std::shared_ptr</TT>. It was also in TR1
+ as <TT>std::tr1::shared_ptr</TT> before it was fully standardized.
+ Support for the widely used <TT>boost::shared_ptr</TT> is also
+ available.</P>
+<P> In order to use <TT>std::shared_ptr</TT>, the <TT>std_shared_ptr.i</TT>
+ library file should be included:</P>
<DIV class="code">
<PRE>
-<B>int</B> foo(int x, double y, char *s);
+%include <std_shared_ptr.i>
</PRE>
</DIV>
-<UL>
-<LI>Function return value conversion ("out" typemap).</LI>
-<LI>Return value resource management ("ret" typemap).</LI>
-<LI>Resource management for newly allocated objects ("newfree" typemap).</LI>
-</UL>
-<P><B> Exception handling</B></P>
+<P> The pre-standard <TT>std::tr1::shared_ptr</TT> can be used by
+ including the following macro before including the <TT>std_shared_ptr.i</TT>
+ library file:</P>
<DIV class="code">
<PRE>
-<B>int</B> foo(int x, double y, char *s) throw(<B>MemoryError, IndexError</B>);
+#define SWIG_SHARED_PTR_SUBNAMESPACE tr1
+%include <std_shared_ptr.i>
</PRE>
</DIV>
-<UL>
-<LI>Handling of C++ exception specifications. ("throw" typemap).</LI>
-</UL>
-<P><B> Global variables</B></P>
+<P> In order to use <TT>boost::shared_ptr</TT>, the <TT>
+boost_shared_ptr.i</TT> library file should be included:</P>
<DIV class="code">
<PRE>
-<B>int foo;</B>
+%include <boost_shared_ptr.i>
</PRE>
</DIV>
-<UL>
-<LI>Assignment of a global variable. ("varin" typemap).</LI>
-<LI>Reading a global variable. ("varout" typemap).</LI>
-</UL>
-<P><B> Member variables</B></P>
+<P> You can only use one of these variants of shared_ptr in your
+ interface file at a time. and all three variants must be used in
+ conjunction with the <TT>%shared_ptr(T)</TT> macro, where <TT>T</TT> is
+ the underlying pointer type equating to usage <TT>shared_ptr<T></TT>.
+ The type <TT>T</TT> must be non-primitive. A simple example
+ demonstrates usage:</P>
<DIV class="code">
<PRE>
-struct Foo {
- <B>int x[20]</B>;
+%module example
+%include <boost_shared_ptr.i>
+%shared_ptr(IntValue)
+
+%inline %{
+#include <boost/shared_ptr.hpp>
+
+struct IntValue {
+ int value;
+ IntValue(int v) : value(v) {}
};
+
+static int extractValue(const IntValue &t) {
+ return t.value;
+}
+
+static int extractValueSmart(boost::shared_ptr<IntValue> t) {
+ return t->value;
+}
+%}
</PRE>
</DIV>
-<UL>
-<LI>Assignment of data to a class/structure member. ("memberin"
- typemap).</LI>
-</UL>
-<P><B> Constant creation</B></P>
-<DIV class="code">
+<P> Note that the <TT>%shared_ptr(IntValue)</TT> declaration occurs
+ after the inclusion of the <TT>boost_shared_ptr.i</TT> library which
+ provides the macro and, very importantly, before any usage or
+ declaration of the type, <TT>IntValue</TT>. The <TT>%shared_ptr</TT>
+ macro provides, a few things for handling this smart pointer, but
+ mostly a number of typemaps. These typemaps override the default
+ typemaps so that the underlying proxy class is stored and passed around
+ as a pointer to a <TT>shared_ptr</TT> instead of a plain pointer to the
+ underlying type. This approach means that any instantiation of the type
+ can be passed to methods taking the type by value, reference, pointer
+ or as a smart pointer. The interested reader might want to look at the
+ generated code, however, usage is simple and no different handling is
+ required from the target language. For example, a simple use case of
+ the above code from Java would be:</P>
+<DIV class="targetlang">
<PRE>
-#define FOO 3
-%constant int BAR = 42;
-enum { ALE, LAGER, STOUT };
+IntValue iv = new IntValue(1234);
+int val1 = example.extractValue(iv);
+int val2 = example.extractValueSmart(iv);
+System.out.println(val1 + " " + val2);
</PRE>
</DIV>
-<UL>
-<LI>Creation of constant values. ("consttab" or "constcode" typemap).</LI>
-</UL>
-<P> Details of each of these typemaps will be covered shortly. Also,
- certain language modules may define additional typemaps that expand
- upon this list. For example, the Java module defines a variety of
- typemaps for controlling additional aspects of the Java bindings.
- Consult language specific documentation for further details.</P>
-<H3><A name="Typemaps_nn8"></A>10.1.6 What can't be done with typemaps?</H3>
-<P> Typemaps can't be used to define properties that apply to C/C++
- declarations as a whole. For example, suppose you had a declaration
- like this,</P>
+<P> This shared_ptr library works quite differently to SWIG's normal,
+ but somewhat limited, <A href="#SWIGPlus_smart_pointers">smart pointer
+ handling</A>. The shared_ptr library does not generate extra wrappers,
+ just for smart pointer handling, in addition to the proxy class. The
+ normal proxy class including inheritance relationships is generated as
+ usual. The only real change introduced by the <TT>%shared_ptr</TT>
+ macro is that the proxy class stores a pointer to the shared_ptr
+ instance instead of a raw pointer to the instance. A proxy class
+ derived from a base which is being wrapped with shared_ptr can and<B>
+ must</B> be wrapped as a shared_ptr too. In other words all classes in
+ an inheritance hierarchy must all be used with the <TT>%shared_ptr</TT>
+ macro. For example the following code can be used with the base class
+ shown earlier:</P>
<DIV class="code">
<PRE>
-Foo *make_Foo(int n);
-</PRE>
-</DIV>
-<P> and you wanted to tell SWIG that <TT>make_Foo(int n)</TT> returned a
- newly allocated object (for the purposes of providing better memory
- management). Clearly, this property of <TT>make_Foo(int n)</TT> is<EM>
- not</EM> a property that would be associated with the datatype <TT>Foo
- *</TT> by itself. Therefore, a completely different SWIG customization
- mechanism (<TT>%feature</TT>) is used for this purpose. Consult the <A href="#Customization">
-Customization Features</A> chapter for more information about that.</P>
-<P> Typemaps also can't be used to rearrange or transform the order of
- arguments. For example, if you had a function like this:</P>
-<DIV class="code">
-<PRE>
-void foo(int, char *);
+%shared_ptr(DerivedIntValue)
+%inline %{
+struct DerivedIntValue : IntValue {
+ DerivedIntValue(int value) : IntValue(value) {}
+ ...
+};
+%}
</PRE>
</DIV>
-<P> you can't use typemaps to interchange the arguments, allowing you to
- call the function like this:</P>
+<P> A shared_ptr of the derived class can now be passed to a method
+ where the base is expected in the target language, just as it can in
+ C++:</P>
<DIV class="targetlang">
<PRE>
-foo("hello",3) # Reversed arguments
+DerivedIntValue div = new DerivedIntValue(5678);
+int val3 = example.extractValue(div);
+int val4 = example.extractValueSmart(div);
</PRE>
</DIV>
-<P> If you want to change the calling conventions of a function, write a
- helper function instead. For example:</P>
+<P> If the <TT>%shared_ptr</TT> macro is omitted for any class in the
+ inheritance hierarchy, SWIG will warn about this and the generated code
+ may or may not result in a C++ compilation error. For example, the
+ following input:</P>
<DIV class="code">
<PRE>
-%rename(foo) wrap_foo;
+%include "boost_shared_ptr.i"
+%shared_ptr(Parent);
+
%inline %{
-void wrap_foo(char *s, int x) {
- foo(x,s);
-}
+ #include <boost/shared_ptr.hpp>
+ struct GrandParent {
+ virtual ~GrandParent() {}
+ };
+
+ struct Parent : GrandParent {
+ virtual ~Parent() {}
+ };
+
+ struct Child : Parent {
+ virtual ~Child() {}
+ };
%}
</PRE>
</DIV>
-<H3><A name="Typemaps_aspects"></A>10.1.7 Similarities to Aspect
- Oriented Programming</H3>
-<P> SWIG has parallels to <A href="http://en.wikipedia.org/wiki/Aspect-oriented_programming">
-Aspect Oriented Software Development (AOP)</A>. The <A href="http://en.wikipedia.org/wiki/Aspect-oriented_programming#Terminology">
-AOP terminology</A> with respect to SWIG typemaps can be viewed as
- follows:</P>
-<UL>
-<LI><B> Cross-cutting concerns</B>: The cross-cutting concerns are the
- modularization of the functionality that the typemaps implement, which
- is primarily marshalling of types from/to the target language and
- C/C++.</LI>
-<LI><B> Advice</B>: The typemap body contains code which is executed
- whenever the marshalling is required.</LI>
-<LI><B> Pointcut</B>: The pointcuts are the positions in the wrapper
- code that the typemap code is generated into.</LI>
-<LI><B> Aspect</B>: Aspects are the combination of the pointcut and the
- advice, hence each typemap is an aspect.</LI>
-</UL>
-<P> SWIG can also be viewed as has having a second set of aspects based
- around <A href="Customization.html">%feature</A>. Features such as <TT>
-%exception</TT> are also cross-cutting concerns as they encapsulate code
- that can be used to add logging or exception handling to any function.</P>
-<H3><A name="Typemaps_nn9"></A>10.1.8 The rest of this chapter</H3>
-<P> The rest of this chapter provides detailed information for people
- who want to write new typemaps. This information is of particular
- importance to anyone who intends to write a new SWIG target language
- module. Power users can also use this information to write application
- specific type conversion rules.</P>
-<P> Since typemaps are strongly tied to the underlying C++ type system,
- subsequent sections assume that you are reasonably familiar with the
- basic details of values, pointers, references, arrays, type qualifiers
- (e.g., <TT>const</TT>), structures, namespaces, templates, and memory
- management in C/C++. If not, you would be well-advised to consult a
- copy of "The C Programming Language" by Kernighan and Ritchie or "The
- C++ Programming Language" by Stroustrup before going any further.</P>
-<H2><A name="Typemaps_nn10"></A>10.2 Typemap specifications</H2>
-<P> This section describes the behavior of the <TT>%typemap</TT>
- directive itself.</P>
-<H3><A name="Typemaps_defining"></A>10.2.1 Defining a typemap</H3>
-<P> New typemaps are defined using the <TT>%typemap</TT> declaration.
- The general form of this declaration is as follows (parts enclosed in [
- ... ] are optional):</P>
+<P> warns about the missing smart pointer information:</P>
+<DIV class="shell">
+<PRE>
+example.i:12: Warning 520: Base class 'GrandParent' of 'Parent' is not similarly marked as a smart pointer.
+example.i:16: Warning 520: Derived class 'Child' of 'Parent' is not similarly marked as a smart pointer.
+</PRE>
+</DIV>
+<P> Adding the missing <TT>%shared_ptr</TT> macros will fix this:</P>
<DIV class="code">
<PRE>
-%typemap(<EM>method</EM> [, <EM>modifiers</EM>]) <EM>typelist</EM> <EM>code</EM> ;
+%include "boost_shared_ptr.i"
+%shared_ptr(GrandParent);
+%shared_ptr(Parent);
+%shared_ptr(Child);
+
+... as before ...
</PRE>
</DIV>
-<P><EM> method</EM> is a simply a name that specifies what kind of
- typemap is being defined. It is usually a name like <TT>"in"</TT>, <TT>
-"out"</TT>, or <TT>"argout"</TT>. The purpose of these methods is
- described later.</P>
-<P><EM> modifiers</EM> is an optional comma separated list of <TT>
-name="value"</TT> values. These are sometimes to attach extra
- information to a typemap and is often target-language dependent. They
- are also known as typemap attributes.</P>
-<P><EM> typelist</EM> is a list of the C++ type patterns that the
- typemap will match. The general form of this list is as follows:</P>
-<DIV class="diagram">
+<P><B> Note:</B> There is somewhat limited support for <TT>%shared_ptr</TT>
+ and the director feature and the degress of success varies among the
+ different target languages. Please help to improve this support by
+ providing patches with improvements.</P>
+<H3><A name="Library_std_auto_ptr">9.4.5 auto_ptr smart pointer</A></H3>
+<P> While <TT>std::auto_ptr</TT> is deprecated in C++11, some existing
+ code may still be using it, so SWIG provides limited support for this
+ class: <TT>std_auto_ptr.i</TT> defines the typemaps which apply to the
+ functions returning objects of this type. Any other use of <TT>
+std_auto_ptr.i</TT> is not directly supported.</P>
+<P> A typical example of use would be</P>
+<DIV class="code">
<PRE>
-typelist : typepattern [, typepattern, typepattern, ... ] ;
+%include <std_auto_ptr.i>
-typepattern : type [ (parms) ]
- | type name [ (parms) ]
- | ( typelist ) [ (parms) ]
+%auto_ptr(Klass)
+%inline %{
+class Klass {
+public:
+ // Factory function creating objects of this class:
+ static std::auto_ptr<Klass> Create(int value) {
+ return std::auto_ptr<Klass>(new Klass(value));
+ }
+ int getValue() const { return m_value; }
+
+private:
+ DerivedIntValue(int value) : m_value(value) {}
+ int m_value;
+};
+%}
</PRE>
</DIV>
-<P> Each type pattern is either a simple type, a simple type and
- argument name, or a list of types in the case of multi-argument
- typemaps. In addition, each type pattern can be parameterized with a
- list of temporary variables (parms). The purpose of these variables
- will be explained shortly.</P>
-<P><EM>code</EM> specifies the code used in the typemap. Usually this is
- C/C++ code, but in the statically typed target languages, such as Java
- and C#, this can contain target language code for certain typemaps. It
- can take any one of the following forms:</P>
-<DIV class="diagram">
+<P> The returned objects can be used naturally from the target language,
+ e.g. from C#:</P>
+<DIV class="targetlang">
<PRE>
-code : { ... }
- | " ... "
- | %{ ... %}
+Klass k = Klass.Create(17);
+int value = k.getValue();
</PRE>
</DIV>
-<P> Note that the preprocessor will expand code within the {}
- delimiters, but not in the last two styles of delimiters, see <A href="#Preprocessor_typemap_delimiters">
-Preprocessor and Typemaps</A>. Here are some examples of valid typemap
- specifications:</P>
+<H2><A name="Library_nn16">9.5 Utility Libraries</A></H2>
+<H3><A name="Library_nn17">9.5.1 exception.i</A></H3>
+<P> The <TT>exception.i</TT> library provides a language-independent
+ function for raising a run-time exception in the target language. This
+ library is largely used by the SWIG library writers. If possible, use
+ the error handling scheme available to your target language as there is
+ greater flexibility in what errors/exceptions can be thrown.</P>
+<P><B> <TT>SWIG_exception(int code, const char *message)</TT></B></P>
+<DIV class="indent">
+<P> Raises an exception in the target language. <TT>code</TT> is one of
+ the following symbolic constants:</P>
<DIV class="code">
<PRE>
-/* Simple typemap declarations */
-%typemap(in) int {
- $1 = PyInt_AsLong($input);
-}
-%typemap(in) int "$1 = PyInt_AsLong($input);";
-%typemap(in) int %{
- $1 = PyInt_AsLong($input);
-%}
-
-/* Typemap with extra argument name */
-%typemap(in) int nonnegative {
- ...
-}
-
-/* Multiple types in one typemap */
-%typemap(in) int, short, long {
- $1 = SvIV($input);
+SWIG_MemoryError
+SWIG_IOError
+SWIG_RuntimeError
+SWIG_IndexError
+SWIG_TypeError
+SWIG_DivisionByZero
+SWIG_OverflowError
+SWIG_SyntaxError
+SWIG_ValueError
+SWIG_SystemError
+</PRE>
+</DIV>
+<P> <TT>message</TT> is a string indicating more information about the
+ problem.</P>
+</DIV>
+<P> The primary use of this module is in writing language-independent
+ exception handlers. For example:</P>
+<DIV class="code">
+<PRE>
+%include "exception.i"
+%exception std::vector::getitem {
+ try {
+ $action
+ } catch (std::out_of_range& e) {
+ SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
+ }
}
+</PRE>
+</DIV><HR NOSHADE>
+<H1><A name="Arguments">10 Argument Handling</A></H1>
-/* Typemap with modifiers */
-%typemap(in,doc="integer") int "$1 = scm_to_int($input);";
-
-/* Typemap applied to patterns of multiple arguments */
-%typemap(in) (char *str, int len),
- (char *buffer, int size)
-{
- $1 = PyString_AsString($input);
- $2 = PyString_Size($input);
+<!-- INDEX -->
+<DIV class="sectiontoc">
+<UL>
+<LI><A href="#Arguments_nn2">The typemaps.i library</A>
+<UL>
+<LI><A href="#Arguments_nn3">Introduction</A></LI>
+<LI><A href="#Arguments_nn4">Input parameters</A></LI>
+<LI><A href="#Arguments_nn5">Output parameters</A></LI>
+<LI><A href="#Arguments_nn6">Input/Output parameters</A></LI>
+<LI><A href="#Arguments_nn7">Using different names</A></LI>
+</UL>
+</LI>
+<LI><A href="#Arguments_nn8">Applying constraints to input values</A>
+<UL>
+<LI><A href="#Arguments_nn9">Simple constraint example</A></LI>
+<LI><A href="#Arguments_nn10">Constraint methods</A></LI>
+<LI><A href="#Arguments_nn11">Applying constraints to new datatypes</A></LI>
+</UL>
+</LI>
+</UL>
+</DIV>
+<!-- INDEX -->
+<P> In Chapter 3, SWIG's treatment of basic datatypes and pointers was
+ described. In particular, primitive types such as <TT>int</TT> and <TT>
+double</TT> are mapped to corresponding types in the target language.
+ For everything else, pointers are used to refer to structures, classes,
+ arrays, and other user-defined datatypes. However, in certain
+ applications it is desirable to change SWIG's handling of a specific
+ datatype. For example, you might want to return multiple values through
+ the arguments of a function. This chapter describes some of the
+ techniques for doing this.</P>
+<H2><A name="Arguments_nn2">10.1 The typemaps.i library</A></H2>
+<P> This section describes the <TT>typemaps.i</TT> library
+ file--commonly used to change certain properties of argument
+ conversion.</P>
+<H3><A name="Arguments_nn3">10.1.1 Introduction</A></H3>
+<P> Suppose you had a C function like this:</P>
+<DIV class="code">
+<PRE>
+void add(double a, double b, double *result) {
+ *result = a + b;
}
+</PRE>
+</DIV>
+<P> From reading the source code, it is clear that the function is
+ storing a value in the <TT>double *result</TT> parameter. However,
+ since SWIG does not examine function bodies, it has no way to know that
+ this is the underlying behavior.</P>
+<P> One way to deal with this is to use the <TT>typemaps.i</TT> library
+ file and write interface code like this:</P>
+<DIV class="code">
+<PRE>
+// Simple example using typemaps
+%module example
+%include "typemaps.i"
-/* Typemap with extra pattern parameters */
-%typemap(in, numinputs=0) int *output (int temp),
- long *output (long temp)
-{
- $1 = &temp;
-}
+%apply double *OUTPUT { double *result };
+%inline %{
+extern void add(double a, double b, double *result);
+%}
</PRE>
</DIV>
-<P> Admittedly, it's not the most readable syntax at first glance.
- However, the purpose of the individual pieces will become clear.</P>
-<H3><A name="Typemaps_nn12"></A>10.2.2 Typemap scope</H3>
-<P> Once defined, a typemap remains in effect for all of the
- declarations that follow. A typemap may be redefined for different
- sections of an input file. For example:</P>
+<P> The <TT>%apply</TT> directive tells SWIG that you are going to apply
+ a special type handling rule to a type. The "<TT>double *OUTPUT</TT>"
+ specification is the name of a rule that defines how to return an
+ output value from an argument of type <TT>double *</TT>. This rule gets
+ applied to all of the datatypes listed in curly braces-- in this case "<TT>
+double *result</TT>".</P>
+<P> When the resulting module is created, you can now use the function
+ like this (shown for Python):</P>
+<DIV class="targetlang">
+<PRE>
+>>> a = add(3,4)
+>>> print a
+7
+>>>
+</PRE>
+</DIV>
+<P> In this case, you can see how the output value normally returned in
+ the third argument has magically been transformed into a function
+ return value. Clearly this makes the function much easier to use since
+ it is no longer necessary to manufacture a special <TT>double *</TT>
+ object and pass it to the function somehow.</P>
+<P> Once a typemap has been applied to a type, it stays in effect for
+ all future occurrences of the type and name. For example, you could
+ write the following:</P>
<DIV class="code">
<PRE>
-// typemap1
-%typemap(in) int {
-...
-}
+%module example
+%include "typemaps.i"
-int fact(int); // typemap1
-int gcd(int x, int y); // typemap1
+%apply double *OUTPUT { double *result };
-// typemap2
-%typemap(in) int {
+%inline %{
+extern void add(double a, double b, double *result);
+extern void sub(double a, double b, double *result);
+extern void mul(double a, double b, double *result);
+extern void div(double a, double b, double *result);
+%}
...
-}
-
-int isprime(int); // typemap2
</PRE>
</DIV>
-<P> One exception to the typemap scoping rules pertains to the <TT>
-%extend</TT> declaration. <TT>%extend</TT> is used to attach new
- declarations to a class or structure definition. Because of this, all
- of the declarations in an <TT>%extend</TT> block are subject to the
- typemap rules that are in effect at the point where the class itself is
- defined. For example:</P>
+<P> In this case, the <TT>double *OUTPUT</TT> rule is applied to all of
+ the functions that follow.</P>
+<P> Typemap transformations can even be extended to multiple return
+ values. For example, consider this code:</P>
<DIV class="code">
<PRE>
-class Foo {
- ...
-};
-
-%typemap(in) int {
- ...
-}
+%include "typemaps.i"
+%apply int *OUTPUT { int *width, int *height };
-%extend Foo {
- int blah(int x); // typemap has no effect. Declaration is attached to Foo which
- // appears before the %typemap declaration.
-};
+// Returns a pair (width,height)
+void getwinsize(int winid, int *width, int *height);
</PRE>
</DIV>
-<H3><A name="Typemaps_nn13"></A>10.2.3 Copying a typemap</H3>
-<P> A typemap is copied by using assignment. For example:</P>
-<DIV class="code">
+<P> In this case, the function returns multiple values, allowing it to
+ be used like this:</P>
+<DIV class="targetlang">
<PRE>
-%typemap(in) Integer = int;
+>>> w,h = genwinsize(wid)
+>>> print w
+400
+>>> print h
+300
+>>>
</PRE>
</DIV>
-<P> or this:</P>
+<P> It should also be noted that although the <TT>%apply</TT> directive
+ is used to associate typemap rules to datatypes, you can also use the
+ rule names directly in arguments. For example, you could write this:</P>
<DIV class="code">
<PRE>
-%typemap(in) Integer, Number, int32_t = int;
+// Simple example using typemaps
+%module example
+%include "typemaps.i"
+
+%{
+extern void add(double a, double b, double *OUTPUT);
+%}
+extern void add(double a, double b, double *OUTPUT);
</PRE>
</DIV>
-<P> Types are often managed by a collection of different typemaps. For
- example:</P>
+<P> Typemaps stay in effect until they are explicitly deleted or
+ redefined to something else. To clear a typemap, the <TT>%clear</TT>
+ directive should be used. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) int { ... }
-%typemap(out) int { ... }
-%typemap(varin) int { ... }
-%typemap(varout) int { ... }
+%clear double *result; // Remove all typemaps for double *result
</PRE>
</DIV>
-<P> To copy all of these typemaps to a new type, use <TT>%apply</TT>.
- For example:</P>
+<H3><A name="Arguments_nn4">10.1.2 Input parameters</A></H3>
+<P> The following typemaps instruct SWIG that a pointer really only
+ holds a single input value:</P>
<DIV class="code">
<PRE>
-%apply int { Integer }; // Copy all int typemaps to Integer
-%apply int { Integer, Number }; // Copy all int typemaps to both Integer and Number
+int *INPUT
+short *INPUT
+long *INPUT
+unsigned int *INPUT
+unsigned short *INPUT
+unsigned long *INPUT
+double *INPUT
+float *INPUT
</PRE>
</DIV>
-<P> The patterns for <TT>%apply</TT> follow the same rules as for <TT>
-%typemap</TT>. For example:</P>
+<P> When used, it allows values to be passed instead of pointers. For
+ example, consider this function:</P>
<DIV class="code">
<PRE>
-%apply int *output { Integer *output }; // Typemap with name
-%apply (char *buf, int len) { (char *buffer, int size) }; // Multiple arguments
+double add(double *a, double *b) {
+ return *a+*b;
+}
</PRE>
</DIV>
-<H3><A name="Typemaps_nn14"></A>10.2.4 Deleting a typemap</H3>
-<P> A typemap can be deleted by simply defining no code. For example:</P>
+<P> Now, consider this SWIG interface:</P>
<DIV class="code">
<PRE>
-%typemap(in) int; // Clears typemap for int
-%typemap(in) int, long, short; // Clears typemap for int, long, short
-%typemap(in) int *output;
+%module example
+%include "typemaps.i"
+...
+%{
+extern double add(double *, double *);
+%}
+extern double add(double *INPUT, double *INPUT);
+
</PRE>
</DIV>
-<P> The <TT>%clear</TT> directive clears all typemaps for a given type.
- For example:</P>
-<DIV class="code">
+<P> When the function is used in the scripting language interpreter, it
+ will work like this:</P>
+<DIV class="targetlang">
<PRE>
-%clear int; // Removes all types for int
-%clear int *output, long *output;
+result = add(3,4)
</PRE>
</DIV>
-<P><B> Note:</B> Since SWIG's default behavior is defined by typemaps,
- clearing a fundamental type like <TT>int</TT> will make that type
- unusable unless you also define a new set of typemaps immediately after
- the clear operation.</P>
-<H3><A name="Typemaps_nn15"></A>10.2.5 Placement of typemaps</H3>
-<P> Typemap declarations can be declared in the global scope, within a
- C++ namespace, and within a C++ class. For example:</P>
+<H3><A name="Arguments_nn5">10.1.3 Output parameters</A></H3>
+<P> The following typemap rules tell SWIG that pointer is the output
+ value of a function. When used, you do not need to supply the argument
+ when calling the function. Instead, one or more output values are
+ returned.</P>
<DIV class="code">
<PRE>
-%typemap(in) int {
- ...
-}
-
-namespace std {
- class string;
- %typemap(in) string {
- ...
- }
-}
+int *OUTPUT
+short *OUTPUT
+long *OUTPUT
+unsigned int *OUTPUT
+unsigned short *OUTPUT
+unsigned long *OUTPUT
+double *OUTPUT
+float *OUTPUT
-class Bar {
-public:
- typedef const int & const_reference;
- %typemap(out) const_reference {
- ...
- }
-};
</PRE>
</DIV>
-<P> When a typemap appears inside a namespace or class, it stays in
- effect until the end of the SWIG input (just like before). However, the
- typemap takes the local scope into account. Therefore, this code</P>
+<P> These methods can be used as shown in an earlier example. For
+ example, if you have this C function :</P>
<DIV class="code">
<PRE>
-namespace std {
- class string;
- %typemap(in) string {
- ...
- }
+void add(double a, double b, double *c) {
+ *c = a+b;
}
</PRE>
</DIV>
-<P> is really defining a typemap for the type <TT>std::string</TT>. You
- could have code like this:</P>
+<P> A SWIG interface file might look like this :</P>
<DIV class="code">
<PRE>
-namespace std {
- class string;
- %typemap(in) string { /* std::string */
- ...
- }
-}
+%module example
+%include "typemaps.i"
+...
+%inline %{
+extern void add(double a, double b, double *OUTPUT);
+%}
-namespace Foo {
- class string;
- %typemap(in) string { /* Foo::string */
- ...
- }
-}
</PRE>
</DIV>
-<P> In this case, there are two completely distinct typemaps that apply
- to two completely different types (<TT>std::string</TT> and <TT>
-Foo::string</TT>).</P>
-<P> It should be noted that for scoping to work, SWIG has to know that <TT>
-string</TT> is a typename defined within a particular namespace. In this
- example, this is done using the forward class declaration <TT>class
- string</TT>.</P>
-<H2><A name="Typemaps_pattern_matching"></A>10.3 Pattern matching rules</H2>
-<P> The section describes the pattern matching rules by which C/C++
- datatypes are associated with typemaps. The matching rules can be
- observed in practice by using the debugging options also described.</P>
-<H3><A name="Typemaps_nn17"></A>10.3.1 Basic matching rules</H3>
-<P> Typemaps are matched using both a type and a name (typically the
- name of a argument). For a given <TT>TYPE NAME</TT> pair, the following
- rules are applied, in order, to find a match. The first typemap found
- is used.</P>
-<UL>
-<LI>Typemaps that exactly match <TT>TYPE</TT> and <TT>NAME</TT>.</LI>
-<LI>Typemaps that exactly match <TT>TYPE</TT> only.</LI>
-<LI>If <TT>TYPE</TT> is a C++ template of type <TT>T< TPARMS ></TT>,
- where <TT>TPARMS</TT> are the template parameters, the type is stripped
- of the template parameters and the following checks are then made:
-<UL>
-<LI>Typemaps that exactly match <TT>T</TT> and <TT>NAME</TT>.</LI>
-<LI>Typemaps that exactly match <TT>T</TT> only.</LI>
-</UL>
-</LI>
-</UL>
-<P> If <TT>TYPE</TT> includes qualifiers (const, volatile, etc.), each
- qualifier is stripped one at a time to form a new stripped type and the
- matching rules above are repeated on the stripped type. The left-most
- qualifier is stripped first, resulting in the right-most (or top-level)
- qualifier being stripped last. For example <TT>int const*const</TT> is
- first stripped to <TT>int *const</TT> then <TT>int *</TT>.</P>
-<P> If <TT>TYPE</TT> is an array. The following transformation is made:</P>
-<UL>
-<LI>Replace all dimensions to <TT>[ANY]</TT> and look for a generic
- array typemap.</LI>
-</UL>
-<P> To illustrate, suppose that you had a function like this:</P>
+<P> In this case, only a single output value is returned, but this is
+ not a restriction. An arbitrary number of output values can be returned
+ by applying the output rules to more than one argument (as shown
+ previously).</P>
+<P> If the function also returns a value, it is returned along with the
+ argument. For example, if you had this:</P>
<DIV class="code">
<PRE>
-int foo(const char *s);
+extern int foo(double a, double b, double *OUTPUT);
</PRE>
</DIV>
-<P> To find a typemap for the argument <TT>const char *s</TT>, SWIG will
- search for the following typemaps:</P>
-<DIV class="diagram">
+<P> The function will return two values like this:</P>
+<DIV class="targetlang">
<PRE>
-const char *s Exact type and name match
-const char * Exact type match
-char *s Type and name match (qualifier stripped)
-char * Type match (qualifier stripped)
+iresult, dresult = foo(3.5, 2)
</PRE>
</DIV>
-<P> When more than one typemap rule might be defined, only the first
- match found is actually used. Here is an example that shows how some of
- the basic rules are applied:</P>
+<H3><A name="Arguments_nn6">10.1.4 Input/Output parameters</A></H3>
+<P> When a pointer serves as both an input and output value you can use
+ the following typemaps :</P>
<DIV class="code">
<PRE>
-%typemap(in) int *x {
- ... typemap 1
-}
-
-%typemap(in) int * {
- ... typemap 2
-}
-
-%typemap(in) const int *z {
- ... typemap 3
-}
-
-%typemap(in) int [4] {
- ... typemap 4
-}
-
-%typemap(in) int [ANY] {
- ... typemap 5
-}
+int *INOUT
+short *INOUT
+long *INOUT
+unsigned int *INOUT
+unsigned short *INOUT
+unsigned long *INOUT
+double *INOUT
+float *INOUT
-void A(int *x); // int *x rule (typemap 1)
-void B(int *y); // int * rule (typemap 2)
-void C(const int *x); // int *x rule (typemap 1)
-void D(const int *z); // const int *z rule (typemap 3)
-void E(int x[4]); // int [4] rule (typemap 4)
-void F(int x[1000]); // int [ANY] rule (typemap 5)
</PRE>
</DIV>
-<P><B> Compatibility note:</B> SWIG-2.0.0 introduced stripping the
- qualifiers one step at a time. Prior versions stripped all qualifiers
- in one step.</P>
-<H3><A name="Typemaps_typedef_reductions"></A>10.3.2 Typedef reductions
- matching</H3>
-<P> If no match is found using the rules in the previous section, SWIG
- applies a typedef reduction to the type and repeats the typemap search
- for the reduced type. To illustrate, suppose you had code like this:</P>
+<P> A C function that uses this might be something like this:</P>
<DIV class="code">
<PRE>
-%typemap(in) int {
- ... typemap 1
+void negate(double *x) {
+ *x = -(*x);
}
-typedef int Integer;
-void blah(Integer x);
</PRE>
</DIV>
-<P> To find the typemap for <TT>Integer x</TT>, SWIG will first search
- for the following typemaps:</P>
-<DIV class="diagram">
+<P> To make x function as both and input and output value, declare the
+ function like this in an interface file :</P>
+<DIV class="code">
<PRE>
-Integer x
-Integer
+%module example
+%include "typemaps.i"
+...
+%{
+extern void negate(double *);
+%}
+extern void negate(double *INOUT);
+
</PRE>
</DIV>
-<P> Finding no match, it then applies a reduction <TT>Integer -> int</TT>
- to the type and repeats the search.</P>
-<DIV class="diagram">
+<P> Now within a script, you can simply call the function normally :</P>
+<DIV class="targetlang">
<PRE>
-int x
-int --> match: typemap 1
+a = negate(3); # a = -3 after calling this
</PRE>
</DIV>
-<P> Even though two types might be the same via typedef, SWIG allows
- typemaps to be defined for each typename independently. This allows for
- interesting customization possibilities based solely on the typename
- itself. For example, you could write code like this:</P>
+<P> One subtle point of the <TT>INOUT</TT> rule is that many scripting
+ languages enforce mutability constraints on primitive objects (meaning
+ that simple objects like integers and strings aren't supposed to
+ change). Because of this, you can't just modify the object's value in
+ place as the underlying C function does in this example. Therefore, the
+ <TT>INOUT</TT> rule returns the modified value as a new object rather
+ than directly overwriting the value of the original input object.</P>
+<P><B> Compatibility note :</B> The <TT>INOUT</TT> rule used to be known
+ as <TT>BOTH</TT> in earlier versions of SWIG. Backwards compatibility
+ is preserved, but deprecated.</P>
+<H3><A name="Arguments_nn7">10.1.5 Using different names</A></H3>
+<P> As previously shown, the <TT>%apply</TT> directive can be used to
+ apply the <TT>INPUT</TT>, <TT>OUTPUT</TT>, and <TT>INOUT</TT> typemaps
+ to different argument names. For example:</P>
<DIV class="code">
<PRE>
-typedef double pdouble; // Positive double
+// Make double *result an output value
+%apply double *OUTPUT { double *result };
+
+// Make Int32 *in an input value
+%apply int *INPUT { Int32 *in };
+
+// Make long *x inout
+%apply long *INOUT {long *x};
-// typemap 1
-%typemap(in) double {
- ... get a double ...
-}
-// typemap 2
-%typemap(in) pdouble {
- ... get a positive double ...
-}
-double sin(double x); // typemap 1
-pdouble sqrt(pdouble x); // typemap 2
</PRE>
</DIV>
-<P> When reducing the type, only one typedef reduction is applied at a
- time. The search process continues to apply reductions until a match is
- found or until no more reductions can be made.</P>
-<P> For complicated types, the reduction process can generate a long
- list of patterns. Consider the following:</P>
+<P> To clear a rule, the <TT>%clear</TT> directive is used:</P>
<DIV class="code">
<PRE>
-typedef int Integer;
-typedef Integer Row4[4];
-void foo(Row4 rows[10]);
+%clear double *result;
+%clear Int32 *in, long *x;
</PRE>
</DIV>
-<P> To find a match for the <TT>Row4 rows[10]</TT> argument, SWIG would
- check the following patterns, stopping only when it found a match:</P>
+<P> Typemap declarations are lexically scoped so a typemap takes effect
+ from the point of definition to the end of the file or a matching <TT>
+%clear</TT> declaration.</P>
+<H2><A name="Arguments_nn8">10.2 Applying constraints to input values</A>
+</H2>
+<P> In addition to changing the handling of various input values, it is
+ also possible to use typemaps to apply constraints. For example, maybe
+ you want to insure that a value is positive, or that a pointer is
+ non-NULL. This can be accomplished including the <TT>constraints.i</TT>
+ library file.</P>
+<H3><A name="Arguments_nn9">10.2.1 Simple constraint example</A></H3>
+<P> The constraints library is best illustrated by the following
+ interface file :</P>
<DIV class="code">
<PRE>
-Row4 rows[10]
-Row4 [10]
-Row4 rows[ANY]
-Row4 [ANY]
+// Interface file with constraints
+%module example
+%include "constraints.i"
-# Reduce Row4 --> Integer[4]
-Integer rows[10][4]
-Integer [10][4]
-Integer rows[ANY][ANY]
-Integer [ANY][ANY]
+double exp(double x);
+double log(double POSITIVE); // Allow only positive values
+double sqrt(double NONNEGATIVE); // Non-negative values only
+double inv(double NONZERO); // Non-zero values
+void free(void *NONNULL); // Non-NULL pointers only
-# Reduce Integer --> int
-int rows[10][4]
-int [10][4]
-int rows[ANY][ANY]
-int [ANY][ANY]
</PRE>
</DIV>
-<P> For parameterized types like templates, the situation is even more
- complicated. Suppose you had some declarations like this:</P>
+<P> The behavior of this file is exactly as you would expect. If any of
+ the arguments violate the constraint condition, a scripting language
+ exception will be raised. As a result, it is possible to catch bad
+ values, prevent mysterious program crashes and so on.</P>
+<H3><A name="Arguments_nn10">10.2.2 Constraint methods</A></H3>
+<P> The following constraints are currently available</P>
<DIV class="code">
<PRE>
-typedef int Integer;
-typedef foo<Integer,Integer> fooii;
-void blah(fooii *x);
+POSITIVE Any number > 0 (not zero)
+NEGATIVE Any number < 0 (not zero)
+NONNEGATIVE Any number >= 0
+NONPOSITIVE Any number <= 0
+NONZERO Nonzero number
+NONNULL Non-NULL pointer (pointers only).
+
</PRE>
</DIV>
-<P> In this case, the following typemap patterns are searched for the
- argument <TT>fooii *x</TT>:</P>
+<H3><A name="Arguments_nn11">10.2.3 Applying constraints to new
+ datatypes</A></H3>
+<P> The constraints library only supports the primitive C datatypes, but
+ it is easy to apply it to new datatypes using <TT>%apply</TT>. For
+ example :</P>
<DIV class="code">
<PRE>
-fooii *x
-fooii *
-
-# Reduce fooii --> foo<Integer,Integer>
-foo<Integer,Integer> *x
-foo<Integer,Integer> *
+// Apply a constraint to a Real variable
+%apply Number POSITIVE { Real in };
-# Reduce Integer -> int
-foo<int, Integer> *x
-foo<int, Integer> *
+// Apply a constraint to a pointer type
+%apply Pointer NONNULL { Vector * };
-# Reduce Integer -> int
-foo<int, int> *x
-foo<int, int> *
</PRE>
</DIV>
-<P> Typemap reductions are always applied to the left-most type that
- appears. Only when no reductions can be made to the left-most type are
- reductions made to other parts of the type. This behavior means that
- you could define a typemap for <TT>foo<int,Integer></TT>, but a typemap
- for <TT>foo<Integer,int></TT> would never be matched. Admittedly, this
- is rather esoteric--there's little practical reason to write a typemap
- quite like that. Of course, you could rely on this to confuse your
- coworkers even more.</P>
-<P> As a point of clarification, it is worth emphasizing that typedef
- matching is a typedef<B> reduction</B> process only, that is, SWIG does
- not search for every single possible typedef. Given a type in a
- declaration, it will only reduce the type, it won't build it up looking
- for typedefs. For example, given the type <TT>Struct</TT>, the typemap
- below will not be used for the <TT>aStruct</TT> parameter, because <TT>
-Struct</TT> is fully reduced:</P>
+<P> The special types of "Number" and "Pointer" can be applied to any
+ numeric and pointer variable type respectively. To later remove a
+ constraint, the <TT>%clear</TT> directive can be used :</P>
<DIV class="code">
<PRE>
-struct Struct {...};
-typedef Struct StructTypedef;
-
-%typemap(in) StructTypedef {
- ...
-}
-
-void go(Struct aStruct);
+%clear Real in;
+%clear Vector *;
</PRE>
+</DIV><HR NOSHADE>
+<H1><A name="Typemaps">11 Typemaps</A></H1>
+
+<!-- INDEX -->
+<DIV class="sectiontoc">
+<UL>
+<LI><A href="#Typemaps_nn2">Introduction</A>
+<UL>
+<LI><A href="#Typemaps_nn3">Type conversion</A></LI>
+<LI><A href="#Typemaps_nn4">Typemaps</A></LI>
+<LI><A href="#Typemaps_nn5">Pattern matching</A></LI>
+<LI><A href="#Typemaps_nn6">Reusing typemaps</A></LI>
+<LI><A href="#Typemaps_nn7">What can be done with typemaps?</A></LI>
+<LI><A href="#Typemaps_nn8">What can't be done with typemaps?</A></LI>
+<LI><A href="#Typemaps_aspects">Similarities to Aspect Oriented
+ Programming</A></LI>
+<LI><A href="#Typemaps_nn9">The rest of this chapter</A></LI>
+</UL>
+</LI>
+<LI><A href="#Typemaps_nn10">Typemap specifications</A>
+<UL>
+<LI><A href="#Typemaps_defining">Defining a typemap</A></LI>
+<LI><A href="#Typemaps_nn12">Typemap scope</A></LI>
+<LI><A href="#Typemaps_nn13">Copying a typemap</A></LI>
+<LI><A href="#Typemaps_nn14">Deleting a typemap</A></LI>
+<LI><A href="#Typemaps_nn15">Placement of typemaps</A></LI>
+</UL>
+</LI>
+<LI><A href="#Typemaps_pattern_matching">Pattern matching rules</A>
+<UL>
+<LI><A href="#Typemaps_nn17">Basic matching rules</A></LI>
+<LI><A href="#Typemaps_typedef_reductions">Typedef reductions matching</A>
+</LI>
+<LI><A href="#Typemaps_nn19">Default typemap matching rules</A></LI>
+<LI><A href="#Typemaps_multi_argument_typemaps_patterns">Multi-arguments
+ typemaps</A></LI>
+<LI><A href="#Typemaps_matching_template_comparison">Matching rules
+ compared to C++ templates</A></LI>
+<LI><A href="#Typemaps_debugging_search">Debugging typemap pattern
+ matching</A></LI>
+</UL>
+</LI>
+<LI><A href="#Typemaps_nn21">Code generation rules</A>
+<UL>
+<LI><A href="#Typemaps_nn22">Scope</A></LI>
+<LI><A href="#Typemaps_nn23">Declaring new local variables</A></LI>
+<LI><A href="#Typemaps_special_variables">Special variables</A></LI>
+<LI><A href="#Typemaps_special_variable_macros">Special variable macros</A>
+<UL>
+<LI><A href="#Typemaps_special_macro_descriptor">$descriptor(type)</A></LI>
+<LI><A href="#Typemaps_special_macro_typemap">$typemap(method,
+ typepattern)</A></LI>
+</UL>
+</LI>
+<LI><A href="#Typemaps_special_variable_attributes">Special variables
+ and typemap attributes</A></LI>
+<LI><A href="#Typemaps_special_variables_and_macros">Special variables
+ combined with special variable macros</A></LI>
+</UL>
+</LI>
+<LI><A href="#Typemaps_nn25">Common typemap methods</A>
+<UL>
+<LI><A href="#Typemaps_nn26">"in" typemap</A></LI>
+<LI><A href="#Typemaps_nn27">"typecheck" typemap</A></LI>
+<LI><A href="#Typemaps_nn28">"out" typemap</A></LI>
+<LI><A href="#Typemaps_nn29">"arginit" typemap</A></LI>
+<LI><A href="#Typemaps_nn30">"default" typemap</A></LI>
+<LI><A href="#Typemaps_nn31">"check" typemap</A></LI>
+<LI><A href="#Typemaps_nn32">"argout" typemap</A></LI>
+<LI><A href="#Typemaps_nn33">"freearg" typemap</A></LI>
+<LI><A href="#Typemaps_nn34">"newfree" typemap</A></LI>
+<LI><A href="#Typemaps_nn35">"memberin" typemap</A></LI>
+<LI><A href="#Typemaps_nn36">"varin" typemap</A></LI>
+<LI><A href="#Typemaps_nn37">"varout" typemap</A></LI>
+<LI><A href="#throws_typemap">"throws" typemap</A></LI>
+</UL>
+</LI>
+<LI><A href="#Typemaps_nn39">Some typemap examples</A>
+<UL>
+<LI><A href="#Typemaps_nn40">Typemaps for arrays</A></LI>
+<LI><A href="#Typemaps_nn41">Implementing constraints with typemaps</A></LI>
+</UL>
+</LI>
+<LI><A href="#Typemaps_nn43">Typemaps for multiple target languages</A></LI>
+<LI><A href="#Typemaps_optimal">Optimal code generation when returning
+ by value</A></LI>
+<LI><A href="#Typemaps_multi_argument_typemaps">Multi-argument typemaps</A>
+</LI>
+<LI><A href="#Typemaps_warnings">Typemap warnings</A></LI>
+<LI><A href="#Typemaps_fragments">Typemap fragments</A>
+<UL>
+<LI><A href="#Typemaps_fragment_type_specialization">Fragment type
+ specialization</A></LI>
+<LI><A href="#Typemaps_automatic_specialization">Fragments and automatic
+ typemap specialization</A></LI>
+</UL>
+</LI>
+<LI><A href="#Typemaps_runtime_type_checker">The run-time type checker</A>
+<UL>
+<LI><A href="#Typemaps_nn45">Implementation</A></LI>
+<LI><A href="#Typemaps_runtime_type_checker_usage">Usage</A></LI>
+</UL>
+</LI>
+<LI><A href="#Typemaps_overloading">Typemaps and overloading</A></LI>
+<LI><A href="#Typemaps_nn48">More about %apply and %clear</A></LI>
+<LI><A href="#Typemaps_nn47">Passing data between typemaps</A></LI>
+<LI><A href="#Typemaps_nn52">C++ "this" pointer</A></LI>
+<LI><A href="#Typemaps_nn51">Where to go for more information?</A></LI>
+</UL>
</DIV>
-<H3><A name="Typemaps_nn19"></A>10.3.3 Default typemap matching rules</H3>
-<P> If the basic pattern matching rules result in no match being made,
- even after typedef reductions, the default typemap matching rules are
- used to look for a suitable typemap match. These rules match a generic
- typemap based on the reserved <TT>SWIGTYPE</TT> base type. For example
- pointers will use <TT>SWIGTYPE *</TT> and references will use <TT>
-SWIGTYPE &</TT>. More precisely, the rules are based on the C++ class
- template partial specialization matching rules used by C++ compilers
- when looking for an appropriate partial template specialization. This
- means that a match is chosen from the most specialized set of generic
- typemap types available. For example, when looking for a match to <TT>
-int const *</TT>, the rules will prefer to match <TT>SWIGTYPE const *</TT>
- if available before matching <TT>SWIGTYPE *</TT>, before matching <TT>
-SWIGTYPE</TT>.</P>
-<P> Most SWIG language modules use typemaps to define the default
- behavior of the C primitive types. This is entirely straightforward.
- For example, a set of typemaps for primitives marshalled by value or
- const reference are written like this:</P>
+<!-- INDEX -->
+<H2><A name="Typemaps_nn2">11.1 Introduction</A></H2>
+<P> Chances are, you are reading this chapter for one of two reasons;
+ you either want to customize SWIG's behavior or you overheard someone
+ mumbling some incomprehensible drivel about "typemaps" and you asked
+ yourself "typemaps, what are those?" That said, let's start with a
+ short disclaimer that "typemaps" are an advanced customization feature
+ that provide direct access to SWIG's low-level code generator. Not only
+ that, they are an integral part of the SWIG C++ type system (a
+ non-trivial topic of its own). Typemaps are generally<EM> not</EM> a
+ required part of using SWIG. Therefore, you might want to re-read the
+ earlier chapters if you have found your way to this chapter with only a
+ vague idea of what SWIG already does by default.</P>
+<H3><A name="Typemaps_nn3">11.1.1 Type conversion</A></H3>
+<P> One of the most important problems in wrapper code generation is the
+ conversion or marshalling of datatypes between programming languages.
+ Specifically, for every C/C++ declaration, SWIG must somehow generate
+ wrapper code that allows values to be passed back and forth between
+ languages. Since every programming language represents data
+ differently, this is not a simple of matter of simply linking code
+ together with the C linker. Instead, SWIG has to know something about
+ how data is represented in each language and how it can be manipulated.</P>
+<P> To illustrate, suppose you had a simple C function like this:</P>
<DIV class="code">
<PRE>
-%typemap(in) int "... convert to int ...";
-%typemap(in) short "... convert to short ...";
-%typemap(in) float "... convert to float ...";
-...
-%typemap(in) const int & "... convert ...";
-%typemap(in) const short & "... convert ...";
-%typemap(in) const float & "... convert ...";
-...
+int factorial(int n);
</PRE>
</DIV>
-<P> Since typemap matching follows all <TT>typedef</TT> declarations,
- any sort of type that is mapped to a primitive type by value or const
- reference through <TT>typedef</TT> will be picked up by one of these
- primitive typemaps. Most language modules also define typemaps for char
- pointers and char arrays to handle strings, so these non-default types
- will also be used in preference as the basic typemap matching rules
- provide a better match than the default typemap matching rules.</P>
-<P> Below is a list of the typical default types supplied by language
- modules, showing what the "in" typemap would look like:</P>
+<P> To access this function from Python, a pair of Python API functions
+ are used to convert integer values. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) SWIGTYPE & { ... default reference handling ... };
-%typemap(in) SWIGTYPE * { ... default pointer handling ... };
-%typemap(in) SWIGTYPE *const { ... default pointer const handling ... };
-%typemap(in) SWIGTYPE *const& { ... default pointer const reference handling ... };
-%typemap(in) SWIGTYPE[ANY] { ... 1D fixed size arrays handlling ... };
-%typemap(in) SWIGTYPE [] { ... unknown sized array handling ... };
-%typemap(in) enum SWIGTYPE { ... default handling for enum values ... };
-%typemap(in) const enum SWIGTYPE & { ... default handling for const enum reference values ... };
-%typemap(in) SWIGTYPE (CLASS::*) { ... default pointer member handling ... };
-%typemap(in) SWIGTYPE { ... simple default handling ... };
+long PyInt_AsLong(PyObject *obj); /* Python --> C */
+PyObject *PyInt_FromLong(long x); /* C --> Python */
</PRE>
</DIV>
-<P> If you wanted to change SWIG's default handling for simple pointers,
- you would simply redefine the rule for <TT>SWIGTYPE *</TT>. Note, the
- simple default typemap rule is used to match against simple types that
- don't match any other rules:</P>
+<P> The first function is used to convert the input argument from a
+ Python integer object to C <TT>long</TT>. The second function is used
+ to convert a value from C back into a Python integer object.</P>
+<P> Inside the wrapper function, you might see these functions used like
+ this:</P>
<DIV class="code">
<PRE>
-%typemap(in) SWIGTYPE { ... simple default handling ... }
+PyObject *wrap_factorial(PyObject *self, PyObject *args) {
+ int arg1;
+ int result;
+ PyObject *obj1;
+ PyObject *resultobj;
+
+ if (!PyArg_ParseTuple("O:factorial", &obj1)) return NULL;
+ <B>arg1 = PyInt_AsLong(obj1);</B>
+ result = factorial(arg1);
+ <B>resultobj = PyInt_FromLong(result);</B>
+ return resultobj;
+}
</PRE>
</DIV>
-<P> This typemap is important because it is the rule that gets triggered
- when call or return by value is used. For instance, if you have a
- declaration like this:</P>
+<P> Every target language supported by SWIG has functions that work in a
+ similar manner. For example, in Perl, the following functions are used:</P>
<DIV class="code">
<PRE>
-double dot_product(Vector a, Vector b);
+IV SvIV(SV *sv); /* Perl --> C */
+void sv_setiv(SV *sv, IV val); /* C --> Perl */
</PRE>
</DIV>
-<P> The <TT>Vector</TT> type will usually just get matched against <TT>
-SWIGTYPE</TT>. The default implementation of <TT>SWIGTYPE</TT> is to
- convert the value into pointers (<A href="#SWIG_nn22">as described in
- this earlier section</A>).</P>
-<P> By redefining <TT>SWIGTYPE</TT> it may be possible to implement
- other behavior. For example, if you cleared all typemaps for <TT>
-SWIGTYPE</TT>, SWIG simply won't wrap any unknown datatype (which might
- be useful for debugging). Alternatively, you might modify SWIGTYPE to
- marshal objects into strings instead of converting them to pointers.</P>
-<P> Let's consider an example where the following typemaps are defined
- and SWIG is looking for the best match for the enum shown below:</P>
+<P> In Tcl:</P>
<DIV class="code">
<PRE>
-%typemap(in) const Hello & { ... }
-%typemap(in) const enum SWIGTYPE & { ... }
-%typemap(in) enum SWIGTYPE & { ... }
-%typemap(in) SWIGTYPE & { ... }
-%typemap(in) SWIGTYPE { ... }
-
-enum Hello {};
-const Hello &hi;
+int Tcl_GetLongFromObj(Tcl_Interp *interp, Tcl_Obj *obj, long *value);
+Tcl_Obj *Tcl_NewIntObj(long value);
</PRE>
</DIV>
-<P> The typemap at the top of the list will be chosen, not because it is
- defined first, but because it is the closest match for the type being
- wrapped. If any of the typemaps in the above list were not defined,
- then the next one on the list would have precedence.</P>
-<P> The best way to explore the default typemaps is to look at the ones
- already defined for a particular language module. Typemap definitions
- are usually found in the SWIG library in a file such as <TT>java.swg</TT>
-, <TT>csharp.swg</TT> etc. However, for many of the target languages the
- typemaps are hidden behind complicated macros, so the best way to view
- the default typemaps, or any typemaps for that matter, is to look at
- the preprocessed output by running <TT>swig -E</TT> on any interface
- file. Finally the best way to view the typemap matching rules in action
- is via the <A href="#Typemaps_debugging_search">debugging typemap
- pattern matching</A> options covered later on.</P>
-<P><B> Compatibility note:</B> The default typemap matching rules were
- modified in SWIG-2.0.0 from a slightly simpler scheme to match the
- current C++ class template partial specialization matching rules.</P>
-<H3><A name="Typemaps_multi_argument_typemaps_patterns"></A>10.3.4
- Multi-arguments typemaps</H3>
-<P> When multi-argument typemaps are specified, they take precedence
- over any typemaps specified for a single type. For example:</P>
+<P> The precise details are not so important. What is important is that
+ all of the underlying type conversion is handled by collections of
+ utility functions and short bits of C code like this---you simply have
+ to read the extension documentation for your favorite language to know
+ how it works (an exercise left to the reader).</P>
+<H3><A name="Typemaps_nn4">11.1.2 Typemaps</A></H3>
+<P> Since type handling is so central to wrapper code generation, SWIG
+ allows it to be completely defined (or redefined) by the user. To do
+ this, a special <TT>%typemap</TT> directive is used. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) (char *buffer, int len) {
- // typemap 1
+/* Convert from Python --> C */
+%typemap(in) int {
+ $1 = PyInt_AsLong($input);
}
-%typemap(in) char *buffer {
- // typemap 2
+/* Convert from C --> Python */
+%typemap(out) int {
+ $result = PyInt_FromLong($1);
}
-
-void foo(char *buffer, int len, int count); // (char *buffer, int len)
-void bar(char *buffer, int blah); // char *buffer
</PRE>
</DIV>
-<P> Multi-argument typemaps are also more restrictive in the way that
- they are matched. Currently, the first argument follows the matching
- rules described in the previous section, but all subsequent arguments
- must match exactly.</P>
-<H3><A name="Typemaps_matching_template_comparison"></A>10.3.5 Matching
- rules compared to C++ templates</H3>
-<P> For those intimately familiar with C++ templates, a comparison of
- the typemap matching rules and template type deduction is interesting.
- The two areas considered are firstly the default typemaps and their
- similarities to partial template specialization and secondly,
- non-default typemaps and their similarities to full template
- specialization.</P>
-<P> For default (SWIGTYPE) typemaps the rules are inspired by C++ class
- template partial specialization. For example, given partial
- specialization for <TT>T const&</TT> :</P>
+<P> At first glance, this code will look a little confusing. However,
+ there is really not much to it. The first typemap (the "in" typemap) is
+ used to convert a value from the target language to C. The second
+ typemap (the "out" typemap) is used to convert in the other direction.
+ The content of each typemap is a small fragment of code that is
+ inserted directly into the SWIG generated wrapper functions. The code
+ is usually C or C++ code which will be generated into the C/C++ wrapper
+ functions. Note that this isn't always the case as some target language
+ modules allow target language code within the typemaps which gets
+ generated into target language specific files. Within this code, a
+ number of special variables prefixed with a $ are expanded. These are
+ really just placeholders for C/C++ variables that are generated in the
+ course of creating the wrapper function. In this case, <TT>$input</TT>
+ refers to an input object that needs to be converted to C/C++ and <TT>
+$result</TT> refers to an object that is going to be returned by a
+ wrapper function. <TT>$1</TT> refers to a C/C++ variable that has the
+ same type as specified in the typemap declaration (an <TT>int</TT> in
+ this example).</P>
+<P> A short example might make this a little more clear. If you were
+ wrapping a function like this:</P>
<DIV class="code">
<PRE>
-template <typename T> struct X { void a(); };
-template <typename T> struct X< T const& > { void b(); };
+int gcd(int x, int y);
</PRE>
</DIV>
-<P> The full (unspecialized) template is matched with most types, such
- as:</P>
+<P> A wrapper function would look approximately like this:</P>
<DIV class="code">
<PRE>
-X< int & > x1; x1.a();
+PyObject *wrap_gcd(PyObject *self, PyObject *args) {
+ int arg1;
+ int arg2;
+ int result;
+ PyObject *obj1;
+ PyObject *obj2;
+ PyObject *resultobj;
+
+ if (!PyArg_ParseTuple("OO:gcd", &obj1, &obj2)) return NULL;
+
+ /* "in" typemap, argument 1 */<B>
+ {
+ arg1 = PyInt_AsLong(obj1);
+ }
+</B>
+ /* "in" typemap, argument 2 */<B>
+ {
+ arg2 = PyInt_AsLong(obj2);
+ }
+</B>
+ result = gcd(arg1,arg2);
+
+ /* "out" typemap, return value */<B>
+ {
+ resultobj = PyInt_FromLong(result);
+ }
+</B>
+ return resultobj;
+}
</PRE>
</DIV>
-<P> and the following all match the <TT>T const&</TT> partial
- specialization:</P>
+<P> In this code, you can see how the typemap code has been inserted
+ into the function. You can also see how the special $ variables have
+ been expanded to match certain variable names inside the wrapper
+ function. This is really the whole idea behind typemaps--they simply
+ let you insert arbitrary code into different parts of the generated
+ wrapper functions. Because arbitrary code can be inserted, it possible
+ to completely change the way in which values are converted.</P>
+<H3><A name="Typemaps_nn5">11.1.3 Pattern matching</A></H3>
+<P> As the name implies, the purpose of a typemap is to "map" C
+ datatypes to types in the target language. Once a typemap is defined
+ for a C datatype, it is applied to all future occurrences of that type
+ in the input file. For example:</P>
<DIV class="code">
<PRE>
-X< int *const& > x2; x2.b();
-X< int const*const& > x3; x3.b();
-X< int const& > x4; x4.b();
+/* Convert from Perl --> C */
+%typemap(in) <B>int</B> {
+ $1 = SvIV($input);
+}
+
+...
+int factorial(<B>int</B> n);
+int gcd(<B>int</B> x, <B>int</B> y);
+int count(char *s, char *t, <B>int</B> max);
</PRE>
</DIV>
-<P> Now, given just these two default typemaps, where T is analogous to
- SWIGTYPE:</P>
+<P> The matching of typemaps to C datatypes is more than a simple
+ textual match. In fact, typemaps are fully built into the underlying
+ type system. Therefore, typemaps are unaffected by <TT>typedef</TT>,
+ namespaces, and other declarations that might hide the underlying type.
+ For example, you could have code like this:</P>
<DIV class="code">
<PRE>
-%typemap(...) SWIGTYPE { ... }
-%typemap(...) SWIGTYPE const& { ... }
+/* Convert from Ruby--> C */
+%typemap(in) <B>int</B> {
+ $1 = NUM2INT($input);
+}
+...
+typedef int Integer;
+namespace foo {
+ typedef Integer Number;
+};
+
+int foo(<B>int</B> x);
+int bar(<B>Integer</B> y);
+int spam(<B>foo::Number</B> a, <B>foo::Number</B> b);
</PRE>
</DIV>
-<P> The generic default typemap <TT>SWIGTYPE</TT> is used with most
- types, such as</P>
+<P> In this case, the typemap is still applied to the proper arguments
+ even though typenames don't always match the text "int". This ability
+ to track types is a critical part of SWIG--in fact, all of the target
+ language modules work merely define a set of typemaps for the basic
+ types. Yet, it is never necessary to write new typemaps for typenames
+ introduced by <TT>typedef</TT>.</P>
+<P> In addition to tracking typenames, typemaps may also be specialized
+ to match against a specific argument name. For example, you could write
+ a typemap like this:</P>
<DIV class="code">
<PRE>
-int &
+%typemap(in) <B>double nonnegative</B> {
+ $1 = PyFloat_AsDouble($input);
+ if ($1 < 0) {
+ PyErr_SetString(PyExc_ValueError,"argument must be nonnegative.");
+ return NULL;
+ }
+}
+
+...
+double sin(double x);
+double cos(double x);
+double sqrt(<B>double nonnegative</B>);
+
+typedef double Real;
+double log(<B>Real nonnegative</B>);
+...
</PRE>
</DIV>
-<P> and the following all match the <TT>SWIGTYPE const&</TT> typemap,
- just like the partial template matching:</P>
+<P> For certain tasks such as input argument conversion, typemaps can be
+ defined for sequences of consecutive arguments. For example:</P>
<DIV class="code">
<PRE>
-int *const&
-int const*const&
-int const&
+%typemap(in) (<B>char *str, int len</B>) {
+ $1 = PyString_AsString($input); /* char *str */
+ $2 = PyString_Size($input); /* int len */
+}
+...
+int count(<B>char *str, int len</B>, char c);
</PRE>
</DIV>
-<P> Note that the template and typemap matching rules are not identical
- for all default typemaps though, for example, with arrays.</P>
-<P> For non-default typemaps, one might expect SWIG to follow the fully
- specialized template rules. This is nearly the case, but not quite.
- Consider a very similar example to the earlier partially specialized
- template but this time there is a fully specialized template:</P>
+<P> In this case, a single input object is expanded into a pair of C
+ arguments. This example also provides a hint to the unusual variable
+ naming scheme involving <TT>$1</TT>, <TT>$2</TT>, and so forth.</P>
+<H3><A name="Typemaps_nn6">11.1.4 Reusing typemaps</A></H3>
+<P> Typemaps are normally defined for specific type and argument name
+ patterns. However, typemaps can also be copied and reused. One way to
+ do this is to use assignment like this:</P>
<DIV class="code">
<PRE>
-template <typename T> struct Y { void a(); };
-template <> struct Y< int const & > { void b(); };
+%typemap(in) Integer = int;
+%typemap(in) (char *buffer, int size) = (char *str, int len);
</PRE>
</DIV>
-<P> Only the one type matches the specialized template exactly:</P>
+<P> A more general form of copying is found in the <TT>%apply</TT>
+ directive like this:</P>
<DIV class="code">
<PRE>
-Y< int & > y1; y1.a();
-Y< int *const& > y2; y2.a();
-Y< int const *const& > y3; y3.a();
-Y< int const& > y4; y4.b(); // fully specialized match
+%typemap(in) int {
+ /* Convert an integer argument */
+ ...
+}
+%typemap(out) int {
+ /* Return an integer value */
+ ...
+}
+
+/* Apply all of the integer typemaps to size_t */
+%apply int { size_t };
</PRE>
</DIV>
-<P> Given typemaps with the same types used for the template declared
- above, where T is again analogous to SWIGTYPE:</P>
+<P> <TT>%apply</TT> merely takes<EM> all</EM> of the typemaps that are
+ defined for one type and applies them to other types. Note: you can
+ include a comma separated set of types in the <TT>{ ... }</TT> part of <TT>
+%apply</TT>.</P>
+<P> It should be noted that it is not necessary to copy typemaps for
+ types that are related by <TT>typedef</TT>. For example, if you have
+ this,</P>
<DIV class="code">
<PRE>
-%typemap(...) SWIGTYPE { ... }
-%typemap(...) int const& { ... }
+typedef int size_t;
</PRE>
</DIV>
-<P> The comparison between non-default typemaps and fully specialized
- single parameter templates turns out to be the same, as just the one
- type will match the non-default typemap:</P>
+<P> then SWIG already knows that the <TT>int</TT> typemaps apply. You
+ don't have to do anything.</P>
+<H3><A name="Typemaps_nn7">11.1.5 What can be done with typemaps?</A></H3>
+<P> The primary use of typemaps is for defining wrapper generation
+ behavior at the level of individual C/C++ datatypes. There are
+ currently six general categories of problems that typemaps address:</P>
+<P><B> Argument handling</B></P>
<DIV class="code">
<PRE>
-int &
-int *const&
-int const*const&
-int const& // matches non-default typemap int const&
+int foo(<B>int x, double y, char *s</B>);
</PRE>
</DIV>
-<P> However, if a non-const type is used instead:</P>
+<UL>
+<LI>Input argument conversion ("in" typemap).</LI>
+<LI>Input argument type checking ("typecheck" typemap).</LI>
+<LI>Output argument handling ("argout" typemap).</LI>
+<LI>Input argument value checking ("check" typemap).</LI>
+<LI>Input argument initialization ("arginit" typemap).</LI>
+<LI>Default arguments ("default" typemap).</LI>
+<LI>Input argument resource management ("freearg" typemap).</LI>
+</UL>
+<P><B> Return value handling</B></P>
<DIV class="code">
<PRE>
-%typemap(...) SWIGTYPE { ... }
-%typemap(...) int & { ... }
+<B>int</B> foo(int x, double y, char *s);
</PRE>
</DIV>
-<P> then there is a clear difference to template matching as both the
- const and non-const types match the typemap:</P>
+<UL>
+<LI>Function return value conversion ("out" typemap).</LI>
+<LI>Return value resource management ("ret" typemap).</LI>
+<LI>Resource management for newly allocated objects ("newfree" typemap).</LI>
+</UL>
+<P><B> Exception handling</B></P>
<DIV class="code">
<PRE>
-int & // matches non-default typemap int &
-int *const&
-int const*const&
-int const& // matches non-default typemap int &
+<B>int</B> foo(int x, double y, char *s) throw(<B>MemoryError, IndexError</B>);
</PRE>
</DIV>
-<P> There are other subtle differences such as typedef handling, but at
- least it should be clear that the typemap matching rules are similar to
- those for specialized template handling.</P>
-<H3><A name="Typemaps_debugging_search"></A>10.3.6 Debugging typemap
- pattern matching</H3>
-<P> There are two useful debug command line options available for
- debugging typemaps, <TT>-debug-tmsearch</TT> and <TT>-debug-tmused</TT>
-.</P>
-<P> The <TT>-debug-tmsearch</TT> option is a verbose option for
- debugging typemap searches. This can be very useful for watching the
- pattern matching process in action and for debugging which typemaps are
- used. The option displays all the typemaps and types that are looked
- for until a successful pattern match is made. As the display includes
- searches for each and every type needed for wrapping, the amount of
- information displayed can be large. Normally you would manually search
- through the displayed information for the particular type that you are
- interested in.</P>
-<P> For example, consider some of the code used in the <A href="#Typemaps_typedef_reductions">
-Typedef reductions</A> section already covered:</P>
+<UL>
+<LI>Handling of C++ exception specifications. ("throw" typemap).</LI>
+</UL>
+<P><B> Global variables</B></P>
<DIV class="code">
<PRE>
-typedef int Integer;
-typedef Integer Row4[4];
-void foo(Row4 rows[10]);
+<B>int foo;</B>
</PRE>
</DIV>
-<P> A sample of the debugging output is shown below for the "in"
- typemap:</P>
-<DIV class="shell">
+<UL>
+<LI>Assignment of a global variable. ("varin" typemap).</LI>
+<LI>Reading a global variable. ("varout" typemap).</LI>
+</UL>
+<P><B> Member variables</B></P>
+<DIV class="code">
<PRE>
-swig -perl -debug-tmsearch example.i
-...
-example.h:3: Searching for a suitable 'in' typemap for: Row4 rows[10]
- Looking for: Row4 rows[10]
- Looking for: Row4 [10]
- Looking for: Row4 rows[ANY]
- Looking for: Row4 [ANY]
- Looking for: Integer rows[10][4]
- Looking for: Integer [10][4]
- Looking for: Integer rows[ANY][ANY]
- Looking for: Integer [ANY][ANY]
- Looking for: int rows[10][4]
- Looking for: int [10][4]
- Looking for: int rows[ANY][ANY]
- Looking for: int [ANY][ANY]
- Looking for: SWIGTYPE rows[ANY][ANY]
- Looking for: SWIGTYPE [ANY][ANY]
- Looking for: SWIGTYPE rows[ANY][]
- Looking for: SWIGTYPE [ANY][]
- Looking for: SWIGTYPE *rows[ANY]
- Looking for: SWIGTYPE *[ANY]
- Looking for: SWIGTYPE rows[ANY]
- Looking for: SWIGTYPE [ANY]
- Looking for: SWIGTYPE rows[]
- Looking for: SWIGTYPE []
- Using: %typemap(in) SWIGTYPE []
-...
+struct Foo {
+ <B>int x[20]</B>;
+};
</PRE>
</DIV>
-<P> showing that the best default match supplied by SWIG is the <TT>
-SWIGTYPE []</TT> typemap. As the example shows, the successful match
- displays the used typemap source including typemap method, type and
- optional name in one of these simplified formats:</P>
<UL>
-<LI> <TT>Using: %typemap(method) type name</TT></LI>
-<LI> <TT>Using: %typemap(method) type name = type2 name2</TT></LI>
-<LI> <TT>Using: %apply type2 name2 { type name }</TT></LI>
+<LI>Assignment of data to a class/structure member. ("memberin"
+ typemap).</LI>
</UL>
-<P> This information might meet your debugging needs, however, you might
- want to analyze further. If you next invoke SWIG with the <TT>-E</TT>
- option to display the preprocessed output, and search for the
- particular typemap used, you'll find the full typemap contents (example
- shown below for Python):</P>
+<P><B> Constant creation</B></P>
<DIV class="code">
<PRE>
-%typemap(in, noblock=1) SWIGTYPE [] (void *argp = 0, int res = 0) {
- res = SWIG_ConvertPtr($input, &argp,$descriptor, $disown | 0 );
- if (!SWIG_IsOK(res)) {
- SWIG_exception_fail(SWIG_ArgError(res), "in method '" "$symname" "', argument "
- "$argnum"" of type '" "$type""'");
- }
- $1 = ($ltype)(argp);
-}
+#define FOO 3
+%constant int BAR = 42;
+enum { ALE, LAGER, STOUT };
</PRE>
</DIV>
-<P> The generated code for the <TT>foo</TT> wrapper will then contain
- the snippets of the typemap with the special variables expanded. The
- rest of this chapter will need reading though to fully understand all
- of this, however, the relevant parts of the generated code for the
- above typemap can be seen below:</P>
+<UL>
+<LI>Creation of constant values. ("consttab" or "constcode" typemap).</LI>
+</UL>
+<P> Details of each of these typemaps will be covered shortly. Also,
+ certain language modules may define additional typemaps that expand
+ upon this list. For example, the Java module defines a variety of
+ typemaps for controlling additional aspects of the Java bindings.
+ Consult language specific documentation for further details.</P>
+<H3><A name="Typemaps_nn8">11.1.6 What can't be done with typemaps?</A></H3>
+<P> Typemaps can't be used to define properties that apply to C/C++
+ declarations as a whole. For example, suppose you had a declaration
+ like this,</P>
<DIV class="code">
<PRE>
-SWIGINTERN PyObject *_wrap_foo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-...
- void *argp1 = 0 ;
- int res1 = 0 ;
-...
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_a_4__int, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "foo" "', argument "
- "1"" of type '" "int [10][4]""'");
- }
- arg1 = (int (*)[4])(argp1);
-...
-}
+Foo *make_Foo(int n);
</PRE>
</DIV>
-<P> Searches for multi-argument typemaps are not mentioned unless a
- matching multi-argument typemap does actually exist. For example, the
- output for the code in the <A href="#Typemaps_multi_argument_typemaps_patterns">
-earlier multi-arguments section</A> is as follows:</P>
-<DIV class="shell">
+<P> and you wanted to tell SWIG that <TT>make_Foo(int n)</TT> returned a
+ newly allocated object (for the purposes of providing better memory
+ management). Clearly, this property of <TT>make_Foo(int n)</TT> is<EM>
+ not</EM> a property that would be associated with the datatype <TT>Foo
+ *</TT> by itself. Therefore, a completely different SWIG customization
+ mechanism (<TT>%feature</TT>) is used for this purpose. Consult the <A href="#Customization">
+Customization Features</A> chapter for more information about that.</P>
+<P> Typemaps also can't be used to rearrange or transform the order of
+ arguments. For example, if you had a function like this:</P>
+<DIV class="code">
<PRE>
-...
-example.h:39: Searching for a suitable 'in' typemap for: char *buffer
- Looking for: char *buffer
- Multi-argument typemap found...
- Using: %typemap(in) (char *buffer,int len)
-...
+void foo(int, char *);
</PRE>
</DIV>
-<P> The second option for debugging is <TT>-debug-tmused</TT> and this
- displays the typemaps used. This option is a less verbose version of
- the <TT>-debug-tmsearch</TT> option as it only displays each
- successfully found typemap on a separate single line. The output
- displays the type, and name if present, the typemap method in brackets
- and then the actual typemap used in the same simplified format output
- by the <TT>-debug-tmsearch</TT> option. Below is the output for the
- example code at the start of this section on debugging.</P>
-<DIV class="shell">
+<P> you can't use typemaps to interchange the arguments, allowing you to
+ call the function like this:</P>
+<DIV class="targetlang">
<PRE>
-$ swig -perl -debug-tmused example.i
-example.h:3: Typemap for Row4 rows[10] (in) : %typemap(in) SWIGTYPE []
-example.h:3: Typemap for Row4 rows[10] (typecheck) : %typemap(typecheck) SWIGTYPE *
-example.h:3: Typemap for Row4 rows[10] (freearg) : %typemap(freearg) SWIGTYPE []
-example.h:3: Typemap for void foo (out) : %typemap(out) void
+foo("hello",3) # Reversed arguments
</PRE>
</DIV>
-<P> Now, consider the following interface file:</P>
+<P> If you want to change the calling conventions of a function, write a
+ helper function instead. For example:</P>
<DIV class="code">
<PRE>
-%module example
-
-%{
-void set_value(const char* val) {}
-%}
-
-%typemap(check) char *NON_NULL {
- if (!$1) {
- /* ... error handling ... */
- }
-}
-
-// use default pointer handling instead of strings
-%apply SWIGTYPE * { const char* val, const char* another_value }
-
-%typemap(check) const char* val = char* NON_NULL;
-
-%typemap(arginit, noblock=1) const char* val {
- $1 = "";
+%rename(foo) wrap_foo;
+%inline %{
+void wrap_foo(char *s, int x) {
+ foo(x,s);
}
-
-void set_value(const char* val);
-
-</PRE>
-</DIV>
-<P> and the output debug:</P>
-<DIV class="shell">
-<PRE>
-swig -perl5 -debug-tmused example.i
-example.i:21: Typemap for char const *val (arginit) : %typemap(arginit) char const *val
-example.i:21: Typemap for char const *val (in) : %apply SWIGTYPE * { char const *val }
-example.i:21: Typemap for char const *val (typecheck) : %apply SWIGTYPE * { char const *val }
-example.i:21: Typemap for char const *val (check) : %typemap(check) char const *val = char *NON_NULL
-example.i:21: Typemap for char const *val (freearg) : %apply SWIGTYPE * { char const *val }
-example.i:21: Typemap for void set_value (out) : %typemap(out) void
+%}
</PRE>
</DIV>
-<P> The following observations about what is displayed can be noted (the
- same applies for <TT>-debug-tmsearch</TT>):</P>
+<H3><A name="Typemaps_aspects">11.1.7 Similarities to Aspect Oriented
+ Programming</A></H3>
+<P> SWIG has parallels to <A href="http://en.wikipedia.org/wiki/Aspect-oriented_programming">
+Aspect Oriented Software Development (AOP)</A>. The <A href="http://en.wikipedia.org/wiki/Aspect-oriented_programming#Terminology">
+AOP terminology</A> with respect to SWIG typemaps can be viewed as
+ follows:</P>
<UL>
-<LI> The relevant typemap is shown, but for typemap copying, the
- appropriate <TT>%typemap</TT> or <TT>%apply</TT> is displayed, for
- example, the "check" and "in" typemaps.</LI>
-<LI> The typemap modifiers are not shown, eg the <TT>noblock=1</TT>
- modifier in the "arginit" typemap.</LI>
-<LI> The exact <TT>%apply</TT> statement might look different to what is
- in the actual code. For example, the <TT>const char* another_value</TT>
- is not shown as it is not relevant here. Also the types may be
- displayed slightly differently - <TT>char const *</TT> and not <TT>
-const char*</TT>.</LI>
+<LI><B> Cross-cutting concerns</B>: The cross-cutting concerns are the
+ modularization of the functionality that the typemaps implement, which
+ is primarily marshalling of types from/to the target language and
+ C/C++.</LI>
+<LI><B> Advice</B>: The typemap body contains code which is executed
+ whenever the marshalling is required.</LI>
+<LI><B> Pointcut</B>: The pointcuts are the positions in the wrapper
+ code that the typemap code is generated into.</LI>
+<LI><B> Aspect</B>: Aspects are the combination of the pointcut and the
+ advice, hence each typemap is an aspect.</LI>
</UL>
-<H2><A name="Typemaps_nn21"></A>10.4 Code generation rules</H2>
-<P> This section describes rules by which typemap code is inserted into
- the generated wrapper code.</P>
-<H3><A name="Typemaps_nn22"></A>10.4.1 Scope</H3>
-<P> When a typemap is defined like this:</P>
+<P> SWIG can also be viewed as has having a second set of aspects based
+ around <A href="#Customization">%feature</A>. Features such as <TT>
+%exception</TT> are also cross-cutting concerns as they encapsulate code
+ that can be used to add logging or exception handling to any function.</P>
+<H3><A name="Typemaps_nn9">11.1.8 The rest of this chapter</A></H3>
+<P> The rest of this chapter provides detailed information for people
+ who want to write new typemaps. This information is of particular
+ importance to anyone who intends to write a new SWIG target language
+ module. Power users can also use this information to write application
+ specific type conversion rules.</P>
+<P> Since typemaps are strongly tied to the underlying C++ type system,
+ subsequent sections assume that you are reasonably familiar with the
+ basic details of values, pointers, references, arrays, type qualifiers
+ (e.g., <TT>const</TT>), structures, namespaces, templates, and memory
+ management in C/C++. If not, you would be well-advised to consult a
+ copy of "The C Programming Language" by Kernighan and Ritchie or "The
+ C++ Programming Language" by Stroustrup before going any further.</P>
+<H2><A name="Typemaps_nn10">11.2 Typemap specifications</A></H2>
+<P> This section describes the behavior of the <TT>%typemap</TT>
+ directive itself.</P>
+<H3><A name="Typemaps_defining">11.2.1 Defining a typemap</A></H3>
+<P> New typemaps are defined using the <TT>%typemap</TT> declaration.
+ The general form of this declaration is as follows (parts enclosed in [
+ ... ] are optional):</P>
<DIV class="code">
<PRE>
-%typemap(in) int {
- $1 = PyInt_AsLong($input);
-}
+%typemap(<EM>method</EM> [, <EM>modifiers</EM>]) <EM>typelist</EM> <EM>code</EM> ;
</PRE>
</DIV>
-<P> the typemap code is inserted into the wrapper function using a new
- block scope. In other words, the wrapper code will look like this:</P>
-<DIV class="code">
-<PRE>
-wrap_whatever() {
- ...
- // Typemap code
- {
- arg1 = PyInt_AsLong(obj1);
- }
- ...
+<P><EM> method</EM> is a simply a name that specifies what kind of
+ typemap is being defined. It is usually a name like <TT>"in"</TT>, <TT>
+"out"</TT>, or <TT>"argout"</TT>. The purpose of these methods is
+ described later.</P>
+<P><EM> modifiers</EM> is an optional comma separated list of <TT>
+name="value"</TT> values. These are sometimes to attach extra
+ information to a typemap and is often target-language dependent. They
+ are also known as typemap attributes.</P>
+<P><EM> typelist</EM> is a list of the C++ type patterns that the
+ typemap will match. The general form of this list is as follows:</P>
+<DIV class="diagram">
+<PRE>
+typelist : typepattern [, typepattern, typepattern, ... ] ;
+
+typepattern : type [ (parms) ]
+ | type name [ (parms) ]
+ | ( typelist ) [ (parms) ]
+
+</PRE>
+</DIV>
+<P> Each type pattern is either a simple type, a simple type and
+ argument name, or a list of types in the case of multi-argument
+ typemaps. In addition, each type pattern can be parameterized with a
+ list of temporary variables (parms). The purpose of these variables
+ will be explained shortly.</P>
+<P><EM>code</EM> specifies the code used in the typemap. Usually this is
+ C/C++ code, but in the statically typed target languages, such as Java
+ and C#, this can contain target language code for certain typemaps. It
+ can take any one of the following forms:</P>
+<DIV class="diagram">
+<PRE>
+code : { ... }
+ | " ... "
+ | %{ ... %}
+</PRE>
+</DIV>
+<P> Note that the preprocessor will expand code within the {}
+ delimiters, but not in the last two styles of delimiters, see <A href="#Preprocessor_delimiters">
+Preprocessor and Typemaps</A>. Here are some examples of valid typemap
+ specifications:</P>
+<DIV class="code">
+<PRE>
+/* Simple typemap declarations */
+%typemap(in) int {
+ $1 = PyInt_AsLong($input);
+}
+%typemap(in) int "$1 = PyInt_AsLong($input);";
+%typemap(in) int %{
+ $1 = PyInt_AsLong($input);
+%}
+
+/* Typemap with extra argument name */
+%typemap(in) int nonnegative {
+ ...
+}
+
+/* Multiple types in one typemap */
+%typemap(in) int, short, long {
+ $1 = SvIV($input);
+}
+
+/* Typemap with modifiers */
+%typemap(in,doc="integer") int "$1 = scm_to_int($input);";
+
+/* Typemap applied to patterns of multiple arguments */
+%typemap(in) (char *str, int len),
+ (char *buffer, int size)
+{
+ $1 = PyString_AsString($input);
+ $2 = PyString_Size($input);
+}
+
+/* Typemap with extra pattern parameters */
+%typemap(in, numinputs=0) int *output (int temp),
+ long *output (long temp)
+{
+ $1 = &temp;
}
</PRE>
</DIV>
-<P> Because the typemap code is enclosed in its own block, it is legal
- to declare temporary variables for use during typemap execution. For
- example:</P>
+<P> Admittedly, it's not the most readable syntax at first glance.
+ However, the purpose of the individual pieces will become clear.</P>
+<H3><A name="Typemaps_nn12">11.2.2 Typemap scope</A></H3>
+<P> Once defined, a typemap remains in effect for all of the
+ declarations that follow. A typemap may be redefined for different
+ sections of an input file. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) short {
- long temp; /* Temporary value */
- if (Tcl_GetLongFromObj(interp, $input, &temp) != TCL_OK) {
- return TCL_ERROR;
- }
- $1 = (short) temp;
+// typemap1
+%typemap(in) int {
+...
+}
+
+int fact(int); // typemap1
+int gcd(int x, int y); // typemap1
+
+// typemap2
+%typemap(in) int {
+...
}
+
+int isprime(int); // typemap2
</PRE>
</DIV>
-<P> Of course, any variables that you declare inside a typemap are
- destroyed as soon as the typemap code has executed (they are not
- visible to other parts of the wrapper function or other typemaps that
- might use the same variable names).</P>
-<P> Occasionally, typemap code will be specified using a few alternative
- forms. For example:</P>
+<P> One exception to the typemap scoping rules pertains to the <TT>
+%extend</TT> declaration. <TT>%extend</TT> is used to attach new
+ declarations to a class or structure definition. Because of this, all
+ of the declarations in an <TT>%extend</TT> block are subject to the
+ typemap rules that are in effect at the point where the class itself is
+ defined. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) int "$1 = PyInt_AsLong($input);";
-%typemap(in) int %{
-$1 = PyInt_AsLong($input);
-%}
-%typemap(in, noblock=1) int {
-$1 = PyInt_AsLong($input);
+class Foo {
+ ...
+};
+
+%typemap(in) int {
+ ...
}
+
+%extend Foo {
+ int blah(int x); // typemap has no effect. Declaration is attached to Foo which
+ // appears before the %typemap declaration.
+};
</PRE>
</DIV>
-<P> These three forms are mainly used for cosmetics--the specified code
- is not enclosed inside a block scope when it is emitted. This sometimes
- results in a less complicated looking wrapper function. Note that only
- the third of the three typemaps have the typemap code passed through
- the SWIG preprocessor.</P>
-<H3><A name="Typemaps_nn23"></A>10.4.2 Declaring new local variables</H3>
-<P> Sometimes it is useful to declare a new local variable that exists
- within the scope of the entire wrapper function. A good example of this
- might be an application in which you wanted to marshal strings. Suppose
- you had a C++ function like this</P>
+<H3><A name="Typemaps_nn13">11.2.3 Copying a typemap</A></H3>
+<P> A typemap is copied by using assignment. For example:</P>
<DIV class="code">
<PRE>
-int foo(std::string *s);
+%typemap(in) Integer = int;
</PRE>
</DIV>
-<P> and you wanted to pass a native string in the target language as an
- argument. For instance, in Perl, you wanted the function to work like
- this:</P>
-<DIV class="targetlang">
+<P> or this:</P>
+<DIV class="code">
<PRE>
-$x = foo("Hello World");
+%typemap(in) Integer, Number, int32_t = int;
</PRE>
</DIV>
-<P> To do this, you can't just pass a raw Perl string as the <TT>
-std::string *</TT> argument. Instead, you have to create a temporary <TT>
-std::string</TT> object, copy the Perl string data into it, and then
- pass a pointer to the object. To do this, simply specify the typemap
- with an extra parameter like this:</P>
+<P> Types are often managed by a collection of different typemaps. For
+ example:</P>
<DIV class="code">
<PRE>
-%typemap(in) std::string * <B>(std::string temp)</B> {
- unsigned int len;
- char *s;
- s = SvPV($input,len); /* Extract string data */
- temp.assign(s,len); /* Assign to temp */
- $1 = &temp; /* Set argument to point to temp */
-}
+%typemap(in) int { ... }
+%typemap(out) int { ... }
+%typemap(varin) int { ... }
+%typemap(varout) int { ... }
</PRE>
</DIV>
-<P> In this case, <TT>temp</TT> becomes a local variable in the scope of
- the entire wrapper function. For example:</P>
+<P> To copy all of these typemaps to a new type, use <TT>%apply</TT>.
+ For example:</P>
<DIV class="code">
<PRE>
-wrap_foo() {
- std::string temp; <--- Declaration of temp goes here
- ...
-
- /* Typemap code */
- {
- ...
- temp.assign(s,len);
- ...
- }
- ...
-}
+%apply int { Integer }; // Copy all int typemaps to Integer
+%apply int { Integer, Number }; // Copy all int typemaps to both Integer and Number
</PRE>
</DIV>
-<P> When you set <TT>temp</TT> to a value, it persists for the duration
- of the wrapper function and gets cleaned up automatically on exit.</P>
-<P> It is perfectly safe to use more than one typemap involving local
- variables in the same declaration. For example, you could declare a
- function as :</P>
+<P> The patterns for <TT>%apply</TT> follow the same rules as for <TT>
+%typemap</TT>. For example:</P>
<DIV class="code">
<PRE>
-void foo(std::string *x, std::string *y, std::string *z);
+%apply int *output { Integer *output }; // Typemap with name
+%apply (char *buf, int len) { (char *buffer, int size) }; // Multiple arguments
</PRE>
</DIV>
-<P> This is safely handled because SWIG actually renames all local
- variable references by appending an argument number suffix. Therefore,
- the generated code would actually look like this:</P>
+<H3><A name="Typemaps_nn14">11.2.4 Deleting a typemap</A></H3>
+<P> A typemap can be deleted by simply defining no code. For example:</P>
<DIV class="code">
<PRE>
-wrap_foo() {
- int *arg1; /* Actual arguments */
- int *arg2;
- int *arg3;
- std::string temp1; /* Locals declared in the typemap */
- std::string temp2;
- std::string temp3;
- ...
- {
- char *s;
- unsigned int len;
- ...
- temp1.assign(s,len);
- arg1 = *temp1;
- }
- {
- char *s;
- unsigned int len;
- ...
- temp2.assign(s,len);
- arg2 = &temp2;
- }
- {
- char *s;
- unsigned int len;
- ...
- temp3.assign(s,len);
- arg3 = &temp3;
- }
- ...
-}
+%typemap(in) int; // Clears typemap for int
+%typemap(in) int, long, short; // Clears typemap for int, long, short
+%typemap(in) int *output;
</PRE>
</DIV>
-<P> Some typemaps do not recognize local variables (or they may simply
- not apply). At this time, only typemaps that apply to argument
- conversion support this (input typemaps such as the "in" typemap).</P>
-<P><B> Note:</B></P>
-<P> When declaring a typemap for multiple types, each type must have its
- own local variable declaration.</P>
+<P> The <TT>%clear</TT> directive clears all typemaps for a given type.
+ For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) const std::string *, std::string * (std::string temp) // NO!
-// only std::string * has a local variable
-// const std::string * does not (oops)
-....
-
-%typemap(in) const std::string * (std::string temp), std::string * (std::string temp) // Correct
-....
+%clear int; // Removes all types for int
+%clear int *output, long *output;
</PRE>
</DIV>
-<H3><A name="Typemaps_special_variables"></A>10.4.3 Special variables</H3>
-<P> Within all typemaps, the following special variables are expanded.
- This is by no means a complete list as some target languages have
- additional special variables which are documented in the language
- specific chapters.</P>
-<CENTER>
-<TABLE border="1" summary="Typemap special variables">
-<TR><TH>Variable</TH><TH>Meaning</TH></TR>
-<TR><TD>$<EM>n</EM></TD><TD> A C local variable corresponding to type<EM>
- n</EM> in the typemap pattern.</TD></TR>
-<TR><TD>$argnum</TD><TD>Argument number. Only available in typemaps
- related to argument conversion</TD></TR>
-<TR><TD>$<EM>n</EM>_name</TD><TD>Argument name</TD></TR>
-<TR><TD>$<EM>n</EM>_type</TD><TD>Real C datatype of type<EM> n</EM>.</TD>
-</TR>
-<TR><TD>$<EM>n</EM>_ltype</TD><TD>ltype of type<EM> n</EM></TD></TR>
-<TR><TD>$<EM>n</EM>_mangle</TD><TD>Mangled form of type<EM> n</EM>. For
- example <TT>_p_Foo</TT></TD></TR>
-<TR><TD>$<EM>n</EM>_descriptor</TD><TD>Type descriptor structure for
- type<EM> n</EM>. For example <TT>SWIGTYPE_p_Foo</TT>. This is primarily
- used when interacting with the run-time type checker (described later).</TD>
-</TR>
-<TR><TD>$*<EM>n</EM>_type</TD><TD>Real C datatype of type<EM> n</EM>
- with one pointer removed.</TD></TR>
-<TR><TD>$*<EM>n</EM>_ltype</TD><TD>ltype of type<EM> n</EM> with one
- pointer removed.</TD></TR>
-<TR><TD>$*<EM>n</EM>_mangle</TD><TD>Mangled form of type<EM> n</EM> with
- one pointer removed.</TD></TR>
-<TR><TD>$*<EM>n</EM>_descriptor</TD><TD>Type descriptor structure for
- type<EM> n</EM> with one pointer removed.</TD></TR>
-<TR><TD>$&<EM>n</EM>_type</TD><TD>Real C datatype of type<EM> n</EM>
- with one pointer added.</TD></TR>
-<TR><TD>$&<EM>n</EM>_ltype</TD><TD>ltype of type<EM> n</EM> with one
- pointer added.</TD></TR>
-<TR><TD>$&<EM>n</EM>_mangle</TD><TD>Mangled form of type<EM> n</EM> with
- one pointer added.</TD></TR>
-<TR><TD>$&<EM>n</EM>_descriptor</TD><TD>Type descriptor structure for
- type<EM> n</EM> with one pointer added.</TD></TR>
-<TR><TD>$<EM>n</EM>_basetype</TD><TD>Base typename with all pointers and
- qualifiers stripped.</TD></TR>
-</TABLE>
-</CENTER>
-<P> Within the table, $<EM>n</EM> refers to a specific type within the
- typemap specification. For example, if you write this</P>
+<P><B> Note:</B> Since SWIG's default behavior is defined by typemaps,
+ clearing a fundamental type like <TT>int</TT> will make that type
+ unusable unless you also define a new set of typemaps immediately after
+ the clear operation.</P>
+<H3><A name="Typemaps_nn15">11.2.5 Placement of typemaps</A></H3>
+<P> Typemap declarations can be declared in the global scope, within a
+ C++ namespace, and within a C++ class. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) int *INPUT {
+%typemap(in) int {
+ ...
+}
+namespace std {
+ class string;
+ %typemap(in) string {
+ ...
+ }
}
+
+class Bar {
+public:
+ typedef const int & const_reference;
+ %typemap(out) const_reference {
+ ...
+ }
+};
</PRE>
</DIV>
-<P> then $1 refers to <TT>int *INPUT</TT>. If you have a typemap like
- this,</P>
+<P> When a typemap appears inside a namespace or class, it stays in
+ effect until the end of the SWIG input (just like before). However, the
+ typemap takes the local scope into account. Therefore, this code</P>
<DIV class="code">
<PRE>
-%typemap(in) (int argc, char *argv[]) {
- ...
+namespace std {
+ class string;
+ %typemap(in) string {
+ ...
+ }
}
</PRE>
</DIV>
-<P> then $1 refers to <TT>int argc</TT> and $2 refers to <TT>char
- *argv[]</TT>.</P>
-<P> Substitutions related to types and names always fill in values from
- the actual code that was matched. This is useful when a typemap might
- match multiple C datatype. For example:</P>
+<P> is really defining a typemap for the type <TT>std::string</TT>. You
+ could have code like this:</P>
<DIV class="code">
<PRE>
-%typemap(in) int, short, long {
- $1 = ($1_ltype) PyInt_AsLong($input);
+namespace std {
+ class string;
+ %typemap(in) string { /* std::string */
+ ...
+ }
+}
+
+namespace Foo {
+ class string;
+ %typemap(in) string { /* Foo::string */
+ ...
+ }
}
</PRE>
</DIV>
-<P> In this case, <TT>$1_ltype</TT> is replaced with the datatype that
- is actually matched.</P>
-<P> When typemap code is emitted, the C/C++ datatype of the special
- variables <TT>$1</TT> and <TT>$2</TT> is always an "ltype." An "ltype"
- is simply a type that can legally appear on the left-hand side of a C
- assignment operation. Here are a few examples of types and ltypes:</P>
+<P> In this case, there are two completely distinct typemaps that apply
+ to two completely different types (<TT>std::string</TT> and <TT>
+Foo::string</TT>).</P>
+<P> It should be noted that for scoping to work, SWIG has to know that <TT>
+string</TT> is a typename defined within a particular namespace. In this
+ example, this is done using the forward class declaration <TT>class
+ string</TT>.</P>
+<H2><A name="Typemaps_pattern_matching">11.3 Pattern matching rules</A></H2>
+<P> The section describes the pattern matching rules by which C/C++
+ datatypes are associated with typemaps. The matching rules can be
+ observed in practice by using the debugging options also described.</P>
+<H3><A name="Typemaps_nn17">11.3.1 Basic matching rules</A></H3>
+<P> Typemaps are matched using both a type and a name (typically the
+ name of a argument). For a given <TT>TYPE NAME</TT> pair, the following
+ rules are applied, in order, to find a match. The first typemap found
+ is used.</P>
+<UL>
+<LI>Typemaps that exactly match <TT>TYPE</TT> and <TT>NAME</TT>.</LI>
+<LI>Typemaps that exactly match <TT>TYPE</TT> only.</LI>
+<LI>If <TT>TYPE</TT> is a C++ template of type <TT>T< TPARMS ></TT>,
+ where <TT>TPARMS</TT> are the template parameters, the type is stripped
+ of the template parameters and the following checks are then made:
+<UL>
+<LI>Typemaps that exactly match <TT>T</TT> and <TT>NAME</TT>.</LI>
+<LI>Typemaps that exactly match <TT>T</TT> only.</LI>
+</UL>
+</LI>
+</UL>
+<P> If <TT>TYPE</TT> includes qualifiers (const, volatile, etc.), each
+ qualifier is stripped one at a time to form a new stripped type and the
+ matching rules above are repeated on the stripped type. The left-most
+ qualifier is stripped first, resulting in the right-most (or top-level)
+ qualifier being stripped last. For example <TT>int const*const</TT> is
+ first stripped to <TT>int *const</TT> then <TT>int *</TT>.</P>
+<P> If <TT>TYPE</TT> is an array. The following transformation is made:</P>
+<UL>
+<LI>Replace all dimensions to <TT>[ANY]</TT> and look for a generic
+ array typemap.</LI>
+</UL>
+<P> To illustrate, suppose that you had a function like this:</P>
+<DIV class="code">
+<PRE>
+int foo(const char *s);
+</PRE>
+</DIV>
+<P> To find a typemap for the argument <TT>const char *s</TT>, SWIG will
+ search for the following typemaps:</P>
<DIV class="diagram">
<PRE>
-type ltype
------- ----------------
-int int
-const int int
-const int * int *
-int [4] int *
-int [4][5] int (*)[5]
+const char *s Exact type and name match
+const char * Exact type match
+char *s Type and name match (qualifier stripped)
+char * Type match (qualifier stripped)
</PRE>
</DIV>
-<P> In most cases a ltype is simply the C datatype with qualifiers
- stripped off. In addition, arrays are converted into pointers.</P>
-<P> Variables such as <TT>$&1_type</TT> and <TT>$*1_type</TT> are used
- to safely modify the type by removing or adding pointers. Although not
- needed in most typemaps, these substitutions are sometimes needed to
- properly work with typemaps that convert values between pointers and
- values.</P>
-<P> If necessary, type related substitutions can also be used when
- declaring locals. For example:</P>
+<P> When more than one typemap rule might be defined, only the first
+ match found is actually used. Here is an example that shows how some of
+ the basic rules are applied:</P>
<DIV class="code">
<PRE>
-%typemap(in) int * ($*1_type temp) {
- temp = PyInt_AsLong($input);
- $1 = &temp;
+%typemap(in) int *x {
+ ... typemap 1
+}
+
+%typemap(in) int * {
+ ... typemap 2
+}
+
+%typemap(in) const int *z {
+ ... typemap 3
+}
+
+%typemap(in) int [4] {
+ ... typemap 4
+}
+
+%typemap(in) int [ANY] {
+ ... typemap 5
}
+
+void A(int *x); // int *x rule (typemap 1)
+void B(int *y); // int * rule (typemap 2)
+void C(const int *x); // int *x rule (typemap 1)
+void D(const int *z); // const int *z rule (typemap 3)
+void E(int x[4]); // int [4] rule (typemap 4)
+void F(int x[1000]); // int [ANY] rule (typemap 5)
</PRE>
</DIV>
-<P> There is one word of caution about declaring local variables in this
- manner. If you declare a local variable using a type substitution such
- as <TT>$1_ltype temp</TT>, it won't work like you expect for arrays and
- certain kinds of pointers. For example, if you wrote this,</P>
+<P><B> Compatibility note:</B> SWIG-2.0.0 introduced stripping the
+ qualifiers one step at a time. Prior versions stripped all qualifiers
+ in one step.</P>
+<H3><A name="Typemaps_typedef_reductions">11.3.2 Typedef reductions
+ matching</A></H3>
+<P> If no match is found using the rules in the previous section, SWIG
+ applies a typedef reduction to the type and repeats the typemap search
+ for the reduced type. To illustrate, suppose you had code like this:</P>
<DIV class="code">
<PRE>
-%typemap(in) int [10][20] {
- $1_ltype temp;
+%typemap(in) int {
+ ... typemap 1
}
+
+typedef int Integer;
+void blah(Integer x);
</PRE>
</DIV>
-<P> then the declaration of <TT>temp</TT> will be expanded as</P>
-<DIV class="code">
+<P> To find the typemap for <TT>Integer x</TT>, SWIG will first search
+ for the following typemaps:</P>
+<DIV class="diagram">
<PRE>
-int (*)[20] temp;
+Integer x
+Integer
</PRE>
</DIV>
-<P> This is illegal C syntax and won't compile. There is currently no
- straightforward way to work around this problem in SWIG due to the way
- that typemap code is expanded and processed. However, one possible
- workaround is to simply pick an alternative type such as <TT>void *</TT>
- and use casts to get the correct type when needed. For example:</P>
-<DIV class="code">
+<P> Finding no match, it then applies a reduction <TT>Integer -> int</TT>
+ to the type and repeats the search.</P>
+<DIV class="diagram">
<PRE>
-%typemap(in) int [10][20] {
- void *temp;
- ...
- (($1_ltype) temp)[i][j] = x; /* set a value */
- ...
-}
+int x
+int --> match: typemap 1
</PRE>
</DIV>
-<P> Another approach, which only works for arrays is to use the <TT>
-$1_basetype</TT> substitution. For example:</P>
+<P> Even though two types might be the same via typedef, SWIG allows
+ typemaps to be defined for each typename independently. This allows for
+ interesting customization possibilities based solely on the typename
+ itself. For example, you could write code like this:</P>
<DIV class="code">
<PRE>
-%typemap(in) int [10][20] {
- $1_basetype temp[10][20];
- ...
- temp[i][j] = x; /* set a value */
- ...
+typedef double pdouble; // Positive double
+
+// typemap 1
+%typemap(in) double {
+ ... get a double ...
}
+// typemap 2
+%typemap(in) pdouble {
+ ... get a positive double ...
+}
+double sin(double x); // typemap 1
+pdouble sqrt(pdouble x); // typemap 2
</PRE>
</DIV>
-<H3><A name="Typemaps_special_variable_macros"></A>10.4.4 Special
- variable macros</H3>
-<P> Special variable macros are like macro functions in that they take
- one or more input arguments which are used for the macro expansion.
- They look like macro/function calls but use the special variable <TT>$</TT>
- prefix to the macro name. Note that unlike normal macros, the expansion
- is not done by the preprocessor, it is done during the SWIG
- parsing/compilation stages. The following special variable macros are
- available across all language modules.</P>
-<H4><A name="Typemaps_special_macro_descriptor"></A>10.4.4.1
- $descriptor(type)</H4>
-<P> This macro expands into the type descriptor structure for any C/C++
- type specified in <TT>type</TT>. It behaves like the <TT>$1_descriptor</TT>
- special variable described above except that the type to expand is
- taken from the macro argument rather than inferred from the typemap
- type. For example, <TT>$descriptor(std::vector<int> *)</TT> will expand
- into <TT>SWIGTYPE_p_std__vectorT_int_t</TT>. This macro is mostly used
- in the scripting target languages and is demonstrated later in the <A href="#Typemaps_runtime_type_checker_usage">
-Run-time type checker usage</A> section.</P>
-<H4><A name="Typemaps_special_macro_typemap"></A>10.4.4.2
- $typemap(method, typepattern)</H4>
-<P> This macro uses the <A href="#Typemaps_pattern_matching">pattern
- matching rules</A> described earlier to lookup and then substitute the
- special variable macro with the code in the matched typemap. The
- typemap to search for is specified by the arguments, where <TT>method</TT>
- is the typemap method name and <TT>typepattern</TT> is a type pattern
- as per the <TT>%typemap</TT> specification in the <A href="#Typemaps_defining">
-Defining a typemap</A> section.</P>
-<P> The special variables within the matched typemap are expanded into
- those for the matched typemap type, not the typemap within which the
- macro is called. In practice, there is little use for this macro in the
- scripting target languages. It is mostly used in the target languages
- that are statically typed as a way to obtain the target language type
- given the C/C++ type and more commonly only when the C++ type is a
- template parameter.</P>
-<P> The example below is for C# only and uses some typemap method names
- documented in the C# chapter, but it shows some of the possible syntax
- variations.</P>
-<DIV class="code">
-<PRE>
-%typemap(cstype) unsigned long "uint"
-%typemap(cstype) unsigned long bb "bool"
-%typemap(cscode) BarClass %{
- void foo($typemap(cstype, unsigned long aa) var1,
- $typemap(cstype, unsigned long bb) var2,
- $typemap(cstype, (unsigned long bb)) var3,
- $typemap(cstype, unsigned long) var4)
- {
- // do something
- }
-%}
-</PRE>
-</DIV>
-<P> The result is the following expansion</P>
+<P> When reducing the type, only one typedef reduction is applied at a
+ time. The search process continues to apply reductions until a match is
+ found or until no more reductions can be made.</P>
+<P> For complicated types, the reduction process can generate a long
+ list of patterns. Consider the following:</P>
<DIV class="code">
<PRE>
-%typemap(cstype) unsigned long "uint"
-%typemap(cstype) unsigned long bb "bool"
-%typemap(cscode) BarClass %{
- void foo(uint var1,
- bool var2,
- bool var3,
- uint var4)
- {
- // do something
- }
-%}
+typedef int Integer;
+typedef Integer Row4[4];
+void foo(Row4 rows[10]);
</PRE>
</DIV>
-<H2><A name="Typemaps_nn25"></A>10.5 Common typemap methods</H2>
-<P> The set of typemaps recognized by a language module may vary.
- However, the following typemap methods are nearly universal:</P>
-<H3><A name="Typemaps_nn26"></A>10.5.1 "in" typemap</H3>
-<P> The "in" typemap is used to convert function arguments from the
- target language to C. For example:</P>
+<P> To find a match for the <TT>Row4 rows[10]</TT> argument, SWIG would
+ check the following patterns, stopping only when it found a match:</P>
<DIV class="code">
<PRE>
-%typemap(in) int {
- $1 = PyInt_AsLong($input);
-}
+Row4 rows[10]
+Row4 [10]
+Row4 rows[ANY]
+Row4 [ANY]
+
+# Reduce Row4 --> Integer[4]
+Integer rows[10][4]
+Integer [10][4]
+Integer rows[ANY][ANY]
+Integer [ANY][ANY]
+
+# Reduce Integer --> int
+int rows[10][4]
+int [10][4]
+int rows[ANY][ANY]
+int [ANY][ANY]
</PRE>
</DIV>
-<P> The following special variables are available:</P>
+<P> For parameterized types like templates, the situation is even more
+ complicated. Suppose you had some declarations like this:</P>
<DIV class="code">
<PRE>
-$input - Input object holding value to be converted.
-$symname - Name of function/method being wrapped
+typedef int Integer;
+typedef foo<Integer,Integer> fooii;
+void blah(fooii *x);
</PRE>
</DIV>
-<P> This is probably the most commonly redefined typemap because it can
- be used to implement customized conversions.</P>
-<P> In addition, the "in" typemap allows the number of converted
- arguments to be specified. The <TT>numinputs</TT> attributes
- facilitates this. For example:</P>
+<P> In this case, the following typemap patterns are searched for the
+ argument <TT>fooii *x</TT>:</P>
<DIV class="code">
<PRE>
-// Ignored argument.
-%typemap(in, numinputs=0) int *out (int temp) {
- $1 = &temp;
-}
+fooii *x
+fooii *
+
+# Reduce fooii --> foo<Integer,Integer>
+foo<Integer,Integer> *x
+foo<Integer,Integer> *
+
+# Reduce Integer -> int
+foo<int, Integer> *x
+foo<int, Integer> *
+
+# Reduce Integer -> int
+foo<int, int> *x
+foo<int, int> *
</PRE>
</DIV>
-<P> At this time, only zero or one arguments may be converted. When <TT>
-numinputs</TT> is set to 0, the argument is effectively ignored and
- cannot be supplied from the target language. The argument is still
- required when making the C/C++ call and the above typemap shows the
- value used is instead obtained from a locally declared variable called <TT>
-temp</TT>. Usually <TT>numinputs</TT> is not specified, whereupon the
- default value is 1, that is, there is a one to one mapping of the
- number of arguments when used from the target language to the C/C++
- call. <A href="#Typemaps_multi_argument_typemaps">Multi-argument
- typemaps</A> provide a similar concept where the number of arguments
- mapped from the target language to C/C++ can be changed for multiple
- adjacent C/C++ arguments.</P>
-<P><B> Compatibility note:</B> Specifying <TT>numinputs=0</TT> is the
- same as the old "ignore" typemap.</P>
-<H3><A name="Typemaps_nn27"></A>10.5.2 "typecheck" typemap</H3>
-<P> The "typecheck" typemap is used to support overloaded functions and
- methods. It merely checks an argument to see whether or not it matches
- a specific type. For example:</P>
+<P> Typemap reductions are always applied to the left-most type that
+ appears. Only when no reductions can be made to the left-most type are
+ reductions made to other parts of the type. This behavior means that
+ you could define a typemap for <TT>foo<int,Integer></TT>, but a typemap
+ for <TT>foo<Integer,int></TT> would never be matched. Admittedly, this
+ is rather esoteric--there's little practical reason to write a typemap
+ quite like that. Of course, you could rely on this to confuse your
+ coworkers even more.</P>
+<P> As a point of clarification, it is worth emphasizing that typedef
+ matching is a typedef<B> reduction</B> process only, that is, SWIG does
+ not search for every single possible typedef. Given a type in a
+ declaration, it will only reduce the type, it won't build it up looking
+ for typedefs. For example, given the type <TT>Struct</TT>, the typemap
+ below will not be used for the <TT>aStruct</TT> parameter, because <TT>
+Struct</TT> is fully reduced:</P>
<DIV class="code">
<PRE>
-%typemap(typecheck,precedence=SWIG_TYPECHECK_INTEGER) int {
- $1 = PyInt_Check($input) ? 1 : 0;
+struct Struct {...};
+typedef Struct StructTypedef;
+
+%typemap(in) StructTypedef {
+ ...
}
+
+void go(Struct aStruct);
</PRE>
</DIV>
-<P> For typechecking, the $1 variable is always a simple integer that is
- set to 1 or 0 depending on whether or not the input argument is the
- correct type.</P>
-<P> If you define new "in" typemaps<EM> and</EM> your program uses
- overloaded methods, you should also define a collection of "typecheck"
- typemaps. More details about this follow in the <A href="#Typemaps_overloading">
-Typemaps and overloading</A> section.</P>
-<H3><A name="Typemaps_nn28"></A>10.5.3 "out" typemap</H3>
-<P> The "out" typemap is used to convert function/method return values
- from C into the target language. For example:</P>
+<H3><A name="Typemaps_nn19">11.3.3 Default typemap matching rules</A></H3>
+<P> If the basic pattern matching rules result in no match being made,
+ even after typedef reductions, the default typemap matching rules are
+ used to look for a suitable typemap match. These rules match a generic
+ typemap based on the reserved <TT>SWIGTYPE</TT> base type. For example
+ pointers will use <TT>SWIGTYPE *</TT> and references will use <TT>
+SWIGTYPE &</TT>. More precisely, the rules are based on the C++ class
+ template partial specialization matching rules used by C++ compilers
+ when looking for an appropriate partial template specialization. This
+ means that a match is chosen from the most specialized set of generic
+ typemap types available. For example, when looking for a match to <TT>
+int const *</TT>, the rules will prefer to match <TT>SWIGTYPE const *</TT>
+ if available before matching <TT>SWIGTYPE *</TT>, before matching <TT>
+SWIGTYPE</TT>.</P>
+<P> Most SWIG language modules use typemaps to define the default
+ behavior of the C primitive types. This is entirely straightforward.
+ For example, a set of typemaps for primitives marshalled by value or
+ const reference are written like this:</P>
<DIV class="code">
<PRE>
-%typemap(out) int {
- $result = PyInt_FromLong($1);
-}
+%typemap(in) int "... convert to int ...";
+%typemap(in) short "... convert to short ...";
+%typemap(in) float "... convert to float ...";
+...
+%typemap(in) const int & "... convert ...";
+%typemap(in) const short & "... convert ...";
+%typemap(in) const float & "... convert ...";
+...
</PRE>
</DIV>
-<P> The following special variables are available.</P>
+<P> Since typemap matching follows all <TT>typedef</TT> declarations,
+ any sort of type that is mapped to a primitive type by value or const
+ reference through <TT>typedef</TT> will be picked up by one of these
+ primitive typemaps. Most language modules also define typemaps for char
+ pointers and char arrays to handle strings, so these non-default types
+ will also be used in preference as the basic typemap matching rules
+ provide a better match than the default typemap matching rules.</P>
+<P> Below is a list of the typical default types supplied by language
+ modules, showing what the "in" typemap would look like:</P>
<DIV class="code">
<PRE>
-$result - Result object returned to target language.
-$symname - Name of function/method being wrapped
+%typemap(in) SWIGTYPE & { ... default reference handling ... };
+%typemap(in) SWIGTYPE * { ... default pointer handling ... };
+%typemap(in) SWIGTYPE *const { ... default pointer const handling ... };
+%typemap(in) SWIGTYPE *const& { ... default pointer const reference handling ... };
+%typemap(in) SWIGTYPE[ANY] { ... 1D fixed size arrays handlling ... };
+%typemap(in) SWIGTYPE [] { ... unknown sized array handling ... };
+%typemap(in) enum SWIGTYPE { ... default handling for enum values ... };
+%typemap(in) const enum SWIGTYPE & { ... default handling for const enum reference values ... };
+%typemap(in) SWIGTYPE (CLASS::*) { ... default pointer member handling ... };
+%typemap(in) SWIGTYPE { ... simple default handling ... };
</PRE>
</DIV>
-<P> The "out" typemap supports an optional attribute flag called
- "optimal". This is for code optimisation and is detailed in the <A href="#Typemaps_optimal">
-Optimal code generation when returning by value</A> section.</P>
-<H3><A name="Typemaps_nn29"></A>10.5.4 "arginit" typemap</H3>
-<P> The "arginit" typemap is used to set the initial value of a function
- argument--before any conversion has occurred. This is not normally
- necessary, but might be useful in highly specialized applications. For
- example:</P>
+<P> If you wanted to change SWIG's default handling for simple pointers,
+ you would simply redefine the rule for <TT>SWIGTYPE *</TT>. Note, the
+ simple default typemap rule is used to match against simple types that
+ don't match any other rules:</P>
<DIV class="code">
<PRE>
-// Set argument to NULL before any conversion occurs
-%typemap(arginit) int *data {
- $1 = NULL;
-}
+%typemap(in) SWIGTYPE { ... simple default handling ... }
</PRE>
</DIV>
-<H3><A name="Typemaps_nn30"></A>10.5.5 "default" typemap</H3>
-<P> The "default" typemap is used to turn an argument into a default
- argument. For example:</P>
+<P> This typemap is important because it is the rule that gets triggered
+ when call or return by value is used. For instance, if you have a
+ declaration like this:</P>
<DIV class="code">
<PRE>
-%typemap(default) int flags {
- $1 = DEFAULT_FLAGS;
-}
-...
-int foo(int x, int y, int flags);
+double dot_product(Vector a, Vector b);
</PRE>
</DIV>
-<P> The primary use of this typemap is to either change the wrapping of
- default arguments or specify a default argument in a language where
- they aren't supported (like C). Target languages that do not support
- optional arguments, such as Java and C#, effectively ignore the value
- specified by this typemap as all arguments must be given.</P>
-<P> Once a default typemap has been applied to an argument, all
- arguments that follow must have default values. See the <A href="#SWIG_default_args">
-Default/optional arguments</A> section for further information on
- default argument wrapping.</P>
-<H3><A name="Typemaps_nn31"></A>10.5.6 "check" typemap</H3>
-<P> The "check" typemap is used to supply value checking code during
- argument conversion. The typemap is applied<EM> after</EM> arguments
- have been converted. For example:</P>
+<P> The <TT>Vector</TT> type will usually just get matched against <TT>
+SWIGTYPE</TT>. The default implementation of <TT>SWIGTYPE</TT> is to
+ convert the value into pointers (<A href="#SWIG_nn22">as described in
+ this earlier section</A>).</P>
+<P> By redefining <TT>SWIGTYPE</TT> it may be possible to implement
+ other behavior. For example, if you cleared all typemaps for <TT>
+SWIGTYPE</TT>, SWIG simply won't wrap any unknown datatype (which might
+ be useful for debugging). Alternatively, you might modify SWIGTYPE to
+ marshal objects into strings instead of converting them to pointers.</P>
+<P> Let's consider an example where the following typemaps are defined
+ and SWIG is looking for the best match for the enum shown below:</P>
<DIV class="code">
<PRE>
-%typemap(check) int positive {
- if ($1 <= 0) {
- SWIG_exception(SWIG_ValueError,"Expected positive value.");
- }
-}
+%typemap(in) const Hello & { ... }
+%typemap(in) const enum SWIGTYPE & { ... }
+%typemap(in) enum SWIGTYPE & { ... }
+%typemap(in) SWIGTYPE & { ... }
+%typemap(in) SWIGTYPE { ... }
+
+enum Hello {};
+const Hello &hi;
</PRE>
</DIV>
-<H3><A name="Typemaps_nn32"></A>10.5.7 "argout" typemap</H3>
-<P> The "argout" typemap is used to return values from arguments. This
- is most commonly used to write wrappers for C/C++ functions that need
- to return multiple values. The "argout" typemap is almost always
- combined with an "in" typemap---possibly to ignore the input value. For
- example:</P>
+<P> The typemap at the top of the list will be chosen, not because it is
+ defined first, but because it is the closest match for the type being
+ wrapped. If any of the typemaps in the above list were not defined,
+ then the next one on the list would have precedence.</P>
+<P> The best way to explore the default typemaps is to look at the ones
+ already defined for a particular language module. Typemap definitions
+ are usually found in the SWIG library in a file such as <TT>java.swg</TT>
+, <TT>csharp.swg</TT> etc. However, for many of the target languages the
+ typemaps are hidden behind complicated macros, so the best way to view
+ the default typemaps, or any typemaps for that matter, is to look at
+ the preprocessed output by running <TT>swig -E</TT> on any interface
+ file. Finally the best way to view the typemap matching rules in action
+ is via the <A href="#Typemaps_debugging_search">debugging typemap
+ pattern matching</A> options covered later on.</P>
+<P><B> Compatibility note:</B> The default typemap matching rules were
+ modified in SWIG-2.0.0 from a slightly simpler scheme to match the
+ current C++ class template partial specialization matching rules.</P>
+<H3><A name="Typemaps_multi_argument_typemaps_patterns">11.3.4
+ Multi-arguments typemaps</A></H3>
+<P> When multi-argument typemaps are specified, they take precedence
+ over any typemaps specified for a single type. For example:</P>
<DIV class="code">
<PRE>
-/* Set the input argument to point to a temporary variable */
-%typemap(in, numinputs=0) int *out (int temp) {
- $1 = &temp;
+%typemap(in) (char *buffer, int len) {
+ // typemap 1
}
-%typemap(argout) int *out {
- // Append output value $1 to $result
- ...
+%typemap(in) char *buffer {
+ // typemap 2
}
+
+void foo(char *buffer, int len, int count); // (char *buffer, int len)
+void bar(char *buffer, int blah); // char *buffer
</PRE>
</DIV>
-<P> The following special variables are available.</P>
-<DIV class="diagram">
+<P> Multi-argument typemaps are also more restrictive in the way that
+ they are matched. Currently, the first argument follows the matching
+ rules described in the previous section, but all subsequent arguments
+ must match exactly.</P>
+<H3><A name="Typemaps_matching_template_comparison">11.3.5 Matching
+ rules compared to C++ templates</A></H3>
+<P> For those intimately familiar with C++ templates, a comparison of
+ the typemap matching rules and template type deduction is interesting.
+ The two areas considered are firstly the default typemaps and their
+ similarities to partial template specialization and secondly,
+ non-default typemaps and their similarities to full template
+ specialization.</P>
+<P> For default (SWIGTYPE) typemaps the rules are inspired by C++ class
+ template partial specialization. For example, given partial
+ specialization for <TT>T const&</TT> :</P>
+<DIV class="code">
<PRE>
-$result - Result object returned to target language.
-$input - The original input object passed.
-$symname - Name of function/method being wrapped
+template <typename T> struct X { void a(); };
+template <typename T> struct X< T const& > { void b(); };
</PRE>
</DIV>
-<P> The code supplied to the "argout" typemap is always placed after the
- "out" typemap. If multiple return values are used, the extra return
- values are often appended to return value of the function.</P>
-<P> See the <TT>typemaps.i</TT> library file for examples.</P>
-<H3><A name="Typemaps_nn33"></A>10.5.8 "freearg" typemap</H3>
-<P> The "freearg" typemap is used to cleanup argument data. It is only
- used when an argument might have allocated resources that need to be
- cleaned up when the wrapper function exits. The "freearg" typemap
- usually cleans up argument resources allocated by the "in" typemap. For
- example:</P>
+<P> The full (unspecialized) template is matched with most types, such
+ as:</P>
<DIV class="code">
<PRE>
-// Get a list of integers
-%typemap(in) int *items {
- int nitems = Length($input);
- $1 = (int *) malloc(sizeof(int)*nitems);
-}
-// Free the list
-%typemap(freearg) int *items {
- free($1);
-}
+X< int & > x1; x1.a();
</PRE>
</DIV>
-<P> The "freearg" typemap inserted at the end of the wrapper function,
- just before control is returned back to the target language. This code
- is also placed into a special variable <TT>$cleanup</TT> that may be
- used in other typemaps whenever a wrapper function needs to abort
- prematurely.</P>
-<H3><A name="Typemaps_nn34"></A>10.5.9 "newfree" typemap</H3>
-<P> The "newfree" typemap is used in conjunction with the <TT>%newobject</TT>
- directive and is used to deallocate memory used by the return result of
- a function. For example:</P>
+<P> and the following all match the <TT>T const&</TT> partial
+ specialization:</P>
<DIV class="code">
<PRE>
-%typemap(newfree) string * {
- delete $1;
-}
-%typemap(out) string * {
- $result = PyString_FromString($1->c_str());
-}
-...
-
-%newobject foo;
-...
-string *foo();
+X< int *const& > x2; x2.b();
+X< int const*const& > x3; x3.b();
+X< int const& > x4; x4.b();
</PRE>
</DIV>
-<P> See <A href="#Customization_ownership">Object ownership and
- %newobject</A> for further details.</P>
-<H3><A name="Typemaps_nn35"></A>10.5.10 "memberin" typemap</H3>
-<P> The "memberin" typemap is used to copy data from<EM> an already
- converted input value</EM> into a structure member. It is typically
- used to handle array members and other special cases. For example:</P>
+<P> Now, given just these two default typemaps, where T is analogous to
+ SWIGTYPE:</P>
<DIV class="code">
<PRE>
-%typemap(memberin) int [4] {
- memmove($1, $input, 4*sizeof(int));
-}
+%typemap(...) SWIGTYPE { ... }
+%typemap(...) SWIGTYPE const& { ... }
</PRE>
</DIV>
-<P> It is rarely necessary to write "memberin" typemaps---SWIG already
- provides a default implementation for arrays, strings, and other
- objects.</P>
-<H3><A name="Typemaps_nn36"></A>10.5.11 "varin" typemap</H3>
-<P> The "varin" typemap is used to convert objects in the target
- language to C for the purposes of assigning to a C/C++ global variable.
- This is implementation specific.</P>
-<H3><A name="Typemaps_nn37"></A>10.5.12 "varout" typemap</H3>
-<P> The "varout" typemap is used to convert a C/C++ object to an object
- in the target language when reading a C/C++ global variable. This is
- implementation specific.</P>
-<H3><A name="throws_typemap"></A>10.5.13 "throws" typemap</H3>
-<P> The "throws" typemap is only used when SWIG parses a C++ method with
- an exception specification or has the <TT>%catches</TT> feature
- attached to the method. It provides a default mechanism for handling
- C++ methods that have declared the exceptions they will throw. The
- purpose of this typemap is to convert a C++ exception into an error or
- exception in the target language. It is slightly different to the other
- typemaps as it is based around the exception type rather than the type
- of a parameter or variable. For example:</P>
+<P> The generic default typemap <TT>SWIGTYPE</TT> is used with most
+ types, such as</P>
<DIV class="code">
<PRE>
-%typemap(throws) const char * %{
- PyErr_SetString(PyExc_RuntimeError, $1);
- SWIG_fail;
-%}
-void bar() throw (const char *);
+int &
</PRE>
</DIV>
-<P> As can be seen from the generated code below, SWIG generates an
- exception handler with the catch block comprising the "throws" typemap
- content.</P>
+<P> and the following all match the <TT>SWIGTYPE const&</TT> typemap,
+ just like the partial template matching:</P>
<DIV class="code">
<PRE>
-...
-try {
- bar();
-}
-catch(char const *_e) {
- PyErr_SetString(PyExc_RuntimeError, _e);
- SWIG_fail;
-
-}
-...
+int *const&
+int const*const&
+int const&
</PRE>
</DIV>
-<P> Note that if your methods do not have an exception specification yet
- they do throw exceptions, SWIG cannot know how to deal with them. For a
- neat way to handle these, see the <A href="#Customization_exception">
-Exception handling with %exception</A> section.</P>
-<H2><A name="Typemaps_nn39"></A>10.6 Some typemap examples</H2>
-<P> This section contains a few examples. Consult language module
- documentation for more examples.</P>
-<H3><A name="Typemaps_nn40"></A>10.6.1 Typemaps for arrays</H3>
-<P> A common use of typemaps is to provide support for C arrays
- appearing both as arguments to functions and as structure members.</P>
-<P> For example, suppose you had a function like this:</P>
+<P> Note that the template and typemap matching rules are not identical
+ for all default typemaps though, for example, with arrays.</P>
+<P> For non-default typemaps, one might expect SWIG to follow the fully
+ specialized template rules. This is nearly the case, but not quite.
+ Consider a very similar example to the earlier partially specialized
+ template but this time there is a fully specialized template:</P>
<DIV class="code">
<PRE>
-void set_vector(int type, float value[4]);
+template <typename T> struct Y { void a(); };
+template <> struct Y< int const & > { void b(); };
</PRE>
</DIV>
-<P> If you wanted to handle <TT>float value[4]</TT> as a list of floats,
- you might write a typemap similar to this:</P>
+<P> Only the one type matches the specialized template exactly:</P>
<DIV class="code">
<PRE>
-
-%typemap(in) float value[4] (float temp[4]) {
- int i;
- if (!PySequence_Check($input)) {
- PyErr_SetString(PyExc_ValueError,"Expected a sequence");
- return NULL;
- }
- if (PySequence_Length($input) != 4) {
- PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected 4 elements");
- return NULL;
- }
- for (i = 0; i < 4; i++) {
- PyObject *o = PySequence_GetItem($input,i);
- if (PyNumber_Check(o)) {
- temp[i] = (float) PyFloat_AsDouble(o);
- } else {
- PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers");
- return NULL;
- }
- }
- $1 = temp;
-}
+Y< int & > y1; y1.a();
+Y< int *const& > y2; y2.a();
+Y< int const *const& > y3; y3.a();
+Y< int const& > y4; y4.b(); // fully specialized match
</PRE>
</DIV>
-<P> In this example, the variable <TT>temp</TT> allocates a small array
- on the C stack. The typemap then populates this array and passes it to
- the underlying C function.</P>
-<P> When used from Python, the typemap allows the following type of
- function call:</P>
-<DIV class="targetlang">
+<P> Given typemaps with the same types used for the template declared
+ above, where T is again analogous to SWIGTYPE:</P>
+<DIV class="code">
<PRE>
->>> set_vector(type, [ 1, 2.5, 5, 20 ])
+%typemap(...) SWIGTYPE { ... }
+%typemap(...) int const& { ... }
</PRE>
</DIV>
-<P> If you wanted to generalize the typemap to apply to arrays of all
- dimensions you might write this:</P>
+<P> The comparison between non-default typemaps and fully specialized
+ single parameter templates turns out to be the same, as just the one
+ type will match the non-default typemap:</P>
<DIV class="code">
<PRE>
-%typemap(in) float value[ANY] (float temp[$1_dim0]) {
- int i;
- if (!PySequence_Check($input)) {
- PyErr_SetString(PyExc_ValueError,"Expected a sequence");
- return NULL;
- }
- if (PySequence_Length($input) != $1_dim0) {
- PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected $1_dim0 elements");
- return NULL;
- }
- for (i = 0; i < $1_dim0; i++) {
- PyObject *o = PySequence_GetItem($input,i);
- if (PyNumber_Check(o)) {
- temp[i] = (float) PyFloat_AsDouble(o);
- } else {
- PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers");
- return NULL;
- }
- }
- $1 = temp;
-}
+int &
+int *const&
+int const*const&
+int const& // matches non-default typemap int const&
</PRE>
</DIV>
-<P> In this example, the special variable <TT>$1_dim0</TT> is expanded
- with the actual array dimensions. Multidimensional arrays can be
- matched in a similar manner. For example:</P>
+<P> However, if a non-const type is used instead:</P>
<DIV class="code">
<PRE>
-%typemap(in) float matrix[ANY][ANY] (float temp[$1_dim0][$1_dim1]) {
- ... convert a 2d array ...
-}
+%typemap(...) SWIGTYPE { ... }
+%typemap(...) int & { ... }
</PRE>
</DIV>
-<P> For large arrays, it may be impractical to allocate storage on the
- stack using a temporary variable as shown. To work with heap allocated
- data, the following technique can be used.</P>
+<P> then there is a clear difference to template matching as both the
+ const and non-const types match the typemap:</P>
<DIV class="code">
<PRE>
-%typemap(in) float value[ANY] {
- int i;
- if (!PySequence_Check($input)) {
- PyErr_SetString(PyExc_ValueError,"Expected a sequence");
- return NULL;
- }
- if (PySequence_Length($input) != $1_dim0) {
- PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected $1_dim0 elements");
- return NULL;
- }
- $1 = (float *) malloc($1_dim0*sizeof(float));
- for (i = 0; i < $1_dim0; i++) {
- PyObject *o = PySequence_GetItem($input,i);
- if (PyNumber_Check(o)) {
- $1[i] = (float) PyFloat_AsDouble(o);
- } else {
- PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers");
- free($1);
- return NULL;
- }
- }
-}
-%typemap(freearg) float value[ANY] {
- if ($1) free($1);
-}
+int & // matches non-default typemap int &
+int *const&
+int const*const&
+int const& // matches non-default typemap int &
</PRE>
</DIV>
-<P> In this case, an array is allocated using <TT>malloc</TT>. The <TT>
-freearg</TT> typemap is then used to release the argument after the
- function has been called.</P>
-<P> Another common use of array typemaps is to provide support for array
- structure members. Due to subtle differences between pointers and
- arrays in C, you can't just "assign" to a array structure member.
- Instead, you have to explicitly copy elements into the array. For
- example, suppose you had a structure like this:</P>
+<P> There are other subtle differences such as typedef handling, but at
+ least it should be clear that the typemap matching rules are similar to
+ those for specialized template handling.</P>
+<H3><A name="Typemaps_debugging_search">11.3.6 Debugging typemap pattern
+ matching</A></H3>
+<P> There are two useful debug command line options available for
+ debugging typemaps, <TT>-debug-tmsearch</TT> and <TT>-debug-tmused</TT>
+.</P>
+<P> The <TT>-debug-tmsearch</TT> option is a verbose option for
+ debugging typemap searches. This can be very useful for watching the
+ pattern matching process in action and for debugging which typemaps are
+ used. The option displays all the typemaps and types that are looked
+ for until a successful pattern match is made. As the display includes
+ searches for each and every type needed for wrapping, the amount of
+ information displayed can be large. Normally you would manually search
+ through the displayed information for the particular type that you are
+ interested in.</P>
+<P> For example, consider some of the code used in the <A href="#Typemaps_typedef_reductions">
+Typedef reductions</A> section already covered:</P>
<DIV class="code">
<PRE>
-struct SomeObject {
- float value[4];
- ...
-};
+typedef int Integer;
+typedef Integer Row4[4];
+void foo(Row4 rows[10]);
</PRE>
</DIV>
-<P> When SWIG runs, it won't produce any code to set the <TT>vec</TT>
- member. You may even get a warning message like this:</P>
+<P> A sample of the debugging output is shown below for the "in"
+ typemap:</P>
<DIV class="shell">
<PRE>
-$ swig -python example.i
-example.i:10: Warning 462: Unable to set variable of type float [4].
+swig -perl -debug-tmsearch example.i
+...
+example.h:3: Searching for a suitable 'in' typemap for: Row4 rows[10]
+ Looking for: Row4 rows[10]
+ Looking for: Row4 [10]
+ Looking for: Row4 rows[ANY]
+ Looking for: Row4 [ANY]
+ Looking for: Integer rows[10][4]
+ Looking for: Integer [10][4]
+ Looking for: Integer rows[ANY][ANY]
+ Looking for: Integer [ANY][ANY]
+ Looking for: int rows[10][4]
+ Looking for: int [10][4]
+ Looking for: int rows[ANY][ANY]
+ Looking for: int [ANY][ANY]
+ Looking for: SWIGTYPE rows[ANY][ANY]
+ Looking for: SWIGTYPE [ANY][ANY]
+ Looking for: SWIGTYPE rows[ANY][]
+ Looking for: SWIGTYPE [ANY][]
+ Looking for: SWIGTYPE *rows[ANY]
+ Looking for: SWIGTYPE *[ANY]
+ Looking for: SWIGTYPE rows[ANY]
+ Looking for: SWIGTYPE [ANY]
+ Looking for: SWIGTYPE rows[]
+ Looking for: SWIGTYPE []
+ Using: %typemap(in) SWIGTYPE []
+...
</PRE>
</DIV>
-<P> These warning messages indicate that SWIG does not know how you want
- to set the <TT>vec</TT> field.</P>
-<P> To fix this, you can supply a special "memberin" typemap like this:</P>
+<P> showing that the best default match supplied by SWIG is the <TT>
+SWIGTYPE []</TT> typemap. As the example shows, the successful match
+ displays the used typemap source including typemap method, type and
+ optional name in one of these simplified formats:</P>
+<UL>
+<LI> <TT>Using: %typemap(method) type name</TT></LI>
+<LI> <TT>Using: %typemap(method) type name = type2 name2</TT></LI>
+<LI> <TT>Using: %apply type2 name2 { type name }</TT></LI>
+</UL>
+<P> This information might meet your debugging needs, however, you might
+ want to analyze further. If you next invoke SWIG with the <TT>-E</TT>
+ option to display the preprocessed output, and search for the
+ particular typemap used, you'll find the full typemap contents (example
+ shown below for Python):</P>
<DIV class="code">
<PRE>
-%typemap(memberin) float [ANY] {
- int i;
- for (i = 0; i < $1_dim0; i++) {
- $1[i] = $input[i];
- }
+%typemap(in, noblock=1) SWIGTYPE [] (void *argp = 0, int res = 0) {
+ res = SWIG_ConvertPtr($input, &argp,$descriptor, $disown | 0 );
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "$symname" "', argument "
+ "$argnum"" of type '" "$type""'");
+ }
+ $1 = ($ltype)(argp);
}
</PRE>
</DIV>
-<P> The memberin typemap is used to set a structure member from data
- that has already been converted from the target language to C. In this
- case, <TT>$input</TT> is the local variable in which converted input
- data is stored. This typemap then copies this data into the structure.</P>
-<P> When combined with the earlier typemaps for arrays, the combination
- of the "in" and "memberin" typemap allows the following usage:</P>
-<DIV class="targetlang">
+<P> The generated code for the <TT>foo</TT> wrapper will then contain
+ the snippets of the typemap with the special variables expanded. The
+ rest of this chapter will need reading though to fully understand all
+ of this, however, the relevant parts of the generated code for the
+ above typemap can be seen below:</P>
+<DIV class="code">
<PRE>
->>> s = SomeObject()
->>> s.x = [1, 2.5, 5, 10]
+SWIGINTERN PyObject *_wrap_foo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+...
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+...
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_a_4__int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "foo" "', argument "
+ "1"" of type '" "int [10][4]""'");
+ }
+ arg1 = (int (*)[4])(argp1);
+...
+}
</PRE>
</DIV>
-<P> Related to structure member input, it may be desirable to return
- structure members as a new kind of object. For example, in this
- example, you will get very odd program behavior where the structure
- member can be set nicely, but reading the member simply returns a
- pointer:</P>
-<DIV class="targetlang">
+<P> Searches for multi-argument typemaps are not mentioned unless a
+ matching multi-argument typemap does actually exist. For example, the
+ output for the code in the <A href="#Typemaps_multi_argument_typemaps_patterns">
+earlier multi-arguments section</A> is as follows:</P>
+<DIV class="shell">
<PRE>
->>> s = SomeObject()
->>> s.x = [1, 2.5, 5, 10]
->>> print s.x
-_1008fea8_p_float
->>>
+...
+example.h:39: Searching for a suitable 'in' typemap for: char *buffer
+ Looking for: char *buffer
+ Multi-argument typemap found...
+ Using: %typemap(in) (char *buffer,int len)
+...
</PRE>
</DIV>
-<P> To fix this, you can write an "out" typemap. For example:</P>
+<P> The second option for debugging is <TT>-debug-tmused</TT> and this
+ displays the typemaps used. This option is a less verbose version of
+ the <TT>-debug-tmsearch</TT> option as it only displays each
+ successfully found typemap on a separate single line. The output
+ displays the type, and name if present, the typemap method in brackets
+ and then the actual typemap used in the same simplified format output
+ by the <TT>-debug-tmsearch</TT> option. Below is the output for the
+ example code at the start of this section on debugging.</P>
+<DIV class="shell">
+<PRE>
+$ swig -perl -debug-tmused example.i
+example.h:3: Typemap for Row4 rows[10] (in) : %typemap(in) SWIGTYPE []
+example.h:3: Typemap for Row4 rows[10] (typecheck) : %typemap(typecheck) SWIGTYPE *
+example.h:3: Typemap for Row4 rows[10] (freearg) : %typemap(freearg) SWIGTYPE []
+example.h:3: Typemap for void foo (out) : %typemap(out) void
+</PRE>
+</DIV>
+<P> Now, consider the following interface file:</P>
<DIV class="code">
<PRE>
-%typemap(out) float [ANY] {
- int i;
- $result = PyList_New($1_dim0);
- for (i = 0; i < $1_dim0; i++) {
- PyObject *o = PyFloat_FromDouble((double) $1[i]);
- PyList_SetItem($result,i,o);
+%module example
+
+%{
+void set_value(const char* val) {}
+%}
+
+%typemap(check) char *NON_NULL {
+ if (!$1) {
+ /* ... error handling ... */
}
}
+
+// use default pointer handling instead of strings
+%apply SWIGTYPE * { const char* val, const char* another_value }
+
+%typemap(check) const char* val = char* NON_NULL;
+
+%typemap(arginit, noblock=1) const char* val {
+ $1 = "";
+}
+
+void set_value(const char* val);
+
</PRE>
</DIV>
-<P> Now, you will find that member access is quite nice:</P>
-<DIV class="targetlang">
+<P> and the output debug:</P>
+<DIV class="shell">
<PRE>
->>> s = SomeObject()
->>> s.x = [1, 2.5, 5, 10]
->>> print s.x
-[ 1, 2.5, 5, 10]
+swig -perl5 -debug-tmused example.i
+example.i:21: Typemap for char const *val (arginit) : %typemap(arginit) char const *val
+example.i:21: Typemap for char const *val (in) : %apply SWIGTYPE * { char const *val }
+example.i:21: Typemap for char const *val (typecheck) : %apply SWIGTYPE * { char const *val }
+example.i:21: Typemap for char const *val (check) : %typemap(check) char const *val = char *NON_NULL
+example.i:21: Typemap for char const *val (freearg) : %apply SWIGTYPE * { char const *val }
+example.i:21: Typemap for void set_value (out) : %typemap(out) void
</PRE>
</DIV>
-<P><B> Compatibility Note:</B> SWIG1.1 used to provide a special
- "memberout" typemap. However, it was mostly useless and has since been
- eliminated. To return structure members, simply use the "out" typemap.</P>
-<H3><A name="Typemaps_nn41"></A>10.6.2 Implementing constraints with
- typemaps</H3>
-<P> One particularly interesting application of typemaps is the
- implementation of argument constraints. This can be done with the
- "check" typemap. When used, this allows you to provide code for
- checking the values of function arguments. For example:</P>
+<P> The following observations about what is displayed can be noted (the
+ same applies for <TT>-debug-tmsearch</TT>):</P>
+<UL>
+<LI> The relevant typemap is shown, but for typemap copying, the
+ appropriate <TT>%typemap</TT> or <TT>%apply</TT> is displayed, for
+ example, the "check" and "in" typemaps.</LI>
+<LI> The typemap modifiers are not shown, eg the <TT>noblock=1</TT>
+ modifier in the "arginit" typemap.</LI>
+<LI> The exact <TT>%apply</TT> statement might look different to what is
+ in the actual code. For example, the <TT>const char* another_value</TT>
+ is not shown as it is not relevant here. Also the types may be
+ displayed slightly differently - <TT>char const *</TT> and not <TT>
+const char*</TT>.</LI>
+</UL>
+<H2><A name="Typemaps_nn21">11.4 Code generation rules</A></H2>
+<P> This section describes rules by which typemap code is inserted into
+ the generated wrapper code.</P>
+<H3><A name="Typemaps_nn22">11.4.1 Scope</A></H3>
+<P> When a typemap is defined like this:</P>
<DIV class="code">
<PRE>
-%module math
-
-%typemap(check) double posdouble {
- if ($1 < 0) {
- croak("Expecting a positive number");
- }
+%typemap(in) int {
+ $1 = PyInt_AsLong($input);
}
-
-...
-double sqrt(double posdouble);
-
</PRE>
</DIV>
-<P> This provides a sanity check to your wrapper function. If a negative
- number is passed to this function, a Perl exception will be raised and
- your program terminated with an error message.</P>
-<P> This kind of checking can be particularly useful when working with
- pointers. For example:</P>
+<P> the typemap code is inserted into the wrapper function using a new
+ block scope. In other words, the wrapper code will look like this:</P>
<DIV class="code">
<PRE>
-%typemap(check) Vector * {
- if ($1 == 0) {
- PyErr_SetString(PyExc_TypeError,"NULL Pointer not allowed");
- return NULL;
- }
+wrap_whatever() {
+ ...
+ // Typemap code
+ {
+ arg1 = PyInt_AsLong(obj1);
+ }
+ ...
}
-
</PRE>
</DIV>
-<P> will prevent any function involving a <TT>Vector *</TT> from
- accepting a NULL pointer. As a result, SWIG can often prevent a
- potential segmentation faults or other run-time problems by raising an
- exception rather than blindly passing values to the underlying C/C++
- program.</P>
-<H2><A name="Typemaps_nn43"></A>10.7 Typemaps for multiple target
- languages</H2>
-<P> The code within typemaps is usually language dependent, however,
- many target languages support the same typemaps. In order to
- distinguish typemaps across different languages, the preprocessor
- should be used. For example, the "in" typemap for Perl and Ruby could
- be written as:</P>
+<P> Because the typemap code is enclosed in its own block, it is legal
+ to declare temporary variables for use during typemap execution. For
+ example:</P>
<DIV class="code">
<PRE>
-#if defined(SWIGPERL)
- %typemap(in) int "$1 = ($1_ltype) SvIV($input);"
-#elif defined(SWIGRUBY)
- %typemap(in) int "$1 = NUM2INT($input);"
-#else
- #warning no "in" typemap defined
-#endif
+%typemap(in) short {
+ long temp; /* Temporary value */
+ if (Tcl_GetLongFromObj(interp, $input, &temp) != TCL_OK) {
+ return TCL_ERROR;
+ }
+ $1 = (short) temp;
+}
</PRE>
</DIV>
-<P> The full set of language specific macros is defined in the <A href="#Preprocessor_condition_compilation">
-Conditional Compilation</A> section. The example above also shows a
- common approach of issuing a warning for an as yet unsupported
- language.</P>
-<P><B> Compatibility note:</B> In SWIG-1.1 different languages could be
- distinguished with the language name being put within the <TT>%typemap</TT>
- directive, for example,
-<BR> <TT>%typemap(ruby,in) int "$1 = NUM2INT($input);"</TT>.</P>
-<H2><A name="Typemaps_optimal"></A>10.8 Optimal code generation when
- returning by value</H2>
-<P> The "out" typemap is the main typemap for return types. This typemap
- supports an optional attribute flag called "optimal", which is for
- reducing temporary variables and the amount of generated code, thereby
- giving the compiler the opportunity to use<I> return value optimization</I>
- for generating faster executing code. It only really makes a difference
- when returning objects by value and has some limitations on usage, as
- explained later on.</P>
-<P> When a function returns an object by value, SWIG generates code that
- instantiates the default type on the stack then assigns the value
- returned by the function call to it. A copy of this object is then made
- on the heap and this is what is ultimately stored and used from the
- target language. This will be clearer considering an example. Consider
- running the following code through SWIG:</P>
+<P> Of course, any variables that you declare inside a typemap are
+ destroyed as soon as the typemap code has executed (they are not
+ visible to other parts of the wrapper function or other typemaps that
+ might use the same variable names).</P>
+<P> Occasionally, typemap code will be specified using a few alternative
+ forms. For example:</P>
<DIV class="code">
<PRE>
-%typemap(out) SWIGTYPE %{
- $result = new $1_ltype((const $1_ltype &)$1);
-%}
-
-%inline %{
-#include <iostream>
-using namespace std;
-
-struct XX {
- XX() { cout << "XX()" << endl; }
- XX(int i) { cout << "XX(" << i << ")" << endl; }
- XX(const XX &other) { cout << "XX(const XX &)" << endl; }
- XX & operator =(const XX &other) { cout << "operator=(const XX &)" << endl; return *this; }
- ~XX() { cout << "~XX()" << endl; }
- static XX create() {
- return XX(0);
- }
-};
+%typemap(in) int "$1 = PyInt_AsLong($input);";
+%typemap(in) int %{
+$1 = PyInt_AsLong($input);
%}
+%typemap(in, noblock=1) int {
+$1 = PyInt_AsLong($input);
+}
</PRE>
</DIV>
-<P> The "out" typemap shown is the default typemap for C# when returning
- objects by value. When making a call to <TT>XX::create()</TT> from C#,
- the output is as follows:</P>
-<DIV class="targetlang">
-<PRE>
-XX()
-XX(0)
-operator=(const XX &)
-~XX()
-XX(const XX &)
-~XX()
-~XX()
-</PRE>
-</DIV>
-<P> Note that three objects are being created as well as an assignment.
- Wouldn't it be great if the <TT>XX::create()</TT> method was the only
- time a constructor was called? As the method returns by value, this is
- asking a lot and the code that SWIG generates by default makes it
- impossible for the compiler to use<I> return value optimisation (RVO)</I>
-. However, this is where the "optimal" attribute in the "out" typemap
- can help out. If the typemap code is kept the same and just the
- "optimal" attribute specified like this:</P>
+<P> These three forms are mainly used for cosmetics--the specified code
+ is not enclosed inside a block scope when it is emitted. This sometimes
+ results in a less complicated looking wrapper function. Note that only
+ the third of the three typemaps have the typemap code passed through
+ the SWIG preprocessor.</P>
+<H3><A name="Typemaps_nn23">11.4.2 Declaring new local variables</A></H3>
+<P> Sometimes it is useful to declare a new local variable that exists
+ within the scope of the entire wrapper function. A good example of this
+ might be an application in which you wanted to marshal strings. Suppose
+ you had a C++ function like this</P>
<DIV class="code">
<PRE>
-%typemap(out, optimal="1") SWIGTYPE %{
- $result = new $1_ltype((const $1_ltype &)$1);
-%}
+int foo(std::string *s);
</PRE>
</DIV>
-<P> then when the code is run again, the output is simply:</P>
+<P> and you wanted to pass a native string in the target language as an
+ argument. For instance, in Perl, you wanted the function to work like
+ this:</P>
<DIV class="targetlang">
<PRE>
-XX(0)
-~XX()
+$x = foo("Hello World");
</PRE>
</DIV>
-<P> How the "optimal" attribute works is best explained using the
- generated code. Without "optimal", the generated code is:</P>
+<P> To do this, you can't just pass a raw Perl string as the <TT>
+std::string *</TT> argument. Instead, you have to create a temporary <TT>
+std::string</TT> object, copy the Perl string data into it, and then
+ pass a pointer to the object. To do this, simply specify the typemap
+ with an extra parameter like this:</P>
<DIV class="code">
<PRE>
-SWIGEXPORT void * SWIGSTDCALL CSharp_XX_create() {
- void * jresult ;
- XX result;
- result = XX::create();
- jresult = new XX((const XX &)result);
- return jresult;
+%typemap(in) std::string * <B>(std::string temp)</B> {
+ unsigned int len;
+ char *s;
+ s = SvPV($input,len); /* Extract string data */
+ temp.assign(s,len); /* Assign to temp */
+ $1 = &temp; /* Set argument to point to temp */
}
-
</PRE>
</DIV>
-<P> With the "optimal" attribute, the code is:</P>
+<P> In this case, <TT>temp</TT> becomes a local variable in the scope of
+ the entire wrapper function. For example:</P>
<DIV class="code">
<PRE>
-SWIGEXPORT void * SWIGSTDCALL CSharp_XX_create() {
- void * jresult ;
- jresult = new XX((const XX &)XX::create());
- return jresult;
+wrap_foo() {
+ std::string temp; <--- Declaration of temp goes here
+ ...
+
+ /* Typemap code */
+ {
+ ...
+ temp.assign(s,len);
+ ...
+ }
+ ...
}
</PRE>
</DIV>
-<P> The major difference is the <TT>result</TT> temporary variable
- holding the value returned from <TT>XX::create()</TT> is no longer
- generated and instead the copy constructor call is made directly from
- the value returned by <TT>XX::create()</TT>. With modern compilers
- implementing RVO, the copy is not actually done, in fact the object is
- never created on the stack in <TT>XX::create()</TT> at all, it is
- simply created directly on the heap. In the first instance, the <TT>$1</TT>
- special variable in the typemap is expanded into <TT>result</TT>. In
- the second instance, <TT>$1</TT> is expanded into <TT>XX::create()</TT>
- and this is essentially what the "optimal" attribute is telling SWIG to
- do.</P>
-<P> The "optimal" attribute optimisation is not turned on by default as
- it has a number of restrictions. Firstly, some code cannot be condensed
- into a simple call for passing into the copy constructor. One common
- occurrence is when <A href="#Customization_exception">%exception</A> is
- used. Consider adding the following <TT>%exception</TT> to the example:</P>
+<P> When you set <TT>temp</TT> to a value, it persists for the duration
+ of the wrapper function and gets cleaned up automatically on exit.</P>
+<P> It is perfectly safe to use more than one typemap involving local
+ variables in the same declaration. For example, you could declare a
+ function as :</P>
<DIV class="code">
<PRE>
-%exception XX::create() %{
-try {
- $action
-} catch(const std::exception &e) {
- cout << e.what() << endl;
-}
-%}
+void foo(std::string *x, std::string *y, std::string *z);
</PRE>
</DIV>
-<P> SWIG can detect when the "optimal" attribute cannot be used and will
- ignore it and in this case will issue the following warning:</P>
-<DIV class="targetlang">
+<P> This is safely handled because SWIG actually renames all local
+ variable references by appending an argument number suffix. Therefore,
+ the generated code would actually look like this:</P>
+<DIV class="code">
<PRE>
-example.i:28: Warning 474: Method XX::create() usage of the optimal attribute ignored
-example.i:14: Warning 474: in the out typemap as the following cannot be used to generate
-optimal code:
-try {
- result = XX::create();
-} catch(const std::exception &e) {
- cout << e.what() << endl;
+wrap_foo() {
+ int *arg1; /* Actual arguments */
+ int *arg2;
+ int *arg3;
+ std::string temp1; /* Locals declared in the typemap */
+ std::string temp2;
+ std::string temp3;
+ ...
+ {
+ char *s;
+ unsigned int len;
+ ...
+ temp1.assign(s,len);
+ arg1 = *temp1;
+ }
+ {
+ char *s;
+ unsigned int len;
+ ...
+ temp2.assign(s,len);
+ arg2 = &temp2;
+ }
+ {
+ char *s;
+ unsigned int len;
+ ...
+ temp3.assign(s,len);
+ arg3 = &temp3;
+ }
+ ...
}
</PRE>
</DIV>
-<P> It should be clear that the above code cannot be used as the
- argument to the copy constructor call, that is, for the <TT>$1</TT>
- substitution.</P>
-<P> Secondly, if the typemaps uses <TT>$1</TT> more than once, then
- multiple calls to the wrapped function will be made. Obviously that is
- not very optimal. In fact SWIG attempts to detect this and will issue a
- warning something like:</P>
-<DIV class="targetlang">
+<P>There is an exception: if the variable name starts with the <TT>
+_global_</TT> prefix, the argument number is not appended. Such
+ variables can be used throughout the generated wrapper function. For
+ example, the above typemap could be rewritten to use <TT>_global_temp</TT>
+ instead of <TT>temp</TT> and the generated code would then contain a
+ single <TT>_global_temp</TT> variable instead of <TT>temp1</TT>, <TT>
+temp2</TT> and <TT>temp3</TT>:</P>
+<DIV class="code">
<PRE>
-example.i:21: Warning 475: Multiple calls to XX::create() might be generated due to
-example.i:7: Warning 475: optimal attribute usage in the out typemap.
+%typemap(in) std::string * <B>(std::string _global_temp)</B> {
+ ... as above ...
+}
</PRE>
</DIV>
-<P> However, it doesn't always get it right, for example when <TT>$1</TT>
- is within some commented out code.</P>
-<H2><A name="Typemaps_multi_argument_typemaps"></A>10.9 Multi-argument
- typemaps</H2>
-<P> So far, the typemaps presented have focused on the problem of
- dealing with single values. For example, converting a single input
- object to a single argument in a function call. However, certain
- conversion problems are difficult to handle in this manner. As an
- example, consider the example at the very beginning of this chapter:</P>
+<P> Some typemaps do not recognize local variables (or they may simply
+ not apply). At this time, only typemaps that apply to argument
+ conversion support this (input typemaps such as the "in" typemap).</P>
+<P><B> Note:</B></P>
+<P> When declaring a typemap for multiple types, each type must have its
+ own local variable declaration.</P>
<DIV class="code">
<PRE>
-int foo(int argc, char *argv[]);
+%typemap(in) const std::string *, std::string * (std::string temp) // NO!
+// only std::string * has a local variable
+// const std::string * does not (oops)
+....
+
+%typemap(in) const std::string * (std::string temp), std::string * (std::string temp) // Correct
+....
</PRE>
</DIV>
-<P> Suppose that you wanted to wrap this function so that it accepted a
- single list of strings like this:</P>
-<DIV class="targetlang">
+<H3><A name="Typemaps_special_variables">11.4.3 Special variables</A></H3>
+<P> Within all typemaps, the following special variables are expanded.
+ This is by no means a complete list as some target languages have
+ additional special variables which are documented in the language
+ specific chapters.</P>
+<CENTER>
+<TABLE border="1" summary="Typemap special variables">
+<TR><TH>Variable</TH><TH>Meaning</TH></TR>
+<TR><TD>$<EM>n</EM></TD><TD> A C local variable corresponding to type<EM>
+ n</EM> in the typemap pattern.</TD></TR>
+<TR><TD>$argnum</TD><TD>Argument number. Only available in typemaps
+ related to argument conversion</TD></TR>
+<TR><TD>$<EM>n</EM>_name</TD><TD>Argument name</TD></TR>
+<TR><TD>$<EM>n</EM>_type</TD><TD>Real C datatype of type<EM> n</EM>.</TD>
+</TR>
+<TR><TD>$<EM>n</EM>_ltype</TD><TD>ltype of type<EM> n</EM></TD></TR>
+<TR><TD>$<EM>n</EM>_mangle</TD><TD>Mangled form of type<EM> n</EM>. For
+ example <TT>_p_Foo</TT></TD></TR>
+<TR><TD>$<EM>n</EM>_descriptor</TD><TD>Type descriptor structure for
+ type<EM> n</EM>. For example <TT>SWIGTYPE_p_Foo</TT>. This is primarily
+ used when interacting with the run-time type checker (described later).</TD>
+</TR>
+<TR><TD>$*<EM>n</EM>_type</TD><TD>Real C datatype of type<EM> n</EM>
+ with one pointer removed.</TD></TR>
+<TR><TD>$*<EM>n</EM>_ltype</TD><TD>ltype of type<EM> n</EM> with one
+ pointer removed.</TD></TR>
+<TR><TD>$*<EM>n</EM>_mangle</TD><TD>Mangled form of type<EM> n</EM> with
+ one pointer removed.</TD></TR>
+<TR><TD>$*<EM>n</EM>_descriptor</TD><TD>Type descriptor structure for
+ type<EM> n</EM> with one pointer removed.</TD></TR>
+<TR><TD>$&<EM>n</EM>_type</TD><TD>Real C datatype of type<EM> n</EM>
+ with one pointer added.</TD></TR>
+<TR><TD>$&<EM>n</EM>_ltype</TD><TD>ltype of type<EM> n</EM> with one
+ pointer added.</TD></TR>
+<TR><TD>$&<EM>n</EM>_mangle</TD><TD>Mangled form of type<EM> n</EM> with
+ one pointer added.</TD></TR>
+<TR><TD>$&<EM>n</EM>_descriptor</TD><TD>Type descriptor structure for
+ type<EM> n</EM> with one pointer added.</TD></TR>
+<TR><TD>$<EM>n</EM>_basetype</TD><TD>Base typename with all pointers and
+ qualifiers stripped.</TD></TR>
+</TABLE>
+</CENTER>
+<P> Within the table, $<EM>n</EM> refers to a specific type within the
+ typemap specification. For example, if you write this</P>
+<DIV class="code">
<PRE>
->>> foo(["ale","lager","stout"])
+%typemap(in) int *INPUT {
+
+}
</PRE>
</DIV>
-<P> To do this, you not only need to map a list of strings to <TT>char
- *argv[]</TT>, but the value of <TT>int argc</TT> is implicitly
- determined by the length of the list. Using only simple typemaps, this
- type of conversion is possible, but extremely painful. Multi-argument
- typemaps help in this situation.</P>
-<P> A multi-argument typemap is a conversion rule that specifies how to
- convert a<EM> single</EM> object in the target language to a set of
- consecutive function arguments in C/C++. For example, the following
- multi-argument maps perform the conversion described for the above
- example:</P>
+<P> then $1 refers to <TT>int *INPUT</TT>. If you have a typemap like
+ this,</P>
<DIV class="code">
<PRE>
%typemap(in) (int argc, char *argv[]) {
- int i;
- if (!PyList_Check($input)) {
- PyErr_SetString(PyExc_ValueError, "Expecting a list");
- return NULL;
- }
- $1 = PyList_Size($input);
- $2 = (char **) malloc(($1+1)*sizeof(char *));
- for (i = 0; i < $1; i++) {
- PyObject *s = PyList_GetItem($input,i);
- if (!PyString_Check(s)) {
- free($2);
- PyErr_SetString(PyExc_ValueError, "List items must be strings");
- return NULL;
- }
- $2[i] = PyString_AsString(s);
- }
- $2[i] = 0;
-}
-
-%typemap(freearg) (int argc, char *argv[]) {
- if ($2) free($2);
+ ...
}
</PRE>
</DIV>
-<P> A multi-argument map is always specified by surrounding the
- arguments with parentheses as shown. For example:</P>
+<P> then $1 refers to <TT>int argc</TT> and $2 refers to <TT>char
+ *argv[]</TT>.</P>
+<P> Substitutions related to types and names always fill in values from
+ the actual code that was matched. This is useful when a typemap might
+ match multiple C datatype. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) (int argc, char *argv[]) { ... }
+%typemap(in) int, short, long {
+ $1 = ($1_ltype) PyInt_AsLong($input);
+}
</PRE>
</DIV>
-<P> Within the typemap code, the variables <TT>$1</TT>, <TT>$2</TT>, and
- so forth refer to each type in the map. All of the usual substitutions
- apply--just use the appropriate <TT>$1</TT> or <TT>$2</TT> prefix on
- the variable name (e.g., <TT>$2_type</TT>, <TT>$1_ltype</TT>, etc.)</P>
-<P> Multi-argument typemaps always have precedence over simple typemaps
- and SWIG always performs longest-match searching. Therefore, you will
- get the following behavior:</P>
-<DIV class="code">
+<P> In this case, <TT>$1_ltype</TT> is replaced with the datatype that
+ is actually matched.</P>
+<P> When typemap code is emitted, the C/C++ datatype of the special
+ variables <TT>$1</TT> and <TT>$2</TT> is always an "ltype." An "ltype"
+ is simply a type that can legally appear on the left-hand side of a C
+ assignment operation. Here are a few examples of types and ltypes:</P>
+<DIV class="diagram">
<PRE>
-%typemap(in) int argc { ... typemap 1 ... }
-%typemap(in) (int argc, char *argv[]) { ... typemap 2 ... }
-%typemap(in) (int argc, char *argv[], char *env[]) { ... typemap 3 ... }
-
-int foo(int argc, char *argv[]); // Uses typemap 2
-int bar(int argc, int x); // Uses typemap 1
-int spam(int argc, char *argv[], char *env[]); // Uses typemap 3
+type ltype
+------ ----------------
+int int
+const int int
+const int * int *
+int [4] int *
+int [4][5] int (*)[5]
</PRE>
</DIV>
-<P> It should be stressed that multi-argument typemaps can appear
- anywhere in a function declaration and can appear more than once. For
- example, you could write this:</P>
+<P> In most cases a ltype is simply the C datatype with qualifiers
+ stripped off. In addition, arrays are converted into pointers.</P>
+<P> Variables such as <TT>$&1_type</TT> and <TT>$*1_type</TT> are used
+ to safely modify the type by removing or adding pointers. Although not
+ needed in most typemaps, these substitutions are sometimes needed to
+ properly work with typemaps that convert values between pointers and
+ values.</P>
+<P> If necessary, type related substitutions can also be used when
+ declaring locals. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) (int scount, char *swords[]) { ... }
-%typemap(in) (int wcount, char *words[]) { ... }
-
-void search_words(int scount, char *swords[], int wcount, char *words[], int maxcount);
+%typemap(in) int * ($*1_type temp) {
+ temp = PyInt_AsLong($input);
+ $1 = &temp;
+}
</PRE>
</DIV>
-<P> Other directives such as <TT>%apply</TT> and <TT>%clear</TT> also
- work with multi-argument maps. For example:</P>
+<P> There is one word of caution about declaring local variables in this
+ manner. If you declare a local variable using a type substitution such
+ as <TT>$1_ltype temp</TT>, it won't work like you expect for arrays and
+ certain kinds of pointers. For example, if you wrote this,</P>
<DIV class="code">
<PRE>
-%apply (int argc, char *argv[]) {
- (int scount, char *swords[]),
- (int wcount, char *words[])
-};
-...
-%clear (int scount, char *swords[]), (int wcount, char *words[]);
-...
+%typemap(in) int [10][20] {
+ $1_ltype temp;
+}
</PRE>
</DIV>
-<P> Although multi-argument typemaps may seem like an exotic, little
- used feature, there are several situations where they make sense.
- First, suppose you wanted to wrap functions similar to the low-level <TT>
-read()</TT> and <TT>write()</TT> system calls. For example:</P>
+<P> then the declaration of <TT>temp</TT> will be expanded as</P>
<DIV class="code">
<PRE>
-typedef unsigned int size_t;
-
-int read(int fd, void *rbuffer, size_t len);
-int write(int fd, void *wbuffer, size_t len);
+int (*)[20] temp;
</PRE>
</DIV>
-<P> As is, the only way to use the functions would be to allocate memory
- and pass some kind of pointer as the second argument---a process that
- might require the use of a helper function. However, using
- multi-argument maps, the functions can be transformed into something
- more natural. For example, you might write typemaps like this:</P>
+<P> This is illegal C syntax and won't compile. There is currently no
+ straightforward way to work around this problem in SWIG due to the way
+ that typemap code is expanded and processed. However, one possible
+ workaround is to simply pick an alternative type such as <TT>void *</TT>
+ and use casts to get the correct type when needed. For example:</P>
<DIV class="code">
<PRE>
-// typemap for an outgoing buffer
-%typemap(in) (void *wbuffer, size_t len) {
- if (!PyString_Check($input)) {
- PyErr_SetString(PyExc_ValueError, "Expecting a string");
- return NULL;
- }
- $1 = (void *) PyString_AsString($input);
- $2 = PyString_Size($input);
-}
-
-// typemap for an incoming buffer
-%typemap(in) (void *rbuffer, size_t len) {
- if (!PyInt_Check($input)) {
- PyErr_SetString(PyExc_ValueError, "Expecting an integer");
- return NULL;
- }
- $2 = PyInt_AsLong($input);
- if ($2 < 0) {
- PyErr_SetString(PyExc_ValueError, "Positive integer expected");
- return NULL;
- }
- $1 = (void *) malloc($2);
+%typemap(in) int [10][20] {
+ void *temp;
+ ...
+ (($1_ltype) temp)[i][j] = x; /* set a value */
+ ...
}
-
-// Return the buffer. Discarding any previous return result
-%typemap(argout) (void *rbuffer, size_t len) {
- Py_XDECREF($result); /* Blow away any previous result */
- if (result < 0) { /* Check for I/O error */
- free($1);
- PyErr_SetFromErrno(PyExc_IOError);
- return NULL;
- }
- $result = PyString_FromStringAndSize($1,result);
- free($1);
+</PRE>
+</DIV>
+<P> Another approach, which only works for arrays is to use the <TT>
+$1_basetype</TT> substitution. For example:</P>
+<DIV class="code">
+<PRE>
+%typemap(in) int [10][20] {
+ $1_basetype temp[10][20];
+ ...
+ temp[i][j] = x; /* set a value */
+ ...
}
</PRE>
</DIV>
-<P> (note: In the above example, <TT>$result</TT> and <TT>result</TT>
- are two different variables. <TT>result</TT> is the real C datatype
- that was returned by the function. <TT>$result</TT> is the scripting
- language object being returned to the interpreter.).</P>
-<P> Now, in a script, you can write code that simply passes buffers as
- strings like this:</P>
-<DIV class="targetlang">
+<H3><A name="Typemaps_special_variable_macros">11.4.4 Special variable
+ macros</A></H3>
+<P> Special variable macros are like macro functions in that they take
+ one or more input arguments which are used for the macro expansion.
+ They look like macro/function calls but use the special variable <TT>$</TT>
+ prefix to the macro name. Note that unlike normal macros, the expansion
+ is not done by the preprocessor, it is done during the SWIG
+ parsing/compilation stages. The following special variable macros are
+ available across all language modules.</P>
+<H4><A name="Typemaps_special_macro_descriptor">11.4.4.1
+ $descriptor(type)</A></H4>
+<P> This macro expands into the type descriptor structure for any C/C++
+ type specified in <TT>type</TT>. It behaves like the <TT>$1_descriptor</TT>
+ special variable described above except that the type to expand is
+ taken from the macro argument rather than inferred from the typemap
+ type. For example, <TT>$descriptor(std::vector<int> *)</TT> will expand
+ into <TT>SWIGTYPE_p_std__vectorT_int_t</TT>. This macro is mostly used
+ in the scripting target languages and is demonstrated later in the <A href="#Typemaps_runtime_type_checker_usage">
+Run-time type checker usage</A> section.</P>
+<H4><A name="Typemaps_special_macro_typemap">11.4.4.2 $typemap(method,
+ typepattern)</A></H4>
+<P> This macro uses the <A href="#Typemaps_pattern_matching">pattern
+ matching rules</A> described earlier to lookup and then substitute the
+ special variable macro with the code in the matched typemap. The
+ typemap to search for is specified by the arguments, where <TT>method</TT>
+ is the typemap method name and <TT>typepattern</TT> is a type pattern
+ as per the <TT>%typemap</TT> specification in the <A href="#Typemaps_defining">
+Defining a typemap</A> section.</P>
+<P> The special variables within the matched typemap are expanded into
+ those for the matched typemap type, not the typemap within which the
+ macro is called. In practice, there is little use for this macro in the
+ scripting target languages. It is mostly used in the target languages
+ that are statically typed as a way to obtain the target language type
+ given the C/C++ type and more commonly only when the C++ type is a
+ template parameter.</P>
+<P> The example below is for C# only and uses some typemap method names
+ documented in the C# chapter, but it shows some of the possible syntax
+ variations.</P>
+<DIV class="code">
<PRE>
->>> f = example.open("Makefile")
->>> example.read(f,40)
-'TOP = ../..\nSWIG = $(TOP)/.'
->>> example.read(f,40)
-'./swig\nSRCS = example.c\nTARGET '
->>> example.close(f)
-0
->>> g = example.open("foo", example.O_WRONLY | example.O_CREAT, 0644)
->>> example.write(g,"Hello world\n")
-12
->>> example.write(g,"This is a test\n")
-15
->>> example.close(g)
-0
->>>
+%typemap(cstype) unsigned long "uint"
+%typemap(cstype) unsigned long bb "bool"
+%typemap(cscode) BarClass %{
+ void foo($typemap(cstype, unsigned long aa) var1,
+ $typemap(cstype, unsigned long bb) var2,
+ $typemap(cstype, (unsigned long bb)) var3,
+ $typemap(cstype, unsigned long) var4)
+ {
+ // do something
+ }
+%}
</PRE>
</DIV>
-<P> A number of multi-argument typemap problems also arise in libraries
- that perform matrix-calculations--especially if they are mapped onto
- low-level Fortran or C code. For example, you might have a function
- like this:</P>
+<P> The result is the following expansion</P>
<DIV class="code">
<PRE>
-int is_symmetric(double *mat, int rows, int columns);
+%typemap(cstype) unsigned long "uint"
+%typemap(cstype) unsigned long bb "bool"
+%typemap(cscode) BarClass %{
+ void foo(uint var1,
+ bool var2,
+ bool var3,
+ uint var4)
+ {
+ // do something
+ }
+%}
</PRE>
</DIV>
-<P> In this case, you might want to pass some kind of higher-level
- object as an matrix. To do this, you could write a multi-argument
- typemap like this:</P>
+<H3><A name="Typemaps_special_variable_attributes">11.4.5 Special
+ variables and typemap attributes</A></H3>
+<P> As of SWIG-3.0.7 typemap attributes will also expand special
+ variables and special variable macros.</P>
+<P> Example usage showing the expansion in the 'out' attribute (C#
+ specific) as well as the main typemap body:</P>
<DIV class="code">
<PRE>
-%typemap(in) (double *mat, int rows, int columns) {
- MatrixObject *a;
- a = GetMatrixFromObject($input); /* Get matrix somehow */
-
- /* Get matrix properties */
- $1 = GetPointer(a);
- $2 = GetRows(a);
- $3 = GetColumns(a);
-}
+%typemap(ctype, out="$*1_ltype") unsigned int& "$*1_ltype"
</PRE>
</DIV>
-<P> This kind of technique can be used to hook into scripting-language
- matrix packages such as Numeric Python. However, it should also be
- stressed that some care is in order. For example, when crossing
- languages you may need to worry about issues such as row-major vs.
- column-major ordering (and perform conversions if needed). Note that
- multi-argument typemaps cannot deal with non-consecutive C/C++
- arguments; a workaround such as a helper function re-ordering the
- arguments to make them consecutive will need to be written.</P>
-<H2><A name="Typemaps_warnings"></A>10.10 Typemap warnings</H2>
-<P> Warnings can be added to typemaps so that SWIG generates a warning
- message whenever the typemap is used. See the information in the <A href="#Warnings_nn5">
-issuing warnings</A> section.</P>
-<H2><A name="Typemaps_fragments"></A>10.11 Typemap fragments</H2>
-<P> The primary purpose of fragments is to reduce code bloat that
- repeated use of typemap code can lead to. Fragments are snippets of
- code that can be thought of as code dependencies of a typemap. If a
- fragment is used by more than one typemap, then the snippet of code
- within the fragment is only generated once. Code bloat is typically
- reduced by moving typemap code into a support function and then placing
- the support function into a fragment.</P>
-<P> For example, if you have a very long typemap</P>
+<P> is equivalent to the following as <TT>$*1_ltype</TT> expands to <TT>
+unsigned int</TT>:</P>
<DIV class="code">
<PRE>
-%typemap(in) MyClass * {
- MyClass *value = 0;
-
- ... many lines of marshalling code ...
-
- $result = value;
-}
+%typemap(ctype, out="unsigned int") unsigned int& "unsigned int"
</PRE>
</DIV>
-<P> the same marshalling code is often repeated in several typemaps,
- such as "in", "varin", "directorout", etc. SWIG copies the code for
- each argument that requires the typemap code, easily leading to code
- bloat in the generated code. To eliminate this, define a fragment that
- includes the common marshalling code:</P>
+<H3><A name="Typemaps_special_variables_and_macros">11.4.6 Special
+ variables combined with special variable macros</A></H3>
+<P> Special variables can also be used within special variable macros.
+ The special variables are expanded before they are used in the special
+ variable macros.</P>
+<P> Consider the following C# typemaps:</P>
<DIV class="code">
<PRE>
-%fragment("AsMyClass", "header") {
- MyClass *AsMyClass(PyObject *obj) {
- MyClass *value = 0;
-
- ... many lines of marshalling code ...
-
- return value;
- }
-}
-
-%typemap(in, fragment="AsMyClass") MyClass * {
- $result = AsMyClass($input);
-}
-
-%typemap(varin, fragment="AsMyClass") MyClass * {
- $result = AsMyClass($input);
-}
+%typemap(cstype) unsigned int "uint"
+%typemap(cstype, out="$typemap(cstype, $*1_ltype)") unsigned int& "$typemap(cstype, $*1_ltype)"
</PRE>
</DIV>
-<P> When the "in" or "varin" typemaps for MyClass are required, the
- contents of the fragment called "AsMyClass" is added to the "header"
- section within the generated code, and then the typemap code is
- emitted. Hence, the method <TT>AsMyClass</TT> will be generated into
- the wrapper code before any typemap code that calls it.</P>
-<P> To define a fragment you need a fragment name, a section name for
- generating the fragment code into, and the code itself. See <A href="#SWIG_nn42">
-Code insertion blocks</A> for a full list of section names. Usually the
- section name used is "header". Different delimiters can be used:</P>
+<P> Special variables are expanded first and hence the above is
+ equivalent to:</P>
<DIV class="code">
<PRE>
-%fragment("my_name", "header") %{ ... %}
-%fragment("my_name", "header") { ... }
-%fragment("my_name", "header") " ... "
+%typemap(cstype) unsigned int "uint"
+%typemap(cstype, out="$typemap(cstype, unsigned int)") unsigned int& "$typemap(cstype, unsigned int)"
</PRE>
</DIV>
-<P> and these follow the usual preprocessing rules mentioned in the <A href="#Preprocessor_delimiters">
-Preprocessing delimiters</A> section. The following are some rules and
- guidelines for using fragments:</P>
-<OL>
-<LI>
-<P> A fragment is added to the wrapping code only once. When using the <TT>
-MyClass *</TT> typemaps above and wrapping the method:</P>
+<P> which then expands to:</P>
<DIV class="code">
<PRE>
-void foo(MyClass *a, MyClass *b);
+%typemap(cstype) unsigned int "uint"
+%typemap(cstype, out="uint") unsigned int& "uint"
</PRE>
</DIV>
-<P> the generated code will look something like:</P>
+<H2><A name="Typemaps_nn25">11.5 Common typemap methods</A></H2>
+<P> The set of typemaps recognized by a language module may vary.
+ However, the following typemap methods are nearly universal:</P>
+<H3><A name="Typemaps_nn26">11.5.1 "in" typemap</A></H3>
+<P> The "in" typemap is used to convert function arguments from the
+ target language to C. For example:</P>
<DIV class="code">
<PRE>
-MyClass *AsMyClass(PyObject *obj) {
- ...
-}
-
-void _wrap_foo(...) {
- ....
- arg1 = AsMyClass(obj1);
- arg2 = AsMyClass(obj2);
- ...
- foo(arg1, arg2);
+%typemap(in) int {
+ $1 = PyInt_AsLong($input);
}
</PRE>
</DIV>
-<P> even as there is duplicated typemap code to process both <TT>a</TT>
- and <TT>b</TT>, the <TT>AsMyClass</TT> method will be defined only
- once.</P>
-</LI>
-<LI>
-<P> A fragment should only be defined once. If there is more than one
- definition, the first definition is the one used. All other definitions
- are silently ignored. For example, if you have</P>
+<P> The following special variables are available:</P>
<DIV class="code">
<PRE>
-%fragment("AsMyClass", "header") { ...definition 1... }
-....
-%fragment("AsMyClass", "header") { ...definition 2... }
+$input - Input object holding value to be converted.
+$symname - Name of function/method being wrapped
</PRE>
</DIV>
-<P> only the first definition is used. In this way you can override the
- default fragments in a SWIG library by defining your fragment before
- the library <TT>%include</TT>. Note that this behavior is the opposite
- to typemaps, where the last typemap defined/applied prevails. Fragments
- follow the first-in-first-out convention since they are intended to be
- global, while typemaps are intended to be locally specialized.</P>
-</LI>
-<LI>
-<P> Fragment names cannot contain commas.</P>
-</LI>
-<LI>
-<P> A fragment can use one or more additional fragments, for example:</P>
+<P> This is probably the most commonly redefined typemap because it can
+ be used to implement customized conversions.</P>
+<P> In addition, the "in" typemap allows the number of converted
+ arguments to be specified. The <TT>numinputs</TT> attributes
+ facilitates this. For example:</P>
<DIV class="code">
<PRE>
-%fragment("<limits.h>", "header") {
- %#include <limits.h>
-}
-
-
-%fragment("AsMyClass", "header", fragment="<limits.h>") {
- MyClass *AsMyClass(PyObject *obj) {
- MyClass *value = 0;
-
- ... some marshalling code ...
-
- if (ival < CHAR_MIN /*defined in <limits.h>*/) {
- ...
- } else {
- ...
- }
- ...
- return value;
- }
+// Ignored argument.
+%typemap(in, numinputs=0) int *out (int temp) {
+ $1 = &temp;
}
</PRE>
</DIV>
-<P> in this case, when the "AsMyClass" fragment is emitted, it also
- triggers the inclusion of the "<limits.h>" fragment.</P>
-</LI>
-<LI>
-<P> A fragment can have dependencies on a number of other fragments, for
- example:</P>
+<P> At this time, only zero or one arguments may be converted. When <TT>
+numinputs</TT> is set to 0, the argument is effectively ignored and
+ cannot be supplied from the target language. The argument is still
+ required when making the C/C++ call and the above typemap shows the
+ value used is instead obtained from a locally declared variable called <TT>
+temp</TT>. Usually <TT>numinputs</TT> is not specified, whereupon the
+ default value is 1, that is, there is a one to one mapping of the
+ number of arguments when used from the target language to the C/C++
+ call. <A href="#Typemaps_multi_argument_typemaps">Multi-argument
+ typemaps</A> provide a similar concept where the number of arguments
+ mapped from the target language to C/C++ can be changed for multiple
+ adjacent C/C++ arguments.</P>
+<P><B> Compatibility note:</B> Specifying <TT>numinputs=0</TT> is the
+ same as the old "ignore" typemap.</P>
+<H3><A name="Typemaps_nn27">11.5.2 "typecheck" typemap</A></H3>
+<P> The "typecheck" typemap is used to support overloaded functions and
+ methods. It merely checks an argument to see whether or not it matches
+ a specific type. For example:</P>
<DIV class="code">
<PRE>
-%fragment("bigfragment", "header", fragment="frag1", fragment="frag2", fragment="frag3") "";
+%typemap(typecheck,precedence=SWIG_TYPECHECK_INTEGER) int {
+ $1 = PyInt_Check($input) ? 1 : 0;
+}
</PRE>
</DIV>
-<P> When the "bigfragment" is used, the three dependent fragments
- "frag1", "frag2" and "frag3" are also pulled in. Note that as
- "bigframent" is empty (the empty string - ""), it does not add any code
- itself, but merely triggers the inclusion of the other fragments.</P>
-</LI>
-<LI>
-<P> A typemap can also use more than one fragment, but since the syntax
- is different, you need to specify the dependent fragments in a comma
- separated list. Consider:</P>
+<P> For typechecking, the $1 variable is always a simple integer that is
+ set to 1 or 0 depending on whether or not the input argument is the
+ correct type.</P>
+<P> If you define new "in" typemaps<EM> and</EM> your program uses
+ overloaded methods, you should also define a collection of "typecheck"
+ typemaps. More details about this follow in the <A href="#Typemaps_overloading">
+Typemaps and overloading</A> section.</P>
+<H3><A name="Typemaps_nn28">11.5.3 "out" typemap</A></H3>
+<P> The "out" typemap is used to convert function/method return values
+ from C into the target language. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in, fragment="frag1,frag2,frag3") {...}
+%typemap(out) int {
+ $result = PyInt_FromLong($1);
+}
</PRE>
</DIV>
-<P> which is equivalent to:</P>
+<P> The following special variables are available.</P>
<DIV class="code">
<PRE>
-%typemap(in, fragment="bigfragment") {...}
+$result - Result object returned to target language.
+$symname - Name of function/method being wrapped
</PRE>
</DIV>
-<P> when used with the "bigfragment" defined above.</P>
-</LI>
-<LI>
-<P> Finally, you can force the inclusion of a fragment at any point in
- the generated code as follows:</P>
+<P> The "out" typemap supports an optional attribute flag called
+ "optimal". This is for code optimisation and is detailed in the <A href="#Typemaps_optimal">
+Optimal code generation when returning by value</A> section.</P>
+<H3><A name="Typemaps_nn29">11.5.4 "arginit" typemap</A></H3>
+<P> The "arginit" typemap is used to set the initial value of a function
+ argument--before any conversion has occurred. This is not normally
+ necessary, but might be useful in highly specialized applications. For
+ example:</P>
<DIV class="code">
<PRE>
-%fragment("bigfragment");
+// Set argument to NULL before any conversion occurs
+%typemap(arginit) int *data {
+ $1 = NULL;
+}
</PRE>
</DIV>
-<P> which is very useful inside a template class, for example.</P>
-</LI>
-</OL>
-<P> Most readers will probably want to skip the next two sub-sections on
- advanced fragment usage unless a desire to really get to grips with
- some powerful but tricky macro and fragment usage that is used in parts
- of the SWIG typemap library.</P>
-<H3><A name="Typemaps_fragment_type_specialization"></A>10.11.1 Fragment
- type specialization</H3>
-<P> Fragments can be<I> type specialized</I>. The syntax is as follows:</P>
+<H3><A name="Typemaps_nn30">11.5.5 "default" typemap</A></H3>
+<P> The "default" typemap is used to turn an argument into a default
+ argument. For example:</P>
<DIV class="code">
<PRE>
-%fragment("name", "header") { ...a type independent fragment... }
-%fragment("name"{type}, "header") { ...a type dependent fragment... }
+%typemap(default) int flags {
+ $1 = DEFAULT_FLAGS;
+}
+...
+int foo(int x, int y, int flags);
</PRE>
</DIV>
-<P> where <TT>type</TT> is a C/C++ type. Like typemaps, fragments can
- also be used inside templates, for example:</P>
+<P> The primary use of this typemap is to either change the wrapping of
+ default arguments or specify a default argument in a language where
+ they aren't supported (like C). Target languages that do not support
+ optional arguments, such as Java and C#, effectively ignore the value
+ specified by this typemap as all arguments must be given.</P>
+<P> Once a default typemap has been applied to an argument, all
+ arguments that follow must have default values. See the <A href="#SWIG_default_args">
+Default/optional arguments</A> section for further information on
+ default argument wrapping.</P>
+<H3><A name="Typemaps_nn31">11.5.6 "check" typemap</A></H3>
+<P> The "check" typemap is used to supply value checking code during
+ argument conversion. The typemap is applied<EM> after</EM> arguments
+ have been converted. For example:</P>
<DIV class="code">
<PRE>
-template <class T>
-struct A {
- %fragment("incode"{A<T>}, "header") {
- ... 'incode' specialized fragment ...
- }
-
- %typemap(in, fragment="incode"{A<T>}) {
- ... here we use the 'type specialized' fragment "incode"{A<T>} ...
- }
-};
+%typemap(check) int positive {
+ if ($1 <= 0) {
+ SWIG_exception(SWIG_ValueError,"Expected positive value.");
+ }
+}
</PRE>
</DIV>
-<H3><A name="Typemaps_automatic_specialization"></A>10.11.2 Fragments
- and automatic typemap specialization</H3>
-<P> Since fragments can be type specialized, they can be elegantly used
- to specialize typemaps. For example, if you have something like:</P>
+<H3><A name="Typemaps_nn32">11.5.7 "argout" typemap</A></H3>
+<P> The "argout" typemap is used to return values from arguments. This
+ is most commonly used to write wrappers for C/C++ functions that need
+ to return multiple values. The "argout" typemap is almost always
+ combined with an "in" typemap---possibly to ignore the input value. For
+ example:</P>
<DIV class="code">
<PRE>
-%fragment("incode"{float}, "header") {
- float in_method_float(PyObject *obj) {
- ...
- }
-}
-
-%fragment("incode"{long}, "header") {
- float in_method_long(PyObject *obj) {
- ...
- }
+/* Set the input argument to point to a temporary variable */
+%typemap(in, numinputs=0) int *out (int temp) {
+ $1 = &temp;
}
-// %my_typemaps macro definition
-%define %my_typemaps(Type)
-%typemap(in, fragment="incode"{Type}) Type {
- value = in_method_##Type(obj);
+%typemap(argout) int *out {
+ // Append output value $1 to $result
+ ...
}
-%enddef
-
-%my_typemaps(float);
-%my_typemaps(long);
</PRE>
</DIV>
-<P> then the proper <TT>"incode"{float}</TT> or <TT>"incode"{long}</TT>
- fragment will be used, and the <TT>in_method_float</TT> and <TT>
-in_method_long</TT> methods will be called whenever the <TT>float</TT>
- or <TT>long</TT> types are used as input parameters.</P>
-<P> This feature is used a lot in the typemaps shipped in the SWIG
- library for some scripting languages. The interested (or very brave)
- reader can take a look at the fragments.swg file shipped with SWIG to
- see this in action.</P>
-<H2><A name="Typemaps_runtime_type_checker"></A>10.12 The run-time type
- checker</H2>
-<P> Most scripting languages need type information at run-time. This
- type information can include how to construct types, how to garbage
- collect types, and the inheritance relationships between types. If the
- language interface does not provide its own type information storage,
- the generated SWIG code needs to provide it.</P>
-<P> Requirements for the type system:</P>
-<UL>
-<LI>Store inheritance and type equivalence information and be able to
- correctly re-create the type pointer.</LI>
-<LI>Share type information between modules.</LI>
-<LI>Modules can be loaded in any order, irregardless of actual type
- dependency.</LI>
-<LI>Avoid the use of dynamically allocated memory, and library/system
- calls in general.</LI>
-<LI>Provide a reasonably fast implementation, minimizing the lookup time
- for all language modules.</LI>
-<LI>Custom, language specific information can be attached to types.</LI>
-<LI>Modules can be unloaded from the type system.</LI>
-</UL>
-<H3><A name="Typemaps_nn45"></A>10.12.1 Implementation</H3>
-<P> The run-time type checker is used by many, but not all, of SWIG's
- supported target languages. The run-time type checker features are not
- required and are thus not used for statically typed languages such as
- Java and C#. The scripting and scheme based languages rely on it and it
- forms a critical part of SWIG's operation for these languages.</P>
-<P> When pointers, arrays, and objects are wrapped by SWIG, they are
- normally converted into typed pointer objects. For example, an instance
- of <TT>Foo *</TT> might be a string encoded like this:</P>
+<P> The following special variables are available.</P>
<DIV class="diagram">
<PRE>
-_108e688_p_Foo
+$result - Result object returned to target language.
+$input - The original input object passed.
+$symname - Name of function/method being wrapped
</PRE>
</DIV>
-<P> At a basic level, the type checker simply restores some type-safety
- to extension modules. However, the type checker is also responsible for
- making sure that wrapped C++ classes are handled correctly---especially
- when inheritance is used. This is especially important when an
- extension module makes use of multiple inheritance. For example:</P>
+<P> The code supplied to the "argout" typemap is always placed after the
+ "out" typemap. If multiple return values are used, the extra return
+ values are often appended to return value of the function.</P>
+<P> See the <TT>typemaps.i</TT> library file for examples.</P>
+<H3><A name="Typemaps_nn33">11.5.8 "freearg" typemap</A></H3>
+<P> The "freearg" typemap is used to cleanup argument data. It is only
+ used when an argument might have allocated resources that need to be
+ cleaned up when the wrapper function exits. The "freearg" typemap
+ usually cleans up argument resources allocated by the "in" typemap. For
+ example:</P>
<DIV class="code">
<PRE>
-class Foo {
- int x;
-};
-
-class Bar {
- int y;
-};
-
-class FooBar : public Foo, public Bar {
- int z;
-};
+// Get a list of integers
+%typemap(in) int *items {
+ int nitems = Length($input);
+ $1 = (int *) malloc(sizeof(int)*nitems);
+}
+// Free the list
+%typemap(freearg) int *items {
+ free($1);
+}
</PRE>
</DIV>
-<P> When the class <TT>FooBar</TT> is organized in memory, it contains
- the contents of the classes <TT>Foo</TT> and <TT>Bar</TT> as well as
- its own data members. For example:</P>
-<DIV class="diagram">
+<P> The "freearg" typemap inserted at the end of the wrapper function,
+ just before control is returned back to the target language. This code
+ is also placed into a special variable <TT>$cleanup</TT> that may be
+ used in other typemaps whenever a wrapper function needs to abort
+ prematurely.</P>
+<H3><A name="Typemaps_nn34">11.5.9 "newfree" typemap</A></H3>
+<P> The "newfree" typemap is used in conjunction with the <TT>%newobject</TT>
+ directive and is used to deallocate memory used by the return result of
+ a function. For example:</P>
+<DIV class="code">
<PRE>
-FooBar --> | -----------| <-- Foo
- | int x |
- |------------| <-- Bar
- | int y |
- |------------|
- | int z |
- |------------|
+%typemap(newfree) string * {
+ delete $1;
+}
+%typemap(out) string * {
+ $result = PyString_FromString($1->c_str());
+}
+...
+
+%newobject foo;
+...
+string *foo();
</PRE>
</DIV>
-<P> Because of the way that base class data is stacked together, the
- casting of a <TT>Foobar *</TT> to either of the base classes may change
- the actual value of the pointer. This means that it is generally not
- safe to represent pointers using a simple integer or a bare <TT>void *</TT>
----type tags are needed to implement correct handling of pointer values
- (and to make adjustments when needed).</P>
-<P> In the wrapper code generated for each language, pointers are
- handled through the use of special type descriptors and conversion
- functions. For example, if you look at the wrapper code for Python, you
- will see code like this:</P>
+<P> See <A href="#Customization_ownership">Object ownership and
+ %newobject</A> for further details.</P>
+<H3><A name="Typemaps_nn35">11.5.10 "memberin" typemap</A></H3>
+<P> The "memberin" typemap is used to copy data from<EM> an already
+ converted input value</EM> into a structure member. It is typically
+ used to handle array members and other special cases. For example:</P>
<DIV class="code">
<PRE>
-if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_Foo,1)) == -1) return NULL;
+%typemap(memberin) int [4] {
+ memmove($1, $input, 4*sizeof(int));
+}
</PRE>
</DIV>
-<P> In this code, <TT>SWIGTYPE_p_Foo</TT> is the type descriptor that
- describes <TT>Foo *</TT>. The type descriptor is actually a pointer to
- a structure that contains information about the type name to use in the
- target language, a list of equivalent typenames (via typedef or
- inheritance), and pointer value handling information (if applicable).
- The <TT>SWIG_ConvertPtr()</TT> function is simply a utility function
- that takes a pointer object in the target language and a
- type-descriptor objects and uses this information to generate a C++
- pointer. However, the exact name and calling conventions of the
- conversion function depends on the target language (see language
- specific chapters for details).</P>
-<P> The actual type code is in swigrun.swg, and gets inserted near the
- top of the generated swig wrapper file. The phrase "a type X that can
- cast into a type Y" means that given a type X, it can be converted into
- a type Y. In other words, X is a derived class of Y or X is a typedef
- of Y. The structure to store type information looks like this:</P>
+<P> It is rarely necessary to write "memberin" typemaps---SWIG already
+ provides a default implementation for arrays, strings, and other
+ objects.</P>
+<H3><A name="Typemaps_nn36">11.5.11 "varin" typemap</A></H3>
+<P> The "varin" typemap is used to convert objects in the target
+ language to C for the purposes of assigning to a C/C++ global variable.
+ This is implementation specific.</P>
+<H3><A name="Typemaps_nn37">11.5.12 "varout" typemap</A></H3>
+<P> The "varout" typemap is used to convert a C/C++ object to an object
+ in the target language when reading a C/C++ global variable. This is
+ implementation specific.</P>
+<H3><A name="throws_typemap">11.5.13 "throws" typemap</A></H3>
+<P> The "throws" typemap is only used when SWIG parses a C++ method with
+ an exception specification or has the <TT>%catches</TT> feature
+ attached to the method. It provides a default mechanism for handling
+ C++ methods that have declared the exceptions they will throw. The
+ purpose of this typemap is to convert a C++ exception into an error or
+ exception in the target language. It is slightly different to the other
+ typemaps as it is based around the exception type rather than the type
+ of a parameter or variable. For example:</P>
<DIV class="code">
<PRE>
-/* 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 for 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 */
-} 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;
+%typemap(throws) const char * %{
+ PyErr_SetString(PyExc_RuntimeError, $1);
+ SWIG_fail;
+%}
+void bar() throw (const char *);
</PRE>
</DIV>
-<P> Each <TT>swig_type_info</TT> stores a linked list of types that it
- is equivalent to. Each entry in this doubly linked list stores a
- pointer back to another swig_type_info structure, along with a pointer
- to a conversion function. This conversion function is used to solve the
- above problem of the FooBar class, correctly returning a pointer to the
- type we want.</P>
-<P> The basic problem we need to solve is verifying and building
- arguments passed to functions. So going back to the <TT>
-SWIG_ConvertPtr()</TT> function example from above, we are expecting a <TT>
-Foo *</TT> and need to check if <TT>obj0</TT> is in fact a <TT>Foo *</TT>
-. From before, <TT>SWIGTYPE_p_Foo</TT> is just a pointer to the <TT>
-swig_type_info</TT> structure describing <TT>Foo *</TT>. So we loop
- through the linked list of <TT>swig_cast_info</TT> structures attached
- to <TT>SWIGTYPE_p_Foo</TT>. If we see that the type of <TT>obj0</TT> is
- in the linked list, we pass the object through the associated
- conversion function and then return a positive. If we reach the end of
- the linked list without a match, then <TT>obj0</TT> can not be
- converted to a <TT>Foo *</TT> and an error is generated.</P>
-<P> Another issue needing to be addressed is sharing type information
- between multiple modules. More explicitly, we need to have ONE <TT>
-swig_type_info</TT> for each type. If two modules both use the type, the
- second module loaded must lookup and use the swig_type_info structure
- from the module already loaded. Because no dynamic memory is used and
- the circular dependencies of the casting information, loading the type
- information is somewhat tricky, and not explained here. A complete
- description is in the <TT>Lib/swiginit.swg</TT> file (and near the top
- of any generated file).</P>
-<P> Each module has one swig_module_info structure which looks like
- this:</P>
+<P> As can be seen from the generated code below, SWIG generates an
+ exception handler with the catch block comprising the "throws" typemap
+ content.</P>
<DIV class="code">
<PRE>
-/* 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 structs in this module */
- int 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;
+...
+try {
+ bar();
+}
+catch(char const *_e) {
+ PyErr_SetString(PyExc_RuntimeError, _e);
+ SWIG_fail;
+
+}
+...
</PRE>
</DIV>
-<P> Each module stores an array of pointers to <TT>swig_type_info</TT>
- structures and the number of types in this module. So when a second
- module is loaded, it finds the <TT>swig_module_info</TT> structure for
- the first module and searches the array of types. If any of its own
- types are in the first module and have already been loaded, it uses
- those <TT>swig_type_info</TT> structures rather than creating new ones.
- These <TT>swig_module_info</TT> structures are chained together in a
- circularly linked list.</P>
-<H3><A name="Typemaps_runtime_type_checker_usage"></A>10.12.2 Usage</H3>
-<P>This section covers how to use these functions from typemaps. To
- learn how to call these functions from external files (not the
- generated _wrap.c file), see the <A href="#Modules_external_run_time">
-External access to the run-time system</A> section.</P>
-<P>When pointers are converted in a typemap, the typemap code often
- looks similar to this:</P>
+<P> Note that if your methods do not have an exception specification yet
+ they do throw exceptions, SWIG cannot know how to deal with them. For a
+ neat way to handle these, see the <A href="#Customization_exception">
+Exception handling with %exception</A> section.</P>
+<H2><A name="Typemaps_nn39">11.6 Some typemap examples</A></H2>
+<P> This section contains a few examples. Consult language module
+ documentation for more examples.</P>
+<H3><A name="Typemaps_nn40">11.6.1 Typemaps for arrays</A></H3>
+<P> A common use of typemaps is to provide support for C arrays
+ appearing both as arguments to functions and as structure members.</P>
+<P> For example, suppose you had a function like this:</P>
<DIV class="code">
<PRE>
-%typemap(in) Foo * {
- if ((SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor)) == -1) return NULL;
-}
+void set_vector(int type, float value[4]);
</PRE>
</DIV>
-<P> The most critical part is the typemap is the use of the <TT>
-$1_descriptor</TT> special variable. When placed in a typemap, this is
- expanded into the <TT>SWIGTYPE_*</TT> type descriptor object above. As
- a general rule, you should always use <TT>$1_descriptor</TT> instead of
- trying to hard-code the type descriptor name directly.</P>
-<P> There is another reason why you should always use the <TT>
-$1_descriptor</TT> variable. When this special variable is expanded,
- SWIG marks the corresponding type as "in use." When type-tables and
- type information is emitted in the wrapper file, descriptor information
- is only generated for those datatypes that were actually used in the
- interface. This greatly reduces the size of the type tables and
- improves efficiency.</P>
-<P> Occasionally, you might need to write a typemap that needs to
- convert pointers of other types. To handle this, the special variable
- macro <TT>$descriptor(type)</TT> covered earlier can be used to
- generate the SWIG type descriptor name for any C datatype. For example:</P>
+<P> If you wanted to handle <TT>float value[4]</TT> as a list of floats,
+ you might write a typemap similar to this:</P>
<DIV class="code">
<PRE>
-%typemap(in) Foo * {
- if ((SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor)) == -1) {
- Bar *temp;
- if ((SWIG_ConvertPtr($input, (void **) &temp, <B>$descriptor(Bar *)</B>) == -1) {
- return NULL;
- }
- $1 = (Foo *) temp;
+
+%typemap(in) float value[4] (float temp[4]) {
+ int i;
+ if (!PySequence_Check($input)) {
+ PyErr_SetString(PyExc_ValueError,"Expected a sequence");
+ return NULL;
+ }
+ if (PySequence_Length($input) != 4) {
+ PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected 4 elements");
+ return NULL;
+ }
+ for (i = 0; i < 4; i++) {
+ PyObject *o = PySequence_GetItem($input,i);
+ if (PyNumber_Check(o)) {
+ temp[i] = (float) PyFloat_AsDouble(o);
+ } else {
+ PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers");
+ return NULL;
+ }
}
+ $1 = temp;
}
</PRE>
</DIV>
-<P> The primary use of <TT>$descriptor(type)</TT> is when writing
- typemaps for container objects and other complex data structures. There
- are some restrictions on the argument---namely it must be a fully
- defined C datatype. It can not be any of the special typemap variables.</P>
-<P> In certain cases, SWIG may not generate type-descriptors like you
- expect. For example, if you are converting pointers in some
- non-standard way or working with an unusual combination of interface
- files and modules, you may find that SWIG omits information for a
- specific type descriptor. To fix this, you may need to use the <TT>
-%types</TT> directive. For example:</P>
-<DIV class="code">
+<P> In this example, the variable <TT>temp</TT> allocates a small array
+ on the C stack. The typemap then populates this array and passes it to
+ the underlying C function.</P>
+<P> When used from Python, the typemap allows the following type of
+ function call:</P>
+<DIV class="targetlang">
<PRE>
-%types(int *, short *, long *, float *, double *);
+>>> set_vector(type, [ 1, 2.5, 5, 20 ])
</PRE>
</DIV>
-<P> When <TT>%types</TT> is used, SWIG generates type-descriptor
- information even if those datatypes never appear elsewhere in the
- interface file.</P>
-<P> Further details about the run-time type checking can be found in the
- documentation for individual language modules. Reading the source code
- may also help. The file <TT>Lib/swigrun.swg</TT> in the SWIG library
- contains all of the source of the generated code for type-checking.
- This code is also included in every generated wrapped file so you
- probably just look at the output of SWIG to get a better sense for how
- types are managed.</P>
-<H2><A name="Typemaps_overloading"></A>10.13 Typemaps and overloading</H2>
-<P> This section does not apply to the statically typed languages like
- Java and C#, where overloading of the types is handled much like C++ by
- generating overloaded methods in the target language. In many of the
- other target languages, SWIG still fully supports C++ overloaded
- methods and functions. For example, if you have a collection of
- functions like this:</P>
+<P> If you wanted to generalize the typemap to apply to arrays of all
+ dimensions you might write this:</P>
<DIV class="code">
<PRE>
-int foo(int x);
-int foo(double x);
-int foo(char *s, int y);
+%typemap(in) float value[ANY] (float temp[$1_dim0]) {
+ int i;
+ if (!PySequence_Check($input)) {
+ PyErr_SetString(PyExc_ValueError,"Expected a sequence");
+ return NULL;
+ }
+ if (PySequence_Length($input) != $1_dim0) {
+ PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected $1_dim0 elements");
+ return NULL;
+ }
+ for (i = 0; i < $1_dim0; i++) {
+ PyObject *o = PySequence_GetItem($input,i);
+ if (PyNumber_Check(o)) {
+ temp[i] = (float) PyFloat_AsDouble(o);
+ } else {
+ PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers");
+ return NULL;
+ }
+ }
+ $1 = temp;
+}
</PRE>
</DIV>
-<P> You can access the functions in a normal way from the scripting
- interpreter:</P>
-<DIV class="targetlang">
+<P> In this example, the special variable <TT>$1_dim0</TT> is expanded
+ with the actual array dimensions. Multidimensional arrays can be
+ matched in a similar manner. For example:</P>
+<DIV class="code">
<PRE>
-# Python
-foo(3) # foo(int)
-foo(3.5) # foo(double)
-foo("hello",5) # foo(char *, int)
-
-# Tcl
-foo 3 # foo(int)
-foo 3.5 # foo(double)
-foo hello 5 # foo(char *, int)
+%typemap(in) float matrix[ANY][ANY] (float temp[$1_dim0][$1_dim1]) {
+ ... convert a 2d array ...
+}
</PRE>
</DIV>
-<P> To implement overloading, SWIG generates a separate wrapper function
- for each overloaded method. For example, the above functions would
- produce something roughly like this:</P>
+<P> For large arrays, it may be impractical to allocate storage on the
+ stack using a temporary variable as shown. To work with heap allocated
+ data, the following technique can be used.</P>
<DIV class="code">
<PRE>
-// wrapper pseudocode
-_wrap_foo_0(argc, args[]) { // foo(int)
- int arg1;
- int result;
- ...
- arg1 = FromInteger(args[0]);
- result = foo(arg1);
- return ToInteger(result);
-}
-
-_wrap_foo_1(argc, args[]) { // foo(double)
- double arg1;
- int result;
- ...
- arg1 = FromDouble(args[0]);
- result = foo(arg1);
- return ToInteger(result);
+%typemap(in) float value[ANY] {
+ int i;
+ if (!PySequence_Check($input)) {
+ PyErr_SetString(PyExc_ValueError,"Expected a sequence");
+ return NULL;
+ }
+ if (PySequence_Length($input) != $1_dim0) {
+ PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected $1_dim0 elements");
+ return NULL;
+ }
+ $1 = (float *) malloc($1_dim0*sizeof(float));
+ for (i = 0; i < $1_dim0; i++) {
+ PyObject *o = PySequence_GetItem($input,i);
+ if (PyNumber_Check(o)) {
+ $1[i] = (float) PyFloat_AsDouble(o);
+ } else {
+ PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers");
+ free($1);
+ return NULL;
+ }
+ }
}
-
-_wrap_foo_2(argc, args[]) { // foo(char *, int)
- char *arg1;
- int arg2;
- int result;
- ...
- arg1 = FromString(args[0]);
- arg2 = FromInteger(args[1]);
- result = foo(arg1,arg2);
- return ToInteger(result);
+%typemap(freearg) float value[ANY] {
+ if ($1) free($1);
}
-
</PRE>
</DIV>
-<P> Next, a dynamic dispatch function is generated:</P>
+<P> In this case, an array is allocated using <TT>malloc</TT>. The <TT>
+freearg</TT> typemap is then used to release the argument after the
+ function has been called.</P>
+<P> Another common use of array typemaps is to provide support for array
+ structure members. Due to subtle differences between pointers and
+ arrays in C, you can't just "assign" to a array structure member.
+ Instead, you have to explicitly copy elements into the array. For
+ example, suppose you had a structure like this:</P>
<DIV class="code">
<PRE>
-_wrap_foo(argc, args[]) {
- if (argc == 1) {
- if (IsInteger(args[0])) {
- return _wrap_foo_0(argc,args);
- }
- if (IsDouble(args[0])) {
- return _wrap_foo_1(argc,args);
- }
- }
- if (argc == 2) {
- if (IsString(args[0]) && IsInteger(args[1])) {
- return _wrap_foo_2(argc,args);
- }
- }
- error("No matching function!\n");
-}
+struct SomeObject {
+ float value[4];
+ ...
+};
</PRE>
</DIV>
-<P> The purpose of the dynamic dispatch function is to select the
- appropriate C++ function based on argument types---a task that must be
- performed at runtime in most of SWIG's target languages.</P>
-<P> The generation of the dynamic dispatch function is a relatively
- tricky affair. Not only must input typemaps be taken into account
- (these typemaps can radically change the types of arguments accepted),
- but overloaded methods must also be sorted and checked in a very
- specific order to resolve potential ambiguity. A high-level overview of
- this ranking process is found in the "<A href="#SWIGPlus">SWIG and C++</A>
-" chapter. What isn't mentioned in that chapter is the mechanism by
- which it is implemented---as a collection of typemaps.</P>
-<P> To support dynamic dispatch, SWIG first defines a general purpose
- type hierarchy as follows:</P>
-<DIV class="diagram">
+<P> When SWIG runs, it won't produce any code to set the <TT>vec</TT>
+ member. You may even get a warning message like this:</P>
+<DIV class="shell">
<PRE>
-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
+$ swig -python example.i
+example.i:10: Warning 462: Unable to set variable of type float [4].
</PRE>
</DIV>
-<P> (These precedence levels are defined in <TT>swig.swg</TT>, a library
- file that's included by all target language modules.)</P>
-<P> In this table, the precedence-level determines the order in which
- types are going to be checked. Low values are always checked before
- higher values. For example, integers are checked before floats, single
- values are checked before arrays, and so forth.</P>
-<P> Using the above table as a guide, each target language defines a
- collection of "typecheck" typemaps. The follow excerpt from the Python
- module illustrates this:</P>
+<P> These warning messages indicate that SWIG does not know how you want
+ to set the <TT>vec</TT> field.</P>
+<P> To fix this, you can supply a special "memberin" typemap like this:</P>
<DIV class="code">
<PRE>
-/* Python type checking rules */
-/* Note: %typecheck(X) is a macro for %typemap(typecheck,precedence=X) */
-
-%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,
- bool, const bool &
-{
- $1 = (PyInt_Check($input) || PyLong_Check($input)) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_DOUBLE)
- float, double,
- const float &, const double &
-{
- $1 = (PyFloat_Check($input) || PyInt_Check($input) || PyLong_Check($input)) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_CHAR) char {
- $1 = (PyString_Check($input) && (PyString_Size($input) == 1)) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_STRING) char * {
- $1 = PyString_Check($input) ? 1 : 0;
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
- void *ptr;
- if (SWIG_ConvertPtr($input, (void **) &ptr, $1_descriptor, 0) == -1) {
- $1 = 0;
- PyErr_Clear();
- } else {
- $1 = 1;
- }
-}
-
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
- void *ptr;
- if (SWIG_ConvertPtr($input, (void **) &ptr, $&1_descriptor, 0) == -1) {
- $1 = 0;
- PyErr_Clear();
- } else {
- $1 = 1;
- }
-}
-
-%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
- void *ptr;
- if (SWIG_ConvertPtr($input, (void **) &ptr, 0, 0) == -1) {
- $1 = 0;
- PyErr_Clear();
- } else {
- $1 = 1;
+%typemap(memberin) float [ANY] {
+ int i;
+ for (i = 0; i < $1_dim0; i++) {
+ $1[i] = $input[i];
}
}
-
-%typecheck(SWIG_TYPECHECK_POINTER) PyObject *
-{
- $1 = ($input != 0);
-}
</PRE>
</DIV>
-<P> It might take a bit of contemplation, but this code has merely
- organized all of the basic C++ types, provided some simple
- type-checking code, and assigned each type a precedence value.</P>
-<P> Finally, to generate the dynamic dispatch function, SWIG uses the
- following algorithm:</P>
-<UL>
-<LI>Overloaded methods are first sorted by the number of required
- arguments.</LI>
-<LI>Methods with the same number of arguments are then sorted by
- precedence values of argument types.</LI>
-<LI>Typecheck typemaps are then emitted to produce a dispatch function
- that checks arguments in the correct order.</LI>
-</UL>
-<P> If you haven't written any typemaps of your own, it is unnecessary
- to worry about the typechecking rules. However, if you have written new
- input typemaps, you might have to supply a typechecking rule as well.
- An easy way to do this is to simply copy one of the existing
- typechecking rules. Here is an example,</P>
-<DIV class="code">
+<P> The memberin typemap is used to set a structure member from data
+ that has already been converted from the target language to C. In this
+ case, <TT>$input</TT> is the local variable in which converted input
+ data is stored. This typemap then copies this data into the structure.</P>
+<P> When combined with the earlier typemaps for arrays, the combination
+ of the "in" and "memberin" typemap allows the following usage:</P>
+<DIV class="targetlang">
<PRE>
-// Typemap for a C++ string
-%typemap(in) std::string {
- if (PyString_Check($input)) {
- $1 = std::string(PyString_AsString($input));
- } else {
- SWIG_exception(SWIG_TypeError, "string expected");
- }
-}
-// Copy the typecheck code for "char *".
-%typemap(typecheck) std::string = char *;
+>>> s = SomeObject()
+>>> s.x = [1, 2.5, 5, 10]
</PRE>
</DIV>
-<P> The bottom line: If you are writing new typemaps and you are using
- overloaded methods, you will probably have to write typecheck code or
- copy existing code. Since this is a relatively new SWIG feature, there
- are few examples to work with. However, you might look at some of the
- existing library files likes 'typemaps.i' for a guide.</P>
-<P><B> Notes:</B></P>
-<UL>
-<LI>Typecheck typemaps are not used for non-overloaded methods. Because
- of this, it is still always necessary to check types in any "in"
- typemaps.</LI>
-<LI>The dynamic dispatch process is only meant to be a heuristic. There
- are many corner cases where SWIG simply can't disambiguate types to the
- same degree as C++. The only way to resolve this ambiguity is to use
- the %rename directive to rename one of the overloaded methods
- (effectively eliminating overloading).</LI>
-<LI> Typechecking may be partial. For example, if working with arrays,
- the typecheck code might simply check the type of the first array
- element and use that to dispatch to the correct function. Subsequent
- "in" typemaps would then perform more extensive type-checking.</LI>
-<LI>Make sure you read the section on overloading in the "<A href="#SWIGPlus">
-SWIG and C++</A>" chapter.</LI>
-</UL>
-<H2><A name="Typemaps_nn48"></A>10.14 More about <TT>%apply</TT> and <TT>
-%clear</TT></H2>
-<P> In order to implement certain kinds of program behavior, it is
- sometimes necessary to write sets of typemaps. For example, to support
- output arguments, one often writes a set of typemaps like this:</P>
+<P> Related to structure member input, it may be desirable to return
+ structure members as a new kind of object. For example, in this
+ example, you will get very odd program behavior where the structure
+ member can be set nicely, but reading the member simply returns a
+ pointer:</P>
+<DIV class="targetlang">
+<PRE>
+>>> s = SomeObject()
+>>> s.x = [1, 2.5, 5, 10]
+>>> print s.x
+_1008fea8_p_float
+>>>
+</PRE>
+</DIV>
+<P> To fix this, you can write an "out" typemap. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in,numinputs=0) int *OUTPUT (int temp) {
- $1 = &temp;
-}
-%typemap(argout) int *OUTPUT {
- // return value somehow
+%typemap(out) float [ANY] {
+ int i;
+ $result = PyList_New($1_dim0);
+ for (i = 0; i < $1_dim0; i++) {
+ PyObject *o = PyFloat_FromDouble((double) $1[i]);
+ PyList_SetItem($result,i,o);
+ }
}
</PRE>
</DIV>
-<P> To make it easier to apply the typemap to different argument types
- and names, the <TT>%apply</TT> directive performs a copy of all
- typemaps from one type to another. For example, if you specify this,</P>
-<DIV class="code">
+<P> Now, you will find that member access is quite nice:</P>
+<DIV class="targetlang">
<PRE>
-%apply int *OUTPUT { int *retvalue, int32 *output };
+>>> s = SomeObject()
+>>> s.x = [1, 2.5, 5, 10]
+>>> print s.x
+[ 1, 2.5, 5, 10]
</PRE>
</DIV>
-<P> then all of the <TT>int *OUTPUT</TT> typemaps are copied to <TT>int
- *retvalue</TT> and <TT>int32 *output</TT>.</P>
-<P> However, there is a subtle aspect of <TT>%apply</TT> that needs more
- description. Namely, <TT>%apply</TT> does not overwrite a typemap rule
- if it is already defined for the target datatype. This behavior allows
- you to do two things:</P>
-<UL>
-<LI>You can specialize parts of a complex typemap rule by first defining
- a few typemaps and then using <TT>%apply</TT> to incorporate the
- remaining pieces.</LI>
-<LI>Sets of different typemaps can be applied to the same datatype using
- repeated <TT>%apply</TT> directives.</LI>
-</UL>
-<P> For example:</P>
+<P><B> Compatibility Note:</B> SWIG1.1 used to provide a special
+ "memberout" typemap. However, it was mostly useless and has since been
+ eliminated. To return structure members, simply use the "out" typemap.</P>
+<H3><A name="Typemaps_nn41">11.6.2 Implementing constraints with
+ typemaps</A></H3>
+<P> One particularly interesting application of typemaps is the
+ implementation of argument constraints. This can be done with the
+ "check" typemap. When used, this allows you to provide code for
+ checking the values of function arguments. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) int *INPUT (int temp) {
- temp = ... get value from $input ...;
- $1 = &temp;
-}
+%module math
-%typemap(check) int *POSITIVE {
- if (*$1 <= 0) {
- SWIG_exception(SWIG_ValueError,"Expected a positive number!\n");
- return NULL;
- }
+%typemap(check) double posdouble {
+ if ($1 < 0) {
+ croak("Expecting a positive number");
+ }
}
...
-%apply int *INPUT { int *invalue };
-%apply int *POSITIVE { int *invalue };
-</PRE>
-</DIV>
-<P> Since <TT>%apply</TT> does not overwrite or replace any existing
- rules, the only way to reset behavior is to use the <TT>%clear</TT>
- directive. <TT>%clear</TT> removes all typemap rules defined for a
- specific datatype. For example:</P>
-<DIV class="code">
-<PRE>
-%clear int *invalue;
+double sqrt(double posdouble);
+
</PRE>
</DIV>
-<H2><A name="Typemaps_nn47"></A>10.15 Passing data between typemaps</H2>
-<P> It is also important to note that the primary use of local variables
- is to create stack-allocated objects for temporary use inside a wrapper
- function (this is faster and less-prone to error than allocating data
- on the heap). In general, the variables are not intended to pass
- information between different types of typemaps. However, this can be
- done if you realize that local names have the argument number appended
- to them. For example, you could do this:</P>
+<P> This provides a sanity check to your wrapper function. If a negative
+ number is passed to this function, a Perl exception will be raised and
+ your program terminated with an error message.</P>
+<P> This kind of checking can be particularly useful when working with
+ pointers. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) int *(int temp) {
- temp = (int) PyInt_AsLong($input);
- $1 = &temp;
+%typemap(check) Vector * {
+ if ($1 == 0) {
+ PyErr_SetString(PyExc_TypeError,"NULL Pointer not allowed");
+ return NULL;
+ }
}
-%typemap(argout) int * {
- PyObject *o = PyInt_FromLong(temp$argnum);
- ...
-}
</PRE>
</DIV>
-<P> In this case, the <TT>$argnum</TT> variable is expanded into the
- argument number. Therefore, the code will reference the appropriate
- local such as <TT>temp1</TT> and <TT>temp2</TT>. It should be noted
- that there are plenty of opportunities to break the universe here and
- that accessing locals in this manner should probably be avoided. At the
- very least, you should make sure that the typemaps sharing information
- have exactly the same types and names.</P>
-<H2><A name="Typemaps_nn52"></A>10.16 C++ "this" pointer</H2>
-<P> All the rules discussed for typemaps apply to C++ as well as C.
- However in addition C++ passes an extra parameter into every non-static
- class method -- the <TT>this</TT> pointer. Occasionally it can be
- useful to apply a typemap to this pointer (for example to check and
- make sure <TT>this</TT> is non-null before deferencing). Actually, C
- also has an the equivalent of the <TT>this</TT> pointer which is used
- when accessing variables in a C struct.</P>
-<P> In order to customise the <TT>this</TT> pointer handling, target a
- variable named <TT>self</TT> in your typemaps. <TT>self</TT> is the
- name SWIG uses to refer to the extra parameter in wrapped functions.</P>
-<P> For example, if wrapping for Java generation:</P>
+<P> will prevent any function involving a <TT>Vector *</TT> from
+ accepting a NULL pointer. As a result, SWIG can often prevent a
+ potential segmentation faults or other run-time problems by raising an
+ exception rather than blindly passing values to the underlying C/C++
+ program.</P>
+<H2><A name="Typemaps_nn43">11.7 Typemaps for multiple target languages</A>
+</H2>
+<P> The code within typemaps is usually language dependent, however,
+ many target languages support the same typemaps. In order to
+ distinguish typemaps across different languages, the preprocessor
+ should be used. For example, the "in" typemap for Perl and Ruby could
+ be written as:</P>
<DIV class="code">
<PRE>
-%typemap(check) SWIGTYPE *self %{
-if (!$1) {
- SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException,
- "invalid native object; delete() likely already called");
- return $null;
-}
-%}
+#if defined(SWIGPERL)
+ %typemap(in) int "$1 = ($1_ltype) SvIV($input);"
+#elif defined(SWIGRUBY)
+ %typemap(in) int "$1 = NUM2INT($input);"
+#else
+ #warning no "in" typemap defined
+#endif
</PRE>
</DIV>
-<P> In the above case, the <TT>$1</TT> variable is expanded into the
- argument name that SWIG is using as the <TT>this</TT> pointer. SWIG
- will then insert the check code before the actual C++ class method is
- called, and will raise an exception rather than crash the Java virtual
- machine. The generated code will look something like:</P>
+<P> The full set of language specific macros is defined in the <A href="#Preprocessor_condition_compilation">
+Conditional Compilation</A> section. The example above also shows a
+ common approach of issuing a warning for an as yet unsupported
+ language.</P>
+<P><B> Compatibility note:</B> In SWIG-1.1 different languages could be
+ distinguished with the language name being put within the <TT>%typemap</TT>
+ directive, for example,
+<BR> <TT>%typemap(ruby,in) int "$1 = NUM2INT($input);"</TT>.</P>
+<H2><A name="Typemaps_optimal">11.8 Optimal code generation when
+ returning by value</A></H2>
+<P> The "out" typemap is the main typemap for return types. This typemap
+ supports an optional attribute flag called "optimal", which is for
+ reducing temporary variables and the amount of generated code, thereby
+ giving the compiler the opportunity to use<I> return value optimization</I>
+ for generating faster executing code. It only really makes a difference
+ when returning objects by value and has some limitations on usage, as
+ explained later on.</P>
+<P> When a function returns an object by value, SWIG generates code that
+ instantiates the default type on the stack then assigns the value
+ returned by the function call to it. A copy of this object is then made
+ on the heap and this is what is ultimately stored and used from the
+ target language. This will be clearer considering an example. Consider
+ running the following code through SWIG:</P>
<DIV class="code">
<PRE>
- if (!arg1) {
- SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException,
- "invalid native object; delete() likely already called");
- return ;
+%typemap(out) SWIGTYPE %{
+ $result = new $1_ltype((const $1_ltype &)$1);
+%}
+
+%inline %{
+#include <iostream>
+using namespace std;
+
+struct XX {
+ XX() { cout << "XX()" << endl; }
+ XX(int i) { cout << "XX(" << i << ")" << endl; }
+ XX(const XX &other) { cout << "XX(const XX &)" << endl; }
+ XX & operator =(const XX &other) { cout << "operator=(const XX &)" << endl; return *this; }
+ ~XX() { cout << "~XX()" << endl; }
+ static XX create() {
+ return XX(0);
}
- (arg1)->wrappedFunction(...);
+};
+%}
</PRE>
</DIV>
-<P> Note that if you have a parameter named <TT>self</TT> then it will
- also match the typemap. One work around is to create an interface file
- that wraps the method, but gives the argument a name other than <TT>
-self</TT>.</P>
-<H2><A name="Typemaps_nn51"></A>10.17 Where to go for more information?</H2>
-<P> The best place to find out more information about writing typemaps
- is to look in the SWIG library. Most language modules define all of
- their default behavior using typemaps. These are found in files such as
- <TT>python.swg</TT>, <TT>perl5.swg</TT>, <TT>tcl8.swg</TT> and so
- forth. The <TT>typemaps.i</TT> file in the library also contains
- numerous examples. You should look at these files to get a feel for how
- to define typemaps of your own. Some of the language modules support
- additional typemaps and further information is available in the
- individual chapters for each target language. There you may also find
- more hands-on practical examples.</P>
-<HR NOSHADE>
-<H1><A name="Customization"></A>11 Customization Features</H1>
-
-<!-- INDEX -->
-<DIV class="sectiontoc">
-<UL>
-<LI><A href="#Customization_exception">Exception handling with
- %exception</A>
-<UL>
-<LI><A href="#Customization_nn3">Handling exceptions in C code</A></LI>
-<LI><A href="#Customization_nn4">Exception handling with longjmp()</A></LI>
-<LI><A href="#Customization_nn5">Handling C++ exceptions</A></LI>
-<LI><A href="#Customization_allowexcept">Exception handlers for
- variables</A></LI>
-<LI><A href="#Customization_nn6">Defining different exception handlers</A>
-</LI>
-<LI><A href="#Customization_exception_special_variables">Special
- variables for %exception</A></LI>
-<LI><A href="#Customization_nn7">Using The SWIG exception library</A></LI>
-</UL>
-</LI>
-<LI><A href="#Customization_ownership">Object ownership and %newobject</A>
-</LI>
-<LI><A href="#Customization_features">Features and the %feature
- directive</A>
-<UL>
-<LI><A href="#Customization_feature_attributes">Feature attributes</A></LI>
-<LI><A href="#Customization_feature_flags">Feature flags</A></LI>
-<LI><A href="#Customization_clearing_features">Clearing features</A></LI>
-<LI><A href="#Customization_features_default_args">Features and default
- arguments</A></LI>
-<LI><A href="#Customization_features_example">Feature example</A></LI>
-</UL>
-</LI>
-</UL>
+<P> The "out" typemap shown is the default typemap for C# when returning
+ objects by value. When making a call to <TT>XX::create()</TT> from C#,
+ the output is as follows:</P>
+<DIV class="targetlang">
+<PRE>
+XX()
+XX(0)
+operator=(const XX &)
+~XX()
+XX(const XX &)
+~XX()
+~XX()
+</PRE>
</DIV>
-<!-- INDEX -->
-<P> In many cases, it is desirable to change the default wrapping of
- particular declarations in an interface. For example, you might want to
- provide hooks for catching C++ exceptions, add assertions, or provide
- hints to the underlying code generator. This chapter describes some of
- these customization techniques. First, a discussion of exception
- handling is presented. Then, a more general-purpose customization
- mechanism known as "features" is described.</P>
-<H2><A name="Customization_exception"></A>11.1 Exception handling with
- %exception</H2>
-<P> The <TT>%exception</TT> directive allows you to define a general
- purpose exception handler. For example, you can specify the following:</P>
+<P> Note that three objects are being created as well as an assignment.
+ Wouldn't it be great if the <TT>XX::create()</TT> method was the only
+ time a constructor was called? As the method returns by value, this is
+ asking a lot and the code that SWIG generates by default makes it
+ impossible for the compiler to use<I> return value optimisation (RVO)</I>
+. However, this is where the "optimal" attribute in the "out" typemap
+ can help out. If the typemap code is kept the same and just the
+ "optimal" attribute specified like this:</P>
<DIV class="code">
<PRE>
-%exception {
- try {
- $action
- }
- catch (RangeError) {
- ... handle error ...
- }
-}
+%typemap(out, optimal="1") SWIGTYPE %{
+ $result = new $1_ltype((const $1_ltype &)$1);
+%}
</PRE>
</DIV>
-<P> How the exception is handled depends on the target language, for
- example, Python:</P>
+<P> then when the code is run again, the output is simply:</P>
+<DIV class="targetlang">
+<PRE>
+XX(0)
+~XX()
+</PRE>
+</DIV>
+<P> How the "optimal" attribute works is best explained using the
+ generated code. Without "optimal", the generated code is:</P>
<DIV class="code">
<PRE>
-%exception {
- try {
- $action
- }
- catch (RangeError) {
- PyErr_SetString(PyExc_IndexError,"index out-of-bounds");
- SWIG_fail;
- }
+SWIGEXPORT void * SWIGSTDCALL CSharp_XX_create() {
+ void * jresult ;
+ XX result;
+ result = XX::create();
+ jresult = new XX((const XX &)result);
+ return jresult;
}
+
</PRE>
</DIV>
-<P> When defined, the code enclosed in braces is inserted directly into
- the low-level wrapper functions. The special variable <TT>$action</TT>
- is one of a few <A href="#Customization_exception_special_variables">
-%exception special variables</A> supported and gets replaced with the
- actual operation to be performed (a function call, method invocation,
- attribute access, etc.). An exception handler remains in effect until
- it is explicitly deleted. This is done by using either <TT>%exception</TT>
- or <TT>%noexception</TT> with no code. For example:</P>
+<P> With the "optimal" attribute, the code is:</P>
<DIV class="code">
<PRE>
-%exception; // Deletes any previously defined handler
+SWIGEXPORT void * SWIGSTDCALL CSharp_XX_create() {
+ void * jresult ;
+ jresult = new XX((const XX &)XX::create());
+ return jresult;
+}
</PRE>
</DIV>
-<P><B> Compatibility note:</B> Previous versions of SWIG used a special
- directive <TT>%except</TT> for exception handling. That directive is
- deprecated--<TT>%exception</TT> provides the same functionality, but is
- substantially more flexible.</P>
-<H3><A name="Customization_nn3"></A>11.1.1 Handling exceptions in C code</H3>
-<P> C has no formal exception handling mechanism so there are several
- approaches that might be used. A somewhat common technique is to simply
- set a special error code. For example:</P>
+<P> The major difference is the <TT>result</TT> temporary variable
+ holding the value returned from <TT>XX::create()</TT> is no longer
+ generated and instead the copy constructor call is made directly from
+ the value returned by <TT>XX::create()</TT>. With modern compilers
+ implementing RVO, the copy is not actually done, in fact the object is
+ never created on the stack in <TT>XX::create()</TT> at all, it is
+ simply created directly on the heap. In the first instance, the <TT>$1</TT>
+ special variable in the typemap is expanded into <TT>result</TT>. In
+ the second instance, <TT>$1</TT> is expanded into <TT>XX::create()</TT>
+ and this is essentially what the "optimal" attribute is telling SWIG to
+ do.</P>
+<P> The "optimal" attribute optimisation is not turned on by default as
+ it has a number of restrictions. Firstly, some code cannot be condensed
+ into a simple call for passing into the copy constructor. One common
+ occurrence is when <A href="#Customization_exception">%exception</A> is
+ used. Consider adding the following <TT>%exception</TT> to the example:</P>
<DIV class="code">
<PRE>
-/* File : except.c */
-
-static char error_message[256];
-static int error_status = 0;
-
-void throw_exception(char *msg) {
- strncpy(error_message,msg,256);
- error_status = 1;
-}
-
-void clear_exception() {
- error_status = 0;
-}
-char *check_exception() {
- if (error_status) return error_message;
- else return NULL;
+%exception XX::create() %{
+try {
+ $action
+} catch(const std::exception &e) {
+ cout << e.what() << endl;
}
-
+%}
</PRE>
</DIV>
-<P> To use these functions, functions simply call <TT>throw_exception()</TT>
- to indicate an error occurred. For example :</P>
-<DIV class="code">
+<P> SWIG can detect when the "optimal" attribute cannot be used and will
+ ignore it and in this case will issue the following warning:</P>
+<DIV class="targetlang">
<PRE>
-double inv(double x) {
- if (x != 0) return 1.0/x;
- else {
- throw_exception("Division by zero");
- return 0;
- }
+example.i:28: Warning 474: Method XX::create() usage of the optimal attribute ignored
+example.i:14: Warning 474: in the out typemap as the following cannot be used to generate
+optimal code:
+try {
+ result = XX::create();
+} catch(const std::exception &e) {
+ cout << e.what() << endl;
}
-
</PRE>
</DIV>
-<P> To catch the exception, you can write a simple exception handler
- such as the following (shown for Perl5) :</P>
+<P> It should be clear that the above code cannot be used as the
+ argument to the copy constructor call, that is, for the <TT>$1</TT>
+ substitution.</P>
+<P> Secondly, if the typemaps uses <TT>$1</TT> more than once, then
+ multiple calls to the wrapped function will be made. Obviously that is
+ not very optimal. In fact SWIG attempts to detect this and will issue a
+ warning something like:</P>
+<DIV class="targetlang">
+<PRE>
+example.i:21: Warning 475: Multiple calls to XX::create() might be generated due to
+example.i:7: Warning 475: optimal attribute usage in the out typemap.
+</PRE>
+</DIV>
+<P> However, it doesn't always get it right, for example when <TT>$1</TT>
+ is within some commented out code.</P>
+<H2><A name="Typemaps_multi_argument_typemaps">11.9 Multi-argument
+ typemaps</A></H2>
+<P> So far, the typemaps presented have focused on the problem of
+ dealing with single values. For example, converting a single input
+ object to a single argument in a function call. However, certain
+ conversion problems are difficult to handle in this manner. As an
+ example, consider the example at the very beginning of this chapter:</P>
<DIV class="code">
<PRE>
-%exception {
- char *err;
- clear_exception();
- $action
- if ((err = check_exception())) {
- croak(err);
- }
-}
+int foo(int argc, char *argv[]);
</PRE>
</DIV>
-<P> In this case, when an error occurs, it is translated into a Perl
- error. Each target language has its own approach to creating a runtime
- error/exception in and for Perl it is the <TT>croak</TT> method shown
- above.</P>
-<H3><A name="Customization_nn4"></A>11.1.2 Exception handling with
- longjmp()</H3>
-<P> Exception handling can also be added to C code using the <TT>
-<setjmp.h></TT> library. Here is a minimalistic implementation that
- relies on the C preprocessor :</P>
+<P> Suppose that you wanted to wrap this function so that it accepted a
+ single list of strings like this:</P>
+<DIV class="targetlang">
+<PRE>
+>>> foo(["ale", "lager", "stout"])
+</PRE>
+</DIV>
+<P> To do this, you not only need to map a list of strings to <TT>char
+ *argv[]</TT>, but the value of <TT>int argc</TT> is implicitly
+ determined by the length of the list. Using only simple typemaps, this
+ type of conversion is possible, but extremely painful. Multi-argument
+ typemaps help in this situation.</P>
+<P> A multi-argument typemap is a conversion rule that specifies how to
+ convert a<EM> single</EM> object in the target language to a set of
+ consecutive function arguments in C/C++. For example, the following
+ multi-argument maps perform the conversion described for the above
+ example:</P>
<DIV class="code">
<PRE>
-/* File : except.c
- Just the declaration of a few global variables we're going to use */
-
-#include <setjmp.h>
-jmp_buf exception_buffer;
-int exception_status;
-
-/* File : except.h */
-#include <setjmp.h>
-extern jmp_buf exception_buffer;
-extern int exception_status;
-
-#define try if ((exception_status = setjmp(exception_buffer)) == 0)
-#define catch(val) else if (exception_status == val)
-#define throw(val) longjmp(exception_buffer,val)
-#define finally else
-
-/* Exception codes */
+%typemap(in) (int argc, char *argv[]) {
+ int i;
+ if (!PyList_Check($input)) {
+ PyErr_SetString(PyExc_ValueError, "Expecting a list");
+ return NULL;
+ }
+ $1 = PyList_Size($input);
+ $2 = (char **) malloc(($1+1)*sizeof(char *));
+ for (i = 0; i < $1; i++) {
+ PyObject *s = PyList_GetItem($input,i);
+ if (!PyString_Check(s)) {
+ free($2);
+ PyErr_SetString(PyExc_ValueError, "List items must be strings");
+ return NULL;
+ }
+ $2[i] = PyString_AsString(s);
+ }
+ $2[i] = 0;
+}
-#define RangeError 1
-#define DivisionByZero 2
-#define OutOfMemory 3
+%typemap(freearg) (int argc, char *argv[]) {
+ if ($2) free($2);
+}
+/* Required for C++ method overloading */
+%typecheck(SWIG_TYPECHECK_STRING_ARRAY) (int argc, char *argv[]) {
+ $1 = PyList_Check($input) ? 1 : 0;
+}
</PRE>
</DIV>
-<P> Now, within a C program, you can do the following :</P>
+<P> A multi-argument map is always specified by surrounding the
+ arguments with parentheses as shown. For example:</P>
<DIV class="code">
<PRE>
-double inv(double x) {
- if (x) return 1.0/x;
- else throw(DivisionByZero);
-}
-
+%typemap(in) (int argc, char *argv[]) { ... }
</PRE>
</DIV>
-<P> Finally, to create a SWIG exception handler, write the following :</P>
+<P> Within the typemap code, the variables <TT>$1</TT>, <TT>$2</TT>, and
+ so forth refer to each type in the map. All of the usual substitutions
+ apply--just use the appropriate <TT>$1</TT> or <TT>$2</TT> prefix on
+ the variable name (e.g., <TT>$2_type</TT>, <TT>$1_ltype</TT>, etc.)</P>
+<P> Multi-argument typemaps always have precedence over simple typemaps
+ and SWIG always performs longest-match searching. Therefore, you will
+ get the following behavior:</P>
<DIV class="code">
<PRE>
-%{
-#include "except.h"
-%}
+%typemap(in) int argc { ... typemap 1 ... }
+%typemap(in) (int argc, char *argv[]) { ... typemap 2 ... }
+%typemap(in) (int argc, char *argv[], char *env[]) { ... typemap 3 ... }
-%exception {
- try {
- $action
- } catch(RangeError) {
- croak("Range Error");
- } catch(DivisionByZero) {
- croak("Division by zero");
- } catch(OutOfMemory) {
- croak("Out of memory");
- } finally {
- croak("Unknown exception");
- }
-}
+int foo(int argc, char *argv[]); // Uses typemap 2
+int bar(int argc, int x); // Uses typemap 1
+int spam(int argc, char *argv[], char *env[]); // Uses typemap 3
</PRE>
</DIV>
-<P> Note: This implementation is only intended to illustrate the general
- idea. To make it work better, you'll need to modify it to handle nested
- <TT>try</TT> declarations.</P>
-<H3><A name="Customization_nn5"></A>11.1.3 Handling C++ exceptions</H3>
-<P> Handling C++ exceptions is also straightforward. For example:</P>
+<P> It should be stressed that multi-argument typemaps can appear
+ anywhere in a function declaration and can appear more than once. For
+ example, you could write this:</P>
<DIV class="code">
<PRE>
-%exception {
- try {
- $action
- } catch(RangeError) {
- croak("Range Error");
- } catch(DivisionByZero) {
- croak("Division by zero");
- } catch(OutOfMemory) {
- croak("Out of memory");
- } catch(...) {
- croak("Unknown exception");
- }
-}
+%typemap(in) (int scount, char *swords[]) { ... }
+%typemap(in) (int wcount, char *words[]) { ... }
+void search_words(int scount, char *swords[], int wcount, char *words[], int maxcount);
</PRE>
</DIV>
-<P> The exception types need to be declared as classes elsewhere,
- possibly in a header file :</P>
+<P> Other directives such as <TT>%apply</TT> and <TT>%clear</TT> also
+ work with multi-argument maps. For example:</P>
<DIV class="code">
<PRE>
-class RangeError {};
-class DivisionByZero {};
-class OutOfMemory {};
+%apply (int argc, char *argv[]) {
+ (int scount, char *swords[]),
+ (int wcount, char *words[])
+};
+...
+%clear (int scount, char *swords[]), (int wcount, char *words[]);
+...
</PRE>
</DIV>
-<H3><A name="Customization_allowexcept"></A>11.1.4 Exception handlers
- for variables</H3>
-<P> By default all variables will ignore <TT>%exception</TT>, so it is
- effectively turned off for all variables wrappers. This applies to
- global variables, member variables and static member variables. The
- approach is certainly a logical one when wrapping variables in C.
- However, in C++, it is quite possible for an exception to be thrown
- while the variable is being assigned. To ensure <TT>%exception</TT> is
- used when wrapping variables, it needs to be 'turned on' using the <TT>
-%allowexception</TT> feature. Note that <TT>%allowexception</TT> is just
- a macro for <TT>%feature("allowexcept")</TT>, that is, it is a feature
- called "allowexcept". Any variable which has this feature attached to
- it, will then use the <TT>%exception</TT> feature, but of course, only
- if there is a <TT>%exception</TT> attached to the variable in the first
- place. The <TT>%allowexception</TT> feature works like any other
- feature and so can be used globally or for selective variables.</P>
+<P> Don't forget to also provide a suitable <A href="#Typemaps_overloading">
+typemap for overloaded functions</A>, such as <TT>%typecheck</TT> shown
+ for foo above. This is only required if the function is overloaded in
+ C++.</P>
+<P> Although multi-argument typemaps may seem like an exotic, little
+ used feature, there are several situations where they make sense.
+ First, suppose you wanted to wrap functions similar to the low-level <TT>
+read()</TT> and <TT>write()</TT> system calls. For example:</P>
<DIV class="code">
<PRE>
-%allowexception; // turn on globally
-%allowexception Klass::MyVar; // turn on for a specific variable
+typedef unsigned int size_t;
-%noallowexception Klass::MyVar; // turn off for a specific variable
-%noallowexception; // turn off globally
+int read(int fd, void *rbuffer, size_t len);
+int write(int fd, void *wbuffer, size_t len);
</PRE>
</DIV>
-<H3><A name="Customization_nn6"></A>11.1.5 Defining different exception
- handlers</H3>
-<P> By default, the <TT>%exception</TT> directive creates an exception
- handler that is used for all wrapper functions that follow it. Unless
- there is a well-defined (and simple) error handling mechanism in place,
- defining one universal exception handler may be unwieldy and result in
- excessive code bloat since the handler is inlined into each wrapper
- function.</P>
-<P> To fix this, you can be more selective about how you use the <TT>
-%exception</TT> directive. One approach is to only place it around
- critical pieces of code. For example:</P>
+<P> As is, the only way to use the functions would be to allocate memory
+ and pass some kind of pointer as the second argument---a process that
+ might require the use of a helper function. However, using
+ multi-argument maps, the functions can be transformed into something
+ more natural. For example, you might write typemaps like this:</P>
<DIV class="code">
<PRE>
-%exception {
- ... your exception handler ...
+// typemap for an outgoing buffer
+%typemap(in) (void *wbuffer, size_t len) {
+ if (!PyString_Check($input)) {
+ PyErr_SetString(PyExc_ValueError, "Expecting a string");
+ return NULL;
+ }
+ $1 = (void *) PyString_AsString($input);
+ $2 = PyString_Size($input);
}
-/* Define critical operations that can throw exceptions here */
-%exception;
+// typemap for an incoming buffer
+%typemap(in) (void *rbuffer, size_t len) {
+ if (!PyInt_Check($input)) {
+ PyErr_SetString(PyExc_ValueError, "Expecting an integer");
+ return NULL;
+ }
+ $2 = PyInt_AsLong($input);
+ if ($2 < 0) {
+ PyErr_SetString(PyExc_ValueError, "Positive integer expected");
+ return NULL;
+ }
+ $1 = (void *) malloc($2);
+}
-/* Define non-critical operations that don't throw exceptions */
+// Return the buffer. Discarding any previous return result
+%typemap(argout) (void *rbuffer, size_t len) {
+ Py_XDECREF($result); /* Blow away any previous result */
+ if (result < 0) { /* Check for I/O error */
+ free($1);
+ PyErr_SetFromErrno(PyExc_IOError);
+ return NULL;
+ }
+ $result = PyString_FromStringAndSize($1,result);
+ free($1);
+}
</PRE>
</DIV>
-<P> More precise control over exception handling can be obtained by
- attaching an exception handler to specific declaration name. For
- example:</P>
-<DIV class="code">
+<P> (note: In the above example, <TT>$result</TT> and <TT>result</TT>
+ are two different variables. <TT>result</TT> is the real C datatype
+ that was returned by the function. <TT>$result</TT> is the scripting
+ language object being returned to the interpreter.).</P>
+<P> Now, in a script, you can write code that simply passes buffers as
+ strings like this:</P>
+<DIV class="targetlang">
<PRE>
-%exception allocate {
- try {
- $action
- }
- catch (MemoryError) {
- croak("Out of memory");
- }
-}
+>>> f = example.open("Makefile")
+>>> example.read(f,40)
+'TOP = ../..\nSWIG = $(TOP)/.'
+>>> example.read(f,40)
+'./swig\nSRCS = example.c\nTARGET '
+>>> example.close(f)
+0
+>>> g = example.open("foo", example.O_WRONLY | example.O_CREAT, 0644)
+>>> example.write(g,"Hello world\n")
+12
+>>> example.write(g,"This is a test\n")
+15
+>>> example.close(g)
+0
+>>>
</PRE>
</DIV>
-<P> In this case, the exception handler is only attached to declarations
- named "allocate". This would include both global and member functions.
- The names supplied to <TT>%exception</TT> follow the same rules as for <TT>
-%rename</TT> described in the section on <A href="#SWIGPlus_ambiguity_resolution_renaming">
-Ambiguity resolution and renaming</A>. For example, if you wanted to
- define an exception handler for a specific class, you might write this:</P>
+<P> A number of multi-argument typemap problems also arise in libraries
+ that perform matrix-calculations--especially if they are mapped onto
+ low-level Fortran or C code. For example, you might have a function
+ like this:</P>
<DIV class="code">
<PRE>
-%exception Object::allocate {
- try {
- $action
- }
- catch (MemoryError) {
- croak("Out of memory");
- }
-}
+int is_symmetric(double *mat, int rows, int columns);
</PRE>
</DIV>
-<P> When a class prefix is supplied, the exception handler is applied to
- the corresponding declaration in the specified class as well as for
- identically named functions appearing in derived classes.</P>
-<P> <TT>%exception</TT> can even be used to pinpoint a precise
- declaration when overloading is used. For example:</P>
+<P> In this case, you might want to pass some kind of higher-level
+ object as an matrix. To do this, you could write a multi-argument
+ typemap like this:</P>
<DIV class="code">
<PRE>
-%exception Object::allocate(int) {
- try {
- $action
- }
- catch (MemoryError) {
- croak("Out of memory");
- }
+%typemap(in) (double *mat, int rows, int columns) {
+ MatrixObject *a;
+ a = GetMatrixFromObject($input); /* Get matrix somehow */
+
+ /* Get matrix properties */
+ $1 = GetPointer(a);
+ $2 = GetRows(a);
+ $3 = GetColumns(a);
}
</PRE>
</DIV>
-<P> Attaching exceptions to specific declarations is a good way to
- reduce code bloat. It can also be a useful way to attach exceptions to
- specific parts of a header file. For example:</P>
+<P> This kind of technique can be used to hook into scripting-language
+ matrix packages such as Numeric Python. However, it should also be
+ stressed that some care is in order. For example, when crossing
+ languages you may need to worry about issues such as row-major vs.
+ column-major ordering (and perform conversions if needed). Note that
+ multi-argument typemaps cannot deal with non-consecutive C/C++
+ arguments; a workaround such as a helper function re-ordering the
+ arguments to make them consecutive will need to be written.</P>
+<H2><A name="Typemaps_warnings">11.10 Typemap warnings</A></H2>
+<P> Warnings can be added to typemaps so that SWIG generates a warning
+ message whenever the typemap is used. See the information in the <A href="#Warnings_nn5">
+issuing warnings</A> section.</P>
+<H2><A name="Typemaps_fragments">11.11 Typemap fragments</A></H2>
+<P> The primary purpose of fragments is to reduce code bloat that
+ repeated use of typemap code can lead to. Fragments are snippets of
+ code that can be thought of as code dependencies of a typemap. If a
+ fragment is used by more than one typemap, then the snippet of code
+ within the fragment is only generated once. Code bloat is typically
+ reduced by moving typemap code into a support function and then placing
+ the support function into a fragment.</P>
+<P> For example, if you have a very long typemap</P>
<DIV class="code">
<PRE>
-%module example
-%{
-#include "someheader.h"
-%}
+%typemap(in) MyClass * {
+ MyClass *value = 0;
-// Define a few exception handlers for specific declarations
-%exception Object::allocate(int) {
- try {
- $action
- }
- catch (MemoryError) {
- croak("Out of memory");
- }
-}
+ ... many lines of marshalling code ...
-%exception Object::getitem {
- try {
- $action
- }
- catch (RangeError) {
- croak("Index out of range");
- }
+ $result = value;
}
-...
-// Read a raw header file
-%include "someheader.h"
</PRE>
</DIV>
-<P><B> Compatibility note:</B> The <TT>%exception</TT> directive
- replaces the functionality provided by the deprecated "except" typemap.
- The typemap would allow exceptions to be thrown in the target language
- based on the return type of a function and was intended to be a
- mechanism for pinpointing specific declarations. However, it never
- really worked that well and the new %exception directive is much
- better.</P>
-<H3><A name="Customization_exception_special_variables"></A>11.1.6
- Special variables for %exception</H3>
-<P> The %exception directive supports a few special variables which are
- placeholders for code substitution. The following table shows the
- available special variables and details what the special variables are
- replaced with.</P>
-<TABLE summary="Special variables for %exception">
-<TR><TD>$action</TD><TD>The actual operation to be performed (a function
- call, method invocation, variable access, etc.)</TD></TR>
-<TR><TD>$name</TD><TD>The C/C++ symbol name for the function.</TD></TR>
-<TR><TD>$symname</TD><TD>The symbol name used internally by SWIG</TD></TR>
-<TR><TD>$overname</TD><TD>The extra mangling used in the symbol name for
- overloaded method. Expands to nothing if the wrapped method is not
- overloaded.</TD></TR>
-<TR><TD>$wrapname</TD><TD>The language specific wrapper name (usually a
- C function name exported from the shared object/dll)</TD></TR>
-<TR><TD>$decl</TD><TD>The fully qualified C/C++ declaration of the
- method being wrapped without the return type</TD></TR>
-<TR><TD>$fulldecl</TD><TD>The fully qualified C/C++ declaration of the
- method being wrapped including the return type</TD></TR>
-<TR><TD>$parentname</TD><TD>The parent class name (if any) for a method.</TD>
-</TR>
-<TR><TD>$parentsymname</TD><TD>The target language parent class name (if
- any) for a method.</TD></TR>
-</TABLE>
-<P> The special variables are often used in situations where method
- calls are logged. Exactly which form of the method call needs logging
- is up to individual requirements, but the example code below shows all
- the possible expansions, plus how an exception message could be
- tailored to show the C++ method declaration:</P>
+<P> the same marshalling code is often repeated in several typemaps,
+ such as "in", "varin", "directorout", etc. SWIG copies the code for
+ each argument that requires the typemap code, easily leading to code
+ bloat in the generated code. To eliminate this, define a fragment that
+ includes the common marshalling code:</P>
<DIV class="code">
<PRE>
-%exception Special::something {
- log("symname: $symname");
- log("overname: $overname");
- log("wrapname: $wrapname");
- log("decl: $decl");
- log("fulldecl: $fulldecl");
- try {
- $action
- }
- catch (MemoryError) {
- croak("Out of memory in $decl");
+%fragment("AsMyClass", "header") {
+ MyClass *AsMyClass(PyObject *obj) {
+ MyClass *value = 0;
+
+ ... many lines of marshalling code ...
+
+ return value;
}
}
-void log(const char *message);
-struct Special {
- void something(const char *c);
- void something(int i);
-};
+
+%typemap(in, fragment="AsMyClass") MyClass * {
+ $result = AsMyClass($input);
+}
+
+%typemap(varin, fragment="AsMyClass") MyClass * {
+ $result = AsMyClass($input);
+}
</PRE>
</DIV>
-<P> Below shows the expansions for the 1st of the overloaded <TT>
-something</TT> wrapper methods for Perl:</P>
+<P> When the "in" or "varin" typemaps for MyClass are required, the
+ contents of the fragment called "AsMyClass" is added to the "header"
+ section within the generated code, and then the typemap code is
+ emitted. Hence, the method <TT>AsMyClass</TT> will be generated into
+ the wrapper code before any typemap code that calls it.</P>
+<P> To define a fragment you need a fragment name, a section name for
+ generating the fragment code into, and the code itself. See <A href="#SWIG_nn42">
+Code insertion blocks</A> for a full list of section names. Usually the
+ section name used is "header". Different delimiters can be used:</P>
<DIV class="code">
<PRE>
- log("symname: Special_something");
- log("overname: __SWIG_0");
- log("wrapname: _wrap_Special_something__SWIG_0");
- log("decl: Special::something(char const *)");
- log("fulldecl: void Special::something(char const *)");
- try {
- (arg1)->something((char const *)arg2);
- }
- catch (MemoryError) {
- croak("Out of memory in Special::something(char const *)");
- }
+%fragment("my_name", "header") %{ ... %}
+%fragment("my_name", "header") { ... }
+%fragment("my_name", "header") " ... "
</PRE>
</DIV>
-<H3><A name="Customization_nn7"></A>11.1.7 Using The SWIG exception
- library</H3>
-<P> The <TT>exception.i</TT> library file provides support for creating
- language independent exceptions in your interfaces. To use it, simply
- put an "<TT>%include exception.i</TT>" in your interface file. This
- creates a function <TT>SWIG_exception()</TT> that can be used to raise
- common scripting language exceptions in a portable manner. For example
- :</P>
+<P> and these follow the usual preprocessing rules mentioned in the <A href="#Preprocessor_delimiters">
+Preprocessing delimiters</A> section. The following are some rules and
+ guidelines for using fragments:</P>
+<OL>
+<LI>
+<P> A fragment is added to the wrapping code only once. When using the <TT>
+MyClass *</TT> typemaps above and wrapping the method:</P>
<DIV class="code">
<PRE>
-// Language independent exception handler
-%include exception.i
-
-%exception {
- try {
- $action
- } catch(RangeError) {
- SWIG_exception(SWIG_ValueError, "Range Error");
- } catch(DivisionByZero) {
- SWIG_exception(SWIG_DivisionByZero, "Division by zero");
- } catch(OutOfMemory) {
- SWIG_exception(SWIG_MemoryError, "Out of memory");
- } catch(...) {
- SWIG_exception(SWIG_RuntimeError,"Unknown exception");
- }
-}
-
+void foo(MyClass *a, MyClass *b);
</PRE>
</DIV>
-<P> As arguments, <TT>SWIG_exception()</TT> takes an error type code (an
- integer) and an error message string. The currently supported error
- types are :</P>
-<DIV class="diagram">
+<P> the generated code will look something like:</P>
+<DIV class="code">
<PRE>
-SWIG_UnknownError
-SWIG_IOError
-SWIG_RuntimeError
-SWIG_IndexError
-SWIG_TypeError
-SWIG_DivisionByZero
-SWIG_OverflowError
-SWIG_SyntaxError
-SWIG_ValueError
-SWIG_SystemError
-SWIG_AttributeError
-SWIG_MemoryError
-SWIG_NullReferenceError
+MyClass *AsMyClass(PyObject *obj) {
+ ...
+}
+
+void _wrap_foo(...) {
+ ....
+ arg1 = AsMyClass(obj1);
+ arg2 = AsMyClass(obj2);
+ ...
+ foo(arg1, arg2);
+}
</PRE>
</DIV>
-<P> The <TT>SWIG_exception()</TT> function can also be used in typemaps.</P>
-<H2><A name="Customization_ownership"></A>11.2 Object ownership and
- %newobject</H2>
-<P> A common problem in some applications is managing proper ownership
- of objects. For example, consider a function like this:</P>
+<P> even as there is duplicated typemap code to process both <TT>a</TT>
+ and <TT>b</TT>, the <TT>AsMyClass</TT> method will be defined only
+ once.</P>
+</LI>
+<LI>
+<P> A fragment should only be defined once. If there is more than one
+ definition, the first definition is the one used. All other definitions
+ are silently ignored. For example, if you have</P>
<DIV class="code">
<PRE>
-Foo *blah() {
- Foo *f = new Foo();
- return f;
-}
+%fragment("AsMyClass", "header") { ...definition 1... }
+....
+%fragment("AsMyClass", "header") { ...definition 2... }
</PRE>
</DIV>
-<P> If you wrap the function <TT>blah()</TT>, SWIG has no idea that the
- return value is a newly allocated object. As a result, the resulting
- extension module may produce a memory leak (SWIG is conservative and
- will never delete objects unless it knows for certain that the returned
- object was newly created).</P>
-<P> To fix this, you can provide an extra hint to the code generator
- using the <TT>%newobject</TT> directive. For example:</P>
+<P> only the first definition is used. In this way you can override the
+ default fragments in a SWIG library by defining your fragment before
+ the library <TT>%include</TT>. Note that this behavior is the opposite
+ to typemaps, where the last typemap defined/applied prevails. Fragments
+ follow the first-in-first-out convention since they are intended to be
+ global, while typemaps are intended to be locally specialized.</P>
+</LI>
+<LI>
+<P> Fragment names cannot contain commas.</P>
+</LI>
+<LI>
+<P> A fragment can use one or more additional fragments, for example:</P>
<DIV class="code">
<PRE>
-%newobject blah;
-Foo *blah();
+%fragment("<limits.h>", "header") {
+ %#include <limits.h>
+}
+
+
+%fragment("AsMyClass", "header", fragment="<limits.h>") {
+ MyClass *AsMyClass(PyObject *obj) {
+ MyClass *value = 0;
+
+ ... some marshalling code ...
+
+ if (ival < CHAR_MIN /*defined in <limits.h>*/) {
+ ...
+ } else {
+ ...
+ }
+ ...
+ return value;
+ }
+}
</PRE>
</DIV>
-<P> <TT>%newobject</TT> works exactly like <TT>%rename</TT> and <TT>
-%exception</TT>. In other words, you can attach it to class members and
- parameterized declarations as before. For example:</P>
+<P> in this case, when the "AsMyClass" fragment is emitted, it also
+ triggers the inclusion of the "<limits.h>" fragment.</P>
+</LI>
+<LI>
+<P> A fragment can have dependencies on a number of other fragments, for
+ example:</P>
<DIV class="code">
<PRE>
-%newobject ::blah(); // Only applies to global blah
-%newobject Object::blah(int,double); // Only blah(int,double) in Object
-%newobject *::copy; // Copy method in all classes
-...
+%fragment("bigfragment", "header", fragment="frag1", fragment="frag2", fragment="frag3") "";
</PRE>
</DIV>
-<P> When <TT>%newobject</TT> is supplied, many language modules will
- arrange to take ownership of the return value. This allows the value to
- be automatically garbage-collected when it is no longer in use.
- However, this depends entirely on the target language (a language
- module may also choose to ignore the <TT>%newobject</TT> directive).</P>
-<P> Closely related to <TT>%newobject</TT> is a special typemap. The
- "newfree" typemap can be used to deallocate a newly allocated return
- value. It is only available on methods for which <TT>%newobject</TT>
- has been applied and is commonly used to clean-up string results. For
- example:</P>
+<P> When the "bigfragment" is used, the three dependent fragments
+ "frag1", "frag2" and "frag3" are also pulled in. Note that as
+ "bigframent" is empty (the empty string - ""), it does not add any code
+ itself, but merely triggers the inclusion of the other fragments.</P>
+</LI>
+<LI>
+<P> A typemap can also use more than one fragment, but since the syntax
+ is different, you need to specify the dependent fragments in a comma
+ separated list. Consider:</P>
<DIV class="code">
<PRE>
-%typemap(newfree) char * "free($1);";
-...
-%newobject strdup;
-...
-char *strdup(const char *s);
+%typemap(in, fragment="frag1,frag2,frag3") {...}
</PRE>
</DIV>
-<P> In this case, the result of the function is a string in the target
- language. Since this string is a copy of the original result, the data
- returned by <TT>strdup()</TT> is no longer needed. The "newfree"
- typemap in the example simply releases this memory.</P>
-<P> As a complement to the <TT>%newobject</TT>, from SWIG 1.3.28, you
- can use the <TT>%delobject</TT> directive. For example, if you have two
- methods, one to create objects and one to destroy them, you can use:</P>
+<P> which is equivalent to:</P>
<DIV class="code">
<PRE>
-%newobject create_foo;
-%delobject destroy_foo;
-...
-Foo *create_foo();
-void destroy_foo(Foo *foo);
+%typemap(in, fragment="bigfragment") {...}
</PRE>
</DIV>
-<P> or in a member method as:</P>
+<P> when used with the "bigfragment" defined above.</P>
+</LI>
+<LI>
+<P> Finally, you can force the inclusion of a fragment at any point in
+ the generated code as follows:</P>
<DIV class="code">
<PRE>
-%delobject Foo::destroy;
-
-class Foo {
-public:
- void destroy() { delete this;}
-
-private:
- ~Foo();
-};
+%fragment("bigfragment");
</PRE>
</DIV>
-<P> <TT>%delobject</TT> instructs SWIG that the first argument passed to
- the method will be destroyed, and therefore, the target language should
- not attempt to deallocate it twice. This is similar to use the DISOWN
- typemap in the first method argument, and in fact, it also depends on
- the target language on implementing the 'disown' mechanism properly.</P>
-<P> The use of <TT>%newobject</TT> is also integrated with reference
- counting and is covered in the <A href="#SWIGPlus_ref_unref">C++
- reference counted objects</A> section.</P>
-<P><B> Compatibility note:</B> Previous versions of SWIG had a special <TT>
-%new</TT> directive. However, unlike <TT>%newobject</TT>, it only
- applied to the next declaration. For example:</P>
+<P> which is very useful inside a template class, for example.</P>
+</LI>
+</OL>
+<P> Most readers will probably want to skip the next two sub-sections on
+ advanced fragment usage unless a desire to really get to grips with
+ some powerful but tricky macro and fragment usage that is used in parts
+ of the SWIG typemap library.</P>
+<H3><A name="Typemaps_fragment_type_specialization">11.11.1 Fragment
+ type specialization</A></H3>
+<P> Fragments can be<I> type specialized</I>. The syntax is as follows:</P>
<DIV class="code">
<PRE>
-%new char *strdup(const char *s);
+%fragment("name", "header") { ...a type independent fragment... }
+%fragment("name"{type}, "header") { ...a type dependent fragment... }
</PRE>
</DIV>
-<P> For now this is still supported but is deprecated.</P>
-<P><B> How to shoot yourself in the foot:</B> The <TT>%newobject</TT>
- directive is not a declaration modifier like the old <TT>%new</TT>
- directive. Don't write code like this:</P>
+<P> where <TT>type</TT> is a C/C++ type. Like typemaps, fragments can
+ also be used inside templates, for example:</P>
<DIV class="code">
<PRE>
-%newobject
-char *strdup(const char *s);
+template <class T>
+struct A {
+ %fragment("incode"{A<T>}, "header") {
+ ... 'incode' specialized fragment ...
+ }
+
+ %typemap(in, fragment="incode"{A<T>}) {
+ ... here we use the 'type specialized' fragment "incode"{A<T>} ...
+ }
+};
</PRE>
</DIV>
-<P> The results might not be what you expect.</P>
-<H2><A name="Customization_features"></A>11.3 Features and the %feature
- directive</H2>
-<P> Both <TT>%exception</TT> and <TT>%newobject</TT> are examples of a
- more general purpose customization mechanism known as "features." A
- feature is simply a user-definable property that is attached to
- specific declarations. Features are attached using the <TT>%feature</TT>
- directive. For example:</P>
+<H3><A name="Typemaps_automatic_specialization">11.11.2 Fragments and
+ automatic typemap specialization</A></H3>
+<P> Since fragments can be type specialized, they can be elegantly used
+ to specialize typemaps. For example, if you have something like:</P>
<DIV class="code">
<PRE>
-%feature("except") Object::allocate {
- try {
- $action
- }
- catch (MemoryError) {
- croak("Out of memory");
- }
+%fragment("incode"{float}, "header") {
+ float in_method_float(PyObject *obj) {
+ ...
+ }
}
-%feature("new","1") *::copy;
+%fragment("incode"{long}, "header") {
+ float in_method_long(PyObject *obj) {
+ ...
+ }
+}
+
+// %my_typemaps macro definition
+%define %my_typemaps(Type)
+%typemap(in, fragment="incode"{Type}) Type {
+ value = in_method_##Type(obj);
+}
+%enddef
+
+%my_typemaps(float);
+%my_typemaps(long);
</PRE>
</DIV>
-<P> In fact, the <TT>%exception</TT> and <TT>%newobject</TT> directives
- are really nothing more than macros involving <TT>%feature</TT>:</P>
-<DIV class="code">
+<P> then the proper <TT>"incode"{float}</TT> or <TT>"incode"{long}</TT>
+ fragment will be used, and the <TT>in_method_float</TT> and <TT>
+in_method_long</TT> methods will be called whenever the <TT>float</TT>
+ or <TT>long</TT> types are used as input parameters.</P>
+<P> This feature is used a lot in the typemaps shipped in the SWIG
+ library for some scripting languages. The interested (or very brave)
+ reader can take a look at the fragments.swg file shipped with SWIG to
+ see this in action.</P>
+<H2><A name="Typemaps_runtime_type_checker">11.12 The run-time type
+ checker</A></H2>
+<P> Most scripting languages need type information at run-time. This
+ type information can include how to construct types, how to garbage
+ collect types, and the inheritance relationships between types. If the
+ language interface does not provide its own type information storage,
+ the generated SWIG code needs to provide it.</P>
+<P> Requirements for the type system:</P>
+<UL>
+<LI>Store inheritance and type equivalence information and be able to
+ correctly re-create the type pointer.</LI>
+<LI>Share type information between modules.</LI>
+<LI>Modules can be loaded in any order, regardless of actual type
+ dependency.</LI>
+<LI>Avoid the use of dynamically allocated memory, and library/system
+ calls in general.</LI>
+<LI>Provide a reasonably fast implementation, minimizing the lookup time
+ for all language modules.</LI>
+<LI>Custom, language specific information can be attached to types.</LI>
+<LI>Modules can be unloaded from the type system.</LI>
+</UL>
+<H3><A name="Typemaps_nn45">11.12.1 Implementation</A></H3>
+<P> The run-time type checker is used by many, but not all, of SWIG's
+ supported target languages. The run-time type checker features are not
+ required and are thus not used for statically typed languages such as
+ Java and C#. The scripting and scheme based languages rely on it and it
+ forms a critical part of SWIG's operation for these languages.</P>
+<P> When pointers, arrays, and objects are wrapped by SWIG, they are
+ normally converted into typed pointer objects. For example, an instance
+ of <TT>Foo *</TT> might be a string encoded like this:</P>
+<DIV class="diagram">
<PRE>
-#define %exception %feature("except")
-#define %newobject %feature("new","1")
+_108e688_p_Foo
</PRE>
</DIV>
-<P> The name matching rules outlined in the <A href="#SWIGPlus_ambiguity_resolution_renaming">
-Ambiguity resolution and renaming</A> section applies to all <TT>
-%feature</TT> directives. In fact the <TT>%rename</TT> directive is just
- a special form of <TT>%feature</TT>. The matching rules mean that
- features are very flexible and can be applied with pinpoint accuracy to
- specific declarations if needed. Additionally, if no declaration name
- is given, a global feature is said to be defined. This feature is then
- attached to<EM> every</EM> declaration that follows. This is how global
- exception handlers are defined. For example:</P>
+<P> At a basic level, the type checker simply restores some type-safety
+ to extension modules. However, the type checker is also responsible for
+ making sure that wrapped C++ classes are handled correctly---especially
+ when inheritance is used. This is especially important when an
+ extension module makes use of multiple inheritance. For example:</P>
<DIV class="code">
<PRE>
-/* Define a global exception handler */
-%feature("except") {
- try {
- $action
- }
- ...
-}
+class Foo {
+ int x;
+};
-... bunch of declarations ...
+class Bar {
+ int y;
+};
+
+class FooBar : public Foo, public Bar {
+ int z;
+};
</PRE>
</DIV>
-<P> The <TT>%feature</TT> directive can be used with different syntax.
- The following are all equivalent:</P>
-<DIV class="code">
+<P> When the class <TT>FooBar</TT> is organized in memory, it contains
+ the contents of the classes <TT>Foo</TT> and <TT>Bar</TT> as well as
+ its own data members. For example:</P>
+<DIV class="diagram">
<PRE>
-%feature("except") Object::method { $action };
-%feature("except") Object::method %{ $action %};
-%feature("except") Object::method " $action ";
-%feature("except","$action") Object::method;
+FooBar --> | -----------| <-- Foo
+ | int x |
+ |------------| <-- Bar
+ | int y |
+ |------------|
+ | int z |
+ |------------|
</PRE>
</DIV>
-<P> The syntax in the first variation will generate the <TT>{ }</TT>
- delimiters used whereas the other variations will not.</P>
-<H3><A name="Customization_feature_attributes"></A>11.3.1 Feature
- attributes</H3>
-<P> The <TT>%feature</TT> directive also accepts XML style attributes in
- the same way that typemaps do. Any number of attributes can be
- specified. The following is the generic syntax for features:</P>
+<P> Because of the way that base class data is stacked together, the
+ casting of a <TT>Foobar *</TT> to either of the base classes may change
+ the actual value of the pointer. This means that it is generally not
+ safe to represent pointers using a simple integer or a bare <TT>void *</TT>
+---type tags are needed to implement correct handling of pointer values
+ (and to make adjustments when needed).</P>
+<P> In the wrapper code generated for each language, pointers are
+ handled through the use of special type descriptors and conversion
+ functions. For example, if you look at the wrapper code for Python, you
+ will see code like this:</P>
<DIV class="code">
<PRE>
-%feature("name","value", attribute1="AttributeValue1") symbol;
-%feature("name", attribute1="AttributeValue1") symbol {value};
-%feature("name", attribute1="AttributeValue1") symbol %{value%};
-%feature("name", attribute1="AttributeValue1") symbol "value";
+if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_Foo,1)) == -1) return NULL;
</PRE>
</DIV>
-<P> More than one attribute can be specified using a comma separated
- list. The Java module is an example that uses attributes in <TT>
-%feature("except")</TT>. The <TT>throws</TT> attribute specifies the
- name of a Java class to add to a proxy method's throws clause. In the
- following example, <TT>MyExceptionClass</TT> is the name of the Java
- class for adding to the throws clause.</P>
+<P> In this code, <TT>SWIGTYPE_p_Foo</TT> is the type descriptor that
+ describes <TT>Foo *</TT>. The type descriptor is actually a pointer to
+ a structure that contains information about the type name to use in the
+ target language, a list of equivalent typenames (via typedef or
+ inheritance), and pointer value handling information (if applicable).
+ The <TT>SWIG_ConvertPtr()</TT> function is simply a utility function
+ that takes a pointer object in the target language and a
+ type-descriptor objects and uses this information to generate a C++
+ pointer. However, the exact name and calling conventions of the
+ conversion function depends on the target language (see language
+ specific chapters for details).</P>
+<P> The actual type code is in swigrun.swg, and gets inserted near the
+ top of the generated swig wrapper file. The phrase "a type X that can
+ cast into a type Y" means that given a type X, it can be converted into
+ a type Y. In other words, X is a derived class of Y or X is a typedef
+ of Y. The structure to store type information looks like this:</P>
<DIV class="code">
<PRE>
-%feature("except", throws="MyExceptionClass") Object::method {
- try {
- $action
- } catch (...) {
- ... code to throw a MyExceptionClass Java exception ...
- }
-};
+/* 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 for 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 */
+} 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;
</PRE>
</DIV>
-<P> Further details can be obtained from the <A href="#Java_exception_handling">
-Java exception handling</A> section.</P>
-<H3><A name="Customization_feature_flags"></A>11.3.2 Feature flags</H3>
-<P> Feature flags are used to enable or disable a particular feature.
- Feature flags are a common but simple usage of <TT>%feature</TT> and
- the feature value should be either <TT>1</TT> to enable or <TT>0</TT>
- to disable the feature.</P>
+<P> Each <TT>swig_type_info</TT> stores a linked list of types that it
+ is equivalent to. Each entry in this doubly linked list stores a
+ pointer back to another swig_type_info structure, along with a pointer
+ to a conversion function. This conversion function is used to solve the
+ above problem of the FooBar class, correctly returning a pointer to the
+ type we want.</P>
+<P> The basic problem we need to solve is verifying and building
+ arguments passed to functions. So going back to the <TT>
+SWIG_ConvertPtr()</TT> function example from above, we are expecting a <TT>
+Foo *</TT> and need to check if <TT>obj0</TT> is in fact a <TT>Foo *</TT>
+. From before, <TT>SWIGTYPE_p_Foo</TT> is just a pointer to the <TT>
+swig_type_info</TT> structure describing <TT>Foo *</TT>. So we loop
+ through the linked list of <TT>swig_cast_info</TT> structures attached
+ to <TT>SWIGTYPE_p_Foo</TT>. If we see that the type of <TT>obj0</TT> is
+ in the linked list, we pass the object through the associated
+ conversion function and then return a positive. If we reach the end of
+ the linked list without a match, then <TT>obj0</TT> can not be
+ converted to a <TT>Foo *</TT> and an error is generated.</P>
+<P> Another issue needing to be addressed is sharing type information
+ between multiple modules. More explicitly, we need to have ONE <TT>
+swig_type_info</TT> for each type. If two modules both use the type, the
+ second module loaded must lookup and use the swig_type_info structure
+ from the module already loaded. Because no dynamic memory is used and
+ the circular dependencies of the casting information, loading the type
+ information is somewhat tricky, and not explained here. A complete
+ description is in the <TT>Lib/swiginit.swg</TT> file (and near the top
+ of any generated file).</P>
+<P> Each module has one swig_module_info structure which looks like
+ this:</P>
<DIV class="code">
<PRE>
-%feature("featurename") // enables feature
-%feature("featurename", "1") // enables feature
-%feature("featurename", "x") // enables feature
-%feature("featurename", "0") // disables feature
-%feature("featurename", "") // clears feature
+/* 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 structs in this module */
+ int 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;
</PRE>
</DIV>
-<P> Actually any value other than zero will enable the feature. Note
- that if the value is omitted completely, the default value becomes <TT>
-1</TT>, thereby enabling the feature. A feature is cleared by specifying
- no value, see <A href="#Customization_clearing_features">Clearing
- features</A>. The <TT>%immutable</TT> directive described in the <A href="#SWIG_readonly_variables">
-Creating read-only variables</A> section, is just a macro for <TT>
-%feature("immutable")</TT>, and can be used to demonstrates feature
- flags:</P>
+<P> Each module stores an array of pointers to <TT>swig_type_info</TT>
+ structures and the number of types in this module. So when a second
+ module is loaded, it finds the <TT>swig_module_info</TT> structure for
+ the first module and searches the array of types. If any of its own
+ types are in the first module and have already been loaded, it uses
+ those <TT>swig_type_info</TT> structures rather than creating new ones.
+ These <TT>swig_module_info</TT> structures are chained together in a
+ circularly linked list.</P>
+<H3><A name="Typemaps_runtime_type_checker_usage">11.12.2 Usage</A></H3>
+<P>This section covers how to use these functions from typemaps. To
+ learn how to call these functions from external files (not the
+ generated _wrap.c file), see the <A href="#Modules_external_run_time">
+External access to the run-time system</A> section.</P>
+<P>When pointers are converted in a typemap, the typemap code often
+ looks similar to this:</P>
<DIV class="code">
<PRE>
- // features are disabled by default
-int red; // mutable
-
-%feature("immutable"); // global enable
-int orange; // immutable
-
-%feature("immutable","0"); // global disable
-int yellow; // mutable
-
-%feature("immutable","1"); // another form of global enable
-int green; // immutable
-
-%feature("immutable",""); // clears the global feature
-int blue; // mutable
+%typemap(in) Foo * {
+ if ((SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor)) == -1) return NULL;
+}
</PRE>
</DIV>
-<P> Note that features are disabled by default and must be explicitly
- enabled either globally or by specifying a targeted declaration. The
- above intersperses SWIG directives with C code. Of course you can
- target features explicitly, so the above could also be rewritten as:</P>
+<P> The most critical part is the typemap is the use of the <TT>
+$1_descriptor</TT> special variable. When placed in a typemap, this is
+ expanded into the <TT>SWIGTYPE_*</TT> type descriptor object above. As
+ a general rule, you should always use <TT>$1_descriptor</TT> instead of
+ trying to hard-code the type descriptor name directly.</P>
+<P> There is another reason why you should always use the <TT>
+$1_descriptor</TT> variable. When this special variable is expanded,
+ SWIG marks the corresponding type as "in use." When type-tables and
+ type information is emitted in the wrapper file, descriptor information
+ is only generated for those datatypes that were actually used in the
+ interface. This greatly reduces the size of the type tables and
+ improves efficiency.</P>
+<P> Occasionally, you might need to write a typemap that needs to
+ convert pointers of other types. To handle this, the special variable
+ macro <TT>$descriptor(type)</TT> covered earlier can be used to
+ generate the SWIG type descriptor name for any C datatype. For example:</P>
<DIV class="code">
<PRE>
-%feature("immutable","1") orange;
-%feature("immutable","1") green;
-int red; // mutable
-int orange; // immutable
-int yellow; // mutable
-int green; // immutable
-int blue; // mutable
+%typemap(in) Foo * {
+ if ((SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor)) == -1) {
+ Bar *temp;
+ if ((SWIG_ConvertPtr($input, (void **) &temp, <B>$descriptor(Bar *)</B>) == -1) {
+ return NULL;
+ }
+ $1 = (Foo *) temp;
+ }
+}
</PRE>
</DIV>
-<P> The above approach allows for the C declarations to be separated
- from the SWIG directives for when the C declarations are parsed from a
- C header file. The logic above can of course be inverted and rewritten
- as:</P>
+<P> The primary use of <TT>$descriptor(type)</TT> is when writing
+ typemaps for container objects and other complex data structures. There
+ are some restrictions on the argument---namely it must be a fully
+ defined C datatype. It can not be any of the special typemap variables.</P>
+<P> In certain cases, SWIG may not generate type-descriptors like you
+ expect. For example, if you are converting pointers in some
+ non-standard way or working with an unusual combination of interface
+ files and modules, you may find that SWIG omits information for a
+ specific type descriptor. To fix this, you may need to use the <TT>
+%types</TT> directive. For example:</P>
<DIV class="code">
<PRE>
-%feature("immutable","1");
-%feature("immutable","0") red;
-%feature("immutable","0") yellow;
-%feature("immutable","0") blue;
-int red; // mutable
-int orange; // immutable
-int yellow; // mutable
-int green; // immutable
-int blue; // mutable
+%types(int *, short *, long *, float *, double *);
</PRE>
</DIV>
-<P> As hinted above for <TT>%immutable</TT>, most feature flags can also
- be specified via alternative syntax. The alternative syntax is just a
- macro in the <TT>swig.swg</TT> Library file. The following shows the
- alternative syntax for the imaginary <TT>featurename</TT> feature:</P>
+<P> When <TT>%types</TT> is used, SWIG generates type-descriptor
+ information even if those datatypes never appear elsewhere in the
+ interface file.</P>
+<P> Further details about the run-time type checking can be found in the
+ documentation for individual language modules. Reading the source code
+ may also help. The file <TT>Lib/swigrun.swg</TT> in the SWIG library
+ contains all of the source of the generated code for type-checking.
+ This code is also included in every generated wrapped file so you
+ probably just look at the output of SWIG to get a better sense for how
+ types are managed.</P>
+<H2><A name="Typemaps_overloading">11.13 Typemaps and overloading</A></H2>
+<P> This section does not apply to the statically typed languages like
+ Java and C#, where overloading of the types is handled much like C++ by
+ generating overloaded methods in the target language. In many of the
+ other target languages, SWIG still fully supports C++ overloaded
+ methods and functions. For example, if you have a collection of
+ functions like this:</P>
<DIV class="code">
<PRE>
-%featurename // equivalent to %feature("featurename", "1") ie enables feature
-%nofeaturename // equivalent to %feature("featurename", "0") ie disables feature
-%clearfeaturename // equivalent to %feature("featurename", "") ie clears feature
+int foo(int x);
+int foo(double x);
+int foo(char *s, int y);
</PRE>
</DIV>
-<P> The concept of clearing features is discussed next.</P>
-<H3><A name="Customization_clearing_features"></A>11.3.3 Clearing
- features</H3>
-<P> A feature stays in effect until it is explicitly cleared. A feature
- is cleared by supplying a <TT>%feature</TT> directive with no value.
- For example <TT>%feature("name","")</TT>. A cleared feature means that
- any feature exactly matching any previously defined feature is no
- longer used in the name matching rules. So if a feature is cleared, it
- might mean that another name matching rule will apply. To clarify,
- let's consider the <TT>except</TT> feature again (<TT>%exception</TT>):</P>
+<P> You can access the functions in a normal way from the scripting
+ interpreter:</P>
+<DIV class="targetlang">
+<PRE>
+# Python
+foo(3) # foo(int)
+foo(3.5) # foo(double)
+foo("hello",5) # foo(char *, int)
+
+# Tcl
+foo 3 # foo(int)
+foo 3.5 # foo(double)
+foo hello 5 # foo(char *, int)
+</PRE>
+</DIV>
+<P> To implement overloading, SWIG generates a separate wrapper function
+ for each overloaded method. For example, the above functions would
+ produce something roughly like this:</P>
<DIV class="code">
<PRE>
-// Define global exception handler
-%feature("except") {
- try {
- $action
- } catch (...) {
- croak("Unknown C++ exception");
- }
+// wrapper pseudocode
+_wrap_foo_0(argc, args[]) { // foo(int)
+ int arg1;
+ int result;
+ ...
+ arg1 = FromInteger(args[0]);
+ result = foo(arg1);
+ return ToInteger(result);
}
-// Define exception handler for all clone methods to log the method calls
-%feature("except") *::clone() {
- try {
- logger.info("$action");
- $action
- } catch (...) {
- croak("Unknown C++ exception");
- }
+_wrap_foo_1(argc, args[]) { // foo(double)
+ double arg1;
+ int result;
+ ...
+ arg1 = FromDouble(args[0]);
+ result = foo(arg1);
+ return ToInteger(result);
}
-... initial set of class declarations with clone methods ...
-
-// clear the previously defined feature
-%feature("except","") *::clone();
+_wrap_foo_2(argc, args[]) { // foo(char *, int)
+ char *arg1;
+ int arg2;
+ int result;
+ ...
+ arg1 = FromString(args[0]);
+ arg2 = FromInteger(args[1]);
+ result = foo(arg1,arg2);
+ return ToInteger(result);
+}
-... final set of class declarations with clone methods ...
</PRE>
</DIV>
-<P> In the above scenario, the initial set of clone methods will log all
- method invocations from the target language. This specific feature is
- cleared for the final set of clone methods. However, these clone
- methods will still have an exception handler (without logging) as the
- next best feature match for them is the global exception handler.</P>
-<P> Note that clearing a feature is not always the same as disabling it.
- Clearing the feature above with <TT>%feature("except","") *::clone()</TT>
- is not the same as specifying <TT>%feature("except","0") *::clone()</TT>
-. The former will disable the feature for clone methods - the feature is
- still a better match than the global feature. If on the other hand, no
- global exception handler had been defined at all, then clearing the
- feature would be the same as disabling it as no other feature would
- have matched.</P>
-<P> Note that the feature must match exactly for it to be cleared by any
- previously defined feature. For example the following attempt to clear
- the initial feature will not work:</P>
+<P> Next, a dynamic dispatch function is generated:</P>
<DIV class="code">
<PRE>
-%feature("except") clone() { logger.info("$action"); $action }
-%feature("except","") *::clone();
+_wrap_foo(argc, args[]) {
+ if (argc == 1) {
+ if (IsInteger(args[0])) {
+ return _wrap_foo_0(argc,args);
+ }
+ if (IsDouble(args[0])) {
+ return _wrap_foo_1(argc,args);
+ }
+ }
+ if (argc == 2) {
+ if (IsString(args[0]) && IsInteger(args[1])) {
+ return _wrap_foo_2(argc,args);
+ }
+ }
+ error("No matching function!\n");
+}
</PRE>
</DIV>
-<P> but this will:</P>
-<DIV class="code">
+<P> The purpose of the dynamic dispatch function is to select the
+ appropriate C++ function based on argument types---a task that must be
+ performed at runtime in most of SWIG's target languages.</P>
+<P> The generation of the dynamic dispatch function is a relatively
+ tricky affair. Not only must input typemaps be taken into account
+ (these typemaps can radically change the types of arguments accepted),
+ but overloaded methods must also be sorted and checked in a very
+ specific order to resolve potential ambiguity. A high-level overview of
+ this ranking process is found in the "<A href="#SWIGPlus">SWIG and C++</A>
+" chapter. What isn't mentioned in that chapter is the mechanism by
+ which it is implemented---as a collection of typemaps.</P>
+<P> To support dynamic dispatch, SWIG first defines a general purpose
+ type hierarchy as follows:</P>
+<DIV class="diagram">
<PRE>
-%feature("except") clone() { logger.info("$action"); $action }
-%feature("except","") clone();
+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
</PRE>
</DIV>
-<P> SWIG provides macros for disabling and clearing features. Many of
- these can be found in the <TT>swig.swg</TT> library file. The typical
- pattern is to define three macros; one to define the feature itself,
- one to disable the feature and one to clear the feature. The three
- macros below show this for the "except" feature:</P>
+<P> (These precedence levels are defined in <TT>swig.swg</TT>, a library
+ file that's included by all target language modules.)</P>
+<P> In this table, the precedence-level determines the order in which
+ types are going to be checked. Low values are always checked before
+ higher values. For example, integers are checked before floats, single
+ values are checked before arrays, and so forth.</P>
+<P> Using the above table as a guide, each target language defines a
+ collection of "typecheck" typemaps. The following excerpt from the
+ Python module illustrates this:</P>
<DIV class="code">
<PRE>
-#define %exception %feature("except")
-#define %noexception %feature("except","0")
-#define %clearexception %feature("except","")
+/* Python type checking rules */
+/* Note: %typecheck(X) is a macro for %typemap(typecheck,precedence=X) */
+
+%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,
+ bool, const bool &
+{
+ $1 = (PyInt_Check($input) || PyLong_Check($input)) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_DOUBLE)
+ float, double,
+ const float &, const double &
+{
+ $1 = (PyFloat_Check($input) || PyInt_Check($input) || PyLong_Check($input)) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_CHAR) char {
+ $1 = (PyString_Check($input) && (PyString_Size($input) == 1)) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_STRING) char * {
+ $1 = PyString_Check($input) ? 1 : 0;
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
+ void *ptr;
+ if (SWIG_ConvertPtr($input, (void **) &ptr, $1_descriptor, 0) == -1) {
+ $1 = 0;
+ PyErr_Clear();
+ } else {
+ $1 = 1;
+ }
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
+ void *ptr;
+ if (SWIG_ConvertPtr($input, (void **) &ptr, $&1_descriptor, 0) == -1) {
+ $1 = 0;
+ PyErr_Clear();
+ } else {
+ $1 = 1;
+ }
+}
+
+%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
+ void *ptr;
+ if (SWIG_ConvertPtr($input, (void **) &ptr, 0, 0) == -1) {
+ $1 = 0;
+ PyErr_Clear();
+ } else {
+ $1 = 1;
+ }
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) PyObject *
+{
+ $1 = ($input != 0);
+}
</PRE>
</DIV>
-<H3><A name="Customization_features_default_args"></A>11.3.4 Features
- and default arguments</H3>
-<P> SWIG treats methods with default arguments as separate overloaded
- methods as detailed in the <A href="#SWIGPlus_default_args">default
- arguments</A> section. Any <TT>%feature</TT> targeting a method with
- default arguments will apply to all the extra overloaded methods that
- SWIG generates if the default arguments are specified in the feature.
- If the default arguments are not specified in the feature, then the
- feature will match that exact wrapper method only and not the extra
- overloaded methods that SWIG generates. For example:</P>
+<P> It might take a bit of contemplation, but this code has merely
+ organized all of the basic C++ types, provided some simple
+ type-checking code, and assigned each type a precedence value.</P>
+<P> Finally, to generate the dynamic dispatch function, SWIG uses the
+ following algorithm:</P>
+<UL>
+<LI>Overloaded methods are first sorted by the number of required
+ arguments.</LI>
+<LI>Methods with the same number of arguments are then sorted by
+ precedence values of argument types.</LI>
+<LI>Typecheck typemaps are then emitted to produce a dispatch function
+ that checks arguments in the correct order.</LI>
+</UL>
+<P> If you haven't written any typemaps of your own, it is unnecessary
+ to worry about the typechecking rules. However, if you have written new
+ input typemaps, you might have to supply a typechecking rule as well.
+ An easy way to do this is to simply copy one of the existing
+ typechecking rules. Here is an example,</P>
<DIV class="code">
<PRE>
-%feature("except") void hello(int i=0, double d=0.0) { ... }
-void hello(int i=0, double d=0.0);
+// Typemap for a C++ string
+%typemap(in) std::string {
+ if (PyString_Check($input)) {
+ $1 = std::string(PyString_AsString($input));
+ } else {
+ SWIG_exception(SWIG_TypeError, "string expected");
+ }
+}
+// Copy the typecheck code for "char *".
+%typemap(typecheck) std::string = char *;
</PRE>
</DIV>
-<P> will apply the feature to all three wrapper methods, that is:</P>
+<P> The bottom line: If you are writing new typemaps and you are using
+ overloaded methods, you will probably have to write new typecheck code
+ or copy and modify existing typecheck code.</P>
+<P> If you write a typecheck typemap and omit the precedence level, for
+ example commenting it out as shown below:</P>
<DIV class="code">
<PRE>
-void hello(int i, double d);
-void hello(int i);
-void hello();
+%typemap(typecheck /*,precedence=SWIG_TYPECHECK_INTEGER*/) int {
+ $1 = PyInt_Check($input) ? 1 : 0;
+}
</PRE>
</DIV>
-<P> If the default arguments are not specified in the feature:</P>
-<DIV class="code">
+<P> then the type is given a precedence higher than any other known
+ precedence level and a <A href="#Warnings">warning</A> is issued:</P>
+<DIV class="shell">
<PRE>
-%feature("except") void hello(int i, double d) { ... }
-void hello(int i=0, double d=0.0);
+example.i:18: Warning 467: Overloaded method foo(int) not supported (incomplete type checking rule - no precedence level in typecheck typemap for 'int').
</PRE>
</DIV>
-<P> then the feature will only apply to this wrapper method:</P>
+<P><B> Notes:</B></P>
+<UL>
+<LI>Typecheck typemaps are not used for non-overloaded methods. Because
+ of this, it is still always necessary to check types in any "in"
+ typemaps.</LI>
+<LI>The dynamic dispatch process is only meant to be a heuristic. There
+ are many corner cases where SWIG simply can't disambiguate types to the
+ same degree as C++. The only way to resolve this ambiguity is to use
+ the %rename directive to rename one of the overloaded methods
+ (effectively eliminating overloading).</LI>
+<LI> Typechecking may be partial. For example, if working with arrays,
+ the typecheck code might simply check the type of the first array
+ element and use that to dispatch to the correct function. Subsequent
+ "in" typemaps would then perform more extensive type-checking.</LI>
+<LI>Make sure you read the section on overloading in the "<A href="#SWIGPlus">
+SWIG and C++</A>" chapter.</LI>
+</UL>
+<H2><A name="Typemaps_nn48">11.14 More about %apply and %clear</A></H2>
+<P> In order to implement certain kinds of program behavior, it is
+ sometimes necessary to write sets of typemaps. For example, to support
+ output arguments, one often writes a set of typemaps like this:</P>
<DIV class="code">
<PRE>
-void hello(int i, double d);
+%typemap(in,numinputs=0) int *OUTPUT (int temp) {
+ $1 = &temp;
+}
+%typemap(argout) int *OUTPUT {
+ // return value somehow
+}
</PRE>
</DIV>
-<P> and not these wrapper methods:</P>
+<P> To make it easier to apply the typemap to different argument types
+ and names, the <TT>%apply</TT> directive performs a copy of all
+ typemaps from one type to another. For example, if you specify this,</P>
<DIV class="code">
<PRE>
-void hello(int i);
-void hello();
+%apply int *OUTPUT { int *retvalue, int32 *output };
</PRE>
</DIV>
-<P> If <A href="#SWIGPlus_default_args">compactdefaultargs</A> are being
- used, then the difference between specifying or not specifying default
- arguments in a feature is not applicable as just one wrapper is
- generated.</P>
-<P><B> Compatibility note:</B> The different behaviour of features
- specified with or without default arguments was introduced in
- SWIG-1.3.23 when the approach to wrapping methods with default
- arguments was changed.</P>
-<H3><A name="Customization_features_example"></A>11.3.5 Feature example</H3>
-<P> As has been shown earlier, the intended use for the <TT>%feature</TT>
- directive is as a highly flexible customization mechanism that can be
- used to annotate declarations with additional information for use by
- specific target language modules. Another example is in the Python
- module. You might use <TT>%feature</TT> to rewrite proxy/shadow class
- code as follows:</P>
+<P> then all of the <TT>int *OUTPUT</TT> typemaps are copied to <TT>int
+ *retvalue</TT> and <TT>int32 *output</TT>.</P>
+<P> However, there is a subtle aspect of <TT>%apply</TT> that needs more
+ description. Namely, <TT>%apply</TT> does not overwrite a typemap rule
+ if it is already defined for the target datatype. This behavior allows
+ you to do two things:</P>
+<UL>
+<LI>You can specialize parts of a complex typemap rule by first defining
+ a few typemaps and then using <TT>%apply</TT> to incorporate the
+ remaining pieces.</LI>
+<LI>Sets of different typemaps can be applied to the same datatype using
+ repeated <TT>%apply</TT> directives.</LI>
+</UL>
+<P> For example:</P>
<DIV class="code">
<PRE>
-%module example
-%rename(bar_id) bar(int,double);
+%typemap(in) int *INPUT (int temp) {
+ temp = ... get value from $input ...;
+ $1 = &temp;
+}
-// Rewrite bar() to allow some nice overloading
+%typemap(check) int *POSITIVE {
+ if (*$1 <= 0) {
+ SWIG_exception(SWIG_ValueError,"Expected a positive number!\n");
+ return NULL;
+ }
+}
-%feature("shadow") Foo::bar(int) %{
-def bar(*args):
- if len(args) == 3:
- return apply(examplec.Foo_bar_id,args)
- return apply(examplec.Foo_bar,args)
-%}
-
-class Foo {
-public:
- int bar(int x);
- int bar(int x, double y);
+...
+%apply int *INPUT { int *invalue };
+%apply int *POSITIVE { int *invalue };
+</PRE>
+</DIV>
+<P> Since <TT>%apply</TT> does not overwrite or replace any existing
+ rules, the only way to reset behavior is to use the <TT>%clear</TT>
+ directive. <TT>%clear</TT> removes all typemap rules defined for a
+ specific datatype. For example:</P>
+<DIV class="code">
+<PRE>
+%clear int *invalue;
+</PRE>
+</DIV>
+<H2><A name="Typemaps_nn47">11.15 Passing data between typemaps</A></H2>
+<P> It is also important to note that the primary use of local variables
+ is to create stack-allocated objects for temporary use inside a wrapper
+ function (this is faster and less-prone to error than allocating data
+ on the heap). In general, the variables are not intended to pass
+ information between different types of typemaps. However, this can be
+ done if you realize that local names have the argument number appended
+ to them. For example, you could do this:</P>
+<DIV class="code">
+<PRE>
+%typemap(in) int *(int temp) {
+ temp = (int) PyInt_AsLong($input);
+ $1 = &temp;
+}
+
+%typemap(argout) int * {
+ PyObject *o = PyInt_FromLong(temp$argnum);
+ ...
}
</PRE>
</DIV>
-<P> Further details of <TT>%feature</TT> usage is described in the
- documentation for specific language modules.</P>
+<P> In this case, the <TT>$argnum</TT> variable is expanded into the
+ argument number. Therefore, the code will reference the appropriate
+ local such as <TT>temp1</TT> and <TT>temp2</TT>. It should be noted
+ that there are plenty of opportunities to break the universe here and
+ that accessing locals in this manner should probably be avoided. At the
+ very least, you should make sure that the typemaps sharing information
+ have exactly the same types and names.</P>
+<H2><A name="Typemaps_nn52">11.16 C++ "this" pointer</A></H2>
+<P> All the rules discussed for typemaps apply to C++ as well as C.
+ However in addition C++ passes an extra parameter into every non-static
+ class method -- the <TT>this</TT> pointer. Occasionally it can be
+ useful to apply a typemap to this pointer (for example to check and
+ make sure <TT>this</TT> is non-null before deferencing). Actually, C
+ also has an the equivalent of the <TT>this</TT> pointer which is used
+ when accessing variables in a C struct.</P>
+<P> In order to customise the <TT>this</TT> pointer handling, target a
+ variable named <TT>self</TT> in your typemaps. <TT>self</TT> is the
+ name SWIG uses to refer to the extra parameter in wrapped functions.</P>
+<P> For example, if wrapping for Java generation:</P>
+<DIV class="code">
+<PRE>
+%typemap(check) SWIGTYPE *self %{
+if (!$1) {
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException,
+ "invalid native object; delete() likely already called");
+ return $null;
+}
+%}
+</PRE>
+</DIV>
+<P> In the above case, the <TT>$1</TT> variable is expanded into the
+ argument name that SWIG is using as the <TT>this</TT> pointer. SWIG
+ will then insert the check code before the actual C++ class method is
+ called, and will raise an exception rather than crash the Java virtual
+ machine. The generated code will look something like:</P>
+<DIV class="code">
+<PRE>
+ if (!arg1) {
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException,
+ "invalid native object; delete() likely already called");
+ return ;
+ }
+ (arg1)->wrappedFunction(...);
+</PRE>
+</DIV>
+<P> Note that if you have a parameter named <TT>self</TT> then it will
+ also match the typemap. One work around is to create an interface file
+ that wraps the method, but gives the argument a name other than <TT>
+self</TT>.</P>
+<H2><A name="Typemaps_nn51">11.17 Where to go for more information?</A></H2>
+<P> The best place to find out more information about writing typemaps
+ is to look in the SWIG library. Most language modules define all of
+ their default behavior using typemaps. These are found in files such as
+ <TT>python.swg</TT>, <TT>perl5.swg</TT>, <TT>tcl8.swg</TT> and so
+ forth. The <TT>typemaps.i</TT> file in the library also contains
+ numerous examples. You should look at these files to get a feel for how
+ to define typemaps of your own. Some of the language modules support
+ additional typemaps and further information is available in the
+ individual chapters for each target language. There you may also find
+ more hands-on practical examples.</P>
<HR NOSHADE>
-<H1><A name="Contract"></A>12 Contracts</H1>
+<H1><A name="Customization">12 Customization Features</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<UL>
-<LI><A href="#Contract_nn2">The %contract directive</A></LI>
-<LI><A href="#Contract_nn3">%contract and classes</A></LI>
-<LI><A href="#Contract_nn4">Constant aggregation and %aggregate_check</A>
+<LI><A href="#Customization_exception">Exception handling with
+ %exception</A>
+<UL>
+<LI><A href="#Customization_nn3">Handling exceptions in C code</A></LI>
+<LI><A href="#Customization_nn4">Exception handling with longjmp()</A></LI>
+<LI><A href="#Customization_nn5">Handling C++ exceptions</A></LI>
+<LI><A href="#Customization_allowexcept">Exception handlers for
+ variables</A></LI>
+<LI><A href="#Customization_nn6">Defining different exception handlers</A>
+</LI>
+<LI><A href="#Customization_exception_special_variables">Special
+ variables for %exception</A></LI>
+<LI><A href="#Customization_nn7">Using The SWIG exception library</A></LI>
+</UL>
+</LI>
+<LI><A href="#Customization_ownership">Object ownership and %newobject</A>
+</LI>
+<LI><A href="#Customization_features">Features and the %feature
+ directive</A>
+<UL>
+<LI><A href="#Customization_feature_attributes">Feature attributes</A></LI>
+<LI><A href="#Customization_feature_flags">Feature flags</A></LI>
+<LI><A href="#Customization_clearing_features">Clearing features</A></LI>
+<LI><A href="#Customization_features_default_args">Features and default
+ arguments</A></LI>
+<LI><A href="#Customization_features_example">Feature example</A></LI>
+</UL>
</LI>
-<LI><A href="#Contract_nn5">Notes</A></LI>
</UL>
</DIV>
<!-- INDEX -->
-<P> A common problem that arises when wrapping C libraries is that of
- maintaining reliability and checking for errors. The fact of the matter
- is that many C programs are notorious for not providing error checks.
- Not only that, when you expose the internals of an application as a
- library, it often becomes possible to crash it simply by providing bad
- inputs or using it in a way that wasn't intended.</P>
-<P> This chapter describes SWIG's support for software contracts. In the
- context of SWIG, a contract can be viewed as a runtime constraint that
- is attached to a declaration. For example, you can easily attach
- argument checking rules, check the output values of a function and
- more. When one of the rules is violated by a script, a runtime
- exception is generated rather than having the program continue to
- execute.</P>
-<H2><A name="Contract_nn2"></A>12.1 The %contract directive</H2>
-<P> Contracts are added to a declaration using the %contract directive.
- Here is a simple example:</P>
+<P> In many cases, it is desirable to change the default wrapping of
+ particular declarations in an interface. For example, you might want to
+ provide hooks for catching C++ exceptions, add assertions, or provide
+ hints to the underlying code generator. This chapter describes some of
+ these customization techniques. First, a discussion of exception
+ handling is presented. Then, a more general-purpose customization
+ mechanism known as "features" is described.</P>
+<H2><A name="Customization_exception">12.1 Exception handling with
+ %exception</A></H2>
+<P> The <TT>%exception</TT> directive allows you to define a general
+ purpose exception handler. For example, you can specify the following:</P>
<DIV class="code">
<PRE>
-%contract sqrt(double x) {
-require:
- x >= 0;
-ensure:
- sqrt >= 0;
+%exception {
+ try {
+ $action
+ }
+ catch (RangeError) {
+ ... handle error ...
+ }
}
-
-...
-double sqrt(double);
-</PRE>
-</DIV>
-<P> In this case, a contract is being added to the <TT>sqrt()</TT>
- function. The <TT>%contract</TT> directive must always appear before
- the declaration in question. Within the contract there are two
- sections, both of which are optional. The <TT>require:</TT> section
- specifies conditions that must hold before the function is called.
- Typically, this is used to check argument values. The <TT>ensure:</TT>
- section specifies conditions that must hold after the function is
- called. This is often used to check return values or the state of the
- program. In both cases, the conditions that must hold must be specified
- as boolean expressions.</P>
-<P> In the above example, we're simply making sure that sqrt() returns a
- non-negative number (if it didn't, then it would be broken in some
- way).</P>
-<P> Once a contract has been specified, it modifies the behavior of the
- resulting module. For example:</P>
-<DIV class="shell">
-<PRE>
->>> example.sqrt(2)
-1.4142135623730951
->>> example.sqrt(-2)
-Traceback (most recent call last):
- File "<stdin>", line 1, in ?
-RuntimeError: Contract violation: require: (arg1>=0)
->>>
</PRE>
</DIV>
-<H2><A name="Contract_nn3"></A>12.2 %contract and classes</H2>
-<P> The <TT>%contract</TT> directive can also be applied to class
- methods and constructors. For example:</P>
+<P> How the exception is handled depends on the target language, for
+ example, Python:</P>
<DIV class="code">
<PRE>
-%contract Foo::bar(int x, int y) {
-require:
- x > 0;
-ensure:
- bar > 0;
-}
-
-%contract Foo::Foo(int a) {
-require:
- a > 0;
+%exception {
+ try {
+ $action
+ }
+ catch (RangeError) {
+ PyErr_SetString(PyExc_IndexError,"index out-of-bounds");
+ SWIG_fail;
+ }
}
-
-class Foo {
-public:
- Foo(int);
- int bar(int, int);
-};
</PRE>
</DIV>
-<P> The way in which <TT>%contract</TT> is applied is exactly the same
- as the <TT>%feature</TT> directive. Thus, any contract that you
- specified for a base class will also be attached to inherited methods.
- For example:</P>
+<P> When defined, the code enclosed in braces is inserted directly into
+ the low-level wrapper functions. The special variable <TT>$action</TT>
+ is one of a few <A href="#Customization_exception_special_variables">
+%exception special variables</A> supported and gets replaced with the
+ actual operation to be performed (a function call, method invocation,
+ attribute access, etc.). An exception handler remains in effect until
+ it is explicitly deleted. This is done by using either <TT>%exception</TT>
+ or <TT>%noexception</TT> with no code. For example:</P>
<DIV class="code">
<PRE>
-class Spam : public Foo {
-public:
- int bar(int,int); // Gets contract defined for Foo::bar(int,int)
-};
+%exception; // Deletes any previously defined handler
</PRE>
</DIV>
-<P> In addition to this, separate contracts can be applied to both the
- base class and a derived class. For example:</P>
+<P><B> Compatibility note:</B> Previous versions of SWIG used a special
+ directive <TT>%except</TT> for exception handling. That directive is
+ deprecated--<TT>%exception</TT> provides the same functionality, but is
+ substantially more flexible.</P>
+<H3><A name="Customization_nn3">12.1.1 Handling exceptions in C code</A></H3>
+<P> C has no formal exception handling mechanism so there are several
+ approaches that might be used. A somewhat common technique is to simply
+ set a special error code. For example:</P>
<DIV class="code">
<PRE>
-%contract Foo::bar(int x, int) {
-require:
- x > 0;
-}
+/* File : except.c */
-%contract Spam::bar(int, int y) {
-require:
- y > 0;
+static char error_message[256];
+static int error_status = 0;
+
+void throw_exception(char *msg) {
+ strncpy(error_message,msg,256);
+ error_status = 1;
}
-class Foo {
-public:
- int bar(int,int); // Gets Foo::bar contract.
-};
+void clear_exception() {
+ error_status = 0;
+}
+char *check_exception() {
+ if (error_status)
+ return error_message;
+ else
+ return NULL;
+}
-class Spam : public Foo {
-public:
- int bar(int,int); // Gets Foo::bar and Spam::bar contract
-};
</PRE>
</DIV>
-<P> When more than one contract is applied, the conditions specified in
- a "require:" section are combined together using a logical-AND
- operation. In other words conditions specified for the base class and
- conditions specified for the derived class all must hold. In the above
- example, this means that both the arguments to <TT>Spam::bar</TT> must
- be positive.</P>
-<H2><A name="Contract_nn4"></A>12.3 Constant aggregation and
- %aggregate_check</H2>
-<P> Consider an interface file that contains the following code:</P>
+<P> To use these functions, functions simply call <TT>throw_exception()</TT>
+ to indicate an error occurred. For example :</P>
<DIV class="code">
<PRE>
-#define UP 1
-#define DOWN 2
-#define RIGHT 3
-#define LEFT 4
-
-void move(SomeObject *, int direction, int distance);
+double inv(double x) {
+ if (x != 0)
+ return 1.0/x;
+ else {
+ throw_exception("Division by zero");
+ return 0;
+ }
+}
</PRE>
</DIV>
-<P> One thing you might want to do is impose a constraint on the
- direction parameter to make sure it's one of a few accepted values. To
- do that, SWIG provides an easy to use macro %aggregate_check() that
- works like this:</P>
+<P> To catch the exception, you can write a simple exception handler
+ such as the following (shown for Perl5) :</P>
<DIV class="code">
<PRE>
-%aggregate_check(int, check_direction, UP, DOWN, LEFT, RIGHT);
+%exception {
+ char *err;
+ clear_exception();
+ $action
+ if ((err = check_exception())) {
+ croak(err);
+ }
+}
</PRE>
</DIV>
-<P> This merely defines a utility function of the form</P>
+<P> In this case, when an error occurs, it is translated into a Perl
+ error. Each target language has its own approach to creating a runtime
+ error/exception in and for Perl it is the <TT>croak</TT> method shown
+ above.</P>
+<H3><A name="Customization_nn4">12.1.2 Exception handling with longjmp()</A>
+</H3>
+<P> Exception handling can also be added to C code using the <TT>
+<setjmp.h></TT> library. Here is a minimalistic implementation that
+ relies on the C preprocessor :</P>
<DIV class="code">
<PRE>
-int check_direction(int x);
+/* File : except.c
+ Just the declaration of a few global variables we're going to use */
+
+#include <setjmp.h>
+jmp_buf exception_buffer;
+int exception_status;
+
+/* File : except.h */
+#include <setjmp.h>
+extern jmp_buf exception_buffer;
+extern int exception_status;
+
+#define try if ((exception_status = setjmp(exception_buffer)) == 0)
+#define catch(val) else if (exception_status == val)
+#define throw(val) longjmp(exception_buffer,val)
+#define finally else
+
+/* Exception codes */
+
+#define RangeError 1
+#define DivisionByZero 2
+#define OutOfMemory 3
+
</PRE>
</DIV>
-<P> That checks the argument x to see if it is one of the values listed.
- This utility function can be used in contracts. For example:</P>
+<P> Now, within a C program, you can do the following :</P>
<DIV class="code">
<PRE>
-%aggregate_check(int, check_direction, UP, DOWN, RIGHT, LEFT);
-
-%contract move(SomeObject *, int direction, in) {
-require:
- check_direction(direction);
+double inv(double x) {
+ if (x)
+ return 1.0/x;
+ else
+ throw(DivisionByZero);
}
-#define UP 1
-#define DOWN 2
-#define RIGHT 3
-#define LEFT 4
-
-void move(SomeObject *, int direction, int distance);
</PRE>
</DIV>
-<P> Alternatively, it can be used in typemaps and other directives. For
- example:</P>
+<P> Finally, to create a SWIG exception handler, write the following :</P>
<DIV class="code">
<PRE>
-%aggregate_check(int, check_direction, UP, DOWN, RIGHT, LEFT);
+%{
+#include "except.h"
+%}
-%typemap(check) int direction {
- if (!check_direction($1)) SWIG_exception(SWIG_ValueError, "Bad direction");
+%exception {
+ try {
+ $action
+ } catch(RangeError) {
+ croak("Range Error");
+ } catch(DivisionByZero) {
+ croak("Division by zero");
+ } catch(OutOfMemory) {
+ croak("Out of memory");
+ } finally {
+ croak("Unknown exception");
+ }
}
-
-#define UP 1
-#define DOWN 2
-#define RIGHT 3
-#define LEFT 4
-
-void move(SomeObject *, int direction, int distance);
</PRE>
</DIV>
-<P> Regrettably, there is no automatic way to perform similar checks
- with enums values. Maybe in a future release.</P>
-<H2><A name="Contract_nn5"></A>12.4 Notes</H2>
-<P> Contract support was implemented by Songyan (Tiger) Feng and first
- appeared in SWIG-1.3.20.</P>
-<HR NOSHADE>
-<H1><A name="Varargs"></A>13 Variable Length Arguments</H1>
-
-<!-- INDEX -->
-<DIV class="sectiontoc">
-<UL>
-<LI><A href="#Varargs_nn2">Introduction</A></LI>
-<LI><A href="#Varargs_nn3">The Problem</A></LI>
-<LI><A href="#Varargs_nn4">Default varargs support</A></LI>
-<LI><A href="#Varargs_nn5">Argument replacement using %varargs</A></LI>
-<LI><A href="#Varargs_nn6">Varargs and typemaps</A></LI>
-<LI><A href="#Varargs_nn7">Varargs wrapping with libffi</A></LI>
-<LI><A href="#Varargs_nn8">Wrapping of va_list</A></LI>
-<LI><A href="#Varargs_nn9">C++ Issues</A></LI>
-<LI><A href="#Varargs_nn10">Discussion</A></LI>
-</UL>
-</DIV>
-<!-- INDEX -->
-<P><B> (a.k.a, "The horror. The horror.")</B></P>
-<P> This chapter describes the problem of wrapping functions that take a
- variable number of arguments. For instance, generating wrappers for the
- C <TT>printf()</TT> family of functions.</P>
-<P> This topic is sufficiently advanced to merit its own chapter. In
- fact, support for varargs is an often requested feature that was first
- added in SWIG-1.3.12. Most other wrapper generation tools have wisely
- chosen to avoid this issue.</P>
-<H2><A name="Varargs_nn2"></A>13.1 Introduction</H2>
-<P> Some C and C++ programs may include functions that accept a variable
- number of arguments. For example, most programmers are familiar with
- functions from the C library such as the following:</P>
+<P> Note: This implementation is only intended to illustrate the general
+ idea. To make it work better, you'll need to modify it to handle nested
+ <TT>try</TT> declarations.</P>
+<H3><A name="Customization_nn5">12.1.3 Handling C++ exceptions</A></H3>
+<P> Handling C++ exceptions is also straightforward. For example:</P>
<DIV class="code">
<PRE>
-int printf(const char *fmt, ...)
-int fprintf(FILE *, const char *fmt, ...);
-int sprintf(char *s, const char *fmt, ...);
+%exception {
+ try {
+ $action
+ } catch(RangeError) {
+ croak("Range Error");
+ } catch(DivisionByZero) {
+ croak("Division by zero");
+ } catch(OutOfMemory) {
+ croak("Out of memory");
+ } catch(...) {
+ croak("Unknown exception");
+ }
+}
+
</PRE>
</DIV>
-<P> Although there is probably little practical purpose in wrapping
- these specific C library functions in a scripting language (what would
- be the point?), a library may include its own set of special functions
- based on a similar API. For example:</P>
+<P> The exception types need to be declared as classes elsewhere,
+ possibly in a header file :</P>
<DIV class="code">
<PRE>
-int traceprintf(const char *fmt, ...);
+class RangeError {};
+class DivisionByZero {};
+class OutOfMemory {};
</PRE>
</DIV>
-<P> In this case, you may want to have some kind of access from the
- target language.</P>
-<P> Before describing the SWIG implementation, it is important to
- discuss the common uses of varargs that you are likely to encounter in
- real programs. Obviously, there are the <TT>printf()</TT> style output
- functions as shown. Closely related to this would be <TT>scanf()</TT>
- style input functions that accept a format string and a list of
- pointers into which return values are placed. However, variable length
- arguments are also sometimes used to write functions that accept a
- NULL-terminated list of pointers. A good example of this would be a
- function like this:</P>
+<H3><A name="Customization_allowexcept">12.1.4 Exception handlers for
+ variables</A></H3>
+<P> By default all variables will ignore <TT>%exception</TT>, so it is
+ effectively turned off for all variables wrappers. This applies to
+ global variables, member variables and static member variables. The
+ approach is certainly a logical one when wrapping variables in C.
+ However, in C++, it is quite possible for an exception to be thrown
+ while the variable is being assigned. To ensure <TT>%exception</TT> is
+ used when wrapping variables, it needs to be 'turned on' using the <TT>
+%allowexception</TT> feature. Note that <TT>%allowexception</TT> is just
+ a macro for <TT>%feature("allowexcept")</TT>, that is, it is a feature
+ called "allowexcept". Any variable which has this feature attached to
+ it, will then use the <TT>%exception</TT> feature, but of course, only
+ if there is a <TT>%exception</TT> attached to the variable in the first
+ place. The <TT>%allowexception</TT> feature works like any other
+ feature and so can be used globally or for selective variables.</P>
<DIV class="code">
<PRE>
-int execlp(const char *path, const char *arg1, ...);
-...
+%allowexception; // turn on globally
+%allowexception Klass::MyVar; // turn on for a specific variable
-/* Example */
-execlp("ls","ls","-l",NULL);
+%noallowexception Klass::MyVar; // turn off for a specific variable
+%noallowexception; // turn off globally
</PRE>
</DIV>
-<P> In addition, varargs is sometimes used to fake default arguments in
- older C libraries. For instance, the low level <TT>open()</TT> system
- call is often declared as a varargs function so that it will accept two
- or three arguments:</P>
+<H3><A name="Customization_nn6">12.1.5 Defining different exception
+ handlers</A></H3>
+<P> By default, the <TT>%exception</TT> directive creates an exception
+ handler that is used for all wrapper functions that follow it. Unless
+ there is a well-defined (and simple) error handling mechanism in place,
+ defining one universal exception handler may be unwieldy and result in
+ excessive code bloat since the handler is inlined into each wrapper
+ function.</P>
+<P> To fix this, you can be more selective about how you use the <TT>
+%exception</TT> directive. One approach is to only place it around
+ critical pieces of code. For example:</P>
<DIV class="code">
<PRE>
-int open(const char *path, int oflag, ...);
-...
+%exception {
+ ... your exception handler ...
+}
+/* Define critical operations that can throw exceptions here */
-/* Examples */
-f = open("foo", O_RDONLY);
-g = open("bar", O_WRONLY | O_CREAT, 0644);
+%exception;
+
+/* Define non-critical operations that don't throw exceptions */
</PRE>
</DIV>
-<P> Finally, to implement a varargs function, recall that you have to
- use the C library functions defined in <TT><stdarg.h></TT>. For
+<P> More precise control over exception handling can be obtained by
+ attaching an exception handler to specific declaration name. For
example:</P>
<DIV class="code">
<PRE>
-List make_list(const char *s, ...) {
- va_list ap;
- List x;
- ...
- va_start(ap, s);
- while (s) {
- x.append(s);
- s = va_arg(ap, const char *);
+%exception allocate {
+ try {
+ $action
+ }
+ catch (MemoryError) {
+ croak("Out of memory");
}
- va_end(ap);
- return x;
}
</PRE>
</DIV>
-<H2><A name="Varargs_nn3"></A>13.2 The Problem</H2>
-<P> Generating wrappers for a variable length argument function presents
- a number of special challenges. Although C provides support for
- implementing functions that receive variable length arguments, there
- are no functions that can go in the other direction. Specifically, you
- can't write a function that dynamically creates a list of arguments and
- which invokes a varargs function on your behalf.</P>
-<P> Although it is possible to write functions that accept the special
- type <TT>va_list</TT>, this is something entirely different. You can't
- take a <TT>va_list</TT> structure and pass it in place of the variable
- length arguments to another varargs function. It just doesn't work.</P>
-<P> The reason this doesn't work has to do with the way that function
- calls get compiled. For example, suppose that your program has a
- function call like this:</P>
+<P> In this case, the exception handler is only attached to declarations
+ named "allocate". This would include both global and member functions.
+ The names supplied to <TT>%exception</TT> follow the same rules as for <TT>
+%rename</TT> described in the section on <A href="#SWIGPlus_ambiguity_resolution_renaming">
+Ambiguity resolution and renaming</A>. For example, if you wanted to
+ define an exception handler for a specific class, you might write this:</P>
<DIV class="code">
<PRE>
-printf("Hello %s. Your number is %d\n", name, num);
+%exception Object::allocate {
+ try {
+ $action
+ }
+ catch (MemoryError) {
+ croak("Out of memory");
+ }
+}
</PRE>
</DIV>
-<P> When the compiler looks at this, it knows that you are calling <TT>
-printf()</TT> with exactly three arguments. Furthermore, it knows that
- the number of arguments as well are their types and sizes is<EM> never</EM>
- going to change during program execution. Therefore, this gets turned
- to machine code that sets up a three-argument stack frame followed by a
- call to <TT>printf()</TT>.</P>
-<P> In contrast, suppose you attempted to make some kind of wrapper
- around <TT>printf()</TT> using code like this:</P>
+<P> When a class prefix is supplied, the exception handler is applied to
+ the corresponding declaration in the specified class as well as for
+ identically named functions appearing in derived classes.</P>
+<P> <TT>%exception</TT> can even be used to pinpoint a precise
+ declaration when overloading is used. For example:</P>
<DIV class="code">
<PRE>
-int wrap_printf(const char *fmt, ...) {
- va_list ap;
- va_start(ap,fmt);
- ...
- printf(fmt,ap);
- ...
- va_end(ap);
-};
+%exception Object::allocate(int) {
+ try {
+ $action
+ }
+ catch (MemoryError) {
+ croak("Out of memory");
+ }
+}
</PRE>
</DIV>
-<P> Although this code might compile, it won't do what you expect. This
- is because the call to <TT>printf()</TT> is compiled as a procedure
- call involving only two arguments. However, clearly a two-argument
- configuration of the call stack is completely wrong if your intent is
- to pass an arbitrary number of arguments to the real <TT>printf()</TT>.
- Needless to say, it won't work.</P>
-<P> Unfortunately, the situation just described is exactly the problem
- faced by wrapper generation tools. In general, the number of passed
- arguments will not be known until run-time. To make matters even worse,
- you won't know the types and sizes of arguments until run-time as well.
- Needless to say, there is no obvious way to make the C compiler
- generate code for a function call involving an unknown number of
- arguments of unknown types.</P>
-<P> In theory, it<EM> is</EM> possible to write a wrapper that does the
- right thing. However, this involves knowing the underlying ABI for the
- target platform and language as well as writing special purpose code
- that manually constructed the call stack before making a procedure
- call. Unfortunately, both of these tasks require the use of inline
- assembly code. Clearly, that's the kind of solution you would much
- rather avoid.</P>
-<P> With this nastiness in mind, SWIG provides a number of solutions to
- the varargs wrapping problem. Most of these solutions are compromises
- that provide limited varargs support without having to resort to
- assembly language. However, SWIG can also support real varargs wrapping
- (with stack-frame manipulation) if you are willing to get hands dirty.
- Keep reading.</P>
-<H2><A name="Varargs_nn4"></A>13.3 Default varargs support</H2>
-<P> When variable length arguments appear in an interface, the default
- behavior is to drop the variable argument list entirely, replacing them
- with a single NULL pointer. For example, if you had this function,</P>
+<P> Attaching exceptions to specific declarations is a good way to
+ reduce code bloat. It can also be a useful way to attach exceptions to
+ specific parts of a header file. For example:</P>
<DIV class="code">
<PRE>
-void traceprintf(const char *fmt, ...);
+%module example
+%{
+#include "someheader.h"
+%}
+
+// Define a few exception handlers for specific declarations
+%exception Object::allocate(int) {
+ try {
+ $action
+ }
+ catch (MemoryError) {
+ croak("Out of memory");
+ }
+}
+
+%exception Object::getitem {
+ try {
+ $action
+ }
+ catch (RangeError) {
+ croak("Index out of range");
+ }
+}
+...
+// Read a raw header file
+%include "someheader.h"
</PRE>
</DIV>
-<P> it would be wrapped as if it had been declared as follows:</P>
+<P><B> Compatibility note:</B> The <TT>%exception</TT> directive
+ replaces the functionality provided by the deprecated "except" typemap.
+ The typemap would allow exceptions to be thrown in the target language
+ based on the return type of a function and was intended to be a
+ mechanism for pinpointing specific declarations. However, it never
+ really worked that well and the new %exception directive is much
+ better.</P>
+<H3><A name="Customization_exception_special_variables">12.1.6 Special
+ variables for %exception</A></H3>
+<P> The %exception directive supports a few special variables which are
+ placeholders for code substitution. The following table shows the
+ available special variables and details what the special variables are
+ replaced with.</P>
+<TABLE summary="Special variables for %exception">
+<TR><TD>$action</TD><TD>The actual operation to be performed (a function
+ call, method invocation, variable access, etc.)</TD></TR>
+<TR><TD>$name</TD><TD>The C/C++ symbol name for the function.</TD></TR>
+<TR><TD>$symname</TD><TD>The symbol name used internally by SWIG</TD></TR>
+<TR><TD>$overname</TD><TD>The extra mangling used in the symbol name for
+ overloaded method. Expands to nothing if the wrapped method is not
+ overloaded.</TD></TR>
+<TR><TD>$wrapname</TD><TD>The language specific wrapper name (usually a
+ C function name exported from the shared object/dll)</TD></TR>
+<TR><TD>$decl</TD><TD>The fully qualified C/C++ declaration of the
+ method being wrapped without the return type</TD></TR>
+<TR><TD>$fulldecl</TD><TD>The fully qualified C/C++ declaration of the
+ method being wrapped including the return type</TD></TR>
+<TR><TD>$parentclassname</TD><TD>The parent class name (if any) for a
+ method.</TD></TR>
+<TR><TD>$parentclasssymname</TD><TD>The target language parent class
+ name (if any) for a method.</TD></TR>
+</TABLE>
+<P> The special variables are often used in situations where method
+ calls are logged. Exactly which form of the method call needs logging
+ is up to individual requirements, but the example code below shows all
+ the possible expansions, plus how an exception message could be
+ tailored to show the C++ method declaration:</P>
<DIV class="code">
<PRE>
-void traceprintf(const char *fmt);
+%exception Special::something {
+ log("symname: $symname");
+ log("overname: $overname");
+ log("wrapname: $wrapname");
+ log("decl: $decl");
+ log("fulldecl: $fulldecl");
+ try {
+ $action
+ }
+ catch (MemoryError) {
+ croak("Out of memory in $decl");
+ }
+}
+void log(const char *message);
+struct Special {
+ void something(const char *c);
+ void something(int i);
+};
</PRE>
</DIV>
-<P> When the function is called inside the wrappers, it is called as
- follows:</P>
+<P> Below shows the expansions for the 1st of the overloaded <TT>
+something</TT> wrapper methods for Perl:</P>
<DIV class="code">
<PRE>
-traceprintf(arg1, NULL);
+ log("symname: Special_something");
+ log("overname: __SWIG_0");
+ log("wrapname: _wrap_Special_something__SWIG_0");
+ log("decl: Special::something(char const *)");
+ log("fulldecl: void Special::something(char const *)");
+ try {
+ (arg1)->something((char const *)arg2);
+ }
+ catch (MemoryError) {
+ croak("Out of memory in Special::something(char const *)");
+ }
</PRE>
</DIV>
-<P> Arguably, this approach seems to defeat the whole point of variable
- length arguments. However, this actually provides enough support for
- many simple kinds of varargs functions to still be useful, however it
- does come with a caveat. For instance, you could make function calls
- like this (in Python):</P>
-<DIV class="targetlang">
+<H3><A name="Customization_nn7">12.1.7 Using The SWIG exception library</A>
+</H3>
+<P> The <TT>exception.i</TT> library file provides support for creating
+ language independent exceptions in your interfaces. To use it, simply
+ put an "<TT>%include exception.i</TT>" in your interface file. This
+ provides a function <TT>SWIG_exception()</TT> that can be used to raise
+ common scripting language exceptions in a portable manner. For example
+ :</P>
+<DIV class="code">
<PRE>
->>> traceprintf("Hello World")
->>> traceprintf("Hello %s. Your number is %d\n" % (name, num))
->>> traceprintf("Your result is 90%%.")
+// Language independent exception handler
+%include exception.i
+
+%exception {
+ try {
+ $action
+ } catch(RangeError) {
+ SWIG_exception(SWIG_ValueError, "Range Error");
+ } catch(DivisionByZero) {
+ SWIG_exception(SWIG_DivisionByZero, "Division by zero");
+ } catch(OutOfMemory) {
+ SWIG_exception(SWIG_MemoryError, "Out of memory");
+ } catch(...) {
+ SWIG_exception(SWIG_RuntimeError,"Unknown exception");
+ }
+}
+
</PRE>
</DIV>
-<P> Notice how string formatting is being done in Python instead of C.
- The caveat is the strings passed must be safe to use in C though. For
- example if name was to contain a "%" it should be double escaped in
- order to avoid unpredictable behaviour:</P>
-<DIV class="targetlang">
+<P> As arguments, <TT>SWIG_exception()</TT> takes an error type code (an
+ integer) and an error message string. The currently supported error
+ types are :</P>
+<DIV class="diagram">
<PRE>
->>> traceprintf("Your result is 90%.\n") # unpredictable behaviour
->>> traceprintf("Your result is 90%%.\n") # good
+SWIG_UnknownError
+SWIG_IOError
+SWIG_RuntimeError
+SWIG_IndexError
+SWIG_TypeError
+SWIG_DivisionByZero
+SWIG_OverflowError
+SWIG_SyntaxError
+SWIG_ValueError
+SWIG_SystemError
+SWIG_AttributeError
+SWIG_MemoryError
+SWIG_NullReferenceError
</PRE>
</DIV>
-<P> Read on for further solutions.</P>
-<H2><A name="Varargs_nn5"></A>13.4 Argument replacement using %varargs</H2>
-<P> Instead of dropping the variable length arguments, an alternative
- approach is to replace <TT>(...)</TT> with a set of suitable arguments.
- SWIG provides a special <TT>%varargs</TT> directive that can be used to
- do this. For example,</P>
+<P> The <TT>SWIG_exception()</TT> function can also be used in typemaps.</P>
+<H2><A name="Customization_ownership">12.2 Object ownership and
+ %newobject</A></H2>
+<P> A common problem in some applications is managing proper ownership
+ of objects. For example, consider a function like this:</P>
<DIV class="code">
<PRE>
-%varargs(int mode = 0) open;
-...
-int open(const char *path, int oflags, ...);
+Foo *blah() {
+ Foo *f = new Foo();
+ return f;
+}
</PRE>
</DIV>
-<P> is equivalent to this:</P>
+<P> If you wrap the function <TT>blah()</TT>, SWIG has no idea that the
+ return value is a newly allocated object. As a result, the resulting
+ extension module may produce a memory leak (SWIG is conservative and
+ will never delete objects unless it knows for certain that the returned
+ object was newly created).</P>
+<P> To fix this, you can provide an extra hint to the code generator
+ using the <TT>%newobject</TT> directive. For example:</P>
<DIV class="code">
<PRE>
-int open(const char *path, int oflags, int mode = 0);
+%newobject blah;
+Foo *blah();
</PRE>
</DIV>
-<P> In this case, <TT>%varargs</TT> is simply providing more specific
- information about the extra arguments that might be passed to a
- function. If the arguments to a varargs function are of uniform type, <TT>
-%varargs</TT> can also accept a numerical argument count as follows:</P>
+<P> <TT>%newobject</TT> works exactly like <TT>%rename</TT> and <TT>
+%exception</TT>. In other words, you can attach it to class members and
+ parameterized declarations as before. For example:</P>
<DIV class="code">
<PRE>
-%varargs(3, char *str = NULL) execlp;
+%newobject ::blah(); // Only applies to global blah
+%newobject Object::blah(int,double); // Only blah(int,double) in Object
+%newobject *::copy; // Copy method in all classes
...
-int execlp(const char *path, const char *arg, ...);
</PRE>
</DIV>
-<P> and is effectively seen as:</P>
+<P> When <TT>%newobject</TT> is supplied, many language modules will
+ arrange to take ownership of the return value. This allows the value to
+ be automatically garbage-collected when it is no longer in use.
+ However, this depends entirely on the target language (a language
+ module may also choose to ignore the <TT>%newobject</TT> directive).</P>
+<P> Closely related to <TT>%newobject</TT> is a special typemap. The
+ "newfree" typemap can be used to deallocate a newly allocated return
+ value. It is only available on methods for which <TT>%newobject</TT>
+ has been applied and is commonly used to clean-up string results. For
+ example:</P>
<DIV class="code">
<PRE>
-int execlp(const char *path, const char *arg,
- char *str1 = NULL,
- char *str2 = NULL,
- char *str3 = NULL);
+%typemap(newfree) char * "free($1);";
+...
+%newobject strdup;
+...
+char *strdup(const char *s);
</PRE>
</DIV>
-<P> This would wrap <TT>execlp()</TT> as a function that accepted up to
- 3 optional arguments. Depending on the application, this may be more
- than enough for practical purposes.</P>
-<P> The handling of <A href="#SWIGPlus_default_args">default arguments</A>
- can be changed via the <TT>compactdefaultargs</TT> feature. If this
- feature is used, for example</P>
+<P> In this case, the result of the function is a string in the target
+ language. Since this string is a copy of the original result, the data
+ returned by <TT>strdup()</TT> is no longer needed. The "newfree"
+ typemap in the example simply releases this memory.</P>
+<P> As a complement to the <TT>%newobject</TT>, from SWIG 1.3.28, you
+ can use the <TT>%delobject</TT> directive. For example, if you have two
+ methods, one to create objects and one to destroy them, you can use:</P>
<DIV class="code">
<PRE>
-%feature("compactdefaultargs") execlp;
-%varargs(3, char *str = NULL) execlp;
+%newobject create_foo;
+%delobject destroy_foo;
...
-int execlp(const char *path, const char *arg, ...);
+Foo *create_foo();
+void destroy_foo(Foo *foo);
</PRE>
</DIV>
-<P> a call from the target language which does not provide the maximum
- number of arguments, such as, <TT>execlp("a", "b", "c")</TT> will
- generate C code which includes the missing default values, that is, <TT>
-execlp("a", "b", "c", NULL, NULL)</TT>. If <TT>compactdefaultargs</TT>
- is not used, then the generated code will be <TT>execlp("a", "b", "c")</TT>
-. The former is useful for helping providing a sentinel to terminate the
- argument list. However, this is not guaranteed, for example when a user
- passes a non-NULL value for all the parameters. When using <TT>
-compactdefaultargs</TT> it is possible to guarantee the NULL sentinel is
- passed through the, <TT>numinputs=0</TT> <A href="#Typemaps_nn26">'in'
- typemap attribute</A>, naming the<B> last parameter</B>. For example,</P>
+<P> or in a member method as:</P>
<DIV class="code">
<PRE>
-%feature("compactdefaultargs") execlp;
-%varargs(3, char *str = NULL) execlp;
-%typemap(in, numinputs=0) char *str3 ""
-...
-int execlp(const char *path, const char *arg, ...);
+%delobject Foo::destroy;
+
+class Foo {
+public:
+ void destroy() { delete this;}
+
+private:
+ ~Foo();
+};
</PRE>
</DIV>
-<P> Note that <TT>str3</TT> is the name of the last argument, as we have
- used <TT>%varargs</TT> with 3. Now <TT>execlp("a", "b", "c", "d", "e")</TT>
- will result in an error as one too many arguments has been passed, as
- now only 2 additional 'str' arguments can be passed with the 3rd one
- always using the specified default <TT>NULL</TT>.</P>
-<P> Argument replacement is most appropriate in cases where the types of
- the extra arguments are uniform and the maximum number of arguments are
- known. Argument replacement is not as useful when working with
- functions that accept mixed argument types such as <TT>printf()</TT>.
- Providing general purpose wrappers to such functions presents special
- problems (covered shortly).</P>
-<H2><A name="Varargs_nn6"></A>13.5 Varargs and typemaps</H2>
-<P> Variable length arguments may be used in typemap specifications. For
- example:</P>
+<P> <TT>%delobject</TT> instructs SWIG that the first argument passed to
+ the method will be destroyed, and therefore, the target language should
+ not attempt to deallocate it twice. This is similar to use the DISOWN
+ typemap in the first method argument, and in fact, it also depends on
+ the target language on implementing the 'disown' mechanism properly.</P>
+<P> The use of <TT>%newobject</TT> is also integrated with reference
+ counting and is covered in the <A href="#SWIGPlus_ref_unref">C++
+ reference counted objects</A> section.</P>
+<P><B> Compatibility note:</B> Previous versions of SWIG had a special <TT>
+%new</TT> directive. However, unlike <TT>%newobject</TT>, it only
+ applied to the next declaration. For example:</P>
<DIV class="code">
<PRE>
-%typemap(in) (...) {
- // Get variable length arguments (somehow)
- ...
+%new char *strdup(const char *s);
+</PRE>
+</DIV>
+<P> For now this is still supported but is deprecated.</P>
+<P><B> How to shoot yourself in the foot:</B> The <TT>%newobject</TT>
+ directive is not a declaration modifier like the old <TT>%new</TT>
+ directive. Don't write code like this:</P>
+<DIV class="code">
+<PRE>
+%newobject
+char *strdup(const char *s);
+</PRE>
+</DIV>
+<P> The results might not be what you expect.</P>
+<H2><A name="Customization_features">12.3 Features and the %feature
+ directive</A></H2>
+<P> Both <TT>%exception</TT> and <TT>%newobject</TT> are examples of a
+ more general purpose customization mechanism known as "features." A
+ feature is simply a user-definable property that is attached to
+ specific declarations. Features are attached using the <TT>%feature</TT>
+ directive. For example:</P>
+<DIV class="code">
+<PRE>
+%feature("except") Object::allocate {
+ try {
+ $action
+ }
+ catch (MemoryError) {
+ croak("Out of memory");
+ }
}
-%typemap(in) (const char *fmt, ...) {
- // Multi-argument typemap
-}
+%feature("new","1") *::copy;
</PRE>
</DIV>
-<P> However, this immediately raises the question of what "type" is
- actually used to represent <TT>(...)</TT>. For lack of a better
- alternative, the type of <TT>(...)</TT> is set to <TT>void *</TT>.
- Since there is no way to dynamically pass arguments to a varargs
- function (as previously described), the <TT>void *</TT> argument value
- is intended to serve as a place holder for storing some kind of
- information about the extra arguments (if any). In addition, the
- default behavior of SWIG is to pass the <TT>void *</TT> value as an
- argument to the function. Therefore, you could use the pointer to hold
- a valid argument value if you wanted.</P>
-<P> To illustrate, here is a safer version of wrapping <TT>printf()</TT>
- in Python:</P>
+<P> In fact, the <TT>%exception</TT> and <TT>%newobject</TT> directives
+ are really nothing more than macros involving <TT>%feature</TT>:</P>
<DIV class="code">
<PRE>
-%typemap(in) (const char *fmt, ...) {
- $1 = "%s"; /* Fix format string to %s */
- $2 = (void *) PyString_AsString($input); /* Get string argument */
-};
-...
-int printf(const char *fmt, ...);
+#define %exception %feature("except")
+#define %newobject %feature("new","1")
</PRE>
</DIV>
-<P> In this example, the format string is implicitly set to <TT>"%s"</TT>
-. This prevents a program from passing a bogus format string to the
- extension. Then, the passed input object is decoded and placed in the <TT>
-void *</TT> argument defined for the <TT>(...)</TT> argument. When the
- actual function call is made, the underlying wrapper code will look
- roughly like this:</P>
+<P> The name matching rules outlined in the <A href="#SWIGPlus_ambiguity_resolution_renaming">
+Ambiguity resolution and renaming</A> section applies to all <TT>
+%feature</TT> directives. In fact the <TT>%rename</TT> directive is just
+ a special form of <TT>%feature</TT>. The matching rules mean that
+ features are very flexible and can be applied with pinpoint accuracy to
+ specific declarations if needed. Additionally, if no declaration name
+ is given, a global feature is said to be defined. This feature is then
+ attached to<EM> every</EM> declaration that follows. This is how global
+ exception handlers are defined. For example:</P>
<DIV class="code">
<PRE>
-wrap_printf() {
- char *arg1;
- void *arg2;
- int result;
-
- arg1 = "%s";
- arg2 = (void *) PyString_AsString(arg2obj);
- ...
- result = printf(arg1,arg2);
+/* Define a global exception handler */
+%feature("except") {
+ try {
+ $action
+ }
...
}
+
+... bunch of declarations ...
</PRE>
</DIV>
-<P> Notice how both arguments are passed to the function and it does
- what you would expect.</P>
-<P> The next example illustrates a more advanced kind of varargs
- typemap. Disclaimer: this requires special support in the target
- language module and is not guaranteed to work with all SWIG modules at
- this time. It also starts to illustrate some of the more fundamental
- problems with supporting varargs in more generality.</P>
-<P> If a typemap is defined for any form of <TT>(...)</TT>, many SWIG
- modules will generate wrappers that accept a variable number of
- arguments as input and will make these arguments available in some
- form. The precise details of this depends on the language module being
- used (consult the appropriate chapter for more details). However,
- suppose that you wanted to create a Python wrapper for the <TT>execlp()</TT>
- function shown earlier. To do this using a typemap instead of using <TT>
-%varargs</TT>, you might first write a typemap like this:</P>
+<P> The <TT>%feature</TT> directive can be used with different syntax.
+ The following are all equivalent:</P>
<DIV class="code">
<PRE>
-%typemap(in) (...)(char *vargs[10]) {
- int i;
- int argc;
- for (i = 0; i < 10; i++) vargs[i] = 0;
- argc = PyTuple_Size(varargs);
- if (argc > 10) {
- PyErr_SetString(PyExc_ValueError, "Too many arguments");
- return NULL;
- }
- for (i = 0; i < argc; i++) {
- PyObject *pyobj = PyTuple_GetItem(varargs, i);
- char *str = 0;
-%#if PY_VERSION_HEX>=0x03000000
- PyObject *pystr;
- if (!PyUnicode_Check(pyobj)) {
- PyErr_SetString(PyExc_ValueError, "Expected a string");
- return NULL;
- }
- pystr = PyUnicode_AsUTF8String(pyobj);
- str = strdup(PyBytes_AsString(pystr));
- Py_XDECREF(pystr);
-%#else
- if (!PyString_Check(pyobj)) {
- PyErr_SetString(PyExc_ValueError, "Expected a string");
- return NULL;
- }
- str = PyString_AsString(pyobj);
-%#endif
- vargs[i] = str;
- }
- $1 = (void *)vargs;
-}
-
-%typemap(freearg) (...) {
-%#if PY_VERSION_HEX>=0x03000000
- int i;
- for (i = 0; i < 10; i++) {
- free(vargs$argnum[i]);
- }
-%#endif
-}
+%feature("except") Object::method { $action };
+%feature("except") Object::method %{ $action %};
+%feature("except") Object::method " $action ";
+%feature("except","$action") Object::method;
</PRE>
</DIV>
-<P> In the 'in' typemap, the special variable <TT>varargs</TT> is a
- tuple holding all of the extra arguments passed (this is specific to
- the Python module). The typemap then pulls this apart and sticks the
- values into the array of strings <TT>args</TT>. Then, the array is
- assigned to <TT>$1</TT> (recall that this is the <TT>void *</TT>
- variable corresponding to <TT>(...)</TT>). However, this assignment is
- only half of the picture----clearly this alone is not enough to make
- the function work. The 'freearg' typemap cleans up memory allocated in
- the 'in' typemap; this code is generated to be called after the <TT>
-execlp</TT> function is called. To patch everything up, you have to
- rewrite the underlying action code using the <TT>%feature</TT>
- directive like this:</P>
+<P> The syntax in the first variation will generate the <TT>{ }</TT>
+ delimiters used whereas the other variations will not.</P>
+<H3><A name="Customization_feature_attributes">12.3.1 Feature attributes</A>
+</H3>
+<P> The <TT>%feature</TT> directive also accepts XML style attributes in
+ the same way that typemaps do. Any number of attributes can be
+ specified. The following is the generic syntax for features:</P>
<DIV class="code">
<PRE>
-%feature("action") execlp {
- char **vargs = (char **) arg3;
- result = execlp(arg1, arg2, vargs[0], vargs[1], vargs[2], vargs[3], vargs[4],
- vargs[5], vargs[6], vargs[7], vargs[8], vargs[9], NULL);
-}
-
-int execlp(const char *path, const char *arg, ...);
+%feature("name","value", attribute1="AttributeValue1") symbol;
+%feature("name", attribute1="AttributeValue1") symbol {value};
+%feature("name", attribute1="AttributeValue1") symbol %{value%};
+%feature("name", attribute1="AttributeValue1") symbol "value";
</PRE>
</DIV>
-<P> This patches everything up and creates a function that more or less
- works. However, don't try explaining this to your coworkers unless you
- know for certain that they've had several cups of coffee. If you really
- want to elevate your guru status and increase your job security,
- continue to the next section.</P>
-<H2><A name="Varargs_nn7"></A>13.6 Varargs wrapping with libffi</H2>
-<P> All of the previous examples have relied on features of SWIG that
- are portable and which don't rely upon any low-level machine-level
- details. In many ways, they have all dodged the real issue of variable
- length arguments by recasting a varargs function into some weaker
- variation with a fixed number of arguments of known types. In many
- cases, this works perfectly fine. However, if you want more generality
- than this, you need to bring out some bigger guns.</P>
-<P> One way to do this is to use a special purpose library such as
- libffi (<A href="http://sources.redhat.com/libffi/">
-http://sources.redhat.com/libffi</A>). libffi is a library that allows
- you to dynamically construct call-stacks and invoke procedures in a
- relatively platform independent manner. Details about the library can
- be found in the libffi distribution and are not repeated here.</P>
-<P> To illustrate the use of libffi, suppose that you<EM> really</EM>
- wanted to create a wrapper for <TT>execlp()</TT> that accepted<EM> any</EM>
- number of arguments. To do this, you might make a few adjustments to
- the previous example. For example:</P>
+<P> More than one attribute can be specified using a comma separated
+ list. The Java module is an example that uses attributes in <TT>
+%feature("except")</TT>. The <TT>throws</TT> attribute specifies the
+ name of a Java class to add to a proxy method's throws clause. In the
+ following example, <TT>MyExceptionClass</TT> is the name of the Java
+ class for adding to the throws clause.</P>
<DIV class="code">
<PRE>
-/* Take an arbitrary number of extra arguments and place into an array
- of strings */
-
-%typemap(in) (...) {
- char **argv;
- int argc;
- int i;
-
- argc = PyTuple_Size(varargs);
- argv = (char **) malloc(sizeof(char *)*(argc+1));
- for (i = 0; i < argc; i++) {
- PyObject *o = PyTuple_GetItem(varargs,i);
- if (!PyString_Check(o)) {
- PyErr_SetString(PyExc_ValueError,"Expected a string");
- free(argv);
- return NULL;
- }
- argv[i] = PyString_AsString(o);
+%feature("except", throws="MyExceptionClass") Object::method {
+ try {
+ $action
+ } catch (...) {
+ ... code to throw a MyExceptionClass Java exception ...
}
- argv[i] = NULL;
- $1 = (void *) argv;
-}
-
-/* Rewrite the function call, using libffi */
-
-%feature("action") execlp {
- int i, vc;
- ffi_cif cif;
- ffi_type **types;
- void **values;
- char **args;
-
- vc = PyTuple_Size(varargs);
- types = (ffi_type **) malloc((vc+3)*sizeof(ffi_type *));
- values = (void **) malloc((vc+3)*sizeof(void *));
- args = (char **) arg3;
-
- /* Set up path parameter */
- types[0] = &ffi_type_pointer;
- values[0] = &arg1;
-
- /* Set up first argument */
- types[1] = &ffi_type_pointer;
- values[1] = &arg2;
-
- /* Set up rest of parameters */
- for (i = 0; i <= vc; i++) {
- types[2+i] = &ffi_type_pointer;
- values[2+i] = &args[i];
- }
- if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, vc+3,
- &ffi_type_uint, types) == FFI_OK) {
- ffi_call(&cif, (void (*)()) execlp, &result, values);
- } else {
- PyErr_SetString(PyExc_RuntimeError, "Whoa!!!!!");
- free(types);
- free(values);
- free(arg3);
- return NULL;
- }
- free(types);
- free(values);
- free(arg3);
-}
-
-/* Declare the function. Whew! */
-int execlp(const char *path, const char *arg1, ...);
+};
</PRE>
</DIV>
-<P> Looking at this example, you may start to wonder if SWIG is making
- life any easier. Given the amount of code involved, you might also
- wonder why you didn't just write a hand-crafted wrapper! Either that or
- you're wondering "why in the hell am I trying to wrap this varargs
- function in the first place?!?" Obviously, those are questions you'll
- have to answer for yourself.</P>
-<P> As a more extreme example of libffi, here is some code that attempts
- to wrap <TT>printf()</TT>,</P>
+<P> Further details can be obtained from the <A href="#Java_exception_handling">
+Java exception handling</A> section.</P>
+<H3><A name="Customization_feature_flags">12.3.2 Feature flags</A></H3>
+<P> Feature flags are used to enable or disable a particular feature.
+ Feature flags are a common but simple usage of <TT>%feature</TT> and
+ the feature value should be either <TT>1</TT> to enable or <TT>0</TT>
+ to disable the feature.</P>
<DIV class="code">
<PRE>
-/* A wrapper for printf() using libffi */
-
-%{
-/* Structure for holding passed arguments after conversion */
- typedef struct {
- int type;
- union {
- int ivalue;
- double dvalue;
- void *pvalue;
- } val;
- } vtype;
- enum { VT_INT, VT_DOUBLE, VT_POINTER };
-%}
-
-%typemap(in) (const char *fmt, ...) {
- vtype *argv;
- int argc;
- int i;
-
- /* Format string */
- $1 = PyString_AsString($input);
-
- /* Variable length arguments */
- argc = PyTuple_Size(varargs);
- argv = (vtype *) malloc(argc*sizeof(vtype));
- for (i = 0; i < argc; i++) {
- PyObject *o = PyTuple_GetItem(varargs,i);
- if (PyInt_Check(o)) {
- argv[i].type = VT_INT;
- argv[i].val.ivalue = PyInt_AsLong(o);
- } else if (PyFloat_Check(o)) {
- argv[i].type = VT_DOUBLE;
- argv[i].val.dvalue = PyFloat_AsDouble(o);
- } else if (PyString_Check(o)) {
- argv[i].type = VT_POINTER;
- argv[i].val.pvalue = (void *) PyString_AsString(o);
- } else {
- PyErr_SetString(PyExc_ValueError,"Unsupported argument type");
- free(argv);
- return NULL;
- }
- }
- $2 = (void *) argv;
-}
-
-/* Rewrite the function call using libffi */
-%feature("action") printf {
- int i, vc;
- ffi_cif cif;
- ffi_type **types;
- void **values;
- vtype *args;
+%feature("featurename") // enables feature
+%feature("featurename", "1") // enables feature
+%feature("featurename", "x") // enables feature
+%feature("featurename", "0") // disables feature
+%feature("featurename", "") // clears feature
+</PRE>
+</DIV>
+<P> Actually any value other than zero will enable the feature. Note
+ that if the value is omitted completely, the default value becomes <TT>
+1</TT>, thereby enabling the feature. A feature is cleared by specifying
+ no value, see <A href="#Customization_clearing_features">Clearing
+ features</A>. The <TT>%immutable</TT> directive described in the <A href="#SWIG_readonly_variables">
+Creating read-only variables</A> section, is just a macro for <TT>
+%feature("immutable")</TT>, and can be used to demonstrates feature
+ flags:</P>
+<DIV class="code">
+<PRE>
+ // features are disabled by default
+int red; // mutable
- vc = PyTuple_Size(varargs);
- types = (ffi_type **) malloc((vc+1)*sizeof(ffi_type *));
- values = (void **) malloc((vc+1)*sizeof(void *));
- args = (vtype *) arg2;
+%feature("immutable"); // global enable
+int orange; // immutable
- /* Set up fmt parameter */
- types[0] = &ffi_type_pointer;
- values[0] = &arg1;
+%feature("immutable","0"); // global disable
+int yellow; // mutable
- /* Set up rest of parameters */
- for (i = 0; i < vc; i++) {
- switch(args[i].type) {
- case VT_INT:
- types[1+i] = &ffi_type_uint;
- values[1+i] = &args[i].val.ivalue;
- break;
- case VT_DOUBLE:
- types[1+i] = &ffi_type_double;
- values[1+i] = &args[i].val.dvalue;
- break;
- case VT_POINTER:
- types[1+i] = &ffi_type_pointer;
- values[1+i] = &args[i].val.pvalue;
- break;
- default:
- abort(); /* Whoa! We're seriously hosed */
- break;
- }
- }
- if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, vc+1,
- &ffi_type_uint, types) == FFI_OK) {
- ffi_call(&cif, (void (*)()) printf, &result, values);
- } else {
- PyErr_SetString(PyExc_RuntimeError, "Whoa!!!!!");
- free(types);
- free(values);
- free(args);
- return NULL;
- }
- free(types);
- free(values);
- free(args);
-}
+%feature("immutable","1"); // another form of global enable
+int green; // immutable
-/* The function */
-int printf(const char *fmt, ...);
+%feature("immutable",""); // clears the global feature
+int blue; // mutable
</PRE>
</DIV>
-<P> Much to your amazement, it even seems to work if you try it:</P>
-<DIV class="targetlang">
+<P> Note that features are disabled by default and must be explicitly
+ enabled either globally or by specifying a targeted declaration. The
+ above intersperses SWIG directives with C code. Of course you can
+ target features explicitly, so the above could also be rewritten as:</P>
+<DIV class="code">
<PRE>
->>> import example
->>> example.printf("Grade: %s %d/60 = %0.2f%%\n", "Dave", 47, 47.0*100/60)
-Grade: Dave 47/60 = 78.33%
->>>
+%feature("immutable","1") orange;
+%feature("immutable","1") green;
+int red; // mutable
+int orange; // immutable
+int yellow; // mutable
+int green; // immutable
+int blue; // mutable
</PRE>
</DIV>
-<P> Of course, there are still some limitations to consider:</P>
-<DIV class="targetlang">
+<P> The above approach allows for the C declarations to be separated
+ from the SWIG directives for when the C declarations are parsed from a
+ C header file. The logic above can of course be inverted and rewritten
+ as:</P>
+<DIV class="code">
<PRE>
->>> example.printf("la de da de da %s", 42)
-Segmentation fault (core dumped)
+%feature("immutable","1");
+%feature("immutable","0") red;
+%feature("immutable","0") yellow;
+%feature("immutable","0") blue;
+int red; // mutable
+int orange; // immutable
+int yellow; // mutable
+int green; // immutable
+int blue; // mutable
</PRE>
</DIV>
-<P> And, on this note, we leave further exploration of libffi to the
- reader as an exercise. Although Python has been used as an example,
- most of the techniques in this section can be extrapolated to other
- language modules with a bit of work. The only details you need to know
- is how the extra arguments are accessed in each target language. For
- example, in the Python module, we used the special <TT>varargs</TT>
- variable to get these arguments. Modules such as Tcl8 and Perl5 simply
- provide an argument number for the first extra argument. This can be
- used to index into an array of passed arguments to get values. Please
- consult the chapter on each language module for more details.</P>
-<H2><A name="Varargs_nn8"></A>13.7 Wrapping of va_list</H2>
-<P> Closely related to variable length argument wrapping, you may
- encounter functions that accept a parameter of type <TT>va_list</TT>.
- For example:</P>
+<P> As hinted above for <TT>%immutable</TT>, most feature flags can also
+ be specified via alternative syntax. The alternative syntax is just a
+ macro in the <TT>swig.swg</TT> Library file. The following shows the
+ alternative syntax for the imaginary <TT>featurename</TT> feature:</P>
<DIV class="code">
<PRE>
-int vprintf(const char *fmt, va_list ap);
+%featurename // equivalent to %feature("featurename", "1") ie enables feature
+%nofeaturename // equivalent to %feature("featurename", "0") ie disables feature
+%clearfeaturename // equivalent to %feature("featurename", "") ie clears feature
</PRE>
</DIV>
-<P> As far as we know, there is no obvious way to wrap these functions
- with SWIG. This is because there is no documented way to assemble the
- proper va_list structure (there are no C library functions to do it and
- the contents of va_list are opaque). Not only that, the contents of a <TT>
-va_list</TT> structure are closely tied to the underlying call-stack.
- It's not clear that exporting a <TT>va_list</TT> would have any use or
- that it would work at all.</P>
-<P> A workaround can be implemented by writing a simple varargs C
- wrapper and then using the techniques discussed earlier in this chapter
- for varargs. Below is a simple wrapper for <TT>vprintf</TT> renamed so
- that it can still be called as <TT>vprintf</TT> from your target
- language. The <TT>%varargs</TT> used in the example restricts the
- function to taking one string argument.</P>
+<P> The concept of clearing features is discussed next.</P>
+<H3><A name="Customization_clearing_features">12.3.3 Clearing features</A>
+</H3>
+<P> A feature stays in effect until it is explicitly cleared. A feature
+ is cleared by supplying a <TT>%feature</TT> directive with no value.
+ For example <TT>%feature("name","")</TT>. A cleared feature means that
+ any feature exactly matching any previously defined feature is no
+ longer used in the name matching rules. So if a feature is cleared, it
+ might mean that another name matching rule will apply. To clarify,
+ let's consider the <TT>except</TT> feature again (<TT>%exception</TT>):</P>
<DIV class="code">
<PRE>
-%{
-int vprintf(const char *fmt, va_list ap);
-%}
+// Define global exception handler
+%feature("except") {
+ try {
+ $action
+ } catch (...) {
+ croak("Unknown C++ exception");
+ }
+}
-%varargs(const char *) my_vprintf;
-%rename(vprintf) my_vprintf;
+// Define exception handler for all clone methods to log the method calls
+%feature("except") *::clone() {
+ try {
+ logger.info("$action");
+ $action
+ } catch (...) {
+ croak("Unknown C++ exception");
+ }
+}
-%inline %{
-int my_vprintf(const char *fmt, ...) {
- va_list ap;
- int result;
+... initial set of class declarations with clone methods ...
- va_start(ap, fmt);
- result = vprintf(fmt, ap);
- va_end(ap);
- return result;
-}
-%}
+// clear the previously defined feature
+%feature("except","") *::clone();
+
+... final set of class declarations with clone methods ...
</PRE>
</DIV>
-<H2><A name="Varargs_nn9"></A>13.8 C++ Issues</H2>
-<P> Wrapping of C++ member functions that accept a variable number of
- arguments presents a number of challenges. By far, the easiest way to
- handle this is to use the <TT>%varargs</TT> directive. This is portable
- and it fully supports classes much like the <TT>%rename</TT> directive.
- For example:</P>
+<P> In the above scenario, the initial set of clone methods will log all
+ method invocations from the target language. This specific feature is
+ cleared for the final set of clone methods. However, these clone
+ methods will still have an exception handler (without logging) as the
+ next best feature match for them is the global exception handler.</P>
+<P> Note that clearing a feature is not always the same as disabling it.
+ Clearing the feature above with <TT>%feature("except","") *::clone()</TT>
+ is not the same as specifying <TT>%feature("except","0") *::clone()</TT>
+. The former will disable the feature for clone methods - the feature is
+ still a better match than the global feature. If on the other hand, no
+ global exception handler had been defined at all, then clearing the
+ feature would be the same as disabling it as no other feature would
+ have matched.</P>
+<P> Note that the feature must match exactly for it to be cleared by any
+ previously defined feature. For example the following attempt to clear
+ the initial feature will not work:</P>
<DIV class="code">
<PRE>
-%varargs (10, char * = NULL) Foo::bar;
-
-class Foo {
-public:
- virtual void bar(char *arg, ...); // gets varargs above
-};
-
-class Spam: public Foo {
-public:
- virtual void bar(char *arg, ...); // gets varargs above
-};
+%feature("except") clone() { logger.info("$action"); $action }
+%feature("except","") *::clone();
</PRE>
</DIV>
-<P> <TT>%varargs</TT> also works with constructors, operators, and any
- other C++ programming construct that accepts variable arguments.</P>
-<P> Doing anything more advanced than this is likely to involve a
- serious world of pain. In order to use a library like libffi, you will
- need to know the underlying calling conventions and details of the C++
- ABI. For instance, the details of how <TT>this</TT> is passed to member
- functions as well as any hidden arguments that might be used to pass
- additional information. These details are implementation specific and
- may differ between compilers and even different versions of the same
- compiler. Also, be aware that invoking a member function is further
- complicated if it is a virtual method. In this case, invocation might
- require a table lookup to obtain the proper function address (although
- you might be able to obtain an address by casting a bound pointer to a
- pointer to function as described in the C++ ARM section 18.3.4).</P>
-<P> If you do decide to change the underlying action code, be aware that
- SWIG always places the <TT>this</TT> pointer in <TT>arg1</TT>. Other
- arguments are placed in <TT>arg2</TT>, <TT>arg3</TT>, and so forth. For
- example:</P>
+<P> but this will:</P>
<DIV class="code">
<PRE>
-%feature("action") Foo::bar {
- ...
- result = arg1->bar(arg2, arg3, etc.);
- ...
-}
+%feature("except") clone() { logger.info("$action"); $action }
+%feature("except","") clone();
</PRE>
</DIV>
-<P> Given the potential to shoot yourself in the foot, it is probably
- easier to reconsider your design or to provide an alternative interface
- using a helper function than it is to create a fully general wrapper to
- a varargs C++ member function.</P>
-<H2><A name="Varargs_nn10"></A>13.9 Discussion</H2>
-<P> This chapter has provided a number of techniques that can be used to
- address the problem of variable length argument wrapping. If you care
- about portability and ease of use, the <TT>%varargs</TT> directive is
- probably the easiest way to tackle the problem. However, using
- typemaps, it is possible to do some very advanced kinds of wrapping.</P>
-<P> One point of discussion concerns the structure of the libffi
- examples in the previous section. Looking at that code, it is not at
- all clear that this is the easiest way to solve the problem. However,
- there are a number of subtle aspects of the solution to
- consider--mostly concerning the way in which the problem has been
- decomposed. First, the example is structured in a way that tries to
- maintain separation between wrapper-specific information and the
- declaration of the function itself. The idea here is that you might
- structure your interface like this:</P>
+<P> SWIG provides macros for disabling and clearing features. Many of
+ these can be found in the <TT>swig.swg</TT> library file. The typical
+ pattern is to define three macros; one to define the feature itself,
+ one to disable the feature and one to clear the feature. The three
+ macros below show this for the "except" feature:</P>
<DIV class="code">
<PRE>
-%typemap(const char *fmt, ...) {
- ...
-}
-%feature("action") traceprintf {
- ...
-}
-
-/* Include some header file with traceprintf in it */
-%include "someheader.h"
+#define %exception %feature("except")
+#define %noexception %feature("except","0")
+#define %clearexception %feature("except","")
</PRE>
</DIV>
-<P> Second, careful scrutiny will reveal that the typemaps involving <TT>
-(...)</TT> have nothing whatsoever to do with the libffi library. In
- fact, they are generic with respect to the way in which the function is
- actually called. This decoupling means that it will be much easier to
- consider other library alternatives for making the function call. For
- instance, if libffi wasn't supported on a certain platform, you might
- be able to use something else instead. You could use conditional
- compilation to control this:</P>
+<H3><A name="Customization_features_default_args">12.3.4 Features and
+ default arguments</A></H3>
+<P> SWIG treats methods with default arguments as separate overloaded
+ methods as detailed in the <A href="#SWIGPlus_default_args">default
+ arguments</A> section. Any <TT>%feature</TT> targeting a method with
+ default arguments will apply to all the extra overloaded methods that
+ SWIG generates if the default arguments are specified in the feature.
+ If the default arguments are not specified in the feature, then the
+ feature will match that exact wrapper method only and not the extra
+ overloaded methods that SWIG generates. For example:</P>
<DIV class="code">
<PRE>
-#ifdef USE_LIBFFI
-%feature("action") printf {
- ...
-}
-#endif
-#ifdef USE_OTHERFFI
-%feature("action") printf {
-...
+%feature("except") hello(int i=0, double d=0.0) { ... }
+void hello(int i=0, double d=0.0);
+</PRE>
+</DIV>
+<P> will apply the feature to all three wrapper methods, that is:</P>
+<DIV class="code">
+<PRE>
+void hello(int i, double d);
+void hello(int i);
+void hello();
+</PRE>
+</DIV>
+<P> If the default arguments are not specified in the feature:</P>
+<DIV class="code">
+<PRE>
+%feature("except") hello(int i, double d) { ... }
+void hello(int i=0, double d=0.0);
+</PRE>
+</DIV>
+<P> then the feature will only apply to this wrapper method:</P>
+<DIV class="code">
+<PRE>
+void hello(int i, double d);
+</PRE>
+</DIV>
+<P> and not these wrapper methods:</P>
+<DIV class="code">
+<PRE>
+void hello(int i);
+void hello();
+</PRE>
+</DIV>
+<P> If <A href="#SWIGPlus_default_args">compactdefaultargs</A> are being
+ used, then the difference between specifying or not specifying default
+ arguments in a feature is not applicable as just one wrapper is
+ generated.</P>
+<P><B> Compatibility note:</B> The different behaviour of features
+ specified with or without default arguments was introduced in
+ SWIG-1.3.23 when the approach to wrapping methods with default
+ arguments was changed.</P>
+<H3><A name="Customization_features_example">12.3.5 Feature example</A></H3>
+<P> As has been shown earlier, the intended use for the <TT>%feature</TT>
+ directive is as a highly flexible customization mechanism that can be
+ used to annotate declarations with additional information for use by
+ specific target language modules. Another example is in the Python
+ module. You might use <TT>%feature</TT> to rewrite proxy/shadow class
+ code as follows:</P>
+<DIV class="code">
+<PRE>
+%module example
+%rename(bar_id) bar(int,double);
+
+// Rewrite bar() to allow some nice overloading
+
+%feature("shadow") Foo::bar(int) %{
+def bar(*args):
+ if len(args) == 3:
+ return apply(examplec.Foo_bar_id,args)
+ return apply(examplec.Foo_bar,args)
+%}
+
+class Foo {
+public:
+ int bar(int x);
+ int bar(int x, double y);
}
-#endif
</PRE>
</DIV>
-<P> Finally, even though you might be inclined to just write a
- hand-written wrapper for varargs functions, the techniques used in the
- previous section have the advantage of being compatible with all other
- features of SWIG such as exception handling.</P>
-<P> As a final word, some C programmers seem to have the assumption that
- the wrapping of variable length argument functions is an easily solved
- problem. However, this section has hopefully dispelled some of these
- myths. All things being equal, you are better off avoiding variable
- length arguments if you can. If you can't avoid them, please consider
- some of the simple solutions first. If you can't live with a simple
- solution, proceed with caution. At the very least, make sure you
- carefully read the section "A7.3.2 Function Calls" in Kernighan and
- Ritchie and make sure you fully understand the parameter passing
- conventions used for varargs. Also, be aware of the platform
- dependencies and reliability issues that this will introduce. Good
- luck.</P>
+<P> Further details of <TT>%feature</TT> usage is described in the
+ documentation for specific language modules.</P>
<HR NOSHADE>
-<H1><A name="Warnings"></A>14 Warning Messages</H1>
+<H1><A name="Contract">13 Contracts</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<UL>
-<LI><A href="#Warnings_nn2">Introduction</A></LI>
-<LI><A href="#Warnings_suppression">Warning message suppression</A></LI>
-<LI><A href="#Warnings_nn4">Enabling extra warnings</A></LI>
-<LI><A href="#Warnings_nn5">Issuing a warning message</A></LI>
-<LI><A href="#Warnings_symbolic_symbols">Symbolic symbols</A></LI>
-<LI><A href="#Warnings_nn6">Commentary</A></LI>
-<LI><A href="#Warnings_nn7">Warnings as errors</A></LI>
-<LI><A href="#Warnings_nn8">Message output format</A></LI>
-<LI><A href="#Warnings_nn9">Warning number reference</A>
-<UL>
-<LI><A href="#Warnings_nn10">Deprecated features (100-199)</A></LI>
-<LI><A href="#Warnings_nn11">Preprocessor (200-299)</A></LI>
-<LI><A href="#Warnings_nn12">C/C++ Parser (300-399)</A></LI>
-<LI><A href="#Warnings_nn13">Types and typemaps (400-499)</A></LI>
-<LI><A href="#Warnings_nn14">Code generation (500-599)</A></LI>
-<LI><A href="#Warnings_nn15">Language module specific (700-899)</A></LI>
-<LI><A href="#Warnings_nn16">User defined (900-999)</A></LI>
-</UL>
+<LI><A href="#Contract_nn2">The %contract directive</A></LI>
+<LI><A href="#Contract_nn3">%contract and classes</A></LI>
+<LI><A href="#Contract_nn4">Constant aggregation and %aggregate_check</A>
</LI>
-<LI><A href="#Warnings_nn17">History</A></LI>
+<LI><A href="#Contract_nn5">Notes</A></LI>
</UL>
</DIV>
<!-- INDEX -->
-<H2><A name="Warnings_nn2"></A>14.1 Introduction</H2>
-<P> During compilation, SWIG may generate a variety of warning messages.
- For example:</P>
-<DIV class="shell">
+<P> A common problem that arises when wrapping C libraries is that of
+ maintaining reliability and checking for errors. The fact of the matter
+ is that many C programs are notorious for not providing error checks.
+ Not only that, when you expose the internals of an application as a
+ library, it often becomes possible to crash it simply by providing bad
+ inputs or using it in a way that wasn't intended.</P>
+<P> This chapter describes SWIG's support for software contracts. In the
+ context of SWIG, a contract can be viewed as a runtime constraint that
+ is attached to a declaration. For example, you can easily attach
+ argument checking rules, check the output values of a function and
+ more. When one of the rules is violated by a script, a runtime
+ exception is generated rather than having the program continue to
+ execute.</P>
+<H2><A name="Contract_nn2">13.1 The %contract directive</A></H2>
+<P> Contracts are added to a declaration using the %contract directive.
+ Here is a simple example:</P>
+<DIV class="code">
<PRE>
-example.i:16: Warning 501: Overloaded declaration ignored. bar(double)
-example.i:15: Warning 501: Previous declaration is bar(int)
+%contract sqrt(double x) {
+require:
+ x >= 0;
+ensure:
+ sqrt >= 0;
+}
+
+...
+double sqrt(double);
</PRE>
</DIV>
-<P> Typically, warning messages indicate non-fatal problems with the
- input where the generated wrapper code will probably compile, but it
- may not work like you expect.</P>
-<H2><A name="Warnings_suppression"></A>14.2 Warning message suppression</H2>
-<P> All warning messages have a numeric code that is shown in the
- warning message itself. To suppress the printing of a warning message,
- a number of techniques can be used. First, you can run SWIG with the <TT>
--w</TT> command line option. For example:</P>
+<P> In this case, a contract is being added to the <TT>sqrt()</TT>
+ function. The <TT>%contract</TT> directive must always appear before
+ the declaration in question. Within the contract there are two
+ sections, both of which are optional. The <TT>require:</TT> section
+ specifies conditions that must hold before the function is called.
+ Typically, this is used to check argument values. The <TT>ensure:</TT>
+ section specifies conditions that must hold after the function is
+ called. This is often used to check return values or the state of the
+ program. In both cases, the conditions that must hold must be specified
+ as boolean expressions.</P>
+<P> In the above example, we're simply making sure that sqrt() returns a
+ non-negative number (if it didn't, then it would be broken in some
+ way).</P>
+<P> Once a contract has been specified, it modifies the behavior of the
+ resulting module. For example:</P>
<DIV class="shell">
<PRE>
-% swig -python -w501 example.i
-% swig -python -w501,505,401 example.i
+>>> example.sqrt(2)
+1.4142135623730951
+>>> example.sqrt(-2)
+Traceback (most recent call last):
+ File "<stdin>", line 1, in ?
+RuntimeError: Contract violation: require: (arg1>=0)
+>>>
</PRE>
</DIV>
-<P> Alternatively, warnings can be suppressed by inserting a special
- preprocessor pragma into the input file:</P>
+<H2><A name="Contract_nn3">13.2 %contract and classes</A></H2>
+<P> The <TT>%contract</TT> directive can also be applied to class
+ methods and constructors. For example:</P>
<DIV class="code">
<PRE>
-%module example
-#pragma SWIG nowarn=501
-#pragma SWIG nowarn=501,505,401
+%contract Foo::bar(int x, int y) {
+require:
+ x > 0;
+ensure:
+ bar > 0;
+}
+
+%contract Foo::Foo(int a) {
+require:
+ a > 0;
+}
+
+class Foo {
+public:
+ Foo(int);
+ int bar(int, int);
+};
</PRE>
</DIV>
-<P> Finally, code-generation warnings can be disabled on a declaration
- by declaration basis using the <TT>%warnfilter</TT> directive. For
- example:</P>
+<P> The way in which <TT>%contract</TT> is applied is exactly the same
+ as the <TT>%feature</TT> directive. Thus, any contract that you
+ specified for a base class will also be attached to inherited methods.
+ For example:</P>
<DIV class="code">
<PRE>
-%module example
-%warnfilter(501) foo;
-...
-int foo(int);
-int foo(double); // Silently ignored.
+class Spam : public Foo {
+public:
+ int bar(int,int); // Gets contract defined for Foo::bar(int,int)
+};
</PRE>
</DIV>
-<P> The <TT>%warnfilter</TT> directive has the same semantics as other
- declaration modifiers like <TT>%rename</TT>, <TT>%ignore</TT> and <TT>
-%feature</TT>, see the <A href="#Customization_features">%feature
- directive</A> section. For example, if you wanted to suppress a warning
- for a method in a class hierarchy, you could do this:</P>
+<P> In addition to this, separate contracts can be applied to both the
+ base class and a derived class. For example:</P>
<DIV class="code">
<PRE>
-%warnfilter(501) Object::foo;
-class Object {
+%contract Foo::bar(int x, int) {
+require:
+ x > 0;
+}
+
+%contract Spam::bar(int, int y) {
+require:
+ y > 0;
+}
+
+class Foo {
public:
- int foo(int);
- int foo(double); // Silently ignored
- ...
+ int bar(int,int); // Gets Foo::bar contract.
};
-class Derived : public Object {
+class Spam : public Foo {
public:
- int foo(int);
- int foo(double); // Silently ignored
- ...
+ int bar(int,int); // Gets Foo::bar and Spam::bar contract
};
</PRE>
</DIV>
-<P> Warnings can be suppressed for an entire class by supplying a class
- name. For example:</P>
+<P> When more than one contract is applied, the conditions specified in
+ a "require:" section are combined together using a logical-AND
+ operation. In other words conditions specified for the base class and
+ conditions specified for the derived class all must hold. In the above
+ example, this means that both the arguments to <TT>Spam::bar</TT> must
+ be positive.</P>
+<H2><A name="Contract_nn4">13.3 Constant aggregation and
+ %aggregate_check</A></H2>
+<P> Consider an interface file that contains the following code:</P>
<DIV class="code">
<PRE>
-%warnfilter(501) Object;
+#define UP 1
+#define DOWN 2
+#define RIGHT 3
+#define LEFT 4
-class Object {
-public:
- ... // All 501 warnings ignored in class
-};
+void move(SomeObject *, int direction, int distance);
</PRE>
</DIV>
-<P> There is no option to suppress all SWIG warning messages. The
- warning messages are there for a reason---to tell you that something
- may be<EM> broken</EM> in your interface. Ignore the warning messages
- at your own peril.</P>
-<H2><A name="Warnings_nn4"></A>14.3 Enabling extra warnings</H2>
-<P> Some warning messages are disabled by default and are generated only
- to provide additional diagnostics. These warnings can be turned on
- using the <TT>-Wextra</TT> option. For example:</P>
-<DIV class="shell">
+<P> One thing you might want to do is impose a constraint on the
+ direction parameter to make sure it's one of a few accepted values. To
+ do that, SWIG provides an easy to use macro %aggregate_check() that
+ works like this:</P>
+<DIV class="code">
<PRE>
-% swig -Wextra -python example.i
+%aggregate_check(int, check_direction, UP, DOWN, LEFT, RIGHT);
</PRE>
</DIV>
-<P> To selectively turn on extra warning messages, you can use the
- directives and options in the previous section--simply add a "+" to all
- warning numbers. For example:</P>
-<DIV class="shell">
+<P> This merely defines a utility function of the form</P>
+<DIV class="code">
<PRE>
-% swig -w+309,+452 example.i
+int check_direction(int x);
</PRE>
</DIV>
-<P> or in your interface file use either</P>
+<P> That checks the argument x to see if it is one of the values listed.
+ This utility function can be used in contracts. For example:</P>
<DIV class="code">
<PRE>
-#pragma SWIG nowarn=+309,+452
+%aggregate_check(int, check_direction, UP, DOWN, RIGHT, LEFT);
+
+%contract move(SomeObject *, int direction, in) {
+require:
+ check_direction(direction);
+}
+
+#define UP 1
+#define DOWN 2
+#define RIGHT 3
+#define LEFT 4
+
+void move(SomeObject *, int direction, int distance);
</PRE>
</DIV>
-<P> or</P>
+<P> Alternatively, it can be used in typemaps and other directives. For
+ example:</P>
<DIV class="code">
<PRE>
-%warnfilter(+309,+452) foo;
+%aggregate_check(int, check_direction, UP, DOWN, RIGHT, LEFT);
+
+%typemap(check) int direction {
+ if (!check_direction($1)) SWIG_exception(SWIG_ValueError, "Bad direction");
+}
+
+#define UP 1
+#define DOWN 2
+#define RIGHT 3
+#define LEFT 4
+
+void move(SomeObject *, int direction, int distance);
</PRE>
</DIV>
-<P> Note: selective enabling of warnings with <TT>%warnfilter</TT>
- overrides any global settings you might have made using <TT>-w</TT> or <TT>
-#pragma</TT>.</P>
-<P> You can of course also enable all warnings and suppress a select
- few, for example:</P>
-<DIV class="shell">
-<PRE>
-% swig -Wextra -w309,452 example.i
-</PRE>
+<P> Regrettably, there is no automatic way to perform similar checks
+ with enums values. Maybe in a future release.</P>
+<H2><A name="Contract_nn5">13.4 Notes</A></H2>
+<P> Contract support was implemented by Songyan (Tiger) Feng and first
+ appeared in SWIG-1.3.20.</P>
+<HR NOSHADE>
+<H1><A name="Varargs">14 Variable Length Arguments</A></H1>
+
+<!-- INDEX -->
+<DIV class="sectiontoc">
+<UL>
+<LI><A href="#Varargs_nn2">Introduction</A></LI>
+<LI><A href="#Varargs_nn3">The Problem</A></LI>
+<LI><A href="#Varargs_nn4">Default varargs support</A></LI>
+<LI><A href="#Varargs_nn5">Argument replacement using %varargs</A></LI>
+<LI><A href="#Varargs_nn6">Varargs and typemaps</A></LI>
+<LI><A href="#Varargs_nn7">Varargs wrapping with libffi</A></LI>
+<LI><A href="#Varargs_nn8">Wrapping of va_list</A></LI>
+<LI><A href="#Varargs_nn9">C++ Issues</A></LI>
+<LI><A href="#Varargs_nn10">Discussion</A></LI>
+</UL>
</DIV>
-<P> The warnings on the right take precedence over the warnings on the
- left, so in the above example <TT>-Wextra</TT> adds numerous warnings
- including 452, but then <TT>-w309,452</TT> overrides this and so 452 is
- suppressesed.</P>
-<P> If you would like all warnings to appear, regardless of the warning
- filters used, then use the <TT>-Wall</TT> option. The <TT>-Wall</TT>
- option also turns on the extra warnings that <TT>-Wextra</TT> adds,
- however, it is subtely different. When <TT>-Wall</TT> is used, it also
- disables all other warning filters, that is, any warnings suppressed or
- added in <TT>%warnfilter</TT>, <TT>#pragma SWIG nowarn</TT> or the <TT>
--w</TT> option.</P>
-<H2><A name="Warnings_nn5"></A>14.4 Issuing a warning message</H2>
-<P> Warning messages can be issued from an interface file using a number
- of directives. The <TT>%warn</TT> directive is the most simple:</P>
+<!-- INDEX -->
+<P><B> (a.k.a, "The horror. The horror.")</B></P>
+<P> This chapter describes the problem of wrapping functions that take a
+ variable number of arguments. For instance, generating wrappers for the
+ C <TT>printf()</TT> family of functions.</P>
+<P> This topic is sufficiently advanced to merit its own chapter. In
+ fact, support for varargs is an often requested feature that was first
+ added in SWIG-1.3.12. Most other wrapper generation tools have wisely
+ chosen to avoid this issue.</P>
+<H2><A name="Varargs_nn2">14.1 Introduction</A></H2>
+<P> Some C and C++ programs may include functions that accept a variable
+ number of arguments. For example, most programmers are familiar with
+ functions from the C library such as the following:</P>
<DIV class="code">
<PRE>
-%warn "900:This is your last warning!"
+int printf(const char *fmt, ...)
+int fprintf(FILE *, const char *fmt, ...);
+int sprintf(char *s, const char *fmt, ...);
</PRE>
</DIV>
-<P> All warning messages are optionally prefixed by the warning number
- to use. If you are generating your own warnings, make sure you don't
- use numbers defined in the table at the end of this section.</P>
-<P> The <TT>%ignorewarn</TT> directive is the same as <TT>%ignore</TT>
- except that it issues a warning message whenever a matching declaration
- is found. For example:</P>
+<P> Although there is probably little practical purpose in wrapping
+ these specific C library functions in a scripting language (what would
+ be the point?), a library may include its own set of special functions
+ based on a similar API. For example:</P>
<DIV class="code">
<PRE>
-%ignorewarn("362:operator= ignored") operator=;
+int traceprintf(const char *fmt, ...);
</PRE>
</DIV>
-<P> Warning messages can be associated with typemaps using the <TT>
-warning</TT> attribute of a typemap declaration. For example:</P>
+<P> In this case, you may want to have some kind of access from the
+ target language.</P>
+<P> Before describing the SWIG implementation, it is important to
+ discuss the common uses of varargs that you are likely to encounter in
+ real programs. Obviously, there are the <TT>printf()</TT> style output
+ functions as shown. Closely related to this would be <TT>scanf()</TT>
+ style input functions that accept a format string and a list of
+ pointers into which return values are placed. However, variable length
+ arguments are also sometimes used to write functions that accept a
+ NULL-terminated list of pointers. A good example of this would be a
+ function like this:</P>
<DIV class="code">
<PRE>
-%typemap(in, warning="901:You are really going to regret this usage of $1_type $1_name") blah * {
- ...
-}
+int execlp(const char *path, const char *arg1, ...);
+...
+
+/* Example */
+execlp("ls","ls","-l",NULL);
</PRE>
</DIV>
-<P> In this case, the warning message will be printed whenever the
- typemap is actually used and the <A href="#Typemaps_special_variables">
-special variables</A> will be expanded as appropriate, for example:</P>
-<DIV class="shell">
+<P> In addition, varargs is sometimes used to fake default arguments in
+ older C libraries. For instance, the low level <TT>open()</TT> system
+ call is often declared as a varargs function so that it will accept two
+ or three arguments:</P>
+<DIV class="code">
<PRE>
-example.i:23: Warning 901: You are really going to regret this usage of blah * self
-example.i:24: Warning 901: You are really going to regret this usage of blah * stuff
+int open(const char *path, int oflag, ...);
+...
+
+/* Examples */
+f = open("foo", O_RDONLY);
+g = open("bar", O_WRONLY | O_CREAT, 0644);
</PRE>
</DIV>
-<H2><A name="Warnings_symbolic_symbols"></A>14.5 Symbolic symbols</H2>
-<P> The <TT>swigwarn.swg</TT> file that is installed with SWIG contains
- symbol constants that could also be used in <TT>%warnfilter</TT> and <TT>
-#pragma SWIG nowarn</TT>. For example this file contains the following
- line:</P>
+<P> Finally, to implement a varargs function, recall that you have to
+ use the C library functions defined in <TT><stdarg.h></TT>. For
+ example:</P>
<DIV class="code">
<PRE>
-%define SWIGWARN_TYPE_UNDEFINED_CLASS 401 %enddef
+List make_list(const char *s, ...) {
+ va_list ap;
+ List x;
+ ...
+ va_start(ap, s);
+ while (s) {
+ x.append(s);
+ s = va_arg(ap, const char *);
+ }
+ va_end(ap);
+ return x;
+}
</PRE>
</DIV>
-<P> so <TT>SWIGWARN_TYPE_UNDEFINED_CLASS</TT> could be used instead of
- 401, for example:</P>
+<H2><A name="Varargs_nn3">14.2 The Problem</A></H2>
+<P> Generating wrappers for a variable length argument function presents
+ a number of special challenges. Although C provides support for
+ implementing functions that receive variable length arguments, there
+ are no functions that can go in the other direction. Specifically, you
+ can't write a function that dynamically creates a list of arguments and
+ which invokes a varargs function on your behalf.</P>
+<P> Although it is possible to write functions that accept the special
+ type <TT>va_list</TT>, this is something entirely different. You can't
+ take a <TT>va_list</TT> structure and pass it in place of the variable
+ length arguments to another varargs function. It just doesn't work.</P>
+<P> The reason this doesn't work has to do with the way that function
+ calls get compiled. For example, suppose that your program has a
+ function call like this:</P>
<DIV class="code">
<PRE>
-#pragma SWIG nowarn=SWIGWARN_TYPE_UNDEFINED_CLASS
+printf("Hello %s. Your number is %d\n", name, num);
</PRE>
</DIV>
-<P> or</P>
+<P> When the compiler looks at this, it knows that you are calling <TT>
+printf()</TT> with exactly three arguments. Furthermore, it knows that
+ the number of arguments as well are their types and sizes is<EM> never</EM>
+ going to change during program execution. Therefore, this gets turned
+ to machine code that sets up a three-argument stack frame followed by a
+ call to <TT>printf()</TT>.</P>
+<P> In contrast, suppose you attempted to make some kind of wrapper
+ around <TT>printf()</TT> using code like this:</P>
<DIV class="code">
<PRE>
-%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Foo;
+int wrap_printf(const char *fmt, ...) {
+ va_list ap;
+ va_start(ap,fmt);
+ ...
+ printf(fmt,ap);
+ ...
+ va_end(ap);
+};
</PRE>
</DIV>
-<H2><A name="Warnings_nn6"></A>14.6 Commentary</H2>
-<P> The ability to suppress warning messages is really only provided for
- advanced users and is not recommended in normal use. You are advised to
- modify your interface to fix the problems highlighted by the warnings
- wherever possible instead of suppressing warnings.</P>
-<P> Certain types of SWIG problems are errors. These usually arise due
- to parsing errors (bad syntax) or semantic problems for which there is
- no obvious recovery. There is no mechanism for suppressing error
- messages.</P>
-<H2><A name="Warnings_nn7"></A>14.7 Warnings as errors</H2>
-<P> Warnings can be handled as errors by using the <TT>-Werror</TT>
- command line option. This will cause SWIG to exit with a non successful
- exit code if a warning is encountered.</P>
-<H2><A name="Warnings_nn8"></A>14.8 Message output format</H2>
-<P> The output format for both warnings and errors can be selected for
- integration with your favourite IDE/editor. Editors and IDEs can
- usually parse error messages and if in the appropriate format will
- easily take you directly to the source of the error. The standard
- format is used by default except on Windows where the Microsoft format
- is used by default. These can be overridden using command line options,
- for example:</P>
-<DIV class="shell">
-<PRE>
-$ swig -python -Fstandard example.i
-example.i:4: Syntax error in input.
-$ swig -python -Fmicrosoft example.i
-example.i(4) : Syntax error in input.
+<P> Although this code might compile, it won't do what you expect. This
+ is because the call to <TT>printf()</TT> is compiled as a procedure
+ call involving only two arguments. However, clearly a two-argument
+ configuration of the call stack is completely wrong if your intent is
+ to pass an arbitrary number of arguments to the real <TT>printf()</TT>.
+ Needless to say, it won't work.</P>
+<P> Unfortunately, the situation just described is exactly the problem
+ faced by wrapper generation tools. In general, the number of passed
+ arguments will not be known until run-time. To make matters even worse,
+ you won't know the types and sizes of arguments until run-time as well.
+ Needless to say, there is no obvious way to make the C compiler
+ generate code for a function call involving an unknown number of
+ arguments of unknown types.</P>
+<P> In theory, it<EM> is</EM> possible to write a wrapper that does the
+ right thing. However, this involves knowing the underlying ABI for the
+ target platform and language as well as writing special purpose code
+ that manually constructed the call stack before making a procedure
+ call. Unfortunately, both of these tasks require the use of inline
+ assembly code. Clearly, that's the kind of solution you would much
+ rather avoid.</P>
+<P> With this nastiness in mind, SWIG provides a number of solutions to
+ the varargs wrapping problem. Most of these solutions are compromises
+ that provide limited varargs support without having to resort to
+ assembly language. However, SWIG can also support real varargs wrapping
+ (with stack-frame manipulation) if you are willing to get hands dirty.
+ Keep reading.</P>
+<H2><A name="Varargs_nn4">14.3 Default varargs support</A></H2>
+<P> When variable length arguments appear in an interface, the default
+ behavior is to drop the variable argument list entirely, replacing them
+ with a single NULL pointer. For example, if you had this function,</P>
+<DIV class="code">
+<PRE>
+void traceprintf(const char *fmt, ...);
</PRE>
</DIV>
-<H2><A name="Warnings_nn9"></A>14.9 Warning number reference</H2>
-<H3><A name="Warnings_nn10"></A>14.9.1 Deprecated features (100-199)</H3>
-<UL>
-<LI>101. Deprecated <TT>%extern</TT> directive.</LI>
-<LI>102. Deprecated <TT>%val</TT> directive.</LI>
-<LI>103. Deprecated <TT>%out</TT> directive.</LI>
-<LI>104. Deprecated <TT>%disabledoc</TT> directive.</LI>
-<LI>105. Deprecated <TT>%enabledoc</TT> directive.</LI>
-<LI>106. Deprecated <TT>%doconly</TT> directive.</LI>
-<LI>107. Deprecated <TT>%style</TT> directive.</LI>
-<LI>108. Deprecated <TT>%localstyle</TT> directive.</LI>
-<LI>109. Deprecated <TT>%title</TT> directive.</LI>
-<LI>110. Deprecated <TT>%section</TT> directive.</LI>
-<LI>111. Deprecated <TT>%subsection</TT> directive.</LI>
-<LI>112. Deprecated <TT>%subsubsection</TT> directive.</LI>
-<LI>113. Deprecated <TT>%addmethods</TT> directive.</LI>
-<LI>114. Deprecated <TT>%readonly</TT> directive.</LI>
-<LI>115. Deprecated <TT>%readwrite</TT> directive.</LI>
-<LI>116. Deprecated <TT>%except</TT> directive.</LI>
-<LI>117. Deprecated <TT>%new</TT> directive.</LI>
-<LI>118. Deprecated <TT>%typemap(except)</TT>.</LI>
-<LI>119. Deprecated <TT>%typemap(ignore)</TT>.</LI>
-<LI>120. Deprecated command line option (-runtime, -noruntime).</LI>
-<LI>121. Deprecated <TT>%name</TT> directive.</LI>
-</UL>
-<H3><A name="Warnings_nn11"></A>14.9.2 Preprocessor (200-299)</H3>
-<UL>
-<LI>201. Unable to find<EM> filename</EM>.</LI>
-<LI>202. Could not evaluate expression<EM> expr</EM>.</LI>
-<LI>203. Both includeall and importall are defined: using includeall.</LI>
-<LI>204. CPP #warning, "<EM>warning</EM>".</LI>
-<LI>205. CPP #error, "<EM>error</EM>".</LI>
-<LI>206. Unexpected tokens after #<EM>directive</EM> directive.</LI>
-</UL>
-<H3><A name="Warnings_nn12"></A>14.9.3 C/C++ Parser (300-399)</H3>
-<UL>
-<LI>301. <TT>class</TT> keyword used, but not in C++ mode.</LI>
-<LI>302. Identifier '<EM>name</EM>' redefined (ignored).</LI>
-<LI>303. <TT>%extend</TT> defined for an undeclared class '<EM>name</EM>
-'.</LI>
-<LI>304. Unsupported constant value (ignored).</LI>
-<LI>305. Bad constant value (ignored).</LI>
-<LI>306. '<EM>identifier</EM>' is private in this context.</LI>
-<LI>307. Can't set default argument value (ignored)</LI>
-<LI>308. Namespace alias '<EM>name</EM>' not allowed here. Assuming '<EM>
-name</EM>'</LI>
-<LI>309. [private | protected] inheritance ignored.</LI>
-<LI>310. Template '<EM>name</EM>' was already wrapped as '<EM>name</EM>'
- (ignored)</LI>
-<LI>312. Unnamed nested class not currently supported (ignored).</LI>
-<LI>313. Unrecognized extern type "<EM>name</EM>" (ignored).</LI>
-<LI>314. '<EM>identifier</EM>' is a<EM> lang</EM> keyword.</LI>
-<LI>315. Nothing known about '<EM>identifier</EM>'.</LI>
-<LI>316. Repeated %module directive.</LI>
-<LI>317. Specialization of non-template '<EM>name</EM>'.</LI>
-<LI>318. Instantiation of template '<EM>name</EM>' is ambiguous,
- instantiation<EM> templ</EM> used, instantiation<EM> templ</EM>
- ignored.</LI>
-<LI>319. No access specifier given for base class<EM> name</EM>
- (ignored).</LI>
-<LI>320. Explicit template instantiation ignored.</LI>
-<LI>321.<EM> identifier</EM> conflicts with a built-in name.</LI>
-<LI>322. Redundant redeclaration of '<EM>name</EM>'.</LI>
-<LI>323. Recursive scope inheritance of '<EM>name</EM>'.</LI>
-<LI>324. Named nested template instantiations not supported. Processing
- as if no name was given to %template().</LI>
-<LI>325. Nested<EM> kind</EM> not currently supported (<EM>name</EM>
- ignored).</LI>
-<LI>326. Deprecated %extend name used - the<EM> kind</EM> name '<EM>name</EM>
-' should be used instead of the typedef name '<EM>name</EM>'.</LI>
-<LI>350. operator new ignored.</LI>
-<LI>351. operator delete ignored.</LI>
-<LI>352. operator+ ignored.</LI>
-<LI>353. operator- ignored.</LI>
-<LI>354. operator* ignored.</LI>
-<LI>355. operator/ ignored.</LI>
-<LI>356. operator% ignored.</LI>
-<LI>357. operator^ ignored.</LI>
-<LI>358. operator& ignored.</LI>
-<LI>359. operator| ignored.</LI>
-<LI>360. operator~ ignored.</LI>
-<LI>361. operator! ignored.</LI>
-<LI>362. operator= ignored.</LI>
-<LI>363. operator< ignored.</LI>
-<LI>364. operator> ignored.</LI>
-<LI>365. operator+= ignored.</LI>
-<LI>366. operator-= ignored.</LI>
-<LI>367. operator*= ignored.</LI>
-<LI>368. operator/= ignored.</LI>
-<LI>369. operator%= ignored.</LI>
-<LI>370. operator^= ignored.</LI>
-<LI>371. operator&= ignored.</LI>
-<LI>372. operator|= ignored.</LI>
-<LI>373. operator<< ignored.</LI>
-<LI>374. operator>>ignored.</LI>
-<LI>375. operator<<= ignored.</LI>
-<LI>376. operator>>= ignored.</LI>
-<LI>377. operator== ignored.</LI>
-<LI>378. operator!= ignored.</LI>
-<LI>379. operator<= ignored.</LI>
-<LI>380. operator>= ignored.</LI>
-<LI>381. operator&& ignored.</LI>
-<LI>382. operator|| ignored.</LI>
-<LI>383. operator++ ignored.</LI>
-<LI>384. operator-- ignored.</LI>
-<LI>385. operator, ignored.</LI>
-<LI>386. operator-<* ignored.</LI>
-<LI>387. operator-< ignored.</LI>
-<LI>388. operator() ignored.</LI>
-<LI>389. operator[] ignored.</LI>
-<LI>390. operator+ ignored (unary).</LI>
-<LI>391. operator- ignored (unary).</LI>
-<LI>392. operator* ignored (unary).</LI>
-<LI>393. operator& ignored (unary).</LI>
-<LI>394. operator new[] ignored.</LI>
-<LI>395. operator delete[] ignored.</LI>
-</UL>
-<H3><A name="Warnings_nn13"></A>14.9.4 Types and typemaps (400-499)</H3>
-<UL>
-<LI>401. Nothing known about class 'name'. Ignored.</LI>
-<LI>402. Base class 'name' is incomplete.</LI>
-<LI>403. Class 'name' might be abstract.</LI>
-<LI>450. Deprecated typemap feature ($source/$target).</LI>
-<LI>451. Setting const char * variable may leak memory.</LI>
-<LI>452. Reserved</LI>
-<LI>453. Can't apply (pattern). No typemaps are defined.</LI>
-<LI>460. Unable to use type<EM> type</EM> as a function argument.</LI>
-<LI>461. Unable to use return type<EM> type</EM> in function<EM> name</EM>
-.</LI>
-<LI>462. Unable to set variable of type<EM> type</EM>.</LI>
-<LI>463. Unable to read variable of type<EM> type</EM>.</LI>
-<LI>464. Unsupported constant value.</LI>
-<LI>465. Unable to handle type<EM> type</EM>.</LI>
-<LI>466. Unsupported variable type<EM> type</EM>.</LI>
-<LI>467. Overloaded<EM> declaration</EM> not supported (no type checking
- rule for '<EM>type</EM>')</LI>
-<LI>468. No 'throw' typemap defined for exception type<EM> type</EM></LI>
-<LI>469. No or improper directorin typemap defined for<EM> type</EM></LI>
-<LI>470. Thread/reentrant unsafe wrapping, consider returning by value
- instead.</LI>
-<LI>471. Unable to use return type<EM> type</EM> in director method</LI>
-<LI>474. Method<EM> method</EM> usage of the optimal attribute ignored
- in the out typemap as the following cannot be used to generate optimal
- code:<EM> code</EM></LI>
-<LI>475. Multiple calls to<EM> method</EM> might be generated due to
- optimal attribute usage in the out typemap.</LI>
-</UL>
-<H3><A name="Warnings_nn14"></A>14.9.5 Code generation (500-599)</H3>
-<UL>
-<LI>501. Overloaded declaration ignored.<EM> decl</EM>. Previous
- declaration is<EM> decl</EM>.</LI>
-<LI>502. Overloaded constructor ignored.<EM> decl</EM>. Previous
- declaration is<EM> decl</EM>.</LI>
-<LI>503. Can't wrap '<EM>identifier</EM>' unless renamed to a valid
- identifier.</LI>
-<LI>504. Function<EM> name</EM> must have a return type. Ignored.</LI>
-<LI>505. Variable length arguments discarded.</LI>
-<LI>506. Can't wrap varargs with keyword arguments enabled.</LI>
-<LI>507. Adding native function<EM> name</EM> not supported (ignored).</LI>
-<LI>508. Declaration of '<EM>name</EM>' shadows declaration accessible
- via operator->(), previous declaration of'<EM>declaration</EM>'.</LI>
-<LI>509. Overloaded method<EM> declaration</EM> effectively ignored, as
- it is shadowed by<EM> declaration</EM>.</LI>
-<LI>510. Friend function '<EM>name</EM>' ignored.</LI>
-<LI>511. Can't use keyword arguments with overloaded functions.</LI>
-<LI>512. Overloaded method<EM> declaration</EM> ignored, using non-const
- method<EM> declaration</EM> instead.</LI>
-<LI>513. Can't generate wrappers for unnamed struct/class.</LI>
-<LI>514.</LI>
-<LI>515.</LI>
-<LI>516. Overloaded method<EM> declaration</EM> ignored, using<EM>
- declaration</EM> instead.</LI>
-<LI>517.</LI>
-<LI>518. Portability warning: File<EM> file1</EM> will be overwritten by<EM>
- file2</EM> on case insensitive filesystems such as Windows' FAT32 and
- NTFS unless the class/module name is renamed.</LI>
-<LI>519. %template() contains no name. Template method ignored:<EM>
- declaration</EM></LI>
-<LI>520.<EM> Base/Derived</EM> class '<EM>classname1</EM>' of '<EM>
-classname2</EM>' is not similarly marked as a smart pointer.</LI>
-<LI>521. Illegal destructor name<EM> name</EM>. Ignored.</LI>
-<LI>522. Use of an illegal constructor name '<EM>name</EM>' in %extend
- is deprecated, the constructor name should be '<EM>name</EM>'.</LI>
-<LI>523. Use of an illegal destructor name '<EM>name</EM>' in %extend is
- deprecated, the destructor name should be '<EM>name</EM>'.</LI>
-</UL>
-<H3><A name="Warnings_nn15"></A>14.9.6 Language module specific
- (700-899)</H3>
-<UL>
-<LI>801. Wrong name (corrected to '<EM>name</EM>'). (Ruby).</LI>
-</UL>
-<UL>
-<LI>810. No jni typemap defined for<EM> type</EM> (Java).</LI>
-<LI>811. No jtype typemap defined for<EM> type</EM> (Java).</LI>
-<LI>812. No jstype typemap defined for<EM> type</EM> (Java).</LI>
-<LI>813. Warning for<EM> classname</EM>: Base<EM> baseclass</EM>
- ignored. Multiple inheritance is not supported in Java. (Java).</LI>
-<LI>814.</LI>
-<LI>815. No javafinalize typemap defined for<EM> type</EM> (Java).</LI>
-<LI>816. No javabody typemap defined for<EM> type</EM> (Java).</LI>
-<LI>817. No javaout typemap defined for<EM> type</EM> (Java).</LI>
-<LI>818. No javain typemap defined for<EM> type</EM> (Java).</LI>
-<LI>819. No javadirectorin typemap defined for<EM> type</EM> (Java).</LI>
-<LI>820. No javadirectorout typemap defined for<EM> type</EM> (Java).</LI>
-<LI>821.</LI>
-<LI>822. Covariant return types not supported in Java. Proxy method will
- return<EM> basetype</EM> (Java).</LI>
-<LI>823. No javaconstruct typemap defined for<EM> type</EM> (Java).</LI>
-<LI>824. Missing JNI descriptor in directorin typemap defined for<EM>
- type</EM> (Java).</LI>
-<LI>825. "directorconnect" attribute missing in<EM> type</EM>
- "javaconstruct" typemap. (Java).</LI>
-<LI>826. The nspace feature is used on '<EM>type</EM>' without -package.
- The generated code may not compile as Java does not support types
- declared in a named package accessing types declared in an unnamed
- package. (Java).</LI>
-</UL>
-<UL>
-<LI>830. No ctype typemap defined for<EM> type</EM> (C#).</LI>
-<LI>831. No cstype typemap defined for<EM> type</EM> (C#).</LI>
-<LI>832. No cswtype typemap defined for<EM> type</EM> (C#).</LI>
-<LI>833. Warning for<EM> classname</EM>: Base<EM> baseclass</EM>
- ignored. Multiple inheritance is not supported in C#. (C#).</LI>
-<LI>834.</LI>
-<LI>835. No csfinalize typemap defined for<EM> type</EM> (C#).</LI>
-<LI>836. No csbody typemap defined for<EM> type</EM> (C#).</LI>
-<LI>837. No csout typemap defined for<EM> type</EM> (C#).</LI>
-<LI>838. No csin typemap defined for<EM> type</EM> (C#).</LI>
-<LI>839.</LI>
-<LI>840.</LI>
-<LI>841.</LI>
-<LI>842. Covariant return types not supported in C#. Proxy method will
- return<EM> basetype</EM> (C#).</LI>
-<LI>843. No csconstruct typemap defined for<EM> type</EM> (C#).</LI>
-<LI>844. C# exception may not be thrown - no $excode or excode attribute
- in<EM> typemap</EM> typemap. (C#).</LI>
-<LI>845. Unmanaged code contains a call to a
- SWIG_CSharpSetPendingException method and C# code does not handle
- pending exceptions via the canthrow attribute. (C#).</LI>
-</UL>
-<UL>
-<LI>870. Warning for<EM> classname</EM>: Base<EM> baseclass</EM>
- ignored. Multiple inheritance is not supported in PHP.</LI>
-<LI>871. Unrecognized pragma<EM> pragma</EM>. (Php).</LI>
-</UL>
-<H3><A name="Warnings_nn16"></A>14.9.7 User defined (900-999)</H3>
-<P> These numbers can be used by your own application.</P>
-<H2><A name="Warnings_nn17"></A>14.10 History</H2>
-<P> The ability to control warning messages was first added to
- SWIG-1.3.12.</P>
-<HR NOSHADE>
-<H1><A name="Modules"></A>15 Working with Modules</H1>
-
-<!-- INDEX -->
-<DIV class="sectiontoc">
-<UL>
-<LI><A href="#Modules_introduction">Modules Introduction</A></LI>
-<LI><A href="#Modules_nn1">Basics</A></LI>
-<LI><A href="#Modules_nn2">The SWIG runtime code</A></LI>
-<LI><A href="#Modules_external_run_time">External access to the runtime</A>
-</LI>
-<LI><A href="#Modules_nn4">A word of caution about static libraries</A></LI>
-<LI><A href="#Modules_nn5">References</A></LI>
-<LI><A href="#Modules_nn6">Reducing the wrapper file size</A></LI>
-</UL>
+<P> it would be wrapped as if it had been declared as follows:</P>
+<DIV class="code">
+<PRE>
+void traceprintf(const char *fmt);
+</PRE>
</DIV>
-<!-- INDEX -->
-<H2><A name="Modules_introduction"></A>15.1 Modules Introduction</H2>
-<P> Each invocation of SWIG requires a module name to be specified. The
- module name is used to name the resulting target language extension
- module. Exactly what this means and what the name is used for depends
- on the target language, for example the name can define a target
- language namespace or merely be a useful name for naming files or
- helper classes. Essentially, a module comprises target language
- wrappers for a chosen collection of global variables/functions,
- structs/classes and other C/C++ types.</P>
-<P> The module name can be supplied in one of two ways. The first is to
- specify it with the special <TT>%module</TT> directive. This directive
- must appear at the beginning of the interface file. The general form of
- this directive is:</P>
+<P> When the function is called inside the wrappers, it is called as
+ follows:</P>
<DIV class="code">
<PRE>
-<TT>%module(option1="value1",option2="value2",...) modulename</TT>
+traceprintf(arg1, NULL);
</PRE>
</DIV>
-<P> where the modulename is mandatory and the options add one or more
- optional additional features. Typically no options are specified, for
- example:</P>
+<P> Arguably, this approach seems to defeat the whole point of variable
+ length arguments. However, this actually provides enough support for
+ many simple kinds of varargs functions to still be useful, however it
+ does come with a caveat. For instance, you could make function calls
+ like this (in Python):</P>
+<DIV class="targetlang">
+<PRE>
+>>> traceprintf("Hello World")
+>>> traceprintf("Hello %s. Your number is %d\n" % (name, num))
+>>> traceprintf("Your result is 90%%.")
+</PRE>
+</DIV>
+<P> Notice how string formatting is being done in Python instead of C.
+ The caveat is the strings passed must be safe to use in C though. For
+ example if name was to contain a "%" it should be double escaped in
+ order to avoid unpredictable behaviour:</P>
+<DIV class="targetlang">
+<PRE>
+>>> traceprintf("Your result is 90%.\n") # unpredictable behaviour
+>>> traceprintf("Your result is 90%%.\n") # good
+</PRE>
+</DIV>
+<P> Read on for further solutions.</P>
+<H2><A name="Varargs_nn5">14.4 Argument replacement using %varargs</A></H2>
+<P> Instead of dropping the variable length arguments, an alternative
+ approach is to replace <TT>(...)</TT> with a set of suitable arguments.
+ SWIG provides a special <TT>%varargs</TT> directive that can be used to
+ do this. For example,</P>
<DIV class="code">
<PRE>
-<TT>%module mymodule</TT>
+%varargs(int mode = 0) open;
+...
+int open(const char *path, int oflags, ...);
</PRE>
</DIV>
-<P> The second way to specify the module name is with the <TT>-module</TT>
- command line option, for example <TT>-module mymodule</TT>. If the
- module name is supplied on the command line, it overrides the name
- specified by the <TT>%module</TT> directive.</P>
-<P> When first working with SWIG, users commonly start by creating a
- single module. That is, you might define a single SWIG interface that
- wraps some set of C/C++ code. You then compile all of the generated
- wrapper code together and use it. For large applications, however, this
- approach is problematic---the size of the generated wrapper code can be
- rather large. Moreover, it is probably easier to manage the target
- language interface when it is broken up into smaller pieces.</P>
-<P> This chapter describes the problem of using SWIG in programs where
- you want to create a collection of modules. Each module in the
- collection is created via separate invocations of SWIG.</P>
-<H2><A name="Modules_nn1"></A>15.2 Basics</H2>
-<P> The basic usage case with multiple modules is when modules do not
- have cross-references (ie. when wrapping multiple independent C APIs).
- In that case, swig input files should just work out of the box - you
- simply create multiple wrapper .cxx files, link them into your
- application, and insert/load each in the scripting language runtime as
- you would do for the single module case.</P>
-<P> A bit more complex is the case in which modules need to share
- information. For example, when one module extends the class of another
- by deriving from it:</P>
+<P> is equivalent to this:</P>
<DIV class="code">
<PRE>
-// File: base.h
-class base {
-public:
- int foo();
-};
+int open(const char *path, int oflags, int mode = 0);
</PRE>
-</DIV> <DIV class="code">
+</DIV>
+<P> In this case, <TT>%varargs</TT> is simply providing more specific
+ information about the extra arguments that might be passed to a
+ function. If the arguments to a varargs function are of uniform type, <TT>
+%varargs</TT> can also accept a numerical argument count as follows:</P>
+<DIV class="code">
<PRE>
-// File: base_module.i
-%module base_module
-
-%{
-#include "base.h"
-%}
-%include "base.h"
+%varargs(3, char *str = NULL) execlp;
+...
+int execlp(const char *path, const char *arg, ...);
</PRE>
-</DIV> <DIV class="code">
+</DIV>
+<P> and is effectively seen as:</P>
+<DIV class="code">
<PRE>
-// File: derived_module.i
-%module derived_module
-
-%import "base_module.i"
-
-%inline %{
-class derived : public base {
-public:
- int bar();
-};
-%}
+int execlp(const char *path, const char *arg,
+ char *str1 = NULL,
+ char *str2 = NULL,
+ char *str3 = NULL);
</PRE>
</DIV>
-<P>To create the wrapper properly, module <TT>derived_module</TT> needs
- to know about the <TT>base</TT> class and that its interface is covered
- in another module. The line <TT>%import "base_module.i"</TT> lets SWIG
- know exactly that. Oftentimes the <TT>.h</TT> file is passed to <TT>
-%import</TT> instead of the <TT>.i</TT>, which unfortunately doesn't
- work for all language modules. For example, Python requires the name of
- module that the base class exists in so that the proxy classes can
- fully inherit the base class's methods. Typically you will get a
- warning when the module name is missing, eg:</P>
-<DIV class="shell">
+<P> This would wrap <TT>execlp()</TT> as a function that accepted up to
+ 3 optional arguments. Depending on the application, this may be more
+ than enough for practical purposes.</P>
+<P> The handling of <A href="#SWIGPlus_default_args">default arguments</A>
+ can be changed via the <TT>compactdefaultargs</TT> feature. If this
+ feature is used, for example</P>
+<DIV class="code">
<PRE>
-derived_module.i:8: Warning 401: Base class 'base' ignored - unknown module name for base. Either
-import
-the appropriate module interface file or specify the name of the module in the %import directive.
+%feature("compactdefaultargs") execlp;
+%varargs(3, char *str = NULL) execlp;
+...
+int execlp(const char *path, const char *arg, ...);
</PRE>
</DIV>
-<P> It is sometimes desirable to import the header file rather than the
- interface file and overcome the above warning. For example in the case
- of the imported interface being quite large, it may be desirable to
- simplify matters and just import a small header file of dependent
- types. This can be done by specifying the optional <TT>module</TT>
- attribute in the <TT>%import</TT> directive. The <TT>derived_module.i</TT>
- file shown above could be replaced with the following:<DIV class="code">
+<P> a call from the target language which does not provide the maximum
+ number of arguments, such as, <TT>execlp("a", "b", "c")</TT> will
+ generate C code which includes the missing default values, that is, <TT>
+execlp("a", "b", "c", NULL, NULL)</TT>. If <TT>compactdefaultargs</TT>
+ is not used, then the generated code will be <TT>execlp("a", "b", "c")</TT>
+. The former is useful for helping providing a sentinel to terminate the
+ argument list. However, this is not guaranteed, for example when a user
+ passes a non-NULL value for all the parameters. When using <TT>
+compactdefaultargs</TT> it is possible to guarantee the NULL sentinel is
+ passed through the, <TT>numinputs=0</TT> <A href="#Typemaps_nn26">'in'
+ typemap attribute</A>, naming the<B> last parameter</B>. For example,</P>
+<DIV class="code">
<PRE>
-// File: derived_module.i
-%module derived_module
-
-%import(module="base_module") "base.h"
+%feature("compactdefaultargs") execlp;
+%varargs(3, char *str = NULL) execlp;
+%typemap(in, numinputs=0) char *str3 ""
+...
+int execlp(const char *path, const char *arg, ...);
+</PRE>
+</DIV>
+<P> Note that <TT>str3</TT> is the name of the last argument, as we have
+ used <TT>%varargs</TT> with 3. Now <TT>execlp("a", "b", "c", "d", "e")</TT>
+ will result in an error as one too many arguments has been passed, as
+ now only 2 additional 'str' arguments can be passed with the 3rd one
+ always using the specified default <TT>NULL</TT>.</P>
+<P> Argument replacement is most appropriate in cases where the types of
+ the extra arguments are uniform and the maximum number of arguments are
+ known. Argument replacement is not as useful when working with
+ functions that accept mixed argument types such as <TT>printf()</TT>.
+ Providing general purpose wrappers to such functions presents special
+ problems (covered shortly).</P>
+<H2><A name="Varargs_nn6">14.5 Varargs and typemaps</A></H2>
+<P> Variable length arguments may be used in typemap specifications. For
+ example:</P>
+<DIV class="code">
+<PRE>
+%typemap(in) (...) {
+ // Get variable length arguments (somehow)
+ ...
+}
-%inline %{
-class derived : public base {
-public:
- int bar();
+%typemap(in) (const char *fmt, ...) {
+ // Multi-argument typemap
+}
+</PRE>
+</DIV>
+<P> However, this immediately raises the question of what "type" is
+ actually used to represent <TT>(...)</TT>. For lack of a better
+ alternative, the type of <TT>(...)</TT> is set to <TT>void *</TT>.
+ Since there is no way to dynamically pass arguments to a varargs
+ function (as previously described), the <TT>void *</TT> argument value
+ is intended to serve as a place holder for storing some kind of
+ information about the extra arguments (if any). In addition, the
+ default behavior of SWIG is to pass the <TT>void *</TT> value as an
+ argument to the function. Therefore, you could use the pointer to hold
+ a valid argument value if you wanted.</P>
+<P> To illustrate, here is a safer version of wrapping <TT>printf()</TT>
+ in Python:</P>
+<DIV class="code">
+<PRE>
+%typemap(in) (const char *fmt, ...) {
+ $1 = "%s"; /* Fix format string to %s */
+ $2 = (void *) PyString_AsString($input); /* Get string argument */
};
+...
+int printf(const char *fmt, ...);
</PRE>
-</DIV></P>
-<P> Note that "base_module" is the module name and is the same as that
- specified in <TT>%module</TT> in <TT>base_module.i</TT> as well as the <TT>
-%import</TT> in <TT>derived_module.i</TT>.</P>
-<P> Another issue to beware of is that multiple dependent wrappers
- should not be linked/loaded in parallel from multiple threads as SWIG
- provides no locking - for more on that issue, read on.</P>
-<H2><A name="Modules_nn2"></A>15.3 The SWIG runtime code</H2>
-<P> Many of SWIG's target languages generate a set of functions commonly
- known as the "SWIG runtime." These functions are primarily related to
- the runtime type system which checks pointer types and performs other
- tasks such as proper casting of pointer values in C++. As a general
- rule, the statically typed target languages, such as Java, use the
- language's built in static type checking and have no need for a SWIG
- runtime. All the dynamically typed / interpreted languages rely on the
- SWIG runtime.</P>
-<P> The runtime functions are private to each SWIG-generated module.
- That is, the runtime functions are declared with "static" linkage and
- are visible only to the wrapper functions defined in that module. The
- only problem with this approach is that when more than one SWIG module
- is used in the same application, those modules often need to share type
- information. This is especially true for C++ programs where SWIG must
- collect and share information about inheritance relationships that
- cross module boundaries.</P>
-<P> To solve the problem of sharing information across modules, a
- pointer to the type information is stored in a global variable in the
- target language namespace. During module initialization, type
- information is loaded into the global data structure of type
- information from all modules.</P>
-<P> There are a few trade offs with this approach. This type information
- is global across all SWIG modules loaded, and can cause type conflicts
- between modules that were not designed to work together. To solve this
- approach, the SWIG runtime code uses a define SWIG_TYPE_TABLE to
- provide a unique type table. This behavior can be enabled when
- compiling the generated _wrap.cxx or _wrap.c file by adding
- -DSWIG_TYPE_TABLE=myprojectname to the command line argument.</P>
-<P> Then, only modules compiled with SWIG_TYPE_TABLE set to
- myprojectname will share type information. So if your project has three
- modules, all three should be compiled with
- -DSWIG_TYPE_TABLE=myprojectname, and then these three modules will
- share type information. But any other project's types will not
- interfere or clash with the types in your module.</P>
-<P> Another issue relating to the global type table is thread safety. If
- two modules try and load at the same time, the type information can
- become corrupt. SWIG currently does not provide any locking, and if you
- use threads, you must make sure that modules are loaded serially. Be
- careful if you use threads and the automatic module loading that some
- scripting languages provide. One solution is to load all modules before
- spawning any threads, or use SWIG_TYPE_TABLE to separate type tables so
- they do not clash with each other.</P>
-<P> Lastly, SWIG uses a #define SWIG_RUNTIME_VERSION, located in
- Lib/swigrun.swg and near the top of every generated module. This number
- gets incremented when the data structures change, so that SWIG modules
- generated with different versions can peacefully coexist. So the type
- structures are separated by the (SWIG_TYPE_TABLE, SWIG_RUNTIME_VERSION)
- pair, where by default SWIG_TYPE_TABLE is empty. Only modules compiled
- with the same pair will share type information.</P>
-<H2><A name="Modules_external_run_time"></A>15.4 External access to the
- runtime</H2>
-<P>As described in <A href="#Typemaps_runtime_type_checker">The run-time
- type checker</A>, the functions <TT>SWIG_TypeQuery</TT>, <TT>
-SWIG_NewPointerObj</TT>, and others sometimes need to be called. Calling
- these functions from a typemap is supported, since the typemap code is
- embedded into the <TT>_wrap.c</TT> file, which has those declarations
- available. If you need to call the SWIG run-time functions from another
- C file, there is one header you need to include. To generate the header
- that needs to be included, run the following command:<DIV class="shell">
+</DIV>
+<P> In this example, the format string is implicitly set to <TT>"%s"</TT>
+. This prevents a program from passing a bogus format string to the
+ extension. Then, the passed input object is decoded and placed in the <TT>
+void *</TT> argument defined for the <TT>(...)</TT> argument. When the
+ actual function call is made, the underlying wrapper code will look
+ roughly like this:</P>
+<DIV class="code">
<PRE>
-$ swig -python -external-runtime <filename>
+wrap_printf() {
+ char *arg1;
+ void *arg2;
+ int result;
+
+ arg1 = "%s";
+ arg2 = (void *) PyString_AsString(arg2obj);
+ ...
+ result = printf(arg1,arg2);
+ ...
+}
</PRE>
-</DIV></P>
-<P>The filename argument is optional and if it is not passed, then the
- default filename will be something like <TT>swigpyrun.h</TT>, depending
- on the language. This header file should be treated like any of the
- other _wrap.c output files, and should be regenerated when the _wrap
- files are. After including this header, your code will be able to call <TT>
-SWIG_TypeQuery</TT>, <TT>SWIG_NewPointerObj</TT>, <TT>SWIG_ConvertPtr</TT>
- and others. The exact argument parameters for these functions might
- differ between language modules; please check the language module
- chapters for more information.</P>
-<P>Inside this header the functions are declared static and are included
- inline into the file, and thus the file does not need to be linked
- against any SWIG libraries or code (you might still need to link
- against the language libraries like libpython-2.3). Data is shared
- between this file and the _wrap.c files through a global variable in
- the scripting language. It is also possible to copy this header file
- along with the generated wrapper files into your own package, so that
- you can distribute a package that can be compiled without SWIG
- installed (this works because the header file is self-contained, and
- does not need to link with anything).</P>
-<P> This header will also use the -DSWIG_TYPE_TABLE described above, so
- when compiling any code which includes the generated header file should
- define the SWIG_TYPE_TABLE to be the same as the module whose types you
- are trying to access.</P>
-<H2><A name="Modules_nn4"></A>15.5 A word of caution about static
- libraries</H2>
-<P> When working with multiple SWIG modules, you should take care not to
- use static libraries. For example, if you have a static library <TT>
-libfoo.a</TT> and you link a collection of SWIG modules with that
- library, each module will get its own private copy of the library code
- inserted into it. This is very often<B> NOT</B> what you want and it
- can lead to unexpected or bizarre program behavior. When working with
- dynamically loadable modules, you should try to work exclusively with
- shared libraries.</P>
-<H2><A name="Modules_nn5"></A>15.6 References</H2>
-<P> Due to the complexity of working with shared libraries and multiple
- modules, it might be a good idea to consult an outside reference. John
- Levine's "Linkers and Loaders" is highly recommended.</P>
-<H2><A name="Modules_nn6"></A>15.7 Reducing the wrapper file size</H2>
-<P> Using multiple modules with the <TT>%import</TT> directive is the
- most common approach to modularising large projects. In this way a
- number of different wrapper files can be generated, thereby avoiding
- the generation of a single large wrapper file. There are a couple of
- alternative solutions for reducing the size of a wrapper file through
- the use of command line options and features.</P>
-<P><B> -fcompact</B>
-<BR> This command line option will compact the size of the wrapper file
- without changing the code generated into the wrapper file. It simply
- removes blank lines and joins lines of code together. This is useful
- for compilers that have a maximum file size that can be handled.</P>
-<P><B> -fvirtual</B>
-<BR> This command line option will remove the generation of superfluous
- virtual method wrappers. Consider the following inheritance hierarchy:</P>
+</DIV>
+<P> Notice how both arguments are passed to the function and it does
+ what you would expect.</P>
+<P> The next example illustrates a more advanced kind of varargs
+ typemap. Disclaimer: this requires special support in the target
+ language module and is not guaranteed to work with all SWIG modules at
+ this time. It also starts to illustrate some of the more fundamental
+ problems with supporting varargs in more generality.</P>
+<P> If a typemap is defined for any form of <TT>(...)</TT>, many SWIG
+ modules will generate wrappers that accept a variable number of
+ arguments as input and will make these arguments available in some
+ form. The precise details of this depends on the language module being
+ used (consult the appropriate chapter for more details). However,
+ suppose that you wanted to create a Python wrapper for the <TT>execlp()</TT>
+ function shown earlier. To do this using a typemap instead of using <TT>
+%varargs</TT>, you might first write a typemap like this:</P>
<DIV class="code">
<PRE>
-struct Base {
- virtual void method();
- ...
-};
+%typemap(in) (...)(char *vargs[10]) {
+ int i;
+ int argc;
+ for (i = 0; i < 10; i++) vargs[i] = 0;
+ argc = PyTuple_Size(varargs);
+ if (argc > 10) {
+ PyErr_SetString(PyExc_ValueError, "Too many arguments");
+ return NULL;
+ }
+ for (i = 0; i < argc; i++) {
+ PyObject *pyobj = PyTuple_GetItem(varargs, i);
+ char *str = 0;
+%#if PY_VERSION_HEX>=0x03000000
+ PyObject *pystr;
+ if (!PyUnicode_Check(pyobj)) {
+ PyErr_SetString(PyExc_ValueError, "Expected a string");
+ return NULL;
+ }
+ pystr = PyUnicode_AsUTF8String(pyobj);
+ str = strdup(PyBytes_AsString(pystr));
+ Py_XDECREF(pystr);
+%#else
+ if (!PyString_Check(pyobj)) {
+ PyErr_SetString(PyExc_ValueError, "Expected a string");
+ return NULL;
+ }
+ str = PyString_AsString(pyobj);
+%#endif
+ vargs[i] = str;
+ }
+ $1 = (void *)vargs;
+}
-struct Derived : Base {
- virtual void method();
- ...
-};
+%typemap(freearg) (...) {
+%#if PY_VERSION_HEX>=0x03000000
+ int i;
+ for (i = 0; i < 10; i++) {
+ free(vargs$argnum[i]);
+ }
+%#endif
+}
</PRE>
</DIV>
-<P> Normally wrappers are generated for both methods, whereas this
- command line option will suppress the generation of a wrapper for <TT>
-Derived::method</TT>. Normal polymorphic behaviour remains as <TT>
-Derived::method</TT> will still be called should you have a <TT>Derived</TT>
- instance and call the wrapper for <TT>Base::method</TT>.</P>
-<P><B> %feature("compactdefaultargs")</B>
-<BR> This feature can reduce the number of wrapper methods when wrapping
- methods with default arguments. The section on <A href="#SWIGPlus_default_args">
-default arguments</A> discusses the feature and its limitations.</P>
-<HR NOSHADE>
-<H1><A name="CCache"></A>16 Using SWIG with ccache - ccache-swig(1)
- manpage</H1>
+<P> In the 'in' typemap, the special variable <TT>varargs</TT> is a
+ tuple holding all of the extra arguments passed (this is specific to
+ the Python module). The typemap then pulls this apart and sticks the
+ values into the array of strings <TT>args</TT>. Then, the array is
+ assigned to <TT>$1</TT> (recall that this is the <TT>void *</TT>
+ variable corresponding to <TT>(...)</TT>). However, this assignment is
+ only half of the picture----clearly this alone is not enough to make
+ the function work. The 'freearg' typemap cleans up memory allocated in
+ the 'in' typemap; this code is generated to be called after the <TT>
+execlp</TT> function is called. To patch everything up, you have to
+ rewrite the underlying action code using the <TT>%feature</TT>
+ directive like this:</P>
+<DIV class="code">
+<PRE>
+%feature("action") execlp {
+ char **vargs = (char **) arg3;
+ result = execlp(arg1, arg2, vargs[0], vargs[1], vargs[2], vargs[3], vargs[4],
+ vargs[5], vargs[6], vargs[7], vargs[8], vargs[9], NULL);
+}
-<!-- INDEX -->
-<DIV class="sectiontoc">
-<UL>
-<LI><A href="#CCache_nn2">NAME</A></LI>
-<LI><A href="#CCache_nn3">SYNOPSIS</A></LI>
-<LI><A href="#CCache_nn4">DESCRIPTION</A></LI>
-<LI><A href="#CCache_nn5">OPTIONS SUMMARY</A></LI>
-<LI><A href="#CCache_nn6">OPTIONS</A></LI>
-<LI><A href="#CCache_nn7">INSTALLATION</A></LI>
-<LI><A href="#CCache_nn8">EXTRA OPTIONS</A></LI>
-<LI><A href="#CCache_nn9">ENVIRONMENT VARIABLES</A></LI>
-<LI><A href="#CCache_nn10">CACHE SIZE MANAGEMENT</A></LI>
-<LI><A href="#CCache_nn11">CACHE COMPRESSION</A></LI>
-<LI><A href="#CCache_nn12">HOW IT WORKS</A></LI>
-<LI><A href="#CCache_nn13">USING CCACHE WITH DISTCC</A></LI>
-<LI><A href="#CCache_nn14">SHARING A CACHE</A></LI>
-<LI><A href="#CCache_nn15">HISTORY</A></LI>
-<LI><A href="#CCache_nn16">DIFFERENCES FROM COMPILERCACHE</A></LI>
-<LI><A href="#CCache_nn17">CREDITS</A></LI>
-<LI><A href="#CCache_nn18">AUTHOR</A></LI>
-</UL>
+int execlp(const char *path, const char *arg, ...);
+</PRE>
</DIV>
-<!-- INDEX -->
-<P></P>
-<H2><A name="CCache_nn2"></A>16.1 NAME</H2>
-<P> ccache-swig - a fast compiler cache</P>
-<P></P>
-<H2><A name="CCache_nn3"></A>16.2 SYNOPSIS</H2>
-<P> ccache-swig [OPTION]</P>
-<P> ccache-swig <compiler> [COMPILER OPTIONS]</P>
-<P> <compiler> [COMPILER OPTIONS]</P>
-<P></P>
-<H2><A name="CCache_nn4"></A>16.3 DESCRIPTION</H2>
-<P> 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.</P>
-<P></P>
-<H2><A name="CCache_nn5"></A>16.4 OPTIONS SUMMARY</H2>
-<P> Here is a summary of the options to ccache-swig.</P>
-<P></P>
+<P> This patches everything up and creates a function that more or less
+ works. However, don't try explaining this to your coworkers unless you
+ know for certain that they've had several cups of coffee. If you really
+ want to elevate your guru status and increase your job security,
+ continue to the next section.</P>
+<H2><A name="Varargs_nn7">14.6 Varargs wrapping with libffi</A></H2>
+<P> All of the previous examples have relied on features of SWIG that
+ are portable and which don't rely upon any low-level machine-level
+ details. In many ways, they have all dodged the real issue of variable
+ length arguments by recasting a varargs function into some weaker
+ variation with a fixed number of arguments of known types. In many
+ cases, this works perfectly fine. However, if you want more generality
+ than this, you need to bring out some bigger guns.</P>
+<P> One way to do this is to use a special purpose library such as
+ libffi (<A href="http://www.sourceware.org/libffi/">
+http://www.sourceware.org/libffi/</A>). libffi is a library that allows
+ you to dynamically construct call-stacks and invoke procedures in a
+ relatively platform independent manner. Details about the library can
+ be found in the libffi distribution and are not repeated here.</P>
+<P> To illustrate the use of libffi, suppose that you<EM> really</EM>
+ wanted to create a wrapper for <TT>execlp()</TT> that accepted<EM> any</EM>
+ number of arguments. To do this, you might make a few adjustments to
+ the previous example. For example:</P>
+<DIV class="code">
<PRE>
+/* Take an arbitrary number of extra arguments and place into an array
+ of strings */
--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
+%typemap(in) (...) {
+ char **argv;
+ int argc;
+ int i;
+
+ argc = PyTuple_Size(varargs);
+ argv = (char **) malloc(sizeof(char *)*(argc+1));
+ for (i = 0; i < argc; i++) {
+ PyObject *o = PyTuple_GetItem(varargs,i);
+ if (!PyString_Check(o)) {
+ PyErr_SetString(PyExc_ValueError,"Expected a string");
+ free(argv);
+ return NULL;
+ }
+ argv[i] = PyString_AsString(o);
+ }
+ argv[i] = NULL;
+ $1 = (void *) argv;
+}
+
+/* Rewrite the function call, using libffi */
+
+%feature("action") execlp {
+ int i, vc;
+ ffi_cif cif;
+ ffi_type **types;
+ void **values;
+ char **args;
+
+ vc = PyTuple_Size(varargs);
+ types = (ffi_type **) malloc((vc+3)*sizeof(ffi_type *));
+ values = (void **) malloc((vc+3)*sizeof(void *));
+ args = (char **) arg3;
+
+ /* Set up path parameter */
+ types[0] = &ffi_type_pointer;
+ values[0] = &arg1;
+
+ /* Set up first argument */
+ types[1] = &ffi_type_pointer;
+ values[1] = &arg2;
+
+ /* Set up rest of parameters */
+ for (i = 0; i <= vc; i++) {
+ types[2+i] = &ffi_type_pointer;
+ values[2+i] = &args[i];
+ }
+ if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, vc+3,
+ &ffi_type_uint, types) == FFI_OK) {
+ ffi_call(&cif, (void (*)()) execlp, &result, values);
+ } else {
+ PyErr_SetString(PyExc_RuntimeError, "Whoa!!!!!");
+ free(types);
+ free(values);
+ free(arg3);
+ return NULL;
+ }
+ free(types);
+ free(values);
+ free(arg3);
+}
+/* Declare the function. Whew! */
+int execlp(const char *path, const char *arg1, ...);
</PRE>
-<P></P>
-<H2><A name="CCache_nn6"></A>16.5 OPTIONS</H2>
-<P> These options only apply when you invoke ccache as "ccache-swig".
- 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.</P>
-<P></P>
-<DL>
-<P>
-<DT><STRONG><STRONG>-h</STRONG></STRONG></DT>
-<DD> Print a options summary page
-<P></P>
-<P></P>
-</DD>
-<DT><STRONG><STRONG>-s</STRONG></STRONG></DT>
-<DD> Print the current statistics summary for the cache. The statistics
- are stored spread across the subdirectories of the cache. Using
- "ccache-swig -s" adds up the statistics across all subdirectories and
- prints the totals.
-<P></P>
-<P></P>
-</DD>
-<DT><STRONG><STRONG>-z</STRONG></STRONG></DT>
-<DD> Zero the cache statistics.
-<P></P>
-<P></P>
-</DD>
-<DT><STRONG><STRONG>-V</STRONG></STRONG></DT>
-<DD> Print the ccache version number
-<P></P>
-<P></P>
-</DD>
-<DT><STRONG><STRONG>-c</STRONG></STRONG></DT>
-<DD> 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.
-<P></P>
-<P></P>
-</DD>
-<DT><STRONG><STRONG>-C</STRONG></STRONG></DT>
-<DD> Clear the entire cache, removing all cached files.
-<P></P>
-<P></P>
-</DD>
-<DT><STRONG><STRONG>-F <maxfiles></STRONG></STRONG></DT>
-<DD> 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.
-<P></P>
-<P></P>
-</DD>
-<DT><STRONG><STRONG>-M <maxsize></STRONG></STRONG></DT>
-<DD> 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.
-<P></P>
-</DD>
-</P>
-</DL>
-<P></P>
-<H2><A name="CCache_nn7"></A>16.6 INSTALLATION</H2>
-<P> There are two ways to use ccache. You can either prefix your compile
- commands with "ccache-swig" 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.</P>
-<P> To install for usage by the first method just copy ccache-swig to
- somewhere in your path.</P>
-<P> To install for the second method do something like this:</P>
+</DIV>
+<P> Looking at this example, you may start to wonder if SWIG is making
+ life any easier. Given the amount of code involved, you might also
+ wonder why you didn't just write a hand-crafted wrapper! Either that or
+ you're wondering "why in the hell am I trying to wrap this varargs
+ function in the first place?!?" Obviously, those are questions you'll
+ have to answer for yourself.</P>
+<P> As a more extreme example of libffi, here is some code that attempts
+ to wrap <TT>printf()</TT>,</P>
+<DIV class="code">
<PRE>
+/* A wrapper for printf() using libffi */
- 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
+%{
+/* Structure for holding passed arguments after conversion */
+ typedef struct {
+ int type;
+ union {
+ int ivalue;
+ double dvalue;
+ void *pvalue;
+ } val;
+ } vtype;
+ enum { VT_INT, VT_DOUBLE, VT_POINTER };
+%}
-</PRE>
- 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
- "which gcc" to make sure that the correct link is being used.
-<P> Note! Do not use a hard link, use a symbolic link. A hardlink will
- cause "interesting" problems.</P>
-<P></P>
-<H2><A name="CCache_nn8"></A>16.7 EXTRA OPTIONS</H2>
-<P> 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 '--ccache-skip'. 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.</P>
-<P> 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.</P>
-<P></P>
-<H2><A name="CCache_nn9"></A>16.8 ENVIRONMENT VARIABLES</H2>
-<P> ccache uses a number of environment variables to control operation.
- In most cases you won't need any of these as the defaults will be fine.</P>
-<P></P>
-<DL>
-<P></P>
-<P>
-<DT><STRONG><STRONG>CCACHE_DIR</STRONG></STRONG></DT>
-<DD> the CCACHE_DIR environment variable specifies where ccache will
- keep its cached compiler output. The default is "$HOME/.ccache".
-<P></P>
-<P></P>
-</DD>
-<DT><STRONG><STRONG>CCACHE_TEMPDIR</STRONG></STRONG></DT>
-<DD> 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.
-<P></P>
-<P></P>
-</DD>
-<DT><STRONG><STRONG>CCACHE_LOGFILE</STRONG></STRONG></DT>
-<DD> 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.
-<P></P>
-<P></P>
-</DD>
-<DT><STRONG><STRONG>CCACHE_VERBOSE</STRONG></STRONG></DT>
-<DD> 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.
-<P></P>
-<P></P>
-</DD>
-<DT><STRONG><STRONG>CCACHE_PATH</STRONG></STRONG></DT>
-<DD> You can optionally set CCACHE_PATH to a colon separated path where
- ccache will look for the real compilers. If you don't do this then
- ccache will look for the first executable matching the compiler name in
- the normal PATH that isn't a symbolic link to ccache itself.
-<P></P>
-<P></P>
-</DD>
-<DT><STRONG><STRONG>CCACHE_CC</STRONG></STRONG></DT>
+%typemap(in) (const char *fmt, ...) {
+ vtype *argv;
+ int argc;
+ int i;
+
+ /* Format string */
+ $1 = PyString_AsString($input);
+
+ /* Variable length arguments */
+ argc = PyTuple_Size(varargs);
+ argv = (vtype *) malloc(argc*sizeof(vtype));
+ for (i = 0; i < argc; i++) {
+ PyObject *o = PyTuple_GetItem(varargs,i);
+ if (PyInt_Check(o)) {
+ argv[i].type = VT_INT;
+ argv[i].val.ivalue = PyInt_AsLong(o);
+ } else if (PyFloat_Check(o)) {
+ argv[i].type = VT_DOUBLE;
+ argv[i].val.dvalue = PyFloat_AsDouble(o);
+ } else if (PyString_Check(o)) {
+ argv[i].type = VT_POINTER;
+ argv[i].val.pvalue = (void *) PyString_AsString(o);
+ } else {
+ PyErr_SetString(PyExc_ValueError,"Unsupported argument type");
+ free(argv);
+ return NULL;
+ }
+ }
+ $2 = (void *) argv;
+}
+
+/* Rewrite the function call using libffi */
+%feature("action") printf {
+ int i, vc;
+ ffi_cif cif;
+ ffi_type **types;
+ void **values;
+ vtype *args;
+
+ vc = PyTuple_Size(varargs);
+ types = (ffi_type **) malloc((vc+1)*sizeof(ffi_type *));
+ values = (void **) malloc((vc+1)*sizeof(void *));
+ args = (vtype *) arg2;
+
+ /* Set up fmt parameter */
+ types[0] = &ffi_type_pointer;
+ values[0] = &arg1;
+
+ /* Set up rest of parameters */
+ for (i = 0; i < vc; i++) {
+ switch(args[i].type) {
+ case VT_INT:
+ types[1+i] = &ffi_type_uint;
+ values[1+i] = &args[i].val.ivalue;
+ break;
+ case VT_DOUBLE:
+ types[1+i] = &ffi_type_double;
+ values[1+i] = &args[i].val.dvalue;
+ break;
+ case VT_POINTER:
+ types[1+i] = &ffi_type_pointer;
+ values[1+i] = &args[i].val.pvalue;
+ break;
+ default:
+ abort(); /* Whoa! We're seriously hosed */
+ break;
+ }
+ }
+ if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, vc+1,
+ &ffi_type_uint, types) == FFI_OK) {
+ ffi_call(&cif, (void (*)()) printf, &result, values);
+ } else {
+ PyErr_SetString(PyExc_RuntimeError, "Whoa!!!!!");
+ free(types);
+ free(values);
+ free(args);
+ return NULL;
+ }
+ free(types);
+ free(values);
+ free(args);
+}
+
+/* The function */
+int printf(const char *fmt, ...);
+</PRE>
+</DIV>
+<P> Much to your amazement, it even seems to work if you try it:</P>
+<DIV class="targetlang">
+<PRE>
+>>> import example
+>>> example.printf("Grade: %s %d/60 = %0.2f%%\n", "Dave", 47, 47.0*100/60)
+Grade: Dave 47/60 = 78.33%
+>>>
+</PRE>
+</DIV>
+<P> Of course, there are still some limitations to consider:</P>
+<DIV class="targetlang">
+<PRE>
+>>> example.printf("la de da de da %s", 42)
+Segmentation fault (core dumped)
+</PRE>
+</DIV>
+<P> And, on this note, we leave further exploration of libffi to the
+ reader as an exercise. Although Python has been used as an example,
+ most of the techniques in this section can be extrapolated to other
+ language modules with a bit of work. The only details you need to know
+ is how the extra arguments are accessed in each target language. For
+ example, in the Python module, we used the special <TT>varargs</TT>
+ variable to get these arguments. Modules such as Tcl8 and Perl5 simply
+ provide an argument number for the first extra argument. This can be
+ used to index into an array of passed arguments to get values. Please
+ consult the chapter on each language module for more details.</P>
+<H2><A name="Varargs_nn8">14.7 Wrapping of va_list</A></H2>
+<P> Closely related to variable length argument wrapping, you may
+ encounter functions that accept a parameter of type <TT>va_list</TT>.
+ For example:</P>
+<DIV class="code">
+<PRE>
+int vprintf(const char *fmt, va_list ap);
+</PRE>
+</DIV>
+<P> As far as we know, there is no obvious way to wrap these functions
+ with SWIG. This is because there is no documented way to assemble the
+ proper va_list structure (there are no C library functions to do it and
+ the contents of va_list are opaque). Not only that, the contents of a <TT>
+va_list</TT> structure are closely tied to the underlying call-stack.
+ It's not clear that exporting a <TT>va_list</TT> would have any use or
+ that it would work at all.</P>
+<P> A workaround can be implemented by writing a simple varargs C
+ wrapper and then using the techniques discussed earlier in this chapter
+ for varargs. Below is a simple wrapper for <TT>vprintf</TT> renamed so
+ that it can still be called as <TT>vprintf</TT> from your target
+ language. The <TT>%varargs</TT> used in the example restricts the
+ function to taking one string argument.</P>
+<DIV class="code">
+<PRE>
+%{
+int vprintf(const char *fmt, va_list ap);
+%}
+
+%varargs(const char *) my_vprintf;
+%rename(vprintf) my_vprintf;
+
+%inline %{
+int my_vprintf(const char *fmt, ...) {
+ va_list ap;
+ int result;
+
+ va_start(ap, fmt);
+ result = vprintf(fmt, ap);
+ va_end(ap);
+ return result;
+}
+%}
+</PRE>
+</DIV>
+<H2><A name="Varargs_nn9">14.8 C++ Issues</A></H2>
+<P> Wrapping of C++ member functions that accept a variable number of
+ arguments presents a number of challenges. By far, the easiest way to
+ handle this is to use the <TT>%varargs</TT> directive. This is portable
+ and it fully supports classes much like the <TT>%rename</TT> directive.
+ For example:</P>
+<DIV class="code">
+<PRE>
+%varargs (10, char * = NULL) Foo::bar;
+
+class Foo {
+public:
+ virtual void bar(char *arg, ...); // gets varargs above
+};
+
+class Spam: public Foo {
+public:
+ virtual void bar(char *arg, ...); // gets varargs above
+};
+</PRE>
+</DIV>
+<P> <TT>%varargs</TT> also works with constructors, operators, and any
+ other C++ programming construct that accepts variable arguments.</P>
+<P> Doing anything more advanced than this is likely to involve a
+ serious world of pain. In order to use a library like libffi, you will
+ need to know the underlying calling conventions and details of the C++
+ ABI. For instance, the details of how <TT>this</TT> is passed to member
+ functions as well as any hidden arguments that might be used to pass
+ additional information. These details are implementation specific and
+ may differ between compilers and even different versions of the same
+ compiler. Also, be aware that invoking a member function is further
+ complicated if it is a virtual method. In this case, invocation might
+ require a table lookup to obtain the proper function address (although
+ you might be able to obtain an address by casting a bound pointer to a
+ pointer to function as described in the C++ ARM section 18.3.4).</P>
+<P> If you do decide to change the underlying action code, be aware that
+ SWIG always places the <TT>this</TT> pointer in <TT>arg1</TT>. Other
+ arguments are placed in <TT>arg2</TT>, <TT>arg3</TT>, and so forth. For
+ example:</P>
+<DIV class="code">
+<PRE>
+%feature("action") Foo::bar {
+ ...
+ result = arg1->bar(arg2, arg3, etc.);
+ ...
+}
+</PRE>
+</DIV>
+<P> Given the potential to shoot yourself in the foot, it is probably
+ easier to reconsider your design or to provide an alternative interface
+ using a helper function than it is to create a fully general wrapper to
+ a varargs C++ member function.</P>
+<H2><A name="Varargs_nn10">14.9 Discussion</A></H2>
+<P> This chapter has provided a number of techniques that can be used to
+ address the problem of variable length argument wrapping. If you care
+ about portability and ease of use, the <TT>%varargs</TT> directive is
+ probably the easiest way to tackle the problem. However, using
+ typemaps, it is possible to do some very advanced kinds of wrapping.</P>
+<P> One point of discussion concerns the structure of the libffi
+ examples in the previous section. Looking at that code, it is not at
+ all clear that this is the easiest way to solve the problem. However,
+ there are a number of subtle aspects of the solution to
+ consider--mostly concerning the way in which the problem has been
+ decomposed. First, the example is structured in a way that tries to
+ maintain separation between wrapper-specific information and the
+ declaration of the function itself. The idea here is that you might
+ structure your interface like this:</P>
+<DIV class="code">
+<PRE>
+%typemap(const char *fmt, ...) {
+ ...
+}
+%feature("action") traceprintf {
+ ...
+}
+
+/* Include some header file with traceprintf in it */
+%include "someheader.h"
+</PRE>
+</DIV>
+<P> Second, careful scrutiny will reveal that the typemaps involving <TT>
+(...)</TT> have nothing whatsoever to do with the libffi library. In
+ fact, they are generic with respect to the way in which the function is
+ actually called. This decoupling means that it will be much easier to
+ consider other library alternatives for making the function call. For
+ instance, if libffi wasn't supported on a certain platform, you might
+ be able to use something else instead. You could use conditional
+ compilation to control this:</P>
+<DIV class="code">
+<PRE>
+#ifdef USE_LIBFFI
+%feature("action") printf {
+ ...
+}
+#endif
+#ifdef USE_OTHERFFI
+%feature("action") printf {
+...
+}
+#endif
+</PRE>
+</DIV>
+<P> Finally, even though you might be inclined to just write a
+ hand-written wrapper for varargs functions, the techniques used in the
+ previous section have the advantage of being compatible with all other
+ features of SWIG such as exception handling.</P>
+<P> As a final word, some C programmers seem to have the assumption that
+ the wrapping of variable length argument functions is an easily solved
+ problem. However, this section has hopefully dispelled some of these
+ myths. All things being equal, you are better off avoiding variable
+ length arguments if you can. If you can't avoid them, please consider
+ some of the simple solutions first. If you can't live with a simple
+ solution, proceed with caution. At the very least, make sure you
+ carefully read the section "A7.3.2 Function Calls" in Kernighan and
+ Ritchie and make sure you fully understand the parameter passing
+ conventions used for varargs. Also, be aware of the platform
+ dependencies and reliability issues that this will introduce. Good
+ luck.</P>
+<HR NOSHADE>
+<H1><A name="Warnings">15 Warning Messages</A></H1>
+
+<!-- INDEX -->
+<DIV class="sectiontoc">
+<UL>
+<LI><A href="#Warnings_nn2">Introduction</A></LI>
+<LI><A href="#Warnings_suppression">Warning message suppression</A></LI>
+<LI><A href="#Warnings_nn4">Enabling extra warnings</A></LI>
+<LI><A href="#Warnings_nn5">Issuing a warning message</A></LI>
+<LI><A href="#Warnings_symbolic_symbols">Symbolic symbols</A></LI>
+<LI><A href="#Warnings_nn6">Commentary</A></LI>
+<LI><A href="#Warnings_nn7">Warnings as errors</A></LI>
+<LI><A href="#Warnings_nn8">Message output format</A></LI>
+<LI><A href="#Warnings_nn9">Warning number reference</A>
+<UL>
+<LI><A href="#Warnings_nn10">Deprecated features (100-199)</A></LI>
+<LI><A href="#Warnings_nn11">Preprocessor (200-299)</A></LI>
+<LI><A href="#Warnings_nn12">C/C++ Parser (300-399)</A></LI>
+<LI><A href="#Warnings_nn13">Types and typemaps (400-499)</A></LI>
+<LI><A href="#Warnings_nn14">Code generation (500-599)</A></LI>
+<LI><A href="#Warnings_nn15">Language module specific (700-899)</A></LI>
+<LI><A href="#Warnings_nn16">User defined (900-999)</A></LI>
+</UL>
+</LI>
+<LI><A href="#Warnings_nn17">History</A></LI>
+</UL>
+</DIV>
+<!-- INDEX -->
+<H2><A name="Warnings_nn2">15.1 Introduction</A></H2>
+<P> During compilation, SWIG may generate a variety of warning messages.
+ For example:</P>
+<DIV class="shell">
+<PRE>
+example.i:16: Warning 501: Overloaded declaration ignored. bar(double)
+example.i:15: Warning 501: Previous declaration is bar(int)
+</PRE>
+</DIV>
+<P> Typically, warning messages indicate non-fatal problems with the
+ input where the generated wrapper code will probably compile, but it
+ may not work like you expect.</P>
+<H2><A name="Warnings_suppression">15.2 Warning message suppression</A></H2>
+<P> All warning messages have a numeric code that is shown in the
+ warning message itself. To suppress the printing of a warning message,
+ a number of techniques can be used. First, you can run SWIG with the <TT>
+-w</TT> command line option. For example:</P>
+<DIV class="shell">
+<PRE>
+% swig -python -w501 example.i
+% swig -python -w501,505,401 example.i
+</PRE>
+</DIV>
+<P> Alternatively, warnings can be suppressed by inserting a special
+ preprocessor pragma into the input file:</P>
+<DIV class="code">
+<PRE>
+%module example
+#pragma SWIG nowarn=501
+#pragma SWIG nowarn=501,505,401
+</PRE>
+</DIV>
+<P> Finally, code-generation warnings can be disabled on a declaration
+ by declaration basis using the <TT>%warnfilter</TT> directive. For
+ example:</P>
+<DIV class="code">
+<PRE>
+%module example
+%warnfilter(501) foo;
+...
+int foo(int);
+int foo(double); // Silently ignored.
+</PRE>
+</DIV>
+<P> The <TT>%warnfilter</TT> directive has the same semantics as other
+ declaration modifiers like <TT>%rename</TT>, <TT>%ignore</TT> and <TT>
+%feature</TT>, see the <A href="#Customization_features">%feature
+ directive</A> section. For example, if you wanted to suppress a warning
+ for a method in a class hierarchy, you could do this:</P>
+<DIV class="code">
+<PRE>
+%warnfilter(501) Object::foo;
+class Object {
+public:
+ int foo(int);
+ int foo(double); // Silently ignored
+ ...
+};
+
+class Derived : public Object {
+public:
+ int foo(int);
+ int foo(double); // Silently ignored
+ ...
+};
+</PRE>
+</DIV>
+<P> Warnings can be suppressed for an entire class by supplying a class
+ name. For example:</P>
+<DIV class="code">
+<PRE>
+%warnfilter(501) Object;
+
+class Object {
+public:
+ ... // All 501 warnings ignored in class
+};
+</PRE>
+</DIV>
+<P> There is no option to suppress all SWIG warning messages. The
+ warning messages are there for a reason---to tell you that something
+ may be<EM> broken</EM> in your interface. Ignore the warning messages
+ at your own peril.</P>
+<H2><A name="Warnings_nn4">15.3 Enabling extra warnings</A></H2>
+<P> Some warning messages are disabled by default and are generated only
+ to provide additional diagnostics. These warnings can be turned on
+ using the <TT>-Wextra</TT> option. For example:</P>
+<DIV class="shell">
+<PRE>
+% swig -Wextra -python example.i
+</PRE>
+</DIV>
+<P> To selectively turn on extra warning messages, you can use the
+ directives and options in the previous section--simply add a "+" to all
+ warning numbers. For example:</P>
+<DIV class="shell">
+<PRE>
+% swig -w+309,+452 example.i
+</PRE>
+</DIV>
+<P> or in your interface file use either</P>
+<DIV class="code">
+<PRE>
+#pragma SWIG nowarn=+309,+452
+</PRE>
+</DIV>
+<P> or</P>
+<DIV class="code">
+<PRE>
+%warnfilter(+309,+452) foo;
+</PRE>
+</DIV>
+<P> Note: selective enabling of warnings with <TT>%warnfilter</TT>
+ overrides any global settings you might have made using <TT>-w</TT> or <TT>
+#pragma</TT>.</P>
+<P> You can of course also enable all warnings and suppress a select
+ few, for example:</P>
+<DIV class="shell">
+<PRE>
+% swig -Wextra -w309,452 example.i
+</PRE>
+</DIV>
+<P> The warnings on the right take precedence over the warnings on the
+ left, so in the above example <TT>-Wextra</TT> adds numerous warnings
+ including 452, but then <TT>-w309,452</TT> overrides this and so 452 is
+ suppressesed.</P>
+<P> If you would like all warnings to appear, regardless of the warning
+ filters used, then use the <TT>-Wall</TT> option. The <TT>-Wall</TT>
+ option also turns on the extra warnings that <TT>-Wextra</TT> adds,
+ however, it is subtely different. When <TT>-Wall</TT> is used, it also
+ disables all other warning filters, that is, any warnings suppressed or
+ added in <TT>%warnfilter</TT>, <TT>#pragma SWIG nowarn</TT> or the <TT>
+-w</TT> option.</P>
+<H2><A name="Warnings_nn5">15.4 Issuing a warning message</A></H2>
+<P> Warning messages can be issued from an interface file using a number
+ of directives. The <TT>%warn</TT> directive is the most simple:</P>
+<DIV class="code">
+<PRE>
+%warn "900:This is your last warning!"
+</PRE>
+</DIV>
+<P> All warning messages are optionally prefixed by the warning number
+ to use. If you are generating your own warnings, make sure you don't
+ use numbers defined in the table at the end of this section.</P>
+<P> The <TT>%ignorewarn</TT> directive is the same as <TT>%ignore</TT>
+ except that it issues a warning message whenever a matching declaration
+ is found. For example:</P>
+<DIV class="code">
+<PRE>
+%ignorewarn("362:operator= ignored") operator=;
+</PRE>
+</DIV>
+<P> Warning messages can be associated with typemaps using the <TT>
+warning</TT> attribute of a typemap declaration. For example:</P>
+<DIV class="code">
+<PRE>
+%typemap(in, warning="901:You are really going to regret this usage of $1_type $1_name") blah * {
+ ...
+}
+</PRE>
+</DIV>
+<P> In this case, the warning message will be printed whenever the
+ typemap is actually used and the <A href="#Typemaps_special_variables">
+special variables</A> will be expanded as appropriate, for example:</P>
+<DIV class="shell">
+<PRE>
+example.i:23: Warning 901: You are really going to regret this usage of blah * self
+example.i:24: Warning 901: You are really going to regret this usage of blah * stuff
+</PRE>
+</DIV>
+<H2><A name="Warnings_symbolic_symbols">15.5 Symbolic symbols</A></H2>
+<P> The <TT>swigwarn.swg</TT> file that is installed with SWIG contains
+ symbol constants that could also be used in <TT>%warnfilter</TT> and <TT>
+#pragma SWIG nowarn</TT>. For example this file contains the following
+ line:</P>
+<DIV class="code">
+<PRE>
+%define SWIGWARN_TYPE_UNDEFINED_CLASS 401 %enddef
+</PRE>
+</DIV>
+<P> so <TT>SWIGWARN_TYPE_UNDEFINED_CLASS</TT> could be used instead of
+ 401, for example:</P>
+<DIV class="code">
+<PRE>
+#pragma SWIG nowarn=SWIGWARN_TYPE_UNDEFINED_CLASS
+</PRE>
+</DIV>
+<P> or</P>
+<DIV class="code">
+<PRE>
+%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Foo;
+</PRE>
+</DIV>
+<H2><A name="Warnings_nn6">15.6 Commentary</A></H2>
+<P> The ability to suppress warning messages is really only provided for
+ advanced users and is not recommended in normal use. You are advised to
+ modify your interface to fix the problems highlighted by the warnings
+ wherever possible instead of suppressing warnings.</P>
+<P> Certain types of SWIG problems are errors. These usually arise due
+ to parsing errors (bad syntax) or semantic problems for which there is
+ no obvious recovery. There is no mechanism for suppressing error
+ messages.</P>
+<H2><A name="Warnings_nn7">15.7 Warnings as errors</A></H2>
+<P> Warnings can be handled as errors by using the <TT>-Werror</TT>
+ command line option. This will cause SWIG to exit with a non successful
+ exit code if a warning is encountered.</P>
+<H2><A name="Warnings_nn8">15.8 Message output format</A></H2>
+<P> The output format for both warnings and errors can be selected for
+ integration with your favourite IDE/editor. Editors and IDEs can
+ usually parse error messages and if in the appropriate format will
+ easily take you directly to the source of the error. The standard
+ format is used by default except on Windows where the Microsoft format
+ is used by default. These can be overridden using command line options,
+ for example:</P>
+<DIV class="shell">
+<PRE>
+$ swig -python -Fstandard example.i
+example.i:4: Syntax error in input(1).
+$ swig -python -Fmicrosoft example.i
+example.i(4) : Syntax error in input(1).
+</PRE>
+</DIV>
+<H2><A name="Warnings_nn9">15.9 Warning number reference</A></H2>
+<H3><A name="Warnings_nn10">15.9.1 Deprecated features (100-199)</A></H3>
+<UL>
+<LI>101. Deprecated <TT>%extern</TT> directive.</LI>
+<LI>102. Deprecated <TT>%val</TT> directive.</LI>
+<LI>103. Deprecated <TT>%out</TT> directive.</LI>
+<LI>104. Deprecated <TT>%disabledoc</TT> directive.</LI>
+<LI>105. Deprecated <TT>%enabledoc</TT> directive.</LI>
+<LI>106. Deprecated <TT>%doconly</TT> directive.</LI>
+<LI>107. Deprecated <TT>%style</TT> directive.</LI>
+<LI>108. Deprecated <TT>%localstyle</TT> directive.</LI>
+<LI>109. Deprecated <TT>%title</TT> directive.</LI>
+<LI>110. Deprecated <TT>%section</TT> directive.</LI>
+<LI>111. Deprecated <TT>%subsection</TT> directive.</LI>
+<LI>112. Deprecated <TT>%subsubsection</TT> directive.</LI>
+<LI>113. Deprecated <TT>%addmethods</TT> directive.</LI>
+<LI>114. Deprecated <TT>%readonly</TT> directive.</LI>
+<LI>115. Deprecated <TT>%readwrite</TT> directive.</LI>
+<LI>116. Deprecated <TT>%except</TT> directive.</LI>
+<LI>117. Deprecated <TT>%new</TT> directive.</LI>
+<LI>118. Deprecated <TT>%typemap(except)</TT>.</LI>
+<LI>119. Deprecated <TT>%typemap(ignore)</TT>.</LI>
+<LI>120. Deprecated command line option (-runtime, -noruntime).</LI>
+<LI>121. Deprecated <TT>%name</TT> directive.</LI>
+<LI>126. The 'nestedworkaround' feature is deprecated.</LI>
+</UL>
+<H3><A name="Warnings_nn11">15.9.2 Preprocessor (200-299)</A></H3>
+<UL>
+<LI>201. Unable to find<EM> filename</EM>.</LI>
+<LI>202. Could not evaluate expression<EM> expr</EM>.</LI>
+<LI>203. Both includeall and importall are defined: using includeall.</LI>
+<LI>204. CPP #warning, "<EM>warning</EM>".</LI>
+<LI>205. CPP #error, "<EM>error</EM>".</LI>
+<LI>206. Unexpected tokens after #<EM>directive</EM> directive.</LI>
+</UL>
+<H3><A name="Warnings_nn12">15.9.3 C/C++ Parser (300-399)</A></H3>
+<UL>
+<LI>301. <TT>class</TT> keyword used, but not in C++ mode.</LI>
+<LI>302. Identifier '<EM>name</EM>' redefined (ignored).</LI>
+<LI>303. <TT>%extend</TT> defined for an undeclared class '<EM>name</EM>
+'.</LI>
+<LI>304. Unsupported constant value (ignored).</LI>
+<LI>305. Bad constant value (ignored).</LI>
+<LI>306. '<EM>identifier</EM>' is private in this context.</LI>
+<LI>307. Can't set default argument value (ignored)</LI>
+<LI>308. Namespace alias '<EM>name</EM>' not allowed here. Assuming '<EM>
+name</EM>'</LI>
+<LI>309. [private | protected] inheritance ignored.</LI>
+<LI>310. Template '<EM>name</EM>' was already wrapped as '<EM>name</EM>'
+ (ignored)</LI>
+<LI>312. Unnamed nested class not currently supported (ignored).</LI>
+<LI>313. Unrecognized extern type "<EM>name</EM>" (ignored).</LI>
+<LI>314. '<EM>identifier</EM>' is a<EM> lang</EM> keyword.</LI>
+<LI>315. Nothing known about '<EM>identifier</EM>'.</LI>
+<LI>316. Repeated %module directive.</LI>
+<LI>317. Specialization of non-template '<EM>name</EM>'.</LI>
+<LI>318. Instantiation of template '<EM>name</EM>' is ambiguous,
+ instantiation<EM> templ</EM> used, instantiation<EM> templ</EM>
+ ignored.</LI>
+<LI>319. No access specifier given for base class<EM> name</EM>
+ (ignored).</LI>
+<LI>320. Explicit template instantiation ignored.</LI>
+<LI>321.<EM> identifier</EM> conflicts with a built-in name.</LI>
+<LI>322. Redundant redeclaration of '<EM>name</EM>'.</LI>
+<LI>323. Recursive scope inheritance of '<EM>name</EM>'.</LI>
+<LI>324. Named nested template instantiations not supported. Processing
+ as if no name was given to %template().</LI>
+<LI>325. Nested<EM> kind</EM> not currently supported (<EM>name</EM>
+ ignored).</LI>
+<LI>326. Deprecated %extend name used - the<EM> kind</EM> name '<EM>name</EM>
+' should be used instead of the typedef name '<EM>name</EM>'.</LI>
+<LI>350. operator new ignored.</LI>
+<LI>351. operator delete ignored.</LI>
+<LI>352. operator+ ignored.</LI>
+<LI>353. operator- ignored.</LI>
+<LI>354. operator* ignored.</LI>
+<LI>355. operator/ ignored.</LI>
+<LI>356. operator% ignored.</LI>
+<LI>357. operator^ ignored.</LI>
+<LI>358. operator& ignored.</LI>
+<LI>359. operator| ignored.</LI>
+<LI>360. operator~ ignored.</LI>
+<LI>361. operator! ignored.</LI>
+<LI>362. operator= ignored.</LI>
+<LI>363. operator< ignored.</LI>
+<LI>364. operator> ignored.</LI>
+<LI>365. operator+= ignored.</LI>
+<LI>366. operator-= ignored.</LI>
+<LI>367. operator*= ignored.</LI>
+<LI>368. operator/= ignored.</LI>
+<LI>369. operator%= ignored.</LI>
+<LI>370. operator^= ignored.</LI>
+<LI>371. operator&= ignored.</LI>
+<LI>372. operator|= ignored.</LI>
+<LI>373. operator<< ignored.</LI>
+<LI>374. operator>>ignored.</LI>
+<LI>375. operator<<= ignored.</LI>
+<LI>376. operator>>= ignored.</LI>
+<LI>377. operator== ignored.</LI>
+<LI>378. operator!= ignored.</LI>
+<LI>379. operator<= ignored.</LI>
+<LI>380. operator>= ignored.</LI>
+<LI>381. operator&& ignored.</LI>
+<LI>382. operator|| ignored.</LI>
+<LI>383. operator++ ignored.</LI>
+<LI>384. operator-- ignored.</LI>
+<LI>385. operator, ignored.</LI>
+<LI>386. operator-<* ignored.</LI>
+<LI>387. operator-< ignored.</LI>
+<LI>388. operator() ignored.</LI>
+<LI>389. operator[] ignored.</LI>
+<LI>390. operator+ ignored (unary).</LI>
+<LI>391. operator- ignored (unary).</LI>
+<LI>392. operator* ignored (unary).</LI>
+<LI>393. operator& ignored (unary).</LI>
+<LI>394. operator new[] ignored.</LI>
+<LI>395. operator delete[] ignored.</LI>
+</UL>
+<H3><A name="Warnings_nn13">15.9.4 Types and typemaps (400-499)</A></H3>
+<UL>
+<LI>401. Nothing known about class 'name'. Ignored.</LI>
+<LI>402. Base class 'name' is incomplete.</LI>
+<LI>403. Class 'name' might be abstract.</LI>
+<LI>450. Deprecated typemap feature ($source/$target).</LI>
+<LI>451. Setting const char * variable may leak memory.</LI>
+<LI>452. Reserved</LI>
+<LI>453. Can't apply (pattern). No typemaps are defined.</LI>
+<LI>460. Unable to use type<EM> type</EM> as a function argument.</LI>
+<LI>461. Unable to use return type<EM> type</EM> in function<EM> name</EM>
+.</LI>
+<LI>462. Unable to set variable of type<EM> type</EM>.</LI>
+<LI>463. Unable to read variable of type<EM> type</EM>.</LI>
+<LI>464. Unsupported constant value.</LI>
+<LI>465. Unable to handle type<EM> type</EM>.</LI>
+<LI>466. Unsupported variable type<EM> type</EM>.</LI>
+<LI>467. Overloaded<EM> declaration</EM> not supported (incomplete type
+ checking rule - no precedence level in typecheck typemap for '<EM>type</EM>
+')</LI>
+<LI>468. No 'throw' typemap defined for exception type<EM> type</EM></LI>
+<LI>469. No or improper directorin typemap defined for<EM> type</EM></LI>
+<LI>470. Thread/reentrant unsafe wrapping, consider returning by value
+ instead.</LI>
+<LI>471. Unable to use return type<EM> type</EM> in director method</LI>
+<LI>474. Method<EM> method</EM> usage of the optimal attribute ignored
+ in the out typemap as the following cannot be used to generate optimal
+ code:<EM> code</EM></LI>
+<LI>475. Multiple calls to<EM> method</EM> might be generated due to
+ optimal attribute usage in the out typemap.</LI>
+<LI>476. Initialization using std::initializer_list.</LI>
+<LI>477. No directorthrows typemap defined for<EM> type</EM></LI>
+</UL>
+<H3><A name="Warnings_nn14">15.9.5 Code generation (500-599)</A></H3>
+<UL>
+<LI>501. Overloaded declaration ignored.<EM> decl</EM>. Previous
+ declaration is<EM> decl</EM>.</LI>
+<LI>502. Overloaded constructor ignored.<EM> decl</EM>. Previous
+ declaration is<EM> decl</EM>.</LI>
+<LI>503. Can't wrap '<EM>identifier</EM>' unless renamed to a valid
+ identifier.</LI>
+<LI>504. Function<EM> name</EM> must have a return type. Ignored.</LI>
+<LI>505. Variable length arguments discarded.</LI>
+<LI>506. Can't wrap varargs with keyword arguments enabled.</LI>
+<LI>507. Adding native function<EM> name</EM> not supported (ignored).</LI>
+<LI>508. Declaration of '<EM>name</EM>' shadows declaration accessible
+ via operator->(), previous declaration of'<EM>declaration</EM>'.</LI>
+<LI>509. Overloaded method<EM> declaration</EM> effectively ignored, as
+ it is shadowed by<EM> declaration</EM>.</LI>
+<LI>510. Friend function '<EM>name</EM>' ignored.</LI>
+<LI>511. Can't use keyword arguments with overloaded functions.</LI>
+<LI>512. Overloaded method<EM> declaration</EM> ignored, using non-const
+ method<EM> declaration</EM> instead.</LI>
+<LI>513. Can't generate wrappers for unnamed struct/class.</LI>
+<LI>514.</LI>
+<LI>515.</LI>
+<LI>516. Overloaded method<EM> declaration</EM> ignored, using<EM>
+ declaration</EM> instead.</LI>
+<LI>517.</LI>
+<LI>518. Portability warning: File<EM> file1</EM> will be overwritten by<EM>
+ file2</EM> on case insensitive filesystems such as Windows' FAT32 and
+ NTFS unless the class/module name is renamed.</LI>
+<LI>519. %template() contains no name. Template method ignored:<EM>
+ declaration</EM></LI>
+<LI>520.<EM> Base/Derived</EM> class '<EM>classname1</EM>' of '<EM>
+classname2</EM>' is not similarly marked as a smart pointer.</LI>
+<LI>521. Illegal destructor name<EM> name</EM>. Ignored.</LI>
+<LI>522. Use of an illegal constructor name '<EM>name</EM>' in %extend
+ is deprecated, the constructor name should be '<EM>name</EM>'.</LI>
+<LI>523. Use of an illegal destructor name '<EM>name</EM>' in %extend is
+ deprecated, the destructor name should be '<EM>name</EM>'.</LI>
+</UL>
+<H3><A name="Warnings_nn15">15.9.6 Language module specific (700-899)</A>
+</H3>
+<UL>
+<LI>801. Wrong name (corrected to '<EM>name</EM>'). (Ruby).</LI>
+</UL>
+<UL>
+<LI>810. No jni typemap defined for<EM> type</EM> (Java).</LI>
+<LI>811. No jtype typemap defined for<EM> type</EM> (Java).</LI>
+<LI>812. No jstype typemap defined for<EM> type</EM> (Java).</LI>
+<LI>813. Warning for<EM> classname</EM>, base<EM> baseclass</EM>
+ ignored. Multiple inheritance is not supported in Java. (Java).</LI>
+<LI>814.</LI>
+<LI>815. No javafinalize typemap defined for<EM> type</EM> (Java).</LI>
+<LI>816. No javabody typemap defined for<EM> type</EM> (Java).</LI>
+<LI>817. No javaout typemap defined for<EM> type</EM> (Java).</LI>
+<LI>818. No javain typemap defined for<EM> type</EM> (Java).</LI>
+<LI>819. No javadirectorin typemap defined for<EM> type</EM> (Java).</LI>
+<LI>820. No javadirectorout typemap defined for<EM> type</EM> (Java).</LI>
+<LI>821.</LI>
+<LI>822. Covariant return types not supported in Java. Proxy method will
+ return<EM> basetype</EM> (Java).</LI>
+<LI>823. No javaconstruct typemap defined for<EM> type</EM> (Java).</LI>
+<LI>824. Missing JNI descriptor in directorin typemap defined for<EM>
+ type</EM> (Java).</LI>
+<LI>825. "directorconnect" attribute missing in<EM> type</EM>
+ "javaconstruct" typemap. (Java).</LI>
+<LI>826. The nspace feature is used on '<EM>type</EM>' without -package.
+ The generated code may not compile as Java does not support types
+ declared in a named package accessing types declared in an unnamed
+ package. (Java).</LI>
+</UL>
+<UL>
+<LI>830. No ctype typemap defined for<EM> type</EM> (C#).</LI>
+<LI>831. No cstype typemap defined for<EM> type</EM> (C#).</LI>
+<LI>832. No cswtype typemap defined for<EM> type</EM> (C#).</LI>
+<LI>833. Warning for<EM> classname</EM>, base<EM> baseclass</EM>
+ ignored. Multiple inheritance is not supported in C#. (C#).</LI>
+<LI>834.</LI>
+<LI>835. No csfinalize typemap defined for<EM> type</EM> (C#).</LI>
+<LI>836. No csbody typemap defined for<EM> type</EM> (C#).</LI>
+<LI>837. No csout typemap defined for<EM> type</EM> (C#).</LI>
+<LI>838. No csin typemap defined for<EM> type</EM> (C#).</LI>
+<LI>839.</LI>
+<LI>840.</LI>
+<LI>841.</LI>
+<LI>842. Covariant return types not supported in C#. Proxy method will
+ return<EM> basetype</EM> (C#).</LI>
+<LI>843. No csconstruct typemap defined for<EM> type</EM> (C#).</LI>
+<LI>844. C# exception may not be thrown - no $excode or excode attribute
+ in<EM> typemap</EM> typemap. (C#).</LI>
+<LI>845. Unmanaged code contains a call to a
+ SWIG_CSharpSetPendingException method and C# code does not handle
+ pending exceptions via the canthrow attribute. (C#).</LI>
+</UL>
+<UL>
+<LI>870. Warning for<EM> classname</EM>: Base<EM> baseclass</EM>
+ ignored. Multiple inheritance is not supported in PHP. (Php).</LI>
+<LI>871. Unrecognized pragma<EM> pragma</EM>. (Php).</LI>
+</UL>
+<H3><A name="Warnings_nn16">15.9.7 User defined (900-999)</A></H3>
+<P> These numbers can be used by your own application.</P>
+<H2><A name="Warnings_nn17">15.10 History</A></H2>
+<P> The ability to control warning messages was first added to
+ SWIG-1.3.12.</P>
+<HR NOSHADE>
+<H1><A name="Modules">16 Working with Modules</A></H1>
+
+<!-- INDEX -->
+<DIV class="sectiontoc">
+<UL>
+<LI><A href="#Modules_introduction">Modules Introduction</A></LI>
+<LI><A href="#Modules_nn1">Basics</A></LI>
+<LI><A href="#Modules_nn2">The SWIG runtime code</A></LI>
+<LI><A href="#Modules_external_run_time">External access to the runtime</A>
+</LI>
+<LI><A href="#Modules_nn4">A word of caution about static libraries</A></LI>
+<LI><A href="#Modules_nn5">References</A></LI>
+<LI><A href="#Modules_nn6">Reducing the wrapper file size</A></LI>
+</UL>
+</DIV>
+<!-- INDEX -->
+<H2><A name="Modules_introduction">16.1 Modules Introduction</A></H2>
+<P> Each invocation of SWIG requires a module name to be specified. The
+ module name is used to name the resulting target language extension
+ module. Exactly what this means and what the name is used for depends
+ on the target language, for example the name can define a target
+ language namespace or merely be a useful name for naming files or
+ helper classes. Essentially, a module comprises target language
+ wrappers for a chosen collection of global variables/functions,
+ structs/classes and other C/C++ types.</P>
+<P> The module name can be supplied in one of two ways. The first is to
+ specify it with the special <TT>%module</TT> directive. This directive
+ must appear at the beginning of the interface file. The general form of
+ this directive is:</P>
+<DIV class="code">
+<PRE>
+<TT>%module(option1="value1",option2="value2",...) modulename</TT>
+</PRE>
+</DIV>
+<P> where the modulename is mandatory and the options add one or more
+ optional additional features. Typically no options are specified, for
+ example:</P>
+<DIV class="code">
+<PRE>
+<TT>%module mymodule</TT>
+</PRE>
+</DIV>
+<P> The second way to specify the module name is with the <TT>-module</TT>
+ command line option, for example <TT>-module mymodule</TT>. If the
+ module name is supplied on the command line, it overrides the name
+ specified by the <TT>%module</TT> directive.</P>
+<P> When first working with SWIG, users commonly start by creating a
+ single module. That is, you might define a single SWIG interface that
+ wraps some set of C/C++ code. You then compile all of the generated
+ wrapper code together and use it. For large applications, however, this
+ approach is problematic---the size of the generated wrapper code can be
+ rather large. Moreover, it is probably easier to manage the target
+ language interface when it is broken up into smaller pieces.</P>
+<P> This chapter describes the problem of using SWIG in programs where
+ you want to create a collection of modules. Each module in the
+ collection is created via separate invocations of SWIG.</P>
+<H2><A name="Modules_nn1">16.2 Basics</A></H2>
+<P> The basic usage case with multiple modules is when modules do not
+ have cross-references (ie. when wrapping multiple independent C APIs).
+ In that case, swig input files should just work out of the box - you
+ simply create multiple wrapper .cxx files, link them into your
+ application, and insert/load each in the scripting language runtime as
+ you would do for the single module case.</P>
+<P> A bit more complex is the case in which modules need to share
+ information. For example, when one module extends the class of another
+ by deriving from it:</P>
+<DIV class="code">
+<PRE>
+// File: base.h
+class base {
+public:
+ int foo();
+};
+</PRE>
+</DIV> <DIV class="code">
+<PRE>
+// File: base_module.i
+%module base_module
+
+%{
+#include "base.h"
+%}
+%include "base.h"
+</PRE>
+</DIV> <DIV class="code">
+<PRE>
+// File: derived_module.i
+%module derived_module
+
+%import "base_module.i"
+
+%inline %{
+class derived : public base {
+public:
+ int bar();
+};
+%}
+</PRE>
+</DIV>
+<P>To create the wrapper properly, module <TT>derived_module</TT> needs
+ to know about the <TT>base</TT> class and that its interface is covered
+ in another module. The line <TT>%import "base_module.i"</TT> lets SWIG
+ know exactly that. Often the <TT>.h</TT> file is passed to <TT>%import</TT>
+ instead of the <TT>.i</TT>, which unfortunately doesn't work for all
+ language modules. For example, Python requires the name of module that
+ the base class exists in so that the proxy classes can fully inherit
+ the base class's methods. Typically you will get a warning when the
+ module name is missing, eg:</P>
+<DIV class="shell">
+<PRE>
+derived_module.i:8: Warning 401: Base class 'base' ignored - unknown module name for base. Either
+import
+the appropriate module interface file or specify the name of the module in the %import directive.
+</PRE>
+</DIV>
+<P> It is sometimes desirable to import the header file rather than the
+ interface file and overcome the above warning. For example in the case
+ of the imported interface being quite large, it may be desirable to
+ simplify matters and just import a small header file of dependent
+ types. This can be done by specifying the optional <TT>module</TT>
+ attribute in the <TT>%import</TT> directive. The <TT>derived_module.i</TT>
+ file shown above could be replaced with the following:<DIV class="code">
+<PRE>
+// File: derived_module.i
+%module derived_module
+
+%import(module="base_module") "base.h"
+
+%inline %{
+class derived : public base {
+public:
+ int bar();
+};
+</PRE>
+</DIV></P>
+<P> Note that "base_module" is the module name and is the same as that
+ specified in <TT>%module</TT> in <TT>base_module.i</TT> as well as the <TT>
+%import</TT> in <TT>derived_module.i</TT>.</P>
+<P> Another issue to beware of is that multiple dependent wrappers
+ should not be linked/loaded in parallel from multiple threads as SWIG
+ provides no locking - for more on that issue, read on.</P>
+<H2><A name="Modules_nn2">16.3 The SWIG runtime code</A></H2>
+<P> Many of SWIG's target languages generate a set of functions commonly
+ known as the "SWIG runtime." These functions are primarily related to
+ the runtime type system which checks pointer types and performs other
+ tasks such as proper casting of pointer values in C++. As a general
+ rule, the statically typed target languages, such as Java, use the
+ language's built in static type checking and have no need for a SWIG
+ runtime. All the dynamically typed / interpreted languages rely on the
+ SWIG runtime.</P>
+<P> The runtime functions are private to each SWIG-generated module.
+ That is, the runtime functions are declared with "static" linkage and
+ are visible only to the wrapper functions defined in that module. The
+ only problem with this approach is that when more than one SWIG module
+ is used in the same application, those modules often need to share type
+ information. This is especially true for C++ programs where SWIG must
+ collect and share information about inheritance relationships that
+ cross module boundaries.</P>
+<P> To solve the problem of sharing information across modules, a
+ pointer to the type information is stored in a global variable in the
+ target language namespace. During module initialization, type
+ information is loaded into the global data structure of type
+ information from all modules.</P>
+<P> There are a few trade offs with this approach. This type information
+ is global across all SWIG modules loaded, and can cause type conflicts
+ between modules that were not designed to work together. To solve this
+ approach, the SWIG runtime code uses a define SWIG_TYPE_TABLE to
+ provide a unique type table. This behavior can be enabled when
+ compiling the generated _wrap.cxx or _wrap.c file by adding
+ -DSWIG_TYPE_TABLE=myprojectname to the command line argument.</P>
+<P> Then, only modules compiled with SWIG_TYPE_TABLE set to
+ myprojectname will share type information. So if your project has three
+ modules, all three should be compiled with
+ -DSWIG_TYPE_TABLE=myprojectname, and then these three modules will
+ share type information. But any other project's types will not
+ interfere or clash with the types in your module.</P>
+<P> Another issue relating to the global type table is thread safety. If
+ two modules try and load at the same time, the type information can
+ become corrupt. SWIG currently does not provide any locking, and if you
+ use threads, you must make sure that modules are loaded serially. Be
+ careful if you use threads and the automatic module loading that some
+ scripting languages provide. One solution is to load all modules before
+ spawning any threads, or use SWIG_TYPE_TABLE to separate type tables so
+ they do not clash with each other.</P>
+<P> Lastly, SWIG uses a #define SWIG_RUNTIME_VERSION, located in
+ Lib/swigrun.swg and near the top of every generated module. This number
+ gets incremented when the data structures change, so that SWIG modules
+ generated with different versions can peacefully coexist. So the type
+ structures are separated by the (SWIG_TYPE_TABLE, SWIG_RUNTIME_VERSION)
+ pair, where by default SWIG_TYPE_TABLE is empty. Only modules compiled
+ with the same pair will share type information.</P>
+<H2><A name="Modules_external_run_time">16.4 External access to the
+ runtime</A></H2>
+<P>As described in <A href="#Typemaps_runtime_type_checker">The run-time
+ type checker</A>, the functions <TT>SWIG_TypeQuery</TT>, <TT>
+SWIG_NewPointerObj</TT>, and others sometimes need to be called. Calling
+ these functions from a typemap is supported, since the typemap code is
+ embedded into the <TT>_wrap.c</TT> file, which has those declarations
+ available. If you need to call the SWIG run-time functions from another
+ C file, there is one header you need to include. To generate the header
+ that needs to be included, SWIG can be run in a different mode via <TT>
+-external-runtime</TT> to generate the run-time instead of the normal
+ mode of processing an input interface file. For example:<DIV class="shell">
+<PRE>
+$ swig -python -external-runtime <filename>
+</PRE>
+</DIV></P>
+<P>The filename argument is optional and if it is not passed, then the
+ default filename will be something like <TT>swigpyrun.h</TT>, depending
+ on the language. This header file should be treated like any of the
+ other _wrap.c output files, and should be regenerated when the _wrap
+ files are. After including this header, your code will be able to call <TT>
+SWIG_TypeQuery</TT>, <TT>SWIG_NewPointerObj</TT>, <TT>SWIG_ConvertPtr</TT>
+ and others. The exact argument parameters for these functions might
+ differ between language modules; please check the language module
+ chapters for more information.</P>
+<P>Inside this header the functions are declared static and are included
+ inline into the file, and thus the file does not need to be linked
+ against any SWIG libraries or code (you might still need to link
+ against the language libraries like libpython-2.3). Data is shared
+ between this file and the _wrap.c files through a global variable in
+ the scripting language. It is also possible to copy this header file
+ along with the generated wrapper files into your own package, so that
+ you can distribute a package that can be compiled without SWIG
+ installed (this works because the header file is self-contained, and
+ does not need to link with anything).</P>
+<P> This header will also use the -DSWIG_TYPE_TABLE described above, so
+ when compiling any code which includes the generated header file should
+ define the SWIG_TYPE_TABLE to be the same as the module whose types you
+ are trying to access.</P>
+<H2><A name="Modules_nn4">16.5 A word of caution about static libraries</A>
+</H2>
+<P> When working with multiple SWIG modules, you should take care not to
+ use static libraries. For example, if you have a static library <TT>
+libfoo.a</TT> and you link a collection of SWIG modules with that
+ library, each module will get its own private copy of the library code
+ inserted into it. This is very often<B> NOT</B> what you want and it
+ can lead to unexpected or bizarre program behavior. When working with
+ dynamically loadable modules, you should try to work exclusively with
+ shared libraries.</P>
+<H2><A name="Modules_nn5">16.6 References</A></H2>
+<P> Due to the complexity of working with shared libraries and multiple
+ modules, it might be a good idea to consult an outside reference. John
+ Levine's "Linkers and Loaders" is highly recommended.</P>
+<H2><A name="Modules_nn6">16.7 Reducing the wrapper file size</A></H2>
+<P> Using multiple modules with the <TT>%import</TT> directive is the
+ most common approach to modularising large projects. In this way a
+ number of different wrapper files can be generated, thereby avoiding
+ the generation of a single large wrapper file. There are a couple of
+ alternative solutions for reducing the size of a wrapper file through
+ the use of command line options and features.</P>
+<P><B> -fcompact</B>
+<BR> This command line option will compact the size of the wrapper file
+ without changing the code generated into the wrapper file. It simply
+ removes blank lines and joins lines of code together. This is useful
+ for compilers that have a maximum file size that can be handled.</P>
+<P><B> -fvirtual</B>
+<BR> This command line option will remove the generation of superfluous
+ virtual method wrappers. Consider the following inheritance hierarchy:</P>
+<DIV class="code">
+<PRE>
+struct Base {
+ virtual void method();
+ ...
+};
+
+struct Derived : Base {
+ virtual void method();
+ ...
+};
+</PRE>
+</DIV>
+<P> Normally wrappers are generated for both methods, whereas this
+ command line option will suppress the generation of a wrapper for <TT>
+Derived::method</TT>. Normal polymorphic behaviour remains as <TT>
+Derived::method</TT> will still be called should you have a <TT>Derived</TT>
+ instance and call the wrapper for <TT>Base::method</TT>.</P>
+<P><B> %feature("compactdefaultargs")</B>
+<BR> This feature can reduce the number of wrapper methods when wrapping
+ methods with default arguments. The section on <A href="#SWIGPlus_default_args">
+default arguments</A> discusses the feature and its limitations.</P>
+<HR NOSHADE>
+<H1><A name="CCache">17 Using SWIG with ccache - ccache-swig(1) manpage</A>
+</H1>
+
+<!-- INDEX -->
+<DIV class="sectiontoc">
+<UL>
+<LI><A href="#CCache_nn2">NAME</A></LI>
+<LI><A href="#CCache_nn3">SYNOPSIS</A></LI>
+<LI><A href="#CCache_nn4">DESCRIPTION</A></LI>
+<LI><A href="#CCache_nn5">OPTIONS SUMMARY</A></LI>
+<LI><A href="#CCache_nn6">OPTIONS</A></LI>
+<LI><A href="#CCache_nn7">INSTALLATION</A></LI>
+<LI><A href="#CCache_nn8">EXTRA OPTIONS</A></LI>
+<LI><A href="#CCache_nn9">ENVIRONMENT VARIABLES</A></LI>
+<LI><A href="#CCache_nn10">CACHE SIZE MANAGEMENT</A></LI>
+<LI><A href="#CCache_nn11">CACHE COMPRESSION</A></LI>
+<LI><A href="#CCache_nn12">HOW IT WORKS</A></LI>
+<LI><A href="#CCache_nn13">USING CCACHE WITH DISTCC</A></LI>
+<LI><A href="#CCache_nn14">SHARING A CACHE</A></LI>
+<LI><A href="#CCache_nn15">HISTORY</A></LI>
+<LI><A href="#CCache_nn16">DIFFERENCES FROM COMPILERCACHE</A></LI>
+<LI><A href="#CCache_nn17">CREDITS</A></LI>
+<LI><A href="#CCache_nn18">AUTHOR</A></LI>
+</UL>
+</DIV>
+<!-- INDEX -->
+<P></P>
+<H2><A name="CCache_nn2">17.1 NAME</A></H2>
+<P> ccache-swig - a fast compiler cache</P>
+<P></P>
+<H2><A name="CCache_nn3">17.2 SYNOPSIS</A></H2>
+<P> ccache-swig [OPTION]</P>
+<P> ccache-swig <compiler> [COMPILER OPTIONS]</P>
+<P> <compiler> [COMPILER OPTIONS]</P>
+<P></P>
+<H2><A name="CCache_nn4">17.3 DESCRIPTION</A></H2>
+<P> 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.</P>
+<P></P>
+<H2><A name="CCache_nn5">17.4 OPTIONS SUMMARY</A></H2>
+<P> Here is a summary of the options to ccache-swig.</P>
+<P></P>
+<PRE>
+
+-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
+
+</PRE>
+<P></P>
+<H2><A name="CCache_nn6">17.5 OPTIONS</A></H2>
+<P> These options only apply when you invoke ccache as "ccache-swig".
+ 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.</P>
+<P></P>
+<DL>
+<P>
+<DT><STRONG><STRONG>-h</STRONG></STRONG></DT>
+<DD> Print a options summary page
+<P></P>
+<P></P>
+</DD>
+<DT><STRONG><STRONG>-s</STRONG></STRONG></DT>
+<DD> Print the current statistics summary for the cache. The statistics
+ are stored spread across the subdirectories of the cache. Using
+ "ccache-swig -s" adds up the statistics across all subdirectories and
+ prints the totals.
+<P></P>
+<P></P>
+</DD>
+<DT><STRONG><STRONG>-z</STRONG></STRONG></DT>
+<DD> Zero the cache statistics.
+<P></P>
+<P></P>
+</DD>
+<DT><STRONG><STRONG>-V</STRONG></STRONG></DT>
+<DD> Print the ccache version number
+<P></P>
+<P></P>
+</DD>
+<DT><STRONG><STRONG>-c</STRONG></STRONG></DT>
+<DD> 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.
+<P></P>
+<P></P>
+</DD>
+<DT><STRONG><STRONG>-C</STRONG></STRONG></DT>
+<DD> Clear the entire cache, removing all cached files.
+<P></P>
+<P></P>
+</DD>
+<DT><STRONG><STRONG>-F <maxfiles></STRONG></STRONG></DT>
+<DD> 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.
+<P></P>
+<P></P>
+</DD>
+<DT><STRONG><STRONG>-M <maxsize></STRONG></STRONG></DT>
+<DD> 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.
+<P></P>
+</DD>
+</P>
+</DL>
+<P></P>
+<H2><A name="CCache_nn7">17.6 INSTALLATION</A></H2>
+<P> There are two ways to use ccache. You can either prefix your compile
+ commands with "ccache-swig" 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.</P>
+<P> To install for usage by the first method just copy ccache-swig to
+ somewhere in your path.</P>
+<P> To install for the second method do something like this:</P>
+<PRE>
+
+ 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
+
+</PRE>
+ 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
+ "which gcc" to make sure that the correct link is being used.
+<P> Note! Do not use a hard link, use a symbolic link. A hardlink will
+ cause "interesting" problems.</P>
+<P></P>
+<H2><A name="CCache_nn8">17.7 EXTRA OPTIONS</A></H2>
+<P> 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 '--ccache-skip'. 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.</P>
+<P> 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.</P>
+<P></P>
+<H2><A name="CCache_nn9">17.8 ENVIRONMENT VARIABLES</A></H2>
+<P> ccache uses a number of environment variables to control operation.
+ In most cases you won't need any of these as the defaults will be fine.</P>
+<P></P>
+<DL>
+<P></P>
+<P>
+<DT><STRONG><STRONG>CCACHE_DIR</STRONG></STRONG></DT>
+<DD> the CCACHE_DIR environment variable specifies where ccache will
+ keep its cached compiler output. The default is "$HOME/.ccache".
+<P></P>
+<P></P>
+</DD>
+<DT><STRONG><STRONG>CCACHE_TEMPDIR</STRONG></STRONG></DT>
+<DD> 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.
+<P></P>
+<P></P>
+</DD>
+<DT><STRONG><STRONG>CCACHE_LOGFILE</STRONG></STRONG></DT>
+<DD> 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.
+<P></P>
+<P></P>
+</DD>
+<DT><STRONG><STRONG>CCACHE_VERBOSE</STRONG></STRONG></DT>
+<DD> 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.
+<P></P>
+<P></P>
+</DD>
+<DT><STRONG><STRONG>CCACHE_PATH</STRONG></STRONG></DT>
+<DD> You can optionally set CCACHE_PATH to a colon separated path where
+ ccache will look for the real compilers. If you don't do this then
+ ccache will look for the first executable matching the compiler name in
+ the normal PATH that isn't a symbolic link to ccache itself.
+<P></P>
+<P></P>
+</DD>
+<DT><STRONG><STRONG>CCACHE_CC</STRONG></STRONG></DT>
<DD> You can optionally set CCACHE_CC to force the name of the compiler
to use. If you don't do this then ccache works it out from the command
line.
</P>
</DL>
<P></P>
-<H2><A name="CCache_nn10"></A>16.9 CACHE SIZE MANAGEMENT</H2>
+<H2><A name="CCache_nn10">17.9 CACHE SIZE MANAGEMENT</A></H2>
<P> 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
"ccache -M" and "ccache -F" options, which set the size and number of
below the numbers you specified in order to avoid doing the cache clean
operation too often.</P>
<P></P>
-<H2><A name="CCache_nn11"></A>16.10 CACHE COMPRESSION</H2>
+<H2><A name="CCache_nn11">17.10 CACHE COMPRESSION</A></H2>
<P> 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.</P>
<P></P>
-<H2><A name="CCache_nn12"></A>16.11 HOW IT WORKS</H2>
+<H2><A name="CCache_nn12">17.11 HOW IT WORKS</A></H2>
<P> 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:</P>
discover a case where ccache changes the output of your compiler then
please let me know.</P>
<P></P>
-<H2><A name="CCache_nn13"></A>16.12 USING CCACHE WITH DISTCC</H2>
+<H2><A name="CCache_nn13">17.12 USING CCACHE WITH DISTCC</A></H2>
<P> 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
'distcc' and ccache will prefix the command line used with the compiler
with the command 'distcc'.</P>
<P></P>
-<H2><A name="CCache_nn14"></A>16.13 SHARING A CACHE</H2>
+<H2><A name="CCache_nn14">17.13 SHARING A CACHE</A></H2>
<P> 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's modification timestamp.
users with versions of ccache that do not support compression.</LI>
</UL>
<P></P>
-<H2><A name="CCache_nn15"></A>16.14 HISTORY</H2>
+<H2><A name="CCache_nn15">17.14 HISTORY</A></H2>
<P> 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 <A href="http://www.erikyyy.de/compilercache/">
compiler cache and I wanted to remove some of the limitations of the
shell-script version.</P>
<P></P>
-<H2><A name="CCache_nn16"></A>16.15 DIFFERENCES FROM COMPILERCACHE</H2>
+<H2><A name="CCache_nn16">17.15 DIFFERENCES FROM COMPILERCACHE</A></H2>
<P> The biggest differences between Erik's compilercache script and
ccache are:</P>
<UL>
<LI> ccache avoids a double call to cpp on a cache miss</LI>
</UL>
<P></P>
-<H2><A name="CCache_nn17"></A>16.16 CREDITS</H2>
+<H2><A name="CCache_nn17">17.16 CREDITS</A></H2>
<P> Thanks to the following people for their contributions to ccache</P>
<UL>
<LI> Erik Thiele for the original compilercache script</LI>
<LI> Paul Russell for many suggestions and the debian packaging</LI>
</UL>
<P></P>
-<H2><A name="CCache_nn18"></A>16.17 AUTHOR</H2>
+<H2><A name="CCache_nn18">17.17 AUTHOR</A></H2>
<P> ccache was written by Andrew Tridgell <A href="http://samba.org/~tridge/">
http://samba.org/~tridge/</A>. ccache was adapted to create ccache-swig
for use with SWIG by William Fulton.</P>
later. Please see the file COPYING for license details.</P>
<P></P>
<HR NOSHADE>
-
-<!-- Hand-written HTML -->
-<H1><A name="Allegrocl"></A>17 SWIG and Allegro Common Lisp</H1>
+<H1><A name="Allegrocl">18 SWIG and Allegro Common Lisp</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
interfaces (UFFI or CFFI, for example). Such work can only benefit the
lisp community, and we would not be unhappy to see some enterprising
folk use this work to add to it.</P>
-<H2><A name="Allegrocl_nn2"></A>17.1 Basics</H2>
-<H3><A name="Allegrocl_nn3"></A>17.1.1 Running SWIG</H3>
+<H2><A name="Allegrocl_nn2">18.1 Basics</A></H2>
+<H3><A name="Allegrocl_nn3">18.1.1 Running SWIG</A></H3>
<P> If you're reading this, you must have some library you need to
generate an interface for. In order for SWIG to do this work, however,
it needs a bit of information about how it should go about creating
lisp, you will also need to link in the Allegro shared library. The
library you create from the C++ wrapper will be what you then load into
Allegro CL.</P>
-<H3><A name="Allegrocl_nn4"></A>17.1.2 Command Line Options</H3>
+<H3><A name="Allegrocl_nn4">18.1.2 Command Line Options</A></H3>
<P> There are three Allegro CL specific command-line option:</P>
<DIV class="shell">
<PRE>
-identifier-converter [name] - Binds the variable swig:*swig-identifier-convert*
in the generated .cl file to <TT>name</TT>.
- This function is used to generate symbols
- for the lisp side of the interface.
+ This function is used to generate symbols
+ for the lisp side of the interface.
-cwrap - [default] Generate a .cxx file containing C wrapper function when
wrapping C code. The interface generated is similar to what is
- done for C++ code.
+ done for C++ code.
-nocwrap - Explicitly turn off generation of .cxx wrappers for C code. Reasonable
for modules with simple interfaces. Can not handle all legal enum
- and constant constructs, or take advantage of SWIG customization features.
+ and constant constructs, or take advantage of SWIG customization features.
-isolate - With this command-line argument, all lisp helper functions are defined
in a unique package named <TT>swig.<module-name></TT> rather than
- <TT>swig</TT>. This prevents conflicts when the module is
- intended to be used with other swig generated interfaces that may,
- for instance, make use of different identifier converters.
+ <TT>swig</TT>. This prevents conflicts when the module is
+ intended to be used with other swig generated interfaces that may,
+ for instance, make use of different identifier converters.
</PRE>
</DIV>
<P> See <A href="#Allegrocl_nn47">Section 17.5 Identifier converter
functions</A> for more details.</P>
-<H3><A name="Allegrocl_nn5"></A>17.1.3 Inserting user code into
- generated files</H3>
+<H3><A name="Allegrocl_nn5">18.1.3 Inserting user code into generated
+ files</A></H3>
<P> It is often necessary to include user-defined code into the
automatically generated interface files. For example, when building a
C++ interface, example_wrap.cxx will likely not compile unless you add
</UL>
<P> Note that the block <TT>%{ ... %}</TT> is effectively a shortcut for
<TT>%insert("header") %{ ... %}</TT>.</P>
-<H2><A name="Allegrocl_nn6"></A>17.2 Wrapping Overview</H2>
+<H2><A name="Allegrocl_nn6">18.2 Wrapping Overview</A></H2>
<P> New users to SWIG are encouraged to read <A href="#SWIG">SWIG Basics</A>
, and <A href="#SWIGPlus">SWIG and C++</A>, for those interested in
generating an interface to C++.</P>
-<H3><A name="Allegrocl_nn7"></A>17.2.1 Function Wrapping</H3>
+<H3><A name="Allegrocl_nn7">18.2.1 Function Wrapping</A></H3>
<P> Writing lisp code that directly invokes functions at the foreign
function interface level can be cumbersome. Data must often be
translated between lisp and foreign types, data extracted from objects,
| Foreign Code | What we're generating an interface to.
|______________|
|
- |
+ |
_______v______
| | (foreign side)
| Wrapper code | extern "C" wrappers calling C++
| FFI Layer | Low level lisp interface. ff:def-foreign-call,
|______________| ff:def-foreign-variable
|
- +----------------------------
+ +----------------------------
_______v______ _______v______
| | | | (lisp side)
| Defuns | | Defmethods | wrapper for overloaded
|______________| |______________| functions or those with
(lisp side) | defaulted arguments
- Wrapper for non-overloaded |
- functions and methods _______v______
- | | (lisp side)
- | Defuns | dispatch function
- |______________| to overloads based
- on arity
+ Wrapper for non-overloaded |
+ functions and methods _______v______
+ | | (lisp side)
+ | Defuns | dispatch function
+ |______________| to overloads based
+ on arity
</PRE>
</DIV>
-<H3><A name="Allegrocl_nn8"></A>17.2.2 Foreign Wrappers</H3>
+<H3><A name="Allegrocl_nn8">18.2.2 Foreign Wrappers</A></H3>
<P> These wrappers are as generated by SWIG default. The types of
function parameters can be transformed in place using the CTYPE
typemap. This is use for converting pass-by-value parameters to
pass-by-reference where necessary. All wrapper parameters are then
bound to local variables for possible transformation of values (see LIN
typemap). Return values can be transformed via the OUT typemap.</P>
-<H3><A name="Allegrocl_nn9"></A>17.2.3 FFI Wrappers</H3>
+<H3><A name="Allegrocl_nn9">18.2.3 FFI Wrappers</A></H3>
<P> These are the generated ff:def-foreign-call forms. No typemaps are
applicable to this layer, but the <TT>%ffargs</TT> directive is
available for use in .i files, to specify which keyword arguments
<P> Is the only default value specified in <TT>allegrocl.swg</TT> to
force the muffling of warnings about automatic string conversion when
defining ff:def-foreign-call's.</P>
-<H3><A name="Allegrocl_nn10"></A>17.2.4 Non-overloaded Defuns</H3>
+<H3><A name="Allegrocl_nn10">18.2.4 Non-overloaded Defuns</A></H3>
<P> These are simple defuns. There is no typechecking of arguments.
Parameters are bound to local variables for possible transformation of
values, such as pulling values out of instance slots or allocating
These arguments are then passed to the foreign-call (where typechecking
may occur). The return value from this function can be manipulated via
the <TT>lout</TT> typemap.</P>
-<H3><A name="Allegrocl_nn11"></A>17.2.5 Overloaded Defuns</H3>
+<H3><A name="Allegrocl_nn11">18.2.5 Overloaded Defuns</A></H3>
<P> In the case of overloaded functions, mulitple layers are generated.
First, all the overloads for a given name are separated out into groups
based on arity, and are wrapped in defmethods. Each method calls a
appropriate generic-function based on arity. This provides a single
functional interface to all overloads. The return value from this
function can be manipulated via the <TT>lout</TT> typemap.</P>
-<H3><A name="Allegrocl_nn12"></A>17.2.6 What about constant and variable
- access?</H3>
+<H3><A name="Allegrocl_nn12">18.2.6 What about constant and variable
+ access?</A></H3>
<P> Along with the described functional layering, when creating a .cxx
wrapper, this module will generate getter and--if not
immutable--setter, functions for variables and constants. If the
ff:def-foreign-variable</TT> forms will be generated for accessing
constants and global variables. These, along with the <TT>defuns</TT>
listed above are the intended API for calling into the foreign module.</P>
-<H3><A name="Allegrocl_nn13"></A>17.2.7 Object Wrapping</H3>
+<H3><A name="Allegrocl_nn13">18.2.7 Object Wrapping</A></H3>
<P> All non-primitive types (Classes, structs, unions, and typedefs
involving same) have a corresponding foreign-type defined on the lisp
side via ff:def-foreign-type.</P>
legally be passed and the pointer to the C++ object automatically
extracted. This is a natural feature of Allegro's foreign function
interface.</P>
-<H2><A name="Allegrocl_nn14"></A>17.3 Wrapping Details</H2>
+<H2><A name="Allegrocl_nn14">18.3 Wrapping Details</A></H2>
<P> In this section is described how particular C/C++ constructs are
translated into lisp.</P>
-<H3><A name="Allegrocl_nn15"></A>17.3.1 Namespaces</H3>
+<H3><A name="Allegrocl_nn15">18.3.1 Namespaces</A></H3>
<P> C++ namespaces are translated into Lisp packages by SWIG. The Global
namespace is mapped to a package named by the <TT>%module</TT>
directive or the <TT>-module</TT> command-line argument. Further
toplevel modules package</B>. This may lead to confusion if, for
example, the current package is <TT>foo.car.tires</TT> and you attempt
to use a common-lisp function such as <TT>(car '(1 2 3)</TT>.</P>
-<H3><A name="Allegrocl_nn16"></A>17.3.2 Constants</H3>
+<H3><A name="Allegrocl_nn16">18.3.2 Constants</A></H3>
<P> Constants, as declared by the preprocessor #define macro or SWIG <TT>
-%constant</TT> directive, are included in SWIGs parse tree when it can
+%constant</TT> directive, are included in SWIG's parse tree when it can
be determined that they are, or could be reduced to, a literal value.
Such values are translated into defconstant forms in the generated lisp
wrapper when the -nocwrap command-line options is used. Else, wrapper
</DIV>
<P> Users are cautioned to get to know their constants before use, or
not use the <TT>-nocwrap</TT> command-line option.</P>
-<H3><A name="Allegrocl_nn17"></A>17.3.3 Variables</H3>
+<H3><A name="Allegrocl_nn17">18.3.3 Variables</A></H3>
<P> For C wrapping, a def-foreign-variable call is generated for access
to global variables.</P>
<P> When wrapping C++ code, both global and member variables, getter
3.0
</PRE>
</DIV>
-<H3><A name="Allegrocl_nn18"></A>17.3.4 Enumerations</H3>
+<H3><A name="Allegrocl_nn18">18.3.4 Enumerations</A></H3>
<P> In C, an enumeration value is an integer value, while in C++ an
enumeration value is implicitly convertible to an integer value, but
- can also be distinguished by it's enum type. For each enum declaration
- a def-foreign-type is generated, assigning the enum a default type of
+ can also be distinguished by its enum type. For each enum declaration a
+ def-foreign-type is generated, assigning the enum a default type of
:int. Users may adjust the foreign type of enums via SWIG <TT>typemaps</TT>
.</P>
<P> Enum values are a bit trickier as they can be initialized using any
being necessary to probe into foreign space to retrieve enum values.
When generating a .cxx wrapper file, a more general solution is
employed. A wrapper variable is created in the module_wrap.cxx file,
- and a ff:def-foreign-variable call is generated to retrieve it's value
+ and a ff:def-foreign-variable call is generated to retrieve its value
into lisp.</P>
<P>For example, the following header file<DIV class="code">enum.h:
<PRE>
-enum COL { RED, GREEN, BLUE };
+enum COL { RED, GREEN, BLUE };
enum FOO { FOO1 = 10, FOO2, FOO3 };
</PRE>
</DIV></P>
</PRE>
</DIV>
-<H3><A name="Allegrocl_nn19"></A>17.3.5 Arrays</H3>
+<H3><A name="Allegrocl_nn19">18.3.5 Arrays</A></H3>
<P> One limitation in the Allegro CL foreign-types module, is that,
without macrology, expressions may not be used to specify the
dimensions of an array declaration. This is not a horrible drawback
(make-instance 'ff:foreign-pointer :foreign-address (swig-ff-call)))
</PRE>
</DIV>
-<H3><A name="Allegrocl_nn20"></A>17.3.6 Classes and Structs and Unions
- (oh my!)</H3>
-<H4><A name="Allegrocl_nn21"></A>17.3.6.1 CLOS wrapping of</H4>
+<H3><A name="Allegrocl_nn20">18.3.6 Classes and Structs and Unions (oh
+ my!)</A></H3>
+<H4><A name="Allegrocl_nn21">18.3.6.1 CLOS wrapping of</A></H4>
<P> Classes, unions, and structs are all treated the same way by the
interface generator. For any of these objects, a def-foreign-type and a
defclass form are generated. For every function that returns an object
returned in an instance of the appropriate class. This makes it much
easier to write and debug code than if pointers were passed around as a
jumble of integer values.</P>
-<H4><A name="Allegrocl_nn22"></A>17.3.6.2 CLOS Inheritance</H4>
+<H4><A name="Allegrocl_nn22">18.3.6.2 CLOS Inheritance</A></H4>
<P> The CLOS class schema generated by the interface mirrors the
inheritance of the classes in foreign code, with the ff:foreign-pointer
class at its root. ff:foreign-pointer is a thin wrapper for pointers
- that is made available by the foreign function interface. It's key
+ that is made available by the foreign function interface. Its key
benefit is that it may be passed as an argument to any
ff:def-foreign-call that is expecting a pointer as the parameter.</P>
-<H4><A name="Allegrocl_nn23"></A>17.3.6.3 Member fields and functions</H4>
+<H4><A name="Allegrocl_nn23">18.3.6.3 Member fields and functions</A></H4>
<P> All public fields will have accessor getter/setter functions
generated for them, as appropriate. All public member functions will
have wrapper functions generated.</P>
private</TT> or <TT>protected</TT>), because the C++ compiler won't
allow the wrapper functions to access such fields. Likewise, the
interface does nothing for <TT>friend</TT> directives,</P>
-<H4><A name="Allegrocl_nn24"></A>17.3.6.4 Why not directly access C++
- classes using foreign types?</H4>
+<H4><A name="Allegrocl_nn24">18.3.6.4 Why not directly access C++
+ classes using foreign types?</A></H4>
<P> The def-foreign-type generated by the SWIG interface is currently
incomplete. We can reliably generate the object layout of simple
structs and unions; they can be allocated via ff:allocate-fobject, and
result, it is recommended that users of any generated interface not
attempt to access C++ instances via the foreign type system, but
instead use the more robust wrapper functions.</P>
-<H3><A name="Allegrocl_nn25"></A>17.3.7 Templates</H3>
-<H4><A name="Allegrocl_nn26"></A>17.3.7.1 Generating wrapper code for
- templates</H4>
+<H3><A name="Allegrocl_nn25">18.3.7 Templates</A></H3>
+<H4><A name="Allegrocl_nn26">18.3.7.1 Generating wrapper code for
+ templates</A></H4>
<P> SWIG provides support for dealing with templates, but by default, it
will not generate any member variable or function wrappers for
templated classes. In order to create these wrappers, you need to
explicitly tell SWIG to instantiate them. This is done via the <A href="#SWIGPlus_nn30">
<TT>%template</TT></A> directive.</P>
-<H4><A name="Allegrocl_nn27"></A>17.3.7.2 Implicit Template
- instantiation</H4>
+<H4><A name="Allegrocl_nn27">18.3.7.2 Implicit Template instantiation</A>
+</H4>
<P> While no wrapper code is generated for accessing member variables,
or calling member functions, type code is generated to include these
templated classes in the foreign-type and CLOS class schema.</P>
-<H3><A name="Allegrocl_nn28"></A>17.3.8 Typedef, Templates, and Synonym
- Types</H3>
+<H3><A name="Allegrocl_nn28">18.3.8 Typedef, Templates, and Synonym
+ Types</A></H3>
<P> In C/C++ it is possible, via typedef, to have many names refer to
the same <TT>type</TT>. In general, this is not a problem, though it
can lead to confusion. Assume the below C++ header file:</P>
synonym>
</PRE>
</DIV>
-<H4><A name="Allegrocl_nn29"></A>17.3.8.1 Choosing a primary type</H4>
+<H4><A name="Allegrocl_nn29">18.3.8.1 Choosing a primary type</A></H4>
<P> The choice of a primary type is selected by the following criteria
from a set of synonym types.</P>
<UL>
<LI> For all other sets of synonymous types, the synonym which is parsed
first becomes the primary type.</LI>
</UL>
-<H3><A name="Allegrocl_nn30"></A>17.3.9 Function overloading/Parameter
- defaulting</H3>
+<H3><A name="Allegrocl_nn30">18.3.9 Function overloading/Parameter
+ defaulting</A></H3>
<P> For each possible argument combination, a distinct wrapper function
is created in the .cxx file. On the Lisp side, a generic functions is
defined for each possible arity the overloaded/defaulted call may have.
overload>
</PRE>
</DIV>
-<H3><A name="Allegrocl_nn31"></A>17.3.10 Operator wrapping and Operator
- overloading</H3>
+<H3><A name="Allegrocl_nn31">18.3.10 Operator wrapping and Operator
+ overloading</A></H3>
<P> Wrappers to defined C++ Operators are automatically renamed, using <TT>
%rename</TT>, to the following defaults:</P>
<DIV class="code">
<PRE>
/* name conversion for overloaded operators. */
#ifdef __cplusplus
-%rename(__add__) *::operator+;
-%rename(__pos__) *::operator+();
-%rename(__pos__) *::operator+() const;
+%rename(__add__) *::operator+;
+%rename(__pos__) *::operator+();
+%rename(__pos__) *::operator+() const;
-%rename(__sub__) *::operator-;
-%rename(__neg__) *::operator-() const;
-%rename(__neg__) *::operator-();
+%rename(__sub__) *::operator-;
+%rename(__neg__) *::operator-() const;
+%rename(__neg__) *::operator-();
-%rename(__mul__) *::operator*;
-%rename(__deref__) *::operator*();
-%rename(__deref__) *::operator*() const;
+%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(__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(__not__) *::operator!();
+%rename(__not__) *::operator!() const;
-%rename(__assign__) *::operator=;
+%rename(__assign__) *::operator=;
%rename(__add_assign__) *::operator+=;
-%rename(__sub_assign__) *::operator-=;
-%rename(__mul_assign__) *::operator*=;
-%rename(__div_assign__) *::operator/=;
-%rename(__mod_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__) *::operator<<;
%rename(__lshift_assign__) *::operator<<=;
-%rename(__rshift__) *::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(__eq__) *::operator==;
+%rename(__ne__) *::operator!=;
+%rename(__lt__) *::operator<;
+%rename(__gt__) *::operator>;
+%rename(__lte__) *::operator<=;
+%rename(__gte__) *::operator>=;
-%rename(__and__) *::operator&&;
-%rename(__or__) *::operator||;
+%rename(__and__) *::operator&&;
+%rename(__or__) *::operator||;
-%rename(__preincr__) *::operator++();
-%rename(__postincr__) *::operator++(int);
-%rename(__predecr__) *::operator--();
-%rename(__postdecr__) *::operator--(int);
+%rename(__preincr__) *::operator++();
+%rename(__postincr__) *::operator++(int);
+%rename(__predecr__) *::operator--();
+%rename(__postdecr__) *::operator--(int);
-%rename(__comma__) *::operator,();
-%rename(__comma__) *::operator,() const;
+%rename(__comma__) *::operator,();
+%rename(__comma__) *::operator,() const;
%rename(__member_ref__) *::operator->;
%rename(__member_func_ref__) *::operator->*;
-%rename(__funcall__) *::operator();
-%rename(__aref__) *::operator[];
+%rename(__funcall__) *::operator();
+%rename(__aref__) *::operator[];
</PRE>
</DIV>
<P> Name mangling occurs on all such renamed identifiers, so that
opoverload>
</PRE>
</DIV>
-<H3><A name="Allegrocl_nn32"></A>17.3.11 Varargs</H3>
+<H3><A name="Allegrocl_nn32">18.3.11 Varargs</A></H3>
<P> Variable length argument lists are not supported, by default. If
such a function is encountered, a warning will generated to stderr.
Varargs are supported via the SWIG <TT>%varargs</TT> directive. This
directive allows you to specify a (finite) argument list which will be
inserted into the wrapper in place of the variable length argument
- indicator. As an example, consider the function <TT>printf()</TT>. It's
+ indicator. As an example, consider the function <TT>printf()</TT>. Its
declaration would appear as follows:</P>
<P> See the following section on <A href="#Varargs">Variable Length
arguments</A> provides examples on how <TT>%varargs</TT> can be used,
along with other ways such functions can be wrapped.</P>
-<H3><A name="Allegrocl_nn33"></A>17.3.12 C++ Exceptions</H3>
+<H3><A name="Allegrocl_nn33">18.3.12 C++ Exceptions</A></H3>
<P> Each C++ wrapper includes a handler to catch any exceptions that may
be thrown while in foreign code. This helps prevent simple C++ errors
from killing the entire lisp process. There is currently no mechanism
to have these exceptions forwarded to the lisp condition system, nor
has any explicit support of the exception related SWIG typemaps been
implemented.</P>
-<H3><A name="Allegrocl_nn34"></A>17.3.13 Pass by value, pass by
- reference</H3>
+<H3><A name="Allegrocl_nn34">18.3.13 Pass by value, pass by reference</A>
+</H3>
<P> Allegro CL does not support the passing of non-primitive foreign
structures by value. As a result, SWIG must automatically detect and
convert function parameters and return values to pointers whenever
necessary. This is done via the use of <TT>typemaps</TT>, and should
not require any fine tuning by the user, even for newly defined types.</P>
-<H2><A name="Allegrocl_nn35"></A>17.4 Typemaps</H2>
+<H2><A name="Allegrocl_nn35">18.4 Typemaps</A></H2>
<P> SWIG Typemaps provide a powerful tool for automatically generating
code to handle various menial tasks required of writing an interface to
foreign code. The purpose of this section is to describe each of the
typemaps used by the Allegro CL module. Please read the chapter on <A href="#Typemaps">
Typemaps</A> for more information.</P>
-<H3><A name="Allegrocl_nn36"></A>17.4.1 Code Generation in the C++
- Wrapper</H3>
+<H3><A name="Allegrocl_nn36">18.4.1 Code Generation in the C++ Wrapper</A>
+</H3>
<P> Every C++ wrapper generated by SWIG takes the following form:</P>
<DIV class="diagram">
<PRE>
}
</PRE>
</DIV>
-<H4><A name="Allegrocl_nn37"></A>17.4.1.1 IN Typemap</H4>
+<H4><A name="Allegrocl_nn37">18.4.1.1 IN Typemap</A></H4>
<P> the <TT>in</TT> typemap is used to generate code to convert
parameters passed to C++ wrapper functions into the arguments desired
for the call being wrapped. That is, it fills in the code for the <TT>
%typemap(in) SWIGTYPE "$1 = *$input;";
</PRE>
</DIV>
-<H4><A name="Allegrocl_nn38"></A>17.4.1.2 OUT Typemap</H4>
+<H4><A name="Allegrocl_nn38">18.4.1.2 OUT Typemap</A></H4>
<P> The <TT>out</TT> typemap is used to generate code to form the return
value of the wrapper from the return value of the wrapped function.
This code is placed in the <convert and bind result to lresult> section
- of the above code diagram. It's default mapping is as follows:</P>
+ of the above code diagram. Its default mapping is as follows:</P>
<DIV class="code">
<PRE>
%typemap(out) bool "$result = (int)$1;";
%typemap(out) SWIGTYPE "$result = new $1_type($1);";
</PRE>
</DIV>
-<H4><A name="Allegrocl_nn39"></A>17.4.1.3 CTYPE Typemap</H4>
+<H4><A name="Allegrocl_nn39">18.4.1.3 CTYPE Typemap</A></H4>
<P> This typemap is not used for code generation, but purely for the
transformation of types in the parameter list of the wrapper function.
- It's primary use is to handle by-value to by-reference conversion in
- the wrappers parameter list. Its default settings are:</P>
+ Its primary use is to handle by-value to by-reference conversion in the
+ wrappers parameter list. Its default settings are:</P>
<DIV class="code">
<PRE>
%typemap(ctype) bool "int";
interface generator. SWIG also implements a number of other typemaps
that can be used for generating code in the C/C++ wrappers. You can
read about these <A href="#Typemaps_nn25">common typemaps</A> here.</P>
-<H3><A name="Allegrocl_nn40"></A>17.4.2 Code generation in Lisp wrappers</H3>
+<H3><A name="Allegrocl_nn40">18.4.2 Code generation in Lisp wrappers</A></H3>
<P> A number of custom typemaps have also been added to facilitate the
generation of code in the lisp side of the interface. These are
described below. The basic code generation structure is applied as a
necessary. Users writing their own typemaps should do likewise. See the
explanation in the last paragraph of <A href="#Allegrocl_nn15">16.3.1
Namespaces</A> for details.</P>
-<H4><A name="Allegrocl_nn41"></A>17.4.2.1 LIN Typemap</H4>
+<H4><A name="Allegrocl_nn41">18.4.2.1 LIN Typemap</A></H4>
<P> The LIN typemap allows for the manipulating the lisp objects passed
as arguments to the wrapping defun before passing them to the foreign
function call. For example, when passing lisp strings to foreign code,
</UL>
<DIV class="code">
<PRE>
-%typemap(lin) SWIGTYPE "(cl:let (($out $in))\n $body)";
+%typemap(lin) SWIGTYPE "(cl:let (($out $in))\n $body)";
</PRE>
</DIV>
-<H4><A name="Allegrocl_nn42"></A>17.4.2.2 LOUT Typemap</H4>
+<H4><A name="Allegrocl_nn42">18.4.2.2 LOUT Typemap</A></H4>
<P> The LOUT typemap is the means by which we effect the wrapping of
foreign pointers in CLOS instances. It is applied after all LIN
typemaps, and immediately before the actual foreign-call.</P>
ACL_result)";
</PRE>
</DIV>
-<H4><A name="Allegrocl_nn43"></A>17.4.2.3 FFITYPE Typemap</H4>
+<H4><A name="Allegrocl_nn43">18.4.2.3 FFITYPE Typemap</A></H4>
<P> The FFITYPE typemap works as a helper for a body of code that
converts C/C++ type specifications into Allegro CL foreign-type
specifications. These foreign-type specifications appear in
%typemap(ffitype) SWIGTYPE & "(* :void)";
</PRE>
</DIV>
-<H4><A name="Allegrocl_nn44"></A>17.4.2.4 LISPTYPE Typemap</H4>
+<H4><A name="Allegrocl_nn44">18.4.2.4 LISPTYPE Typemap</A></H4>
<P> This is another type only transformation map, and is used to provide
the lisp-type, which is the optional third argument in argument
specifier in a ff:def-foreign-call form. Specifying a lisp-type allows
%typemap(lisptype) signed char "cl:integer";
</PRE>
</DIV>
-<H4><A name="Allegrocl_nn45"></A>17.4.2.5 LISPCLASS Typemap</H4>
+<H4><A name="Allegrocl_nn45">18.4.2.5 LISPCLASS Typemap</A></H4>
<P> The LISPCLASS typemap is used to generate the method signatures for
the generic-functions which wrap overloaded functions and functions
with defaulted arguments. The default entries are:</P>
%typemap(lispclass) char * "cl:string";
</PRE>
</DIV>
-<H3><A name="Allegrocl_nn46"></A>17.4.3 Modifying SWIG behavior using
- typemaps</H3>
+<H3><A name="Allegrocl_nn46">18.4.3 Modifying SWIG behavior using
+ typemaps</A></H3>
<P> The following example shows how we made use of the above typemaps to
add support for the wchar_t type.</P>
<DIV class="code">
%typemap(lispclass) wchar_t* "cl:string";
</PRE>
</DIV>
-<H2><A name="Allegrocl_nn47"></A>17.5 Identifier Converter functions</H2>
-<H3><A name="Allegrocl_nn48"></A>17.5.1 Creating symbols in the lisp
- environment</H3>
+<H2><A name="Allegrocl_nn47">18.5 Identifier Converter functions</A></H2>
+<H3><A name="Allegrocl_nn48">18.5.1 Creating symbols in the lisp
+ environment</A></H3>
<P> Various symbols must be generated in the lisp environment to which
class definitions, functions, constants, variables, etc. must be bound.
Rather than force a particular convention for naming these symbols, an
reference. It is therefore expected that the identifier-converter
function reliably return the same (eq) symbol given the same set of
arguments.</P>
-<H3><A name="Allegrocl_nn49"></A>17.5.2 Existing identifier-converter
- functions</H3>
+<H3><A name="Allegrocl_nn49">18.5.2 Existing identifier-converter
+ functions</A></H3>
<P>Two basic identifier routines have been defined.</P>
-<H4><A name="Allegrocl_nn50"></A>17.5.2.1 identifier-convert-null</H4>
+<H4><A name="Allegrocl_nn50">18.5.2.1 identifier-convert-null</A></H4>
<P> No modification of the identifier string is performed. Based on
other arguments, the identifier may be concatenated with other strings,
from which a symbol will be created.</P>
-<H4><A name="Allegrocl_nn51"></A>17.5.2.2 identifier-convert-lispify</H4>
+<H4><A name="Allegrocl_nn51">18.5.2.2 identifier-convert-lispify</A></H4>
<P> All underscores in the identifier string are converted to hyphens.
Otherwise, identifier-convert-lispify performs the same symbol
transformations.</P>
-<H4><A name="Allegrocl_nn52"></A>17.5.2.3 Default identifier to symbol
- conversions</H4>
+<H4><A name="Allegrocl_nn52">18.5.2.3 Default identifier to symbol
+ conversions</A></H4>
<P> Check the definitions of the above two default identifier-converters
in <TT>Lib/allegrocl/allegrocl.swg</TT> for default naming conventions.</P>
-<H3><A name="Allegrocl_nn53"></A>17.5.3 Defining your own
- identifier-converter</H3>
+<H3><A name="Allegrocl_nn53">18.5.3 Defining your own
+ identifier-converter</A></H3>
<P> A user-defined identifier-converter function should conform to the
following specification:</P>
<DIV class="targetlang">
<P>The <TT>ID</TT> argument is a string representing an identifier in
the foreign environment.</P>
<P> The :type keyword argument provides more information on the type of
- identifier. It's value is a symbol. This allows the
- identifier-converter to apply different heuristics when mapping
- different types of identifiers to symbols. SWIG will generate calls to
- your identifier-converter using the following types.</P>
+ identifier. Its value is a symbol. This allows the identifier-converter
+ to apply different heuristics when mapping different types of
+ identifiers to symbols. SWIG will generate calls to your
+ identifier-converter using the following types.</P>
<UL>
<LI>:class - names a CLOS class.</LI>
<LI>:constant - names a defconstant</LI>
non-nil, it indicates that the current identifier has scope in the
specified class.</P>
<P> The :arity keyword argument only appears in swig:swig-defmethod
- forms generated for overloaded functions. It's value is an integer
+ forms generated for overloaded functions. Its value is an integer
indicating the number of arguments passed to the routine indicated by
this identifier.</P>
-<H3><A name="Allegrocl_nn54"></A>17.5.4 Instructing SWIG to use a
- particular identifier-converter</H3>
+<H3><A name="Allegrocl_nn54">18.5.4 Instructing SWIG to use a particular
+ identifier-converter</A></H3>
<P> By default, SWIG will use identifier-converter-null. To specify
another convert function, use the <TT>-identifier-converter</TT>
command-line argument. The value should be a string naming the function
% swig -allegrocl -c++ -module mymodule -identifier-converter my-identifier-converter
</PRE>
</DIV><HR NOSHADE>
-<H1><A name="Android"></A>18 SWIG and Android</H1>
+<H1><A name="Android">19 SWIG and Android</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
</DIV>
<!-- INDEX -->
<P> This chapter describes SWIG's support of Android.</P>
-<H2><A name="Android_overview"></A>18.1 Overview</H2>
+<H2><A name="Android_overview">19.1 Overview</A></H2>
<P> The Android chapter is fairly short as support for Android is the
same as for Java, where the Java Native Interface (JNI) is used to call
- from Android Java into C or C++ compiled code. Everything in the <A href="Java.html">
+ from Android Java into C or C++ compiled code. Everything in the <A href="#Java">
Java chapter</A> applies to generating code for access from Android Java
code. This chapter contains a few Android specific notes and examples.</P>
-<H2><A name="Android_examples"></A>18.2 Android examples</H2>
-<H3><A name="Android_examples_intro"></A>18.2.1 Examples introduction</H3>
+<H2><A name="Android_examples">19.2 Android examples</A></H2>
+<H3><A name="Android_examples_intro">19.2.1 Examples introduction</A></H3>
<P> The examples require the <A href="http://developer.android.com/sdk/index.html">
-Android SDK</A> and <A href="http://developer.android.com/sdk/ndk/index.html">
+Android SDK</A> and <A href="http://developer.android.com/tools/sdk/ndk/index.html">
Android NDK</A> which can be installed as per instructions in the links.
The Eclipse version is not required for these examples as just the
command line tools are used (shown for Linux as the host, but Windows
<PRE>
$ export PATH=$HOME/android/android-sdk-linux_x86/tools:$HOME/android/android-sdk-linux_x86/platform-tools:$HOME/android/android-ndk-r6b:$PATH
$ mkdir AndroidApps
-$ cd AnrdoidApps
+$ cd AndroidApps
</PRE>
</DIV>
<P> The examples use a target id of 1. This might need changing
<P> The following examples are shipped with SWIG under the
Examples/android directory and include a Makefile to build and install
each example.</P>
-<H3><A name="Android_example_simple"></A>18.2.2 Simple C example</H3>
+<H3><A name="Android_example_simple">19.2.2 Simple C example</A></H3>
<P> This simple C example shows how to call a C function as well as read
and modify a global variable. First we'll create and build a pure Java
Android app. Afterwards the JNI code will be generated by SWIG and
<PRE>
$ adb devices
List of devices attached
-A32-6DBE0001-9FF80000-015D62C3-02018028 device
+A32-6DBE0001-9FF80000-015D62C3-02018028 device
</PRE>
</DIV>
<P> This means you are now ready to install the application...</P>
<PRE>
$ adb install bin/SwigSimple-debug.apk
95 KB/s (4834 bytes in 0.049s)
- pkg: /data/local/tmp/SwigSimple-debug.apk
+ pkg: /data/local/tmp/SwigSimple-debug.apk
Success
</PRE>
</DIV>
below, showing the result of calls into the C code:</P>
<CENTER><IMG alt="Android screenshot of SwigSimple example" HEIGHT="400" src="android-simple.png"
WIDTH="256"></CENTER>
-<H3><A name="Android_example_class"></A>18.2.3 C++ class example</H3>
+<H3><A name="Android_example_class">19.2.3 C++ class example</A></H3>
<P> The steps for calling C++ code are almost identical to those in the
previous C code example. All the steps required to compile and use a
simple hierarchy of classes for shapes are shown in this example.</P>
}
virtual ~Shape() {
nshapes--;
- };
+ }
double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
</PRE>
</DIV>
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
</PRE>
<P> Run the app to see the result of calling the C++ code from Java:</P>
<CENTER><IMG alt="Android screenshot of SwigClass example" HEIGHT="400" src="android-class.png"
WIDTH="256"></CENTER>
-<H3><A name="Android_examples_other"></A>18.2.4 Other examples</H3>
+<H3><A name="Android_examples_other">19.2.4 Other examples</A></H3>
<P> The Examples/android directory contains further examples which can
be run and installed in a similar manner to the previous two examples.</P>
<P> Note that the 'extend' example is demonstrates the directors
feature. Normally C++ exception handling and the STL is not available
by default in the version of g++ shipped with Android, but this example
turns these features on as described in the next section.</P>
-<H2><A name="Android_stl"></A>18.3 C++ STL</H2>
+<H2><A name="Android_stl">19.3 C++ STL</A></H2>
<P> Should the C++ Standard Template Library (STL) be required, an <TT>
Application.mk</TT> file needs to be created in the same directory as
the <TT>Android.mk</TT> directory containing information about the STL
APP_STL := gnustl_static
</PRE>
</DIV><HR NOSHADE>
-<H1><A name="CSharp"></A>19 SWIG and C#</H1>
+<H1><A name="CSharp">20 SWIG and C#</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<UL>
-<LI><A href="#CSharp_introduction">Introduction</A></LI>
+<LI><A href="#CSharp_introduction">Introduction</A>
+<UL>
+<LI><A href="#CSharp_introduction_swig2_compatibility">SWIG 2
+ Compatibility</A></LI>
+<LI><A href="#CSharp_commandline">Additional command line options</A></LI>
+</UL>
+</LI>
<LI><A href="#CSharp_differences_java">Differences to the Java module</A>
</LI>
<LI><A href="#CSharp_void_pointers">Void pointers</A></LI>
<LI><A href="#CSharp_director_caveats">Director caveats</A></LI>
</UL>
</LI>
-<LI><A href="#CSharp_multiple_modules">Multiples modules</A></LI>
+<LI><A href="#CSharp_multiple_modules">Multiple modules</A></LI>
<LI><A href="#CSharp_typemap_examples">C# Typemap examples</A>
<UL>
<LI><A href="#CSharp_memory_management_member_variables">Memory
</UL>
</DIV>
<!-- INDEX -->
-<H2><A name="CSharp_introduction"></A>19.1 Introduction</H2>
+<H2><A name="CSharp_introduction">20.1 Introduction</A></H2>
<P> The purpose of the C# module is to offer an automated way of
accessing existing C/C++ code from .NET languages. The wrapper code
implementation uses C# and the Platform Invoke (PInvoke) interface to
required. The <A href="http://msdn.microsoft.com">Microsoft Developer
Network (MSDN)</A> has a good reference guide in a section titled
"Interop Marshaling". Monodoc, available from the Mono project, has a
- very useful section titled <A href="http://www.mono-project.com/Interop_with_Native_Libraries">
+ very useful section titled <A href="http://www.mono-project.com/docs/advanced/pinvoke/">
Interop with native libraries</A>.</P>
-<H2><A name="CSharp_differences_java"></A>19.2 Differences to the Java
- module</H2>
+<H3><A name="CSharp_introduction_swig2_compatibility">20.1.1 SWIG 2
+ Compatibility</A></H3>
+<P> In order to minimize name collisions between names generated based
+ on input to SWIG and names used in the generated code from the .NET
+ framework, SWIG 3 fully qualifies the use of all .NET types.
+ Furthermore, SWIG 3 avoids <TT>using</TT> directives in generated code.
+ This breaks backwards compatibility with typemaps, pragmas, etc written
+ for use with SWIG 2 that assume the presence of <TT>using System;</TT>
+ or <TT>using System.Runtime.InteropServices;</TT> directives in the
+ intermediate class imports, module imports, or proxy imports. SWIG 3
+ supports backwards compatibility though the use of the <TT>SWIG2_CSHARP</TT>
+ macro. If <TT>SWIG2_CSHARP</TT> is defined, SWIG 3 generates <TT>using</TT>
+ directives in the intermediate class, module class, and proxy class
+ code similar to those generated by SWIG 2. This can be done without
+ modifying any of the input code by passing the <TT>-DSWIG2_CSHARP</TT>
+ commandline parameter when executing <TT>swig</TT>.</P>
+<H3><A name="CSharp_commandline">20.1.2 Additional command line options</A>
+</H3>
+<P> The following table lists the additional commandline options
+ available for the C# module. They can also be seen by using:</P>
+<DIV class="code">
+<PRE>
+swig -csharp -help
+</PRE>
+</DIV>
+<TABLE summary="C# specific options">
+<TR><TH>C# specific options</TH></TR>
+<TR><TD>-dllimport <dl></TD><TD>Override DllImport attribute name to
+ <dl></TD></TR>
+<TR><TD>-namespace <nm></TD><TD>Generate wrappers into C# namespace <nm></TD>
+</TR>
+<TR><TD>-noproxy</TD><TD>Generate the low-level functional interface
+ instead of proxy classes</TD></TR>
+<TR><TD>-oldvarnames</TD><TD>Old intermediary method names for variable
+ wrappers</TD></TR>
+<TR><TD>-outfile <file></TD><TD>Write all C# into a single <file>
+ located in the output directory</TD></TR>
+</TABLE>
+<P> The -outfile option combines all the generated C# code into a single
+ output file instead of creating multiple C# files. The default, when
+ this option is not provided, is to generate separate .cs files for the
+ module class, intermediary class and each of the generated proxy and
+ type wrapper classes. Note that the file extension (.cs) will not be
+ automatically added and needs to be provided. Due to possible compiler
+ limits it is not advisable to use <TT>-outfile</TT> for large projects.</P>
+<H2><A name="CSharp_differences_java">20.2 Differences to the Java
+ module</A></H2>
<P> The C# module is very similar to the Java module, so until some more
complete documentation has been written, please use the <A href="#Java">
Java documentation</A> as a guide to using SWIG with C#. The C# module
javafinalize -> csfinalize
javadestruct -> csdestruct
javadestruct_derived -> csdestruct_derived
+javainterfacecode -> csinterfacecode
</PRE>
</DIV></LI>
<LI>
$javaclazzname -> $csclazzname
$javainput -> $csinput
$jnicall -> $imcall
+$javainterfacename -> $csinterfacename
+$&javainterfacename -> $&csinterfacename
+$*javainterfacename -> $*csinterfacename
</PRE>
</DIV></LI>
<LI>
char *</TT> could be marshalled in different ways,</P>
<DIV class="code">
<PRE>
-%typemap(imtype, out="IntPtr") char * "string"
+%typemap(imtype, out="global::System.IntPtr") char * "string"
char * function(char *);
</PRE>
</DIV>
resulting intermediary C# code is:</P>
<DIV class="code">
<PRE>
-public static extern IntPtr function(string jarg1);
+public static extern global::System.IntPtr function(string jarg1);
</PRE>
</DIV></LI>
<LI>
<DIV class="code">
<PRE>
%typemap(imtype,
- inattributes="[MarshalAs(UnmanagedType.LPStr)]",
- outattributes="[return: MarshalAs(UnmanagedType.LPStr)]") const char * "String"
+ inattributes="[global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPStr)]",
+ outattributes="[return: global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPStr)]") const char * "String"
const char * GetMsg() {}
void SetMsg(const char *msg) {}
<PRE>
class examplePINVOKE {
...
- [DllImport("example", EntryPoint="CSharp_GetMsg")]
- [return: MarshalAs(UnmanagedType.LPStr)]
+ [global::System.Runtime.InteropServices.DllImport("example", EntryPoint="CSharp_GetMsg")]
+ [return: global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPStr)]
public static extern String GetMsg();
- [DllImport("example", EntryPoint="CSharp_SetMsg")]
- public static extern void SetMsg([MarshalAs(UnmanagedType.LPStr)]String jarg1);
+ [global::System.Runtime.InteropServices.DllImport("example", EntryPoint="CSharp_SetMsg")]
+ public static extern void SetMsg([global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPStr)]String jarg1);
}
</PRE>
</DIV>
<DIV class="code">
<PRE>
[ThreadSafe]
-public class AClass : IDisposable {
+public class AClass : global::System.IDisposable {
...
[ThreadSafe(false)]
public AClass(double a) ...
shown below.</P>
<DIV class="code">
<PRE>
-%typemap(csattributes) Couleur "[System.ComponentModel.Description(\"Colours\")]"
-%csattributes Rouge "[System.ComponentModel.Description(\"Red\")]"
-%csattributes Vert "[System.ComponentModel.Description(\"Green\")]"
+%typemap(csattributes) Couleur "[global::System.ComponentModel.Description(\"Colours\")]"
+%csattributes Rouge "[global::System.ComponentModel.Description(\"Red\")]"
+%csattributes Vert "[global::System.ComponentModel.Description(\"Green\")]"
%inline %{
enum Couleur { Rouge, Orange, Vert };
%}
<P> which will result in the following C# enum:</P>
<DIV class="code">
<PRE>
-[System.ComponentModel.Description("Colours")]
+[global::System.ComponentModel.Description("Colours")]
public enum Couleur {
- [System.ComponentModel.Description("Red")]
+ [global::System.ComponentModel.Description("Red")]
Rouge,
Orange,
- [System.ComponentModel.Description("Green")]
+ [global::System.ComponentModel.Description("Green")]
Vert
}
</PRE>
automatic configuration of the example makefiles. Any one of the three
C# compilers (Portable.NET, Mono or Microsoft) can be detected from
within a Cygwin or Mingw environment if installed in your path.</P>
-<H2><A name="CSharp_void_pointers"></A>19.3 Void pointers</H2>
+<H2><A name="CSharp_void_pointers">20.3 Void pointers</A></H2>
<P> By default SWIG treats <TT>void *</TT> as any other pointer and
hence marshalls it as a type wrapper class called <TT>SWIGTYPE_p_void</TT>
. If you want to marshall with the .NET <TT>System.IntPtr</TT> type
void * f(void *v);
</PRE>
</DIV>
-<H2><A name="CSharp_arrays"></A>19.4 C# Arrays</H2>
+<H2><A name="CSharp_arrays">20.4 C# Arrays</A></H2>
<P> There are various ways to pass arrays from C# to C/C++. The default
wrapping treats arrays as pointers and as such simple type wrapper
classes are generated, eg <TT>SWIGTYPE_p_int</TT> when wrapping the C
arrays is to enhance or customise with one of the following three
approaches; namely the SWIG C arrays library, P/Invoke default array
marshalling or pinned arrays.</P>
-<H3><A name="CSharp_arrays_swig_library"></A>19.4.1 The SWIG C arrays
- library</H3>
+<H3><A name="CSharp_arrays_swig_library">20.4.1 The SWIG C arrays
+ library</A></H3>
<P> The C arrays library keeps all the array memory in the unmanaged
layer. The library is available to all language modules and is
documented in the <A href="#Library_carrays">carrays.i library</A>
example.print_array(c.cast()); // Pass to C
</PRE>
</DIV>
-<H3><A name="CSharp_arrays_pinvoke_default_array_marshalling"></A>19.4.2
- Managed arrays using P/Invoke default array marshalling</H3>
+<H3><A name="CSharp_arrays_pinvoke_default_array_marshalling">20.4.2
+ Managed arrays using P/Invoke default array marshalling</A></H3>
<P> In the P/Invoke default marshalling scheme, one needs to designate
whether the invoked function will treat a managed array parameter as
input, output, or both. When the function is invoked, the CLR allocates
use default marshalling for the arrays:</P>
<DIV class="code">
<PRE>
-[DllImport("example", EntryPoint="CSharp_myArrayCopy")]
-public static extern void myArrayCopy([In, MarshalAs(UnmanagedType.LPArray)]int[] jarg1,
- [Out, MarshalAs(UnmanagedType.LPArray)]int[] jarg2,
+[global::System.Runtime.InteropServices.DllImport("example", EntryPoint="CSharp_myArrayCopy")]
+public static extern void myArrayCopy([global::System.Runtime.InteropServices.In, global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPArray)]int[] jarg1,
+ [global::System.Runtime.InteropServices.Out, global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPArray)]int[] jarg2,
int jarg3);
</PRE>
</DIV>
<P> and intermediary class method</P>
<DIV class="code">
<PRE>
- [DllImport("example", EntryPoint="CSharp_myArraySwap")]
- public static extern void myArraySwap([In, Out, MarshalAs(UnmanagedType.LPArray)]int[] jarg1,
- [In, Out, MarshalAs(UnmanagedType.LPArray)]int[] jarg2,
+ [global::System.Runtime.InteropServices.DllImport("example", EntryPoint="CSharp_myArraySwap")]
+ public static extern void myArraySwap([global::System.Runtime.InteropServices.In, global::System.Runtime.InteropServices.Out, global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPArray)]int[] jarg1,
+ [global::System.Runtime.InteropServices.In, global::System.Runtime.InteropServices.Out, global::System.Runtime.InteropServices.MarshalAs(UnmanagedType.LPArray)]int[] jarg2,
int jarg3);
</PRE>
</DIV>
-<H3><A name="CSharp_arrays_pinning"></A>19.4.3 Managed arrays using
- pinning</H3>
+<H3><A name="CSharp_arrays_pinning">20.4.3 Managed arrays using pinning</A>
+</H3>
<P> It is also possible to pin a given array in memory (i.e. fix its
location in memory), obtain a direct pointer to it, and then pass this
pointer to the wrapped C/C++ function. This approach involves no
fixed ( int *swig_ptrTo_sourceArray = sourceArray ) {
fixed ( int *swig_ptrTo_targetArray = targetArray ) {
{
- examplePINVOKE.myArrayCopy((IntPtr)swig_ptrTo_sourceArray, (IntPtr)swig_ptrTo_targetArray,
+ examplePINVOKE.myArrayCopy((global::System.IntPtr)swig_ptrTo_sourceArray, (global::System.IntPtr)swig_ptrTo_targetArray,
nitems);
}
}
parameter type.</P>
<DIV class="code">
<PRE>
-[DllImport("example", EntryPoint="CSharp_myArrayCopy")]
-public static extern void myArrayCopy(IntPtr jarg1, IntPtr jarg2, int jarg3);
+[global::System.Runtime.InteropServices.DllImport("example", EntryPoint="CSharp_myArrayCopy")]
+public static extern void myArrayCopy(global::System.IntPtr jarg1, global::System.IntPtr jarg2, int jarg3);
</PRE>
</DIV>
-<H2><A name="CSharp_exceptions"></A>19.5 C# Exceptions</H2>
+<H2><A name="CSharp_exceptions">20.5 C# Exceptions</A></H2>
<P> It is possible to throw a C# Exception from C/C++ code. SWIG already
provides the framework for throwing C# exceptions if it is able to
detect that a C++ exception could be thrown. Automatically detecting
attribute set. The <TT>%csnothrowexception</TT> feature is like <TT>
%exception</TT>, but it does not have the <TT>canthrow</TT> attribute
set so should only be used when a C# exception is not created.</P>
-<H3><A name="CSharp_exception_example_check_typemap"></A>19.5.1 C#
- exception example using "check" typemap</H3>
-<P> Lets say we have the following simple C++ method:</P>
+<H3><A name="CSharp_exception_example_check_typemap">20.5.1 C# exception
+ example using "check" typemap</A></H3>
+<P> Let's say we have the following simple C++ method:</P>
<DIV class="code">
<PRE>
void positivesonly(int number);
</DIV>
<P> Actually it will issue this warning for any function beginning with <TT>
SWIG_CSharpSetPendingException</TT>.</P>
-<H3><A name="CSharp_exception_example_percent_exception"></A>19.5.2 C#
- exception example using %exception</H3>
+<H3><A name="CSharp_exception_example_percent_exception">20.5.2 C#
+ exception example using %exception</A></H3>
<P> Let's consider a similar, but more common example that throws a C++
exception from within a wrapped function. We can use <TT>%exception</TT>
as mentioned in <A href="#Customization_exception">Exception handling
$action
} catch (std::out_of_range e) {
SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
+ return $null;
}
%}
}
</PRE>
</DIV>
-<H3><A name="CSharp_exception_example_exception_specifications"></A>
-19.5.3 C# exception example using exception specifications</H3>
+<H3><A name="CSharp_exception_example_exception_specifications">20.5.3
+ C# exception example using exception specifications</A></H3>
<P> When C++ exception specifications are used, SWIG is able to detect
that the method might throw an exception. By default SWIG will
automatically generate code to catch the exception and convert it into
</DIV>
<P> Multiple catch handlers are generated should there be more than one
exception specifications declared.</P>
-<H3><A name="CSharp_custom_application_exception"></A>19.5.4 Custom C#
- ApplicationException example</H3>
+<H3><A name="CSharp_custom_application_exception">20.5.4 Custom C#
+ ApplicationException example</A></H3>
<P> This example involves a user defined exception. The conventional
.NET exception handling approach is to create a custom <TT>
ApplicationException</TT> and throw it in your application. The goal in
static CustomExceptionDelegate customDelegate =
new CustomExceptionDelegate(SetPendingCustomException);
- [DllImport("$dllimport", EntryPoint="CustomExceptionRegisterCallback")]
+ [global::System.Runtime.InteropServices.DllImport("$dllimport", EntryPoint="CustomExceptionRegisterCallback")]
public static extern
void CustomExceptionRegisterCallback(CustomExceptionDelegate customCallback);
<DIV class="code">
<PRE>
// Custom C# Exception
-class CustomApplicationException : System.ApplicationException {
+class CustomApplicationException : global::System.ApplicationException {
public CustomApplicationException(string message)
: base(message) {
}
}
</PRE>
</DIV>
-<H2><A name="CSharp_directors"></A>19.6 C# Directors</H2>
+<H2><A name="CSharp_directors">20.6 C# Directors</A></H2>
<P> The SWIG directors feature adds extra code to the generated C# proxy
classes that enable these classes to be used in cross-language
polymorphism. Essentially, it enables unmanaged C++ code to call back
C# directors. However, the <A href="#Java_directors">Java directors</A>
section should also be read in order to gain more insight into
directors.</P>
-<H3><A name="CSharp_directors_example"></A>19.6.1 Directors example</H3>
+<H3><A name="CSharp_directors_example">20.6.1 Directors example</A></H3>
<P> Imagine we are wrapping a C++ base class, <TT>Base</TT>, from which
we would like to inherit in C#. Such a class is shown below as well as
another class, <TT>Caller</TT>, which calls the virtual method <TT>
CSharpDerived - UIntMethod(123)
</PRE>
</DIV>
-<H3><A name="CSharp_directors_implementation"></A>19.6.2 Directors
- implementation</H3>
+<H3><A name="CSharp_directors_implementation">20.6.2 Directors
+ implementation</A></H3>
<P> The previous section demonstrated a simple example where the virtual
<TT>UIntMethod</TT> method was called from C++ code, even when the
overridden method is implemented in C#. The intention of this section
<P> Below is the generated C# <TT>Base</TT> director class.</P>
<DIV class="code">
<PRE>
-using System;
-using System.Runtime.InteropServices;
-
-public class Base : IDisposable {
- private HandleRef swigCPtr;
+public class Base : global::System.IDisposable {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- internal Base(IntPtr cPtr, bool cMemoryOwn) {
+ internal Base(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
- swigCPtr = new HandleRef(this, cPtr);
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static HandleRef getCPtr(Base obj) {
- return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Base obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
~Base() {
public virtual void Dispose() {
lock(this) {
- if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+ if(swigCPtr.Handle != global::System.IntPtr.Zero && swigCMemOwn) {
swigCMemOwn = false;
examplePINVOKE.delete_Base(swigCPtr);
}
- swigCPtr = new HandleRef(null, IntPtr.Zero);
- GC.SuppressFinalize(this);
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ global::System.GC.SuppressFinalize(this);
}
}
examplePINVOKE.Base_director_connect(swigCPtr, swigDelegate0, swigDelegate1);
}
- private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes) {
+ private bool SwigDerivedClassHasMethod(string methodName, global::System.global::System.Type[] methodTypes) {
System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, methodTypes);
bool hasDerivedMethod = methodInfo.DeclaringType.IsSubclassOf(typeof(Base));
return hasDerivedMethod;
return UIntMethod(x);
}
- private void SwigDirectorBaseBoolMethod(IntPtr b, bool flag) {
+ private void SwigDirectorBaseBoolMethod(global::System.IntPtr b, bool flag) {
BaseBoolMethod(new Base(b, false), flag);
}
internal delegate uint SwigDelegateBase_0(uint x);
- internal delegate void SwigDelegateBase_1(IntPtr b, bool flag);
+ internal delegate void SwigDelegateBase_1(global::System.IntPtr b, bool flag);
private SwigDelegateBase_0 swigDelegate0;
private SwigDelegateBase_1 swigDelegate1;
- private static Type[] swigMethodTypes0 = new Type[] { typeof(uint) };
- private static Type[] swigMethodTypes1 = new Type[] { typeof(Base), typeof(bool) };
+ private static global::System.Type[] swigMethodTypes0 = new global::System.Type[] { typeof(uint) };
+ private static global::System.Type[] swigMethodTypes1 = new global::System.Type[] { typeof(Base), typeof(bool) };
}
</PRE>
</DIV>
}
</PRE>
</DIV>
-<H3><A name="CSharp_director_caveats"></A>19.6.3 Director caveats</H3>
+<H3><A name="CSharp_director_caveats">20.6.3 Director caveats</A></H3>
<P> There is a subtle gotcha with directors. If default parameters are
used, it is recommended to follow a pattern of always calling a single
method in any C# derived class. An example will clarify this and the
the implementation should pass the call on to <TT>
CSharpDefaults.DefaultMethod(int)</TT>using the C++ default value, as
shown above.</P>
-<H2><A name="CSharp_multiple_modules"></A>19.7 Multiples modules</H2>
-<P> When using <A href="Modules.html">multiple modules</A> it is is
- possible to compile each SWIG generated wrapper into a different
- assembly. However, by default the generated code may not compile if
- generated classes in one assembly use generated classes in another
- assembly. The visibility of the <TT>getCPtr()</TT> and pointer
- constructor generated from the <TT>csbody</TT> typemaps needs changing.
- The default visibility is <TT>internal</TT> but it needs to be <TT>
-public</TT> for access from a different assembly. Just changing
- 'internal' to 'public' in the typemap achieves this. Two macros are
- available in <TT>csharp.swg</TT> to make this easier and using them is
- the preferred approach over simply copying the typemaps and modifying
- as this is forward compatible with any changes in the <TT>csbody</TT>
- typemap in future versions of SWIG. The macros are for the proxy and
- typewrapper classes and can respectively be used to to make the method
- and constructor public:</P>
+<H2><A name="CSharp_multiple_modules">20.7 Multiple modules</A></H2>
+<P> When using <A href="#Modules">multiple modules</A> it is is possible
+ to compile each SWIG generated wrapper into a different assembly.
+ However, by default the generated code may not compile if generated
+ classes in one assembly use generated classes in another assembly. The
+ visibility of the <TT>getCPtr()</TT> and pointer constructor generated
+ from the <TT>csbody</TT> typemaps needs changing. The default
+ visibility is <TT>internal</TT> but it needs to be <TT>public</TT> for
+ access from a different assembly. Just changing 'internal' to 'public'
+ in the typemap achieves this. Two macros are available in <TT>
+csharp.swg</TT> to make this easier and using them is the preferred
+ approach over simply copying the typemaps and modifying as this is
+ forward compatible with any changes in the <TT>csbody</TT> typemap in
+ future versions of SWIG. The macros are for the proxy and typewrapper
+ classes and can respectively be used to to make the method and
+ constructor public:</P>
<DIV class="code">
<PRE>
SWIG_CSBODY_PROXY(public, public, SWIGTYPE)
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
</TT> attribute if you don't want users to easily stumble upon these so
called 'internal workings' of the wrappers.</P>
-<H2><A name="CSharp_typemap_examples"></A>19.8 C# Typemap examples</H2>
+<H2><A name="CSharp_typemap_examples">20.8 C# Typemap examples</A></H2>
This section includes a few examples of typemaps. For more examples,
you might look at the files "<TT>csharp.swg</TT>" and "<TT>typemaps.i</TT>
" in the SWIG library.
-<H3><A name="CSharp_memory_management_member_variables"></A>19.8.1
- Memory management when returning references to member variables</H3>
+<H3><A name="CSharp_memory_management_member_variables">20.8.1 Memory
+ management when returning references to member variables</A></H3>
<P> This example shows how to prevent premature garbage collection of
objects when the underlying C++ class returns a pointer or reference to
a member variable. The example is a direct equivalent to this <A href="#Java_memory_management_objects">
Wheel wheel = new Bike(10).getWheel();
Console.WriteLine("wheel size: " + wheel.size);
// Simulate a garbage collection
- System.GC.Collect();
- System.GC.WaitForPendingFinalizers();
- Console.WriteLine("wheel size: " + wheel.size);
+ global::System.GC.Collect();
+ global::System.GC.WaitForPendingFinalizers();
+ global::System.Console.WriteLine("wheel size: " + wheel.size);
</PRE>
</DIV>
<P> Don't be surprised that if the resulting output gives strange
// of dangling C++ pointer. Intended for methods that return pointers or
// references to a member variable.
%typemap(csout, excode=SWIGEXCODE) Wheel& getWheel {
- IntPtr cPtr = $imcall;$excode
+ global::System.IntPtr cPtr = $imcall;$excode
$csclassname ret = null;
- if (cPtr != IntPtr.Zero) {
+ if (cPtr != global::System.IntPtr.Zero) {
ret = new $csclassname(cPtr, $owner);
ret.addReference(this);
}
in the generated <TT>getWheel()</TT> function:</P>
<DIV class="code">
<PRE>
-public class Wheel : IDisposable {
+public class Wheel : global::System.IDisposable {
...
// Ensure that the GC doesn't collect any Bike instance set from C#
private Bike bikeReference;
}
}
-public class Bike : IDisposable {
+public class Bike : global::System.IDisposable {
...
public Wheel getWheel() {
- IntPtr cPtr = examplePINVOKE.Bike_getWheel(swigCPtr);
+ global::System.IntPtr cPtr = examplePINVOKE.Bike_getWheel(swigCPtr);
Wheel ret = null;
- if (cPtr != IntPtr.Zero) {
+ if (cPtr != global::System.IntPtr.Zero) {
ret = new Wheel(cPtr, false);
ret.addReference(this);
}
</PRE>
</DIV>
<P> Note the <TT>addReference</TT> call.</P>
-<H3><A name="CSharp_memory_management_objects"></A>19.8.2 Memory
- management for objects passed to the C++ layer</H3>
+<H3><A name="CSharp_memory_management_objects">20.8.2 Memory management
+ for objects passed to the C++ layer</A></H3>
<P> The example is a direct equivalent to this <A href="#Java_memory_management_objects">
Java equivalent</A>. Managing memory can be tricky when using C++ and C#
proxy classes. The previous example shows one such case and this
container.setElement(element);
Console.WriteLine("element.value: " + container.getElement().value);
// Simulate a garbage collection
- System.GC.Collect();
- System.GC.WaitForPendingFinalizers();
- Console.WriteLine("element.value: " + container.getElement().value);
+ global::System.GC.Collect();
+ global::System.GC.WaitForPendingFinalizers();
+ global::System.Console.WriteLine("element.value: " + container.getElement().value);
</PRE>
</DIV>
<P> The temporary element created with <TT>new Element(20)</TT> could
add in the appropriate references in the C# layer...</P>
<DIV class="code">
<PRE>
-public class Container : IDisposable {
+public class Container : global::System.IDisposable {
...
// Ensure that the GC doesn't collect any Element set from C#
// as the underlying C++ class stores a shallow copy
private Element elementReference;
- private HandleRef getCPtrAndAddReference(Element element) {
+ private global::System.Runtime.InteropServices.HandleRef getCPtrAndAddReference(Element element) {
elementReference = element;
return Element.getCPtr(element);
}
// Ensure that the GC doesn't collect any Element set from C#
// as the underlying C++ class stores a shallow copy
private Element elementReference;
- private HandleRef getCPtrAndAddReference(Element element) {
+ private global::System.Runtime.InteropServices.HandleRef getCPtrAndAddReference(Element element) {
elementReference = element;
return Element.getCPtr(element);
}
%}
</PRE>
</DIV>
-<H3><A name="CSharp_date_marshalling"></A>19.8.3 Date marshalling using
- the csin typemap and associated attributes</H3>
+<H3><A name="CSharp_date_marshalling">20.8.3 Date marshalling using the
+ csin typemap and associated attributes</A></H3>
<P> The <A href="#Java_nan_exception_typemap">NaN Exception example</A>
is a simple example of the "javain" typemap and its 'pre' attribute.
This example demonstrates how a C++ date class, say <TT>CDate</TT>, can
C# proxy class <TT>CDate</TT> is used in the proxy interface:</P>
<DIV class="code">
<PRE>
-public class Action : IDisposable {
+public class Action : global::System.IDisposable {
...
public Action(CDate dateIn, CDate dateOut)
: this(examplePINVOKE.new_Action(CDate.getCPtr(dateIn), CDate.getCPtr(dateOut)), true) {
follows:</P>
<DIV class="code">
<PRE>
-public class Action : IDisposable {
+public class Action : global::System.IDisposable {
...
public int doSomething(System.DateTime dateIn, out System.DateTime dateOut) {
CDate tempdateIn = new CDate(dateIn.Year, dateIn.Month, dateIn.Day);
}
}
- static private IntPtr SwigConstructAction(System.DateTime dateIn, out System.DateTime dateOut) {
+ static private global::System.IntPtr SwigConstructAction(System.DateTime dateIn, out System.DateTime dateOut) {
CDate tempdateIn = new CDate(dateIn.Year, dateIn.Month, dateIn.Day);
CDate tempdateOut = new CDate();
try {
}
</PRE>
</DIV>
-<H3><A name="CSharp_date_properties"></A>19.8.4 A date example
- demonstrating marshalling of C# properties</H3>
+<H3><A name="CSharp_date_properties">20.8.4 A date example demonstrating
+ marshalling of C# properties</A></H3>
<P> The previous section looked at converting a C++ date class to <TT>
System.DateTime</TT> for parameters. This section extends this idea so
that the correct marshalling is obtained when wrapping C++ variables.
%typemap(csvarout, excode=SWIGEXCODE2) CDate * %{
/* csvarout typemap code */
get {
- IntPtr cPtr = $imcall;
- CDate tempDate = (cPtr == IntPtr.Zero) ? null : new CDate(cPtr, $owner);$excode
+ global::System.IntPtr cPtr = $imcall;
+ CDate tempDate = (cPtr == global::System.IntPtr.Zero) ? null : new CDate(cPtr, $owner);$excode
return new System.DateTime(tempDate.getYear(), tempDate.getMonth(), tempDate.getDay(),
0, 0, 0);
} %}
}
/* csvarout typemap code */
get {
- IntPtr cPtr = examplePINVOKE.ImportantDate_get();
- CDate tempDate = (cPtr == IntPtr.Zero) ? null : new CDate(cPtr, false);
+ global::System.IntPtr cPtr = examplePINVOKE.ImportantDate_get();
+ CDate tempDate = (cPtr == global::System.IntPtr.Zero) ? null : new CDate(cPtr, false);
return new System.DateTime(tempDate.getYear(), tempDate.getMonth(), tempDate.getDay(),
0, 0, 0);
}
creating the <TT>temp$csinput</TT> variable is such an example; it is
identical to what is in the 'pre' attribute.</LI>
</UL>
-<H3><A name="CSharp_date_pre_post_directors"></A>19.8.5 Date example
- demonstrating the 'pre' and 'post' typemap attributes for directors</H3>
+<H3><A name="CSharp_date_pre_post_directors">20.8.5 Date example
+ demonstrating the 'pre' and 'post' typemap attributes for directors</A></H3>
<P> The 'pre' and 'post' attributes in the "csdirectorin" typemap act
like the attributes of the same name in the "csin" typemap. For example
if we modify the <A href="#CSharp_date_marshalling">Date marshalling
<DIV class="code">
<PRE>
...
- private void SwigDirectorsomeCallback(IntPtr date) {
+ private void SwigDirectorsomeCallback(global::System.IntPtr date) {
System.DateTime tempdate = new System.DateTime();
try {
someCallback(out tempdate);
</DIV>
<P> Pay special attention to the memory management issues, using these
attributes.</P>
-<H3><A name="CSharp_partial_classes"></A>19.8.6 Turning wrapped classes
- into partial classes</H3>
+<H3><A name="CSharp_partial_classes">20.8.6 Turning wrapped classes into
+ partial classes</A></H3>
<P> C# supports the notion of partial classes whereby a class definition
can be split into more than one file. It is possible to turn the
wrapped C++ class into a partial C# class using the <TT>
<P> The default C# proxy class generated is:</P>
<DIV class="code">
<PRE>
-public class ExtendMe : IDisposable {
+public class ExtendMe : global::System.IDisposable {
...
public int Part1() {
...
<P> The C# proxy class becomes a partial class:</P>
<DIV class="code">
<PRE>
-public partial class ExtendMe : IDisposable {
+public partial class ExtendMe : global::System.IDisposable {
...
public int Part1() {
...
elsewhere, for example:</P>
<DIV class="code">
<PRE>
-public partial class ExtendMe : IDisposable {
+public partial class ExtendMe : global::System.IDisposable {
public int Part2() {
return 2;
}
code - <TT>Part1()</TT> and managed code - <TT>Part2()</TT>. The
following example is an alternative approach to adding managed code to
the generated proxy class.</P>
-<H3><A name="CSharp_extending_proxy_class"></A>19.8.7 Extending proxy
- classes with additional C# code</H3>
+<H3><A name="CSharp_extending_proxy_class">20.8.7 Extending proxy
+ classes with additional C# code</A></H3>
<P> The previous example showed how to use partial classes to add
functionality to a generated C# proxy class. It is also possible to
extend a wrapped struct/class with C/C++ code by using the <A href="#SWIGPlus_class_extension">
<P> The generated C# proxy class will instead be:</P>
<DIV class="code">
<PRE>
-public class ExtendMe : IDisposable {
+public class ExtendMe : global::System.IDisposable {
...
public int Part3() {
return 3;
}
</PRE>
</DIV>
-<H3><A name="CSharp_enum_underlying_type"></A>19.8.8 Underlying type for
- enums</H3>
+<H3><A name="CSharp_enum_underlying_type">20.8.8 Underlying type for
+ enums</A></H3>
<P> C# enums use int as the underlying type for each enum item. If you
wish to change the underlying type to something else, then use the <TT>
csbase</TT> typemap. For example when your C++ code uses a value larget
}
</PRE>
</DIV><HR NOSHADE>
-
-<!-- Hand-written HTML -->
-<H1><A name="Chicken"></A>20 SWIG and Chicken</H1>
+<H1><A name="Chicken">21 SWIG and Chicken</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
-- object-oriented code is difficult to wrap by hand in CHICKEN -- and
its<STRONG> typed pointer representation</STRONG>, essential for C and
C++ libraries involving structures or classes.</P>
-<H2><A name="Chicken_nn2"></A>20.1 Preliminaries</H2>
+<H2><A name="Chicken_nn2">21.1 Preliminaries</A></H2>
<P> CHICKEN support was introduced to SWIG in version 1.3.18. SWIG
relies on some recent additions to CHICKEN, which are only present in
releases of CHICKEN with version number<STRONG> greater than or equal
the <A href="#Chicken_collection">Garbage collection</A> section below.</P>
<P> You may want to look at any of the examples in Examples/chicken/
directory for the basic steps to run SWIG CHICKEN.</P>
-<H3><A name="Chicken_nn3"></A>20.1.1 Running SWIG in C mode</H3>
+<H3><A name="Chicken_nn3">21.1.1 Running SWIG in C mode</A></H3>
<P> To run SWIG CHICKEN in C mode, use the -chicken option.</P>
<DIV class="shell">
<PRE>% swig -chicken example.i</PRE>
<P> So for the C mode of SWIG CHICKEN, <TT>example_wrap.c</TT> and <TT>
oexample.c</TT> are the files that must be compiled to object files and
linked into your project.</P>
-<H3><A name="Chicken_nn4"></A>20.1.2 Running SWIG in C++ mode</H3>
+<H3><A name="Chicken_nn4">21.1.2 Running SWIG in C++ mode</A></H3>
<P> To run SWIG CHICKEN in C++ mode, use the -chicken -c++ option.</P>
<DIV class="shell">
<PRE>% swig -chicken -c++ example.i</PRE>
<P> So for the C++ mode of SWIG CHICKEN, <TT>example_wrap.cxx</TT> and <TT>
oexample.c</TT> are the files that must be compiled to object files and
linked into your project.</P>
-<H2><A name="Chicken_nn5"></A>20.2 Code Generation</H2>
-<H3><A name="Chicken_nn6"></A>20.2.1 Naming Conventions</H3>
+<H2><A name="Chicken_nn5">21.2 Code Generation</A></H2>
+<H3><A name="Chicken_nn6">21.2.1 Naming Conventions</A></H3>
<P> Given a C variable, function or constant declaration named <TT>
Foo_Bar</TT>, the declaration will be available in CHICKEN as an
identifier ending with <TT>Foo-Bar</TT>. That is, an underscore is
converted to a dash.</P>
<P> You may control what the CHICKEN identifier will be by using the <TT>
%rename</TT> SWIG directive in the SWIG interface file.</P>
-<H3><A name="Chicken_nn7"></A>20.2.2 Modules</H3>
+<H3><A name="Chicken_nn7">21.2.2 Modules</A></H3>
<P> The name of the module must be declared one of two ways:</P>
<UL>
<LI>Placing <TT>%module example</TT> in the SWIG interface file.</LI>
(declare (unit modulename))</CODE>, pass the -nounit option to SWIG.</P>
<P> CHICKEN will be able to access the module using the <CODE>(declare
(uses<I> modulename</I>))</CODE> CHICKEN Scheme form.</P>
-<H3><A name="Chicken_nn8"></A>20.2.3 Constants and Variables</H3>
+<H3><A name="Chicken_nn8">21.2.3 Constants and Variables</A></H3>
<P> Constants may be created using any of the four constructs in the
interface file:</P>
<OL>
MYCONSTANT1 (MYCONSTANT1))</TT>. See <A href="#Customization_features">
Features and the %feature directive</A> for info on how to apply the
%feature.</P>
-<H3><A name="Chicken_nn9"></A>20.2.4 Functions</H3>
+<H3><A name="Chicken_nn9">21.2.4 Functions</A></H3>
<P> C functions declared in the SWIG interface file will have
corresponding CHICKEN Scheme procedures. For example, the C function
"int sqrt(double x);" will be available using the Scheme form <TT>(sqrt
parameter, or a void return value and at least two argout parameters).
The return values can then be accessed with <CODE>(call-with-values)</CODE>
.</P>
-<H3><A name="Chicken_nn10"></A>20.2.5 Exceptions</H3>
+<H3><A name="Chicken_nn10">21.2.5 Exceptions</A></H3>
<P>The SWIG chicken module has support for exceptions thrown from C or
C++ code to be caught in scheme. See <A href="#Customization_exception">
Exception handling with %exception</A> for more information about
(test-throw 1))
</PRE>
</DIV>
-<H2><A name="Chicken_nn11"></A>20.3 TinyCLOS</H2>
+<H2><A name="Chicken_nn11">21.3 TinyCLOS</A></H2>
<P> The author of TinyCLOS, Gregor Kiczales, describes TinyCLOS as:
"Tiny CLOS is a Scheme implementation of a `kernelized' CLOS, with a
metaobject protocol. The implementation is even simpler than the simple
the -closprefix mymod: argument is passed to SWIG, then the exported
functions will be prefixed by the string "mymod:". If -useclassprefix
is passed, -closprefix is ignored.</P>
-<H2><A name="Chicken_nn12"></A>20.4 Linkage</H2>
+<H2><A name="Chicken_nn12">21.4 Linkage</A></H2>
<P> Please refer to<EM> CHICKEN - A practical and portable Scheme system
- User's manual</EM> for detailed help on how to link object files to
create a CHICKEN Scheme program. Briefly, to link object files, be sure
(uses<I> modname</I>))</CODE>. This means that to load the module from
scheme code, the code must include <CODE>(declare (uses<I> modname</I>
))</CODE>.</P>
-<H3><A name="Chicken_nn13"></A>20.4.1 Static binary or shared library
- linked at compile time</H3>
+<H3><A name="Chicken_nn13">21.4.1 Static binary or shared library linked
+ at compile time</A></H3>
<P>We can easily use csc to build a static binary.</P>
<DIV class="shell">
<PRE>
(load-library 'example "example.so")</CODE>, in which case the test
script does not need to be linked with example.so. The test_script.scm
file can then be run with <TT>csi</TT>.</P>
-<H3><A name="Chicken_nn14"></A>20.4.2 Building chicken extension
- libraries</H3>
+<H3><A name="Chicken_nn14">21.4.2 Building chicken extension libraries</A>
+</H3>
<P>Building a shared library like in the above section only works if the
library is linked at compile time with a script containing <CODE>
(declare (uses ...))</CODE> or is loaded explicitly with <CODE>
<P>See the <TT>Examples/chicken/egg</TT> directory in the SWIG source
for an example that builds two eggs, one using the first method and one
using the second method.</P>
-<H3><A name="Chicken_nn15"></A>20.4.3 Linking multiple SWIG modules with
- TinyCLOS</H3>
+<H3><A name="Chicken_nn15">21.4.3 Linking multiple SWIG modules with
+ TinyCLOS</A></H3>
<P>Linking together multiple modules that share type information using
the <CODE>%import</CODE> directive while also using <TT>-proxy</TT> is
more complicated. For example, if <TT>mod2.i</TT> imports <TT>mod1.i</TT>
create an extension library or an egg, just create a <TT>
module_load.scm</TT> file that <CODE>(declare (uses ...))</CODE> all the
modules.</P>
-<H2><A name="Chicken_nn16"></A>20.5 Typemaps</H2>
+<H2><A name="Chicken_nn16">21.5 Typemaps</A></H2>
<P> The Chicken module handles all types via typemaps. This information
is read from <CODE>Lib/chicken/typemaps.i</CODE> and <CODE>
Lib/chicken/chicken.swg</CODE>.</P>
-<H2><A name="Chicken_nn17"></A>20.6 Pointers</H2>
+<H2><A name="Chicken_nn17">21.6 Pointers</A></H2>
<P> For pointer types, SWIG uses CHICKEN tagged pointers. A tagged
pointer is an ordinary CHICKEN pointer with an extra slot for a void *.
With SWIG CHICKEN, this void * is a pointer to a type-info structure.
**result, swig_type_info *type, int flags)</CODE>, passing a pointer to
a struct representing the expected pointer type. flags is either zero
or SWIG_POINTER_DISOWN (see below).</P>
-<H3><A name="Chicken_collection"></A>20.6.1 Garbage collection</H3>
+<H3><A name="Chicken_collection">21.6.1 Garbage collection</A></H3>
<P>If the owner flag passed to <CODE>SWIG_NewPointerObj</CODE> is 1, <CODE>
NewPointerObj</CODE> will add a finalizer to the type which will call
the destructor or delete method of that type. The destructor and delete
SWIG. This will not export code inside the _wrap.c file to register
finalizers, and will then export destructor functions which must be
called manually.</P>
-<H2><A name="Chicken_nn18"></A>20.7 Unsupported features and known
- problems</H2>
+<H2><A name="Chicken_nn18">21.7 Unsupported features and known problems</A>
+</H2>
<UL>
<LI>No director support.</LI>
<LI>No support for c++ standard types like std::vector.</LI>
correctly when using <A href="#SWIGPlus_default_args">
%feature(compactdefaultargs)</A>.</LI>
</UL>
-<H3><A name="Chicken_nn19"></A>20.7.1 TinyCLOS problems with Chicken
- version <= 1.92</H3>
+<H3><A name="Chicken_nn19">21.7.1 TinyCLOS problems with Chicken version
+ <= 1.92</A></H3>
<P>In Chicken versions equal to or below 1.92, TinyCLOS has a limitation
such that generic methods do not properly work on methods with
different number of specializers: TinyCLOS assumes that every method
functions inside TinyCLOS to correctly support multi-argument generics.
Please see the comments at the top of both files for more information.</P>
<HR NOSHADE>
-<H1><A name="D"></A>21 SWIG and D</H1>
+<H1><A name="D">22 SWIG and D</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<LI><A href="#D_special_variables">Special variable macros</A></LI>
</UL>
</LI>
-<LI><A href="#D_features"><TT>%feature</TT>s</A></LI>
+<LI><A href="#D_features">D and %feature</A></LI>
<LI><A href="#D_pragmas">Pragmas</A></LI>
<LI><A href="#D_exceptions">D Exceptions</A></LI>
<LI><A href="#D_directors">D Directors</A></LI>
<LI><A href="#D_other_features">Other features</A>
<UL>
-<LI><A href="#D_nspace">Extended namespace support (<TT>nspace</TT>)</A></LI>
+<LI><A href="#D_nspace">Extended namespace support (nspace)</A></LI>
<LI><A href="#D_native_pointer_support">Native pointer support</A></LI>
<LI><A href="#D_operator_overloading">Operator overloading</A></LI>
<LI><A href="#D_test_suite">Running the test-suite</A></LI>
</UL>
</DIV>
<!-- INDEX -->
-<H2><A name="D_introduction"></A>21.1 Introduction</H2>
+<H2><A name="D_introduction">22.1 Introduction</A></H2>
<P>From the <A href="http://www.digitalmars.com/d/">D Programming
Language</A> web site:<EM> D is a systems programming language. Its
focus is on combining the power and high performance of C and C++ with
<P>To help addressing these issues, the SWIG C# module has been forked
to support D. Is has evolved quite a lot since then, but there are
still many similarities, so if you do not find what you are looking for
- on this page, it might be worth having a look at the chapter on <A href="CSharp.html">
-C#</A> (and also on <A href="Java.html">Java</A>, since the C# module
- was in turn forked from it).</P>
-<H2><A name="D_command_line_invocation"></A>21.2 Command line invocation</H2>
+ on this page, it might be worth having a look at the chapter on <A href="#CSharp">
+C#</A> (and also on <A href="#Java">Java</A>, since the C# module was in
+ turn forked from it).</P>
+<H2><A name="D_command_line_invocation">22.2 Command line invocation</A></H2>
<P>To activate the D module, pass the <TT>-d</TT> option to SWIG at the
command line. The same standard command line switches as with any other
language module are available, plus the following D specific ones:</P>
<P>By default, SWIG generates code for D1/Tango. Use the <TT>-d2</TT>
flag to target D2/Phobos instead.</P>
</DD>
-<DT id="D_splitproxy"><TT>-splitproxy</TT></DT>
+<DT><A name="D_splitproxy"></A><TT>-splitproxy</TT></DT>
<DD>
<P>By default, SWIG generates two D modules: the<EM> proxy</EM> module,
named like the source module (either specified via the <TT>%module</TT>
shared library.</P>
</DD>
</DL>
-<H2><A name="D_typemaps"></A>21.3 Typemaps</H2>
-<H3><A name="D_typemap_name_comparison"></A>21.3.1 C# <-> D name
- comparison</H3>
+<H2><A name="D_typemaps">22.3 Typemaps</A></H2>
+<H3><A name="D_typemap_name_comparison">22.3.1 C# <-> D name comparison</A>
+</H3>
<P>If you already know the SWIG C# module, you might find the following
name comparison table useful:</P>
<DIV class="diagram">
csdestruct_derived <-> ddispose_derived
</PRE>
</DIV>
-<H3><A name="D_ctype_imtype_dtype"></A>21.3.2 ctype, imtype, dtype</H3>
+<H3><A name="D_ctype_imtype_dtype">22.3.2 ctype, imtype, dtype</A></H3>
<P>Mapping of types between the C/C++ library, the C/C++ library wrapper
exposing the C functions, the D wrapper module importing these
functions and the D proxy code.</P>
used in the extern(C) declarations of these functions in the
intermediary D module. The <TT>dtype</TT> typemap contains the D types
used in the D proxy module/class.</P>
-<H3><A name="D_in_out_directorin_direcetorout"></A>21.3.3 in, out,
- directorin, directorout</H3>
+<H3><A name="D_in_out_directorin_direcetorout">22.3.3 in, out,
+ directorin, directorout</A></H3>
<P>Used for converting between the types for C/C++ and D when generating
the code for the wrapper functions (on the C++ side).</P>
<P>The code from the <TT>in</TT> typemap is used to convert arguments to
<P>The <TT>directorin</TT> typemap is used to convert parameters to the
type used in the D director callback function, its return value is
processed by <TT>directorout</TT> (see below).</P>
-<H3><A name="D_din_dout_ddirectorin_ddirectorout"></A>21.3.4 din, dout,
- ddirectorin, ddirectorout</H3>
+<H3><A name="D_din_dout_ddirectorin_ddirectorout">22.3.4 din, dout,
+ ddirectorin, ddirectorout</A></H3>
<P>Typemaps for code generation in D proxy and type wrapper classes.</P>
-<P id="D_din">The <TT>din</TT> typemap is used for converting function
- parameter types from the type used in the proxy module or class to the
- type used in the intermediary D module (the <A href="D.html#D_dinput"><TT>
-$dinput</TT></A> macro is replaced). To inject further parameter
- processing code before or after the call to the intermediary layer, the
- <TT>pre</TT>, <TT>post</TT> and <TT>terminator</TT> attributes can be
- used (please refer to the <A href="#CSharp_date_marshalling">C# date
- marshalling example</A> for more information on these).</P>
-<P id="D_dout">The <TT>dout</TT> typemap is used for converting function
- return values from the return type used in the intermediary D module to
- the type returned by the proxy function. The <TT>$excode</TT> special
- variable in <TT>dout</TT> typemaps is replaced by the <TT>excode</TT>
- typemap attribute code if the method can throw any exceptions from
- unmanaged code, otherwise by nothing (the <A href="D.html#D_imcall"><TT>
-$imcall</TT> and <TT>$owner</TT></A> macros are replaced).</P>
-<P id="D_ddirectorinout">The code from the <TT>ddirectorin</TT> and <TT>
-ddirectorout</TT> typemaps is used for conversion in director callback
- functions. Arguments are converted to the type used in the proxy class
- method they are calling by using the code from <TT>ddirectorin</TT>,
- the proxy class method return value is converted to the type the C++
- code expects via the <TT>ddirectorout</TT> typemap (the <A href="D.html#D_dpcall">
-<TT>$dcall</TT> and <TT>$winput</TT></A> macros are replaced).</P>
+<P><A name="D_din"></A>The <TT>din</TT> typemap is used for converting
+ function parameter types from the type used in the proxy module or
+ class to the type used in the intermediary D module (the <A href="#D_dinput">
+$dinput</A> macro is replaced). To inject further parameter processing
+ code before or after the call to the intermediary layer, the <TT>pre</TT>
+, <TT>post</TT> and <TT>terminator</TT> attributes can be used (please
+ refer to the <A href="#CSharp_date_marshalling">C# date marshalling
+ example</A> for more information on these).</P>
+<P><A name="D_dout"></A>The <TT>dout</TT> typemap is used for converting
+ function return values from the return type used in the intermediary D
+ module to the type returned by the proxy function. The <TT>$excode</TT>
+ special variable in <TT>dout</TT> typemaps is replaced by the <TT>
+excode</TT> typemap attribute code if the method can throw any
+ exceptions from unmanaged code, otherwise by nothing (the <A href="#D_imcall">
+<TT>$imcall</TT> and <TT>$owner</TT></A> macros are replaced).</P>
+<P><A name="D_ddirectorinout"></A>The code from the <TT>ddirectorin</TT>
+ and <TT>ddirectorout</TT> typemaps is used for conversion in director
+ callback functions. Arguments are converted to the type used in the
+ proxy class method they are calling by using the code from <TT>
+ddirectorin</TT>, the proxy class method return value is converted to
+ the type the C++ code expects via the <TT>ddirectorout</TT> typemap
+ (the <A href="#D_dpcall"><TT>$dcall</TT> and <TT>$winput</TT></A>
+ macros are replaced).</P>
<P>The full chain of type conversions when a director callback is
invoked looks like this:</P>
<DIV class="diagram">
↑ ↓
dtype DClass.method(dtype a)</PRE>
</DIV>
-<H3><A name="D_typecheck_typemaps"></A>21.3.5 typecheck typemaps</H3>
+<H3><A name="D_typecheck_typemaps">22.3.5 typecheck typemaps</A></H3>
<P>Because, unlike many scripting languages supported by SWIG, D does
not need any dynamic dispatch helper to access an overloaded function,
the purpose of these is merely to issue a warning for overloaded C++
functions that cannot be overloaded in D (as more than one C++ type
maps to a single D type).</P>
-<H3><A name="D_code_injection_typemaps"></A>21.3.6 Code injection
- typemaps</H3>
+<H3><A name="D_code_injection_typemaps">22.3.6 Code injection typemaps</A>
+</H3>
<P>These typemaps are used for generating the skeleton of proxy classes
for C++ types.</P>
<P>By overriding <TT>dbase</TT>, <TT>dinterfaces</TT> or <TT>
additional D code which will be emitted into the class body
respectively the imports section of the D module the class is written
to.</P>
-<P id="D_class_code_typemaps"><TT>dconstructor</TT>, <TT>ddestructor</TT>
-, <TT>ddispose</TT> and <TT>ddispose_derived</TT> are used to generate
- the class constructor, destructor and <TT>dispose()</TT> method,
- respectively. The auxiliary code for handling the pointer to the C++
- object is stored in <TT>dbody</TT> and <TT>dbody_derived</TT>. You can
- override them for specific types.</P>
-<H3><A name="D_special_variables"></A>21.3.7 Special variable macros</H3>
+<P><A name="D_class_code_typemaps"></A><TT>dconstructor</TT>, <TT>
+ddestructor</TT>, <TT>ddispose</TT> and <TT>ddispose_derived</TT> are
+ used to generate the class constructor, destructor and <TT>dispose()</TT>
+ method, respectively. The auxiliary code for handling the pointer to
+ the C++ object is stored in <TT>dbody</TT> and <TT>dbody_derived</TT>.
+ You can override them for specific types.</P>
+<H3><A name="D_special_variables">22.3.7 Special variable macros</A></H3>
<P>The standard SWIG special variables are available for use within
typemaps as described in the <A href="#Typemaps">Typemaps documentation</A>
, for example <TT>$1</TT>, <TT>$input</TT>, <TT>$result</TT> etc.</P>
on whether the function has a return value or not. It can be used to
bail out early e.g. in case of errors (<TT>return $null;</TT>).</P>
</DD>
-<DT id="D_dinput"><TT>$dinput</TT> (C#: <TT>$csinput</TT>)</DT>
+<DT><A name="D_dinput"></A><TT>$dinput</TT> (C#: <TT>$csinput</TT>)</DT>
<DD>
-<P>This variable is used in <TT><A href="D.html#D_din">din</A></TT>
- typemaps and is replaced by the expression which is to be passed to
- C/C++.</P>
+<P>This variable is used in <TT><A href="#D_din">din</A></TT> typemaps
+ and is replaced by the expression which is to be passed to C/C++.</P>
<P>For example, this input</P>
<DIV class="code">
<PRE>
example_im.foo(SomeClass.getCPointer(arg));
}</PRE>
</DIV></DD>
-<DT id="D_imcall"><TT>$imcall</TT> and <TT>$owner</TT> (C#: <TT>$imcall</TT>
-)</DT>
+<DT><A name="D_imcall"></A><TT>$imcall</TT> and <TT>$owner</TT> (C#: <TT>
+$imcall</TT>)</DT>
<DD>
-<P>These variables are used in <TT><A href="D.html#D_dout">dout</A></TT>
+<P>These variables are used in <TT><A href="#D_dout">dout</A></TT>
typemaps. <TT>$imcall</TT> contains the call to the intermediary module
which provides the value to be used, and <TT>$owner</TT> signals if the
caller is responsible for managing the object lifetime (that is, if the
</DIV></DD>
<DT><TT>$dcall</TT> and <TT>$winput</TT> (C#: <TT>$cscall</TT>, <TT>
$iminput</TT>)</DT>
-<DD id="D_dpcall">
-<P>These variables are used in the director-specific typemaps <A href="D.html#D_ddirectorinout">
-<TT>ddirectorin</TT></A> and <A href="D.html#D_ddirectorinout"><TT>
+<DD><A name="D_dpcall"></A>
+<P>These variables are used in the director-specific typemaps <A href="#D_ddirectorinout">
+<TT>ddirectorin</TT></A> and <A href="#D_ddirectorinout"><TT>
ddirectorout</TT></A>. They are more or less the reverse of the <TT>
$imcall</TT> and <TT>$dinput</TT> macros: <TT>$dcall</TT> contains the
invocation of the D proxy method of which the return value is to be
</DD>
<DT><TT>$directorconnect</TT></DT>
<DD>
-<P>This macro is only valid inside the <TT><A href="D.html#D_class_code_typemaps">
+<P>This macro is only valid inside the <TT><A href="#D_class_code_typemaps">
dconstructor</A></TT> typemap and contains the value of the <TT>
dconstructor</TT> typemap attribute if the currently wrapped class has
directors enabled.</P>
}
</PRE>
</DIV></DD>
-<DT id="D_importtype"><TT>$importtype(SomeDType)</TT></DT>
+<DT><A name="D_importtype"></A><TT>$importtype(SomeDType)</TT></DT>
<DD>
<P>This macro is used in the <TT>dimports</TT> typemap if a dependency
on another D type generated by SWIG is added by a custom typemap.</P>
<P>Contains the fully qualified name of the intermediary D module.</P>
</DD>
</DL>
-<H2><A name="D_features"></A>21.4 <TT>%feature</TT>s</H2>
+<H2><A name="D_features">22.4 D and %feature</A></H2>
<P>The D module defines a number of directives which modify the <A href="#Customization_features">
SWIG features</A> set globally or for a specific declaration:</P>
<DL>
</PRE>
</DIV></DD>
</DL>
-<H2><A name="D_pragmas"></A>21.5 Pragmas</H2>
+<H2><A name="D_pragmas">22.5 Pragmas</A></H2>
<P>There are a few SWIG pragmas specific to the D module, which you can
use to influence the D code SWIG generates:</P>
<DL>
<DT><TT>%pragma(d) imdmoduleimports</TT></DT>
<DD>
<P>Additional code to be emitted to the imports section of the
- intermediary D module (the <A href="D.html#D_importtype">$importtype</A>
+ intermediary D module (the <A href="#D_importtype">$importtype</A>
macro can be used here). You probably want to use this in conjunction
with the <TT>imdmodulecode</TT> pragma.</P>
</DD>
<DT><TT>%pragma(d) proxydmodulecode</TT></DT>
<DD>
<P>Just like <TT>proxydmodulecode</TT>, the argument is copied to the
- proxy D module (if SWIG is in <A href="D.html#D_splitproxy">split proxy
- mode</A> and/or the <TT>nspace</TT> feature is used, it is emitted to
- the main proxy D module only).</P>
+ proxy D module (if SWIG is in <A href="#D_splitproxy">split proxy mode</A>
+ and/or the <TT>nspace</TT> feature is used, it is emitted to the main
+ proxy D module only).</P>
</DD>
<DT><TT>%pragma(d) globalproxyimports</TT></DT>
<DD>
overwritten.</P>
</DD>
</DL>
-<H2><A name="D_exceptions"></A>21.6 D Exceptions</H2>
+<H2><A name="D_exceptions">22.6 D Exceptions</A></H2>
<P>Out of the box, C++ exceptions are fundamentally incompatible to
their equivalent in the D world and cannot simply be propagated to a
calling D method. There is, however, an easy way to solve this problem:
<P>As this feature is implemented in exactly the same way it is for C#,
please see the <A href="#CSharp_exceptions">C# documentation</A> for a
more detailed explanation.</P>
-<H2><A name="D_directors"></A>21.7 D Directors</H2>
+<H2><A name="D_directors">22.7 D Directors</A></H2>
<P>When the directors feature is activated, SWIG generates extra code on
both the C++ and the D side to enable cross-language polymorphism.
Essentially, this means that if you subclass a proxy class in D, C++
<P>There is no D specific documentation yet, but the way the feature is
implemented is very similar to how it is done in <A href="#Java_directors">
Java</A> and <A href="#CSharp_directors">C#</A>.</P>
-<H2><A name="D_other_features"></A>21.8 Other features</H2>
-<H3><A name="D_nspace"></A>21.8.1 Extended namespace support (<TT>nspace</TT>
-)</H3>
+<H2><A name="D_other_features">22.8 Other features</A></H2>
+<H3><A name="D_nspace">22.8.1 Extended namespace support (nspace)</A></H3>
<P>By default, SWIG flattens all C++ namespaces into a single target
language namespace, but as for Java and C#, the <A href="#SWIGPlus_nspace">
<TT>nspace</TT></A> feature is supported for D. If it is active, C++
for the other languages,<EM> free</EM> variables and functions are not
supported yet; currently, they are all allows written to the main proxy
D module.</P>
-<H3><A name="D_native_pointer_support"></A>21.8.2 Native pointer support</H3>
+<H3><A name="D_native_pointer_support">22.8.2 Native pointer support</A></H3>
<P>Contrary to many of the scripting languages supported by SWIG, D
fully supports C-style pointers. The D module thus includes a custom
mechanism to wrap C pointers directly as D pointers where applicable,
cprimitive="1"</TT>, so the code from the <TT>nativepointer</TT>
attribute is taken into account e.g. for <TT>float **</TT> or the
function pointer <TT>float (*)(float *)</TT>.</P>
-<H3><A name="D_operator_overloading"></A>21.8.3 Operator overloading</H3>
+<H3><A name="D_operator_overloading">22.8.3 Operator overloading</A></H3>
<P>The D module comes with basic operator overloading support for both
D1 and D2. There are, however, a few limitations arising from
conceptual differences between C++ and D:</P>
-, or implicit casting (which was introduced in D2 via <TT>alias this</TT>
). Despite the lack of automatic support, manually handling these cases
should be perfectly possible.</P>
-<H3><A name="D_test_suite"></A>21.8.4 Running the test-suite</H3>
+<H3><A name="D_test_suite">22.8.4 Running the test-suite</A></H3>
<P>As with any other language, the SWIG test-suite can be built for D
using the <TT>*-d-test-suite</TT> targets of the top-level Makefile. By
default, D1 is targeted, to build it with D2, use the optional <TT>
library, you might have to add <TT>-ldl</TT> manually to the <TT>
d_compile</TT> target in <TT>Examples/Makefile</TT>, because GDC does
not currently honor the <TT>pragma(lib,...)</TT> statement.</P>
-<H2><A name="D_typemap_examples"></A>21.9 D Typemap examples</H2>
+<H2><A name="D_typemap_examples">22.9 D Typemap examples</A></H2>
<P>There are no D-specific typemap examples yet. However, with the above
<A href="#D_typemap_name_comparison">name comparison table</A>, you
should be able to get an idea what can be done by looking at the <A href="#CSharp_typemap_examples">
corresponding C# section</A>.</P>
-<H2><A name="D_planned_features"></A>21.10 Work in progress and planned
- features</H2>
+<H2><A name="D_planned_features">22.10 Work in progress and planned
+ features</A></H2>
<P>There are a couple of features which are not implemented yet, but
would be very useful and might be added in the near future:</P>
<UL>
issues concerning const-correctness etc.</LI>
</UL>
<HR NOSHADE>
-<H1><A name="Go"></A>22 SWIG and Go</H1>
+<H1><A name="Go">23 SWIG and Go</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<UL>
<LI><A href="#Go_overview">Overview</A></LI>
+<LI><A href="#Go_examples">Examples</A></LI>
<LI><A href="#Go_running_swig">Running SWIG with Go</A>
<UL>
-<LI><A href="#Go_commandline">Additional Commandline Options</A></LI>
-<LI><A href="#Go_outputs">Go Output Files</A></LI>
+<LI><A href="#Go_commandline">Go-specific Commandline Options</A></LI>
+<LI><A href="#Go_outputs">Generated Wrapper Files</A></LI>
</UL>
</LI>
<LI><A href="#Go_basic_tour">A tour of basic C/C++ wrapping</A>
<LI><A href="#Go_enumerations">Go Enumerations</A></LI>
<LI><A href="#Go_classes">Go Classes</A>
<UL>
+<LI><A href="#Go_class_memory">Go Class Memory Management</A></LI>
<LI><A href="#Go_class_inheritance">Go Class Inheritance</A></LI>
</UL>
</LI>
<LI><A href="#Go_templates">Go Templates</A></LI>
-<LI><A href="#Go_director_classes">Go Director Classes</A></LI>
+<LI><A href="#Go_director_classes">Go Director Classes</A>
+<UL>
+<LI><A href="#Go_director_example_cpp_code">Example C++ code</A></LI>
+<LI><A href="#Go_director_enable">Enable director feature</A></LI>
+<LI><A href="#Go_director_ctor_dtor">Constructor and destructor</A></LI>
+<LI><A href="#Go_director_overriding">Override virtual methods</A></LI>
+<LI><A href="#Go_director_base_methods">Call base methods</A></LI>
+<LI><A href="#Go_director_subclass">Subclass via embedding</A></LI>
+<LI><A href="#Go_director_finalizer">Memory management with
+ runtime.SetFinalizer</A></LI>
+<LI><A href="#Go_director_foobargo_class">Complete FooBarGo example
+ class</A></LI>
+</UL>
+</LI>
<LI><A href="#Go_primitive_type_mappings">Default Go primitive type
mappings</A></LI>
<LI><A href="#Go_output_arguments">Output arguments</A></LI>
<LI><A href="#Go_adding_additional_code">Adding additional go code</A></LI>
+<LI><A href="#Go_typemaps">Go typemaps</A></LI>
</UL>
</LI>
</UL>
<P> This chapter describes SWIG's support of Go. For more information on
the Go programming language see <A href="http://golang.org/">golang.org</A>
.</P>
-<H2><A name="Go_overview"></A>22.1 Overview</H2>
-<P> Go is a compiled language, not a scripting language. However, it
- does not support direct calling of functions written in C/C++. The cgo
- program may be used to generate wrappers to call C code from Go, but
- there is no convenient way to call C++ code. SWIG fills this gap.</P>
-<P> There are (at least) two different Go compilers. One is the gc
- compiler, normally invoked under the names 6g, 8g, or 5g. The other is
- the gccgo compiler, which is a frontend to the gcc compiler suite. The
+<H2><A name="Go_overview">23.1 Overview</A></H2>
+<P> Go does not support direct calling of functions written in C/C++.
+ The <A href="https://golang.org/cmd/cgo/">cgo program</A> may be used
+ to generate wrappers to call C code from Go, but there is no convenient
+ way to call C++ code. SWIG fills this gap.</P>
+<P> There are (at least) two different Go compilers. The first is the gc
+ compiler of the <A href="https://golang.org/doc/install">Go
+ distribution</A>, normally invoked via the <A href="https://golang.org/cmd/go/">
+go tool</A>. The second Go compiler is the <A href="https://golang.org/doc/install/gccgo">
+ gccgo compiler</A>, which is a frontend to the GCC compiler suite. The
interface to C/C++ code is completely different for the two Go
- compilers. SWIG supports both, selected by a command line option.</P>
-<P> Because Go is a type-safe compiled language, SWIG's runtime type
- checking and runtime library are not used with Go. This should be borne
- in mind when reading the rest of the SWIG documentation.</P>
-<H2><A name="Go_running_swig"></A>22.2 Running SWIG with Go</H2>
-<P> To generate Go code, use the <TT>-go</TT> option with SWIG. By
- default SWIG will generate code for the gc compilers. To generate code
- for gccgo, you should also use the <TT>-gccgo</TT> option.</P>
-<H3><A name="Go_commandline"></A>22.2.1 Additional Commandline Options</H3>
-<P> These are the command line options for SWIG's GO module. They can
+ compilers. SWIG supports both Go compilers, selected by the <TT>-gccgo</TT>
+ command line option.</P>
+<P> Go is a type-safe compiled language and the wrapper code generated
+ by SWIG is type-safe as well. In case of type issues the build will
+ fail and hence SWIG's <A href="#Modules_nn2">runtime library</A> and <A href="#Typemaps_runtime_type_checker">
+runtime type checking</A> are not used.</P>
+<H2><A name="Go_examples">23.2 Examples</A></H2>
+<P> Working examples can be found in the <A href="https://github.com/swig/swig/tree/master/Examples/go">
+SWIG source tree</A> .</P>
+<P> Please note that the examples in the SWIG source tree use makefiles
+ with the .i SWIG interface file extension for backwards compatibility
+ with Go 1.</P>
+<H2><A name="Go_running_swig">23.3 Running SWIG with Go</A></H2>
+<P> Most Go programs are built using the <A href="https://golang.org/cmd/go/">
+go tool</A>. Since Go 1.1 the go tool has support for SWIG. To use it,
+ give your SWIG interface file the extension .swig (for C code) or
+ .swigcxx (for C++ code). Put that file in a GOPATH/src directory as
+ usual for Go sources. Put other C/C++ code in the same directory with
+ extensions of .c and .cxx. The <TT>go build</TT> and <TT>go install</TT>
+ commands will automatically run SWIG for you and compile the generated
+ wrapper code. To check the SWIG command line options the go tool uses
+ run <TT>go build -x</TT>. To access the automatically generated files
+ run <TT>go build -work</TT>. You'll find the files under the temporary
+ WORK directory.</P>
+<P> To manually generate and compile C/C++ wrapper code for Go, use the <TT>
+-go</TT> option with SWIG. By default SWIG will generate code for the Go
+ compiler of the Go distribution. To generate code for gccgo, you should
+ also use the <TT>-gccgo</TT> option.</P>
+<P> When using the <TT>-cgo</TT> option, SWIG will generate files that
+ can be used directly by <TT>go build</TT>. Starting with the Go 1.5
+ distribution the <TT>-cgo</TT> option has to be given. Put your SWIG
+ interface file in a directory under GOPATH/src, and give it a name that
+ does<B> not</B> end in the .swig or .swigcxx extension. Typically the
+ SWIG interface file extension is .i in this case.</P>
+<DIV class="code">
+<PRE>
+% swig -go -cgo example.i
+% go install
+</PRE>
+</DIV>
+<P> You will now have a Go package that you can import from other Go
+ packages as usual.</P>
+<P> To use SWIG without the <TT>-cgo</TT> option, more steps are
+ required. Recall that this only works with Go versions before 1.5. When
+ using Go version 1.2 or later, or when using gccgo, the code generated
+ by SWIG can be linked directly into the Go program. A typical command
+ sequence when using the Go compiler of the Go distribution would look
+ like this:</P>
+<DIV class="code">
+<PRE>
+% swig -go example.i
+% gcc -c code.c # The C library being wrapped.
+% gcc -c example_wrap.c
+% go tool 6g example.go
+% go tool 6c example_gc.c
+% go tool pack grc example.a example.6 example_gc.6 code.o example_wrap.o
+% go tool 6g main.go
+% go tool 6l main.6
+</PRE>
+</DIV>
+<P> You can also put the wrapped code into a shared library, and when
+ using the Go versions before 1.2 this is the only supported option. A
+ typical command sequence for this approach would look like this:</P>
+<DIV class="code">
+<PRE>
+% swig -go -use-shlib example.i
+% gcc -c -fpic example.c
+% gcc -c -fpic example_wrap.c
+% gcc -shared example.o example_wrap.o -o example.so
+% go tool 6g example.go
+% go tool 6c example_gc.c
+% go tool pack grc example.a example.6 example_gc.6
+% go tool 6g main.go # your code, not generated by SWIG
+% go tool 6l main.6
+</PRE>
+</DIV>
+<H3><A name="Go_commandline">23.3.1 Go-specific Commandline Options</A></H3>
+<P> These are the command line options for SWIG's Go module. They can
also be seen by using:</P>
<DIV class="code">
<PRE>
swig -go -help
</PRE>
</DIV>
-<TABLE summary="Go specific options">
-<TR><TH>Go specific options</TH></TR>
-<TR><TD>-intgo-type-size %lt;s%gt;</TD><TD>Set the size for the Go type <TT>
-int</TT>. This controls the size that the C/C++ code expects to see. The
- %lt;s%gt; argument should be 32 or 64. This option is currently
- required during the transition from Go 1.0 to Go 1.1, as the size of <TT>
-int</TT> on 64-bit x86 systems changes between those releases (from 32
- bits to 64 bits). In the future the option may become optional, and
- SWIG will assume that the size of <TT>int</TT> is the size of a C
- pointer.</TD></TR>
+<TABLE summary="Go-specific options">
+<TR><TH>Go-specific options</TH></TR>
+<TR><TD>-cgo</TD><TD>Generate files to be used as input for the Go cgo
+ tool. This option is required for Go 1.5 and later, and works for Go
+ 1.2 and later. In the future this option will likely become the
+ default.</TD></TR>
+<TR><TD>-intgosize <s></TD><TD>Set the size for the Go type <TT>int</TT>
+. This controls the size that the C/C++ code expects to see. The <s>
+ argument should be 32 or 64. This option is currently required during
+ the transition from Go 1.0 to Go 1.1, as the size of <TT>int</TT> on
+ 64-bit x86 systems changes between those releases (from 32 bits to 64
+ bits). In the future the option may become optional, and SWIG will
+ assume that the size of <TT>int</TT> is the size of a C pointer.</TD></TR>
<TR><TD>-gccgo</TD><TD>Generate code for gccgo. The default is to
- generate code for 6g/8g/5g.</TD></TR>
+ generate code for the Go compiler of the Go distribution.</TD></TR>
<TR><TD>-package <name></TD><TD>Set the name of the Go package to
<name>. The default package name is the SWIG module name.</TD></TR>
-<TR><TD>-soname %lt;name%gt;</TD><TD>Set the runtime name of the shared
+<TR><TD>-use-shlib</TD><TD>Tell SWIG to emit code that uses a shared
+ library. This is only meaningful for the Go compiler of the Go
+ distribution, which needs to know at compile time whether a shared
+ library will be used.</TD></TR>
+<TR><TD>-soname <name></TD><TD>Set the runtime name of the shared
library that the dynamic linker should include at runtime. The default
is the package name with ".so" appended. This is only used when
- generating code for 6g/8g/5g; when using gccgo, the equivalent name
- will be taken from the <CODE>-soname</CODE> option passed to the
- linker.</TD></TR>
+ generating code for the Go compiler of the Go distribution; when using
+ gccgo, the equivalent name will be taken from the <CODE>-soname</CODE>
+ option passed to the linker. Using this option implies the -use-shlib
+ option.</TD></TR>
+<TR><TD>-go-pkgpath <pkgpath></TD><TD>When generating code for gccgo,
+ set the pkgpath to use. This corresponds to the <TT>-fgo-pkgpath</TT>
+ option to gccgo.</TD></TR>
<TR><TD>-go-prefix <prefix></TD><TD>When generating code for gccgo, set
the prefix to use. This corresponds to the <TT>-fgo-prefix</TT> option
- to gccgo.</TD></TR>
-<TR><TD>-long-type-size <s></TD><TD>Set the size for the C/C++ type <TT>
-long</TT>. This controls whether <TT>long</TT> is converted to the Go
- type <TT>int32</TT> or <TT>int64</TT>. The <s> argument should be 32 or
- 64.</TD></TR>
+ to gccgo. If <TT>-go-pkgpath</TT> is used, <TT>-go-prefix</TT> will be
+ ignored.</TD></TR>
</TABLE>
-<H3><A name="Go_outputs"></A>22.2.2 Go Output Files</H3>
-<P> When generating Go code, SWIG will generate the following files:</P>
+<H3><A name="Go_outputs">23.3.2 Generated Wrapper Files</A></H3>
+<P>There are two different approaches to generating wrapper files,
+ controlled by SWIG's <TT>-cgo</TT> option. The <TT>-cgo</TT> option
+ works with Go version 1.2 or later. It is required when using Go
+ version 1.5 or later.</P>
+<P>With or without the <TT>-cgo</TT> option, SWIG will generate the
+ following files when generating wrapper code:</P>
<UL>
<LI> MODULE.go will contain the Go functions that your Go code will
call. These functions will be wrappers for the C++ functions defined by
compiler.</LI>
<LI> MODULE_wrap.c or MODULE_wrap.cxx will contain C/C++ functions will
be invoked by the Go wrapper code. This file should be compiled with
- the usual C or C++ compiler and linked into a shared library.</LI>
+ the usual C or C++ compiler.</LI>
<LI> MODULE_wrap.h will be generated if you use the directors feature.
It provides a definition of the generated C++ director classes. It is
generally not necessary to use this file, but in some special cases it
may be helpful to include it in your code, compiled with the usual C or
C++ compiler.</LI>
-<LI> If using the gc compiler, MODULE_gc.c will contain C code which
- should be compiled with the C compiler distributed as part of the gc
- compiler: 6c, 8c, or 5c. It should then be combined with the compiled
- MODULE.go using gopack. This file will not be generated when using
- gccgo.</LI>
</UL>
-<P> A typical command sequence would look like this:</P>
-<DIV class="code">
-<PRE>
-% swig -go example.i
-% gcc -c -fpic example.c
-% gcc -c -fpic example_wrap.c
-% gcc -shared example.o example_wrap.o -o example.so
-% 6g example.go
-% 6c example_gc.c
-% gopack grc example.a example.6 example_gc.6
-% 6g main.go # your code, not generated by SWIG
-% 6l main.6
-</PRE>
-</DIV>
-<H2><A name="Go_basic_tour"></A>22.3 A tour of basic C/C++ wrapping</H2>
+<P>When neither the <TT>-cgo</TT> nor the <TT>-gccgo</TT> option is
+ used, SWIG will also generate an additional file:</P>
+<UL>
+<LI> MODULE_gc.c will contain C code which should be compiled with the C
+ compiler distributed as part of the gc compiler. It should then be
+ combined with the compiled MODULE.go using go tool pack.</LI>
+</UL>
+<H2><A name="Go_basic_tour">23.4 A tour of basic C/C++ wrapping</A></H2>
<P> By default, SWIG attempts to build a natural Go interface to your
C/C++ code. However, the languages are somewhat different, so some
modifications have to occur. This section briefly covers the essential
aspects of this wrapping.</P>
-<H3><A name="Go_package"></A>22.3.1 Go Package Name</H3>
+<H3><A name="Go_package">23.4.1 Go Package Name</A></H3>
<P> All Go source code lives in a package. The name of this package will
default to the name of the module from SWIG's <TT>%module</TT>
directive. You may override this by using SWIG's <TT>-package</TT>
command line option.</P>
-<H3><A name="Go_names"></A>22.3.2 Go Names</H3>
+<H3><A name="Go_names">23.4.2 Go Names</A></H3>
<P> In Go, a function is only visible outside the current package if the
first letter of the name is uppercase. This is quite different from
C/C++. Because of this, C/C++ names are modified when generating the Go
the name of a type in Go. A constructor will be named <TT>New</TT>
followed by that name, and the destructor will be named <TT>Delete</TT>
followed by that name.</P>
-<H3><A name="Go_constants"></A>22.3.3 Go Constants</H3>
+<H3><A name="Go_constants">23.4.3 Go Constants</A></H3>
<P> C/C++ constants created via <TT>#define</TT> or the <TT>%constant</TT>
directive become Go constants, declared with a <TT>const</TT>
declaration.</P>
-<H3><A name="Go_enumerations"></A>22.3.4 Go Enumerations</H3>
+<H3><A name="Go_enumerations">23.4.4 Go Enumerations</A></H3>
<P> C/C++ enumeration types will cause SWIG to define an integer type
with the name of the enumeration (with first letter forced to uppercase
as usual). The values of the enumeration will become variables in Go;
code should avoid modifying those variables.</P>
-<H3><A name="Go_classes"></A>22.3.5 Go Classes</H3>
+<H3><A name="Go_classes">23.4.5 Go Classes</A></H3>
<P> Go has interfaces, methods and inheritance, but it does not have
classes in the same sense as C++. This sections describes how SWIG
represents C++ classes represented in Go.</P>
MyMethod() int
}
-MyClassMyFactoryFunction() MyClass {
+func MyClassMyFactoryFunction() MyClass {
// swig magic here
}
</PRE>
<P>Note that the factory function does not return a go pointer; it
actually returns a go interface. If the returned pointer can be null,
you can check for this by calling the Swigcptr() method.</P>
-<H4><A name="Go_class_inheritance"></A>22.3.5.1 Go Class Inheritance</H4>
+<H4><A name="Go_class_memory">23.4.5.1 Go Class Memory Management</A></H4>
+<P> Calling <TT>NewClassName</TT> for a C++ class <TT>ClassName</TT>
+ will allocate memory using the C++ memory allocator. This memory will
+ not be automatically freed by Go's garbage collector as the object
+ ownership is not tracked. When you are done with the C++ object you
+ must free it using <TT>DeleteClassName</TT>.
+<BR>
+<BR> The most Go idiomatic way to manage the memory for some C++ class
+ is to call <TT>NewClassName</TT> followed by a <TT><A href="https://golang.org/doc/effective_go.html#defer">
+defer</A></TT> of the <TT>DeleteClassName</TT> call. Using <TT>defer</TT>
+ ensures that the memory of the C++ object is freed as soon as the
+ function containing the <TT>defer</TT> statement returns. Furthemore <TT>
+defer</TT> works great for short-lived objects and fits nicely C++'s
+ RAII idiom. Example:</P>
+<DIV class="code">
+<PRE>
+func UseClassName(...) ... {
+ o := NewClassName(...)
+ defer DeleteClassName(o)
+ // Use the ClassName object
+ return ...
+}
+</PRE>
+</DIV>
+<P> With increasing complexity, especially complex C++ object
+ hierarchies, the correct placement of <TT>defer</TT> statements becomes
+ harder and harder as C++ objects need to be freed in the correct order.
+ This problem can be eased by keeping a C++ object function local so
+ that it is only available to the function that creates a C++ object and
+ functions called by this function. Example:</P>
+<DIV class="code">
+<PRE>
+func WithClassName(constructor args, f func(ClassName, ...interface{}) error, data ...interface{}) error {
+ o := NewClassName(constructor args)
+ defer DeleteClassName(o)
+ return f(o, data...)
+}
+
+func UseClassName(o ClassName, data ...interface{}) (err error) {
+ // Use the ClassName object and additional data and return error.
+}
+
+func main() {
+ WithClassName(constructor args, UseClassName, additional data)
+}
+</PRE>
+</DIV>
+<P> Using <TT>defer</TT> has limitations though, especially when it
+ comes to long-lived C++ objects whichs lifetimes are hard to predict.
+ For such C++ objects a common technique is to store the C++ object into
+ a Go object, and to use the Go function <TT>runtime.SetFinalizer</TT>
+ to add a finalizer which frees the C++ object when the Go object is
+ freed. It is strongly recommended to read the <A href="https://golang.org/pkg/runtime/#SetFinalizer">
+runtime.SetFinalizer</A> documentation before using this technique to
+ understand the <TT>runtime.SetFinalizer</TT> limitations.
+<BR></P>
+<P> Common pitfalls with <TT>runtime.SetFinalizer</TT> are:</P>
+<UL>
+<LI> If a hierarchy of C++ objects will be automatically freed by Go
+ finalizers then the Go objects that store the C++ objects need to
+ replicate the hierarchy of the C++ objects to prevent that C++ objects
+ are freed prematurely while other C++ objects still rely on them.</LI>
+<LI> The usage of Go finalizers is problematic with C++'s RAII idiom as
+ it isn't predictable when the finalizer will run and this might require
+ a Close or Delete method to be added the Go object that stores a C++
+ object to mitigate.</LI>
+<LI> The Go finalizer function typically runs in a different OS thread
+ which can be problematic with C++ code that uses thread-local storage.</LI>
+</UL>
+<P> <TT>runtime.SetFinalizer</TT> Example:</P>
+<DIV class="code">
+<PRE>
+import (
+ "runtime"
+ "wrap" // SWIG generated wrapper code
+)
+
+type GoClassName struct {
+ wcn wrap.ClassName
+}
+
+func NewGoClassName() *GoClassName {
+ o := &GoClassName{wcn: wrap.NewClassName()}
+ runtime.SetFinalizer(o, deleteGoClassName)
+ return o
+}
+
+func deleteGoClassName(o *GoClassName) {
+ // Runs typically in a different OS thread!
+ wrap.DeleteClassName(o.wcn)
+ o.wcn = nil
+}
+
+func (o *GoClassName) Close() {
+ // If the C++ object has a Close method.
+ o.wcn.Close()
+
+ // If the GoClassName object is no longer in an usable state.
+ runtime.SetFinalizer(o, nil) // Remove finalizer.
+ deleteGoClassName() // Free the C++ object.
+}
+</PRE>
+</DIV>
+<H4><A name="Go_class_inheritance">23.4.5.2 Go Class Inheritance</A></H4>
<P> C++ class inheritance is automatically represented in Go due to its
use of interfaces. The interface for a child class will be a superset
of the interface of its parent class. Thus a value of the child class
type in Go may be passed to a function which expects the parent class.
Doing the reverse will require an explicit type assertion, which will
be checked dynamically.</P>
-<H3><A name="Go_templates"></A>22.3.6 Go Templates</H3>
+<H3><A name="Go_templates">23.4.6 Go Templates</A></H3>
<P> In order to use C++ templates in Go, you must tell SWIG to create
wrappers for a particular template instantation. To do this, use the <TT>
%template</TT> directive.</P>
-<H3><A name="Go_director_classes"></A>22.3.7 Go Director Classes</H3>
+<H3><A name="Go_director_classes">23.4.7 Go Director Classes</A></H3>
<P> SWIG's director feature permits a Go type to act as the subclass of
- a C++ class with virtual methods. This is complicated by the fact that
- C++ and Go define inheritance differently. In Go, structs can inherit
- methods via anonymous field embedding. However, when a method is called
- for an embedded struct, if that method calls any other methods, they
- are called for the embedded struct, not for the original type.
- Therefore, SWIG must use Go interfaces to represent C++ inheritance.</P>
-<P> In order to use the director feature in Go, you must define a type
- in your Go code. You must then add methods for the type. Define a
- method in Go for each C++ virtual function that you want to override.
- You must then create a value of your new type, and pass a pointer to it
- to the function <TT>NewDirectorClassName</TT>, where <TT>ClassName</TT>
- is the name of the C++ class. That will return a value of type <TT>
-ClassName</TT>.</P>
-<P> For example:</P>
+ a C++ class. This is complicated by the fact that C++ and Go define
+ inheritance differently. SWIG normally represents the C++ class
+ inheritance automatically in Go via interfaces but with a Go type
+ representing a subclass of a C++ class some manual work is necessary.</P>
+<P> This subchapter gives a step by step guide how to properly sublass a
+ C++ class with a Go type. In general it is strongly recommended to
+ follow this guide completely to avoid common pitfalls with directors in
+ Go.</P>
+<H4><A name="Go_director_example_cpp_code">23.4.7.1 Example C++ code</A></H4>
+<P> The step by step guide is based on two example C++ classes.
+ FooBarAbstract is an abstract C++ class and the FooBarCpp class
+ inherits from it. This guide explains how to implement a FooBarGo class
+ similar to the FooBarCpp class.</P>
+<P> <TT>FooBarAbstract</TT> abstract C++ class:</P>
+<DIV class="code">
+<PRE>
+class FooBarAbstract
+{
+public:
+ FooBarAbstract() {};
+ virtual ~FooBarAbstract() {};
+
+ std::string FooBar() {
+ return this->Foo() + ", " + this->Bar();
+ };
+
+protected:
+ virtual std::string Foo() {
+ return "Foo";
+ };
+
+ virtual std::string Bar() = 0;
+};
+</PRE>
+</DIV>
+<P> <TT>FooBarCpp</TT> C++ class:</P>
+<DIV class="code">
+<PRE>
+class FooBarCpp : public FooBarAbstract
+{
+protected:
+ virtual std::string Foo() {
+ return "C++ " + FooBarAbstract::Foo();
+ }
+
+ virtual std::string Bar() {
+ return "C++ Bar";
+ }
+};
+</PRE>
+</DIV>
+<P> Returned string by the <TT>FooBarCpp::FooBar</TT> method is:</P>
+<DIV class="code">
+<PRE>
+C++ Foo, C++ Bar
+</PRE>
+</DIV>
+<P> The complete example, including the <TT>FooBarGoo</TT> class
+ implementation, can be found in <A href="#Go_director_foobargo_class">
+the end of the guide</A>.</P>
+<H4><A name="Go_director_enable">23.4.7.2 Enable director feature</A></H4>
+<P> The director feature is disabled by default. To use directors you
+ must make two changes to the interface file. First, add the "directors"
+ option to the %module directive, like this:</P>
+<DIV class="code">
+<PRE>
+%module(directors="1") modulename
+</PRE>
+</DIV>
+<P> Second, you must use the %feature("director") directive to tell SWIG
+ which classes should get directors. In the example the FooBarAbstract
+ class needs the director feature enabled so that the FooBarGo class can
+ inherit from it, like this:</P>
+<DIV class="code">
+<PRE>
+%feature("director") FooBarAbstract;
+</PRE>
+</DIV>
+<P> For a more detailed documentation of the director feature and how to
+ enable or disable it for specific classes and virtual methods see
+ SWIG's Java documentation on directors.</P>
+<H4><A name="Go_director_ctor_dtor">23.4.7.3 Constructor and destructor</A>
+</H4>
+<P> SWIG creates an additional set of constructor and destructor
+ functions once the director feature has been enabled for a C++ class. <TT>
+NewDirectorClassName</TT> allows overriding virtual methods on the new
+ object instance and <TT>DeleteDirectorClassName</TT> needs to be used
+ to free a director object instance created with <TT>
+NewDirectorClassName</TT>. More on overriding virtual methods follows
+ later in this guide under <A href="#Go_director_overriding">overriding
+ virtual methods</A>.</P>
+<P> The default constructor and destructor functions <TT>NewClassName</TT>
+ and <TT>DeleteClassName</TT> can still be used as before so that
+ existing code doesn't break just because the director feature has been
+ enabled for a C++ class. The behavior is undefined if the default and
+ director constructor and destructor functions get mixed and so great
+ care needs to be taken that only one of the constructor and destructor
+ function pairs is used for any object instance. Both constructor
+ functions, the default and the director one, return the same interface
+ type. This makes it potentially hard to know which destructor function,
+ the default or the director one, needs to be called to delete an object
+ instance.</P>
+<P> In<B> theory</B> the <TT>DirectorInterface</TT> method could be used
+ to determine if an object instance was created via <TT>
+NewDirectorClassName</TT>:</P>
+<DIV class="code">
+<PRE>
+if o.DirectorInterface() != nil {
+ DeleteDirectorClassName(o)
+} else {
+ DeleteClassName(o)
+}
+</PRE>
+</DIV>
+<P> In<B> practice</B> it is strongly recommended to embed a director
+ object instance in a Go struct so that a director object instance will
+ be represented as a distinct Go type that subclasses a C++ class. For
+ this Go type custom constructor and destructor functions take care of
+ the director constructor and destructor function calls and the
+ resulting Go class will appear to the user as any other SWIG wrapped
+ C++ class. More on properly subclassing a C++ class follows later in
+ this guide under <A href="#Go_director_subclass">subclass via embedding</A>
+.</P>
+<H4><A name="Go_director_overriding">23.4.7.4 Override virtual methods</A>
+</H4>
+<P> In order to override virtual methods on a C++ class with Go methods
+ the <TT>NewDirectorClassName</TT> constructor functions receives a <TT>
+DirectorInterface</TT> argument. The methods in the <TT>
+DirectorInterface</TT> are a subset of the public and protected virtual
+ methods of the C++ class. If the <TT>DirectorInterface</TT> contains a
+ method with a matching signature to a virtual method of the C++ class
+ then the virtual C++ method will be overwritten with the Go method. As
+ Go doesn't support protected methods all overriden protected virtual
+ C++ methods will be public in Go.</P>
+<P> As an example see part of the <TT>FooBarGo</TT> class:</P>
+<DIV class="code">
+<PRE>
+type overwrittenMethodsOnFooBarAbstract struct {
+ fb FooBarAbstract
+}
+
+func (om *overwrittenMethodsOnFooBarAbstract) Foo() string {
+ ...
+}
+
+func (om *overwrittenMethodsOnFooBarAbstract) Bar() string {
+ ...
+}
+
+func NewFooBarGo() FooBarGo {
+ om := &overwrittenMethodsOnFooBarAbstract{}
+ fb := NewDirectorFooBarAbstract(om)
+ om.fb = fb
+ ...
+}
+</PRE>
+</DIV>
+<P> The complete example, including the <TT>FooBarGoo</TT> class
+ implementation, can be found in <A href="#Go_director_foobargo_class">
+the end of the guide</A>. In this part of the example the virtual
+ methods <TT>FooBarAbstract::Foo</TT> and <TT>FooBarAbstract::Bar</TT>
+ have been overwritten with Go methods similarly to how the <TT>
+FooBarAbstract</TT> virtual methods are overwritten by the <TT>FooBarCpp</TT>
+ class.</P>
+<P> The <TT>DirectorInterface</TT> in the example is implemented by the <TT>
+overwrittenMethodsOnFooBarAbstract</TT> Go struct type. A pointer to a <TT>
+overwrittenMethodsOnFooBarAbstract</TT> struct instance will be given to
+ the <TT>NewDirectorFooBarAbstract</TT> constructor function. The
+ constructor return value implements the <TT>FooBarAbstract</TT>
+ interface. <TT>overwrittenMethodsOnFooBarAbstract</TT> could in theory
+ be any Go type but in practice a struct is used as it typically
+ contains at least a value of the C++ class interface so that the
+ overwritten methods can use the rest of the C++ class. If the <TT>
+FooBarGo</TT> class would receive additional constructor arguments then
+ these would also typically be stored in the <TT>
+overwrittenMethodsOnFooBarAbstract</TT> struct so that they can be used
+ by the Go methods.</P>
+<H4><A name="Go_director_base_methods">23.4.7.5 Call base methods</A></H4>
+<P> Often a virtual method will be overwritten to extend the original
+ behavior of the method in the base class. This is also the case for the
+ <TT>FooBarCpp::Foo</TT> method of the example code:</P>
+<DIV class="code">
+<PRE>
+virtual std::string Foo() {
+ return "C++ " + FooBarAbstract::Foo();
+}
+</PRE>
+</DIV>
+<P> To use base methods the <TT>DirectorClassNameMethodName</TT> wrapper
+ functions are automatically generated by SWIG for public and protected
+ virtual methods. The <TT>FooBarGo.Foo</TT> implementation in the
+ example looks like this:</P>
+<DIV class="code">
+<PRE>
+func (om *overwrittenMethodsOnFooBarAbstract) Foo() string {
+ return "Go " + DirectorFooBarAbstractFoo(om.fb)
+}
+</PRE>
+</DIV>
+<P> The complete example, including the <TT>FooBarGoo</TT> class
+ implementation, can be found in <A href="#Go_director_foobargo_class">
+the end of the guide</A>.</P>
+<H4><A name="Go_director_subclass">23.4.7.6 Subclass via embedding</A></H4>
+<P> <A href="#Go_director_ctor_dtor">As previously mentioned in this
+ guide</A> the default and director constructor functions return the
+ same interface type. To properly subclass a C++ class with a Go type
+ the director object instance returned by the <TT>NewDirectorClassName</TT>
+ constructor function should be embedded into a Go struct so that it
+ represents a distinct but compatible type in Go's type system. This Go
+ struct should be private and the constructor and destructor functions
+ should instead work with a public interface type so that the Go class
+ that subclasses a C++ class can be used as a compatible drop in.</P>
+<P> The subclassing part of the <TT>FooBarGo</TT> class for an example
+ looks like this:</P>
+<DIV class="code">
+<PRE>
+type FooBarGo interface {
+ FooBarAbstract
+ deleteFooBarAbstract()
+ IsFooBarGo()
+}
+
+type fooBarGo struct {
+ FooBarAbstract
+}
+
+func (fbgs *fooBarGo) deleteFooBarAbstract() {
+ DeleteDirectorFooBarAbstract(fbgs.FooBarAbstract)
+}
+
+func (fbgs *fooBarGo) IsFooBarGo() {}
+
+func NewFooBarGo() FooBarGo {
+ om := &overwrittenMethodsOnFooBarAbstract{}
+ fb := NewDirectorFooBarAbstract(om)
+ om.fb = fb
+
+ return &fooBarGo{FooBarAbstract: fb}
+}
+
+func DeleteFooBarGo(fbg FooBarGo) {
+ fbg.deleteFooBarAbstract()
+}
+</PRE>
+</DIV>
+<P> The complete example, including the <TT>FooBarGoo</TT> class
+ implementation, can be found in <A href="#Go_director_foobargo_class">
+the end of the guide</A>. In this part of the example the private <TT>
+fooBarGo</TT> struct embeds <TT>FooBarAbstract</TT> which lets the <TT>
+fooBarGo</TT> Go type "inherit" all the methods of the <TT>
+FooBarAbstract</TT> C++ class by means of embedding. The public <TT>
+FooBarGo</TT> interface type includes the <TT>FooBarAbstract</TT>
+ interface and hence <TT>FooBarGo</TT> can be used as a drop in
+ replacement for <TT>FooBarAbstract</TT> while the reverse isn't
+ possible and would raise a compile time error. Furthemore the
+ constructor and destructor functions <TT>NewFooBarGo</TT> and <TT>
+DeleteFooBarGo</TT> take care of all the director specifics and to the
+ user the class appears as any other SWIG wrapped C++ class.</P>
+<H4><A name="Go_director_finalizer">23.4.7.7 Memory management with
+ runtime.SetFinalizer</A></H4>
+<P> In general all guidelines for <A href="#Go_class_memory">C++ class
+ memory management</A> apply as well to director classes. One often
+ overlooked limitation with <TT>runtime.SetFinalizer</TT> is that a
+ finalizer doesn't run in case of a cycle and director classes typically
+ have a cycle. The cycle in the <TT>FooBarGo</TT> class is here:</P>
+<DIV class="code">
+<PRE>
+type overwrittenMethodsOnFooBarAbstract struct {
+ fb FooBarAbstract
+}
+
+func NewFooBarGo() FooBarGo {
+ om := &overwrittenMethodsOnFooBarAbstract{}
+ fb := NewDirectorFooBarAbstract(om) // fb.v = om
+ om.fb = fb // Backlink causes cycle as fb.v = om!
+ ...
+}
+</PRE>
+</DIV>
+<P> In order to be able to use <TT>runtime.SetFinalizer</TT>
+ nevertheless the finalizer needs to be set on something that isn't in a
+ cycle and that references the director object instance. In the <TT>
+FooBarGo</TT> class example the <TT>FooBarAbstract</TT> director
+ instance can be automatically deleted by setting the finalizer on <TT>
+fooBarGo</TT>:</P>
+<DIV class="code">
+<PRE>
+type fooBarGo struct {
+ FooBarAbstract
+}
+
+type overwrittenMethodsOnFooBarAbstract struct {
+ fb FooBarAbstract
+}
+
+func NewFooBarGo() FooBarGo {
+ om := &overwrittenMethodsOnFooBarAbstract{}
+ fb := NewDirectorFooBarAbstract(om)
+ om.fb = fb // Backlink causes cycle as fb.v = om!
+
+ fbgs := &fooBarGo{FooBarAbstract: fb}
+ runtime.SetFinalizer(fbgs, FooBarGo.deleteFooBarAbstract)
+ return fbgs
+}
+</PRE>
+</DIV>
+<P> Furthermore if <TT>runtime.SetFinalizer</TT> is in use either the <TT>
+DeleteClassName</TT> destructor function needs to be removed or the <TT>
+fooBarGo</TT> struct needs additional data to prevent double deletion.
+ Please read the <A href="#Go_class_memory">C++ class memory management</A>
+ subchapter before using <TT>runtime.SetFinalizer</TT> to know all of
+ its gotchas.</P>
+<H4><A name="Go_director_foobargo_class">23.4.7.8 Complete FooBarGo
+ example class</A></H4>
+<P> The complete and annotated <TT>FooBarGo</TT> class looks like this:</P>
<DIV class="code">
<PRE>
-type GoClass struct { }
-func (p *GoClass) VirtualFunction() { }
-func MakeClass() ClassName {
- return NewDirectorClassName(&GoClass{})
+// FooBarGo is a superset of FooBarAbstract and hence FooBarGo can be used as a
+// drop in replacement for FooBarAbstract but the reverse causes a compile time
+// error.
+type FooBarGo interface {
+ FooBarAbstract
+ deleteFooBarAbstract()
+ IsFooBarGo()
+}
+
+// Via embedding fooBarGo "inherits" all methods of FooBarAbstract.
+type fooBarGo struct {
+ FooBarAbstract
+}
+
+func (fbgs *fooBarGo) deleteFooBarAbstract() {
+ DeleteDirectorFooBarAbstract(fbgs.FooBarAbstract)
+}
+
+// The IsFooBarGo method ensures that FooBarGo is a superset of FooBarAbstract.
+// This is also how the class hierarchy gets represented by the SWIG generated
+// wrapper code. For an instance FooBarCpp has the IsFooBarAbstract and
+// IsFooBarCpp methods.
+func (fbgs *fooBarGo) IsFooBarGo() {}
+
+// Go type that defines the DirectorInterface. It contains the Foo and Bar
+// methods that overwrite the respective virtual C++ methods on FooBarAbstract.
+type overwrittenMethodsOnFooBarAbstract struct {
+ // Backlink to FooBarAbstract so that the rest of the class can be used by
+ // the overridden methods.
+ fb FooBarAbstract
+
+ // If additional constructor arguments have been given they are typically
+ // stored here so that the overriden methods can use them.
+}
+
+func (om *overwrittenMethodsOnFooBarAbstract) Foo() string {
+ // DirectorFooBarAbstractFoo calls the base method FooBarAbstract::Foo.
+ return "Go " + DirectorFooBarAbstractFoo(om.fb)
+}
+
+func (om *overwrittenMethodsOnFooBarAbstract) Bar() string {
+ return "Go Bar"
+}
+
+func NewFooBarGo() FooBarGo {
+ // Instantiate FooBarAbstract with selected methods overridden. The methods
+ // that will be overwritten are defined on
+ // overwrittenMethodsOnFooBarAbstract and have a compatible signature to the
+ // respective virtual C++ methods. Furthermore additional constructor
+ // arguments will be typically stored in the
+ // overwrittenMethodsOnFooBarAbstract struct.
+ om := &overwrittenMethodsOnFooBarAbstract{}
+ fb := NewDirectorFooBarAbstract(om)
+ om.fb = fb // Backlink causes cycle as fb.v = om!
+
+ fbgs := &fooBarGo{FooBarAbstract: fb}
+ // The memory of the FooBarAbstract director object instance can be
+ // automatically freed once the FooBarGo instance is garbage collected by
+ // uncommenting the following line. Please make sure to understand the
+ // runtime.SetFinalizer specific gotchas before doing this. Furthemore
+ // DeleteFooBarGo should be deleted if a finalizer is in use or the fooBarGo
+ // struct needs additional data to prevent double deletion.
+ // runtime.SetFinalizer(fbgs, FooBarGo.deleteFooBarAbstract)
+ return fbgs
+}
+
+// Recommended to be removed if runtime.SetFinalizer is in use.
+func DeleteFooBarGo(fbg FooBarGo) {
+ fbg.deleteFooBarAbstract()
}
</PRE>
</DIV>
-<P> Any call in C++ code to the virtual function will wind up calling
- the method defined in Go. The Go code may of course call other methods
- on itself, and those methods may be defined either in Go or in C++.</P>
-<H3><A name="Go_primitive_type_mappings"></A>22.3.8 Default Go primitive
- type mappings</H3>
+<P> Returned string by the <TT>FooBarGo.FooBar</TT> method is:</P>
+<DIV class="code">
+<PRE>
+Go Foo, Go Bar
+</PRE>
+</DIV>
+<P> For comparison the <TT>FooBarCpp</TT> class looks like this:</P>
+<DIV class="code">
+<PRE>
+class FooBarCpp : public FooBarAbstract
+{
+protected:
+ virtual std::string Foo() {
+ return "C++ " + FooBarAbstract::Foo();
+ }
+
+ virtual std::string Bar() {
+ return "C++ Bar";
+ }
+};
+</PRE>
+</DIV>
+<P> For comparison the returned string by the <TT>FooBarCpp::FooBar</TT>
+ method is:</P>
+<DIV class="code">
+<PRE>
+C++ Foo, C++ Bar
+</PRE>
+</DIV>
+<P> The complete source of this example can be found under <A href="https://github.com/swig/swig/tree/master/Examples/go/director">
+ SWIG/Examples/go/director/</A>.</P>
+<H3><A name="Go_primitive_type_mappings">23.4.8 Default Go primitive
+ type mappings</A></H3>
<P> The following table lists the default type mapping from C/C++ to Go.
This table will tell you which Go type to expect for a function which
uses a given C/C++ type.</P>
<TR><TD>unsigned short</TD><TD>uint16</TD></TR>
<TR><TD>int</TD><TD>int</TD></TR>
<TR><TD>unsigned int</TD><TD>uint</TD></TR>
-<TR><TD>long</TD><TD>int32 or int64, depending on <TT>-long-type-size</TT>
-</TD></TR>
-<TR><TD>unsigned long</TD><TD>uint32 or uint64, depending on <TT>
--long-type-size</TT></TD></TR>
+<TR><TD>long</TD><TD>int64</TD></TR>
+<TR><TD>unsigned long</TD><TD>uint64</TD></TR>
<TR><TD>long long</TD><TD>int64</TD></TR>
<TR><TD>unsigned long long</TD><TD>uint64</TD></TR>
<TR><TD>float</TD><TD>float32</TD></TR>
<P> These type mappings are defined by the "gotype" typemap. You may
change that typemap, or add new values, to control how C/C++ types are
mapped into Go types.</P>
-<H3><A name="Go_output_arguments"></A>22.3.9 Output arguments</H3>
+<H3><A name="Go_output_arguments">23.4.9 Output arguments</A></H3>
<P>Because of limitations in the way output arguments are processed in
swig, a function with output arguments will not have multiple return
values. Instead, you must pass a pointer into the C++ function to tell
void f(char *output);
</PRE>
</DIV>
-<H3><A name="Go_adding_additional_code"></A>22.3.10 Adding additional go
- code</H3>
+<H3><A name="Go_adding_additional_code">23.4.10 Adding additional go
+ code</A></H3>
<P>Often the APIs generated by swig are not very natural in go,
especially if there are output arguments. You can insert additional go
wrapping code to add new APIs with <CODE>%insert(go_wrapper)</CODE>,
just a few, then you might as well define your own struct that includes
the swig-wrapped object, instead of adding methods to the
swig-generated object.</P>
-<P>This only works if your wrappers do not need to import other go
- modules. There is at present no way to insert import statements in the
- correct place in swig-generated go. If you need to do that, you must
- put your go code in a separate file.</P>
-<HR NOSHADE>
+<P>If you need to import other go packages, you can do this with <CODE>
+%go_import</CODE>. For example,</P>
+<DIV class="code">
+<PRE>
+%go_import("fmt", _ "unusedPackage", rp "renamed/package")
+
+%insert(go_wrapper) %{
-<!-- Hand-written HTML -->
-<H1><A name="Guile"></A>23 SWIG and Guile</H1>
+func foo() {
+ fmt.Println("Some string:", rp.GetString())
+}
+
+// Importing the same package twice is permitted,
+// Go code will be generated with only the first instance of the import.
+%go_import("fmt")
+
+%insert(go_wrapper) %{
+
+func bar() {
+ fmt.Println("Hello world!")
+}
+
+%}
+</PRE>
+</DIV>
+<H3><A name="Go_typemaps">23.4.11 Go typemaps</A></H3>
+<P> You can use the <TT>%typemap</TT> directive to modify SWIG's default
+ wrapping behavior for specific C/C++ types. You need to be familiar
+ with the material in the general "<A href="#Typemaps">Typemaps</A>"
+ chapter. That chapter explains how to define a typemap. This section
+ describes some specific typemaps used for Go.</P>
+<P> In general type conversion code may be written either in C/C++ or in
+ Go. The choice to make normally depends on where memory should be
+ allocated. To allocate memory controlled by the Go garbage collector,
+ write Go code. To allocate memory in the C/C++ heap, write C code.</P>
+<TABLE BORDER summary="Go Typemaps">
+<TR><TD><B>Typemap</B></TD><TD><B>Description</B></TD></TR>
+<TR><TD>gotype</TD><TD> The Go type to use for a C++ type. This type
+ will appear in the generated Go wrapper function. If this is not
+ defined SWIG will use a default as <A href="#Go_primitive_type_mappings">
+described above</A>.</TD></TR>
+<TR><TD>imtype</TD><TD> An intermediate Go type used by the "goin",
+ "goout", "godirectorin", and "godirectorout" typemaps. If this typemap
+ is not defined for a C/C++ type, the gotype typemape will be used. This
+ is useful when gotype is best converted to C/C++ using Go code.</TD></TR>
+<TR><TD>goin</TD><TD> Go code to convert from gotype to imtype when
+ calling a C/C++ function. SWIG will then internally convert imtype to a
+ C/C++ type and pass it down. If this is not defined, or is the empty
+ string, no conversion is done.</TD></TR>
+<TR><TD>in</TD><TD> C/C++ code to convert the internally generated C/C++
+ type, based on imtype, into the C/C++ type that a function call
+ expects. If this is not defined the value will simply be cast to the
+ desired type.</TD></TR>
+<TR><TD>out</TD><TD> C/C++ code to convert the C/C++ type that a
+ function call returns into the internally generated C/C++ type, based
+ on imtype, that will be returned to Go. If this is not defined the
+ value will simply be cast to the desired type.</TD></TR>
+<TR><TD>goout</TD><TD> Go code to convert a value returned from a C/C++
+ function from imtype to gotype. If this is not defined, or is the empty
+ string, no conversion is done.</TD></TR>
+<TR><TD>argout</TD><TD> C/C++ code to adjust an argument value when
+ returning from a function. This is called after the real C/C++ function
+ has run. This uses the internally generated C/C++ type, based on
+ imtype. This is only useful for a pointer type of some sort. If this is
+ not defined nothing will be done.</TD></TR>
+<TR><TD>goargout</TD><TD> Go code to adjust an argument value when
+ returning from a function. This is called after the real C/C++ function
+ has run. The value will be in imtype. This is only useful for a pointer
+ type of some sort. If this is not defined, or is the empty string,
+ nothing will be done.</TD></TR>
+<TR><TD>directorin</TD><TD> C/C++ code to convert the C/C++ type used to
+ call a director method into the internally generated C/C++ type, based
+ on imtype, that will be passed to Go. If this is not defined the value
+ will simply be cast to the desired type.</TD></TR>
+<TR><TD>godirectorin</TD><TD> Go code to convert a value used to call a
+ director method from imtype to gotype. If this is not defined, or is
+ the empty string, no conversion is done.</TD></TR>
+<TR><TD>godirectorout</TD><TD> Go code to convert a value returned from
+ a director method from gotype to imtype. If this is not defined, or is
+ the empty string, no conversion is done.</TD></TR>
+<TR><TD>directorout</TD><TD> C/C++ code to convert a value returned from
+ a director method from the internally generated C/C++ type, based on
+ imtype, into the type that the method should return If this is not
+ defined the value will simply be cast to the desired type.</TD></TR>
+</TABLE>
+<HR NOSHADE>
+<H1><A name="Guile">24 SWIG and Guile</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
</DIV>
<!-- INDEX -->
<P> This section details guile-specific support in SWIG.</P>
-<H2><A name="Guile_nn1"></A>23.1 Supported Guile Versions</H2>
+<H2><A name="Guile_nn1">24.1 Supported Guile Versions</A></H2>
<P> SWIG works with Guile versions 1.8.x and 2.0.x. Support for version
1.6.x has been dropped. The last version of SWIG that still works with
Guile version 1.6.x is SWIG 2.0.9.</P>
for improved performance. This is currently not tested with swig so
your mileage may vary. To be safe set environment variable
GUILE_AUTO_COMPILE to 0 when using swig generated guile code.</P>
-<H2><A name="Guile_nn2"></A>23.2 Meaning of "Module"</H2>
+<H2><A name="Guile_nn2">24.2 Meaning of "Module"</A></H2>
<P> There are three different concepts of "module" involved, defined
separately for SWIG, Guile, and Libtool. To avoid horrible confusion,
we explicitly prefix the context, e.g., "guile-module".</P>
-<H2><A name="Guile_nn3"></A>23.3 Old GH Guile API</H2>
+<H2><A name="Guile_nn3">24.3 Old GH Guile API</A></H2>
<P>Guile 1.8 and older could be interfaced using two different api's,
the SCM or the GH API. The GH interface to guile is deprecated. Read
more about why in the <A href="http://www.gnu.org/software/guile/docs/docs-1.6/guile-ref/GH.html#GH">
from SWIG. The last version of SWIG that can still generate guile GH
wrapper code is 2.0.9. Please use that version if you really need the
GH wrapper code.</P>
-<H2><A name="Guile_nn4"></A>23.4 Linkage</H2>
+<H2><A name="Guile_nn4">24.4 Linkage</A></H2>
<P> Guile support is complicated by a lack of user community
cohesiveness, which manifests in multiple shared-library usage
conventions. A set of policies implementing a usage convention is
called a<B> linkage</B>.</P>
-<H3><A name="Guile_nn5"></A>23.4.1 Simple Linkage</H3>
+<H3><A name="Guile_nn5">24.4.1 Simple Linkage</A></H3>
<P> The default linkage is the simplest; nothing special is done. In
this case the function <CODE>SWIG_init()</CODE> is exported. Simple
linkage can be used in several ways:</P>
<DIV class="targetlang">
<PRE>
(module-map (lambda (sym var)
- (module-export! (current-module) (list sym)))
- (current-module))
+ (module-export! (current-module) (list sym)))
+ (current-module))
</PRE>
</DIV>
<P>SWIG can also generate this Scheme stub (from <CODE>define-module</CODE>
<P>If you want to include several SWIG modules, you would need to rename
<CODE>SWIG_init</CODE> via a preprocessor define to avoid symbol
clashes. For this case, however, passive linkage is available.</P>
-<H3><A name="Guile_nn6"></A>23.4.2 Passive Linkage</H3>
+<H3><A name="Guile_nn6">24.4.2 Passive Linkage</A></H3>
<P>Passive linkage is just like simple linkage, but it generates an
initialization function whose name is derived from the module and
package name (see below).</P>
<P>You should use passive linkage rather than simple linkage when you
are using multiple modules.</P>
-<H3><A name="Guile_nn7"></A>23.4.3 Native Guile Module Linkage</H3>
+<H3><A name="Guile_nn7">24.4.3 Native Guile Module Linkage</A></H3>
<P>SWIG can also generate wrapper code that does all the Guile module
declarations on its own if you pass it the <CODE>-Linkage module</CODE>
command-line option.</P>
</PRE>
</DIV></LI>
</UL>
-<H3><A name="Guile_nn8"></A>23.4.4 Old Auto-Loading Guile Module Linkage</H3>
+<H3><A name="Guile_nn8">24.4.4 Old Auto-Loading Guile Module Linkage</A></H3>
<P>Guile used to support an autoloading facility for object-code
modules. This support has been marked deprecated in version 1.4.1 and
is going to disappear sooner or later. SWIG still supports building
<P>When invoked with the <CODE>-Linkage ltdlmod</CODE> command-line
option, SWIG generates an exported module initialization function with
an appropriate name.</P>
-<H3><A name="Guile_nn9"></A>23.4.5 Hobbit4D Linkage</H3>
+<H3><A name="Guile_nn9">24.4.5 Hobbit4D Linkage</A></H3>
<P> The only other linkage supported at this time creates shared object
libraries suitable for use by hobbit's <CODE>(hobbit4d link)</CODE>
guile module. This is called the "hobbit" linkage, and requires also
case foo.i declares the module to be "foo"). The installed files are
my/lib/libfoo.so.X.Y.Z and friends. This scheme is still very
experimental; the (hobbit4d link) conventions are not well understood.</P>
-<H2><A name="Guile_nn10"></A>23.5 Underscore Folding</H2>
+<H2><A name="Guile_nn10">24.5 Underscore Folding</A></H2>
<P> Underscores are converted to dashes in identifiers. Guile support
may grow an option to inhibit this folding in the future, but no one
has complained so far.</P>
<P>You can use the SWIG directives <CODE>%name</CODE> and <CODE>%rename</CODE>
to specify the Guile name of the wrapped functions and variables (see
CHANGES).</P>
-<H2><A name="Guile_nn11"></A>23.6 Typemaps</H2>
+<H2><A name="Guile_nn11">24.6 Typemaps</A></H2>
<P> The Guile module handles all types via typemaps. This information is
read from <CODE>Lib/guile/typemaps.i</CODE>. Some non-standard typemap
substitutions are supported:</P>
must be called, the constant will appear as a scheme variable. See <A href="#Customization_features">
Features and the %feature directive</A> for info on how to apply the
%feature.</P>
-<H2><A name="Guile_nn12"></A>23.7 Representation of pointers as smobs</H2>
+<H2><A name="Guile_nn12">24.7 Representation of pointers as smobs</A></H2>
<P> For pointer types, SWIG uses Guile smobs. SWIG smobs print like
this: <CODE>#<swig struct xyzzy * 0x1234affe></CODE> Two of them are <CODE>
equal?</CODE> if and only if they have the same type and value.</P>
The run-time type checker</A>. If the Scheme object passed was not a
SWIG smob representing a compatible pointer, a <CODE>wrong-type-arg</CODE>
exception is raised.</P>
-<H3><A name="Guile_nn14"></A>23.7.1 Smobs</H3>
+<H3><A name="Guile_nn14">24.7.1 Smobs</A></H3>
<P> In earlier versions of SWIG, C pointers were represented as Scheme
strings containing a hexadecimal rendering of the pointer value and a
mangled type name. As Guile allows registering user types, so-called
object and the second word of data is the swig_type_info * structure
describing this type. If a generated GOOPS module has been loaded,
smobs will be wrapped by the corresponding GOOPS class.</P>
-<H3><A name="Guile_nn15"></A>23.7.2 Garbage Collection</H3>
+<H3><A name="Guile_nn15">24.7.2 Garbage Collection</A></H3>
<P>Garbage collection is a feature of Guile since version 1.6. As SWIG
now requires Guile > 1.8, it is automatically included. Garbage
collection works like this. Every swig_type_info structure stores in
Object ownership and %newobject</A> in the SWIG manual. All typemaps
use an $owner var, and the guile module replaces $owner with 0 or 1
depending on feature:new.</P>
-<H2><A name="Guile_nn16"></A>23.8 Exception Handling</H2>
+<H2><A name="Guile_nn16">24.8 Exception Handling</A></H2>
<P> SWIG code calls <CODE>scm_error</CODE> on exception, using the
following mapping:<DIV class="code">
<PRE>
- 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");
+ 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");
</PRE>
</DIV></P>
<P> The default when not specified here is to use "swig-error". See
Lib/exception.i for details.</P>
-<H2><A name="Guile_nn17"></A>23.9 Procedure documentation</H2>
+<H2><A name="Guile_nn17">24.9 Procedure documentation</A></H2>
<P>If invoked with the command-line option <CODE>-procdoc<VAR> file</VAR>
</CODE>, SWIG creates documentation strings for the generated wrapper
functions, describing the procedure signature and return value, and
<P>Documentation strings can be configured using the Guile-specific
typemap argument <CODE>doc</CODE>. See <CODE>Lib/guile/typemaps.i</CODE>
for details.</P>
-<H2><A name="Guile_nn18"></A>23.10 Procedures with setters</H2>
+<H2><A name="Guile_nn18">24.10 Procedures with setters</A></H2>
<P>For global variables, SWIG creates a single wrapper procedure <CODE>(<VAR>
variable</VAR> :optional value)</CODE>, which is used for both getting
and setting the value. For struct members, SWIG creates two wrapper
struct members, the procedures <CODE>(<VAR>struct</VAR>-<VAR>member</VAR>
-get pointer)</CODE> and <CODE>(<VAR>struct-member</VAR>-set pointer
value)</CODE> are<EM> not</EM> generated.</P>
-<H2><A name="Guile_nn19"></A>23.11 GOOPS Proxy Classes</H2>
+<H2><A name="Guile_nn19">24.11 GOOPS Proxy Classes</A></H2>
<P>SWIG can also generate classes and generic functions for use with
Guile's Object-Oriented Programming System (GOOPS). GOOPS is a
sophisticated object system in the spirit of the Common Lisp Object
<P> Notice that <Foo> is used before it is defined. The fix is to just
put the <CODE>%import "foo.h"</CODE> before the <CODE>%inline</CODE>
block.</P>
-<H3><A name="Guile_nn20"></A>23.11.1 Naming Issues</H3>
+<H3><A name="Guile_nn20">24.11.1 Naming Issues</A></H3>
<P>As you can see in the example above, there are potential naming
conflicts. The default exported accessor for the <CODE>Foo::a</CODE>
variable is named <CODE>a</CODE>. The name of the wrapper global
(use-modules ((Test) #:renamer (symbol-prefix-proc 'goops:)))
</PRE>
</DIV>
-<H3><A name="Guile_nn21"></A>23.11.2 Linking</H3>
+<H3><A name="Guile_nn21">24.11.2 Linking</A></H3>
<P>The guile-modules generated above all need to be linked together.
GOOPS support requires either passive or module linkage. The exported
GOOPS guile-module will be the name of the swig-module and should be
future SWIG can detect dependencies and export this line. (how do other
language modules handle this problem?)</P>
<HR NOSHADE>
-<H1><A name="Java"></A>24 SWIG and Java</H1>
+<H1><A name="Java">25 SWIG and Java</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<LI><A href="#Java_default_arguments">C++ default arguments</A></LI>
<LI><A href="#Java_namespaces">C++ namespaces</A></LI>
<LI><A href="#Java_templates">C++ templates</A></LI>
-<LI><A href="#Java_smart_pointers">C++ Smart Pointers</A></LI>
+<LI><A href="#Java_smart_pointers">C++ Smart Pointers</A>
+<UL>
+<LI><A href="#Java_smart_pointers_shared_ptr">The shared_ptr Smart
+ Pointer</A></LI>
+<LI><A href="#Java_smart_pointers_generic">Generic Smart Pointers</A></LI>
+</UL>
+</LI>
</UL>
</LI>
<LI><A href="#Java_further_details">Further details on the generated
</LI>
</UL>
</LI>
+<LI><A href="#Java_interfaces">Interfaces</A></LI>
</UL>
</LI>
<LI><A href="#Java_directors">Cross language polymorphism using
<LI><A href="#Java_directors_threading">Director threading issues</A></LI>
<LI><A href="#Java_directors_performance">Director performance tuning</A>
</LI>
+<LI><A href="#Java_exceptions_from_directors">Java exceptions from
+ directors</A></LI>
</UL>
</LI>
<LI><A href="#Java_allprotected">Accessing protected members</A></LI>
<P> This chapter describes SWIG's support of Java. It covers most SWIG
features, but certain low-level details are covered in less depth than
in earlier chapters.</P>
-<H2><A name="Java_overview"></A>24.1 Overview</H2>
+<H2><A name="Java_overview">25.1 Overview</A></H2>
<P> The 100% Pure Java effort is a commendable concept, however in the
real world programmers often either need to re-use their existing code
or in some situations want to take advantage of Java but are forced
directives are covered. The latter sections cover the advanced
techniques of using typemaps for complete control of the wrapping
process.</P>
-<H2><A name="Java_preliminaries"></A>24.2 Preliminaries</H2>
+<H2><A name="Java_preliminaries">25.2 Preliminaries</A></H2>
<P> SWIG 1.1 works with JDKs from JDK 1.1 to JDK1.4 (Java 2 SDK1.4) and
should also work with any later versions. Given the choice, you should
probably use the latest version of Sun's JDK. The SWIG Java module is
<P> The Java module requires your system to support shared libraries and
dynamic loading. This is the commonly used method to load JNI code so
your system will more than likely support this.</P>
-<P> Android uses Java JNI and also works with SWIG. Please read the <A href="Android.html">
+<P> Android uses Java JNI and also works with SWIG. Please read the <A href="#Android">
Android chapter</A> in conjunction with this one if you are targeting
Android.</P>
-<H3><A name="Java_running_swig"></A>24.2.1 Running SWIG</H3>
+<H3><A name="Java_running_swig">25.2.1 Running SWIG</A></H3>
<P> Suppose that you defined a SWIG module such as the following:</P>
<DIV class="code">
<PRE>
use.</P>
<P> The following sections have further practical examples and details
on how you might go about compiling and using the generated files.</P>
-<H3><A name="Java_commandline"></A>24.2.2 Additional Commandline Options</H3>
+<H3><A name="Java_commandline">25.2.2 Additional Commandline Options</A></H3>
<P> The following table list the additional commandline options
available for the Java module. They can also be seen by using:</P>
<DIV class="code">
</TABLE>
<P> Their use will become clearer by the time you have finished reading
this section on SWIG and Java.</P>
-<H3><A name="Java_getting_right_headers"></A>24.2.3 Getting the right
- header files</H3>
+<H3><A name="Java_getting_right_headers">25.2.3 Getting the right header
+ files</A></H3>
<P> In order to compile the C/C++ wrappers, the compiler needs the <TT>
jni.h</TT> and <TT>jni_md.h</TT> header files which are part of the JDK.
They are usually in directories like this:</P>
</DIV>
<P> The exact location may vary on your machine, but the above locations
are typical.</P>
-<H3><A name="Java_compiling_dynamic"></A>24.2.4 Compiling a dynamic
- module</H3>
+<H3><A name="Java_compiling_dynamic">25.2.4 Compiling a dynamic module</A>
+</H3>
<P> The JNI code exists in a dynamic module or shared library (DLL on
Windows) and gets loaded by the JVM. Assuming you have code you need to
link to in a file called <TT>example.c</TT>, in order to build a shared
<DIV class="code">
<PRE>
$ swig -java example.i
-$ gcc -c example_wrap.c -I/usr/java/include -I/usr/java/include/solaris
-$ gcc -c example.c
+$ gcc -fPIC -c example_wrap.c -I/usr/java/include -I/usr/java/include/solaris
+$ gcc -fPIC -c example.c
$ ld -G example_wrap.o example.o -o libexample.so
</PRE>
</DIV>
Examples/java</TT> directory. If that doesn't work, you will need to
read the man-pages for your compiler and linker to get the right set of
options. You might also check the <A href="http://www.dabeaz.com/cgi-bin/wiki.pl">
-SWIG Wiki</A> for additional information. <A href="http://weblogs.java.net/blog/kellyohair/archive/2006/01/compilation_of.html">
-JNI compilation</A> is a useful reference for compiling on different
- platforms.</P>
+SWIG Wiki</A> for additional information.</P>
<P><B> Important</B>
<BR> If you are going to use optimisations turned on with gcc (for
example -O2), ensure you also compile with -fno-strict-aliasing. The
Dynamic linking problems</A> for more information). The name of the
module is specified using the <TT>%module</TT> directive or <TT>-module</TT>
command line option.</P>
-<H3><A name="Java_using_module"></A>24.2.5 Using your module</H3>
+<H3><A name="Java_using_module">25.2.5 Using your module</A></H3>
<P> To load your shared native library module in Java, simply use Java's
<TT>System.loadLibrary</TT> method in a Java class:</P>
<DIV class="code">
</DIV>
<P> If it doesn't work have a look at the following section which
discusses problems loading the shared library.</P>
-<H3><A name="Java_dynamic_linking_problems"></A>24.2.6 Dynamic linking
- problems</H3>
+<H3><A name="Java_dynamic_linking_problems">25.2.6 Dynamic linking
+ problems</A></H3>
<P> As shown in the previous section the code to load a native library
(shared library) is <TT>System.loadLibrary("name")</TT>. This can fail
with an UnsatisfiedLinkError exception and can be due to a number of
<PRE>
$ java runme
Exception in thread "main" java.lang.UnsatisfiedLinkError: exampleJNI.gcd(II)I
- at exampleJNI.gcd(Native Method)
- at example.gcd(example.java:12)
- at runme.main(runme.java:18)
+ at exampleJNI.gcd(Native Method)
+ at example.gcd(example.java:12)
+ at runme.main(runme.java:18)
</PRE>
</DIV>
<P> where <TT>gcd</TT> is the missing JNI function that SWIG generated
SWIG Wiki</A> also has some settings for commonly used compiler and
operating system combinations. The following section also contains some
C++ specific linking problems and solutions.</P>
-<H3><A name="Java_compilation_problems_cpp"></A>24.2.7 Compilation
- problems and compiling with C++</H3>
+<H3><A name="Java_compilation_problems_cpp">25.2.7 Compilation problems
+ and compiling with C++</A></H3>
<P> On most machines, shared library files should be linked using the
C++ compiler. For example:</P>
<DIV class="code">
<PRE>
% swig -c++ -java example.i
% g++ -c -fpic example.cxx
-% g++ -c -fpic example_wrap.cxx -I/usr/java/j2sdk1.4.1/include -I/usr/java/
-j2sdk1.4.1/include/linux
+% g++ -c -fpic example_wrap.cxx -I/usr/java/j2sdk1.4.1/include -I/usr/java/j2sdk1.4.1/include/linux
% g++ -shared example.o example_wrap.o -o libexample.so
</PRE>
</DIV>
<P> Finally make sure the version of JDK header files matches the
version of Java that you are running as incompatibilities could lead to
compilation problems or unpredictable behaviour.</P>
-<H3><A name="Java_building_windows"></A>24.2.8 Building on Windows</H3>
+<H3><A name="Java_building_windows">25.2.8 Building on Windows</A></H3>
<P> Building on Windows is roughly similar to the process used with
Unix. You will want to produce a DLL that can be loaded by the Java
Virtual Machine. This section covers the process of using SWIG with
Microsoft Visual C++ 6 although the procedure may be similar with other
compilers. In order for everything to work, you will need to have a JDK
installed on your machine in order to read the JNI header files.</P>
-<H4><A name="Java_visual_studio"></A>24.2.8.1 Running SWIG from Visual
- Studio</H4>
+<H4><A name="Java_visual_studio">25.2.8.1 Running SWIG from Visual
+ Studio</A></H4>
<P> If you are developing your application within Microsoft Visual
studio, SWIG can be invoked as a custom build option. The Examples\java
directory has a few <A href="#Windows_examples">Windows Examples</A>
as described in the previous section. If the library fails to load have
a look at <A href="#Java_dynamic_linking_problems">Dynamic linking
problems</A>.</P>
-<H4><A name="Java_nmake"></A>24.2.8.2 Using NMAKE</H4>
+<H4><A name="Java_nmake">25.2.8.2 Using NMAKE</A></H4>
<P> Alternatively, a Makefile for use by NMAKE can be written. Make sure
the environment variables for MSVC++ are available and the MSVC++ tools
are in your path. Now, just write a short Makefile like this :</P>
JAVA_INCLUDE = -ID:\jdk1.3\include -ID:\jdk1.3\include\win32
java::
- swig -java -o $(WRAPFILE) $(INTERFACE)
- $(CC) $(CFLAGS) $(JAVA_INCLUDE) $(SRCS) $(WRAPFILE)
- set LIB=$(TOOLS)\lib
- $(LINK) $(LOPT) -out:example.dll $(LIBS) example.obj example_wrap.obj
- javac *.java
+ swig -java -o $(WRAPFILE) $(INTERFACE)
+ $(CC) $(CFLAGS) $(JAVA_INCLUDE) $(SRCS) $(WRAPFILE)
+ set LIB=$(TOOLS)\lib
+ $(LINK) $(LOPT) -out:example.dll $(LIBS) example.obj example_wrap.obj
+ javac *.java
</PRE>
</DIV>
<P> To build the DLL and compile the java code, run NMAKE (you may need
but hopefully its enough to get you started. Of course you may want to
make changes for it to work for C++ by adding in the -c++ command line
switch for swig and replacing .c with .cxx.</P>
-<H2><A name="Java_basic_tour"></A>24.3 A tour of basic C/C++ wrapping</H2>
+<H2><A name="Java_basic_tour">25.3 A tour of basic C/C++ wrapping</A></H2>
<P> By default, SWIG attempts to build a natural Java interface to your
C/C++ code. Functions are wrapped as functions, classes are wrapped as
classes, variables are wrapped with JavaBean type getters and setters
and so forth. This section briefly covers the essential aspects of this
wrapping.</P>
-<H3><A name="Java_module_packages_classes"></A>24.3.1 Modules, packages
- and generated Java classes</H3>
+<H3><A name="Java_module_packages_classes">25.3.1 Modules, packages and
+ generated Java classes</A></H3>
<P> The SWIG <TT>%module</TT> directive specifies the name of the Java
module. When you specify `<TT>%module example</TT>', the<I> module name</I>
determines the name of some of the generated files in the module. The
</PRE>
</DIV>
<P> SWIG won't create the directory, so make sure it exists beforehand.</P>
-<H3><A name="Java_functions"></A>24.3.2 Functions</H3>
+<H3><A name="Java_functions">25.3.2 Functions</A></H3>
<P> There is no such thing as a global Java function so global C
functions are wrapped as static methods in the module class. For
example,</P>
System.out.println(example.fact(4));
</PRE>
</DIV>
-<H3><A name="Java_global_variables"></A>24.3.3 Global variables</H3>
+<H3><A name="Java_global_variables">25.3.3 Global variables</A></H3>
<P> C/C++ global variables are fully supported by SWIG. Java does not
allow the overriding of the dot operator so all variables are accessed
through getters and setters. Again because there is no such thing as a
extern char *path; // Read-only (due to %immutable)
</PRE>
</DIV>
-<H3><A name="Java_constants"></A>24.3.4 Constants</H3>
+<H3><A name="Java_constants">25.3.4 Constants</A></H3>
<P> C/C++ constants are wrapped as Java static final variables. To
create a constant, use <TT>#define</TT> or the <TT>%constant</TT>
directive. For example:</P>
example.EXPRESSION</TT> or <TT>exampleConstants.EXPRESSION</TT>. Or if
you decide this practice isn't so bad and your own class implements <TT>
exampleConstants</TT>, you can of course just use <TT>EXPRESSION</TT>.</P>
-<H3><A name="Java_enumerations"></A>24.3.5 Enumerations</H3>
+<H3><A name="Java_enumerations">25.3.5 Enumerations</A></H3>
<P> SWIG handles both named and unnamed (anonymous) enumerations. There
is a choice of approaches to wrapping named C/C++ enums. This is due to
historical reasons as SWIG's initial support for enums was limited and
final two approaches use simple integers for each enum item. Before
looking at the various approaches for wrapping named C/C++ enums,
anonymous enums are considered.</P>
-<H4><A name="Java_anonymous_enums"></A>24.3.5.1 Anonymous enums</H4>
+<H4><A name="Java_anonymous_enums">25.3.5.1 Anonymous enums</A></H4>
<P> There is no name for anonymous enums and so they are handled like
constants. For example:</P>
<DIV class="code">
<P> As in the case of constants, you can access them through either the
module class or the constants interface, for example, <TT>example.ALE</TT>
or <TT>exampleConstants.ALE</TT>.</P>
-<H4><A name="Java_typesafe_enums"></A>24.3.5.2 Typesafe enums</H4>
+<H4><A name="Java_typesafe_enums">25.3.5.2 Typesafe enums</A></H4>
<P> This is the default approach to wrapping named enums. The typesafe
enum pattern is a relatively well known construct to work around the
lack of enums in versions of Java prior to JDK 1.5. It basically
1.5 or later, proper Java enums could be used instead, without users
having to change their code. The following section details proper Java
enum generation.</P>
-<H4><A name="Java_proper_enums"></A>24.3.5.3 Proper Java enums</H4>
+<H4><A name="Java_proper_enums">25.3.5.3 Proper Java enums</A></H4>
<P> Proper Java enums were only introduced in JDK 1.5 so this approach
is only compatible with more recent versions of Java. Java enums have
been designed to overcome all the limitations of both typesafe and type
<P> The additional support methods need not be generated if none of the
enum items have initializers and this is covered later in the <A href="#Java_simpler_enum_classes">
Simpler Java enums for enums without initializers</A> section.</P>
-<H4><A name="Java_typeunsafe_enums"></A>24.3.5.4 Type unsafe enums</H4>
+<H4><A name="Java_typeunsafe_enums">25.3.5.4 Type unsafe enums</A></H4>
<P> In this approach each enum item in a named enumeration is wrapped as
a static final integer in a class named after the C/C++ enum name. This
is a commonly used pattern in Java to simulate C/C++ enums, but it is
look at an example.</P>
<DIV class="code">
<PRE>
-%include "enumtypeunsafe.swg"
-%javaconst(1);
-enum Beverage { ALE, LAGER=10, STOUT, PILSNER, PILZ=PILSNER };
+%include "enumtypeunsafe.swg"
+%javaconst(1);
+enum Beverage { ALE, LAGER=10, STOUT, PILSNER, PILZ=PILSNER };
+</PRE>
+</DIV>
+<P> will generate:</P>
+<DIV class="code">
+<PRE>
+public final class Beverage {
+ public final static int ALE = 0;
+ public final static int LAGER = 10;
+ public final static int STOUT = LAGER + 1;
+ public final static int PILSNER = STOUT + 1;
+ public final static int PILZ = PILSNER;
+}
+</PRE>
+</DIV>
+<P> As is the case previously, the default is <TT>%javaconst(0)</TT> as
+ not all C/C++ values will compile as Java code. However, again it is
+ recommended to add in a <TT>%javaconst(1)</TT> directive. and the <TT>
+%javaconstvalue(value)</TT> directive covered in the <A href="#Java_constants">
+Constants</A> section can also be used for type unsafe enums. Note that
+ global enums are generated into a Java class within whatever package
+ you are using. C++ enums defined within a C++ class are generated into
+ a static final inner Java class within the Java proxy class.</P>
+<P> Note that unlike typesafe enums, this approach requires users to
+ mostly use different syntax compared with proper Java enums. Thus the
+ upgrade path to proper enums provided in JDK 1.5 is more painful.</P>
+<H4><A name="Java_simple_enums">25.3.5.5 Simple enums</A></H4>
+<P> This approach is similar to the type unsafe approach. Each enum item
+ is also wrapped as a static final integer. However, these integers are
+ not generated into a class named after the C/C++ enum. Instead, global
+ enums are generated into the constants interface. Also, enums defined
+ in a C++ class have their enum items generated directly into the Java
+ proxy class rather than an inner class within the Java proxy class. In
+ fact, this approach is effectively wrapping the enums as if they were
+ anonymous enums and the resulting code is as per <A href="#Java_anonymous_enums">
+anonymous enums</A>. The implementation is in the "enumsimple.swg" file.</P>
+<P><B> Compatibility Note:</B> SWIG-1.3.21 and earlier versions wrapped
+ all enums using this approach. The type unsafe approach is preferable
+ to this one and this simple approach is only included for backwards
+ compatibility with these earlier versions of SWIG.</P>
+<H3><A name="Java_pointers">25.3.6 Pointers</A></H3>
+<P> C/C++ pointers are fully supported by SWIG. Furthermore, SWIG has no
+ problem working with incomplete type information. Here is a rather
+ simple interface:</P>
+<DIV class="code">
+<PRE>
+%module example
+
+FILE *fopen(const char *filename, const char *mode);
+int fputs(const char *, FILE *);
+int fclose(FILE *);
+</PRE>
+</DIV>
+<P> When wrapped, you will be able to use the functions in a natural way
+ from Java. For example:</P>
+<DIV class="code">
+<PRE>
+SWIGTYPE_p_FILE f = example.fopen("junk","w");
+example.fputs("Hello World\n", f);
+example.fclose(f);
+</PRE>
+</DIV>
+<P> C pointers in the Java module are stored in a Java <TT>long</TT> and
+ cross the JNI boundary held within this 64 bit number. Many other SWIG
+ language modules use an encoding of the pointer in a string. These
+ scripting languages use the SWIG runtime type checker for dynamic type
+ checking as they do not support static type checking by a compiler. In
+ order to implement static type checking of pointers within Java, they
+ are wrapped by a simple Java class. In the example above the <TT>FILE *</TT>
+ pointer is wrapped with a<I> type wrapper class</I> called <TT>
+SWIGTYPE_p_FILE</TT>.</P>
+<P> Once obtained, a type wrapper object can be freely passed around to
+ different C functions that expect to receive an object of that type.
+ The only thing you can't do is dereference the pointer from Java. Of
+ course, that isn't much of a concern in this example.</P>
+<P> As much as you might be inclined to modify a pointer value directly
+ from Java, don't. The value is not necessarily the same as the logical
+ memory address of the underlying object. The value will vary depending
+ on the native byte-ordering of the platform (i.e., big-endian vs.
+ little-endian). Most JVMs are 32 bit applications so any JNI code must
+ also be compiled as 32 bit. The net result is pointers in JNI code are
+ also 32 bits and are stored in the high order 4 bytes on big-endian
+ machines and in the low order 4 bytes on little-endian machines. By
+ design it is also not possible to manually cast a pointer to a new type
+ by using Java casts as it is particularly dangerous especially when
+ casting C++ objects. If you need to cast a pointer or change its value,
+ consider writing some helper functions instead. For example:</P>
+<DIV class="code">
+<PRE>
+%inline %{
+/* C-style cast */
+Bar *FooToBar(Foo *f) {
+ return (Bar *) f;
+}
+
+/* C++-style cast */
+Foo *BarToFoo(Bar *b) {
+ return dynamic_cast<Foo*>(b);
+}
+
+Foo *IncrFoo(Foo *f, int i) {
+ return f+i;
+}
+%}
+</PRE>
+</DIV>
+<P> Also, if working with C++, you should always try to use the new C++
+ style casts. For example, in the above code, the C-style cast may
+ return a bogus result whereas as the C++-style cast will return a NULL
+ pointer if the conversion can't be performed.</P>
+<H3><A name="Java_structures">25.3.7 Structures</A></H3>
+<P> If you wrap a C structure, it is wrapped by a Java class with
+ getters and setters for access to the member variables. For example,</P>
+<DIV class="code">
+<PRE>
+struct Vector {
+ double x,y,z;
+};
+
+</PRE>
+</DIV>
+<P> is used as follows:</P>
+<DIV class="code">
+<PRE>
+Vector v = new Vector();
+v.setX(3.5);
+v.setY(7.2);
+double x = v.getX();
+double y = v.getY();
+</PRE>
+</DIV>
+<P> The variable setters and getters are also based on the JavaBean
+ design pattern already covered under the Global variables section.
+ Similar access is provided for unions and the public data members of
+ C++ classes.</P>
+<P> This object is actually an instance of a Java class that has been
+ wrapped around a pointer to the C structure. This instance doesn't
+ actually do anything--it just serves as a proxy. The pointer to the C
+ object is held in the Java proxy class in much the same way as pointers
+ are held by type wrapper classes. Further details about Java proxy
+ classes are covered a little later.</P>
+<P> <TT>const</TT> members of a structure are read-only. Data members
+ can also be forced to be read-only using the <TT>%immutable</TT>
+ directive. For example:</P>
+<DIV class="code">
+<PRE>
+struct Foo {
+ ...
+ %immutable;
+ int x; /* Read-only members */
+ char *name;
+ %mutable;
+ ...
+};
+</PRE>
+</DIV>
+<P> When <TT>char *</TT> members of a structure are wrapped, the
+ contents are assumed to be dynamically allocated using <TT>malloc</TT>
+ or <TT>new</TT> (depending on whether or not SWIG is run with the -c++
+ option). When the structure member is set, the old contents will be
+ released and a new value created. If this is not the behavior you want,
+ you will have to use a typemap (described later).</P>
+<P> If a structure contains arrays, access to those arrays is managed
+ through pointers. For example, consider this:</P>
+<DIV class="code">
+<PRE>
+struct Bar {
+ int x[16];
+};
+</PRE>
+</DIV>
+<P> If accessed in Java, you will see behavior like this:</P>
+<DIV class="code">
+<PRE>
+Bar b = new Bar();
+SWIGTYPE_p_int x = b.getX();
+</PRE>
+</DIV>
+<P> This pointer can be passed around to functions that expect to
+ receive an <TT>int *</TT> (just like C). You can also set the value of
+ an array member using another pointer. For example:</P>
+<DIV class="code">
+<PRE>
+Bar b = new Bar();
+SWIGTYPE_p_int x = b.getX();
+Bar c = new Bar();
+c.setX(x); // Copy contents of b.x to c.x
+</PRE>
+</DIV>
+<P> For array assignment (setters not getters), SWIG copies the entire
+ contents of the array starting with the data pointed to by <TT>b.x</TT>
+. In this example, 16 integers would be copied. Like C, SWIG makes no
+ assumptions about bounds checking---if you pass a bad pointer, you may
+ get a segmentation fault or access violation. The default wrapping
+ makes it hard to set or get just one element of the array and so array
+ access from Java is somewhat limited. This can be changed easily though
+ by using the approach outlined later in the <A href="#Java_c_arrays">
+Wrapping C arrays with Java arrays</A> and <A href="#Java_unbounded_c_arrays">
+Unbounded C Arrays</A> sections.</P>
+<P> When a member of a structure is itself a structure, it is handled as
+ a pointer. For example, suppose you have two structures like this:</P>
+<DIV class="code">
+<PRE>
+struct Foo {
+ int a;
+};
+
+struct Bar {
+ Foo f;
+};
+</PRE>
+</DIV>
+<P> Now, suppose that you access the <TT>f</TT> member of <TT>Bar</TT>
+ like this:</P>
+<DIV class="code">
+<PRE>
+Bar b = new Bar();
+Foo x = b.getF();
+</PRE>
+</DIV>
+<P> In this case, <TT>x</TT> is a pointer that points to the <TT>Foo</TT>
+ that is inside <TT>b</TT>. This is the same value as generated by this
+ C code:</P>
+<DIV class="code">
+<PRE>
+Bar b;
+Foo *x = &b->f; /* Points inside b */
+</PRE>
+</DIV>
+<P> Because the pointer points inside the structure, you can modify the
+ contents and everything works just like you would expect. For example:</P>
+<DIV class="code">
+<PRE>
+Bar b = new Bar();
+b.getF().setA(3); // Modify b.f.a
+Foo x = b.getF();
+x.setA(3); // Modify x.a - this is the same as b.f.a
+</PRE>
+</DIV>
+<H3><A name="Java_classes">25.3.8 C++ classes</A></H3>
+<P> C++ classes are wrapped by Java classes as well. For example, if you
+ have this class,</P>
+<DIV class="code">
+<PRE>
+class List {
+public:
+ List();
+ ~List();
+ int search(char *item);
+ void insert(char *item);
+ void remove(char *item);
+ char *get(int n);
+ int length;
+};
+</PRE>
+</DIV>
+<P> you can use it in Java like this:</P>
+<DIV class="code">
+<PRE>
+List l = new List();
+l.insert("Ale");
+l.insert("Stout");
+l.insert("Lager");
+String item = l.get(2);
+int length = l.getLength();
+</PRE>
+</DIV>
+<P> Class data members are accessed in the same manner as C structures.</P>
+<P> Static class members are unsurprisingly wrapped as static members of
+ the Java class:</P>
+<DIV class="code">
+<PRE>
+class Spam {
+public:
+ static void foo();
+ static int bar;
+};
+</PRE>
+</DIV>
+<P> The static members work like any other Java static member:</P>
+<DIV class="code">
+<PRE>
+Spam.foo();
+int bar = Spam.getBar();
+</PRE>
+</DIV>
+<H3><A name="Java_inheritance">25.3.9 C++ inheritance</A></H3>
+<P> SWIG is fully aware of issues related to C++ inheritance. Therefore,
+ if you have classes like this</P>
+<DIV class="code">
+<PRE>
+class Foo {
+...
+};
+
+class Bar : public Foo {
+...
+};
+</PRE>
+</DIV>
+<P> those classes are wrapped into a hierarchy of Java classes that
+ reflect the same inheritance structure:</P>
+<DIV class="code">
+<PRE>
+Bar b = new Bar();
+Class c = b.getClass();
+System.out.println(c.getSuperclass().getName());
+</PRE>
+</DIV>
+<P> will of course display:</P>
+<DIV class="code">
+<PRE>
+Foo
+</PRE>
+</DIV>
+<P> Furthermore, if you have functions like this</P>
+<DIV class="code">
+<PRE>
+void spam(Foo *f);
+</PRE>
+</DIV>
+<P> then the Java function <TT>spam()</TT> accepts instances of <TT>Foo</TT>
+ or instances of any other proxy classes derived from <TT>Foo</TT>.</P>
+<P> Note that Java does not support multiple inheritance so any multiple
+ inheritance in the C++ code is not going to work. A warning is given
+ when multiple inheritance is detected and only the first base class is
+ used.</P>
+<H3><A name="Java_pointers_refs_arrays">25.3.10 Pointers, references,
+ arrays and pass by value</A></H3>
+<P> In C++, there are many different ways a function might receive and
+ manipulate objects. For example:</P>
+<DIV class="code">
+<PRE>
+void spam1(Foo *x); // Pass by pointer
+void spam2(Foo &x); // Pass by reference
+void spam3(Foo x); // Pass by value
+void spam4(Foo x[]); // Array of objects
+</PRE>
+</DIV>
+<P> In Java, there is no detailed distinction like this--specifically,
+ there are only instances of classes. There are no pointers nor
+ references. Because of this, SWIG unifies all of these types together
+ in the wrapper code. For instance, if you actually had the above
+ functions, it is perfectly legal to do this from Java:</P>
+<DIV class="code">
+<PRE>
+Foo f = new Foo(); // Create a Foo
+example.spam1(f); // Ok. Pointer
+example.spam2(f); // Ok. Reference
+example.spam3(f); // Ok. Value.
+example.spam4(f); // Ok. Array (1 element)
+</PRE>
+</DIV>
+<P> Similar behavior occurs for return values. For example, if you had
+ functions like this,</P>
+<DIV class="code">
+<PRE>
+Foo *spam5();
+Foo &spam6();
+Foo spam7();
+</PRE>
+</DIV>
+<P> then all three functions will return a pointer to some <TT>Foo</TT>
+ object. Since the third function (spam7) returns a value, newly
+ allocated memory is used to hold the result and a pointer is returned
+ (Java will release this memory when the returned object's finalizer is
+ run by the garbage collector).</P>
+<H4><A name="Java_null_pointers">25.3.10.1 Null pointers</A></H4>
+<P> Working with null pointers is easy. A Java <TT>null</TT> can be used
+ whenever a method expects a proxy class or typewrapper class. However,
+ it is not possible to pass null to C/C++ functions that take parameters
+ by value or by reference. If you try you will get a
+ NullPointerException.</P>
+<DIV class="code">
+<PRE>
+example.spam1(null); // Pointer - ok
+example.spam2(null); // Reference - NullPointerException
+example.spam3(null); // Value - NullPointerException
+example.spam4(null); // Array - ok
+</PRE>
+</DIV>
+<P> For <TT>spam1</TT> and <TT>spam4</TT> above the Java <TT>null</TT>
+ gets translated into a NULL pointer for passing to the C/C++ function.
+ The converse also occurs, that is, NULL pointers are translated into <TT>
+null</TT> Java objects when returned from a C/C++ function.</P>
+<H3><A name="Java_overloaded_functions">25.3.11 C++ overloaded functions</A>
+</H3>
+<P> C++ overloaded functions, methods, and constructors are mostly
+ supported by SWIG. For example, if you have two functions like this:</P>
+<DIV class="code">
+<PRE>
+%module example
+
+void foo(int);
+void foo(char *c);
+</PRE>
+</DIV>
+<P> You can use them in Java in a straightforward manner:</P>
+<DIV class="code">
+<PRE>
+example.foo(3); // foo(int)
+example.foo("Hello"); // foo(char *c)
+</PRE>
+</DIV>
+<P> Similarly, if you have a class like this,</P>
+<DIV class="code">
+<PRE>
+class Foo {
+public:
+ Foo();
+ Foo(const Foo &);
+ ...
+};
+</PRE>
+</DIV>
+<P> you can write Java code like this:</P>
+<DIV class="code">
+<PRE>
+Foo f = new Foo(); // Create a Foo
+Foo g = new Foo(f); // Copy f
+</PRE>
+</DIV>
+<P> Overloading support is not quite as flexible as in C++. Sometimes
+ there are methods that SWIG cannot disambiguate as there can be more
+ than one C++ type mapping onto a single Java type. For example:</P>
+<DIV class="code">
+<PRE>
+void spam(int);
+void spam(unsigned short);
+</PRE>
+</DIV>
+<P> Here both int and unsigned short map onto a Java int. Here is
+ another example:</P>
+<DIV class="code">
+<PRE>
+void foo(Bar *b);
+void foo(Bar &b);
+</PRE>
+</DIV>
+<P> If declarations such as these appear, you will get a warning message
+ like this:</P>
+<DIV class="code">
+<PRE>
+example.i:12: Warning 515: Overloaded method spam(unsigned short) ignored.
+Method spam(int) at example.i:11 used.
+</PRE>
+</DIV>
+<P> To fix this, you either need to either <A href="#SWIG_rename_ignore">
+rename or ignore</A> one of the methods. For example:</P>
+<DIV class="code">
+<PRE>
+%rename(spam_ushort) spam(unsigned short);
+...
+void spam(int);
+void spam(unsigned short); // Now renamed to spam_ushort
+</PRE>
+</DIV>
+<P> or</P>
+<DIV class="code">
+<PRE>
+%ignore spam(unsigned short);
+...
+void spam(int);
+void spam(unsigned short); // Ignored
+</PRE>
+</DIV>
+<H3><A name="Java_default_arguments">25.3.12 C++ default arguments</A></H3>
+<P> Any function with a default argument is wrapped by generating an
+ additional function for each argument that is defaulted. For example,
+ if we have the following C++:</P>
+<DIV class="code">
+<PRE>
+%module example
+
+void defaults(double d=10.0, int i=0);
</PRE>
</DIV>
-<P> will generate:</P>
+<P> The following methods are generated in the Java module class:</P>
<DIV class="code">
<PRE>
-public final class Beverage {
- public final static int ALE = 0;
- public final static int LAGER = 10;
- public final static int STOUT = LAGER + 1;
- public final static int PILSNER = STOUT + 1;
- public final static int PILZ = PILSNER;
+public class example {
+ public static void defaults(double d, int i) { ... }
+ public static void defaults(double d) { ... }
+ public static void defaults() { ... }
}
</PRE>
</DIV>
-<P> As is the case previously, the default is <TT>%javaconst(0)</TT> as
- not all C/C++ values will compile as Java code. However, again it is
- recommended to add in a <TT>%javaconst(1)</TT> directive. and the <TT>
-%javaconstvalue(value)</TT> directive covered in the <A href="#Java_constants">
-Constants</A> section can also be used for type unsafe enums. Note that
- global enums are generated into a Java class within whatever package
- you are using. C++ enums defined within a C++ class are generated into
- a static final inner Java class within the Java proxy class.</P>
-<P> Note that unlike typesafe enums, this approach requires users to
- mostly use different syntax compared with proper Java enums. Thus the
- upgrade path to proper enums provided in JDK 1.5 is more painful.</P>
-<H4><A name="Java_simple_enums"></A>24.3.5.5 Simple enums</H4>
-<P> This approach is similar to the type unsafe approach. Each enum item
- is also wrapped as a static final integer. However, these integers are
- not generated into a class named after the C/C++ enum. Instead, global
- enums are generated into the constants interface. Also, enums defined
- in a C++ class have their enum items generated directly into the Java
- proxy class rather than an inner class within the Java proxy class. In
- fact, this approach is effectively wrapping the enums as if they were
- anonymous enums and the resulting code is as per <A href="#Java_anonymous_enums">
-anonymous enums</A>. The implementation is in the "enumsimple.swg" file.</P>
-<P><B> Compatibility Note:</B> SWIG-1.3.21 and earlier versions wrapped
- all enums using this approach. The type unsafe approach is preferable
- to this one and this simple approach is only included for backwards
- compatibility with these earlier versions of SWIG.</P>
-<H3><A name="Java_pointers"></A>24.3.6 Pointers</H3>
-<P> C/C++ pointers are fully supported by SWIG. Furthermore, SWIG has no
- problem working with incomplete type information. Here is a rather
- simple interface:</P>
+<P> It is as if SWIG had parsed three separate overloaded methods. The
+ same approach is taken for static methods, constructors and member
+ methods.</P>
+<P><B> Compatibility note:</B> Versions of SWIG prior to SWIG-1.3.23
+ wrapped these with a single wrapper method and so the default values
+ could not be taken advantage of from Java. Further details on default
+ arguments and how to restore this approach are given in the more
+ general <A href="#SWIGPlus_default_args">Default arguments</A> section.</P>
+<H3><A name="Java_namespaces">25.3.13 C++ namespaces</A></H3>
+<P> SWIG is aware of named C++ namespaces and they can be mapped to Java
+ packages, however, the default wrapping flattens the namespaces,
+ effectively ignoring them. So by default, the namespace names do not
+ appear in the module nor do namespaces result in a module that is
+ broken up into submodules or packages. For example, if you have a file
+ like this,</P>
<DIV class="code">
<PRE>
%module example
-FILE *fopen(const char *filename, const char *mode);
-int fputs(const char *, FILE *);
-int fclose(FILE *);
+namespace foo {
+ int fact(int n);
+ struct Vector {
+ double x,y,z;
+ };
+};
</PRE>
</DIV>
-<P> When wrapped, you will be able to use the functions in a natural way
- from Java. For example:</P>
+<P> it works in Java as follows:</P>
<DIV class="code">
<PRE>
-SWIGTYPE_p_FILE f = example.fopen("junk","w");
-example.fputs("Hello World\n", f);
-example.fclose(f);
+int f = example.fact(3);
+Vector v = new Vector();
+v.setX(3.4);
+double y = v.getY();
</PRE>
</DIV>
-<P> C pointers in the Java module are stored in a Java <TT>long</TT> and
- cross the JNI boundary held within this 64 bit number. Many other SWIG
- language modules use an encoding of the pointer in a string. These
- scripting languages use the SWIG runtime type checker for dynamic type
- checking as they do not support static type checking by a compiler. In
- order to implement static type checking of pointers within Java, they
- are wrapped by a simple Java class. In the example above the <TT>FILE *</TT>
- pointer is wrapped with a<I> type wrapper class</I> called <TT>
-SWIGTYPE_p_FILE</TT>.</P>
-<P> Once obtained, a type wrapper object can be freely passed around to
- different C functions that expect to receive an object of that type.
- The only thing you can't do is dereference the pointer from Java. Of
- course, that isn't much of a concern in this example.</P>
-<P> As much as you might be inclined to modify a pointer value directly
- from Java, don't. The value is not necessarily the same as the logical
- memory address of the underlying object. The value will vary depending
- on the native byte-ordering of the platform (i.e., big-endian vs.
- little-endian). Most JVMs are 32 bit applications so any JNI code must
- also be compiled as 32 bit. The net result is pointers in JNI code are
- also 32 bits and are stored in the high order 4 bytes on big-endian
- machines and in the low order 4 bytes on little-endian machines. By
- design it is also not possible to manually cast a pointer to a new type
- by using Java casts as it is particularly dangerous especially when
- casting C++ objects. If you need to cast a pointer or change its value,
- consider writing some helper functions instead. For example:</P>
+<P> If your program has more than one namespace, name conflicts (if any)
+ can be resolved using <TT>%rename</TT> For example:</P>
<DIV class="code">
<PRE>
-%inline %{
-/* C-style cast */
-Bar *FooToBar(Foo *f) {
- return (Bar *) f;
-}
+%rename(Bar_spam) Bar::spam;
-/* C++-style cast */
-Foo *BarToFoo(Bar *b) {
- return dynamic_cast<Foo*>(b);
+namespace Foo {
+ int spam();
}
-Foo *IncrFoo(Foo *f, int i) {
- return f+i;
+namespace Bar {
+ int spam();
}
-%}
</PRE>
</DIV>
-<P> Also, if working with C++, you should always try to use the new C++
- style casts. For example, in the above code, the C-style cast may
- return a bogus result whereas as the C++-style cast will return a NULL
- pointer if the conversion can't be performed.</P>
-<H3><A name="Java_structures"></A>24.3.7 Structures</H3>
-<P> If you wrap a C structure, it is wrapped by a Java class with
- getters and setters for access to the member variables. For example,</P>
+<P> If you have more than one namespace and you want to keep their
+ symbols separate, consider wrapping them as separate SWIG modules. Each
+ SWIG module can be placed into a separate package.</P>
+<P> The default behaviour described above can be improved via the <A href="#SWIGPlus_nspace">
+nspace feature</A>. Note that it only works for classes, structs, unions
+ and enums declared within a named C++ namespace. When the nspace
+ feature is used, the C++ namespaces are converted into Java packages of
+ the same name. Proxy classes are thus declared within a package and
+ this proxy makes numerous calls to the JNI intermediary class which is
+ declared in the unnamed package by default. As Java does not support
+ types declared in a named package accessing types declared in an
+ unnamed package, the <TT>-package</TT> commandline option described
+ earlier generally should be used to provide a parent package. So if
+ SWIG is run using the <TT>-package com.myco</TT> option, a wrapped
+ class, <TT>MyWorld::Material::Color</TT>, can then be accessed as <TT>
+com.myco.MyWorld.Material.Color</TT>. If you don't specify a package,
+ you will get the following warning:</P>
+<DIV class="shell">
+<PRE>
+example.i:16: Warning 826: The nspace feature is used on 'MyWorld::Material::Color' without -package. The generated code
+may not compile as Java does not support types declared in a named package accessing types declared in an unnamed package.
+</PRE>
+</DIV>
+<P> If it is undesirable to have a single top level package, the nspace
+ feature may be used without the <TT>-package</TT> commandline option
+ (and the resulting warning ignored) if all of the types exposed using
+ SWIG are placed in a package using the nspace feature and the
+ 'jniclasspackage' pragma is used to specify a package for the JNI
+ intermediary class.</P>
+<P> If the resulting use of the nspace feature and hence packages
+ results in a proxy class in one package deriving or using a proxy class
+ from another package, you will need to open up the visibility for the
+ pointer constructor and <TT>getCPtr</TT> method from the default
+ 'protected' to 'public' with the <TT>SWIG_JAVABODY_PROXY</TT> macro.
+ See <A href="#Java_code_typemaps">Java code typemaps</A>.</P>
+<H3><A name="Java_templates">25.3.14 C++ templates</A></H3>
+<P> C++ templates don't present a huge problem for SWIG. However, in
+ order to create wrappers, you have to tell SWIG to create wrappers for
+ a particular template instantiation. To do this, you use the <TT>
+%template</TT> directive. For example:</P>
<DIV class="code">
<PRE>
-struct Vector {
- double x,y,z;
+%module example
+%{
+#include <utility>
+%}
+
+template<class T1, class T2>
+struct pair {
+ typedef T1 first_type;
+ typedef T2 second_type;
+ T1 first;
+ T2 second;
+ pair();
+ pair(const T1&, const T2&);
+ ~pair();
};
+%template(pairii) pair<int,int>;
</PRE>
</DIV>
-<P> is used as follows:</P>
+<P> In Java:</P>
<DIV class="code">
<PRE>
-Vector v = new Vector();
-v.setX(3.5);
-v.setY(7.2);
-double x = v.getX();
-double y = v.getY();
+pairii p = new pairii(3,4);
+int first = p.getFirst();
+int second = p.getSecond();
</PRE>
</DIV>
-<P> The variable setters and getters are also based on the JavaBean
- design pattern already covered under the Global variables section.
- Similar access is provided for unions and the public data members of
- C++ classes.</P>
-<P> This object is actually an instance of a Java class that has been
- wrapped around a pointer to the C structure. This instance doesn't
- actually do anything--it just serves as a proxy. The pointer to the C
- object is held in the Java proxy class in much the same way as pointers
- are held by type wrapper classes. Further details about Java proxy
- classes are covered a little later.</P>
-<P> <TT>const</TT> members of a structure are read-only. Data members
- can also be forced to be read-only using the <TT>%immutable</TT>
- directive. For example:</P>
+<P> Obviously, there is more to template wrapping than shown in this
+ example. More details can be found in the <A href="#SWIGPlus">SWIG and
+ C++</A> chapter.</P>
+<H3><A name="Java_smart_pointers">25.3.15 C++ Smart Pointers</A></H3>
+<H4><A name="Java_smart_pointers_shared_ptr">25.3.15.1 The shared_ptr
+ Smart Pointer</A></H4>
+<P> The C++11 standard provides <TT>std::shared_ptr</TT> which was
+ derived from the Boost implementation, <TT>boost::shared_ptr</TT>. Both
+ of these are available for Java in the SWIG library and usage is
+ outlined in the <A href="#Library_std_shared_ptr">shared_ptr smart
+ pointer</A> library section.</P>
+<H4><A name="Java_smart_pointers_generic">25.3.15.2 Generic Smart
+ Pointers</A></H4>
+<P> In certain C++ programs, it is common to use classes that have been
+ wrapped by so-called "smart pointers." Generally, this involves the use
+ of a template class that implements <TT>operator->()</TT> like this:</P>
<DIV class="code">
<PRE>
-struct Foo {
+template<class T> class SmartPtr {
...
- %immutable;
- int x; /* Read-only members */
- char *name;
- %mutable;
+ T *operator->();
...
-};
+}
</PRE>
</DIV>
-<P> When <TT>char *</TT> members of a structure are wrapped, the
- contents are assumed to be dynamically allocated using <TT>malloc</TT>
- or <TT>new</TT> (depending on whether or not SWIG is run with the -c++
- option). When the structure member is set, the old contents will be
- released and a new value created. If this is not the behavior you want,
- you will have to use a typemap (described later).</P>
-<P> If a structure contains arrays, access to those arrays is managed
- through pointers. For example, consider this:</P>
+<P> Then, if you have a class like this,</P>
<DIV class="code">
<PRE>
-struct Bar {
- int x[16];
+class Foo {
+public:
+ int x;
+ int bar();
};
</PRE>
</DIV>
-<P> If accessed in Java, you will see behavior like this:</P>
+<P> A smart pointer would be used in C++ as follows:</P>
<DIV class="code">
<PRE>
-Bar b = new Bar();
-SWIGTYPE_p_int x = b.getX();
+SmartPtr<Foo> p = CreateFoo(); // Created somehow (not shown)
+...
+p->x = 3; // Foo::x
+int y = p->bar(); // Foo::bar
</PRE>
</DIV>
-<P> This pointer can be passed around to functions that expect to
- receive an <TT>int *</TT> (just like C). You can also set the value of
- an array member using another pointer. For example:</P>
+<P> To wrap this in Java, simply tell SWIG about the <TT>SmartPtr</TT>
+ class and the low-level <TT>Foo</TT> object. Make sure you instantiate <TT>
+SmartPtr</TT> using <TT>%template</TT> if necessary. For example:</P>
<DIV class="code">
<PRE>
-Bar b = new Bar();
-SWIGTYPE_p_int x = b.getX();
-Bar c = new Bar();
-c.setX(x); // Copy contents of b.x to c.x
+%module example
+...
+%template(SmartPtrFoo) SmartPtr<Foo>;
+...
</PRE>
</DIV>
-<P> For array assignment (setters not getters), SWIG copies the entire
- contents of the array starting with the data pointed to by <TT>b.x</TT>
-. In this example, 16 integers would be copied. Like C, SWIG makes no
- assumptions about bounds checking---if you pass a bad pointer, you may
- get a segmentation fault or access violation. The default wrapping
- makes it hard to set or get just one element of the array and so array
- access from Java is somewhat limited. This can be changed easily though
- by using the approach outlined later in the <A href="#Java_c_arrays">
-Wrapping C arrays with Java arrays</A> and <A href="#Java_unbounded_c_arrays">
-Unbounded C Arrays</A> sections.</P>
-<P> When a member of a structure is itself a structure, it is handled as
- a pointer. For example, suppose you have two structures like this:</P>
+<P> Now, in Java, everything should just "work":</P>
<DIV class="code">
<PRE>
-struct Foo {
- int a;
-};
-
-struct Bar {
- Foo f;
+SmartPtrFoo p = example.CreateFoo(); // Create a smart-pointer somehow
+p.setX(3); // Foo::x
+int y = p.bar(); // Foo::bar
+</PRE>
+</DIV>
+<P> If you ever need to access the underlying pointer returned by <TT>
+operator->()</TT> itself, simply use the <TT>__deref__()</TT> method.
+ For example:</P>
+<DIV class="code">
+<PRE>
+Foo f = p.__deref__(); // Returns underlying Foo *
+</PRE>
+</DIV>
+<H2><A name="Java_further_details">25.4 Further details on the generated
+ Java classes</A></H2>
+<P> In the previous section, a high-level view of Java wrapping was
+ presented. A key component of this wrapping is that structures and
+ classes are wrapped by Java proxy classes and type wrapper classes are
+ used in situations where no proxies are generated. This provides a very
+ natural, type safe Java interface to the C/C++ code and fits in with
+ the Java programming paradigm. However, a number of low-level details
+ were omitted. This section provides a brief overview of how the proxy
+ classes work and then covers the type wrapper classes. Finally enum
+ classes are covered. First, the crucial intermediary JNI class is
+ considered.</P>
+<H3><A name="Java_imclass">25.4.1 The intermediary JNI class</A></H3>
+<P> In the <A href="#SWIG">"SWIG basics"</A> and <A href="#SWIGPlus">
+"SWIG and C++"</A> chapters, details of low-level structure and class
+ wrapping are described. To summarize those chapters, if you have a
+ global function and class like this</P>
+<DIV class="code">
+<PRE>
+class Foo {
+public:
+ int x;
+ int spam(int num, Foo* foo);
};
+void egg(Foo* chips);
</PRE>
</DIV>
-<P> Now, suppose that you access the <TT>f</TT> member of <TT>Bar</TT>
- like this:</P>
+<P> then SWIG transforms the class into a set of low-level procedural
+ wrappers. These procedural wrappers essentially perform the equivalent
+ of this C++ code:</P>
<DIV class="code">
<PRE>
-Bar b = new Bar();
-Foo x = b.getF();
+Foo *new_Foo() {
+ return new Foo();
+}
+void delete_Foo(Foo *f) {
+ delete f;
+}
+int Foo_x_get(Foo *f) {
+ return f->x;
+}
+void Foo_x_set(Foo *f, int value) {
+ f->x = value;
+}
+int Foo_spam(Foo *f, int num, Foo* foo) {
+ return f->spam(num, foo);
+}
</PRE>
</DIV>
-<P> In this case, <TT>x</TT> is a pointer that points to the <TT>Foo</TT>
- that is inside <TT>b</TT>. This is the same value as generated by this
- C code:</P>
+<P> These procedural function names don't actually exist, but their
+ functionality appears inside the generated JNI functions. The JNI
+ functions have to follow a particular naming convention so the function
+ names are actually:</P>
<DIV class="code">
<PRE>
-Bar b;
-Foo *x = &b->f; /* Points inside b */
+SWIGEXPORT jlong JNICALL Java_exampleJNI_new_1Foo(JNIEnv *jenv, jclass jcls);
+SWIGEXPORT void JNICALL Java_exampleJNI_delete_1Foo(JNIEnv *jenv, jclass jcls,
+ jlong jarg1);
+SWIGEXPORT void JNICALL Java_exampleJNI_Foo_1x_1set(JNIEnv *jenv, jclass jcls,
+ jlong jarg1, jobject jarg1_, jint jarg2);
+SWIGEXPORT jint JNICALL Java_exampleJNI_Foo_1x_1get(JNIEnv *jenv, jclass jcls,
+ jlong jarg1, jobject jarg1_);
+SWIGEXPORT jint JNICALL Java_exampleJNI_Foo_1spam(JNIEnv *jenv, jclass jcls,
+ jlong jarg1, jobject jarg1_, jint jarg2,
+ jlong jarg3, jobject jarg3_);
+SWIGEXPORT void JNICALL Java_exampleJNI_egg(JNIEnv *jenv, jclass jcls,
+ jlong jarg1, jobject jarg1_);
</PRE>
</DIV>
-<P> Because the pointer points inside the structure, you can modify the
- contents and everything works just like you would expect. For example:</P>
+<P> For every JNI C function there has to be a static native Java
+ function. These appear in the intermediary JNI class:</P>
<DIV class="code">
<PRE>
-Bar b = new Bar();
-b.getF().setA(3); // Modify b.f.a
-Foo x = b.getF();
-x.setA(3); // Modify x.a - this is the same as b.f.a
+class exampleJNI {
+ public final static native long new_Foo();
+ public final static native void delete_Foo(long jarg1);
+ public final static native void Foo_x_set(long jarg1, Foo jarg1_, int jarg2);
+ public final static native int Foo_x_get(long jarg1, Foo jarg1_);
+ public final static native int Foo_spam(long jarg1, Foo jarg1_, int jarg2,
+ long jarg3, Foo jarg3_);
+ public final static native void egg(long jarg1, Foo jarg1_);
+}
</PRE>
</DIV>
-<H3><A name="Java_classes"></A>24.3.8 C++ classes</H3>
-<P> C++ classes are wrapped by Java classes as well. For example, if you
- have this class,</P>
+<P> This class contains the complete Java - C/C++ interface so all
+ function calls go via this class. As this class acts as a go-between
+ for all JNI calls to C/C++ code from the Java <A href="#Java_proxy_classes">
+proxy classes</A>, <A href="#Java_type_wrapper_classes">type wrapper
+ classes</A> and <A href="#Java_module_class">module class</A>, it is
+ known as the intermediary JNI class.</P>
+<P> You may notice that SWIG uses a Java long wherever a pointer or
+ class object needs to be marshalled across the Java-C/C++ boundary.
+ This approach leads to minimal JNI code which makes for better
+ performance as JNI code involves a lot of string manipulation. SWIG
+ favours generating Java code over JNI code as Java code is compiled
+ into byte code and avoids the costly string operations needed in JNI
+ code. This approach has a downside though as the proxy class might get
+ collected before the native method has completed. You might notice
+ above that there is an additional parameters with a underscore postfix,
+ eg <TT>jarg1_</TT>. These are added in order to prevent <A href="#Java_pgcpp">
+premature garbage collection when marshalling proxy classes</A>.</P>
+<P> The functions in the intermediary JNI class cannot be accessed
+ outside of its package. Access to them is gained through the module
+ class for globals otherwise the appropriate proxy class.</P>
+ <A name="Java_module_directive"></A>
+<P> The name of the intermediary JNI class can be changed from its
+ default, that is, the module name with JNI appended after it. The
+ module directive attribute <TT>jniclassname</TT> is used to achieve
+ this:</P>
<DIV class="code">
<PRE>
-class List {
-public:
- List();
- ~List();
- int search(char *item);
- void insert(char *item);
- void remove(char *item);
- char *get(int n);
- int length;
-};
+%module (jniclassname="name") modulename
</PRE>
</DIV>
-<P> you can use it in Java like this:</P>
+<P> If <TT>name</TT> is the same as <TT>modulename</TT> then the module
+ class name gets changed from <TT>modulename</TT> to <TT>
+modulenameModule</TT>.</P>
+<H4><A name="Java_imclass_pragmas">25.4.1.1 The intermediary JNI class
+ pragmas</A></H4>
+<P> The intermediary JNI class can be tailored through the use of
+ pragmas, but is not commonly done. The pragmas for this class are:</P>
+<TABLE BORDER summary="Intermediary JNI class pragmas">
+<TR VALIGN="TOP"><TD><B>Pragma</B></TD><TD><B>Description</B></TD></TR>
+<TR><TD>jniclassbase</TD><TD>Base class for the intermediary JNI class</TD>
+</TR>
+<TR><TD>jniclasspackage</TD><TD>Package in which to place the
+ intermediary JNI class</TD></TR>
+<TR><TD>jniclassclassmodifiers</TD><TD>Class modifiers and class type
+ for the intermediary JNI class</TD></TR>
+<TR><TD>jniclasscode</TD><TD>Java code is copied verbatim into the
+ intermediary JNI class</TD></TR>
+<TR><TD>jniclassimports</TD><TD>Java code, usually one or more import
+ statements, placed before the intermediary JNI class definition</TD></TR>
+<TR><TD>jniclassinterfaces</TD><TD>Comma separated interface classes for
+ the intermediary JNI class</TD></TR>
+</TABLE>
+<P> The pragma code appears in the generated intermediary JNI class
+ where you would expect:</P>
<DIV class="code">
<PRE>
-List l = new List();
-l.insert("Ale");
-l.insert("Stout");
-l.insert("Lager");
-String item = l.get(2);
-int length = l.getLength();
+[ jniclassimports pragma ]
+[ jniclassclassmodifiers pragma ] jniclassname extends [ jniclassbase pragma ]
+ implements [ jniclassinterfaces pragma ] {
+[ jniclasscode pragma ]
+... SWIG generated native methods ...
+}
</PRE>
</DIV>
-<P> Class data members are accessed in the same manner as C structures.</P>
-<P> Static class members are unsurprisingly wrapped as static members of
- the Java class:</P>
+<P> The <TT>jniclasscode</TT> pragma is quite useful for adding in a
+ static block for loading the shared library / dynamic link library and
+ demonstrates how pragmas work:</P>
<DIV class="code">
<PRE>
-class Spam {
-public:
- static void foo();
- static int bar;
-};
+%pragma(java) jniclasscode=%{
+ static {
+ try {
+ System.loadLibrary("example");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. \n" + e);
+ System.exit(1);
+ }
+ }
+%}
</PRE>
</DIV>
-<P> The static members work like any other Java static member:</P>
+<P> Pragmas will take either <TT>""</TT> or <TT>%{ %}</TT> as
+ delimiters. For example, let's change the intermediary JNI class access
+ to just the default package-private access.</P>
+<DIV class="code">
+<PRE>
+%pragma(java) jniclassclassmodifiers="class"
+</PRE>
+</DIV>
+<P> All the methods in the intermediary JNI class will then not be
+ callable outside of the package as the method modifiers have been
+ changed from public access to default access. This is useful if you
+ want to prevent users calling these low level functions.</P>
+<H3><A name="Java_module_class">25.4.2 The Java module class</A></H3>
+<P> All global functions and variable getters/setters appear in the
+ module class. For our example, there is just one function:</P>
+<DIV class="code">
+<PRE>
+public class example {
+ public static void egg(Foo chips) {
+ exampleJNI.egg(Foo.getCPtr(chips), chips);
+ }
+}
+</PRE>
+</DIV>
+<P> The module class is necessary as there is no such thing as a global
+ in Java so all the C globals are put into this class. They are
+ generated as static functions and so must be accessed as such by using
+ the module name in the static function call:</P>
+<DIV class="code">
+<PRE>
+example.egg(new Foo());
+</PRE>
+</DIV>
+<P> The primary reason for having the module class wrapping the calls in
+ the intermediary JNI class is to implement static type checking. In
+ this case only a <TT>Foo</TT> can be passed to the <TT>egg</TT>
+ function, whereas any <TT>long</TT> can be passed to the <TT>egg</TT>
+ function in the intermediary JNI class.</P>
+<H4><A name="Java_module_class_pragmas">25.4.2.1 The Java module class
+ pragmas</A></H4>
+<P> The module class can be tailored through the use of pragmas, in the
+ same manner as the intermediary JNI class. The pragmas are similarly
+ named and are used in the same way. The complete list follows:</P>
+<TABLE BORDER summary="Java module class pragmas">
+<TR VALIGN="TOP"><TD><B>Pragma</B></TD><TD><B>Description</B></TD></TR>
+<TR><TD>modulebase</TD><TD>Base class for the module class</TD></TR>
+<TR><TD>moduleclassmodifiers</TD><TD>Class modifiers and class type for
+ the module class</TD></TR>
+<TR><TD>modulecode</TD><TD>Java code is copied verbatim into the module
+ class</TD></TR>
+<TR><TD>moduleimports</TD><TD>Java code, usually one or more import
+ statements, placed before the module class definition</TD></TR>
+<TR><TD>moduleinterfaces</TD><TD>Comma separated interface classes for
+ the module class</TD></TR>
+</TABLE>
+<P> The pragma code appears in the generated module class like this:</P>
<DIV class="code">
<PRE>
-Spam.foo();
-int bar = Spam.getBar();
+[ moduleimports pragma ]
+[ modulemodifiers pragma ] modulename extends [ modulebase pragma ]
+ implements [ moduleinterfaces pragma ] {
+[ modulecode pragma ]
+... SWIG generated wrapper functions ...
+}
</PRE>
</DIV>
-<H3><A name="Java_inheritance"></A>24.3.9 C++ inheritance</H3>
-<P> SWIG is fully aware of issues related to C++ inheritance. Therefore,
- if you have classes like this</P>
+<P> See <A href="#Java_imclass_pragmas">The intermediary JNI class
+ pragmas</A> section for further details on using pragmas.</P>
+<H3><A name="Java_proxy_classes">25.4.3 Java proxy classes</A></H3>
+<P> A Java proxy class is generated for each structure, union or C++
+ class that is wrapped. Proxy classes have also been called <A href="http://java.sun.com/docs/books/jni/html/stubs.html">
+peer classes</A>. The default proxy class for our previous example looks
+ like this:</P>
<DIV class="code">
<PRE>
-class Foo {
-...
-};
+public class Foo {
+ private transient long swigCPtr;
+ protected transient boolean swigCMemOwn;
-class Bar : public Foo {
-...
-};
+ protected Foo(long cPtr, boolean cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = cPtr;
+ }
+
+ protected static long getCPtr(Foo obj) {
+ return (obj == null) ? 0 : obj.swigCPtr;
+ }
+
+ protected void finalize() {
+ delete();
+ }
+
+ public synchronized void delete() {
+ if(swigCPtr != 0 && swigCMemOwn) {
+ swigCMemOwn = false;
+ exampleJNI.delete_Foo(swigCPtr);
+ }
+ swigCPtr = 0;
+ }
+
+ public void setX(int value) {
+ exampleJNI.Foo_x_set(swigCPtr, this, value);
+ }
+
+ public int getX() {
+ return exampleJNI.Foo_x_get(swigCPtr, this);
+ }
+
+ public int spam(int num, Foo foo) {
+ return exampleJNI.Foo_spam(swigCPtr, this, num, Foo.getCPtr(foo), foo);
+ }
+
+ public Foo() {
+ this(exampleJNI.new_Foo(), true);
+ }
+
+}
</PRE>
</DIV>
-<P> those classes are wrapped into a hierarchy of Java classes that
- reflect the same inheritance structure:</P>
+<P> This class merely holds a pointer to the underlying C++ object (<TT>
+swigCPtr</TT>). It also contains all the methods in the C++ class it is
+ proxying plus getters and setters for public member variables. These
+ functions call the native methods in the intermediary JNI class. The
+ advantage of having this extra layer is the type safety that the proxy
+ class functions offer. It adds static type checking which leads to
+ fewer surprises at runtime. For example, you can see that if you
+ attempt to use the <TT>spam()</TT> function it will only compile when
+ the parameters passed are an <TT>int</TT> and a <TT>Foo</TT>. From a
+ user's point of view, it makes the class work as if it were a Java
+ class:</P>
<DIV class="code">
<PRE>
-Bar b = new Bar();
-Class c = b.getClass();
-System.out.println(c.getSuperclass().getName());
+Foo f = new Foo();
+f.setX(3);
+int y = f.spam(5, new Foo());
</PRE>
</DIV>
-<P> will of course display:</P>
+<H4><A name="Java_memory_management">25.4.3.1 Memory management</A></H4>
+<P> Each proxy class has an ownership flag <TT>swigCMemOwn</TT>. The
+ value of this flag determines who is responsible for deleting the
+ underlying C++ object. If set to <TT>true</TT>, the proxy class's
+ finalizer will destroy the C++ object when the proxy class is garbage
+ collected. If set to false, then the destruction of the proxy class has
+ no effect on the C++ object.</P>
+<P> When an object is created by a constructor or returned by value,
+ Java automatically takes ownership of the result. On the other hand,
+ when pointers or references are returned to Java, there is often no way
+ to know where they came from. Therefore, the ownership is set to false.
+ For example:</P>
<DIV class="code">
<PRE>
-Foo
+class Foo {
+public:
+ Foo();
+ Foo bar1();
+ Foo &bar2();
+ Foo *bar2();
+};
</PRE>
</DIV>
-<P> Furthermore, if you have functions like this</P>
+<P> In Java:</P>
<DIV class="code">
<PRE>
-void spam(Foo *f);
+Foo f = new Foo(); // f.swigCMemOwn = true
+Foo f1 = f.bar1(); // f1.swigCMemOwn = true
+Foo f2 = f.bar2(); // f2.swigCMemOwn = false
+Foo f3 = f.bar3(); // f3.swigCMemOwn = false
</PRE>
</DIV>
-<P> then the Java function <TT>spam()</TT> accepts instances of <TT>Foo</TT>
- or instances of any other proxy classes derived from <TT>Foo</TT>.</P>
-<P> Note that Java does not support multiple inheritance so any multiple
- inheritance in the C++ code is not going to work. A warning is given
- when multiple inheritance is detected and only the first base class is
- used.</P>
-<H3><A name="Java_pointers_refs_arrays"></A>24.3.10 Pointers,
- references, arrays and pass by value</H3>
-<P> In C++, there are many different ways a function might receive and
- manipulate objects. For example:</P>
+<P> This behavior for pointers and references is especially important
+ for classes that act as containers. For example, if a method returns a
+ pointer to an object that is contained inside another object, you
+ definitely don't want Java to assume ownership and destroy it!</P>
+<P> For the most part, memory management issues remain hidden. However,
+ there are situations where you might have to manually change the
+ ownership of an object. For instance, consider code like this:</P>
<DIV class="code">
<PRE>
-void spam1(Foo *x); // Pass by pointer
-void spam2(Foo &x); // Pass by reference
-void spam3(Foo x); // Pass by value
-void spam4(Foo x[]); // Array of objects
+class Obj {};
+class Node {
+ Obj *value;
+public:
+ void set_value(Obj *v) { value = v; }
+};
</PRE>
</DIV>
-<P> In Java, there is no detailed distinction like this--specifically,
- there are only instances of classes. There are no pointers nor
- references. Because of this, SWIG unifies all of these types together
- in the wrapper code. For instance, if you actually had the above
- functions, it is perfectly legal to do this from Java:</P>
+<P> Now, consider the following Java code:</P>
<DIV class="code">
<PRE>
-Foo f = new Foo(); // Create a Foo
-example.spam1(f); // Ok. Pointer
-example.spam2(f); // Ok. Reference
-example.spam3(f); // Ok. Value.
-example.spam4(f); // Ok. Array (1 element)
+Node n = new Node(); // Create a node
+{
+ Obj o = new Obj(); // Create an object
+ n.set_value(o); // Set value
+} // o goes out of scope
</PRE>
</DIV>
-<P> Similar behavior occurs for return values. For example, if you had
- functions like this,</P>
+<P> In this case, the Node <TT>n</TT> is holding a reference to <TT>o</TT>
+ internally. However, SWIG has no way to know that this has occurred.
+ The Java proxy class still thinks that it has ownership of <TT>o</TT>.
+ As <TT>o</TT> has gone out of scope, it could be garbage collected in
+ which case the C++ destructor will be invoked and <TT>n</TT> will then
+ be holding a stale-pointer to <TT>o</TT>. If you're lucky, you will
+ only get a segmentation fault.</P>
+<P> To work around this, the ownership flag of <TT>o</TT> needs changing
+ to <TT>false</TT>. The ownership flag is a private member variable of
+ the proxy class so this is not possible without some customization of
+ the proxy class. This can be achieved by using a typemap to customise
+ the proxy class with pure Java code as detailed later in the section on
+ <A href="#Java_typemaps">Java typemaps</A>.</P>
+<P> Sometimes a function will create memory and return a pointer to a
+ newly allocated object. SWIG has no way of knowing this so by default
+ the proxy class does not manage the returned object. However, you can
+ tell the proxy class to manage the memory if you specify the <TT>
+%newobject</TT> directive. Consider:</P>
<DIV class="code">
<PRE>
-Foo *spam5();
-Foo &spam6();
-Foo spam7();
+class Obj {...};
+class Factory {
+public:
+ static Obj *createObj() { return new Obj(); }
+};
</PRE>
</DIV>
-<P> then all three functions will return a pointer to some <TT>Foo</TT>
- object. Since the third function (spam7) returns a value, newly
- allocated memory is used to hold the result and a pointer is returned
- (Java will release this memory when the returned object's finalizer is
- run by the garbage collector).</P>
-<H4><A name="Java_null_pointers"></A>24.3.10.1 Null pointers</H4>
-<P> Working with null pointers is easy. A Java <TT>null</TT> can be used
- whenever a method expects a proxy class or typewrapper class. However,
- it is not possible to pass null to C/C++ functions that take parameters
- by value or by reference. If you try you will get a
- NullPointerException.</P>
+<P> If we call the factory function, then we have to manually delete the
+ memory:</P>
<DIV class="code">
<PRE>
-example.spam1(null); // Pointer - ok
-example.spam2(null); // Reference - NullPointerException
-example.spam3(null); // Value - NullPointerException
-example.spam4(null); // Array - ok
+Obj obj = Factory.createObj(); // obj.swigCMemOwn = false
+...
+obj.delete();
</PRE>
</DIV>
-<P> For <TT>spam1</TT> and <TT>spam4</TT> above the Java <TT>null</TT>
- gets translated into a NULL pointer for passing to the C/C++ function.
- The converse also occurs, that is, NULL pointers are translated into <TT>
-null</TT> Java objects when returned from a C/C++ function.</P>
-<H3><A name="Java_overloaded_functions"></A>24.3.11 C++ overloaded
- functions</H3>
-<P> C++ overloaded functions, methods, and constructors are mostly
- supported by SWIG. For example, if you have two functions like this:</P>
+<P> Now add in the %newobject directive:</P>
<DIV class="code">
<PRE>
-%module example
+%newobject Factory::createObj();
-void foo(int);
-void foo(char *c);
+class Obj {...};
+class Factory {
+public:
+ static Obj *createObj() { return new Obj(); }
+};
</PRE>
</DIV>
-<P> You can use them in Java in a straightforward manner:</P>
+<P> A call to <TT>delete()</TT> is no longer necessary as the garbage
+ collector will make the C++ destructor call because <TT>swigCMemOwn</TT>
+ is now true.</P>
<DIV class="code">
<PRE>
-example.foo(3); // foo(int)
-example.foo("Hello"); // foo(char *c)
+Obj obj = Factory.createObj(); // obj.swigCMemOwn = true;
+...
</PRE>
</DIV>
-<P> Similarly, if you have a class like this,</P>
+<P> Some memory management issues are quite tricky to fix and may only
+ be noticeable after using for a long time. One such issue is premature
+ garbage collection of an object created from Java and resultant usage
+ from C++ code. The section on typemap examples cover two such
+ scenarios, <A href="#Java_memory_management_objects">Memory management
+ for objects passed to the C++ layer</A> and <A href="#Java_memory_management_member_variables">
+Memory management when returning references to member variables</A></P>
+<H4><A name="Java_inheritance_mirroring">25.4.3.2 Inheritance</A></H4>
+<P> Java proxy classes will mirror C++ inheritance chains. For example,
+ given the base class <TT>Base</TT> and its derived class <TT>Derived</TT>
+:</P>
<DIV class="code">
<PRE>
-class Foo {
+class Base {
public:
- Foo();
- Foo(const Foo &);
- ...
+ virtual double foo();
+};
+
+class Derived : public Base {
+public:
+ virtual double foo();
};
</PRE>
</DIV>
-<P> you can write Java code like this:</P>
-<DIV class="code">
-<PRE>
-Foo f = new Foo(); // Create a Foo
-Foo g = new Foo(f); // Copy f
-</PRE>
-</DIV>
-<P> Overloading support is not quite as flexible as in C++. Sometimes
- there are methods that SWIG cannot disambiguate as there can be more
- than one C++ type mapping onto a single Java type. For example:</P>
+<P> The base class is generated much like any other proxy class seen so
+ far:</P>
<DIV class="code">
<PRE>
-void spam(int);
-void spam(unsigned short);
+public class Base {
+ private transient long swigCPtr;
+ protected transient boolean swigCMemOwn;
+
+ protected Base(long cPtr, boolean cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = cPtr;
+ }
+
+ protected static long getCPtr(Base obj) {
+ return (obj == null) ? 0 : obj.swigCPtr;
+ }
+
+ protected void finalize() {
+ delete();
+ }
+
+ public synchronized void delete() {
+ if(swigCPtr != 0 && swigCMemOwn) {
+ swigCMemOwn = false;
+ exampleJNI.delete_Base(swigCPtr);
+ }
+ swigCPtr = 0;
+ }
+
+ public double foo() {
+ return exampleJNI.Base_foo(swigCPtr, this);
+ }
+
+ public Base() {
+ this(exampleJNI.new_Base(), true);
+ }
+
+}
</PRE>
</DIV>
-<P> Here both int and unsigned short map onto a Java int. Here is
- another example:</P>
+<P> The <TT>Derived</TT> class extends <TT>Base</TT> mirroring the C++
+ class inheritance hierarchy.</P>
<DIV class="code">
<PRE>
-void foo(Bar *b);
-void foo(Bar &b);
+public class Derived extends Base {
+ private transient long swigCPtr;
+
+ protected Derived(long cPtr, boolean cMemoryOwn) {
+ super(exampleJNI.SWIGDerivedUpcast(cPtr), cMemoryOwn);
+ swigCPtr = cPtr;
+ }
+
+ protected static long getCPtr(Derived obj) {
+ return (obj == null) ? 0 : obj.swigCPtr;
+ }
+
+ protected void finalize() {
+ delete();
+ }
+
+ public synchronized void delete() {
+ if(swigCPtr != 0 && swigCMemOwn) {
+ swigCMemOwn = false;
+ exampleJNI.delete_Derived(swigCPtr);
+ }
+ swigCPtr = 0;
+ super.delete();
+ }
+
+ public double foo() {
+ return exampleJNI.Derived_foo(swigCPtr, this);
+ }
+
+ public Derived() {
+ this(exampleJNI.new_Derived(), true);
+ }
+
+}
</PRE>
</DIV>
-<P> If declarations such as these appear, you will get a warning message
- like this:</P>
+<P> Note the memory ownership is controlled by the base class. However
+ each class in the inheritance hierarchy has its own pointer value which
+ is obtained during construction. The <TT>SWIGDerivedUpcast()</TT> call
+ converts the pointer from a <TT>Derived *</TT> to a <TT>Base *</TT>.
+ This is a necessity as C++ compilers are free to implement pointers in
+ the inheritance hierarchy with different values.</P>
+<P> It is of course possible to extend <TT>Base</TT> using your own Java
+ classes. If <TT>Derived</TT> is provided by the C++ code, you could for
+ example add in a pure Java class <TT>Extended</TT> derived from <TT>
+Base</TT>. There is a caveat and that is any C++ code will not know
+ about your pure Java class <TT>Extended</TT> so this type of derivation
+ is restricted. However, true cross language polymorphism can be
+ achieved using the <A href="#Java_directors">directors</A> feature.</P>
+<H4><A name="Java_proxy_classes_gc">25.4.3.3 Proxy classes and garbage
+ collection</A></H4>
+<P> By default each proxy class has a <TT>delete()</TT> and a <TT>
+finalize()</TT> method. The <TT>finalize()</TT> method calls <TT>
+delete()</TT> which frees any malloc'd memory for wrapped C structs or
+ calls the C++ class destructors. The idea is for <TT>delete()</TT> to
+ be called when you have finished with the C/C++ object. Ideally you
+ need not call <TT>delete()</TT>, but rather leave it to the garbage
+ collector to call it from the finalizer. When a program exits, the
+ garbage collector does not guarantee to call all finalizers. An insight
+ into the reasoning behind this can be obtained from <A href="http://www.hpl.hp.com/techreports/2002/HPL-2002-335.html">
+Hans Boehm's Destructors, Finalizers, and Synchronization</A> paper.
+ Depending on what the finalizers do and which operating system you use,
+ this may or may not be a problem.</P>
+<P> If the <TT>delete()</TT> call into JNI code is just for memory
+ handling, there is not a problem when run on most operating systems,
+ for example Windows and Unix. Say your JNI code creates memory on the
+ heap which your finalizers should clean up, the finalizers may or may
+ not be called before the program exits. In Windows and Unix all memory
+ that a process uses is returned to the system on exit, so this isn't a
+ problem. This is not the case in some operating systems like vxWorks.
+ If however, your finalizer calls into JNI code invoking the C++
+ destructor which in turn releases a TCP/IP socket for example, there is
+ no guarantee that it will be released. Note that with long running
+ programs the garbage collector will eventually run, thereby calling any
+ unreferenced object's finalizers.</P>
+<P> Some not so ideal solutions are:</P>
+<OL>
+<LI>
+<P> Call the <TT>System.runFinalizersOnExit(true)</TT> or <TT>
+Runtime.getRuntime().runFinalizersOnExit(true)</TT> to ensure the
+ finalizers are called before the program exits. The catch is that this
+ is a deprecated function call as the documentation says:</P>
+<DIV class="code"><I> This method is inherently unsafe. It may result in
+ finalizers being called on live objects while other threads are
+ concurrently manipulating those objects, resulting in erratic behavior
+ or deadlock.</I></DIV>
+<P>In many cases you will be lucky and find that it works, but it is not
+ to be advocated. Have a look at <A href="http://www.oracle.com/technetwork/java/index.html">
+Java web site</A> and search for <TT>runFinalizersOnExit</TT>.</P>
+</LI>
+<LI>
+<P> From jdk1.3 onwards a new function, <TT>addShutdownHook()</TT>, was
+ introduced which is guaranteed to be called when your program exits.
+ You can encourage the garbage collector to call the finalizers, for
+ example, add this static block to the class that has the <TT>main()</TT>
+ function:</P>
<DIV class="code">
<PRE>
-example.i:12: Warning 515: Overloaded method spam(unsigned short) ignored.
-Method spam(int) at example.i:11 used.
+ static {
+ Runtime.getRuntime().addShutdownHook(
+ new Thread() {
+ public void run() { System.gc(); System.runFinalization(); }
+ }
+ );
+ }
</PRE>
</DIV>
-<P> To fix this, you either need to either <A href="#SWIG_rename_ignore">
-rename or ignore</A> one of the methods. For example:</P>
+<P>Although this usually works, the documentation doesn't guarantee that
+ <TT>runFinalization()</TT> will actually call the finalizers. As the
+ shutdown hook is guaranteed you could also make a JNI call to clean up
+ any resources that are being tracked by the C/C++ code.</P>
+</LI>
+<LI>
+<P>Call the <TT>delete()</TT> function manually which will immediately
+ invoke the C++ destructor. As a suggestion it may be a good idea to set
+ the object to null so that should the object be inadvertently used
+ again a Java null pointer exception is thrown, the alternative would
+ crash the JVM by using a null C pointer. For example given a SWIG
+ generated class A:</P>
<DIV class="code">
<PRE>
-%rename(spam_ushort) spam(unsigned short);
-...
-void spam(int);
-void spam(unsigned short); // Now renamed to spam_ushort
+A myA = new A();
+// use myA ...
+myA.delete();
+// any use of myA here would crash the JVM
+myA=null;
+// any use of myA here would cause a Java null pointer exception to be thrown
</PRE>
</DIV>
-<P> or</P>
+<P> The SWIG generated code ensures that the memory is not deleted
+ twice, in the event the finalizers get called in addition to the manual
+ <TT>delete()</TT> call.</P>
+</LI>
+<LI>
+<P> Write your own object manager in Java. You could derive all SWIG
+ classes from a single base class which could track which objects have
+ had their finalizers run, then call the rest of them on program
+ termination. The section on <A href="#Java_typemaps">Java typemaps</A>
+ details how to specify a pure Java base class.</P>
+</LI>
+</OL>
+<P> See the <A href="http://www.devx.com/Java/Article/30192">How to
+ Handle Java Finalization's Memory-Retention Issues</A> article for
+ alternative approaches to managing memory by avoiding finalizers
+ altogether.</P>
+<H4><A name="Java_pgcpp">25.4.3.4 The premature garbage collection
+ prevention parameter for proxy class marshalling</A></H4>
+<P> As covered earlier, the C/C++ struct/class pointer is stored in the
+ proxy class as a Java long and when needed is passed into the native
+ method where it is cast into the appropriate type. This approach
+ provides very fast marshalling but could be susceptible to premature
+ garbage collection. Consider the following C++ code:</P>
<DIV class="code">
<PRE>
-%ignore spam(unsigned short);
-...
-void spam(int);
-void spam(unsigned short); // Ignored
+class Wibble {
+};
+void wobble(Wibble &w);
</PRE>
</DIV>
-<H3><A name="Java_default_arguments"></A>24.3.12 C++ default arguments</H3>
-<P> Any function with a default argument is wrapped by generating an
- additional function for each argument that is defaulted. For example,
- if we have the following C++:</P>
+<P> The module class contains the Java wrapper for the global <TT>wobble</TT>
+ method:</P>
<DIV class="code">
<PRE>
-%module example
-
-void defaults(double d=10.0, int i=0);
+public class example {
+ ...
+ public static void wobble(Wibble w) {
+ exampleJNI.wobble(Wibble.getCPtr(w), w);
+ }
+}
</PRE>
</DIV>
-<P> The following methods are generated in the Java module class:</P>
+<P> where <TT>example</TT> is the name of the module. All native methods
+ go through the intermediary class which has the native method declared
+ as such:</P>
<DIV class="code">
<PRE>
-public class example {
- public static void defaults(double d, int i) { ... }
- public static void defaults(double d) { ... }
- public static void defaults() { ... }
+public class exampleJNI {
+ ...
+ public final static native void wobble(long jarg1, Wibble jarg1_);
}
</PRE>
</DIV>
-<P> It is as if SWIG had parsed three separate overloaded methods. The
- same approach is taken for static methods, constructors and member
- methods.</P>
-<P><B> Compatibility note:</B> Versions of SWIG prior to SWIG-1.3.23
- wrapped these with a single wrapper method and so the default values
- could not be taken advantage of from Java. Further details on default
- arguments and how to restore this approach are given in the more
- general <A href="#SWIGPlus_default_args">Default arguments</A> section.</P>
-<H3><A name="Java_namespaces"></A>24.3.13 C++ namespaces</H3>
-<P> SWIG is aware of named C++ namespaces and they can be mapped to Java
- packages, however, the default wrapping flattens the namespaces,
- effectively ignoring them. So by default, the namespace names do not
- appear in the module nor do namespaces result in a module that is
- broken up into submodules or packages. For example, if you have a file
- like this,</P>
+<P> The second parameter, <TT>jarg1_</TT>, is the premature garbage
+ collection prevention parameter and is added to the native method
+ parameter list whenever a C/C++ struct or class is marshalled as a Java
+ long. In order to understand why, consider the alternative where the
+ intermediary class method is declared without the additional parameter:</P>
<DIV class="code">
<PRE>
-%module example
-
-namespace foo {
- int fact(int n);
- struct Vector {
- double x,y,z;
- };
-};
+public class exampleJNI {
+ ...
+ public final static native void wobble(long jarg1);
+}
</PRE>
</DIV>
-<P> it works in Java as follows:</P>
+<P> and the following simple call to <TT>wobble</TT>:</P>
<DIV class="code">
<PRE>
-int f = example.fact(3);
-Vector v = new Vector();
-v.setX(3.4);
-double y = v.getY();
+{
+ Wibble w = new Wibble();
+ example.wobble(w);
+}
</PRE>
</DIV>
-<P> If your program has more than one namespace, name conflicts (if any)
- can be resolved using <TT>%rename</TT> For example:</P>
+<P> The hotspot compiler effectively sees something like:</P>
<DIV class="code">
<PRE>
-%rename(Bar_spam) Bar::spam;
-
-namespace Foo {
- int spam();
+{
+ Wibble w = new Wibble();
+ long w_ptr = Wibble.getCPtr(w);
+ // w is no longer reachable
+ exampleJNI.wobble(w_ptr);
}
-
-namespace Bar {
- int spam();
+</PRE>
+</DIV>
+<P> The <TT>Wibble</TT> object is no longer reachable after the point
+ shown as in this bit of code, the <TT>Wibble</TT> object is not
+ referenced again after this point. This means that it is a candidate
+ for garbage collection. Should <TT>wobble</TT> be a long running
+ method, it is quite likely that the finalizer for the <TT>Wibble</TT>
+ instance will be called. This in turn will call its underlying C++
+ destructor which is obviously disastrous while the method <TT>wobble</TT>
+ is running using this object. Even if <TT>wobble</TT> is not a long
+ running method, it is possible for the <TT>Wibble</TT> instance to be
+ finalized. By passing the <TT>Wibble</TT> instance into the native
+ method, it will not be finalized as the JVM guarantees not to finalize
+ any objects until the native method returns. Effectively, the code then
+ becomes</P>
+<DIV class="code">
+<PRE>
+{
+ Wibble w = new Wibble();
+ long w_ptr = Wibble.getCPtr(w);
+ exampleJNI.wobble(w_ptr, w);
+ // w is no longer reachable
}
</PRE>
</DIV>
-<P> If you have more than one namespace and you want to keep their
- symbols separate, consider wrapping them as separate SWIG modules. Each
- SWIG module can be placed into a separate package.</P>
-<P> The default behaviour described above can be improved via the <A href="#SWIGPlus_nspace">
-nspace feature</A>. Note that it only works for classes, structs, unions
- and enums declared within a named C++ namespace. When the nspace
- feature is used, the C++ namespaces are converted into Java packages of
- the same name. Proxy classes are thus declared within a package and
- this proxy makes numerous calls to the JNI intermediary class which is
- declared in the unnamed package by default. As Java does not support
- types declared in a named package accessing types declared in an
- unnamed package, the <TT>-package</TT> commandline option described
- earlier generally should be used to provide a parent package. So if
- SWIG is run using the <TT>-package com.myco</TT> option, a wrapped
- class, <TT>MyWorld::Material::Color</TT>, can then be accessed as <TT>
-com.myco.MyWorld.Material.Color</TT>. If you don't specify a package,
- you will get the following warning:</P>
-<DIV class="shell">
+<P> and therefore there is no possibility of premature garbage
+ collection. In practice, this premature garbage collection was only
+ ever observed in Sun's server JVM from jdk-1.3 onwards and in Sun's
+ client JVM from jdk-1.6 onwards.</P>
+<P> The premature garbage collection prevention parameter for proxy
+ classes is generated by default whenever proxy classes are passed by
+ value, reference or with a pointer. The implementation for this extra
+ parameter generation requires the "jtype" typemap to contain <TT>long</TT>
+ and the "jstype" typemap to contain the name of a proxy class.</P>
+<P> The additional parameter does impose a slight performance overhead
+ and the parameter generation can be suppressed globally with the <TT>
+-nopgcpp</TT> commandline option. More selective suppression is possible
+ with the 'nopgcpp' attribute in the "jtype" <A href="#Java_typemaps">
+Java typemap</A>. The attribute is a flag and so should be set to "1" to
+ enable the suppression, or it can be omitted or set to "0" to disable.
+ For example:</P>
+<DIV class="code">
<PRE>
-example.i:16: Warning 826: The nspace feature is used on 'MyWorld::Material::Color' without -package. The generated code
-may not compile as Java does not support types declared in a named package accessing types declared in an unnamed package.
+%typemap(jtype, nopgcpp="1") Wibble & "long"
</PRE>
</DIV>
-<P> If it is undesirable to have a single top level package, the nspace
- feature may be used without the <TT>-package</TT> commandline option
- (and the resulting warning ignored) if all of the types exposed using
- SWIG are placed in a package using the nspace feature and the
- 'jniclasspackage' pragma is used to specify a package for the JNI
- intermediary class.</P>
-<P> If the resulting use of the nspace feature and hence packages
- results in a proxy class in one package deriving or using a proxy class
- from another package, you will need to open up the visibility for the
- pointer constructor and <TT>getCPtr</TT> method from the default
- 'protected' to 'public' with the <TT>SWIG_JAVABODY_PROXY</TT> macro.
- See <A href="#Java_code_typemaps">Java code typemaps</A>.</P>
-<H3><A name="Java_templates"></A>24.3.14 C++ templates</H3>
-<P> C++ templates don't present a huge problem for SWIG. However, in
- order to create wrappers, you have to tell SWIG to create wrappers for
- a particular template instantiation. To do this, you use the <TT>
-%template</TT> directive. For example:</P>
+<P><B> Compatibility note:</B> The generation of this additional
+ parameter did not occur in versions prior to SWIG-1.3.30.</P>
+<H4><A name="Java_multithread_libraries">25.4.3.5 Single threaded
+ applications and thread safety</A></H4>
+<P> Single threaded Java applications using JNI need to consider thread
+ safety. The same applies for the C# module where the .NET wrappers use
+ PInvoke. Consider the C++ class:</P>
<DIV class="code">
<PRE>
-%module example
-%{
-#include <utility>
-%}
-
-template<class T1, class T2>
-struct pair {
- typedef T1 first_type;
- typedef T2 second_type;
- T1 first;
- T2 second;
- pair();
- pair(const T1&, const T2&);
- ~pair();
+class Test {
+ string str;
+public:
+ Test() : str("initial") {}
};
-
-%template(pairii) pair<int,int>;
</PRE>
</DIV>
-<P> In Java:</P>
+<P> and the Java proxy class generated by SWIG:</P>
<DIV class="code">
<PRE>
-pairii p = new pairii(3,4);
-int first = p.getFirst();
-int second = p.getSecond();
+public class Test {
+ private transient long swigCPtr;
+ protected transient boolean swigCMemOwn;
+
+ protected Test(long cPtr, boolean cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = cPtr;
+ }
+
+ protected static long getCPtr(Test obj) {
+ return (obj == null) ? 0 : obj.swigCPtr;
+ }
+
+ protected void finalize() {
+ delete();
+ }
+
+ // Call C++ destructor
+ public synchronized void delete() {
+ if(swigCPtr != 0 && swigCMemOwn) {
+ swigCMemOwn = false;
+ exampleJNI.delete_Test(swigCPtr);
+ }
+ swigCPtr = 0;
+ }
+
+ // Call C++ constructor
+ public Test() {
+ this(exampleJNI.new_Test(), true);
+ }
+
+}
</PRE>
</DIV>
-<P> Obviously, there is more to template wrapping than shown in this
- example. More details can be found in the <A href="#SWIGPlus">SWIG and
- C++</A> chapter.</P>
-<H3><A name="Java_smart_pointers"></A>24.3.15 C++ Smart Pointers</H3>
-<P> In certain C++ programs, it is common to use classes that have been
- wrapped by so-called "smart pointers." Generally, this involves the use
- of a template class that implements <TT>operator->()</TT> like this:</P>
+<P> It has two methods that call JNI methods, namely, <TT>
+exampleJNI.new_Test()</TT> for the C++ constructor and <TT>
+exampleJNI.delete_Test()</TT> for the C++ destructor. If the garbage
+ collector collects an instance of this class, ie <TT>delete()</TT> is
+ not explicitly called, then the C++ destructor will be run in a
+ different thread to the main thread. This is because when an object is
+ marked for garbage collection, any objects with finalizers are added to
+ a finalization queue and the objects in the finalization queue have
+ their <TT>finalize()</TT> methods run in a separate finalization
+ thread. Therefore, if the C memory allocator is not thread safe, then
+ the heap will get corrupted sooner or later, when a concurrent C++
+ delete and new are executed. It is thus essential, even in single
+ threaded usage, to link to the C multi-thread runtime libraries, for
+ example, use the /MD option for Visual C++ on Windows. Alternatively,
+ lock all access to C++ functions that have heap
+ allocation/deallocation.</P>
+<P> Note that some of the STL in Visual C++ 6 is not thread safe, so
+ although code might be linked to the multithread runtime libraries,
+ undefined behaviour might still occur in a single threaded Java
+ program. Similarly some older versions of Sun Studio have bugs in the
+ multi-threaded implementation of the std::string class and so will lead
+ to undefined behaviour in these supposedly single threaded Java
+ applications.</P>
+<P> The following innocuous Java usage of Test is an example that will
+ crash very quickly on a multiprocessor machine if the JNI compiled code
+ is linked against the single thread C runtime libraries.</P>
<DIV class="code">
<PRE>
-template<class T> class SmartPtr {
- ...
- T *operator->();
- ...
+for (int i=0; i<100000; i++) {
+ System.out.println("Iteration " + i);
+ for (int k=0; k<10; k++) {
+ Test test = new Test();
+ }
+ System.gc();
}
</PRE>
</DIV>
-<P> Then, if you have a class like this,</P>
+<H3><A name="Java_type_wrapper_classes">25.4.4 Type wrapper classes</A></H3>
+<P> The generated type wrapper class, for say an <TT>int *</TT>, looks
+ like this:</P>
<DIV class="code">
<PRE>
-class Foo {
-public:
- int x;
- int bar();
-};
+public class SWIGTYPE_p_int {
+ private transient long swigCPtr;
+
+ protected SWIGTYPE_p_int(long cPtr, boolean bFutureUse) {
+ swigCPtr = cPtr;
+ }
+
+ protected SWIGTYPE_p_int() {
+ swigCPtr = 0;
+ }
+
+ protected static long getCPtr(SWIGTYPE_p_int obj) {
+ return obj.swigCPtr;
+ }
+}
</PRE>
</DIV>
-<P> A smart pointer would be used in C++ as follows:</P>
+<P> The methods do not have public access, so by default it is
+ impossible to do anything with objects of this class other than pass
+ them around. The methods in the class are part of the inner workings of
+ SWIG. If you need to mess around with pointers you will have to use
+ some typemaps specific to the Java module to achieve this. The section
+ on <A href="#Java_typemaps">Java typemaps</A> details how to modify the
+ generated code.</P>
+<P> Note that if you use a pointer or reference to a proxy class in a
+ function then no type wrapper class is generated because the proxy
+ class can be used as the function parameter. If however, you need
+ anything more complicated like a pointer to a pointer to a proxy class
+ then a typewrapper class is generated for your use.</P>
+<P> Note that SWIG generates a type wrapper class and not a proxy class
+ when it has not parsed the definition of a type that gets used. For
+ example, say SWIG has not parsed the definition of <TT>class Snazzy</TT>
+ because it is in a header file that you may have forgotten to use the <TT>
+%include</TT> directive on. Should SWIG parse <TT>Snazzy *</TT> being
+ used in a function parameter, it will then generates a type wrapper
+ class around a <TT>Snazzy</TT> pointer. Also recall from earlier that
+ SWIG will use a pointer when a class is passed by value or by
+ reference:</P>
<DIV class="code">
<PRE>
-SmartPtr<Foo> p = CreateFoo(); // Created somehow (not shown)
-...
-p->x = 3; // Foo::x
-int y = p->bar(); // Foo::bar
+void spam(Snazzy *x, Snazzy &y, Snazzy z);
</PRE>
</DIV>
-<P> To wrap this in Java, simply tell SWIG about the <TT>SmartPtr</TT>
- class and the low-level <TT>Foo</TT> object. Make sure you instantiate <TT>
-SmartPtr</TT> using <TT>%template</TT> if necessary. For example:</P>
+<P> Should SWIG not know anything about <TT>Snazzy</TT> then a <TT>
+SWIGTYPE_p_Snazzy</TT> must be used for all 3 parameters in the <TT>spam</TT>
+ function. The Java function generated is:</P>
<DIV class="code">
<PRE>
-%module example
-...
-%template(SmartPtrFoo) SmartPtr<Foo>;
-...
+public static void spam(SWIGTYPE_p_Snazzy x, SWIGTYPE_p_Snazzy y, SWIGTYPE_p_Snazzy z) {
+ ...
+}
</PRE>
</DIV>
-<P> Now, in Java, everything should just "work":</P>
+<P> Note that typedefs are tracked by SWIG and the typedef name is used
+ to construct the type wrapper class name. For example, consider the
+ case where <TT>Snazzy</TT> is a typedef to an <TT>int</TT> which SWIG
+ does parse:</P>
<DIV class="code">
<PRE>
-SmartPtrFoo p = example.CreateFoo(); // Create a smart-pointer somehow
-p.setX(3); // Foo::x
-int y = p.bar(); // Foo::bar
+typedef int Snazzy;
+void spam(Snazzy *x, Snazzy &y, Snazzy z);
</PRE>
</DIV>
-<P> If you ever need to access the underlying pointer returned by <TT>
-operator->()</TT> itself, simply use the <TT>__deref__()</TT> method.
- For example:</P>
+<P> Because the typedefs have been tracked the Java function generated
+ is:</P>
<DIV class="code">
<PRE>
-Foo f = p.__deref__(); // Returns underlying Foo *
+public static void spam(SWIGTYPE_p_int x, SWIGTYPE_p_int y, int z) { ... }
</PRE>
</DIV>
-<H2><A name="Java_further_details"></A>24.4 Further details on the
- generated Java classes</H2>
-<P> In the previous section, a high-level view of Java wrapping was
- presented. A key component of this wrapping is that structures and
- classes are wrapped by Java proxy classes and type wrapper classes are
- used in situations where no proxies are generated. This provides a very
- natural, type safe Java interface to the C/C++ code and fits in with
- the Java programming paradigm. However, a number of low-level details
- were omitted. This section provides a brief overview of how the proxy
- classes work and then covers the type wrapper classes. Finally enum
- classes are covered. First, the crucial intermediary JNI class is
- considered.</P>
-<H3><A name="Java_imclass"></A>24.4.1 The intermediary JNI class</H3>
-<P> In the <A href="#SWIG">"SWIG basics"</A> and <A href="#SWIGPlus">
-"SWIG and C++"</A> chapters, details of low-level structure and class
- wrapping are described. To summarize those chapters, if you have a
- global function and class like this</P>
+<H3><A name="Java_enum_classes">25.4.5 Enum classes</A></H3>
+<P> SWIG can generate three types of enum classes. The <A href="#Java_enumerations">
+Enumerations</A> section discussed these but omitted all the details.
+ The following sub-sections detail the various types of enum classes
+ that can be generated.</P>
+<H4><A name="Java_typesafe_enums_classes">25.4.5.1 Typesafe enum classes</A>
+</H4>
+<P> The following example demonstrates the typesafe enum classes which
+ SWIG generates:</P>
<DIV class="code">
<PRE>
-class Foo {
-public:
- int x;
- int spam(int num, Foo* foo);
-};
-void egg(Foo* chips);
+%include "enumtypesafe.swg"
+%javaconst(1);
+enum Beverage { ALE, LAGER=10, STOUT, PILSNER, PILZ=PILSNER };
</PRE>
</DIV>
-<P> then SWIG transforms the class into a set of low-level procedural
- wrappers. These procedural wrappers essentially perform the equivalent
- of this C++ code:</P>
+<P> The following is the code that SWIG generates:</P>
<DIV class="code">
<PRE>
-Foo *new_Foo() {
- return new Foo();
-}
-void delete_Foo(Foo *f) {
- delete f;
-}
-int Foo_x_get(Foo *f) {
- return f->x;
-}
-void Foo_x_set(Foo *f, int value) {
- f->x = value;
-}
-int Foo_spam(Foo *f, int num, Foo* foo) {
- return f->spam(num, foo);
+public final class Beverage {
+ public final static Beverage ALE = new Beverage("ALE");
+ public final static Beverage LAGER = new Beverage("LAGER", 10);
+ public final static Beverage STOUT = new Beverage("STOUT");
+ public final static Beverage PILSNER = new Beverage("PILSNER");
+ public final static Beverage PILZ = new Beverage("PILZ", PILSNER);
+
+ public final int swigValue() {
+ return swigValue;
+ }
+
+ public String toString() {
+ return swigName;
+ }
+
+ public static Beverage 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 " + Beverage.class + " with value " +
+ swigValue);
+ }
+
+ private Beverage(String swigName) {
+ this.swigName = swigName;
+ this.swigValue = swigNext++;
+ }
+
+ private Beverage(String swigName, int swigValue) {
+ this.swigName = swigName;
+ this.swigValue = swigValue;
+ swigNext = swigValue+1;
+ }
+
+ private Beverage(String swigName, Beverage swigEnum) {
+ this.swigName = swigName;
+ this.swigValue = swigEnum.swigValue;
+ swigNext = this.swigValue+1;
+ }
+
+ private static Beverage[] swigValues = { ALE, LAGER, STOUT, PILSNER, PILZ };
+ private static int swigNext = 0;
+ private final int swigValue;
+ private final String swigName;
}
</PRE>
</DIV>
-<P> These procedural function names don't actually exist, but their
- functionality appears inside the generated JNI functions. The JNI
- functions have to follow a particular naming convention so the function
- names are actually:</P>
+<P> As can be seen, there are a fair number of support methods for the
+ typesafe enum pattern. The typesafe enum pattern involves creating a
+ fixed number of static instances of the enum class. The constructors
+ are private to enforce this. Three constructors are available - two for
+ C/C++ enums with an initializer and one for those without an
+ initializer. Note that the two enums with initializers, <TT>LAGER</TT>
+ and <TT>PILZ</TT>, each call one the two different initializer
+ constructors. In order to use one of these typesafe enums, the <TT>
+swigToEnum</TT> static method must be called to return a reference to
+ one of the static instances. The JNI layer returns the enum value from
+ the C/C++ world as an integer and this method is used to find the
+ appropriate Java enum static instance. The <TT>swigValue</TT> method is
+ used for marshalling in the other direction. The <TT>toString</TT>
+ method is overridden so that the enum name is available.</P>
+<H4><A name="Java_proper_enums_classes">25.4.5.2 Proper Java enum
+ classes</A></H4>
+<P> The following example demonstrates the Java enums approach:</P>
<DIV class="code">
<PRE>
-SWIGEXPORT jlong JNICALL Java_exampleJNI_new_1Foo(JNIEnv *jenv, jclass jcls);
-SWIGEXPORT void JNICALL Java_exampleJNI_delete_1Foo(JNIEnv *jenv, jclass jcls,
- jlong jarg1);
-SWIGEXPORT void JNICALL Java_exampleJNI_Foo_1x_1set(JNIEnv *jenv, jclass jcls,
- jlong jarg1, jobject jarg1_, jint jarg2);
-SWIGEXPORT jint JNICALL Java_exampleJNI_Foo_1x_1get(JNIEnv *jenv, jclass jcls,
- jlong jarg1, jobject jarg1_);
-SWIGEXPORT jint JNICALL Java_exampleJNI_Foo_1spam(JNIEnv *jenv, jclass jcls,
- jlong jarg1, jobject jarg1_, jint jarg2,
- jlong jarg3, jobject jarg3_);
-SWIGEXPORT void JNICALL Java_exampleJNI_egg(JNIEnv *jenv, jclass jcls,
- jlong jarg1, jobject jarg1_);
+%include "enums.swg"
+%javaconst(1);
+enum Beverage { ALE, LAGER=10, STOUT, PILSNER, PILZ=PILSNER };
</PRE>
</DIV>
-<P> For every JNI C function there has to be a static native Java
- function. These appear in the intermediary JNI class:</P>
+<P> SWIG will generate the following Java enum:</P>
<DIV class="code">
<PRE>
-class exampleJNI {
- public final static native long new_Foo();
- public final static native void delete_Foo(long jarg1);
- public final static native void Foo_x_set(long jarg1, Foo jarg1_, int jarg2);
- public final static native int Foo_x_get(long jarg1, Foo jarg1_);
- public final static native int Foo_spam(long jarg1, Foo jarg1_, int jarg2,
- long jarg3, Foo jarg3_);
- public final static native void egg(long jarg1, Foo jarg1_);
+public enum Beverage {
+ ALE,
+ LAGER(10),
+ STOUT,
+ PILSNER,
+ PILZ(PILSNER);
+
+ public final int swigValue() {
+ return swigValue;
+ }
+
+ public static Beverage swigToEnum(int swigValue) {
+ Beverage[] swigValues = Beverage.class.getEnumConstants();
+ if (swigValue < swigValues.length && swigValue >= 0 &&
+ swigValues[swigValue].swigValue == swigValue)
+ return swigValues[swigValue];
+ for (Beverage swigEnum : swigValues)
+ if (swigEnum.swigValue == swigValue)
+ return swigEnum;
+ throw new IllegalArgumentException("No enum " + Beverage.class +
+ " with value " + swigValue);
+ }
+
+ private Beverage() {
+ this.swigValue = SwigNext.next++;
+ }
+
+ private Beverage(int swigValue) {
+ this.swigValue = swigValue;
+ SwigNext.next = swigValue+1;
+ }
+
+ private Beverage(Beverage swigEnum) {
+ this.swigValue = swigEnum.swigValue;
+ SwigNext.next = this.swigValue+1;
+ }
+
+ private final int swigValue;
+
+ private static class SwigNext {
+ private static int next = 0;
+ }
}
</PRE>
</DIV>
-<P> This class contains the complete Java - C/C++ interface so all
- function calls go via this class. As this class acts as a go-between
- for all JNI calls to C/C++ code from the Java <A href="#Java_proxy_classes">
-proxy classes</A>, <A href="#Java_type_wrapper_classes">type wrapper
- classes</A> and <A href="#Java_module_class">module class</A>, it is
- known as the intermediary JNI class.</P>
-<P> You may notice that SWIG uses a Java long wherever a pointer or
- class object needs to be marshalled across the Java-C/C++ boundary.
- This approach leads to minimal JNI code which makes for better
- performance as JNI code involves a lot of string manipulation. SWIG
- favours generating Java code over JNI code as Java code is compiled
- into byte code and avoids the costly string operations needed in JNI
- code. This approach has a downside though as the proxy class might get
- collected before the native method has completed. You might notice
- above that there is an additional parameters with a underscore postfix,
- eg <TT>jarg1_</TT>. These are added in order to prevent <A href="#Java_pgcpp">
-premature garbage collection when marshalling proxy classes</A>.</P>
-<P> The functions in the intermediary JNI class cannot be accessed
- outside of its package. Access to them is gained through the module
- class for globals otherwise the appropriate proxy class.</P>
- <A name="Java_module_directive"></A>
-<P> The name of the intermediary JNI class can be changed from its
- default, that is, the module name with JNI appended after it. The
- module directive attribute <TT>jniclassname</TT> is used to achieve
- this:</P>
+<P> The enum items appear first. Like the typesafe enum pattern, the
+ constructors are private. The constructors are required to handle C/C++
+ enums with initializers. The <TT>next</TT> variable is in the <TT>
+SwigNext</TT> inner class rather than in the enum class as static
+ primitive variables cannot be modified from within enum constructors.
+ Marshalling between Java enums and the C/C++ enum integer value is
+ handled via the <TT>swigToEnum</TT> and <TT>swigValue</TT> methods. All
+ the constructors and methods in the Java enum are required just to
+ handle C/C++ enums with initializers. These needn't be generated if the
+ enum being wrapped does not have any initializers and the <A href="#Java_simpler_enum_classes">
+Simpler Java enums for enums without initializers</A> section describes
+ how typemaps can be used to achieve this.</P>
+<H4><A name="Java_typeunsafe_enums_classes">25.4.5.3 Type unsafe enum
+ classes</A></H4>
+<P> The following example demonstrates type unsafe enums:</P>
+<DIV class="code">
+<PRE>
+%include "enumtypeunsafe.swg"
+%javaconst(1);
+enum Beverage { ALE, LAGER=10, STOUT, PILSNER, PILZ=PILSNER };
+</PRE>
+</DIV>
+<P> SWIG will generate the following simple class:</P>
<DIV class="code">
<PRE>
-%module (jniclassname="name") modulename
+public final class Beverage {
+ public final static int ALE = 0;
+ public final static int LAGER = 10;
+ public final static int STOUT = LAGER + 1;
+ public final static int PILSNER = STOUT + 1;
+ public final static int PILZ = PILSNER;
+}
</PRE>
</DIV>
-<P> If <TT>name</TT> is the same as <TT>modulename</TT> then the module
- class name gets changed from <TT>modulename</TT> to <TT>
-modulenameModule</TT>.</P>
-<H4><A name="Java_imclass_pragmas"></A>24.4.1.1 The intermediary JNI
- class pragmas</H4>
-<P> The intermediary JNI class can be tailored through the use of
- pragmas, but is not commonly done. The pragmas for this class are:</P>
-<TABLE BORDER summary="Intermediary JNI class pragmas">
-<TR VALIGN="TOP"><TD><B>Pragma</B></TD><TD><B>Description</B></TD></TR>
-<TR><TD>jniclassbase</TD><TD>Base class for the intermediary JNI class</TD>
+<H3><A name="Java_interfaces">25.4.6 Interfaces</A></H3>
+<P> By default SWIG wraps all C++ classes as Java classes. As Java only
+ supports derivation from a single base class, SWIG has to ignore all
+ bases except the first when a C++ class inherits from more than one
+ base class. However, there is a family of SWIG macros that change the
+ default wrapping and allows a C++ class to be wrapped as a Java
+ interface instead of a Java class. These macros provide a way to
+ support some sort of multiple inheritance as there is no limit to the
+ number of interfaces that a Java class can inherit from.</P>
+<P> When a C++ class is wrapped as a Java interface, a Java proxy class
+ is still needed. The <TT>swiginterface.i</TT> library file provides
+ three macros for marking a C++ class to be wrapped as a Java interface.
+ There is more than one macro in order to provide a choice for choosing
+ the Java interface and Java proxy names.</P>
+<TABLE BORDER summary="Java interface macros">
+<TR VALIGN="TOP"><TD><B>Interface Macro Name</B></TD><TD><B>Description</B>
+</TD></TR>
+<TR><TD><TT>%interface(CTYPE)</TT></TD><TD>Proxy class name is
+ unchanged, interface name has <TT>SwigInterface</TT> added as a suffix
+ for C++ class <TT>CTYPE</TT>.</TD></TR>
+<TR><TD><TT>%interface_impl(CTYPE)</TT></TD><TD>Proxy class name has <TT>
+SwigImpl</TT> as a suffix, interface name has <TT>SwigInterface</TT>
+ added as a suffix for C++ class <TT>CTYPE</TT>.</TD></TR>
+<TR><TD><TT>%interface_custom("PROXY", "INTERFACE", CTYPE)</TT></TD><TD>
+Proxy class name is given by the string <TT>PROXY</TT>, interface name
+ is given by the string <TT>INTERFACE</TT> for C++ class <TT>CTYPE</TT>.
+ The <TT>PROXY</TT> and <TT>INTERFACE</TT> names can use the <A href="#SWIG_advanced_renaming">
+string formatting functions</A> used in <TT>%rename</TT>.</TD></TR>
+</TABLE>
+<P> The table below has a few examples showing the resulting proxy and
+ interface names.</P>
+<TABLE BORDER summary="Java interface macro examples">
+<TR VALIGN="TOP"><TD><B>Example Usage</B></TD><TD><B>Proxy Class Name</B>
+</TD><TD><B>Interface Class Name</B></TD></TR>
+<TR><TD><TT>%interface(Base)</TT></TD><TD><TT>Base</TT></TD><TD><TT>
+BaseSwigInterface</TT></TD></TR>
+<TR><TD><TT>%interface_impl(Base)</TT></TD><TD><TT>BaseSwigImpl</TT></TD><TD>
+<TT>Base</TT></TD></TR>
+<TR><TD><TT>%interface_custom("BaseProxy", "IBase", Base)</TT></TD><TD><TT>
+BaseProxy</TT></TD><TD><TT>IBase</TT></TD></TR>
+<TR><TD><TT>%interface_custom("%sProxy", "IBase", Base)</TT></TD><TD><TT>
+BaseProxy</TT></TD><TD><TT>IBase</TT></TD></TR>
+<TR><TD><TT>%interface_custom("%sProxy", "%sInterface", Base)</TT></TD><TD>
+<TT>BaseProxy</TT></TD><TD><TT>BaseProxyInterface</TT></TD></TR>
+<TR><TD><TT>%interface_custom("%sProxy", "%(rstrip:[Proxy])sInterface",
+ Base)</TT></TD><TD><TT>BaseProxy</TT></TD><TD><TT>BaseInterface</TT></TD>
</TR>
-<TR><TD>jniclasspackage</TD><TD>Package in which to place the
- intermediary JNI class</TD></TR>
-<TR><TD>jniclassclassmodifiers</TD><TD>Class modifiers and class type
- for the intermediary JNI class</TD></TR>
-<TR><TD>jniclasscode</TD><TD>Java code is copied verbatim into the
- intermediary JNI class</TD></TR>
-<TR><TD>jniclassimports</TD><TD>Java code, usually one or more import
- statements, placed before the intermediary JNI class definition</TD></TR>
-<TR><TD>jniclassinterfaces</TD><TD>Comma separated interface classes for
- the intermediary JNI class</TD></TR>
</TABLE>
-<P> The pragma code appears in the generated intermediary JNI class
- where you would expect:</P>
+<P> The 2nd last example shows the names used in the string formatting
+ functions. The input for <TT>PROXY</TT> that <TT>"%s"</TT> expands to
+ is the proxy name, that is, Base. The input for <TT>INTERFACE</TT> that
+ <TT>"%s"</TT> expands to is the proxy name, that is, <TT>BaseProxy</TT>
+.</P>
+<P> The last example shows <TT>rstrip</TT> and in this case strips the <TT>
+Proxy</TT> suffix and then adds on <TT>Interface</TT>.</P>
+<P> Consider the following C++ code:</P>
<DIV class="code">
<PRE>
-[ jniclassimports pragma ]
-[ jniclassclassmodifiers pragma ] jniclassname extends [ jniclassbase pragma ]
- implements [ jniclassinterfaces pragma ] {
-[ jniclasscode pragma ]
-... SWIG generated native methods ...
+namespace Space {
+ struct Base1 {
+ virtual void Method1();
+ };
+ struct Base2 {
+ virtual void Method2();
+ };
+ struct Derived : Base1, Base2 {
+ };
+ void UseBases(const Base1 &b1, const Base2 &b2);
}
</PRE>
</DIV>
-<P> The <TT>jniclasscode</TT> pragma is quite useful for adding in a
- static block for loading the shared library / dynamic link library and
- demonstrates how pragmas work:</P>
-<DIV class="code">
+<P> By default all classes are wrapped and are available in Java, but, <TT>
+Derived</TT> has all bases ignored except the first. SWIG generates a
+ warning for the above code:</P>
+<DIV class="shell">
<PRE>
-%pragma(java) jniclasscode=%{
- static {
- try {
- System.loadLibrary("example");
- } catch (UnsatisfiedLinkError e) {
- System.err.println("Native code library failed to load. \n" + e);
- System.exit(1);
- }
- }
-%}
+example.i:10: Warning 813: Warning for Derived, base Base2 ignored.
+Multiple inheritance is not supported in Java.
</PRE>
</DIV>
-<P> Pragmas will take either <TT>""</TT> or <TT>%{ %}</TT> as
- delimiters. For example, let's change the intermediary JNI class access
- to just the default package-private access.</P>
+<P> If we decide to wrap the two base classes as interfaces and add the
+ following before SWIG parses the above example code:</P>
<DIV class="code">
<PRE>
-%pragma(java) jniclassclassmodifiers="class"
+%include <swiginterface.i>
+%interface_impl(Space::Base1);
+%interface_impl(Space::Base2);
</PRE>
</DIV>
-<P> All the methods in the intermediary JNI class will then not be
- callable outside of the package as the method modifiers have been
- changed from public access to default access. This is useful if you
- want to prevent users calling these low level functions.</P>
-<H3><A name="Java_module_class"></A>24.4.2 The Java module class</H3>
-<P> All global functions and variable getters/setters appear in the
- module class. For our example, there is just one function:</P>
+<P> then two interface files are generated, Base1.java and Base2.java in
+ addition to proxy class files, Base1SwigImpl.java and
+ Base2SwigImpl.java. The contents of interface file Base1.java for <TT>
+Base1</TT> is shown below:</P>
<DIV class="code">
<PRE>
-public class example {
- public static void egg(Foo chips) {
- exampleJNI.egg(Foo.getCPtr(chips), chips);
- }
+public interface Base1 {
+ long Base1_GetInterfaceCPtr();
+ void Method1();
}
</PRE>
</DIV>
-<P> The module class is necessary as there is no such thing as a global
- in Java so all the C globals are put into this class. They are
- generated as static functions and so must be accessed as such by using
- the module name in the static function call:</P>
-<DIV class="code">
-<PRE>
-example.egg(new Foo());
-</PRE>
-</DIV>
-<P> The primary reason for having the module class wrapping the calls in
- the intermediary JNI class is to implement static type checking. In
- this case only a <TT>Foo</TT> can be passed to the <TT>egg</TT>
- function, whereas any <TT>long</TT> can be passed to the <TT>egg</TT>
- function in the intermediary JNI class.</P>
-<H4><A name="Java_module_class_pragmas"></A>24.4.2.1 The Java module
- class pragmas</H4>
-<P> The module class can be tailored through the use of pragmas, in the
- same manner as the intermediary JNI class. The pragmas are similarly
- named and are used in the same way. The complete list follows:</P>
-<TABLE BORDER summary="Java module class pragmas">
-<TR VALIGN="TOP"><TD><B>Pragma</B></TD><TD><B>Description</B></TD></TR>
-<TR><TD>modulebase</TD><TD>Base class for the module class</TD></TR>
-<TR><TD>moduleclassmodifiers</TD><TD>Class modifiers and class type for
- the module class</TD></TR>
-<TR><TD>modulecode</TD><TD>Java code is copied verbatim into the module
- class</TD></TR>
-<TR><TD>moduleimports</TD><TD>Java code, usually one or more import
- statements, placed before the module class definition</TD></TR>
-<TR><TD>moduleinterfaces</TD><TD>Comma separated interface classes for
- the module class</TD></TR>
-</TABLE>
-<P> The pragma code appears in the generated module class like this:</P>
+<P> The proxy class in Base1SwigImpl.java for Base1 is as it would have
+ been if <TT>%interface</TT> was not used, except the name has changed
+ to <TT>Base1SwigImpl</TT> and it implements the appropriate base:</P>
<DIV class="code">
<PRE>
-[ moduleimports pragma ]
-[ modulemodifiers pragma ] modulename extends [ modulebase pragma ]
- implements [ moduleinterfaces pragma ] {
-[ modulecode pragma ]
-... SWIG generated wrapper functions ...
+public class Base1SwigImpl implements Base1 {
+...
+ public long Base1_GetInterfaceCPtr() {
+ return exampleJNI.Base1SwigImpl_Base1_GetInterfaceCPtr(swigCPtr);
+ }
+
+ public void Method1() {
+ exampleJNI.Base1SwigImpl_Method1(swigCPtr, this);
+ }
+...
}
</PRE>
</DIV>
-<P> See <A href="#Java_imclass_pragmas">The intermediary JNI class
- pragmas</A> section for further details on using pragmas.</P>
-<H3><A name="Java_proxy_classes"></A>24.4.3 Java proxy classes</H3>
-<P> A Java proxy class is generated for each structure, union or C++
- class that is wrapped. Proxy classes have also been called <A href="http://java.sun.com/docs/books/jni/html/stubs.html">
-peer classes</A>. The default proxy class for our previous example looks
- like this:</P>
+<P> In fact any class deriving from <TT>Base</TT> will now implement the
+ interface instead of deriving from it (or ignoring the base in the case
+ of multiple base classes). Hence the <TT>Derived</TT> proxy class will
+ now implement both bases:</P>
<DIV class="code">
<PRE>
-public class Foo {
- private long swigCPtr;
- protected boolean swigCMemOwn;
-
- protected Foo(long cPtr, boolean cMemoryOwn) {
- swigCMemOwn = cMemoryOwn;
- swigCPtr = cPtr;
+public class Derived implements Base1, Base2 {
+...
+ public long Base1_GetInterfaceCPtr() {
+ return exampleJNI.Derived_Base1_GetInterfaceCPtr(swigCPtr);
}
- protected static long getCPtr(Foo obj) {
- return (obj == null) ? 0 : obj.swigCPtr;
+ public long Base2_GetInterfaceCPtr() {
+ return exampleJNI.Derived_Base2_GetInterfaceCPtr(swigCPtr);
}
- protected void finalize() {
- delete();
+ public void Method1() {
+ exampleJNI.Derived_Method1(swigCPtr, this);
}
- public synchronized void delete() {
- if(swigCPtr != 0 && swigCMemOwn) {
- swigCMemOwn = false;
- exampleJNI.delete_Foo(swigCPtr);
- }
- swigCPtr = 0;
+ public void Method2() {
+ exampleJNI.Derived_Method2(swigCPtr, this);
}
-
- public void setX(int value) {
- exampleJNI.Foo_x_set(swigCPtr, this, value);
+...
+}
+</PRE>
+</DIV>
+<P> Wherever a class marked as an interface is used, such as the <TT>
+UseBases</TT> method in the example, the interface name is used as the
+ type in the Java layer:</P>
+<DIV class="code">
+<PRE>
+ public static void UseBases(Base1 b1, Base2 b2) {
+ exampleJNI.UseBases(b1.Base1_GetInterfaceCPtr(), b1, b2.Base2_GetInterfaceCPtr(), b2);
}
+</PRE>
+</DIV>
+<P> Note that each Java interface has a method added to obtain the
+ correct C++ pointer for passing to the native function - <TT>
+Base1_GetInterfaceCPtr</TT> for <TT>Base1</TT>. This method is similar
+ to the <TT>getCPtr</TT> method in the proxy classes. In fact, as shown
+ above in the <TT>Derived</TT> class, the proxy classes implement this
+ generated interface by calling a native method (<TT>
+Derived_Base1_GetInterfaceCPtr</TT>) which calls an appropriate C++ cast
+ of the pointer up the inheritance chain.</P>
+<P> The interface macros are implemented using the <TT>interface</TT>
+ feature and typemaps. For example:</P>
+<DIV class="code">
+<PRE>
+%define %interface(CTYPE...)
+%feature("interface", name="%sSwigInterface") CTYPE;
+INTERFACE_TYPEMAPS(CTYPE)
+%enddef
+</PRE>
+</DIV>
+<P> The feature accepts one attribute called <TT>name</TT>, which is the
+ name of the Java interface mentioned earlier. The <TT>
+INTERFACE_TYPEMAPS</TT> macro implements the typemaps and can be viewed
+ in the <TT>swiginterface.i</TT> file and contain the usual Java
+ typemaps for generating code plus the <TT>javainterfacecode</TT>
+ typemap which is only used when a class is marked with the <TT>
+interface</TT> feature. See <A href="#Java_code_typemaps">Java code
+ typemaps</A> for details.</P>
+<H2><A name="Java_directors">25.5 Cross language polymorphism using
+ directors</A></H2>
+<P> Proxy classes provide a natural, object-oriented way to wrap C++
+ classes. as described earlier, each proxy instance has an associated
+ C++ instance, and method calls from Java to the proxy are passed to the
+ C++ instance transparently via C wrapper functions.</P>
+<P> This arrangement is asymmetric in the sense that no corresponding
+ mechanism exists to pass method calls down the inheritance chain from
+ C++ to Java. In particular, if a C++ class has been extended in Java
+ (by deriving from the proxy class), these classes will not be visible
+ from C++ code. Virtual method calls from C++ are thus not able to
+ access the lowest implementation in the inheritance chain.</P>
+<P> SWIG can address this problem and make the relationship between C++
+ classes and proxy classes more symmetric. To achieve this goal, new
+ classes called directors are introduced at the bottom of the C++
+ inheritance chain. The job of the directors is to route method calls
+ correctly, either to C++ implementations higher in the inheritance
+ chain or to Java implementations lower in the inheritance chain. The
+ upshot is that C++ classes can be extended in Java and from C++ these
+ extensions look exactly like native C++ classes. Neither C++ code nor
+ Java code needs to know where a particular method is implemented: the
+ combination of proxy classes, director classes, and C wrapper functions
+ transparently takes care of all the cross-language method routing.</P>
+<H3><A name="Java_enabling_directors">25.5.1 Enabling directors</A></H3>
+<P> The director feature is disabled by default. To use directors you
+ must make two changes to the interface file. First, add the "directors"
+ option to the %module directive, like this:</P>
+<DIV class="code">
+<PRE>
+%module(directors="1") modulename
+</PRE>
+</DIV>
+<P> Without this option no director code will be generated. Second, you
+ must use the %feature("director") directive to tell SWIG which classes
+ and methods should get directors. The %feature directive can be applied
+ globally, to specific classes, and to specific methods, like this:</P>
+<DIV class="code">
+<PRE>
+// generate directors for all classes that have virtual methods
+%feature("director");
- public int getX() {
- return exampleJNI.Foo_x_get(swigCPtr, this);
- }
+// generate directors for all virtual methods in class Foo
+%feature("director") Foo;
+</PRE>
+</DIV>
+<P> You can use the %feature("nodirector") directive to turn off
+ directors for specific classes or methods. So for example,</P>
+<DIV class="code">
+<PRE>
+%feature("director") Foo;
+%feature("nodirector") Foo::bar;
+</PRE>
+</DIV>
+<P> will generate directors for all virtual methods of class Foo except
+ bar().</P>
+<P> Directors can also be generated implicitly through inheritance. In
+ the following, class Bar will get a director class that handles the
+ methods one() and two() (but not three()):</P>
+<DIV class="code">
+<PRE>
+%feature("director") Foo;
+class Foo {
+public:
+ virtual void one();
+ virtual void two();
+};
- public int spam(int num, Foo foo) {
- return exampleJNI.Foo_spam(swigCPtr, this, num, Foo.getCPtr(foo), foo);
- }
+class Bar: public Foo {
+public:
+ virtual void three();
+};
+</PRE>
+</DIV>
+<H3><A name="Java_directors_classes">25.5.2 Director classes</A></H3>
+<P> For each class that has directors enabled, SWIG generates a new
+ class that derives from both the class in question and a special <TT>
+Swig::Director</TT> class. These new classes, referred to as director
+ classes, can be loosely thought of as the C++ equivalent of the Java
+ proxy classes. The director classes store a pointer to their underlying
+ Java proxy classes.</P>
+<P> For simplicity let's ignore the <TT>Swig::Director</TT> class and
+ refer to the original C++ class as the director's base class. By
+ default, a director class extends all virtual methods in the
+ inheritance chain of its base class (see the preceding section for how
+ to modify this behavior). Thus all virtual method calls, whether they
+ originate in C++ or in Java via proxy classes, eventually end up in at
+ the implementation in the director class. The job of the director
+ methods is to route these method calls to the appropriate place in the
+ inheritance chain. By "appropriate place" we mean the method that would
+ have been called if the C++ base class and its Java derived classes
+ were seamlessly integrated. That seamless integration is exactly what
+ the director classes provide, transparently skipping over all the messy
+ JNI glue code that binds the two languages together.</P>
+<P> In reality, the "appropriate place" is one of only two
+ possibilities: C++ or Java. Once this decision is made, the rest is
+ fairly easy. If the correct implementation is in C++, then the lowest
+ implementation of the method in the C++ inheritance chain is called
+ explicitly. If the correct implementation is in Java, the Java API is
+ used to call the method of the underlying Java object (after which the
+ usual virtual method resolution in Java automatically finds the right
+ implementation).</P>
+<H3><A name="Java_directors_overhead">25.5.3 Overhead and code bloat</A></H3>
+<P> Enabling directors for a class will generate a new director method
+ for every virtual method in the class' inheritance chain. This alone
+ can generate a lot of code bloat for large hierarchies. Method
+ arguments that require complex conversions to and from Java types can
+ result in large director methods. For this reason it is recommended
+ that directors are selectively enabled only for specific classes that
+ are likely to be extended in Java and used in C++.</P>
+<P> Although directors make it natural to mix native C++ objects with
+ Java objects (as director objects), one should be aware of the obvious
+ fact that method calls to Java objects from C++ will be much slower
+ than calls to C++ objects. Additionally, compared to classes that do
+ not use directors, the call routing in the director methods adds a
+ small overhead. This situation can be optimized by selectively enabling
+ director methods (using the %feature directive) for only those methods
+ that are likely to be extended in Java.</P>
+<H3><A name="Java_directors_example">25.5.4 Simple directors example</A></H3>
+<P> Consider the following SWIG interface file:</P>
+<DIV class="code">
+<PRE>
+%module(directors="1") example;
- public Foo() {
- this(exampleJNI.new_Foo(), true);
+%feature("director") DirectorBase;
+
+class DirectorBase {
+public:
+ virtual ~DirectorBase() {}
+ virtual void upcall_method() {}
+};
+
+void callup(DirectorBase *director) {
+ director->upcall_method();
+}
+</PRE>
+</DIV>
+<P> The following <CODE>DirectorDerived</CODE> Java class is derived
+ from the Java proxy class <CODE>DirectorBase</CODE> and overrides <CODE>
+upcall_method()</CODE>. When C++ code invokes <CODE>upcall_method()</CODE>
+, the SWIG-generated C++ code redirects the call via JNI to the Java <CODE>
+DirectorDerived</CODE> subclass. Naturally, the SWIG generated C++ code
+ and the generated Java intermediary class marshal and convert arguments
+ between C++ and Java when needed.</P>
+<DIV class="code">
+<PRE>
+public class DirectorDerived extends DirectorBase {
+ public DirectorDerived() {
}
+ public void upcall_method() {
+ System.out.println("DirectorDerived::upcall_method() invoked.");
+ }
}
</PRE>
</DIV>
-<P> This class merely holds a pointer to the underlying C++ object (<TT>
-swigCPtr</TT>). It also contains all the methods in the C++ class it is
- proxying plus getters and setters for public member variables. These
- functions call the native methods in the intermediary JNI class. The
- advantage of having this extra layer is the type safety that the proxy
- class functions offer. It adds static type checking which leads to
- fewer surprises at runtime. For example, you can see that if you
- attempt to use the <TT>spam()</TT> function it will only compile when
- the parameters passed are an <TT>int</TT> and a <TT>Foo</TT>. From a
- user's point of view, it makes the class work as if it were a Java
- class:</P>
+<P> Running the following Java code</P>
<DIV class="code">
<PRE>
-Foo f = new Foo();
-f.setX(3);
-int y = f.spam(5, new Foo());
+DirectorDerived director = new DirectorDerived();
+example.callup(director);
</PRE>
</DIV>
-<H4><A name="Java_memory_management"></A>24.4.3.1 Memory management</H4>
-<P> Each proxy class has an ownership flag <TT>swigCMemOwn</TT>. The
- value of this flag determines who is responsible for deleting the
- underlying C++ object. If set to <TT>true</TT>, the proxy class's
- finalizer will destroy the C++ object when the proxy class is garbage
- collected. If set to false, then the destruction of the proxy class has
- no effect on the C++ object.</P>
-<P> When an object is created by a constructor or returned by value,
- Java automatically takes ownership of the result. On the other hand,
- when pointers or references are returned to Java, there is often no way
- to know where they came from. Therefore, the ownership is set to false.
- For example:</P>
+<P> will result in the following being output:</P>
<DIV class="code">
<PRE>
-class Foo {
-public:
- Foo();
- Foo bar1();
- Foo &bar2();
- Foo *bar2();
-};
+DirectorDerived::upcall_method() invoked.
</PRE>
</DIV>
-<P> In Java:</P>
+<H3><A name="Java_directors_threading">25.5.5 Director threading issues</A>
+</H3>
+<P> Depending on your operating system and version of Java and how you
+ are using threads, you might find the JVM hangs on exit. There are a
+ couple of solutions to try out. The preferred solution requires jdk-1.4
+ and later and uses <TT>AttachCurrentThreadAsDaemon</TT> instead of <TT>
+AttachCurrentThread</TT> whenever a call into the JVM is required. This
+ can be enabled by defining the
+ SWIG_JAVA_ATTACH_CURRENT_THREAD_AS_DAEMON macro when compiling the C++
+ wrapper code. For older JVMs define SWIG_JAVA_NO_DETACH_CURRENT_THREAD
+ instead, to avoid the <TT>DetachCurrentThread</TT> call but this will
+ result in a memory leak instead. For further details inspect the source
+ code in the java/director.swg library file.</P>
+<P> Macros can be defined on the commandline when compiling your C++
+ code, or alternatively added to the C++ wrapper file as shown below:</P>
<DIV class="code">
<PRE>
-Foo f = new Foo(); // f.swigCMemOwn = true
-Foo f1 = f.bar1(); // f1.swigCMemOwn = true
-Foo f2 = f.bar2(); // f2.swigCMemOwn = false
-Foo f3 = f.bar3(); // f3.swigCMemOwn = false
+%insert("runtime") %{
+#define SWIG_JAVA_NO_DETACH_CURRENT_THREAD
+%}
</PRE>
</DIV>
-<P> This behavior for pointers and references is especially important
- for classes that act as containers. For example, if a method returns a
- pointer to an object that is contained inside another object, you
- definitely don't want Java to assume ownership and destroy it!</P>
-<P> For the most part, memory management issues remain hidden. However,
- there are situations where you might have to manually change the
- ownership of an object. For instance, consider code like this:</P>
+<H3><A name="Java_directors_performance">25.5.6 Director performance
+ tuning</A></H3>
+<P> When a new instance of a director (or subclass) is created in Java,
+ the C++ side of the director performs a runtime check per director
+ method to determine if that particular method is overridden in Java or
+ if it should invoke the C++ base implementation directly. Although this
+ makes initialization slightly more expensive, it is generally a good
+ overall tradeoff.</P>
+<P> However, if all director methods are expected to usually be
+ overridden by Java subclasses, then initialization can be made faster
+ by avoiding these checks via the <TT>assumeoverride</TT> attribute. For
+ example:</P>
<DIV class="code">
<PRE>
-class Obj {};
-class Node {
- Obj *value;
-public:
- void set_value(Obj *v) { value = v; }
-};
+%feature("director", assumeoverride=1) Foo;
</PRE>
</DIV>
-<P> Now, consider the following Java code:</P>
+<P> The disadvantage is that invocation of director methods from C++
+ when Java doesn't actually override the method will require an
+ additional call up into Java and back to C++. As such, this option is
+ only useful when overrides are extremely common and instantiation is
+ frequent enough that its performance is critical.</P>
+<H3><A name="Java_exceptions_from_directors">25.5.7 Java exceptions from
+ directors</A></H3>
+<P> With directors routing method calls to Java, and proxies routing
+ them to C++, the handling of exceptions is an important concern. The
+ default behavior from SWIG 3.0 onwards is to convert the thrown Java
+ exception into a SWIG defined <CODE>DirectorException</CODE> C++
+ exception. SWIG 2.0 and earlier versions didn't provide any mechanism
+ to handle the Java director method exceptions in C++.</P>
+<P> Converting Java exceptions into C++ exceptions can be done in two
+ different ways using the <CODE>director:except</CODE> <A href="#Customization_features">
+feature</A>. In the simplest approach, a code block is attached to each
+ director method to handle the mapping of Java exceptions into C++
+ exceptions.</P>
<DIV class="code">
<PRE>
-Node n = new Node(); // Create a node
-{
- Obj o = new Obj(); // Create an object
- n.set_value(o); // Set value
-} // o goes out of scope
+%feature("director:except") MyClass::method(int x) {
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ jenv->ExceptionClear();
+ if (Swig::ExceptionMatches(jenv, $error, "java/lang/IndexOutOfBoundsException"))
+ throw std::out_of_range(Swig::JavaExceptionMessage(jenv, $error).message());
+ if (Swig::ExceptionMatches(jenv, $error, "$packagepath/MyJavaException"))
+ throw MyCppException(Swig::JavaExceptionMessage(jenv, $error).message());
+ throw std::runtime_error("Unexpected exception thrown in MyClass::method");
+ }
+}
+
+class MyClass {
+ /** Throws either a std::out_of_range or MyCppException on error */
+ void method(int x);
+}
+</PRE>
+</DIV>
+<P> This approach allows a flexible mapping of Java exceptions thrown by
+ director methods into C++ exceptions expected by a C++ caller. There
+ need not be any C++<EM> exception specifications</EM> on the C++
+ method. The utility function <CODE>Swig::ExceptionMatches</CODE> and
+ class <CODE>Swig::JavaExceptionMessage</CODE> are provided to simplify
+ writing code for wrappers that use the <CODE>director:except</CODE>
+ feature. The function <CODE>Swig::ExceptionMatches</CODE> matches the
+ type of the <CODE>jthrowable</CODE> thrown against a<B> fully qualified</B>
+ JNI style class name, such as <CODE>"java/lang/IOError"</CODE>. If the
+ throwable class is the same type, or derives from the given type, <CODE>
+Swig::ExceptionMatches</CODE> will return true. Care must be taken to
+ provide the correct fully qualified name, since for wrapped exceptions
+ the generated proxy class will have additional package qualification,
+ depending on the '-package' argument and use of the <A href="#Java_namespaces">
+nspace feature</A>. The special variable <CODE>$error</CODE> is expanded
+ by SWIG into a unique variable name and should be used for the
+ assignment of the exception that occurred. The special variable <CODE>
+$packagepath</CODE> is replaced by the outer package provided for SWIG
+ generation by the -package option. The utility class <CODE>
+Swig::JavaExceptionMessage</CODE> is a holder providing access to the
+ message from the thrown Java exception. The <CODE>message()</CODE>
+ method returns the exception message as a <CODE>const char *</CODE>,
+ which is only valid during the lifetime of the holder. Any code using
+ this message needs to copy it, for example into a std::string or a
+ newly constructed C++ exception.</P>
+<P> Using the above approach to write handlers for a large number of
+ methods will require repetitive duplication of the <CODE>
+director:except</CODE> feature code. To mitigate this, an alternative
+ approach is provided via typemaps in a fashion analagous to the <A href="#throws_typemap">
+"throws" typemap.</A> The "throws" typemap provides an approach to
+ automatically map all the C++ exceptions listed in a method's defined
+ exceptions (either from a C++<EM> exception specification</EM> or a <CODE>
+%catches</CODE> feature) into Java exceptions. The "directorthrows"
+ typemap provides the inverse mapping and should contain code to convert
+ a suitably matching Java exception into a C++ exception. The example
+ below converts a Java <CODE>java.lang.IndexOutOfBoundsException</CODE>
+ exception to the typemap's type, that is <CODE>std::out_of_range</CODE>
+:<DIV class="code">
+<PRE>
+%typemap(directorthrows) std::out_of_range %{
+ if (Swig::ExceptionMatches(jenv, $error, "java/lang/IndexOutOfBoundsException")) {
+ throw std::out_of_range(Swig::JavaExceptionMessage(jenv, $error).message());
+ }
+%}
+</PRE>
+</DIV></P>
+<P> The "directorthrows" typemap is then used in conjunction with the <CODE>
+director:except</CODE> feature if the <CODE>$directorthrowshandlers</CODE>
+ special variable is used in the feature code. Consider the following,
+ which also happens to be the default:</P>
+<DIV class="code">
+<PRE>
+%feature("director:except") %{
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ jenv->ExceptionClear();
+ $directorthrowshandlers
+ throw Swig::DirectorException(jenv, $error);
+ }
+%}
</PRE>
</DIV>
-<P> In this case, the Node <TT>n</TT> is holding a reference to <TT>o</TT>
- internally. However, SWIG has no way to know that this has occurred.
- The Java proxy class still thinks that it has ownership of <TT>o</TT>.
- As <TT>o</TT> has gone out of scope, it could be garbage collected in
- which case the C++ destructor will be invoked and <TT>n</TT> will then
- be holding a stale-pointer to <TT>o</TT>. If you're lucky, you will
- only get a segmentation fault.</P>
-<P> To work around this, the ownership flag of <TT>o</TT> needs changing
- to <TT>false</TT>. The ownership flag is a private member variable of
- the proxy class so this is not possible without some customization of
- the proxy class. This can be achieved by using a typemap to customise
- the proxy class with pure Java code as detailed later in the section on
- <A href="#Java_typemaps">Java typemaps</A>.</P>
-<P> Sometimes a function will create memory and return a pointer to a
- newly allocated object. SWIG has no way of knowing this so by default
- the proxy class does not manage the returned object. However, you can
- tell the proxy class to manage the memory if you specify the <TT>
-%newobject</TT> directive. Consider:</P>
+<P>The code generated using the <CODE>director:except</CODE> feature
+ replaces the <CODE>$directorthrowshandlers</CODE> special variable with
+ the code in the "directorthrows" typemaps, for each and every exception
+ defined for the method. The possible exceptions can be defined either
+ with a C++ exception specification or <CODE>%catches</CODE> as
+ described for the <A href="#throws_typemap">"throws" typemap</A>.</P>
+<P> Consider the following director method:</P>
<DIV class="code">
<PRE>
-class Obj {...};
-class Factory {
-public:
- static Obj *createObj() { return new Obj(); }
-};
+ ...
+ virtual void doSomething(int index) throw (std::out_of_range);
+ ...
</PRE>
</DIV>
-<P> If we call the factory function, then we have to manually delete the
- memory:</P>
+<P> When combined with the default <CODE>director:except</CODE> feature
+ and the "directorthrows" typemap above, the resulting code generated in
+ the director method after calling up to Java will be:</P>
<DIV class="code">
<PRE>
-Obj obj = Factory.createObj(); // obj.swigCMemOwn = false
-...
-obj.delete();
+jthrowable swigerror = jenv->ExceptionOccurred();
+if (swigerror) {
+ jenv->ExceptionClear();
+ if (Swig::ExceptionMatches(jenv, swigerror, "java/lang/IndexOutOfBoundsException")) {
+ throw std::out_of_range(Swig::JavaExceptionMessage(jenv, swigerror).message());
+ }
+
+ throw Swig::DirectorException(jenv, swigerror);
+}
</PRE>
</DIV>
-<P> Now add in the %newobject directive:</P>
+<P><EM> Note: Beware of using exception specifications as the SWIG
+ director methods will be generated with the same exception
+ specifications and if the director method throws an exception that is
+ not specified it is likely to terminate your program. See the C++
+ standard for more details. Using the %catches feature instead to define
+ the handled exceptions does not suffer this potential fate.</EM></P>
+<P>Because the default code generation maps any unhandled Java
+ exceptions to <CODE>Swig::DirectorException</CODE>, any director
+ methods that have exception specifications may cause program
+ termination. To simply ignore unexpected exceptions, the default
+ handling can be changed with:</P>
<DIV class="code">
<PRE>
-%newobject Factory::createObj();
-
-class Obj {...};
-class Factory {
-public:
- static Obj *createObj() { return new Obj(); }
-};
+%feature("director:except") %{
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ jenv->ExceptionClear();
+ $directorthrowshandlers
+ return $null; // exception is ignored
+ }
+%}
</PRE>
</DIV>
-<P> A call to <TT>delete()</TT> is no longer necessary as the garbage
- collector will make the C++ destructor call because <TT>swigCMemOwn</TT>
- is now true.</P>
+<P>Alternatively an exception compatible with the existing director
+ method exception specifications can be thrown. Assuming that all
+ methods allow std::runtime_error to be thrown, the <CODE>return $null;</CODE>
+ could be changed to:</P>
<DIV class="code">
<PRE>
-Obj obj = Factory.createObj(); // obj.swigCMemOwn = true;
-...
+ throw std::runtime_error(Swig::JavaExceptionMessage(jenv, $error).message());
</PRE>
</DIV>
-<P> Some memory management issues are quite tricky to fix and may only
- be noticeable after using for a long time. One such issue is premature
- garbage collection of an object created from Java and resultant usage
- from C++ code. The section on typemap examples cover two such
- scenarios, <A href="#Java_memory_management_objects">Memory management
- for objects passed to the C++ layer</A> and <A href="#Java_memory_management_member_variables">
-Memory management when returning references to member variables</A></P>
-<H4><A name="Java_inheritance_mirroring"></A>24.4.3.2 Inheritance</H4>
-<P> Java proxy classes will mirror C++ inheritance chains. For example,
- given the base class <TT>Base</TT> and its derived class <TT>Derived</TT>
-:</P>
+<P>In more complex situations, a separate <CODE>director:except</CODE>
+ feature may need to be attached to specific methods.</P>
+<P>Below is a complete example demonstrating the use of the
+ "directorthrows" typemaps. In this example, a generic "directorthrows"
+ typemap is appropriate for all three exceptions - all take single
+ string constructors. If the exceptions had different constructors, it
+ would be necessary to have separate typemaps for each exception type.
+<!-- All the DEFINE_ and DECLARE_EXCEPTIONS CAN BE OMITTED to make
+ this more succinct. They are included to make this a complete
+ example interface that could be generated and built. -->
<DIV class="code">
<PRE>
-class Base {
-public:
- virtual double foo();
-};
+%module(directors="1") example
-class Derived : public Base {
-public:
- virtual double foo();
-};
+%{
+ #include <string>
+ #include <stdexcept>
+%}
+
+// Define exceptions in header section using std::runtime_error
+%define DEFINE_EXCEPTION(NAME)
+%{
+ namespace MyNS {
+ struct NAME : public std::runtime_error { NAME(const std::string &what) : runtime_error(what) {} };
+ }
+%}
+%enddef
+
+// Expose C++ exceptions as Java Exceptions by changing the Java base class and providing a getMessage()
+%define DECLARE_EXCEPTION(NAME)
+%typemap(javabase) MyNS::NAME "java.lang.Exception";
+%rename(getMessage) MyNS::NAME::what;
+namespace MyNS {
+ struct NAME {
+ NAME(const std::string& what);
+ const char * what();
+ };
+}
+%enddef
+
+DEFINE_EXCEPTION(ExceptionA)
+DEFINE_EXCEPTION(ExceptionB)
+DEFINE_EXCEPTION(Unexpected)
+
+// Mark three methods to map director thrown exceptions.
+%feature("director:except") MyClass::meth1(int);
+%feature("director:except") MyClass::meth2;
+%feature("director:except") meth3;
+
+%typemap(directorthrows) MyNS::ExceptionA, MyNS::ExceptionB, MyNS::Unexpected %{
+ if (Swig::ExceptionMatches(jenv, $error, "$packagepath/$javaclassname"))
+ throw $1_type(Swig::JavaExceptionMessage(jenv, $error).message());
+%}
+
+DECLARE_EXCEPTION(ExceptionA)
+DECLARE_EXCEPTION(ExceptionB)
+DECLARE_EXCEPTION(Unexpected)
+
+%catches(MyNS::ExceptionA, MyNS::ExceptionB, MyNS::Unexpected) MyClass::meth2();
+
+%inline {
+ class MyClass {
+ public:
+ virtual void meth1(int x) throw(MyNS::ExceptionA, MyNS::ExceptionB) = 0;
+ virtual void meth2() = 0; /* throws MyNS::ExceptionA, MyNS::ExceptionB, MyNS::Unexpected */
+ virtual void meth3(float x) throw(MyNS::Unexpected) = 0;
+ virtual ~MyClass() {}
+ };
+}
+</PRE>
+</DIV></P>
+<P> In this case the three different "directorthrows" typemaps will be
+ used to generate the three different exception handlers for <CODE>meth1</CODE>
+, <CODE>meth2</CODE> and <CODE>meth3</CODE>. The generated handlers will
+ have "if" blocks for each exception type specified, in the exception
+ specification or <CODE>%catches</CODE> feature.</P>
+<P>Note that the "directorthrows" typemaps are important only if it is
+ important for the the exceptions passed through the C++ layer to be
+ mapped to distinct C++ exceptions. If director methods are being called
+ by C++ code that is itself wrapped in a SWIG generated Java wrapper and
+ access is always through this wrapper, the default <CODE>
+Swig::DirectorException</CODE> class provides enough information to
+ reconstruct the original exception. In this case removing the <CODE>
+$directorthrowshandlers</CODE> special variable from the default <CODE>
+director:except</CODE> feature and simply always throwing a <CODE>
+Swig::DirectorException</CODE> will achieve the desired result. Along
+ with this a generic exception feature is added to convert any caught <CODE>
+Swig::DirectorException</CODE>s back into the underlying Java exceptions
+ via the <CODE>Swig::DirectorException::raiseJavaException</CODE>
+ method, as demonstrated with <CODE>%javaexception</CODE> below:</P>
+<DIV class="code">
+<PRE>
+%javaexception("Exception") MyClass::myMethod %{
+ try {
+ $action
+ } catch (Swig::DirectorException &e) {
+ // raise/throw the Java exception that originally caused the DirectorException
+ e.raiseJavaException(jenv);
+ return $null;
+ }
+%}
+</PRE>
+</DIV>
+<P> See the <A href="#Java_exception_handling">Exception handling with
+ %exception and %javaexception</A> section for more on converting C++
+ exceptions to Java exceptions.</P>
+<H2><A name="Java_allprotected">25.6 Accessing protected members</A></H2>
+<P> When using directors, the protected virtual methods are also
+ wrapped. These methods are wrapped with a protected Java proxy method,
+ so the only way that Java code can access these is from within a Java
+ class derived from the director class.</P>
+<P> Members which are protected and non-virtual can also be accessed
+ when using the 'allprotected' mode. The allprotected mode requires
+ directors and is turned on by setting the <TT>allprotected</TT> option
+ in addition to the <TT>directors</TT> option in the %module directive,
+ like this:</P>
+<DIV class="code">
+<PRE>
+%module(directors="1", allprotected="1") modulename
</PRE>
</DIV>
-<P> The base class is generated much like any other proxy class seen so
- far:</P>
+<P> Protected member variables and methods (both static and non-static)
+ will then be wrapped with protected access in the Java proxy class.</P>
+<P><B> Note:</B> Neither the directors option nor the allprotected mode
+ support types defined with protected scope. This includes any enums or
+ typedefs declared in the protected section of the C++ class.</P>
+<P> The following simple example is a class with numerous protected
+ members, including the constructor and destructor:</P>
<DIV class="code">
<PRE>
-public class Base {
- private long swigCPtr;
- protected boolean swigCMemOwn;
+%module(directors="1", allprotected="1") example
- protected Base(long cPtr, boolean cMemoryOwn) {
- swigCMemOwn = cMemoryOwn;
- swigCPtr = cPtr;
- }
+%feature("director") ProtectedBase;
- protected static long getCPtr(Base obj) {
- return (obj == null) ? 0 : obj.swigCPtr;
- }
+// Ignore use of unsupported types (those defined in the protected section)
+%ignore ProtectedBase::typedefs;
- protected void finalize() {
- delete();
- }
+%inline %{
- public synchronized void delete() {
- if(swigCPtr != 0 && swigCMemOwn) {
- swigCMemOwn = false;
- exampleJNI.delete_Base(swigCPtr);
- }
- swigCPtr = 0;
- }
+class ProtectedBase {
+protected:
+ ProtectedBase() {}
+ virtual ~ProtectedBase() {}
+ virtual void virtualMethod() const {}
+ void nonStaticMethod(double d) const {}
+ static void staticMethod(int i) {}
+ int instanceMemberVariable;
+ static int staticMemberVariable;
- public double foo() {
- return exampleJNI.Base_foo(swigCPtr, this);
- }
+ // unsupported: types defined with protected access and the methods/variables which use them
+ typedef int IntegerType;
+ IntegerType typedefs(IntegerType it) { return it; }
+};
+int ProtectedBase::staticMemberVariable = 10;
- public Base() {
- this(exampleJNI.new_Base(), true);
- }
+%}
-}
</PRE>
</DIV>
-<P> The <TT>Derived</TT> class extends <TT>Base</TT> mirroring the C++
- class inheritance hierarchy.</P>
+<P> Note that the <TT>IntegerType</TT> has protected scope and the
+ members which use this type must be ignored as they cannot be wrapped.</P>
+<P> The proxy methods are protected, so the only way the protected
+ members can be accessed is within a class that derives from the
+ director class, such as the following:</P>
<DIV class="code">
<PRE>
-public class Derived extends Base {
- private long swigCPtr;
-
- protected Derived(long cPtr, boolean cMemoryOwn) {
- super(exampleJNI.SWIGDerivedUpcast(cPtr), cMemoryOwn);
- swigCPtr = cPtr;
- }
-
- protected static long getCPtr(Derived obj) {
- return (obj == null) ? 0 : obj.swigCPtr;
- }
-
- protected void finalize() {
- delete();
+class MyProtectedBase extends ProtectedBase
+{
+ public MyProtectedBase() {
}
- public synchronized void delete() {
- if(swigCPtr != 0 && swigCMemOwn) {
- swigCMemOwn = false;
- exampleJNI.delete_Derived(swigCPtr);
- }
- swigCPtr = 0;
- super.delete();
- }
+ public void accessProtected() {
+ virtualMethod();
+ nonStaticMethod(1.2);
+ staticMethod(99);
- public double foo() {
- return exampleJNI.Derived_foo(swigCPtr, this);
- }
+ setInstanceMemberVariable(5);
+ int i = getInstanceMemberVariable();
- public Derived() {
- this(exampleJNI.new_Derived(), true);
+ setStaticMemberVariable(10);
+ i = getStaticMemberVariable();
}
-
}
</PRE>
</DIV>
-<P> Note the memory ownership is controlled by the base class. However
- each class in the inheritance hierarchy has its own pointer value which
- is obtained during construction. The <TT>SWIGDerivedUpcast()</TT> call
- converts the pointer from a <TT>Derived *</TT> to a <TT>Base *</TT>.
- This is a necessity as C++ compilers are free to implement pointers in
- the inheritance hierarchy with different values.</P>
-<P> It is of course possible to extend <TT>Base</TT> using your own Java
- classes. If <TT>Derived</TT> is provided by the C++ code, you could for
- example add in a pure Java class <TT>Extended</TT> derived from <TT>
-Base</TT>. There is a caveat and that is any C++ code will not know
- about your pure Java class <TT>Extended</TT> so this type of derivation
- is restricted. However, true cross language polymorphism can be
- achieved using the <A href="#Java_directors">directors</A> feature.</P>
-<H4><A name="Java_proxy_classes_gc"></A>24.4.3.3 Proxy classes and
- garbage collection</H4>
-<P> By default each proxy class has a <TT>delete()</TT> and a <TT>
-finalize()</TT> method. The <TT>finalize()</TT> method calls <TT>
-delete()</TT> which frees any malloc'd memory for wrapped C structs or
- calls the C++ class destructors. The idea is for <TT>delete()</TT> to
- be called when you have finished with the C/C++ object. Ideally you
- need not call <TT>delete()</TT>, but rather leave it to the garbage
- collector to call it from the finalizer. When a program exits, the
- garbage collector does not guarantee to call all finalizers. An insight
- into the reasoning behind this can be obtained from <A href="http://www.hpl.hp.com/techreports/2002/HPL-2002-335.html">
-Hans Boehm's Destructors, Finalizers, and Synchronization</A> paper.
- Depending on what the finalizers do and which operating system you use,
- this may or may not be a problem.</P>
-<P> If the <TT>delete()</TT> call into JNI code is just for memory
- handling, there is not a problem when run on most operating systems,
- for example Windows and Unix. Say your JNI code creates memory on the
- heap which your finalizers should clean up, the finalizers may or may
- not be called before the program exits. In Windows and Unix all memory
- that a process uses is returned to the system on exit, so this isn't a
- problem. This is not the case in some operating systems like vxWorks.
- If however, your finalizer calls into JNI code invoking the C++
- destructor which in turn releases a TCP/IP socket for example, there is
- no guarantee that it will be released. Note that with long running
- programs the garbage collector will eventually run, thereby calling any
- unreferenced object's finalizers.</P>
-<P> Some not so ideal solutions are:</P>
-<OL>
-<LI>
-<P> Call the <TT>System.runFinalizersOnExit(true)</TT> or <TT>
-Runtime.getRuntime().runFinalizersOnExit(true)</TT> to ensure the
- finalizers are called before the program exits. The catch is that this
- is a deprecated function call as the documentation says:</P>
-<DIV class="code"><I> This method is inherently unsafe. It may result in
- finalizers being called on live objects while other threads are
- concurrently manipulating those objects, resulting in erratic behavior
- or deadlock.</I></DIV>
-<P>In many cases you will be lucky and find that it works, but it is not
- to be advocated. Have a look at <A href="http://www.oracle.com/technetwork/java/index.html">
-Java web site</A> and search for <TT>runFinalizersOnExit</TT>.</P>
-</LI>
-<LI>
-<P> From jdk1.3 onwards a new function, <TT>addShutdownHook()</TT>, was
- introduced which is guaranteed to be called when your program exits.
- You can encourage the garbage collector to call the finalizers, for
- example, add this static block to the class that has the <TT>main()</TT>
- function:</P>
+<H2><A name="Java_common_customization">25.7 Common customization
+ features</A></H2>
+<P> An earlier section presented the absolute basics of C/C++ wrapping.
+ If you do nothing but feed SWIG a header file, you will get an
+ interface that mimics the behavior described. However, sometimes this
+ isn't enough to produce a nice module. Certain types of functionality
+ might be missing or the interface to certain functions might be
+ awkward. This section describes some common SWIG features that are used
+ to improve the interface to existing C/C++ code.</P>
+<H3><A name="Java_helper_functions">25.7.1 C/C++ helper functions</A></H3>
+<P> Sometimes when you create a module, it is missing certain bits of
+ functionality. For example, if you had a function like this</P>
<DIV class="code">
<PRE>
- static {
- Runtime.getRuntime().addShutdownHook(
- new Thread() {
- public void run() { System.gc(); System.runFinalization(); }
- }
- );
- }
+typedef struct Image {...};
+void set_transform(Image *im, double m[4][4]);
</PRE>
</DIV>
-<P>Although this usually works, the documentation doesn't guarantee that
- <TT>runFinalization()</TT> will actually call the finalizers. As the
- shutdown hook is guaranteed you could also make a JNI call to clean up
- any resources that are being tracked by the C/C++ code.</P>
-</LI>
-<LI>
-<P>Call the <TT>delete()</TT> function manually which will immediately
- invoke the C++ destructor. As a suggestion it may be a good idea to set
- the object to null so that should the object be inadvertently used
- again a Java null pointer exception is thrown, the alternative would
- crash the JVM by using a null C pointer. For example given a SWIG
- generated class A:</P>
+<P> it would be accessible from Java, but there may be no easy way to
+ call it. The problem here is that a type wrapper class is generated for
+ the two dimensional array parameter so there is no easy way to
+ construct and manipulate a suitable <TT>double [4][4]</TT> value. To
+ fix this, you can write some extra C helper functions. Just use the <TT>
+%inline</TT> directive. For example:</P>
<DIV class="code">
<PRE>
-A myA = new A();
-// use myA ...
-myA.delete();
-// any use of myA here would crash the JVM
-myA=null;
-// any use of myA here would cause a Java null pointer exception to be thrown
+%inline %{
+/* Note: double[4][4] is equivalent to a pointer to an array double (*)[4] */
+double (*new_mat44())[4] {
+ return (double (*)[4]) malloc(16*sizeof(double));
+}
+void free_mat44(double (*x)[4]) {
+ free(x);
+}
+void mat44_set(double x[4][4], int i, int j, double v) {
+ x[i][j] = v;
+}
+double mat44_get(double x[4][4], int i, int j) {
+ return x[i][j];
+}
+%}
</PRE>
</DIV>
-<P> The SWIG generated code ensures that the memory is not deleted
- twice, in the event the finalizers get called in addition to the manual
- <TT>delete()</TT> call.</P>
-</LI>
-<LI>
-<P> Write your own object manager in Java. You could derive all SWIG
- classes from a single base class which could track which objects have
- had their finalizers run, then call the rest of them on program
- termination. The section on <A href="#Java_typemaps">Java typemaps</A>
- details how to specify a pure Java base class.</P>
-</LI>
-</OL>
-<P> See the <A href="http://www.devx.com/Java/Article/30192">How to
- Handle Java Finalization's Memory-Retention Issues</A> article for
- alternative approaches to managing memory by avoiding finalizers
- altogether.</P>
-<H4><A name="Java_pgcpp"></A>24.4.3.4 The premature garbage collection
- prevention parameter for proxy class marshalling</H4>
-<P> As covered earlier, the C/C++ struct/class pointer is stored in the
- proxy class as a Java long and when needed is passed into the native
- method where it is cast into the appropriate type. This approach
- provides very fast marshalling but could be susceptible to premature
- garbage collection. Consider the following C++ code:</P>
+<P> From Java, you could then write code like this:</P>
<DIV class="code">
<PRE>
-class Wibble {
-};
-void wobble(Wibble &w);
+Image im = new Image();
+SWIGTYPE_p_a_4__double a = example.new_mat44();
+example.mat44_set(a,0,0,1.0);
+example.mat44_set(a,1,1,1.0);
+example.mat44_set(a,2,2,1.0);
+...
+example.set_transform(im,a);
+example.free_mat44(a);
</PRE>
</DIV>
-<P> The module class contains the Java wrapper for the global <TT>wobble</TT>
- method:</P>
+<P> Admittedly, this is not the most elegant looking approach. However,
+ it works and it wasn't too hard to implement. It is possible to improve
+ on this using Java code, typemaps, and other customization features as
+ covered in later sections, but sometimes helper functions are a quick
+ and easy solution to difficult cases.</P>
+<H3><A name="Java_class_extension">25.7.2 Class extension with %extend</A>
+</H3>
+<P> One of the more interesting features of SWIG is that it can extend
+ structures and classes with new methods or constructors. Here is a
+ simple example:</P>
<DIV class="code">
<PRE>
-public class example {
- ...
- public static void wobble(Wibble w) {
- exampleJNI.wobble(Wibble.getCPtr(w), w);
- }
-}
+%module example
+%{
+#include "someheader.h"
+%}
+
+struct Vector {
+ double x,y,z;
+};
+
+%extend Vector {
+ char *toString() {
+ static char tmp[1024];
+ sprintf(tmp,"Vector(%g,%g,%g)", $self->x,$self->y,$self->z);
+ return tmp;
+ }
+ Vector(double x, double y, double z) {
+ Vector *v = (Vector *) malloc(sizeof(Vector));
+ v->x = x;
+ v->y = y;
+ v->z = z;
+ return v;
+ }
+};
</PRE>
</DIV>
-<P> where <TT>example</TT> is the name of the module. All native methods
- go through the intermediary class which has the native method declared
- as such:</P>
+<P> Now, in Java</P>
<DIV class="code">
<PRE>
-public class exampleJNI {
- ...
- public final static native void wobble(long jarg1, Wibble jarg1_);
-}
+Vector v = new Vector(2,3,4);
+System.out.println(v);
</PRE>
</DIV>
-<P> The second parameter, <TT>jarg1_</TT>, is the premature garbage
- collection prevention parameter and is added to the native method
- parameter list whenever a C/C++ struct or class is marshalled as a Java
- long. In order to understand why, consider the alternative where the
- intermediary class method is declared without the additional parameter:</P>
+<P> will display</P>
<DIV class="code">
<PRE>
-public class exampleJNI {
- ...
- public final static native void wobble(long jarg1);
-}
+Vector(2,3,4)
</PRE>
</DIV>
-<P> and the following simple call to <TT>wobble</TT>:</P>
+<P> <TT>%extend</TT> works with both C and C++ code. It does not modify
+ the underlying object in any way---the extensions only show up in the
+ Java interface.</P>
+<H3><A name="Java_exception_handling">25.7.3 Exception handling with
+ %exception and %javaexception</A></H3>
+<P> If a C or C++ function throws an error, you may want to convert that
+ error into a Java exception. To do this, you can use the <TT>%exception</TT>
+ directive. The <TT>%exception</TT> directive simply lets you rewrite
+ part of the generated wrapper code to include an error check. It is
+ detailed in full in the <A href="#Customization_exception">Exception
+ handling with %exception</A> section.</P>
+<P> In C, a function often indicates an error by returning a status code
+ (a negative number or a NULL pointer perhaps). Here is a simple example
+ of how you might handle that:</P>
<DIV class="code">
<PRE>
-{
- Wibble w = new Wibble();
- example.wobble(w);
+%exception malloc {
+ $action
+ if (!result) {
+ jclass clazz = (*jenv)->FindClass(jenv, "java/lang/OutOfMemoryError");
+ (*jenv)->ThrowNew(jenv, clazz, "Not enough memory");
+ return $null;
+ }
}
+void *malloc(size_t nbytes);
</PRE>
</DIV>
-<P> The hotspot compiler effectively sees something like:</P>
+<P> In Java,</P>
<DIV class="code">
<PRE>
-{
- Wibble w = new Wibble();
- long w_ptr = Wibble.getCPtr(w);
- // w is no longer reachable
- exampleJNI.wobble(w_ptr);
-}
+SWIGTYPE_p_void a = example.malloc(2000000000);
</PRE>
</DIV>
-<P> The <TT>Wibble</TT> object is no longer reachable after the point
- shown as in this bit of code, the <TT>Wibble</TT> object is not
- referenced again after this point. This means that it is a candidate
- for garbage collection. Should <TT>wobble</TT> be a long running
- method, it is quite likely that the finalizer for the <TT>Wibble</TT>
- instance will be called. This in turn will call its underlying C++
- destructor which is obviously disastrous while the method <TT>wobble</TT>
- is running using this object. Even if <TT>wobble</TT> is not a long
- running method, it is possible for the <TT>Wibble</TT> instance to be
- finalized. By passing the <TT>Wibble</TT> instance into the native
- method, it will not be finalized as the JVM guarantees not to finalize
- any objects until the native method returns. Effectively, the code then
- becomes</P>
+<P> will produce a familiar looking Java exception:</P>
<DIV class="code">
<PRE>
-{
- Wibble w = new Wibble();
- long w_ptr = Wibble.getCPtr(w);
- exampleJNI.wobble(w_ptr, w);
- // w is no longer reachable
-}
+Exception in thread "main" java.lang.OutOfMemoryError: Not enough memory
+ at exampleJNI.malloc(Native Method)
+ at example.malloc(example.java:16)
+ at runme.main(runme.java:112)
</PRE>
</DIV>
-<P> and therefore there is no possibility of premature garbage
- collection. In practice, this premature garbage collection was only
- ever observed in Sun's server JVM from jdk-1.3 onwards and in Sun's
- client JVM from jdk-1.6 onwards.</P>
-<P> The premature garbage collection prevention parameter for proxy
- classes is generated by default whenever proxy classes are passed by
- value, reference or with a pointer. The implementation for this extra
- parameter generation requires the "jtype" typemap to contain <TT>long</TT>
- and the "jstype" typemap to contain the name of a proxy class.</P>
-<P> The additional parameter does impose a slight performance overhead
- and the parameter generation can be suppressed globally with the <TT>
--nopgcpp</TT> commandline option. More selective suppression is possible
- with the 'nopgcpp' attribute in the "jtype" <A href="#Java_typemaps">
-Java typemap</A>. The attribute is a flag and so should be set to "1" to
- enable the suppression, or it can be omitted or set to "0" to disable.
- For example:</P>
+<P> If a library provides some kind of general error handling framework,
+ you can also use that. For example:</P>
<DIV class="code">
<PRE>
-%typemap(jtype, nopgcpp="1") Wibble & "long"
+%exception malloc {
+ $action
+ if (err_occurred()) {
+ jclass clazz = (*jenv)->FindClass(jenv, "java/lang/OutOfMemoryError");
+ (*jenv)->ThrowNew(jenv, clazz, "Not enough memory");
+ return $null;
+ }
+}
+void *malloc(size_t nbytes);
</PRE>
</DIV>
-<P><B> Compatibility note:</B> The generation of this additional
- parameter did not occur in versions prior to SWIG-1.3.30.</P>
-<H4><A name="Java_multithread_libraries"></A>24.4.3.5 Single threaded
- applications and thread safety</H4>
-<P> Single threaded Java applications using JNI need to consider thread
- safety. The same applies for the C# module where the .NET wrappers use
- PInvoke. Consider the C++ class:</P>
+<P> If no declaration name is given to <TT>%exception</TT>, it is
+ applied to all wrapper functions. The <TT>$action</TT> is a SWIG
+ special variable and is replaced by the C/C++ function call being
+ wrapped. The <TT>return $null;</TT> handles all native method return
+ types, namely those that have a void return and those that do not. This
+ is useful for typemaps that will be used in native method returning all
+ return types. See the section on <A href="#Java_special_variables">Java
+ special variables</A> for further explanation.</P>
+<P> C++ exceptions are also easy to handle. We can catch the C++
+ exception and rethrow it as a Java exception like this:</P>
<DIV class="code">
<PRE>
-class Test {
- string str;
+%exception getitem {
+ try {
+ $action
+ } catch (std::out_of_range &e) {
+ jclass clazz = jenv->FindClass("java/lang/Exception");
+ jenv->ThrowNew(clazz, "Range error");
+ return $null;
+ }
+}
+
+class FooClass {
public:
- Test() : str("initial") {}
+ FooClass *getitem(int index); // Might throw std::out_of_range exception
+ ...
};
</PRE>
</DIV>
-<P> and the Java proxy class generated by SWIG:</P>
-<DIV class="code">
-<PRE>
-public class Test {
- private long swigCPtr;
- protected boolean swigCMemOwn;
-
- protected Test(long cPtr, boolean cMemoryOwn) {
- swigCMemOwn = cMemoryOwn;
- swigCPtr = cPtr;
- }
-
- protected static long getCPtr(Test obj) {
- return (obj == null) ? 0 : obj.swigCPtr;
- }
-
- protected void finalize() {
- delete();
- }
-
- // Call C++ destructor
- public synchronized void delete() {
- if(swigCPtr != 0 && swigCMemOwn) {
- swigCMemOwn = false;
- exampleJNI.delete_Test(swigCPtr);
- }
- swigCPtr = 0;
- }
-
- // Call C++ constructor
- public Test() {
- this(exampleJNI.new_Test(), true);
- }
-
-}
-</PRE>
-</DIV>
-<P> It has two methods that call JNI methods, namely, <TT>
-exampleJNI.new_Test()</TT> for the C++ constructor and <TT>
-exampleJNI.delete_Test()</TT> for the C++ destructor. If the garbage
- collector collects an instance of this class, ie <TT>delete()</TT> is
- not explicitly called, then the C++ destructor will be run in a
- different thread to the main thread. This is because when an object is
- marked for garbage collection, any objects with finalizers are added to
- a finalization queue and the objects in the finalization queue have
- their <TT>finalize()</TT> methods run in a separate finalization
- thread. Therefore, if the C memory allocator is not thread safe, then
- the heap will get corrupted sooner or later, when a concurrent C++
- delete and new are executed. It is thus essential, even in single
- threaded usage, to link to the C multi-thread runtime libraries, for
- example, use the /MD option for Visual C++ on Windows. Alternatively,
- lock all access to C++ functions that have heap
- allocation/deallocation.</P>
-<P> Note that some of the STL in Visual C++ 6 is not thread safe, so
- although code might be linked to the multithread runtime libraries,
- undefined behaviour might still occur in a single threaded Java
- program. Similarly some older versions of Sun Studio have bugs in the
- multi-threaded implementation of the std::string class and so will lead
- to undefined behaviour in these supposedly single threaded Java
- applications.</P>
-<P> The following innocuous Java usage of Test is an example that will
- crash very quickly on a multiprocessor machine if the JNI compiled code
- is linked against the single thread C runtime libraries.</P>
+<P> In the example above, <TT>java.lang.Exception</TT> is a checked
+ exception class and so ought to be declared in the throws clause of <TT>
+getitem</TT>. Classes can be specified for adding to the throws clause
+ using <TT>%javaexception(classes)</TT> instead of <TT>%exception</TT>,
+ where <TT>classes</TT> is a string containing one or more comma
+ separated Java classes. The <TT>%clearjavaexception</TT> feature is the
+ equivalent to <TT>%clearexception</TT> and clears previously declared
+ exception handlers. The <TT>%nojavaexception</TT> feature is the
+ equivalent to <TT>%noexception</TT> and disables the exception handler.
+ See <A href="#Customization_clearing_features">Clearing features</A>
+ for the difference on disabling and clearing features.</P>
<DIV class="code">
<PRE>
-for (int i=0; i<100000; i++) {
- System.out.println("Iteration " + i);
- for (int k=0; k<10; k++) {
- Test test = new Test();
- }
- System.gc();
+%javaexception("java.lang.Exception") getitem {
+ try {
+ $action
+ } catch (std::out_of_range &e) {
+ jclass clazz = jenv->FindClass("java/lang/Exception");
+ jenv->ThrowNew(clazz, "Range error");
+ return $null;
+ }
}
+
+class FooClass {
+public:
+ FooClass *getitem(int index); // Might throw std::out_of_range exception
+ ...
+};
</PRE>
</DIV>
-<H3><A name="Java_type_wrapper_classes"></A>24.4.4 Type wrapper classes</H3>
-<P> The generated type wrapper class, for say an <TT>int *</TT>, looks
- like this:</P>
+<P> The generated proxy method now generates a throws clause containing <TT>
+java.lang.Exception</TT>:</P>
<DIV class="code">
<PRE>
-public class SWIGTYPE_p_int {
- private long swigCPtr;
-
- protected SWIGTYPE_p_int(long cPtr, boolean bFutureUse) {
- swigCPtr = cPtr;
- }
-
- protected SWIGTYPE_p_int() {
- swigCPtr = 0;
- }
-
- protected static long getCPtr(SWIGTYPE_p_int obj) {
- return obj.swigCPtr;
- }
+public class FooClass {
+ ...
+ public FooClass getitem(int index) throws java.lang.Exception { ... }
+ ...
}
</PRE>
</DIV>
-<P> The methods do not have public access, so by default it is
- impossible to do anything with objects of this class other than pass
- them around. The methods in the class are part of the inner workings of
- SWIG. If you need to mess around with pointers you will have to use
- some typemaps specific to the Java module to achieve this. The section
- on <A href="#Java_typemaps">Java typemaps</A> details how to modify the
- generated code.</P>
-<P> Note that if you use a pointer or reference to a proxy class in a
- function then no type wrapper class is generated because the proxy
- class can be used as the function parameter. If however, you need
- anything more complicated like a pointer to a pointer to a proxy class
- then a typewrapper class is generated for your use.</P>
-<P> Note that SWIG generates a type wrapper class and not a proxy class
- when it has not parsed the definition of a type that gets used. For
- example, say SWIG has not parsed the definition of <TT>class Snazzy</TT>
- because it is in a header file that you may have forgotten to use the <TT>
-%include</TT> directive on. Should SWIG parse <TT>Snazzy *</TT> being
- used in a function parameter, it will then generates a type wrapper
- class around a <TT>Snazzy</TT> pointer. Also recall from earlier that
- SWIG will use a pointer when a class is passed by value or by
- reference:</P>
+<P> The examples above first use the C JNI calling syntax then the C++
+ JNI calling syntax. The C++ calling syntax will not compile as C and
+ also vice versa. It is however possible to write JNI calls which will
+ compile under both C and C++ and is covered in the <A href="#Java_typemaps_for_c_and_cpp">
+Typemaps for both C and C++ compilation</A> section.</P>
+<P> The language-independent <TT>exception.i</TT> library file can also
+ be used to raise exceptions. See the <A href="#Library">SWIG Library</A>
+ chapter. The typemap example <A href="#Java_exception_typemap">Handling
+ C++ exception specifications as Java exceptions</A> provides further
+ exception handling capabilities.</P>
+<H3><A name="Java_method_access">25.7.4 Method access with
+ %javamethodmodifiers</A></H3>
+<P> A Java feature called <TT>%javamethodmodifiers</TT> can be used to
+ change the method modifiers from the default <TT>public</TT>. It
+ applies to both module class methods and proxy class methods. For
+ example:</P>
<DIV class="code">
<PRE>
-void spam(Snazzy *x, Snazzy &y, Snazzy z);
+%javamethodmodifiers protect_me() "protected";
+void protect_me();
</PRE>
</DIV>
-<P> Should SWIG not know anything about <TT>Snazzy</TT> then a <TT>
-SWIGTYPE_p_Snazzy</TT> must be used for all 3 parameters in the <TT>spam</TT>
- function. The Java function generated is:</P>
+<P> Will produce the method in the module class with protected access.</P>
<DIV class="code">
<PRE>
-public static void spam(SWIGTYPE_p_Snazzy x, SWIGTYPE_p_Snazzy y, SWIGTYPE_p_Snazzy z) {
- ...
+protected static void protect_me() {
+ exampleJNI.protect_me();
}
</PRE>
</DIV>
-<P> Note that typedefs are tracked by SWIG and the typedef name is used
- to construct the type wrapper class name. For example, consider the
- case where <TT>Snazzy</TT> is a typedef to an <TT>int</TT> which SWIG
- does parse:</P>
+<H2><A name="Java_tips_techniques">25.8 Tips and techniques</A></H2>
+<P> Although SWIG is largely automatic, there are certain types of
+ wrapping problems that require additional user input. Examples include
+ dealing with output parameters, strings and arrays. This chapter
+ discusses the common techniques for solving these problems.</P>
+<H3><A name="Java_input_output_parameters">25.8.1 Input and output
+ parameters using primitive pointers and references</A></H3>
+<P> A common problem in some C programs is handling parameters passed as
+ simple pointers or references. For example:</P>
<DIV class="code">
<PRE>
-typedef int Snazzy;
-void spam(Snazzy *x, Snazzy &y, Snazzy z);
+void add(int x, int y, int *result) {
+ *result = x + y;
+}
</PRE>
</DIV>
-<P> Because the typedefs have been tracked the Java function generated
- is:</P>
+<P> or perhaps</P>
<DIV class="code">
<PRE>
-public static void spam(SWIGTYPE_p_int x, SWIGTYPE_p_int y, int z) { ... }
+int sub(int *x, int *y) {
+ return *x-*y;
+}
</PRE>
</DIV>
-<H3><A name="Java_enum_classes"></A>24.4.5 Enum classes</H3>
-<P> SWIG can generate three types of enum classes. The <A href="#Java_enumerations">
-Enumerations</A> section discussed these but omitted all the details.
- The following sub-sections detail the various types of enum classes
- that can be generated.</P>
-<H4><A name="Java_typesafe_enums_classes"></A>24.4.5.1 Typesafe enum
- classes</H4>
-<P> The following example demonstrates the typesafe enum classes which
- SWIG generates:</P>
+<P> The <TT>typemaps.i</TT> library file will help in these situations.
+ For example:</P>
<DIV class="code">
<PRE>
-%include "enumtypesafe.swg"
-%javaconst(1);
-enum Beverage { ALE, LAGER=10, STOUT, PILSNER, PILZ=PILSNER };
+%module example
+%include "typemaps.i"
+
+void add(int, int, int *OUTPUT);
+int sub(int *INPUT, int *INPUT);
</PRE>
</DIV>
-<P> The following is the code that SWIG generates:</P>
+<P> In Java, this allows you to pass simple values. For example:</P>
<DIV class="code">
<PRE>
-public final class Beverage {
- public final static Beverage ALE = new Beverage("ALE");
- public final static Beverage LAGER = new Beverage("LAGER", 10);
- public final static Beverage STOUT = new Beverage("STOUT");
- public final static Beverage PILSNER = new Beverage("PILSNER");
- public final static Beverage PILZ = new Beverage("PILZ", PILSNER);
-
- public final int swigValue() {
- return swigValue;
- }
-
- public String toString() {
- return swigName;
- }
-
- public static Beverage 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 " + Beverage.class + " with value " +
- swigValue);
- }
-
- private Beverage(String swigName) {
- this.swigName = swigName;
- this.swigValue = swigNext++;
- }
-
- private Beverage(String swigName, int swigValue) {
- this.swigName = swigName;
- this.swigValue = swigValue;
- swigNext = swigValue+1;
- }
-
- private Beverage(String swigName, Beverage swigEnum) {
- this.swigName = swigName;
- this.swigValue = swigEnum.swigValue;
- swigNext = this.swigValue+1;
- }
-
- private static Beverage[] swigValues = { ALE, LAGER, STOUT, PILSNER, PILZ };
- private static int swigNext = 0;
- private final int swigValue;
- private final String swigName;
-}
+int result = example.sub(7,4);
+System.out.println("7 - 4 = " + result);
+int[] sum = {0};
+example.add(3,4,sum);
+System.out.println("3 + 4 = " + sum[0]);
</PRE>
</DIV>
-<P> As can be seen, there are a fair number of support methods for the
- typesafe enum pattern. The typesafe enum pattern involves creating a
- fixed number of static instances of the enum class. The constructors
- are private to enforce this. Three constructors are available - two for
- C/C++ enums with an initializer and one for those without an
- initializer. Note that the two enums with initializers, <TT>LAGER</TT>
- and <TT>PILZ</TT>, each call one the two different initializer
- constructors. In order to use one of these typesafe enums, the <TT>
-swigToEnum</TT> static method must be called to return a reference to
- one of the static instances. The JNI layer returns the enum value from
- the C/C++ world as an integer and this method is used to find the
- appropriate Java enum static instance. The <TT>swigValue</TT> method is
- used for marshalling in the other direction. The <TT>toString</TT>
- method is overridden so that the enum name is available.</P>
-<H4><A name="Java_proper_enums_classes"></A>24.4.5.2 Proper Java enum
- classes</H4>
-<P> The following example demonstrates the Java enums approach:</P>
+<P> Which will display:</P>
<DIV class="code">
<PRE>
-%include "enums.swg"
-%javaconst(1);
-enum Beverage { ALE, LAGER=10, STOUT, PILSNER, PILZ=PILSNER };
+7 - 4 = 3
+3 + 4 = 7
</PRE>
</DIV>
-<P> SWIG will generate the following Java enum:</P>
+<P> Notice how the <TT>INPUT</TT> parameters allow integer values to be
+ passed instead of pointers and how the <TT>OUTPUT</TT> parameter will
+ return the result in the first element of the integer array.</P>
+<P> If you don't want to use the names <TT>INPUT</TT> or <TT>OUTPUT</TT>
+, use the <TT>%apply</TT> directive. For example:</P>
<DIV class="code">
<PRE>
-public enum Beverage {
- ALE,
- LAGER(10),
- STOUT,
- PILSNER,
- PILZ(PILSNER);
-
- public final int swigValue() {
- return swigValue;
- }
-
- public static Beverage swigToEnum(int swigValue) {
- Beverage[] swigValues = Beverage.class.getEnumConstants();
- if (swigValue < swigValues.length && swigValue >= 0 &&
- swigValues[swigValue].swigValue == swigValue)
- return swigValues[swigValue];
- for (Beverage swigEnum : swigValues)
- if (swigEnum.swigValue == swigValue)
- return swigEnum;
- throw new IllegalArgumentException("No enum " + Beverage.class +
- " with value " + swigValue);
- }
-
- private Beverage() {
- this.swigValue = SwigNext.next++;
- }
-
- private Beverage(int swigValue) {
- this.swigValue = swigValue;
- SwigNext.next = swigValue+1;
- }
-
- private Beverage(Beverage swigEnum) {
- this.swigValue = swigEnum.swigValue;
- SwigNext.next = this.swigValue+1;
- }
+%module example
+%include "typemaps.i"
- private final int swigValue;
+%apply int *OUTPUT { int *result };
+%apply int *INPUT { int *x, int *y};
- private static class SwigNext {
- private static int next = 0;
- }
-}
+void add(int x, int y, int *result);
+int sub(int *x, int *y);
</PRE>
</DIV>
-<P> The enum items appear first. Like the typesafe enum pattern, the
- constructors are private. The constructors are required to handle C/C++
- enums with initializers. The <TT>next</TT> variable is in the <TT>
-SwigNext</TT> inner class rather than in the enum class as static
- primitive variables cannot be modified from within enum constructors.
- Marshalling between Java enums and the C/C++ enum integer value is
- handled via the <TT>swigToEnum</TT> and <TT>swigValue</TT> methods. All
- the constructors and methods in the Java enum are required just to
- handle C/C++ enums with initializers. These needn't be generated if the
- enum being wrapped does not have any initializers and the <A href="#Java_simpler_enum_classes">
-Simpler Java enums for enums without initializers</A> section describes
- how typemaps can be used to achieve this.</P>
-<H4><A name="Java_typeunsafe_enums_classes"></A>24.4.5.3 Type unsafe
- enum classes</H4>
-<P> The following example demonstrates type unsafe enums:</P>
+<P> If a function mutates one of its parameters like this,</P>
<DIV class="code">
<PRE>
-%include "enumtypeunsafe.swg"
-%javaconst(1);
-enum Beverage { ALE, LAGER=10, STOUT, PILSNER, PILZ=PILSNER };
+void negate(int *x) {
+ *x = -(*x);
+}
</PRE>
</DIV>
-<P> SWIG will generate the following simple class:</P>
+<P> you can use <TT>INOUT</TT> like this:</P>
<DIV class="code">
<PRE>
-public final class Beverage {
- public final static int ALE = 0;
- public final static int LAGER = 10;
- public final static int STOUT = LAGER + 1;
- public final static int PILSNER = STOUT + 1;
- public final static int PILZ = PILSNER;
-}
+%include "typemaps.i"
+...
+void negate(int *INOUT);
</PRE>
</DIV>
-<H2><A name="Java_directors"></A>24.5 Cross language polymorphism using
- directors</H2>
-<P> Proxy classes provide a natural, object-oriented way to wrap C++
- classes. as described earlier, each proxy instance has an associated
- C++ instance, and method calls from Java to the proxy are passed to the
- C++ instance transparently via C wrapper functions.</P>
-<P> This arrangement is asymmetric in the sense that no corresponding
- mechanism exists to pass method calls down the inheritance chain from
- C++ to Java. In particular, if a C++ class has been extended in Java
- (by deriving from the proxy class), these classes will not be visible
- from C++ code. Virtual method calls from C++ are thus not able to
- access the lowest implementation in the inheritance chain.</P>
-<P> SWIG can address this problem and make the relationship between C++
- classes and proxy classes more symmetric. To achieve this goal, new
- classes called directors are introduced at the bottom of the C++
- inheritance chain. The job of the directors is to route method calls
- correctly, either to C++ implementations higher in the inheritance
- chain or to Java implementations lower in the inheritance chain. The
- upshot is that C++ classes can be extended in Java and from C++ these
- extensions look exactly like native C++ classes. Neither C++ code nor
- Java code needs to know where a particular method is implemented: the
- combination of proxy classes, director classes, and C wrapper functions
- transparently takes care of all the cross-language method routing.</P>
-<H3><A name="Java_enabling_directors"></A>24.5.1 Enabling directors</H3>
-<P> The director feature is disabled by default. To use directors you
- must make two changes to the interface file. First, add the "directors"
- option to the %module directive, like this:</P>
+<P> In Java, the input parameter is the first element in a 1 element
+ array and is replaced by the output of the function. For example:</P>
<DIV class="code">
<PRE>
-%module(directors="1") modulename
+int[] neg = {3};
+example.negate(neg);
+System.out.println("Negative of 3 = " + neg[0]);
</PRE>
</DIV>
-<P> Without this option no director code will be generated. Second, you
- must use the %feature("director") directive to tell SWIG which classes
- and methods should get directors. The %feature directive can be applied
- globally, to specific classes, and to specific methods, like this:</P>
+<P> And no prizes for guessing the output:</P>
<DIV class="code">
<PRE>
-// generate directors for all classes that have virtual methods
-%feature("director");
-
-// generate directors for all virtual methods in class Foo
-%feature("director") Foo;
+Negative of 3 = -3
</PRE>
</DIV>
-<P> You can use the %feature("nodirector") directive to turn off
- directors for specific classes or methods. So for example,</P>
+<P> These typemaps can also be applied to C++ references. The above
+ examples would work the same if they had been defined using references
+ instead of pointers. For example, the Java code to use the <TT>negate</TT>
+ function would be the same if it were defined either as it is above:</P>
<DIV class="code">
<PRE>
-%feature("director") Foo;
-%feature("nodirector") Foo::bar;
+void negate(int *INOUT);
</PRE>
</DIV>
-<P> will generate directors for all virtual methods of class Foo except
- bar().</P>
-<P> Directors can also be generated implicitly through inheritance. In
- the following, class Bar will get a director class that handles the
- methods one() and two() (but not three()):</P>
+<P> or using a reference:</P>
<DIV class="code">
<PRE>
-%feature("director") Foo;
-class Foo {
-public:
- virtual void one();
- virtual void two();
-};
-
-class Bar: public Foo {
-public:
- virtual void three();
-};
+void negate(int &INOUT);
</PRE>
</DIV>
-<H3><A name="Java_directors_classes"></A>24.5.2 Director classes</H3>
-<P> For each class that has directors enabled, SWIG generates a new
- class that derives from both the class in question and a special <TT>
-Swig::Director</TT> class. These new classes, referred to as director
- classes, can be loosely thought of as the C++ equivalent of the Java
- proxy classes. The director classes store a pointer to their underlying
- Java proxy classes.</P>
-<P> For simplicity let's ignore the <TT>Swig::Director</TT> class and
- refer to the original C++ class as the director's base class. By
- default, a director class extends all virtual methods in the
- inheritance chain of its base class (see the preceding section for how
- to modify this behavior). Thus all virtual method calls, whether they
- originate in C++ or in Java via proxy classes, eventually end up in at
- the implementation in the director class. The job of the director
- methods is to route these method calls to the appropriate place in the
- inheritance chain. By "appropriate place" we mean the method that would
- have been called if the C++ base class and its Java derived classes
- were seamlessly integrated. That seamless integration is exactly what
- the director classes provide, transparently skipping over all the messy
- JNI glue code that binds the two languages together.</P>
-<P> In reality, the "appropriate place" is one of only two
- possibilities: C++ or Java. Once this decision is made, the rest is
- fairly easy. If the correct implementation is in C++, then the lowest
- implementation of the method in the C++ inheritance chain is called
- explicitly. If the correct implementation is in Java, the Java API is
- used to call the method of the underlying Java object (after which the
- usual virtual method resolution in Java automatically finds the right
- implementation).</P>
-<H3><A name="Java_directors_overhead"></A>24.5.3 Overhead and code bloat</H3>
-<P> Enabling directors for a class will generate a new director method
- for every virtual method in the class' inheritance chain. This alone
- can generate a lot of code bloat for large hierarchies. Method
- arguments that require complex conversions to and from Java types can
- result in large director methods. For this reason it is recommended
- that directors are selectively enabled only for specific classes that
- are likely to be extended in Java and used in C++.</P>
-<P> Although directors make it natural to mix native C++ objects with
- Java objects (as director objects), one should be aware of the obvious
- fact that method calls to Java objects from C++ will be much slower
- than calls to C++ objects. Additionally, compared to classes that do
- not use directors, the call routing in the director methods adds a
- small overhead. This situation can be optimized by selectively enabling
- director methods (using the %feature directive) for only those methods
- that are likely to be extended in Java.</P>
-<H3><A name="Java_directors_example"></A>24.5.4 Simple directors example</H3>
-<P> Consider the following SWIG interface file:</P>
+<P> Note: Since most Java primitive types are immutable and are passed
+ by value, it is not possible to perform in-place modification of a type
+ passed as a parameter.</P>
+<P> Be aware that the primary purpose of the <TT>typemaps.i</TT> file is
+ to support primitive datatypes. Writing a function like this</P>
<DIV class="code">
<PRE>
-%module(directors="1") example;
-
-%feature("director") DirectorBase;
-
-class DirectorBase {
-public:
- virtual ~DirectorBase() {}
- virtual void upcall_method() {}
-};
-
-void callup(DirectorBase *director) {
- director->upcall_method();
-}
+void foo(Bar *OUTPUT);
</PRE>
</DIV>
-<P> The following <CODE>DirectorDerived</CODE> Java class is derived
- from the Java proxy class <CODE>DirectorBase</CODE> and overrides <CODE>
-upcall_method()</CODE>. When C++ code invokes <CODE>upcall_method()</CODE>
-, the SWIG-generated C++ code redirects the call via JNI to the Java <CODE>
-DirectorDerived</CODE> subclass. Naturally, the SWIG generated C++ code
- and the generated Java intermediary class marshal and convert arguments
- between C++ and Java when needed.</P>
+<P> will not have the intended effect since <TT>typemaps.i</TT> does not
+ define an OUTPUT rule for <TT>Bar</TT>.</P>
+<H3><A name="Java_simple_pointers">25.8.2 Simple pointers</A></H3>
+<P> If you must work with simple pointers such as <TT>int *</TT> or <TT>
+double *</TT> another approach to using <TT>typemaps.i</TT> is to use
+ the <TT>cpointer.i</TT> pointer library file. For example:</P>
<DIV class="code">
<PRE>
-public class DirectorDerived extends DirectorBase {
- public DirectorDerived() {
- }
+%module example
+%include "cpointer.i"
- public void upcall_method() {
- System.out.println("DirectorDerived::upcall_method() invoked.");
- }
-}
+%inline %{
+extern void add(int x, int y, int *result);
+%}
+
+%pointer_functions(int, intp);
</PRE>
</DIV>
-<P> Running the following Java code</P>
+<P> The <TT>%pointer_functions(type,name)</TT> macro generates five
+ helper functions that can be used to create, destroy, copy, assign, and
+ dereference a pointer. In this case, the functions are as follows:</P>
<DIV class="code">
<PRE>
-DirectorDerived director = new DirectorDerived();
-example.callup(director);
+int *new_intp();
+int *copy_intp(int *x);
+void delete_intp(int *x);
+void intp_assign(int *x, int value);
+int intp_value(int *x);
</PRE>
</DIV>
-<P> will result in the following being output:</P>
+<P> In Java, you would use the functions like this:</P>
<DIV class="code">
<PRE>
-DirectorDerived::upcall_method() invoked.
+SWIGTYPE_p_int intPtr = example.new_intp();
+example.add(3,4,intPtr);
+int result = example.intp_value(intPtr);
+System.out.println("3 + 4 = " + result);
</PRE>
</DIV>
-<H3><A name="Java_directors_threading"></A>24.5.5 Director threading
- issues</H3>
-<P> Depending on your operating system and version of Java and how you
- are using threads, you might find the JVM hangs on exit. There are a
- couple of solutions to try out. The preferred solution requires jdk-1.4
- and later and uses <TT>AttachCurrentThreadAsDaemon</TT> instead of <TT>
-AttachCurrentThread</TT> whenever a call into the JVM is required. This
- can be enabled by defining the
- SWIG_JAVA_ATTACH_CURRENT_THREAD_AS_DAEMON macro when compiling the C++
- wrapper code. For older JVMs define SWIG_JAVA_NO_DETACH_CURRENT_THREAD
- instead, to avoid the <TT>DetachCurrentThread</TT> call but this will
- result in a memory leak instead. For further details inspect the source
- code in the java/director.swg library file.</P>
-<P> Macros can be defined on the commandline when compiling your C++
- code, or alternatively added to the C++ wrapper file as shown below:</P>
+<P> If you replace <TT>%pointer_functions(int,intp)</TT> by <TT>
+%pointer_class(int,intp)</TT>, the interface is more class-like.</P>
<DIV class="code">
<PRE>
-%insert("runtime") %{
-#define SWIG_JAVA_NO_DETACH_CURRENT_THREAD
-%}
+intp intPtr = new intp();
+example.add(3,4,intPtr.cast());
+int result = intPtr.value();
+System.out.println("3 + 4 = " + result);
</PRE>
</DIV>
-<H3><A name="Java_directors_performance"></A>24.5.6 Director performance
- tuning</H3>
-<P> When a new instance of a director (or subclass) is created in Java,
- the C++ side of the director performs a runtime check per director
- method to determine if that particular method is overridden in Java or
- if it should invoke the C++ base implementation directly. Although this
- makes initialization slightly more expensive, it is generally a good
- overall tradeoff.</P>
-<P> However, if all director methods are expected to usually be
- overridden by Java subclasses, then initialization can be made faster
- by avoiding these checks via the <TT>assumeoverride</TT> attribute. For
+<P> See the <A href="#Library">SWIG Library</A> chapter for further
+ details.</P>
+<H3><A name="Java_c_arrays">25.8.3 Wrapping C arrays with Java arrays</A>
+</H3>
+<P> SWIG can wrap arrays in a more natural Java manner than the default
+ by using the <TT>arrays_java.i</TT> library file. Let's consider an
example:</P>
<DIV class="code">
<PRE>
-%feature("director", assumeoverride=1) Foo;
-</PRE>
-</DIV>
-<P> The disadvantage is that invocation of director methods from C++
- when Java doesn't actually override the method will require an
- additional call up into Java and back to C++. As such, this option is
- only useful when overrides are extremely common and instantiation is
- frequent enough that its performance is critical.</P>
-<H2><A name="Java_allprotected"></A>24.6 Accessing protected members</H2>
-<P> When using directors, the protected virtual methods are also
- wrapped. These methods are wrapped with a protected Java proxy method,
- so the only way that Java code can access these is from within a Java
- class derived from the director class.</P>
-<P> Members which are protected and non-virtual can also be accessed
- when using the 'allprotected' mode. The allprotected mode requires
- directors and is turned on by setting the <TT>allprotected</TT> option
- in addition to the <TT>directors</TT> option in the %module directive,
- like this:</P>
-<DIV class="code">
-<PRE>
-%module(directors="1", allprotected="1") modulename
+%include "arrays_java.i";
+int array[4];
+void populate(int x[]) {
+ int i;
+ for (i=0; i<4; i++)
+ x[i] = 100 + i;
+}
</PRE>
</DIV>
-<P> Protected member variables and methods (both static and non-static)
- will then be wrapped with protected access in the Java proxy class.</P>
-<P><B> Note:</B> Neither the directors option nor the allprotected mode
- support types defined with protected scope. This includes any enums or
- typedefs declared in the protected section of the C++ class.</P>
-<P> The following simple example is a class with numerous protected
- members, including the constructor and destructor:</P>
+<P> These one dimensional arrays can then be used as if they were Java
+ arrays:</P>
<DIV class="code">
<PRE>
-%module(directors="1", allprotected="1") example
-
-%feature("director") ProtectedBase;
-
-// Ignore use of unsupported types (those defined in the protected section)
-%ignore ProtectedBase::typedefs;
-
-%inline %{
+int[] array = new int[4];
+example.populate(array);
-class ProtectedBase {
-protected:
- ProtectedBase() {}
- virtual ~ProtectedBase() {}
- virtual void virtualMethod() const {}
- void nonStaticMethod(double d) const {}
- static void staticMethod(int i) {}
- int instanceMemberVariable;
- static int staticMemberVariable;
+System.out.print("array: ");
+for (int i=0; i<array.length; i++)
+ System.out.print(array[i] + " ");
- // unsupported: types defined with protected access and the methods/variables which use them
- typedef int IntegerType;
- IntegerType typedefs(IntegerType it) { return it; }
-};
-int ProtectedBase::staticMemberVariable = 10;
+example.setArray(array);
-%}
+int[] global_array = example.getArray();
+System.out.print("\nglobal_array: ");
+for (int i=0; i<array.length; i++)
+ System.out.print(global_array[i] + " ");
</PRE>
</DIV>
-<P> Note that the <TT>IntegerType</TT> has protected scope and the
- members which use this type must be ignored as they cannot be wrapped.</P>
-<P> The proxy methods are protected, so the only way the protected
- members can be accessed is within a class that derives from the
- director class, such as the following:</P>
+<P> Java arrays are always passed by reference, so any changes a
+ function makes to the array will be seen by the calling function. Here
+ is the output after running this code:</P>
<DIV class="code">
<PRE>
-class MyProtectedBase extends ProtectedBase
-{
- public MyProtectedBase() {
- }
-
- public void accessProtected() {
- virtualMethod();
- nonStaticMethod(1.2);
- staticMethod(99);
-
- setInstanceMemberVariable(5);
- int i = getInstanceMemberVariable();
-
- setStaticMemberVariable(10);
- i = getStaticMemberVariable();
- }
-}
+array: 100 101 102 103
+global_array: 100 101 102 103
</PRE>
</DIV>
-<H2><A name="Java_common_customization"></A>24.7 Common customization
- features</H2>
-<P> An earlier section presented the absolute basics of C/C++ wrapping.
- If you do nothing but feed SWIG a header file, you will get an
- interface that mimics the behavior described. However, sometimes this
- isn't enough to produce a nice module. Certain types of functionality
- might be missing or the interface to certain functions might be
- awkward. This section describes some common SWIG features that are used
- to improve the interface to existing C/C++ code.</P>
-<H3><A name="Java_helper_functions"></A>24.7.1 C/C++ helper functions</H3>
-<P> Sometimes when you create a module, it is missing certain bits of
- functionality. For example, if you had a function like this</P>
+<P> Note that for assigning array variables the length of the C variable
+ is used, so it is possible to use a Java array that is bigger than the
+ C code will cope with. Only the number of elements in the C array will
+ be used. However, if the Java array is not large enough then you are
+ likely to get a segmentation fault or access violation, just like you
+ would in C. When arrays are used in functions like <TT>populate</TT>,
+ the size of the C array passed to the function is determined by the
+ size of the Java array.</P>
+<P> Please be aware that the typemaps in this library are not efficient
+ as all the elements are copied from the Java array to a C array
+ whenever the array is passed to and from JNI code. There is an
+ alternative approach using the SWIG array library and this is covered
+ in the next section.</P>
+<H3><A name="Java_unbounded_c_arrays">25.8.4 Unbounded C Arrays</A></H3>
+<P> Sometimes a C function expects an array to be passed as a pointer.
+ For example,</P>
<DIV class="code">
<PRE>
-typedef struct Image {...};
-void set_transform(Image *im, double m[4][4]);
+int sumitems(int *first, int nitems) {
+ int i, sum = 0;
+ for (i = 0; i < nitems; i++) {
+ sum += first[i];
+ }
+ return sum;
+}
</PRE>
</DIV>
-<P> it would be accessible from Java, but there may be no easy way to
- call it. The problem here is that a type wrapper class is generated for
- the two dimensional array parameter so there is no easy way to
- construct and manipulate a suitable <TT>double [4][4]</TT> value. To
- fix this, you can write some extra C helper functions. Just use the <TT>
-%inline</TT> directive. For example:</P>
+<P> One of the ways to wrap this is to apply the Java array typemaps
+ that come in the <TT>arrays_java.i</TT> library file:</P>
<DIV class="code">
<PRE>
-%inline %{
-/* Note: double[4][4] is equivalent to a pointer to an array double (*)[4] */
-double (*new_mat44())[4] {
- return (double (*)[4]) malloc(16*sizeof(double));
-}
-void free_mat44(double (*x)[4]) {
- free(x);
-}
-void mat44_set(double x[4][4], int i, int j, double v) {
- x[i][j] = v;
-}
-double mat44_get(double x[4][4], int i, int j) {
- return x[i][j];
-}
-%}
+%include "arrays_java.i"
+%apply int[] {int *};
</PRE>
</DIV>
-<P> From Java, you could then write code like this:</P>
+<P> The <TT>ANY</TT> size will ensure the typemap is applied to arrays
+ of all sizes. You could narrow the typemap matching rules by specifying
+ a particular array size. Now you can use a pure Java array and pass it
+ to the C code:</P>
<DIV class="code">
<PRE>
-Image im = new Image();
-SWIGTYPE_p_a_4__double a = example.new_mat44();
-example.mat44_set(a,0,0,1.0);
-example.mat44_set(a,1,1,1.0);
-example.mat44_set(a,2,2,1.0);
-...
-example.set_transform(im,a);
-example.free_mat44(a);
+int[] array = new int[10000000]; // Array of 10-million integers
+for (int i=0; i<array.length; i++) { // Set some values
+ array[i] = i;
+}
+int sum = example.sumitems(array,10000);
+System.out.println("Sum = " + sum);
</PRE>
</DIV>
-<P> Admittedly, this is not the most elegant looking approach. However,
- it works and it wasn't too hard to implement. It is possible to improve
- on this using Java code, typemaps, and other customization features as
- covered in later sections, but sometimes helper functions are a quick
- and easy solution to difficult cases.</P>
-<H3><A name="Java_class_extension"></A>24.7.2 Class extension with
- %extend</H3>
-<P> One of the more interesting features of SWIG is that it can extend
- structures and classes with new methods or constructors. Here is a
- simple example:</P>
+<P> and the sum would be displayed:</P>
<DIV class="code">
<PRE>
-%module example
-%{
-#include "someheader.h"
-%}
-
-struct Vector {
- double x,y,z;
-};
-
-%extend Vector {
- char *toString() {
- static char tmp[1024];
- sprintf(tmp,"Vector(%g,%g,%g)", $self->x,$self->y,$self->z);
- return tmp;
- }
- Vector(double x, double y, double z) {
- Vector *v = (Vector *) malloc(sizeof(Vector));
- v->x = x;
- v->y = y;
- v->z = z;
- return v;
- }
-};
+Sum = 49995000
</PRE>
</DIV>
-<P> Now, in Java</P>
+<P> This approach is probably the most natural way to use arrays.
+ However, it suffers from performance problems when using large arrays
+ as a lot of copying of the elements occurs in transferring the array
+ from the Java world to the C++ world. An alternative approach to using
+ Java arrays for C arrays is to use an alternative SWIG library file <TT>
+carrays.i</TT>. This approach can be more efficient for large arrays as
+ the array is accessed one element at a time. For example:</P>
<DIV class="code">
<PRE>
-Vector v = new Vector(2,3,4);
-System.out.println(v);
+%include "carrays.i"
+%array_functions(int, intArray);
</PRE>
</DIV>
-<P> will display</P>
+<P> The <TT>%array_functions(type,name)</TT> macro generates four helper
+ functions that can be used to create and destroy arrays and operate on
+ elements. In this case, the functions are as follows:</P>
<DIV class="code">
<PRE>
-Vector(2,3,4)
+int *new_intArray(int nelements);
+void delete_intArray(int *x);
+int intArray_getitem(int *x, int index);
+void intArray_setitem(int *x, int index, int value);
</PRE>
</DIV>
-<P> <TT>%extend</TT> works with both C and C++ code. It does not modify
- the underlying object in any way---the extensions only show up in the
- Java interface.</P>
-<H3><A name="Java_exception_handling"></A>24.7.3 Exception handling with
- %exception and %javaexception</H3>
-<P> If a C or C++ function throws an error, you may want to convert that
- error into a Java exception. To do this, you can use the <TT>%exception</TT>
- directive. The <TT>%exception</TT> directive simply lets you rewrite
- part of the generated wrapper code to include an error check. It is
- detailed in full in the <A href="#Customization_exception">Exception
- handling with %exception</A> section.</P>
-<P> In C, a function often indicates an error by returning a status code
- (a negative number or a NULL pointer perhaps). Here is a simple example
- of how you might handle that:</P>
+<P> In Java, you would use the functions like this:</P>
<DIV class="code">
<PRE>
-%exception malloc {
- $action
- if (!result) {
- jclass clazz = (*jenv)->FindClass(jenv, "java/lang/OutOfMemoryError");
- (*jenv)->ThrowNew(jenv, clazz, "Not enough memory");
- return $null;
- }
+SWIGTYPE_p_int array = example.new_intArray(10000000); // Array of 10-million integers
+for (int i=0; i<10000; i++) { // Set some values
+ example.intArray_setitem(array,i,i);
}
-void *malloc(size_t nbytes);
+int sum = example.sumitems(array,10000);
+System.out.println("Sum = " + sum);
</PRE>
</DIV>
-<P> In Java,</P>
+<P> If you replace <TT>%array_functions(int,intp)</TT> by <TT>
+%array_class(int,intp)</TT>, the interface is more class-like and a
+ couple more helper functions are available for casting between the
+ array and the type wrapper class.</P>
<DIV class="code">
<PRE>
-SWIGTYPE_p_void a = example.malloc(2000000000);
+%include "carrays.i"
+%array_class(int, intArray);
</PRE>
</DIV>
-<P> will produce a familiar looking Java exception:</P>
+<P> The <TT>%array_class(type, name)</TT> macro creates wrappers for an
+ unbounded array object that can be passed around as a simple pointer
+ like <TT>int *</TT> or <TT>double *</TT>. For instance, you will be
+ able to do this in Java:</P>
<DIV class="code">
<PRE>
-Exception in thread "main" java.lang.OutOfMemoryError: Not enough memory
- at exampleJNI.malloc(Native Method)
- at example.malloc(example.java:16)
- at runme.main(runme.java:112)
+intArray array = new intArray(10000000); // Array of 10-million integers
+for (int i=0; i<10000; i++) { // Set some values
+ array.setitem(i,i);
+}
+int sum = example.sumitems(array.cast(),10000);
+System.out.println("Sum = " + sum);
</PRE>
</DIV>
-<P> If a library provides some kind of general error handling framework,
- you can also use that. For example:</P>
+<P> The array "object" created by <TT>%array_class()</TT> does not
+ encapsulate pointers inside a special array object. In fact, there is
+ no bounds checking or safety of any kind (just like in C). Because of
+ this, the arrays created by this library are extremely low-level
+ indeed. You can't iterate over them nor can you even query their
+ length. In fact, any valid memory address can be accessed if you want
+ (negative indices, indices beyond the end of the array, etc.). Needless
+ to say, this approach is not going to suit all applications. On the
+ other hand, this low-level approach is extremely efficient and well
+ suited for applications in which you need to create buffers, package
+ binary data, etc.</P>
+<H3><A name="Java_binary_char">25.8.5 Binary data vs Strings</A></H3>
+<P> By default SWIG handles <TT>char *</TT> as a string but there is a
+ handy multi-argument typemap available as mentioned in <A href="#Library_nn10">
+Passing binary data</A>. The following simple example demonstrates using
+ a byte array instead of passing the default string type and length to
+ the wrapped function.</P>
<DIV class="code">
<PRE>
-%exception malloc {
- $action
- if (err_occurred()) {
- jclass clazz = (*jenv)->FindClass(jenv, "java/lang/OutOfMemoryError");
- (*jenv)->ThrowNew(jenv, clazz, "Not enough memory");
- return $null;
- }
+%apply (char *STRING, size_t LENGTH) { (const char data[], size_t len) }
+%inline %{
+void binaryChar1(const char data[], size_t len) {
+ printf("len: %d data: ", len);
+ for (size_t i=0; i<len; ++i)
+ printf("%x ", data[i]);
+ printf("\n");
}
-void *malloc(size_t nbytes);
+%}
</PRE>
</DIV>
-<P> If no declaration name is given to <TT>%exception</TT>, it is
- applied to all wrapper functions. The <TT>$action</TT> is a SWIG
- special variable and is replaced by the C/C++ function call being
- wrapped. The <TT>return $null;</TT> handles all native method return
- types, namely those that have a void return and those that do not. This
- is useful for typemaps that will be used in native method returning all
- return types. See the section on <A href="#Java_special_variables">Java
- special variables</A> for further explanation.</P>
-<P> C++ exceptions are also easy to handle. We can catch the C++
- exception and rethrow it as a Java exception like this:</P>
+<P> Calling from Java requires just the byte array to be passed in as
+ the multi-argument typemap being applied reduces the number of
+ arguments in the target language to one, from the original two:</P>
<DIV class="code">
<PRE>
-%exception getitem {
- try {
- $action
- } catch (std::out_of_range &e) {
- jclass clazz = jenv->FindClass("java/lang/Exception");
- jenv->ThrowNew(clazz, "Range error");
- return $null;
- }
-}
-
-class FooClass {
-public:
- FooClass *getitem(int index); // Might throw std::out_of_range exception
- ...
-};
+byte[] data = "hi\0jk".getBytes();
+example.binaryChar1(data);
</PRE>
</DIV>
-<P> In the example above, <TT>java.lang.Exception</TT> is a checked
- exception class and so ought to be declared in the throws clause of <TT>
-getitem</TT>. Classes can be specified for adding to the throws clause
- using <TT>%javaexception(classes)</TT> instead of <TT>%exception</TT>,
- where <TT>classes</TT> is a string containing one or more comma
- separated Java classes. The <TT>%clearjavaexception</TT> feature is the
- equivalent to <TT>%clearexception</TT> and clears previously declared
- exception handlers. The <TT>%nojavaexception</TT> feature is the
- equivalent to <TT>%noexception</TT> and disables the exception handler.
- See <A href="#Customization_clearing_features">Clearing features</A>
- for the difference on disabling and clearing features.</P>
+<P> resulting in the output</P>
<DIV class="code">
<PRE>
-%javaexception("java.lang.Exception") getitem {
- try {
- $action
- } catch (std::out_of_range &e) {
- jclass clazz = jenv->FindClass("java/lang/Exception");
- jenv->ThrowNew(clazz, "Range error");
- return $null;
- }
-}
-
-class FooClass {
-public:
- FooClass *getitem(int index); // Might throw std::out_of_range exception
- ...
-};
+$ java runme
+len: 5 data: 68 69 0 6a 6b
</PRE>
</DIV>
-<P> The generated proxy method now generates a throws clause containing <TT>
-java.lang.Exception</TT>:</P>
+<H3><A name="Java_heap_allocations">25.8.6 Overriding new and delete to
+ allocate from Java heap</A></H3>
+<P> Unlike some languages supported by SWIG, Java has a true garbage
+ collection subsystem. Other languages will free SWIG wrapped objects
+ when their reference count reaches zero. Java only schedules these
+ objects for finalization, which may not occur for some time. Because
+ SWIG objects are allocated on the C heap, Java users may find the JVM
+ memory use quickly exceeds the assigned limits, as memory fills with
+ unfinalized proxy objects. Forcing garbage collection is clearly an
+ undesirable solution.</P>
+<P> An elegant fix for C++ users is to override new and delete using the
+ following code (here shown included in a SWIG interface file)</P>
<DIV class="code">
<PRE>
-public class FooClass {
- ...
- public FooClass getitem(int index) throws java.lang.Exception { ... }
- ...
+/* File: java_heap.i */
+%module test
+%{
+#include <stdexcept>
+#include "jni.h"
+
+/**
+ * A stash area embedded in each allocation to hold java handles
+ */
+struct Jalloc {
+ jbyteArray jba;
+ jobject ref;
+};
+
+static JavaVM *cached_jvm = 0;
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) {
+ cached_jvm = jvm;
+ return JNI_VERSION_1_2;
+}
+
+static JNIEnv * JNU_GetEnv() {
+ JNIEnv *env;
+ jint rc = cached_jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
+ if (rc == JNI_EDETACHED)
+ throw std::runtime_error("current thread not attached");
+ if (rc == JNI_EVERSION)
+ throw std::runtime_error("jni version not supported");
+ return env;
+}
+
+void * operator new(size_t t) {
+ if (cached_jvm != 0) {
+ JNIEnv *env = JNU_GetEnv();
+ jbyteArray jba = env->NewByteArray((int) t + sizeof(Jalloc));
+ if (env->ExceptionOccurred())
+ throw bad_alloc();
+ void *jbuffer = static_cast<void *>(env->GetByteArrayElements(jba, 0));
+ if (env->ExceptionOccurred())
+ throw bad_alloc();
+ Jalloc *pJalloc = static_cast<Jalloc *>(jbuffer);
+ pJalloc->jba = jba;
+ /* Assign a global reference so byte array will persist until delete'ed */
+ pJalloc->ref = env->NewGlobalRef(jba);
+ if (env->ExceptionOccurred())
+ throw bad_alloc();
+ return static_cast<void *>(static_cast<char *>(jbuffer) + sizeof(Jalloc));
+ }
+ else { /* JNI_OnLoad not called, use malloc and mark as special */
+ Jalloc *pJalloc = static_cast<Jalloc *>(malloc((int) t + sizeof(Jalloc)));
+ if (!pJalloc)
+ throw bad_alloc();
+ pJalloc->ref = 0;
+ return static_cast<void *>(
+ static_cast<char *>(static_cast<void *>(pJalloc)) + sizeof(Jalloc));
+ }
+}
+
+void operator delete(void *v) {
+ if (v != 0) {
+ void *buffer = static_cast<void *>( static_cast<char *>(v) - sizeof(Jalloc));
+ Jalloc *pJalloc = static_cast<Jalloc *>(buffer);
+ if (pJalloc->ref) {
+ JNIEnv *env = JNU_GetEnv();
+ env->DeleteGlobalRef(pJalloc->ref);
+ env->ReleaseByteArrayElements(pJalloc->jba, static_cast<jbyte *>(buffer), 0);
+ }
+ else {
+ free(buffer);
+ }
+ }
}
+%}
+...
</PRE>
</DIV>
-<P> The examples above first use the C JNI calling syntax then the C++
- JNI calling syntax. The C++ calling syntax will not compile as C and
- also vice versa. It is however possible to write JNI calls which will
- compile under both C and C++ and is covered in the <A href="#Java_typemaps_for_c_and_cpp">
-Typemaps for both C and C++ compilation</A> section.</P>
-<P> The language-independent <TT>exception.i</TT> library file can also
- be used to raise exceptions. See the <A href="#Library">SWIG Library</A>
- chapter. The typemap example <A href="#Java_exception_typemap">Handling
- C++ exception specifications as Java exceptions</A> provides further
- exception handling capabilities.</P>
-<H3><A name="Java_method_access"></A>24.7.4 Method access with
- %javamethodmodifiers</H3>
-<P> A Java feature called <TT>%javamethodmodifiers</TT> can be used to
- change the method modifiers from the default <TT>public</TT>. It
- applies to both module class methods and proxy class methods. For
- example:</P>
+<P> This code caches the Java environment during initialization, and
+ when new is called, a Java ByteArray is allocated to provide the SWIG
+ objects with space in the Java heap. This has the combined effect of
+ re-asserting the Java virtual machine's limit on memory allocation, and
+ puts additional pressure on the garbage collection system to run more
+ frequently. This code is made slightly more complicated because
+ allowances must be made if new is called before the JNI_OnLoad is
+ executed. This can happen during static class initialization, for
+ example.</P>
+<P> Unfortunately, because most Java implementations call malloc and
+ free, this solution will not work for C wrapped structures. However,
+ you are free to make functions that allocate and free memory from the
+ Java heap using this model and use these functions in place of malloc
+ and free in your own code.</P>
+<H2><A name="Java_typemaps">25.9 Java typemaps</A></H2>
+<P> This section describes how you can modify SWIG's default wrapping
+ behavior for various C/C++ datatypes using the <TT>%typemap</TT>
+ directive. You are advised to be familiar with the material in the "<A href="#Typemaps">
+Typemaps</A>" chapter. While not absolutely essential knowledge, this
+ section assumes some familiarity with the Java Native Interface (JNI).
+ JNI documentation can be consulted either online at <A href="http://java.sun.com">
+Sun's Java web site</A> or from a good JNI book. The following two books
+ are recommended:</P>
+<UL>
+<LI> Title: 'Essential JNI: Java Native Interface.' Author: Rob Gordon.
+ Publisher: Prentice Hall. ISBN: 0-13-679895-0.</LI>
+<LI> Title: 'The Java Native Interface: Programmer's Guide and
+ Specification.' Author: Sheng Liang. Publisher: Addison-Wesley. ISBN:
+ 0-201-32577-2. Also available <A href="http://java.sun.com/docs/books/jni">
+online</A> at the Sun Developer Network.</LI>
+</UL>
+<P> Before proceeding, it should be stressed that typemaps are not a
+ required part of using SWIG---the default wrapping behavior is enough
+ in most cases. Typemaps are only used if you want to change some aspect
+ of the generated code.</P>
+<H3><A name="Java_default_primitive_type_mappings">25.9.1 Default
+ primitive type mappings</A></H3>
+<P> The following table lists the default type mapping from Java to
+ C/C++.</P>
+<TABLE BORDER summary="Default primitive type mappings">
+<TR><TD><B>C/C++ type</B></TD><TD><B>Java type</B></TD><TD><B>JNI type</B>
+</TD></TR>
+<TR><TD>bool
+<BR> const bool &</TD><TD>boolean</TD><TD>jboolean</TD></TR>
+<TR><TD>char
+<BR>const char &</TD><TD>char</TD><TD>jchar</TD></TR>
+<TR><TD>signed char
+<BR>const signed char &</TD><TD>byte</TD><TD>jbyte</TD></TR>
+<TR><TD>unsigned char
+<BR>const unsigned char &</TD><TD>short</TD><TD>jshort</TD></TR>
+<TR><TD>short
+<BR>const short &</TD><TD>short</TD><TD>jshort</TD></TR>
+<TR><TD>unsigned short
+<BR> const unsigned short &</TD><TD>int</TD><TD>jint</TD></TR>
+<TR><TD>int
+<BR> const int &</TD><TD>int</TD><TD>jint</TD></TR>
+<TR><TD>unsigned int
+<BR> const unsigned int &</TD><TD>long</TD><TD>jlong</TD></TR>
+<TR><TD>long
+<BR>const long &</TD><TD>int</TD><TD>jint</TD></TR>
+<TR><TD>unsigned long
+<BR>const unsigned long &</TD><TD>long</TD><TD>jlong</TD></TR>
+<TR><TD>long long
+<BR> const long long &</TD><TD>long</TD><TD>jlong</TD></TR>
+<TR><TD>unsigned long long
+<BR>const unsigned long long &</TD><TD>java.math.BigInteger</TD><TD>
+jobject</TD></TR>
+<TR><TD>float
+<BR>const float &</TD><TD>float</TD><TD>jfloat</TD></TR>
+<TR><TD>double
+<BR> const double &</TD><TD>double</TD><TD>jdouble</TD></TR>
+<TR><TD>char *
+<BR>char []</TD><TD>String</TD><TD>jstring</TD></TR>
+</TABLE>
+<P> Note that SWIG wraps the C <TT>char</TT> type as a character.
+ Pointers and arrays of this type are wrapped as strings. The <TT>signed
+ char</TT> type can be used if you want to treat <TT>char</TT> as a
+ signed number rather than a character. Also note that all const
+ references to primitive types are treated as if they are passed by
+ value.</P>
+<P> Given the following C function:</P>
<DIV class="code">
<PRE>
-%javamethodmodifiers protect_me() "protected";
-void protect_me();
+void func(unsigned short a, char *b, const long &c, unsigned long long d);
</PRE>
</DIV>
-<P> Will produce the method in the module class with protected access.</P>
+<P> The module class method would be:</P>
<DIV class="code">
<PRE>
-protected static void protect_me() {
- exampleJNI.protect_me();
-}
+public static void func(int a, String b, int c, java.math.BigInteger d) {...}
</PRE>
</DIV>
-<H2><A name="Java_tips_techniques"></A>24.8 Tips and techniques</H2>
-<P> Although SWIG is largely automatic, there are certain types of
- wrapping problems that require additional user input. Examples include
- dealing with output parameters, strings and arrays. This chapter
- discusses the common techniques for solving these problems.</P>
-<H3><A name="Java_input_output_parameters"></A>24.8.1 Input and output
- parameters using primitive pointers and references</H3>
-<P> A common problem in some C programs is handling parameters passed as
- simple pointers or references. For example:</P>
+<P> The intermediary JNI class would use the same types:</P>
<DIV class="code">
<PRE>
-void add(int x, int y, int *result) {
- *result = x + y;
-}
+public final static native void func(int jarg1, String jarg2, int jarg3,
+ java.math.BigInteger jarg4);
</PRE>
</DIV>
-<P> or perhaps</P>
+<P> and the JNI function would look like this:</P>
<DIV class="code">
<PRE>
-int sub(int *x, int *y) {
- return *x-*y;
-}
+SWIGEXPORT void JNICALL Java_exampleJNI_func(JNIEnv *jenv, jclass jcls,
+ jint jarg1, jstring jarg2, jint jarg3, jobject jarg4) {...}
</PRE>
</DIV>
-<P> The <TT>typemaps.i</TT> library file will help in these situations.
- For example:</P>
+<P> The mappings for C <TT>int</TT> and C <TT>long</TT> are appropriate
+ for 32 bit applications which are used in the 32 bit JVMs. There is no
+ perfect mapping between Java and C as Java doesn't support all the
+ unsigned C data types. However, the mappings allow the full range of
+ values for each C type from Java.</P>
+<H3><A name="Java_default_non_primitive_typemaps">25.9.2 Default
+ typemaps for non-primitive types</A></H3>
+<P> The previous section covered the primitive type mappings.
+ Non-primitive types such as classes and structs are mapped using
+ pointers on the C/C++ side and storing the pointer into a Java <TT>long</TT>
+ variable which is held by the proxy class or type wrapper class. This
+ applies whether the type is marshalled as a pointer, by reference or by
+ value. It also applies for any unknown/incomplete types which use type
+ wrapper classes.</P>
+<P> So in summary, the C/C++ pointer to non-primitive types is cast into
+ the 64 bit Java <TT>long</TT> type and therefore the JNI type is a <TT>
+jlong</TT>. The Java type is either the proxy class or type wrapper
+ class.</P>
+<H3><A name="Java_jvm64">25.9.3 Sixty four bit JVMs</A></H3>
+<P> If you are using a 64 bit JVM you may have to override the C long,
+ but probably not C int default mappings. Mappings will be system
+ dependent, for example long will need remapping on Unix LP64 systems
+ (long, pointer 64 bits, int 32 bits), but not on Microsoft 64 bit
+ Windows which will be using a P64 IL32 (pointer 64 bits and int, long
+ 32 bits) model. This may be automated in a future version of SWIG. Note
+ that the Java write once run anywhere philosophy holds true for all
+ pure Java code when moving to a 64 bit JVM. Unfortunately it won't of
+ course hold true for JNI code.</P>
+<H3><A name="Java_what_is_typemap">25.9.4 What is a typemap?</A></H3>
+<P> A typemap is nothing more than a code generation rule that is
+ attached to a specific C datatype. For example, to convert integers
+ from Java to C, you might define a typemap like this:</P>
<DIV class="code">
<PRE>
%module example
-%include "typemaps.i"
-void add(int, int, int *OUTPUT);
-int sub(int *INPUT, int *INPUT);
+%typemap(in) int {
+ $1 = $input;
+ printf("Received an integer : %d\n", $1);
+}
+%inline %{
+extern int fact(int nonnegative);
+%}
</PRE>
</DIV>
-<P> In Java, this allows you to pass simple values. For example:</P>
+<P> Typemaps are always associated with some specific aspect of code
+ generation. In this case, the "in" method refers to the conversion of
+ input arguments to C/C++. The datatype <TT>int</TT> is the datatype to
+ which the typemap will be applied. The supplied C code is used to
+ convert values. In this code a number of special variables prefaced by
+ a <TT>$</TT> are used. The <TT>$1</TT> variable is a placeholder for a
+ local variable of type <TT>int</TT>. The <TT>$input</TT> variable
+ contains the Java data, the JNI <TT>jint</TT> in this case.</P>
+<P> When this example is compiled into a Java module, it can be used as
+ follows:</P>
<DIV class="code">
<PRE>
-int result = example.sub(7,4);
-System.out.println("7 - 4 = " + result);
-int[] sum = {0};
-example.add(3,4,sum);
-System.out.println("3 + 4 = " + sum[0]);
+System.out.println(example.fact(6));
</PRE>
</DIV>
-<P> Which will display:</P>
+<P> and the output will be:</P>
<DIV class="code">
<PRE>
-7 - 4 = 3
-3 + 4 = 7
+Received an integer : 6
+720
</PRE>
</DIV>
-<P> Notice how the <TT>INPUT</TT> parameters allow integer values to be
- passed instead of pointers and how the <TT>OUTPUT</TT> parameter will
- return the result in the first element of the integer array.</P>
-<P> If you don't want to use the names <TT>INPUT</TT> or <TT>OUTPUT</TT>
-, use the <TT>%apply</TT> directive. For example:</P>
+<P> In this example, the typemap is applied to all occurrences of the <TT>
+int</TT> datatype. You can refine this by supplying an optional
+ parameter name. For example:</P>
<DIV class="code">
<PRE>
%module example
-%include "typemaps.i"
-%apply int *OUTPUT { int *result };
-%apply int *INPUT { int *x, int *y};
+%typemap(in) int nonnegative {
+ $1 = $input;
+ printf("Received an integer : %d\n", $1);
+}
-void add(int x, int y, int *result);
-int sub(int *x, int *y);
+%inline %{
+extern int fact(int nonnegative);
+%}
</PRE>
</DIV>
-<P> If a function mutates one of its parameters like this,</P>
+<P> In this case, the typemap code is only attached to arguments that
+ exactly match <TT>int nonnegative</TT>.</P>
+<P> The application of a typemap to specific datatypes and argument
+ names involves more than simple text-matching--typemaps are fully
+ integrated into the SWIG C++ type-system. When you define a typemap for
+ <TT>int</TT>, that typemap applies to <TT>int</TT> and qualified
+ variations such as <TT>const int</TT>. In addition, the typemap system
+ follows <TT>typedef</TT> declarations. For example:</P>
<DIV class="code">
<PRE>
-void negate(int *x) {
- *x = -(*x);
+%typemap(in) int nonnegative {
+ $1 = $input;
+ printf("Received an integer : %d\n", $1);
}
+%inline %{
+typedef int Integer;
+extern int fact(Integer nonnegative); // Above typemap is applied
+%}
</PRE>
</DIV>
-<P> you can use <TT>INOUT</TT> like this:</P>
+<P> However, the matching of <TT>typedef</TT> only occurs in one
+ direction. If you defined a typemap for <TT>Integer</TT>, it is not
+ applied to arguments of type <TT>int</TT>.</P>
+<P> Typemaps can also be defined for groups of consecutive arguments.
+ For example:</P>
<DIV class="code">
<PRE>
-%include "typemaps.i"
+%typemap(in) (char *str, int len) {
...
-void negate(int *INOUT);
+};
+
+int count(char c, char *str, int len);
</PRE>
</DIV>
-<P> In Java, the input parameter is the first element in a 1 element
- array and is replaced by the output of the function. For example:</P>
+<P> When a multi-argument typemap is defined, the arguments are always
+ handled as a single Java parameter. This allows the function to be used
+ like this (notice how the length parameter is omitted):</P>
<DIV class="code">
<PRE>
-int[] neg = {3};
-example.negate(neg);
-System.out.println("Negative of 3 = " + neg[0]);
+int c = example.count('e',"Hello World");
</PRE>
</DIV>
-<P> And no prizes for guessing the output:</P>
+<H3><A name="Java_typemaps_c_to_java_types">25.9.5 Typemaps for mapping
+ C/C++ types to Java types</A></H3>
+<P> The typemaps available to the Java module include the common
+ typemaps listed in the main typemaps section. There are a number of
+ additional typemaps which are necessary for using SWIG with Java. The
+ most important of these implement the mapping of C/C++ types to Java
+ types:</P>
+<BR>
+<TABLE BORDER summary="Typemap mappings for C/C++ types to Java types">
+<TR><TD><B>Typemap</B></TD><TD><B>Description</B></TD></TR>
+<TR><TD>jni</TD><TD>JNI C types. These provide the default mapping of
+ types from C/C++ to JNI for use in the JNI (C/C++) code.</TD></TR>
+<TR><TD>jtype</TD><TD>Java intermediary types. These provide the default
+ mapping of types from C/C++ to Java for use in the native functions in
+ the intermediary JNI class. The type must be the equivalent Java type
+ for the JNI C type specified in the "jni" typemap.</TD></TR>
+<TR><TD>jstype</TD><TD>Java types. These provide the default mapping of
+ types from C/C++ to Java for use in the Java module class, proxy
+ classes and type wrapper classes.</TD></TR>
+<TR><TD>javain</TD><TD>Conversion from jstype to jtype. These are Java
+ code typemaps which transform the type used in the Java module class,
+ proxy classes and type wrapper classes (as specified in the "jstype"
+ typemap) to the type used in the Java intermediary JNI class (as
+ specified in the "jtype" typemap). In other words the typemap provides
+ the conversion to the native method call parameter types.</TD></TR>
+<TR><TD>javaout</TD><TD>Conversion from jtype to jstype. These are Java
+ code typemaps which transform the type used in the Java intermediary
+ JNI class (as specified in the "jtype" typemap) to the Java type used
+ in the Java module class, proxy classes and type wrapper classes (as
+ specified in the "jstype" typemap). In other words the typemap provides
+ the conversion from the native method call return type.</TD></TR>
+<TR><TD>javadirectorin</TD><TD>Conversion from jtype to jstype for
+ director methods. These are Java code typemaps which transform the type
+ used in the Java intermediary JNI class (as specified in the "jtype"
+ typemap) to the Java type used in the Java module class, proxy classes
+ and type wrapper classes (as specified in the "jstype" typemap). This
+ typemap provides the conversion for the parameters in the director
+ methods when calling up from C++ to Java. See <A href="#Java_directors_typemaps">
+Director typemaps</A>.</TD></TR>
+<TR><TD>javadirectorout</TD><TD>Conversion from jstype to jtype for
+ director methods. These are Java code typemaps which transform the type
+ used in the Java module class, proxy classes and type wrapper classes
+ (as specified in the "jstype" typemap) to the type used in the Java
+ intermediary JNI class (as specified in the "jtype" typemap). This
+ typemap provides the conversion for the return type in the director
+ methods when returning from the C++ to Java upcall. See <A href="#Java_directors_typemaps">
+Director typemaps</A>.</TD></TR>
+<TR><TD>directorin</TD><TD>Conversion from C++ type to jni type for
+ director methods. These are C++ typemaps which convert the parameters
+ used in the C++ director method to the appropriate JNI intermediary
+ type. The conversion is done in JNI code prior to calling the Java
+ function from the JNI code. See <A href="#Java_directors_typemaps">
+Director typemaps</A>.</TD></TR>
+<TR><TD>directorout</TD><TD>Conversion from jni type to C++ type for
+ director methods. These are C++ typemaps which convert the JNI return
+ type used in the C++ director method to the appropriate C++ return
+ type. The conversion is done in JNI code after calling the Java
+ function from the JNI code. See <A href="#Java_directors_typemaps">
+Director typemaps</A>.</TD></TR>
+</TABLE>
+<P> If you are writing your own typemaps to handle a particular type,
+ you will normally have to write a collection of them. The default
+ typemaps are in "<TT>java.swg</TT>" and so might be a good place for
+ finding typemaps to base any new ones on.</P>
+<P> The "jni", "jtype" and "jstype" typemaps are usually defined
+ together to handle the Java to C/C++ type mapping. An "in" typemap
+ should be accompanied by a "javain" typemap and likewise an "out"
+ typemap by a "javaout" typemap. If an "in" typemap is written, a
+ "freearg" and "argout" typemap may also need to be written as some
+ types have a default "freearg" and/or "argout" typemap which may need
+ overriding. The "freearg" typemap sometimes releases memory allocated
+ by the "in" typemap. The "argout" typemap sometimes sets values in
+ function parameters which are passed by reference in Java.</P>
+<P> Note that the "in" typemap marshals the JNI type held in the "jni"
+ typemap to the real C/C++ type and for the opposite direction, the
+ "out" typemap marshals the real C/C++ type to the JNI type held in the
+ "jni" typemap. For <A href="#Java_default_non_primitive_typemaps">
+non-primitive types</A> the "in" and "out" typemaps are responsible for
+ casting between the C/C++ pointer and the 64 bit <TT>jlong</TT> type.
+ There is no portable way to cast a pointer into a 64 bit integer type
+ and the approach taken by SWIG is mostly portable, but breaks C/C++
+ aliasing rules. In summary, these rules state that a pointer to any
+ type must never be dereferenced by a pointer to any other incompatible
+ type. The following code snippet might aid in understand aliasing rules
+ better:</P>
<DIV class="code">
<PRE>
-Negative of 3 = -3
+ short a;
+ short* pa = 0;
+ int i = 0x1234;
+
+ a = (short)i; /* okay */
+ a = *(short*)&i; /* breaks aliasing rules */
</PRE>
</DIV>
-<P> These typemaps can also be applied to C++ references. The above
- examples would work the same if they had been defined using references
- instead of pointers. For example, the Java code to use the <TT>negate</TT>
- function would be the same if it were defined either as it is above:</P>
+<P> An email posting, <A href="http://mail-index.netbsd.org/tech-kern/2003/08/11/0001.html">
+Aliasing, pointer casts and gcc 3.3</A> elaborates further on the
+ subject. In SWIG, the "in" and "out" typemaps for pointers are
+ typically</P>
<DIV class="code">
<PRE>
-void negate(int *INOUT);
+ %typemap(in) struct Foo * %{
+ $1 = *(struct Foo **)&$input; /* cast jlong into C ptr */
+ %}
+ %typemap(out) struct Bar * %{
+ *(struct Bar **)&$result = $1; /* cast C ptr into jlong */
+ %}
+ struct Bar {...};
+ struct Foo {...};
+ struct Bar * FooBar(struct Foo *f);
</PRE>
</DIV>
-<P> or using a reference:</P>
+<P> resulting in the following code which breaks the aliasing rules:</P>
<DIV class="code">
<PRE>
-void negate(int &INOUT);
+SWIGEXPORT jlong JNICALL Java_exampleJNI_FooBar(JNIEnv *jenv, jclass jcls,
+ jlong jarg1, jobject jarg1_) {
+ jlong jresult = 0 ;
+ struct Foo *arg1 = (struct Foo *) 0 ;
+ struct Bar *result = 0 ;
+
+ (void)jenv;
+ (void)jcls;
+ (void)jarg1_;
+ arg1 = *(struct Foo **)&jarg1;
+ result = (struct Bar *)FooBar(arg1);
+ *(struct Bar **)&jresult = result;
+ return jresult;
+}
</PRE>
</DIV>
-<P> Note: Since most Java primitive types are immutable and are passed
- by value, it is not possible to perform in-place modification of a type
- passed as a parameter.</P>
-<P> Be aware that the primary purpose of the <TT>typemaps.i</TT> file is
- to support primitive datatypes. Writing a function like this</P>
+<P> If you are using gcc as your C compiler, you might get a
+ "dereferencing type-punned pointer will break strict-aliasing rules"
+ warning about this. Please see <A href="#Java_compiling_dynamic">
+Compiling a dynamic module</A> to avoid runtime problems with these
+ strict aliasing rules.</P>
+<P> The default code generated by SWIG for the Java module comes from
+ the typemaps in the "<TT>java.swg</TT>" library file which implements
+ the <A href="#Java_default_primitive_type_mappings">Default primitive
+ type mappings</A> and <A href="#Java_default_non_primitive_typemaps">
+Default typemaps for non-primitive types</A> covered earlier. There are
+ other type mapping typemaps in the Java library. These are listed
+ below:</P>
+<BR>
+<TABLE BORDER summary="Java library typemap mappings">
+<TR VALIGN="TOP"><TD><B>C Type</B></TD><TD><B>Typemap</B></TD><TD><B>
+File</B></TD><TD><B>Kind</B></TD><TD><B>Java Type</B></TD><TD><B>
+Function</B></TD></TR>
+<TR><TD>primitive pointers and references</TD><TD>INPUT</TD><TD>
+typemaps.i</TD><TD>input</TD><TD>Java basic types</TD><TD>Allows values
+ to be used for C functions taking pointers for data input.</TD></TR>
+<TR><TD>primitive pointers and references</TD><TD>OUTPUT</TD><TD>
+typemaps.i</TD><TD>output</TD><TD>Java basic type arrays</TD><TD>Allows
+ values held within an array to be used for C functions taking pointers
+ for data output.</TD></TR>
+<TR><TD>primitive pointers and references</TD><TD>INOUT</TD><TD>
+typemaps.i</TD><TD>input
+<BR>output</TD><TD>Java basic type arrays</TD><TD>Allows values held
+ within an array to be used for C functions taking pointers for data
+ input and output.</TD></TR>
+<TR><TD>string
+<BR> wstring</TD><TD>[unnamed]</TD><TD>std_string.i</TD><TD>input
+<BR> output</TD><TD>String</TD><TD>Use for std::string mapping to Java
+ String.</TD></TR>
+<TR><TD>arrays of primitive types</TD><TD>[unnamed]</TD><TD>
+arrays_java.i</TD><TD>input
+<BR> output</TD><TD>arrays of primitive Java types</TD><TD>Use for
+ mapping C arrays to Java arrays.</TD></TR>
+<TR><TD>arrays of classes/structs/unions</TD><TD>JAVA_ARRAYSOFCLASSES
+ macro</TD><TD>arrays_java.i</TD><TD>input
+<BR> output</TD><TD>arrays of proxy classes</TD><TD>Use for mapping C
+ arrays to Java arrays.</TD></TR>
+<TR><TD>arrays of enums</TD><TD>ARRAYSOFENUMS</TD><TD>arrays_java.i</TD><TD>
+input
+<BR> output</TD><TD>int[]</TD><TD>Use for mapping C arrays to Java
+ arrays (typeunsafe and simple enum wrapping approaches only).</TD></TR>
+<TR VALIGN="TOP"><TD>char *</TD><TD>BYTE</TD><TD>various.i</TD><TD>input</TD><TD>
+byte[]</TD><TD VALIGN="TOP">Java byte array is converted to char array</TD>
+</TR>
+<TR><TD>char **</TD><TD>STRING_ARRAY</TD><TD>various.i</TD><TD>input
+<BR> output</TD><TD>String[]</TD><TD>Use for mapping NULL terminated
+ arrays of C strings to Java String arrays</TD></TR>
+<TR><TD>unsigned char *</TD><TD>NIOBUFFER</TD><TD>various.i</TD><TD>
+input
+<BR> output</TD><TD>java.nio.Buffer</TD><TD>Use for mapping directly
+ allocated buffers to c/c++. useful with directors and long lived memory
+ objects</TD></TR>
+</TABLE>
+<H3><A name="Java_typemap_attributes">25.9.6 Java typemap attributes</A></H3>
+<P> There are a few additional typemap attributes that the Java module
+ supports.</P>
+<P> The first of these is the 'throws' attribute. The throws attribute
+ is optional and specified after the typemap name and contains one or
+ more comma separated classes for adding to the throws clause for any
+ methods that use that typemap. It is analogous to the <A href="#Java_exception_handling">
+%javaexception</A> feature's throws attribute.</P>
<DIV class="code">
<PRE>
-void foo(Bar *OUTPUT);
+%typemap(typemapname, throws="ExceptionClass1, ExceptionClass2") type { ... }
</PRE>
</DIV>
-<P> will not have the intended effect since <TT>typemaps.i</TT> does not
- define an OUTPUT rule for <TT>Bar</TT>.</P>
-<H3><A name="Java_simple_pointers"></A>24.8.2 Simple pointers</H3>
-<P> If you must work with simple pointers such as <TT>int *</TT> or <TT>
-double *</TT> another approach to using <TT>typemaps.i</TT> is to use
- the <TT>cpointer.i</TT> pointer library file. For example:</P>
+<P> The attribute is necessary for supporting Java checked exceptions
+ and can be added to just about any typemap. The list of typemaps
+ include all the C/C++ (JNI) typemaps in the "<A href="#Typemaps">
+Typemaps</A>" chapter and the Java specific typemaps listed in <A href="#Java_typemaps_c_to_java_types">
+the previous section</A>, barring the "jni", "jtype" and "jstype"
+ typemaps as they could never contain code to throw an exception.</P>
+<P> The throws clause is generated for the proxy method as well as the
+ JNI method in the JNI intermediary class. If a method uses more than
+ one typemap and each of those typemaps have classes specified in the
+ throws clause, the union of the exception classes is added to the
+ throws clause ensuring there are no duplicate classes. See the <A href="#Java_nan_exception_typemap">
+NaN exception example</A> for further usage.</P>
+<P> The "jtype" typemap has the optional 'nopgcpp' attribute which can
+ be used to suppress the generation of the <A href="#Java_pgcpp">
+premature garbage collection prevention parameter</A>.</P>
+<P> The "javain" typemap has the optional 'pre', 'post' and 'pgcppname'
+ attributes. These are used for generating code before and after the JNI
+ call in the proxy class or module class. The 'pre' attribute contains
+ code that is generated before the JNI call and the 'post' attribute
+ contains code generated after the JNI call. The 'pgcppname' attribute
+ is used to change the <A href="#Java_pgcpp">premature garbage
+ collection prevention parameter</A> name passed to the JNI function.
+ This is sometimes needed when the 'pre' typemap creates a temporary
+ variable which is then passed to the JNI function.</P>
+<P> <A name="Java_constructor_helper_function"></A> Note that when the
+ 'pre' or 'post' attributes are specified and the associated type is
+ used in a constructor, a constructor helper function is generated. This
+ is necessary as the Java proxy constructor wrapper makes a call to a
+ support constructor using a<I> this</I> call. In Java the<I> this</I>
+ call must be the first statement in the constructor body. The
+ constructor body thus calls the helper function and the helper function
+ instead makes the JNI call, ensuring the 'pre' code is called before
+ the JNI call is made. There is a <A href="#Java_date_marshalling">Date
+ marshalling</A> example showing 'pre', 'post' and 'pgcppname'
+ attributes in action.</P>
+<H3><A name="Java_special_variables">25.9.7 Java special variables</A></H3>
+<P> The standard SWIG special variables are available for use within
+ typemaps as described in the <A href="#Typemaps">Typemaps documentation</A>
+, for example <TT>$1</TT>, <TT>$input</TT>,<TT>$result</TT> etc.</P>
+<P> The Java module uses a few additional special variables:</P>
+<P><B> <TT>$javaclassname</TT></B>
+<BR> This special variable works like the other <A href="#Typemaps_special_variables">
+special variables</A> and <TT>$javaclassname</TT> is similar to <TT>
+$1_type</TT>. It expands to the class name for use in Java given a
+ pointer. SWIG wraps unions, structs and classes using pointers and in
+ this case it expands to the Java proxy class name. For example, <TT>
+$javaclassname</TT> is replaced by the proxy classname <TT>Foo</TT> when
+ wrapping a <TT>Foo *</TT> and <TT>$&javaclassname</TT> expands to the
+ proxy classname when wrapping the C/C++ type <TT>Foo</TT> and <TT>
+$*javaclassname</TT> expands to the proxy classname when wrapping <TT>
+Foo *&</TT>. If the type does not have an associated proxy class, it
+ expands to the type wrapper class name, for example, <TT>
+SWIGTYPE_p_unsigned_short</TT> is generated when wrapping <TT>unsigned
+ short *</TT>. The class name is fully qualified with the package name
+ when using the <A href="#SWIGPlus_nspace">nspace feature</A>.</P>
+<P><B> <TT>$javaclazzname</TT></B>
+<BR> This special variable works like <TT>$javaclassname</TT>, but
+ expands the fully qualified C++ class into the package name, if used by
+ the <A href="#SWIGPlus_nspace">nspace feature</A>, and the proxy class
+ name, mangled for use as a function name. For example, <TT>
+Namespace1::Namespace2::Klass</TT> is expanded into <TT>
+Namespace1_Namespace2_Klass_</TT>. This special variable is usually used
+ for making calls to a function in the intermediary JNI class, as they
+ are mangled with this prefix.</P>
+<P><B> <TT>$null</TT></B>
+<BR> Used in input typemaps to return early from JNI functions that have
+ either void or a non-void return type. Example:</P>
<DIV class="code">
<PRE>
-%module example
-%include "cpointer.i"
-
-%inline %{
-extern void add(int x, int y, int *result);
+%typemap(check) int * %{
+ if (error) {
+ SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array element error");
+ return $null;
+ }
%}
-
-%pointer_functions(int, intp);
-</PRE>
-</DIV>
-<P> The <TT>%pointer_functions(type,name)</TT> macro generates five
- helper functions that can be used to create, destroy, copy, assign, and
- dereference a pointer. In this case, the functions are as follows:</P>
-<DIV class="code">
-<PRE>
-int *new_intp();
-int *copy_intp(int *x);
-void delete_intp(int *x);
-void intp_assign(int *x, int value);
-int intp_value(int *x);
-</PRE>
-</DIV>
-<P> In Java, you would use the functions like this:</P>
-<DIV class="code">
-<PRE>
-SWIGTYPE_p_int intPtr = example.new_intp();
-example.add(3,4,intPtr);
-int result = example.intp_value(intPtr);
-System.out.println("3 + 4 = " + result);
-</PRE>
-</DIV>
-<P> If you replace <TT>%pointer_functions(int,intp)</TT> by <TT>
-%pointer_class(int,intp)</TT>, the interface is more class-like.</P>
-<DIV class="code">
-<PRE>
-intp intPtr = new intp();
-example.add(3,4,intPtr.cast());
-int result = intPtr.value();
-System.out.println("3 + 4 = " + result);
</PRE>
</DIV>
-<P> See the <A href="#Library">SWIG Library</A> chapter for further
- details.</P>
-<H3><A name="Java_c_arrays"></A>24.8.3 Wrapping C arrays with Java
- arrays</H3>
-<P> SWIG can wrap arrays in a more natural Java manner than the default
- by using the <TT>arrays_java.i</TT> library file. Let's consider an
- example:</P>
+<P> If the typemap gets put into a function with void as return, $null
+ will expand to nothing:</P>
<DIV class="code">
<PRE>
-%include "arrays_java.i";
-int array[4];
-void populate(int x[]) {
- int i;
- for (i=0; i<4; i++)
- x[i] = 100 + i;
+SWIGEXPORT void JNICALL Java_jnifn(...) {
+ if (error) {
+ SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array element error");
+ return ;
+ }
+ ...
}
</PRE>
</DIV>
-<P> These one dimensional arrays can then be used as if they were Java
- arrays:</P>
+<P> otherwise $null expands to<I> NULL</I></P>
<DIV class="code">
<PRE>
-int[] array = new int[4];
-example.populate(array);
-
-System.out.print("array: ");
-for (int i=0; i<array.length; i++)
- System.out.print(array[i] + " ");
-
-example.setArray(array);
-
-int[] global_array = example.getArray();
-
-System.out.print("\nglobal_array: ");
-for (int i=0; i<array.length; i++)
- System.out.print(global_array[i] + " ");
+SWIGEXPORT jobject JNICALL Java_jnifn(...) {
+ if (error) {
+ SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array element error");
+ return NULL;
+ }
+ ...
+}
</PRE>
</DIV>
-<P> Java arrays are always passed by reference, so any changes a
- function makes to the array will be seen by the calling function. Here
- is the output after running this code:</P>
+<P><B> <TT>$javainput, $jnicall and $owner</TT></B>
+<BR> The $javainput special variable is used in "javain" typemaps and
+ $jnicall and $owner are used in "javaout" typemaps. $jnicall is
+ analogous to $action in %exception. It is replaced by the call to the
+ native method in the intermediary JNI class. $owner is replaced by
+ either <TT>true</TT> if %newobject has been used, otherwise <TT>false</TT>
+. $javainput is analogous to the $input special variable. It is replaced
+ by the parameter name.</P>
+<P> Here is an example:</P>
<DIV class="code">
<PRE>
-array: 100 101 102 103
-global_array: 100 101 102 103
+%typemap(javain) Class "Class.getCPtr($javainput)"
+%typemap(javain) unsigned short "$javainput"
+%typemap(javaout) Class * {
+ return new Class($jnicall, $owner);
+ }
+
+%inline %{
+ class Class {...};
+ Class * bar(Class cls, unsigned short ush) { return new Class(); };
+%}
</PRE>
</DIV>
-<P> Note that for assigning array variables the length of the C variable
- is used, so it is possible to use a Java array that is bigger than the
- C code will cope with. Only the number of elements in the C array will
- be used. However, if the Java array is not large enough then you are
- likely to get a segmentation fault or access violation, just like you
- would in C. When arrays are used in functions like <TT>populate</TT>,
- the size of the C array passed to the function is determined by the
- size of the Java array.</P>
-<P> Please be aware that the typemaps in this library are not efficient
- as all the elements are copied from the Java array to a C array
- whenever the array is passed to and from JNI code. There is an
- alternative approach using the SWIG array library and this is covered
- in the next section.</P>
-<H3><A name="Java_unbounded_c_arrays"></A>24.8.4 Unbounded C Arrays</H3>
-<P> Sometimes a C function expects an array to be passed as a pointer.
- For example,</P>
+<P> The generated proxy code is then:</P>
<DIV class="code">
<PRE>
-int sumitems(int *first, int nitems) {
- int i, sum = 0;
- for (i = 0; i < nitems; i++) {
- sum += first[i];
- }
- return sum;
+public static Class bar(Class cls, int ush) {
+ return new Class(exampleJNI.bar(Class.getCPtr(cls), cls, ush), false);
}
</PRE>
</DIV>
-<P> One of the ways to wrap this is to apply the Java array typemaps
- that come in the <TT>arrays_java.i</TT> library file:</P>
+<P> Here $javainput has been replaced by <TT>cls</TT> and <TT>ush</TT>.
+ $jnicall has been replaced by the native method call, <TT>
+exampleJNI.bar(...)</TT> and $owner has been replaced by <TT>false</TT>.
+ If %newobject is used by adding the following at the beginning of our
+ example:</P>
<DIV class="code">
<PRE>
-%include "arrays_java.i"
-%apply int[] {int *};
+%newobject bar(Class cls, unsigned short ush);
</PRE>
</DIV>
-<P> The <TT>ANY</TT> size will ensure the typemap is applied to arrays
- of all sizes. You could narrow the typemap matching rules by specifying
- a particular array size. Now you can use a pure Java array and pass it
- to the C code:</P>
+<P> The generated code constructs the return type using <TT>true</TT>
+ indicating the proxy class <TT>Class</TT> is responsible for destroying
+ the C++ memory allocated for it in <TT>bar</TT>:</P>
<DIV class="code">
<PRE>
-int[] array = new int[10000000]; // Array of 10-million integers
-for (int i=0; i<array.length; i++) { // Set some values
- array[i] = i;
+public static Class bar(Class cls, int ush) {
+ return new Class(exampleJNI.bar(Class.getCPtr(cls), cls, ush), true);
}
-int sum = example.sumitems(array,10000);
-System.out.println("Sum = " + sum);
</PRE>
</DIV>
-<P> and the sum would be displayed:</P>
+<P><B> <TT>$static</TT></B>
+<BR> This special variable expands to either<I> static</I> or nothing
+ depending on whether the class is an inner Java class or not. It is
+ used in the "javaclassmodifiers" typemap so that global classes can be
+ wrapped as Java proxy classes and nested C++ classes/enums can be
+ wrapped with the Java equivalent, that is, static inner proxy classes.</P>
+<P><B> <TT>$error, $jniinput, $javacall and $packagepath</TT></B>
+<BR> These special variables are used in the directors typemaps. See <A href="#Java_directors_typemaps">
+Director specific typemaps</A> for details.</P>
+<P><B> <TT>$module</TT></B>
+<BR> This special variable expands to the module name, as specified by <TT>
+%module</TT> or the <TT>-module</TT> commandline option.</P>
+<P><B> <TT>$imclassname</TT></B>
+<BR> This special variable expands to the intermediary class name.
+ Usually this is the same as '$moduleJNI', unless the jniclassname
+ attribute is specified in the <A href="#Java_module_directive">%module
+ directive</A>.</P>
+<P><B> <TT>$javainterfacename</TT></B>
+<BR> This special variable is only expanded when the <TT>interface</TT>
+ feature is applied to a class. It works much like <TT>$javaclassname</TT>
+, but instead of expanding to the proxy classname, it expands to the
+ value in the <TT>name</TT> attribute in the <TT>interface</TT> feature.
+ For example:</P>
<DIV class="code">
<PRE>
-Sum = 49995000
+%feature("interface", name="MyInterface") MyClass;
+%typemap(jstype) MyClass "$&javainterfacename"
+%typemap(jstype) MyClass * "$javainterfacename"
</PRE>
</DIV>
-<P> This approach is probably the most natural way to use arrays.
- However, it suffers from performance problems when using large arrays
- as a lot of copying of the elements occurs in transferring the array
- from the Java world to the C++ world. An alternative approach to using
- Java arrays for C arrays is to use an alternative SWIG library file <TT>
-carrays.i</TT>. This approach can be more efficient for large arrays as
- the array is accessed one element at a time. For example:</P>
+<P> will result in the <TT>jstype</TT> typemap expanding to <TT>
+MyInterface</TT> for both <TT>MyClass</TT> and <TT>MyClass *</TT>. The
+ interface name is fully qualified with the package name when using the <A
+href="#SWIGPlus_nspace">nspace feature</A>.</P>
+<P><B> <TT>$interfacename</TT></B>
+<BR> This special variable is only expanded when the <TT>interface</TT>
+ feature is applied to a class. It expands to just the interface name
+ and is thus different to <TT>$javainterfacename</TT> in that it is not
+ fully qualified with the package name when using the <A href="#SWIGPlus_nspace">
+nspace feature</A>.</P>
+<H3><A name="Java_typemaps_for_c_and_cpp">25.9.8 Typemaps for both C and
+ C++ compilation</A></H3>
+<P> JNI calls must be written differently depending on whether the code
+ is being compiled as C or C++. For example C compilation requires the
+ pointer to a function pointer struct member syntax like</P>
<DIV class="code">
<PRE>
-%include "carrays.i"
-%array_functions(int, intArray);
+const jclass clazz = (*jenv)->FindClass(jenv, "java/lang/String");
</PRE>
</DIV>
-<P> The <TT>%array_functions(type,name)</TT> macro generates four helper
- functions that can be used to create and destroy arrays and operate on
- elements. In this case, the functions are as follows:</P>
+<P> whereas C++ code compilation of the same function call is a member
+ function call using a class pointer like</P>
<DIV class="code">
<PRE>
-int *new_intArray(int nelements);
-void delete_intArray(int *x);
-int intArray_getitem(int *x, int index);
-void intArray_setitem(int *x, int index, int value);
+const jclass clazz = jenv->FindClass("java/lang/String");
</PRE>
</DIV>
-<P> In Java, you would use the functions like this:</P>
+<P> To enable typemaps to be used for either C or C++ compilation, a set
+ of JCALLx macros have been defined in Lib/java/javahead.swg, where x is
+ the number of arguments in the C++ version of the JNI call. The above
+ JNI calls would be written in a typemap like this</P>
<DIV class="code">
<PRE>
-SWIGTYPE_p_int array = example.new_intArray(10000000); // Array of 10-million integers
-for (int i=0; i<10000; i++) { // Set some values
- example.intArray_setitem(array,i,i);
-}
-int sum = example.sumitems(array,10000);
-System.out.println("Sum = " + sum);
+const jclass clazz = JCALL1(FindClass, jenv, "java/lang/String");
</PRE>
</DIV>
-<P> If you replace <TT>%array_functions(int,intp)</TT> by <TT>
-%array_class(int,intp)</TT>, the interface is more class-like and a
- couple more helper functions are available for casting between the
- array and the type wrapper class.</P>
+<P> Note that the SWIG preprocessor expands these into the appropriate C
+ or C++ JNI calling convention. The C calling convention is emitted by
+ default and the C++ calling convention is emitted when using the -c++
+ SWIG commandline option. If you do not intend your code to be targeting
+ both C and C++ then your typemaps can use the appropriate JNI calling
+ convention and need not use the JCALLx macros.</P>
+<H3><A name="Java_code_typemaps">25.9.9 Java code typemaps</A></H3>
+<P> Most of SWIG's typemaps are used for the generation of C/C++ code.
+ The typemaps in this section are used solely for the generation of Java
+ code. Elements of proxy classes and type wrapper classes come from the
+ following typemaps (the defaults).</P>
+<P><TT>%typemap(javabase)</TT></P>
+<DIV class="indent"> base (extends) for Java class: empty default
+<BR> Note that this typemap accepts a <TT>replace</TT> attribute as an
+ optional flag. When set to "1", it will replace/override any C++ base
+ classes that might have been parsed. If this flag is not specified and
+ there are C++ base classes, then a multiple inheritance warning is
+ issued and the code in the typemap is ignored. The typemap also accepts
+ a <TT>notderived</TT> attribute as an optional flag. When set to "1",
+ it will not apply to classes that are derived from a C++ base. When
+ used with the SWIGTYPE type, it is useful for giving a common base for
+ all proxy classes, that is, providing a base class that sits in between
+ all proxy classes and the Java base class <TT>Object</TT> for example: <TT>
+%typemap(javabase, notderived="1") SWIGTYPE "CommonBase"</TT>.</DIV>
+<P><TT>%typemap(javabody)</TT></P>
+<DIV class="indent"> the essential support body for proxy classes (proxy
+ base classes only), typewrapper classes and enum classes. Default
+ contains extra constructors, memory ownership control member variables
+ (<TT>swigCMemOwn</TT>, <TT>swigCPtr</TT>), the <TT>getCPtr</TT> method
+ etc.</DIV>
+<P><TT>%typemap(javabody_derived)</TT></P>
+<DIV class="indent"> the essential support body for proxy classes
+ (derived classes only). Same as "javabody" typemap, but only used for
+ proxy derived classes.</DIV>
+<P><TT>%typemap(javaclassmodifiers)</TT></P>
+<DIV class="indent"> class modifiers for the Java class: default is
+ "public class"</DIV>
+<P><TT>%typemap(javacode)</TT></P>
+<DIV class="indent"> Java code is copied verbatim to the Java class:
+ empty default</DIV>
+<P><TT>%typemap(javadestruct, methodname="delete",
+ methodmodifiers="public synchronized")</TT>
+<BR></P>
+<DIV class="indent"> destructor wrapper - the <TT>delete()</TT> method
+ (proxy classes only), used for all proxy classes except those which
+ have a base class : default calls C++ destructor (or frees C memory)
+ and resets <TT>swigCPtr</TT> and <TT>swigCMemOwn</TT> flags
+<BR>
+<BR> Note that the <TT>delete()</TT> method name is configurable and is
+ specified by the <TT>methodname</TT> attribute. The method modifiers
+ are also configurable via the <TT>methodmodifiers</TT> attribute.</DIV>
+<P><TT>%typemap(javadestruct_derived, methodname="delete",
+ methodmodifiers="public synchronized")</TT></P>
+<DIV class="indent"> destructor wrapper - the <TT>delete()</TT> method
+ (proxy classes only), same as "javadestruct" but only used for derived
+ proxy classes : default calls C++ destructor (or frees C memory) and
+ resets <TT>swigCPtr</TT> and <TT>swigCMemOwn</TT> flags
+<BR>
+<BR> Note that the <TT>delete()</TT> method name is configurable and is
+ specified by the <TT>methodname</TT> attribute. The method modifiers
+ are also configurable via the <TT>methodmodifiers</TT> attribute.</DIV>
+<P><TT>%typemap(javaimports)</TT></P>
+<DIV class="indent"> import statements for Java class: empty default</DIV>
+<P><TT>%typemap(javainterfaces)</TT></P>
+<DIV class="indent"> interfaces (implements) for Java class: empty
+ default</DIV>
+<P><TT>%typemap(javafinalize)</TT></P>
+<DIV class="indent"> the <TT>finalize()</TT> method (proxy classes
+ only): default calls the <TT>delete()</TT> method
+<P> Note that the default javafinalize typemap must contain the full
+ implementation of the finalize method. Any customization to this
+ typemap must still declare a java finalize method with the correct
+ signature. Note also that the name of the generated "delete" method may
+ be affected by <TT>javadestruct</TT> and <TT>javadestruct_derived</TT>
+ typemaps. Below shows an example modifying the finalizer, assuming the <TT>
+delete</TT> method has been renamed to <TT>swig_delete</TT>.</P>
<DIV class="code">
<PRE>
-%include "carrays.i"
-%array_class(int, intArray);
+%typemap(javafinalize) SWIGTYPE %{
+ protected void finalize() {
+ swig_delete(); // renamed to prevent conflict with existing delete method
+ }
+]%
</PRE>
-</DIV>
-<P> The <TT>%array_class(type, name)</TT> macro creates wrappers for an
- unbounded array object that can be passed around as a simple pointer
- like <TT>int *</TT> or <TT>double *</TT>. For instance, you will be
- able to do this in Java:</P>
+</DIV></DIV>
+<P><TT>%typemap(javainterfacecode, declaration="...", cptrmethod="...")</TT>
+</P>
+<DIV class="indent">
+<P> The code in this typemap is added to the body of a Java proxy class
+ but only when a class is marked with the <TT>interface</TT> feature.
+ The typemap is used in the proxy class marked with the interface
+ feature as well as all proxy classes derived from the marked C++ class,
+ as they are all generated as implementing the Java interface. The
+ default typemap used in the <TT>%interface</TT> family of macros
+ mentioned in the <A href="#Java_interfaces">Java interfaces</A>
+ section, where <TT>CTYPE</TT> is the C++ class macro argument, is as
+ follows:</P>
<DIV class="code">
<PRE>
-intArray array = new intArray(10000000); // Array of 10-million integers
-for (int i=0; i<10000; i++) { // Set some values
- array.setitem(i,i);
+%typemap(javainterfacecode,
+ declaration=" long $interfacename_GetInterfaceCPtr();\n",
+ cptrmethod="$interfacename_GetInterfaceCPtr") CTYPE %{
+ public long $interfacename_GetInterfaceCPtr() {
+ return $imclassname.$javaclazzname$interfacename_GetInterfaceCPtr(swigCPtr);
+ }
+%}
+</PRE>
+</DIV></DIV>
+<P> The special variable <TT>$interfacename</TT> is expanded into the
+ name specified in the <TT>interface</TT> feature.</P>
+<P><B> Compatibility Note:</B> In SWIG-1.3.21 and earlier releases,
+ typemaps called "javagetcptr" and "javaptrconstructormodifiers" were
+ available. These are deprecated and the "javabody" typemap can be used
+ instead. The <TT>javainterfacecode</TT> typemap and interface feature
+ was introduced in SWIG-3.0.9.</P>
+<P> In summary the contents of the typemaps make up a proxy class like
+ this:</P>
+<DIV class="code">
+<PRE>
+[ javaimports typemap ]
+[ javaclassmodifiers typemap ] javaclassname extends [ javabase typemap ]
+ implements [ javainterfaces typemap ] {
+[ javabody or javabody_derived typemap ]
+[ javafinalize typemap ]
+public synchronized void <I>delete</I>() [ javadestruct OR javadestruct_derived typemap ]
+[ javacode typemap ]
+[ javainterfacecode typemap]
+... proxy functions ...
}
-int sum = example.sumitems(array.cast(),10000);
-System.out.println("Sum = " + sum);
</PRE>
</DIV>
-<P> The array "object" created by <TT>%array_class()</TT> does not
- encapsulate pointers inside a special array object. In fact, there is
- no bounds checking or safety of any kind (just like in C). Because of
- this, the arrays created by this library are extremely low-level
- indeed. You can't iterate over them nor can you even query their
- length. In fact, any valid memory address can be accessed if you want
- (negative indices, indices beyond the end of the array, etc.). Needless
- to say, this approach is not going to suit all applications. On the
- other hand, this low-level approach is extremely efficient and well
- suited for applications in which you need to create buffers, package
- binary data, etc.</P>
-<H3><A name="Java_binary_char"></A>24.8.5 Binary data vs Strings</H3>
-<P> By default SWIG handles <TT>char *</TT> as a string but there is a
- handy multi-argument typemap available as mentioned in <A href="#Library_nn10">
-Passing binary data</A>. The following simple example demonstrates using
- a byte array instead of passing the default string type and length to
- the wrapped function.</P>
+<P> Note the <TT><I>delete</I>()</TT> methodname and method modifiers
+ are configurable, see "javadestruct" and "javadestruct_derived"
+ typemaps above.</P>
+<P> The <TT>javainterfacecode</TT> typemap is only used when bases are
+ marked by the <TT>interface</TT> feature and the <TT>implements</TT>
+ list will also then be expanded to include these Java interfaces.</P>
+<P> The type wrapper class is similar in construction:</P>
<DIV class="code">
<PRE>
-%apply (char *STRING, size_t LENGTH) { (const char data[], size_t len) }
-%inline %{
-void binaryChar1(const char data[], size_t len) {
- printf("len: %d data: ", len);
- for (size_t i=0; i<len; ++i)
- printf("%x ", data[i]);
- printf("\n");
+[ javaimports typemap ]
+[ javaclassmodifiers typemap ] javaclassname extends [ javabase typemap ]
+ implements [ javainterfaces typemap ] {
+[ javabody typemap ]
+[ javacode typemap ]
}
-%}
</PRE>
</DIV>
-<P> Calling from Java requires just the byte array to be passed in as
- the multi-argument typemap being applied reduces the number of
- arguments in the target language to one, from the original two:</P>
+<P>The enum class is also similar in construction:</P>
<DIV class="code">
<PRE>
-byte[] data = "hi\0jk".getBytes();
-example.binaryChar1(data);
+[ javaimports typemap ]
+[ javaclassmodifiers typemap ] javaclassname extends [ javabase typemap ]
+ implements [ javainterfaces typemap ] {
+... Enum values ...
+[ javabody typemap ]
+[ javacode typemap ]
+}
</PRE>
</DIV>
-<P> resulting in the output</P>
+<P> The "javaimports" typemap is ignored if the enum class is wrapped by
+ an inner Java class, that is when wrapping an enum declared within a
+ C++ class.</P>
+<P>The Java interface turned on by the <TT>interface</TT> feature is
+ fairly simple:</P>
<DIV class="code">
<PRE>
-$ java runme
-len: 5 data: 68 69 0 6a 6b
+[ javaimports typemap ]
+public interface [ javainterfacename ] {
+[ javainterfacecode:cptrmethod typemap attribute ]
+... interface declarations ...
+}
</PRE>
</DIV>
-<H3><A name="Java_heap_allocations"></A>24.8.6 Overriding new and delete
- to allocate from Java heap</H3>
-<P> Unlike some languages supported by SWIG, Java has a true garbage
- collection subsystem. Other languages will free SWIG wrapped objects
- when their reference count reaches zero. Java only schedules these
- objects for finalization, which may not occur for some time. Because
- SWIG objects are allocated on the C heap, Java users may find the JVM
- memory use quickly exceeds the assigned limits, as memory fills with
- unfinalized proxy objects. Forcing garbage collection is clearly an
- undesirable solution.</P>
-<P> An elegant fix for C++ users is to override new and delete using the
- following code (here shown included in a SWIG interface file)</P>
+<P> where <TT>javainterfacename</TT> is the <TT>name</TT> attribute in
+ the <A href="#Java_interfaces">interface feature</A>.</P>
+<P> The defaults can be overridden to tailor the generated classes. Here
+ is an example which will change the <TT>getCPtr</TT> method and
+ constructor from the default public access to protected access. If the
+ classes in one package are not using the classes in another package,
+ then these methods need not be public and removing access to these low
+ level implementation details, is a good thing. If you are invoking SWIG
+ more than once and generating the wrapped classes into different
+ packages in each invocation, then you cannot do this as you will then
+ have different packages.</P>
<DIV class="code">
<PRE>
-/* File: java_heap.i */
-%module test
-%{
-#include <stdexcept>
-#include "jni.h"
-
-/**
- * A stash area embedded in each allocation to hold java handles
- */
-struct Jalloc {
- jbyteArray jba;
- jobject ref;
-};
-
-static JavaVM *cached_jvm = 0;
+%typemap(javabody) SWIGTYPE %{
+ private transient long swigCPtr;
+ protected transient boolean swigCMemOwn;
-JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) {
- cached_jvm = jvm;
- return JNI_VERSION_1_2;
-}
+ protected $javaclassname(long cPtr, boolean cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = cPtr;
+ }
-static JNIEnv * JNU_GetEnv() {
- JNIEnv *env;
- jint rc = cached_jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
- if (rc == JNI_EDETACHED)
- throw std::runtime_error("current thread not attached");
- if (rc == JNI_EVERSION)
- throw std::runtime_error("jni version not supported");
- return env;
-}
+ protected static long getCPtr($javaclassname obj) {
+ return (obj == null) ? 0 : obj.swigCPtr;
+ }
+%}
+</PRE>
+</DIV>
+<P> The typemap code is the same that is in "<TT>java.swg</TT>", barring
+ the last two method modifiers. Note that <TT>SWIGTYPE</TT> will target
+ all proxy classes, but not the type wrapper classes. Also the above
+ typemap is only used for proxy classes that are potential base classes.
+ To target proxy classes that are derived from a wrapped class as well,
+ the "javabody_derived" typemap should also be overridden.</P>
+<P> For the typemap to be used in all type wrapper classes, all the
+ different types that type wrapper classes could be used for should be
+ targeted:</P>
+<DIV class="code">
+<PRE>
+%typemap(javabody) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
+ private transient long swigCPtr;
-void * operator new(size_t t) {
- if (cached_jvm != 0) {
- JNIEnv *env = JNU_GetEnv();
- jbyteArray jba = env->NewByteArray((int) t + sizeof(Jalloc));
- if (env->ExceptionOccurred())
- throw bad_alloc();
- void *jbuffer = static_cast<void *>(env->GetByteArrayElements(jba, 0));
- if (env->ExceptionOccurred())
- throw bad_alloc();
- Jalloc *pJalloc = static_cast<Jalloc *>(jbuffer);
- pJalloc->jba = jba;
- /* Assign a global reference so byte array will persist until delete'ed */
- pJalloc->ref = env->NewGlobalRef(jba);
- if (env->ExceptionOccurred())
- throw bad_alloc();
- return static_cast<void *>(static_cast<char *>(jbuffer) + sizeof(Jalloc));
+ protected $javaclassname(long cPtr, boolean bFutureUse) {
+ swigCPtr = cPtr;
}
- else { /* JNI_OnLoad not called, use malloc and mark as special */
- Jalloc *pJalloc = static_cast<Jalloc *>(malloc((int) t + sizeof(Jalloc)));
- if (!pJalloc)
- throw bad_alloc();
- pJalloc->ref = 0;
- return static_cast<void *>(
- static_cast<char *>(static_cast<void *>(pJalloc)) + sizeof(Jalloc));
+
+ protected $javaclassname() {
+ swigCPtr = 0;
}
-}
-void operator delete(void *v) {
- if (v != 0) {
- void *buffer = static_cast<void *>( static_cast<char *>(v) - sizeof(Jalloc));
- Jalloc *pJalloc = static_cast<Jalloc *>(buffer);
- if (pJalloc->ref) {
- JNIEnv *env = JNU_GetEnv();
- env->DeleteGlobalRef(pJalloc->ref);
- env->ReleaseByteArrayElements(pJalloc->jba, static_cast<jbyte *>(buffer), 0);
- }
- else {
- free(buffer);
- }
+ protected static long getCPtr($javaclassname obj) {
+ return (obj == null) ? 0 : obj.swigCPtr;
}
-}
%}
-...
</PRE>
</DIV>
-<P> This code caches the Java environment during initialization, and
- when new is called, a Java ByteArray is allocated to provide the SWIG
- objects with space in the Java heap. This has the combined effect of
- re-asserting the Java virtual machine's limit on memory allocation, and
- puts additional pressure on the garbage collection system to run more
- frequently. This code is made slightly more complicated because
- allowances must be made if new is called before the JNI_OnLoad is
- executed. This can happen during static class initialization, for
- example.</P>
-<P> Unfortunately, because most Java implementations call malloc and
- free, this solution will not work for C wrapped structures. However,
- you are free to make functions that allocate and free memory from the
- Java heap using this model and use these functions in place of malloc
- and free in your own code.</P>
-<H2><A name="Java_typemaps"></A>24.9 Java typemaps</H2>
-<P> This section describes how you can modify SWIG's default wrapping
- behavior for various C/C++ datatypes using the <TT>%typemap</TT>
- directive. You are advised to be familiar with the material in the "<A href="#Typemaps">
-Typemaps</A>" chapter. While not absolutely essential knowledge, this
- section assumes some familiarity with the Java Native Interface (JNI).
- JNI documentation can be consulted either online at <A href="http://java.sun.com">
-Sun's Java web site</A> or from a good JNI book. The following two books
- are recommended:</P>
-<UL>
-<LI> Title: 'Essential JNI: Java Native Interface.' Author: Rob Gordon.
- Publisher: Prentice Hall. ISBN: 0-13-679895-0.</LI>
-<LI> Title: 'The Java Native Interface: Programmer's Guide and
- Specification.' Author: Sheng Liang. Publisher: Addison-Wesley. ISBN:
- 0-201-32577-2. Also available <A href="http://java.sun.com/docs/books/jni">
-online</A> at the Sun Developer Network.</LI>
-</UL>
-<P> Before proceeding, it should be stressed that typemaps are not a
- required part of using SWIG---the default wrapping behavior is enough
- in most cases. Typemaps are only used if you want to change some aspect
- of the generated code.</P>
-<H3><A name="Java_default_primitive_type_mappings"></A>24.9.1 Default
- primitive type mappings</H3>
-<P> The following table lists the default type mapping from Java to
- C/C++.</P>
-<TABLE BORDER summary="Default primitive type mappings">
-<TR><TD><B>C/C++ type</B></TD><TD><B>Java type</B></TD><TD><B>JNI type</B>
-</TD></TR>
-<TR><TD>bool
-<BR> const bool &</TD><TD>boolean</TD><TD>jboolean</TD></TR>
-<TR><TD>char
-<BR>const char &</TD><TD>char</TD><TD>jchar</TD></TR>
-<TR><TD>signed char
-<BR>const signed char &</TD><TD>byte</TD><TD>jbyte</TD></TR>
-<TR><TD>unsigned char
-<BR>const unsigned char &</TD><TD>short</TD><TD>jshort</TD></TR>
-<TR><TD>short
-<BR>const short &</TD><TD>short</TD><TD>jshort</TD></TR>
-<TR><TD>unsigned short
-<BR> const unsigned short &</TD><TD>int</TD><TD>jint</TD></TR>
-<TR><TD>int
-<BR> const int &</TD><TD>int</TD><TD>jint</TD></TR>
-<TR><TD>unsigned int
-<BR> const unsigned int &</TD><TD>long</TD><TD>jlong</TD></TR>
-<TR><TD>long
-<BR>const long &</TD><TD>int</TD><TD>jint</TD></TR>
-<TR><TD>unsigned long
-<BR>const unsigned long &</TD><TD>long</TD><TD>jlong</TD></TR>
-<TR><TD>long long
-<BR> const long long &</TD><TD>long</TD><TD>jlong</TD></TR>
-<TR><TD>unsigned long long
-<BR>const unsigned long long &</TD><TD>java.math.BigInteger</TD><TD>
-jobject</TD></TR>
-<TR><TD>float
-<BR>const float &</TD><TD>float</TD><TD>jfloat</TD></TR>
-<TR><TD>double
-<BR> const double &</TD><TD>double</TD><TD>jdouble</TD></TR>
-<TR><TD>char *
-<BR>char []</TD><TD>String</TD><TD>jstring</TD></TR>
-</TABLE>
-<P> Note that SWIG wraps the C <TT>char</TT> type as a character.
- Pointers and arrays of this type are wrapped as strings. The <TT>signed
- char</TT> type can be used if you want to treat <TT>char</TT> as a
- signed number rather than a character. Also note that all const
- references to primitive types are treated as if they are passed by
- value.</P>
-<P> Given the following C function:</P>
+<P> Again this is the same that is in "<TT>java.swg</TT>", barring the
+ method modifier for <TT>getCPtr</TT>.</P>
+<P> When using <A href="#Modules">multiple modules</A> or the <A href="#Java_namespaces">
+nspace feature</A> it is common to invoke SWIG with a different <TT>
+-package</TT> command line option for each module. However, by default
+ the generated code may not compile if generated classes in one package
+ use generated classes in another package. The visibility of the <TT>
+getCPtr()</TT> and pointer constructor generated from the <TT>javabody</TT>
+ typemaps needs changing. The default visibility is <TT>protected</TT>
+ but it needs to be <TT>public</TT> for access from a different package.
+ Just changing 'protected' to 'public' in the typemap achieves this. Two
+ macros are available in <TT>java.swg</TT> to make this easier and using
+ them is the preferred approach over simply copying the typemaps and
+ modifying as this is forward compatible with any changes in the <TT>
+javabody</TT> typemap in future versions of SWIG. The macros are for the
+ proxy and typewrapper classes and can respectively be used to to make
+ the method and constructor public:</P>
+<DIV class="code">
+<PRE>
+ SWIG_JAVABODY_PROXY(public, public, SWIGTYPE)
+ SWIG_JAVABODY_TYPEWRAPPER(public, public, public, SWIGTYPE)
+</PRE>
+</DIV>
+<H3><A name="Java_directors_typemaps">25.9.10 Director specific typemaps</A>
+</H3>
+<P> The Java directors feature requires the "javadirectorin",
+ "javadirectorout", "directorin" and the "directorout" typemaps in order
+ to work properly. The "javapackage" typemap is an optional typemap used
+ to identify the Java package path for individual SWIG generated proxy
+ classes used in director methods.</P>
+<P><TT>%typemap(directorin)</TT></P>
+<DIV class="indent">
+<P> The "directorin" typemap is used for converting arguments in the C++
+ director class to the appropriate JNI type before the upcall to Java.
+ This typemap also specifies the JNI field descriptor for the type in
+ the "descriptor" attribute. For example, integers are converted as
+ follows:</P>
+<DIV class="code">
+<PRE>
+%typemap(directorin,descriptor="I") int "$input = (jint) $1;"
+</PRE>
+</DIV>
+<P> <CODE>$input</CODE> is the SWIG name of the JNI temporary variable
+ passed to Java in the upcall. The <CODE>descriptor="I"</CODE> will put
+ an <CODE>I</CODE> into the JNI field descriptor that identifies the
+ Java method that will be called from C++. For more about JNI field
+ descriptors and their importance, refer to the <A href="#Java_typemaps">
+JNI documentation mentioned earlier</A>. A typemap for C character
+ strings is:</P>
<DIV class="code">
<PRE>
-void func(unsigned short a, char *b, const long &c, unsigned long long d);
+%typemap(directorin,descriptor="Ljava/lang/String;") char *
+ %{ $input = jenv->NewStringUTF($1); %}
</PRE>
</DIV>
-<P> The module class method would be:</P>
+<P> User-defined types have the default "descriptor" attribute "<CODE>
+L$packagepath/$javaclassname;</CODE>" where <CODE>$packagepath</CODE> is
+ the package name passed from the SWIG command line and <CODE>
+$javaclassname</CODE> is the Java proxy class' name. If the <TT>-package</TT>
+ commandline option is not used to specify the package, then
+ '$packagepath/' will be removed from the resulting output JNI field
+ descriptor.<B> Do not forget the terminating ';' for JNI field
+ descriptors starting with 'L'.</B> If the ';' is left out, Java will
+ generate a "method not found" runtime error. Note that the <CODE>
+$packagepath</CODE> substitution always uses the path separator '/' when
+ expanded. The <CODE>$javaclassname</CODE> expansion can be confusing as
+ it is normally expanded using the '.' separator. However, <CODE>
+$javaclassname</CODE> is expanded using the path separator '/' in
+ typemap's "descriptor" attribute as well as in the "directorthrows"
+ typemap.</P>
+</DIV>
+<P><TT>%typemap(directorout)</TT></P>
+<DIV class="indent">
+<P> The "directorout" typemap is used for converting the JNI return type
+ in the C++ director class to the appropriate C++ type after the upcall
+ to Java. For example, integers are converted as follows:</P>
<DIV class="code">
<PRE>
-public static void func(int a, String b, int c, java.math.BigInteger d) {...}
+%typemap(directorout) int %{ $result = (int)$input; %}
</PRE>
</DIV>
-<P> The intermediary JNI class would use the same types:</P>
+<P> <CODE>$input</CODE> is the SWIG name of the JNI temporary variable
+ returned from Java after the upcall. <CODE>$result</CODE> is the
+ resulting output. A typemap for C character strings is:</P>
<DIV class="code">
<PRE>
-public final static native void func(int jarg1, String jarg2, int jarg3,
- java.math.BigInteger jarg4);
+%typemap(directorout) char * {
+ $1 = 0;
+ if ($input) {
+ $result = (char *)jenv->GetStringUTFChars($input, 0);
+ if (!$1) return $null;
+ }
+}
+</PRE>
+</DIV></DIV>
+<P><TT>%typemap(javadirectorin)</TT></P>
+<DIV class="indent">
+<P> Conversion from jtype to jstype for director methods. These are Java
+ code typemaps which transform the type used in the Java intermediary
+ JNI class (as specified in the "jtype" typemap) to the Java type used
+ in the Java module class, proxy classes and type wrapper classes (as
+ specified in the "jstype" typemap). This typemap provides the
+ conversion for the parameters in the director methods when calling up
+ from C++ to Java.</P>
+<P> For primitive types, this typemap is usually specified as:</P>
+<DIV class="code">
+<PRE>
+%typemap(javadirectorin) int "$jniinput"
</PRE>
</DIV>
-<P> and the JNI function would look like this:</P>
+<P> The <CODE>$jniinput</CODE> special variable is analogous to <CODE>
+$javainput</CODE> special variable. It is replaced by the input
+ parameter name.</P>
+</DIV>
+<P><TT>%typemap(javadirectorout)</TT></P>
+<DIV class="indent">
+<P> Conversion from jstype to jtype for director methods. These are Java
+ code typemaps which transform the type used in the Java module class,
+ proxy classes and type wrapper classes (as specified in the "jstype"
+ typemap) to the type used in the Java intermediary JNI class (as
+ specified in the "jtype" typemap). This typemap provides the conversion
+ for the return type in the director methods when returning from the C++
+ to Java upcall.</P>
+<P> For primitive types, this typemap is usually specified as:</P>
<DIV class="code">
<PRE>
-SWIGEXPORT void JNICALL Java_exampleJNI_func(JNIEnv *jenv, jclass jcls,
- jint jarg1, jstring jarg2, jint jarg3, jobject jarg4) {...}
+%typemap(javadirectorout) int "$javacall"
</PRE>
</DIV>
-<P> The mappings for C <TT>int</TT> and C <TT>long</TT> are appropriate
- for 32 bit applications which are used in the 32 bit JVMs. There is no
- perfect mapping between Java and C as Java doesn't support all the
- unsigned C data types. However, the mappings allow the full range of
- values for each C type from Java.</P>
-<H3><A name="Java_default_non_primitive_typemaps"></A>24.9.2 Default
- typemaps for non-primitive types</H3>
-<P> The previous section covered the primitive type mappings.
- Non-primitive types such as classes and structs are mapped using
- pointers on the C/C++ side and storing the pointer into a Java <TT>long</TT>
- variable which is held by the proxy class or type wrapper class. This
- applies whether the type is marshalled as a pointer, by reference or by
- value. It also applies for any unknown/incomplete types which use type
- wrapper classes.</P>
-<P> So in summary, the C/C++ pointer to non-primitive types is cast into
- the 64 bit Java <TT>long</TT> type and therefore the JNI type is a <TT>
-jlong</TT>. The Java type is either the proxy class or type wrapper
- class.</P>
-<H3><A name="Java_jvm64"></A>24.9.3 Sixty four bit JVMs</H3>
-<P> If you are using a 64 bit JVM you may have to override the C long,
- but probably not C int default mappings. Mappings will be system
- dependent, for example long will need remapping on Unix LP64 systems
- (long, pointer 64 bits, int 32 bits), but not on Microsoft 64 bit
- Windows which will be using a P64 IL32 (pointer 64 bits and int, long
- 32 bits) model. This may be automated in a future version of SWIG. Note
- that the Java write once run anywhere philosophy holds true for all
- pure Java code when moving to a 64 bit JVM. Unfortunately it won't of
- course hold true for JNI code.</P>
-<H3><A name="Java_what_is_typemap"></A>24.9.4 What is a typemap?</H3>
-<P> A typemap is nothing more than a code generation rule that is
- attached to a specific C datatype. For example, to convert integers
- from Java to C, you might define a typemap like this:</P>
+<P> The <CODE>$javacall</CODE> special variable is analogous to the <CODE>
+$jnicall</CODE> special variable. It is replaced by the call to the
+ target Java method. The target method is the method in the Java proxy
+ class which overrides the virtual C++ method in the C++ base class.</P>
+</DIV>
+<P><TT>%typemap(directorthrows)</TT></P>
+<DIV class="indent">
+<P> Conversion of Java exceptions to C++ exceptions in director method's
+ exception handling. This typemap is expected to test the <TT>$error</TT>
+ special variable for a matching Java exception and if successful
+ convert and throw it into a C++ exception given by the typemap's type.
+ The <CODE>$error</CODE> special variable is of type <CODE>jthrowable</CODE>
+ and is substituted with a unique variable name in the generated code.</P>
+<P> The example below converts a Java <CODE>
+java.lang.IndexOutOfBoundsException</CODE> exception to the typemap's
+ type, that is <CODE>std::out_of_range</CODE>:</P>
<DIV class="code">
<PRE>
-%module example
-
-%typemap(in) int {
- $1 = $input;
- printf("Received an integer : %d\n", $1);
-}
-%inline %{
-extern int fact(int nonnegative);
+%typemap(directorthrows) std::out_of_range %{
+ if (Swig::ExceptionMatches(jenv, $error, "java/lang/IndexOutOfBoundsException")) {
+ throw std::out_of_range(Swig::JavaExceptionMessage(jenv, $error).message());
+ }
%}
</PRE>
</DIV>
-<P> Typemaps are always associated with some specific aspect of code
- generation. In this case, the "in" method refers to the conversion of
- input arguments to C/C++. The datatype <TT>int</TT> is the datatype to
- which the typemap will be applied. The supplied C code is used to
- convert values. In this code a number of special variables prefaced by
- a <TT>$</TT> are used. The <TT>$1</TT> variable is a placeholder for a
- local variable of type <TT>int</TT>. The <TT>$input</TT> variable
- contains the Java data, the JNI <TT>jint</TT> in this case.</P>
-<P> When this example is compiled into a Java module, it can be used as
- follows:</P>
+<P> The utility function <CODE>Swig::ExceptionMatches</CODE> and class <CODE>
+Swig::JavaExceptionMessage</CODE> are helpers available when using
+ directors and are described in the <A href="#Java_exceptions_from_directors">
+Java Exceptions from Directors</A> section.</P>
+</DIV>
+<P><TT>%typemap(javapackage)</TT></P>
+<DIV class="indent">
+<P> The "javapackage" typemap is optional; it serves to identify a
+ class's Java package. This typemap should be used in conjunction with
+ classes that are defined outside of the current SWIG interface file.
+ The typemap is only used if the type is used in a director method, that
+ is, in a virtual method in a director class. For example:</P>
<DIV class="code">
<PRE>
-System.out.println(example.fact(6));
+// class Foo is handled in a different interface file:
+%import "Foo.i"
+
+%feature("director") Example;
+
+%inline {
+ class Bar { };
+
+ class Example {
+ public:
+ virtual ~Example();
+ virtual void ping(Foo *arg1, Bar *arg2);
+ };
+}
</PRE>
</DIV>
-<P> and the output will be:</P>
+<P> Assume that the Foo class is part of the Java package<I>
+ com.wombat.foo</I> but the above interface file is part of the Java
+ package<I> com.wombat.example</I>. Without the "javapackage" typemap,
+ SWIG will assume that the Foo class belongs to<I> com.wombat.example</I>
+ class. The corrected interface file looks like:</P>
<DIV class="code">
<PRE>
-Received an integer : 6
-720
+// class Foo is handled in a different interface file:
+%import "Foo.i"
+%typemap("javapackage") Foo, Foo *, Foo & "com.wombat.foo";
+%feature("director") Example;
+
+%inline {
+ class Bar { };
+
+ class Example {
+ public:
+ virtual ~Example();
+ virtual void ping(Foo *arg1, Bar *arg2);
+ };
+}
</PRE>
</DIV>
-<P> In this example, the typemap is applied to all occurrences of the <TT>
-int</TT> datatype. You can refine this by supplying an optional
- parameter name. For example:</P>
+<P> SWIG looks up the package based on the<B> actual</B> type (plain
+ Foo, Foo pointer and Foo reference), so it is important to associate
+ all three types with the desired package. Practically speaking, you
+ should create a separate SWIG interface file, which is %import-ed into
+ each SWIG interface file, when you have multiple Java packages. Note
+ the helper macros below, <CODE>OTHER_PACKAGE_SPEC</CODE> and <CODE>
+ANOTHER_PACKAGE_SPEC</CODE>, which reduce the amount of extra typing. "<CODE>
+TYPE...</CODE>" is useful when passing templated types to the macro,
+ since multiargument template types appear to the SWIG preprocessor as
+ multiple macro arguments.</P>
<DIV class="code">
<PRE>
-%module example
+%typemap("javapackage") SWIGTYPE, SWIGTYPE *, SWIGTYPE &
+ "package.for.most.classes";
-%typemap(in) int nonnegative {
- $1 = $input;
- printf("Received an integer : %d\n", $1);
-}
+%define OTHER_PACKAGE_SPEC(TYPE...)
+%typemap("javapackage") TYPE, TYPE *, TYPE & "package.for.other.classes";
+%enddef
-%inline %{
-extern int fact(int nonnegative);
-%}
+%define ANOTHER_PACKAGE_SPEC(TYPE...)
+%typemap("javapackage") TYPE, TYPE *, TYPE & "package.for.another.set";
+%enddef
+
+OTHER_PACKAGE_SPEC(Package_2_class_one)
+ANOTHER_PACKAGE_SPEC(Package_3_class_two)
+/* etc */
</PRE>
</DIV>
-<P> In this case, the typemap code is only attached to arguments that
- exactly match <TT>int nonnegative</TT>.</P>
-<P> The application of a typemap to specific datatypes and argument
- names involves more than simple text-matching--typemaps are fully
- integrated into the SWIG C++ type-system. When you define a typemap for
- <TT>int</TT>, that typemap applies to <TT>int</TT> and qualified
- variations such as <TT>const int</TT>. In addition, the typemap system
- follows <TT>typedef</TT> declarations. For example:</P>
+<P> The basic strategy here is to provide a default package typemap for
+ the majority of the classes, only providing "javapackage" typemaps for
+ the exceptions.</P>
+</DIV>
+<H2><A name="Java_typemap_examples">25.10 Typemap Examples</A></H2>
+<P> This section includes a few examples of typemaps. For more examples,
+ you might look at the files "<TT>java.swg</TT>" and "<TT>typemaps.i</TT>
+" in the SWIG library.</P>
+<H3><A name="Java_simpler_enum_classes">25.10.1 Simpler Java enums for
+ enums without initializers</A></H3>
+<P> The default <A href="#Java_proper_enums_classes">Proper Java enums</A>
+ approach to wrapping enums is somewhat verbose. This is to handle all
+ possible C/C++ enums, in particular enums with initializers. The
+ generated code can be simplified if the enum being wrapped does not
+ have any initializers.</P>
+<P> The following shows how to remove the support methods that are
+ generated by default and instead use the methods in the Java enum base
+ class <TT>java.lang.Enum</TT> and <TT>java.lang.Class</TT> for
+ marshalling enums between C/C++ and Java. The type used for the
+ typemaps below is <TT>enum SWIGTYPE</TT> which is the default type used
+ for all enums. The "enums.swg" file should be examined in order to see
+ the original overridden versions of the typemaps.</P>
<DIV class="code">
<PRE>
-%typemap(in) int nonnegative {
- $1 = $input;
- printf("Received an integer : %d\n", $1);
-}
+%include "enums.swg"
+
+%typemap(javain) enum SWIGTYPE "$javainput.ordinal()"
+%typemap(javaout) enum SWIGTYPE {
+ return $javaclassname.class.getEnumConstants()[$jnicall];
+ }
+%typemap(javabody) enum SWIGTYPE ""
+
%inline %{
-typedef int Integer;
-extern int fact(Integer nonnegative); // Above typemap is applied
+ enum HairType { blonde, ginger, brunette };
+ void setHair(HairType h);
+ HairType getHair();
%}
</PRE>
</DIV>
-<P> However, the matching of <TT>typedef</TT> only occurs in one
- direction. If you defined a typemap for <TT>Integer</TT>, it is not
- applied to arguments of type <TT>int</TT>.</P>
-<P> Typemaps can also be defined for groups of consecutive arguments.
- For example:</P>
+<P> SWIG will generate the following Java enum, which is somewhat
+ simpler than the default:</P>
<DIV class="code">
<PRE>
-%typemap(in) (char *str, int len) {
-...
-};
-
-int count(char c, char *str, int len);
+public enum HairType {
+ blonde,
+ ginger,
+ brunette;
+}
</PRE>
</DIV>
-<P> When a multi-argument typemap is defined, the arguments are always
- handled as a single Java parameter. This allows the function to be used
- like this (notice how the length parameter is omitted):</P>
+<P> and the two Java proxy methods will be:</P>
<DIV class="code">
<PRE>
-int c = example.count('e',"Hello World");
+public static void setHair(HairType h) {
+ exampleJNI.setHair(h.ordinal());
+}
+
+public static HairType getHair() {
+ return HairType.class.getEnumConstants()[exampleJNI.getHair()];
+}
</PRE>
</DIV>
-<H3><A name="Java_typemaps_c_to_java_types"></A>24.9.5 Typemaps for
- mapping C/C++ types to Java types</H3>
-<P> The typemaps available to the Java module include the common
- typemaps listed in the main typemaps section. There are a number of
- additional typemaps which are necessary for using SWIG with Java. The
- most important of these implement the mapping of C/C++ types to Java
- types:</P>
-<BR>
-<TABLE BORDER summary="Typemap mappings for C/C++ types to Java types">
-<TR><TD><B>Typemap</B></TD><TD><B>Description</B></TD></TR>
-<TR><TD>jni</TD><TD>JNI C types. These provide the default mapping of
- types from C/C++ to JNI for use in the JNI (C/C++) code.</TD></TR>
-<TR><TD>jtype</TD><TD>Java intermediary types. These provide the default
- mapping of types from C/C++ to Java for use in the native functions in
- the intermediary JNI class. The type must be the equivalent Java type
- for the JNI C type specified in the "jni" typemap.</TD></TR>
-<TR><TD>jstype</TD><TD>Java types. These provide the default mapping of
- types from C/C++ to Java for use in the Java module class, proxy
- classes and type wrapper classes.</TD></TR>
-<TR><TD>javain</TD><TD>Conversion from jstype to jtype. These are Java
- code typemaps which transform the type used in the Java module class,
- proxy classes and type wrapper classes (as specified in the "jstype"
- typemap) to the type used in the Java intermediary JNI class (as
- specified in the "jtype" typemap). In other words the typemap provides
- the conversion to the native method call parameter types.</TD></TR>
-<TR><TD>javaout</TD><TD>Conversion from jtype to jstype. These are Java
- code typemaps which transform the type used in the Java intermediary
- JNI class (as specified in the "jtype" typemap) to the Java type used
- in the Java module class, proxy classes and type wrapper classes (as
- specified in the "jstype" typemap). In other words the typemap provides
- the conversion from the native method call return type.</TD></TR>
-<TR><TD>javadirectorin</TD><TD>Conversion from jtype to jstype for
- director methods. These are Java code typemaps which transform the type
- used in the Java intermediary JNI class (as specified in the "jtype"
- typemap) to the Java type used in the Java module class, proxy classes
- and type wrapper classes (as specified in the "jstype" typemap). This
- typemap provides the conversion for the parameters in the director
- methods when calling up from C++ to Java. See <A href="#Java_directors_typemaps">
-Director typemaps</A>.</TD></TR>
-<TR><TD>javadirectorout</TD><TD>Conversion from jstype to jtype for
- director methods. These are Java code typemaps which transform the type
- used in the Java module class, proxy classes and type wrapper classes
- (as specified in the "jstype" typemap) to the type used in the Java
- intermediary JNI class (as specified in the "jtype" typemap). This
- typemap provides the conversion for the return type in the director
- methods when returning from the C++ to Java upcall. See <A href="#Java_directors_typemaps">
-Director typemaps</A>.</TD></TR>
-<TR><TD>directorin</TD><TD>Conversion from C++ type to jni type for
- director methods. These are C++ typemaps which convert the parameters
- used in the C++ director method to the appropriate JNI intermediary
- type. The conversion is done in JNI code prior to calling the Java
- function from the JNI code. See <A href="#Java_directors_typemaps">
-Director typemaps</A>.</TD></TR>
-<TR><TD>directorout</TD><TD>Conversion from jni type to C++ type for
- director methods. These are C++ typemaps which convert the JNI return
- type used in the C++ director method to the appropriate C++ return
- type. The conversion is done in JNI code after calling the Java
- function from the JNI code. See <A href="#Java_directors_typemaps">
-Director typemaps</A>.</TD></TR>
-</TABLE>
-<P> If you are writing your own typemaps to handle a particular type,
- you will normally have to write a collection of them. The default
- typemaps are in "<TT>java.swg</TT>" and so might be a good place for
- finding typemaps to base any new ones on.</P>
-<P> The "jni", "jtype" and "jstype" typemaps are usually defined
- together to handle the Java to C/C++ type mapping. An "in" typemap
- should be accompanied by a "javain" typemap and likewise an "out"
- typemap by a "javaout" typemap. If an "in" typemap is written, a
- "freearg" and "argout" typemap may also need to be written as some
- types have a default "freearg" and/or "argout" typemap which may need
- overriding. The "freearg" typemap sometimes releases memory allocated
- by the "in" typemap. The "argout" typemap sometimes sets values in
- function parameters which are passed by reference in Java.</P>
-<P> Note that the "in" typemap marshals the JNI type held in the "jni"
- typemap to the real C/C++ type and for the opposite direction, the
- "out" typemap marshals the real C/C++ type to the JNI type held in the
- "jni" typemap. For <A href="#Java_default_non_primitive_typemaps">
-non-primitive types</A> the "in" and "out" typemaps are responsible for
- casting between the C/C++ pointer and the 64 bit <TT>jlong</TT> type.
- There is no portable way to cast a pointer into a 64 bit integer type
- and the approach taken by SWIG is mostly portable, but breaks C/C++
- aliasing rules. In summary, these rules state that a pointer to any
- type must never be dereferenced by a pointer to any other incompatible
- type. The following code snippet might aid in understand aliasing rules
- better:</P>
+<P> For marshalling Java enums to C/C++ enums, the <TT>ordinal</TT>
+ method is used to convert the Java enum into an integer value for
+ passing to the JNI layer, see the "javain" typemap. For marshalling
+ C/C++ enums to Java enums, the C/C++ enum value is cast to an integer
+ in the C/C++ typemaps (not shown). This integer value is then used to
+ index into the array of enum constants that the Java language provides.
+ See the <TT>getEnumConstants</TT> method in the "javaout" typemap.</P>
+<P> These typemaps can often be used as the default for wrapping enums
+ as in many cases there won't be any enum initializers. In fact a good
+ strategy is to always use these typemaps and to specifically handle
+ enums with initializers using %apply. This would be done by using the
+ original versions of these typemaps in "enums.swg" under another
+ typemap name for applying using %apply.</P>
+<H3><A name="Java_exception_typemap">25.10.2 Handling C++ exception
+ specifications as Java exceptions</A></H3>
+<P> This example demonstrates various ways in which C++ exceptions can
+ be tailored and converted into Java exceptions. Let's consider a simple
+ file class <TT>SimpleFile</TT> and an exception class <TT>FileException</TT>
+ which it may throw on error:</P>
<DIV class="code">
<PRE>
- short a;
- short* pa = 0;
- int i = 0x1234;
+%include "std_string.i" // for std::string typemaps
+#include <string>
- a = (short)i; /* okay */
- a = *(short*)&i; /* breaks aliasing rules */
+class FileException {
+ std::string message;
+public:
+ FileException(const std::string& msg) : message(msg) {}
+ std::string what() {
+ return message;
+ }
+};
+
+class SimpleFile {
+ std::string filename;
+public:
+ SimpleFile(const std::string& filename) : filename(filename) {}
+ void open() throw(FileException) {
+ ...
+ }
+};
</PRE>
</DIV>
-<P> An email posting, <A href="http://mail-index.netbsd.org/tech-kern/2003/08/11/0001.html">
-Aliasing, pointer casts and gcc 3.3</A> elaborates further on the
- subject. In SWIG, the "in" and "out" typemaps for pointers are
- typically</P>
+<P> As the <TT>open</TT> method has a C++ exception specification, SWIG
+ will parse this and know that the method can throw an exception. The <A href="#throws_typemap">
+"throws" typemap</A> is then used when SWIG encounters an exception
+ specification. The default generic "throws" typemap looks like this:</P>
<DIV class="code">
<PRE>
- %typemap(in) struct Foo * %{
- $1 = *(struct Foo **)&$input; /* cast jlong into C ptr */
- %}
- %typemap(out) struct Bar * %{
- *(struct Bar **)&$result = $1; /* cast C ptr into jlong */
- %}
- struct Bar {...};
- struct Foo {...};
- struct Bar * FooBar(struct Foo *f);
+%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [ANY] %{
+ SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
+ "C++ $1_type exception thrown");
+ return $null;
+%}
</PRE>
</DIV>
-<P> resulting in the following code which breaks the aliasing rules:</P>
+<P> Basically SWIG will generate a C++ try catch block and the body of
+ the "throws" typemap constitutes the catch block. The above typemap
+ calls a SWIG supplied method which throws a <TT>
+java.lang.RuntimeException</TT>. This exception class is a runtime
+ exception and therefore not a checked exception. If, however, we wanted
+ to throw a checked exception, say <TT>java.io.IOException</TT>, then we
+ could use the following typemap:</P>
<DIV class="code">
<PRE>
-SWIGEXPORT jlong JNICALL Java_exampleJNI_FooBar(JNIEnv *jenv, jclass jcls,
- jlong jarg1, jobject jarg1_) {
- jlong jresult = 0 ;
- struct Foo *arg1 = (struct Foo *) 0 ;
- struct Bar *result = 0 ;
-
- (void)jenv;
- (void)jcls;
- (void)jarg1_;
- arg1 = *(struct Foo **)&jarg1;
- result = (struct Bar *)FooBar(arg1);
- *(struct Bar **)&jresult = result;
- return jresult;
+%typemap(throws, throws="java.io.IOException") FileException {
+ jclass excep = jenv->FindClass("java/io/IOException");
+ if (excep)
+ jenv->ThrowNew(excep, $1.what().c_str());
+ return $null;
}
</PRE>
</DIV>
-<P> If you are using gcc as your C compiler, you might get a
- "dereferencing type-punned pointer will break strict-aliasing rules"
- warning about this. Please see <A href="#Java_compiling_dynamic">
-Compiling a dynamic module</A> to avoid runtime problems with these
- strict aliasing rules.</P>
-<P> The default code generated by SWIG for the Java module comes from
- the typemaps in the "<TT>java.swg</TT>" library file which implements
- the <A href="#Java_default_primitive_type_mappings">Default primitive
- type mappings</A> and <A href="#Java_default_non_primitive_typemaps">
-Default typemaps for non-primitive types</A> covered earlier. There are
- other type mapping typemaps in the Java library. These are listed
- below:</P>
-<BR>
-<TABLE BORDER summary="Java library typemap mappings">
-<TR VALIGN="TOP"><TD><B>C Type</B></TD><TD><B>Typemap</B></TD><TD><B>
-File</B></TD><TD><B>Kind</B></TD><TD><B>Java Type</B></TD><TD><B>
-Function</B></TD></TR>
-<TR><TD>primitive pointers and references</TD><TD>INPUT</TD><TD>
-typemaps.i</TD><TD>input</TD><TD>Java basic types</TD><TD>Allows values
- to be used for C functions taking pointers for data input.</TD></TR>
-<TR><TD>primitive pointers and references</TD><TD>OUTPUT</TD><TD>
-typemaps.i</TD><TD>output</TD><TD>Java basic type arrays</TD><TD>Allows
- values held within an array to be used for C functions taking pointers
- for data output.</TD></TR>
-<TR><TD>primitive pointers and references</TD><TD>INOUT</TD><TD>
-typemaps.i</TD><TD>input
-<BR>output</TD><TD>Java basic type arrays</TD><TD>Allows values held
- within an array to be used for C functions taking pointers for data
- input and output.</TD></TR>
-<TR><TD>string
-<BR> wstring</TD><TD>[unnamed]</TD><TD>std_string.i</TD><TD>input
-<BR> output</TD><TD>String</TD><TD>Use for std::string mapping to Java
- String.</TD></TR>
-<TR><TD>arrays of primitive types</TD><TD>[unnamed]</TD><TD>
-arrays_java.i</TD><TD>input
-<BR> output</TD><TD>arrays of primitive Java types</TD><TD>Use for
- mapping C arrays to Java arrays.</TD></TR>
-<TR><TD>arrays of classes/structs/unions</TD><TD>JAVA_ARRAYSOFCLASSES
- macro</TD><TD>arrays_java.i</TD><TD>input
-<BR> output</TD><TD>arrays of proxy classes</TD><TD>Use for mapping C
- arrays to Java arrays.</TD></TR>
-<TR><TD>arrays of enums</TD><TD>ARRAYSOFENUMS</TD><TD>arrays_java.i</TD><TD>
-input
-<BR> output</TD><TD>int[]</TD><TD>Use for mapping C arrays to Java
- arrays (typeunsafe and simple enum wrapping approaches only).</TD></TR>
-<TR VALIGN="TOP"><TD>char *</TD><TD>BYTE</TD><TD>various.i</TD><TD>input</TD><TD>
-byte[]</TD><TD VALIGN="TOP">Java byte array is converted to char array</TD>
-</TR>
-<TR><TD>char **</TD><TD>STRING_ARRAY</TD><TD>various.i</TD><TD>input
-<BR> output</TD><TD>String[]</TD><TD>Use for mapping NULL terminated
- arrays of C strings to Java String arrays</TD></TR>
-</TABLE>
-<H3><A name="Java_typemap_attributes"></A>24.9.6 Java typemap attributes</H3>
-<P> There are a few additional typemap attributes that the Java module
- supports.</P>
-<P> The first of these is the 'throws' attribute. The throws attribute
- is optional and specified after the typemap name and contains one or
- more comma separated classes for adding to the throws clause for any
- methods that use that typemap. It is analogous to the <A href="#Java_exception_handling">
-%javaexception</A> feature's throws attribute.</P>
+<P> Note that this typemap uses the 'throws' <A href="#Java_typemap_attributes">
+typemap attribute</A> to ensure a throws clause is generated. The
+ generated proxy method then specifies the checked exception by
+ containing <TT>java.io.IOException</TT> in the throws clause:</P>
<DIV class="code">
<PRE>
-%typemap(typemapname, throws="ExceptionClass1, ExceptionClass2") type { ... }
+public class SimpleFile {
+ ...
+ public void open() throws java.io.IOException { ... }
+}
</PRE>
</DIV>
-<P> The attribute is necessary for supporting Java checked exceptions
- and can be added to just about any typemap. The list of typemaps
- include all the C/C++ (JNI) typemaps in the "<A href="#Typemaps">
-Typemaps</A>" chapter and the Java specific typemaps listed in <A href="#Java_typemaps_c_to_java_types">
-the previous section</A>, barring the "jni", "jtype" and "jstype"
- typemaps as they could never contain code to throw an exception.</P>
-<P> The throws clause is generated for the proxy method as well as the
- JNI method in the JNI intermediary class. If a method uses more than
- one typemap and each of those typemaps have classes specified in the
- throws clause, the union of the exception classes is added to the
- throws clause ensuring there are no duplicate classes. See the <A href="#Java_nan_exception_typemap">
-NaN exception example</A> for further usage.</P>
-<P> The "jtype" typemap has the optional 'nopgcpp' attribute which can
- be used to suppress the generation of the <A href="#Java_pgcpp">
-premature garbage collection prevention parameter</A>.</P>
-<P> The "javain" typemap has the optional 'pre', 'post' and 'pgcppname'
- attributes. These are used for generating code before and after the JNI
- call in the proxy class or module class. The 'pre' attribute contains
- code that is generated before the JNI call and the 'post' attribute
- contains code generated after the JNI call. The 'pgcppname' attribute
- is used to change the <A href="#Java_pgcpp">premature garbage
- collection prevention parameter</A> name passed to the JNI function.
- This is sometimes needed when the 'pre' typemap creates a temporary
- variable which is then passed to the JNI function.</P>
-<P> <A name="Java_constructor_helper_function"></A> Note that when the
- 'pre' or 'post' attributes are specified and the associated type is
- used in a constructor, a constructor helper function is generated. This
- is necessary as the Java proxy constructor wrapper makes a call to a
- support constructor using a<I> this</I> call. In Java the<I> this</I>
- call must be the first statement in the constructor body. The
- constructor body thus calls the helper function and the helper function
- instead makes the JNI call, ensuring the 'pre' code is called before
- the JNI call is made. There is a <A href="#Java_date_marshalling">Date
- marshalling</A> example showing 'pre', 'post' and 'pgcppname'
- attributes in action.</P>
-<H3><A name="Java_special_variables"></A>24.9.7 Java special variables</H3>
-<P> The standard SWIG special variables are available for use within
- typemaps as described in the <A href="#Typemaps">Typemaps documentation</A>
-, for example <TT>$1</TT>, <TT>$input</TT>,<TT>$result</TT> etc.</P>
-<P> The Java module uses a few additional special variables:</P>
-<P><B> <TT>$javaclassname</TT></B>
-<BR> This special variable works like the other <A href="#Typemaps_special_variables">
-special variables</A> and <TT>$javaclassname</TT> is similar to <TT>
-$1_type</TT>. It expands to the class name for use in Java given a
- pointer. SWIG wraps unions, structs and classes using pointers and in
- this case it expands to the Java proxy class name. For example, <TT>
-$javaclassname</TT> is replaced by the proxy classname <TT>Foo</TT> when
- wrapping a <TT>Foo *</TT> and <TT>$&javaclassname</TT> expands to the
- proxy classname when wrapping the C/C++ type <TT>Foo</TT> and <TT>
-$*javaclassname</TT> expands to the proxy classname when wrapping <TT>
-Foo *&</TT>. If the type does not have an associated proxy class, it
- expands to the type wrapper class name, for example, <TT>
-SWIGTYPE_p_unsigned_short</TT> is generated when wrapping <TT>unsigned
- short *</TT>.</P>
-<P><B> <TT>$javaclazzname</TT></B>
-<BR> This special variable works like <TT>$javaclassname</TT>, but
- expands the fully qualified C++ class into the package name, if used by
- the <A href="#SWIGPlus_nspace">nspace feature</A>, and the proxy class
- name, mangled for use as a function name. For example, <TT>
-Namespace1::Namespace2::Klass</TT> is expanded into <TT>
-Namespace1_Namespace2_Klass_</TT>. This special variable is usually used
- for making calls to a function in the intermediary JNI class, as they
- are mangled with this prefix.</P>
-<P><B> <TT>$null</TT></B>
-<BR> Used in input typemaps to return early from JNI functions that have
- either void or a non-void return type. Example:</P>
+<P> Lastly, if you don't want to map your C++ exception into one of the
+ standard Java exceptions, the C++ class can be wrapped and turned into
+ a custom Java exception class. If we go back to our example, the first
+ thing we must do is get SWIG to wrap <TT>FileException</TT> and ensure
+ that it derives from <TT>java.lang.Exception</TT>. Additionally, we
+ might want to override the <TT>java.lang.Exception.getMessage()</TT>
+ method. The typemaps to use then are as follows:</P>
<DIV class="code">
<PRE>
-%typemap(check) int * %{
- if (error) {
- SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array element error");
- return $null;
+%typemap(javabase) FileException "java.lang.Exception";
+%typemap(javacode) FileException %{
+ public String getMessage() {
+ return what();
}
%}
</PRE>
</DIV>
-<P> If the typemap gets put into a function with void as return, $null
- will expand to nothing:</P>
+<P> This generates:</P>
<DIV class="code">
<PRE>
-SWIGEXPORT void JNICALL Java_jnifn(...) {
- if (error) {
- SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array element error");
- return ;
- }
+public class FileException extends java.lang.Exception {
...
+ public String getMessage() {
+ return what();
+ }
+
+ public FileException(String msg) { ... }
+
+ public String what() {
+ return exampleJNI.FileException_what(swigCPtr, this);
+ }
}
</PRE>
</DIV>
-<P> otherwise $null expands to<I> NULL</I></P>
+<P> We could alternatively have used <TT>%rename</TT> to rename <TT>
+what()</TT> into <TT>getMessage()</TT>.</P>
+<H3><A name="Java_nan_exception_typemap">25.10.3 NaN Exception -
+ exception handling for a particular type</A></H3>
+<P> A Java exception can be thrown from any Java or JNI code. Therefore,
+ as most typemaps contain either Java or JNI code, just about any
+ typemap could throw an exception. The following example demonstrates
+ exception handling on a type by type basis by checking for 'Not a
+ number' (NaN) whenever a parameter of type <TT>float</TT> is wrapped.</P>
+<P> Consider the following C++ code:</P>
<DIV class="code">
<PRE>
-SWIGEXPORT jobject JNICALL Java_jnifn(...) {
- if (error) {
- SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array element error");
- return NULL;
- }
- ...
-}
+bool calculate(float first, float second);
</PRE>
</DIV>
-<P><B> <TT>$javainput, $jnicall and $owner</TT></B>
-<BR> The $javainput special variable is used in "javain" typemaps and
- $jnicall and $owner are used in "javaout" typemaps. $jnicall is
- analogous to $action in %exception. It is replaced by the call to the
- native method in the intermediary JNI class. $owner is replaced by
- either <TT>true</TT> if %newobject has been used, otherwise <TT>false</TT>
-. $javainput is analogous to the $input special variable. It is replaced
- by the parameter name.</P>
-<P> Here is an example:</P>
+<P> To validate every <TT>float</TT> being passed to C++, we could
+ precede the code being wrapped by the following typemap which throws a
+ runtime exception whenever the <TT>float</TT> is 'Not a Number':</P>
<DIV class="code">
<PRE>
-%typemap(javain) Class "Class.getCPtr($javainput)"
-%typemap(javain) unsigned short "$javainput"
-%typemap(javaout) Class * {
- return new Class($jnicall, $owner);
+%module example
+%typemap(javain) float "$module.CheckForNaN($javainput)"
+%pragma(java) modulecode=%{
+ /** Simply returns the input value unless it is not a number,
+ whereupon an exception is thrown. */
+ static protected float CheckForNaN(float num) {
+ if (Float.isNaN(num))
+ throw new RuntimeException("Not a number");
+ return num;
}
-
-%inline %{
- class Class {...};
- Class * bar(Class cls, unsigned short ush) { return new Class(); };
%}
</PRE>
</DIV>
-<P> The generated proxy code is then:</P>
+<P> Note that the <TT>CheckForNaN</TT> support method has been added to
+ the module class using the <TT>modulecode</TT> pragma. The following
+ shows the generated code of interest:</P>
<DIV class="code">
<PRE>
-public static Class bar(Class cls, int ush) {
- return new Class(exampleJNI.bar(Class.getCPtr(cls), cls, ush), false);
+public class example {
+ ...
+
+ /** Simply returns the input value unless it is not a number,
+ whereupon an exception is thrown. */
+ static protected float CheckForNaN(float num) {
+ if (Float.isNaN(num))
+ throw new RuntimeException("Not a number");
+ return num;
+ }
+
+ public static boolean calculate(float first, float second) {
+ return exampleJNI.calculate(example.CheckForNaN(first), example.CheckForNaN(second));
+ }
}
</PRE>
</DIV>
-<P> Here $javainput has been replaced by <TT>cls</TT> and <TT>ush</TT>.
- $jnicall has been replaced by the native method call, <TT>
-exampleJNI.bar(...)</TT> and $owner has been replaced by <TT>false</TT>.
- If %newobject is used by adding the following at the beginning of our
- example:</P>
+<P> Note that the "javain" typemap is used for every occurrence of a <TT>
+float</TT> being used as an input. Of course, we could have targeted the
+ typemap at a particular parameter by using <TT>float first</TT>, say,
+ instead of just <TT>float</TT>.</P>
+<P> The exception checking could alternatively have been placed into the
+ 'pre' attribute that the "javain" typemap supports. The "javain"
+ typemap above could be replaced with the following:</P>
<DIV class="code">
<PRE>
-%newobject bar(Class cls, unsigned short ush);
+%typemap(javain, pre=" $module.CheckForNaN($javainput);") float "$javainput"
</PRE>
</DIV>
-<P> The generated code constructs the return type using <TT>true</TT>
- indicating the proxy class <TT>Class</TT> is responsible for destroying
- the C++ memory allocated for it in <TT>bar</TT>:</P>
+<P> which would modify the <TT>calculate</TT> function to instead be
+ generated as:</P>
<DIV class="code">
<PRE>
-public static Class bar(Class cls, int ush) {
- return new Class(exampleJNI.bar(Class.getCPtr(cls), cls, ush), true);
+public class example {
+ ...
+ public static boolean calculate(float first, float second) {
+ example.CheckForNaN(first);
+ example.CheckForNaN(second);
+ {
+ return exampleJNI.calculate(first, second);
+ }
+ }
}
</PRE>
</DIV>
-<P><B> <TT>$static</TT></B>
-<BR> This special variable expands to either<I> static</I> or nothing
- depending on whether the class is an inner Java class or not. It is
- used in the "javaclassmodifiers" typemap so that global classes can be
- wrapped as Java proxy classes and nested C++ classes/enums can be
- wrapped with the Java equivalent, that is, static inner proxy classes.</P>
-<P><B> <TT>$jniinput, $javacall and $packagepath</TT></B>
-<BR> These special variables are used in the directors typemaps. See <A href="#Java_directors_typemaps">
-Director specific typemaps</A> for details.</P>
-<P><B> <TT>$module</TT></B>
-<BR> This special variable expands to the module name, as specified by <TT>
-%module</TT> or the <TT>-module</TT> commandline option.</P>
-<P><B> <TT>$imclassname</TT></B>
-<BR> This special variable expands to the intermediary class name.
- Usually this is the same as '$moduleJNI', unless the jniclassname
- attribute is specified in the <A href="#Java_module_directive">%module
- directive</A>.</P>
-<H3><A name="Java_typemaps_for_c_and_cpp"></A>24.9.8 Typemaps for both C
- and C++ compilation</H3>
-<P> JNI calls must be written differently depending on whether the code
- is being compiled as C or C++. For example C compilation requires the
- pointer to a function pointer struct member syntax like</P>
+<P> See the <A href="#Java_date_marshalling">Date marshalling example</A>
+ for an example using further "javain" typemap attributes.</P>
+<P> If we decide that what we actually want is a checked exception
+ instead of a runtime exception, we can change this easily enough. The
+ proxy method that uses <TT>float</TT> as an input, must then add the
+ exception class to the throws clause. SWIG can handle this as it
+ supports the 'throws' <A href="#Java_typemap_attributes">typemap
+ attribute</A> for specifying classes for the throws clause. Thus we can
+ modify the pragma and the typemap for the throws clause:</P>
<DIV class="code">
<PRE>
-const jclass clazz = (*jenv)->FindClass(jenv, "java/lang/String");
+%typemap(javain, throws="java.lang.Exception") float "$module.CheckForNaN($javainput)"
+%pragma(java) modulecode=%{
+ /** Simply returns the input value unless it is not a number,
+ whereupon an exception is thrown. */
+ static protected float CheckForNaN(float num) throws java.lang.Exception {
+ if (Float.isNaN(num))
+ throw new RuntimeException("Not a number");
+ return num;
+ }
+%}
</PRE>
</DIV>
-<P> whereas C++ code compilation of the same function call is a member
- function call using a class pointer like</P>
+<P> The <TT>calculate</TT> method now has a throws clause and even
+ though the typemap is used twice for both <TT>float first</TT> and <TT>
+float second</TT>, the throws clause contains a single instance of <TT>
+java.lang.Exception</TT>:</P>
<DIV class="code">
<PRE>
-const jclass clazz = jenv->FindClass("java/lang/String");
+public class example {
+ ...
+
+ /** Simply returns the input value unless it is not a number,
+ whereupon an exception is thrown. */
+ static protected float CheckForNaN(float num) throws java.lang.Exception {
+ if (Float.isNaN(num))
+ throw new RuntimeException("Not a number");
+ return num;
+ }
+
+ public static boolean calculate(float first, float second) throws java.lang.Exception {
+ return exampleJNI.calculate(example.CheckForNaN(first), example.CheckForNaN(second));
+ }
+}
</PRE>
</DIV>
-<P> To enable typemaps to be used for either C or C++ compilation, a set
- of JCALLx macros have been defined in Lib/java/javahead.swg, where x is
- the number of arguments in the C++ version of the JNI call. The above
- JNI calls would be written in a typemap like this</P>
+<P> If we were a martyr to the JNI cause, we could replace the succinct
+ code within the "javain" typemap with a few pages of JNI code. If we
+ had, we would have put it in the "in" typemap which, like all JNI and
+ Java typemaps, also supports the 'throws' attribute.</P>
+<H3><A name="Java_converting_java_string_arrays">25.10.4 Converting Java
+ String arrays to char **</A></H3>
+<P> A common problem in many C programs is the processing of command
+ line arguments, which are usually passed in an array of NULL terminated
+ strings. The following SWIG interface file allows a Java String array
+ to be used as a <TT>char **</TT> object.</P>
<DIV class="code">
<PRE>
-const jclass clazz = JCALL1(FindClass, jenv, "java/lang/String");
+%module example
+
+/* This tells SWIG to treat char ** as a special case when used as a parameter
+ in a function call */
+%typemap(in) char ** (jint size) {
+ int i = 0;
+ size = (*jenv)->GetArrayLength(jenv, $input);
+ $1 = (char **) malloc((size+1)*sizeof(char *));
+ /* make a copy of each string */
+ for (i = 0; i<size; i++) {
+ jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, $input, i);
+ const char * c_string = (*jenv)->GetStringUTFChars(jenv, j_string, 0);
+ $1[i] = malloc((strlen(c_string)+1)*sizeof(char));
+ strcpy($1[i], c_string);
+ (*jenv)->ReleaseStringUTFChars(jenv, j_string, c_string);
+ (*jenv)->DeleteLocalRef(jenv, j_string);
+ }
+ $1[i] = 0;
+}
+
+/* This cleans up the memory we malloc'd before the function call */
+%typemap(freearg) char ** {
+ int i;
+ for (i=0; i<size$argnum-1; i++)
+ free($1[i]);
+ free($1);
+}
+
+/* This allows a C function to return a char ** as a Java String array */
+%typemap(out) char ** {
+ int i;
+ int len=0;
+ jstring temp_string;
+ const jclass clazz = (*jenv)->FindClass(jenv, "java/lang/String");
+
+ while ($1[len]) len++;
+ jresult = (*jenv)->NewObjectArray(jenv, len, clazz, NULL);
+ /* exception checking omitted */
+
+ for (i=0; i<len; i++) {
+ temp_string = (*jenv)->NewStringUTF(jenv, *result++);
+ (*jenv)->SetObjectArrayElement(jenv, jresult, i, temp_string);
+ (*jenv)->DeleteLocalRef(jenv, temp_string);
+ }
+}
+
+/* These 3 typemaps tell SWIG what JNI and Java types to use */
+%typemap(jni) char ** "jobjectArray"
+%typemap(jtype) char ** "String[]"
+%typemap(jstype) char ** "String[]"
+
+/* These 2 typemaps handle the conversion of the jtype to jstype typemap type
+ and vice versa */
+%typemap(javain) char ** "$javainput"
+%typemap(javaout) char ** {
+ return $jnicall;
+ }
+
+/* Now a few test functions */
+%inline %{
+
+int print_args(char **argv) {
+ int i = 0;
+ while (argv[i]) {
+ printf("argv[%d] = %s\n", i, argv[i]);
+ i++;
+ }
+ return i;
+}
+
+char **get_args() {
+ static char *values[] = { "Dave", "Mike", "Susan", "John", "Michelle", 0};
+ return &values[0];
+}
+
+%}
</PRE>
</DIV>
-<P> Note that the SWIG preprocessor expands these into the appropriate C
- or C++ JNI calling convention. The C calling convention is emitted by
- default and the C++ calling convention is emitted when using the -c++
- SWIG commandline option. If you do not intend your code to be targeting
- both C and C++ then your typemaps can use the appropriate JNI calling
- convention and need not use the JCALLx macros.</P>
-<H3><A name="Java_code_typemaps"></A>24.9.9 Java code typemaps</H3>
-<P> Most of SWIG's typemaps are used for the generation of C/C++ code.
- The typemaps in this section are used solely for the generation of Java
- code. Elements of proxy classes and type wrapper classes come from the
- following typemaps (the defaults).</P>
-<P><TT>%typemap(javabase)</TT></P>
-<DIV class="indent"> base (extends) for Java class: empty default
-<BR> Note that this typemap accepts a <TT>replace</TT> attribute as an
- optional flag. When set to "1", it will replace/override any C++ base
- classes that might have been parsed. If this flag is not specified and
- there are C++ base classes, then a multiple inheritance warning is
- issued and the code in the typemap is ignored. The typemap also accepts
- a <TT>notderived</TT> attribute as an optional flag. When set to "1",
- it will not apply to classes that are derived from a C++ base. When
- used with the SWIGTYPE type, it is useful for giving a common base for
- all proxy classes, that is, providing a base class that sits in between
- all proxy classes and the Java base class <TT>Object</TT> for example: <TT>
-%typemap(javabase, notderived="1") SWIGTYPE "CommonBase"</TT>.</DIV>
-<P><TT>%typemap(javabody)</TT></P>
-<DIV class="indent"> the essential support body for proxy classes (proxy
- base classes only), typewrapper classes and enum classes. Default
- contains extra constructors, memory ownership control member variables
- (<TT>swigCMemOwn</TT>, <TT>swigCPtr</TT>), the <TT>getCPtr</TT> method
- etc.</DIV>
-<P><TT>%typemap(javabody_derived)</TT></P>
-<DIV class="indent"> the essential support body for proxy classes
- (derived classes only). Same as "javabody" typemap, but only used for
- proxy derived classes.</DIV>
-<P><TT>%typemap(javaclassmodifiers)</TT></P>
-<DIV class="indent"> class modifiers for the Java class: default is
- "public class"</DIV>
-<P><TT>%typemap(javacode)</TT></P>
-<DIV class="indent"> Java code is copied verbatim to the Java class:
- empty default</DIV>
-<P><TT>%typemap(javadestruct, methodname="delete",
- methodmodifiers="public synchronized")</TT>
-<BR></P>
-<DIV class="indent"> destructor wrapper - the <TT>delete()</TT> method
- (proxy classes only), used for all proxy classes except those which
- have a base class : default calls C++ destructor (or frees C memory)
- and resets <TT>swigCPtr</TT> and <TT>swigCMemOwn</TT> flags
-<BR>
-<BR> Note that the <TT>delete()</TT> method name is configurable and is
- specified by the <TT>methodname</TT> attribute. The method modifiers
- are also configurable via the <TT>methodmodifiers</TT> attribute.</DIV>
-<P><TT>%typemap(javadestruct_derived, methodname="delete",
- methodmodifiers="public synchronized")</TT></P>
-<DIV class="indent"> destructor wrapper - the <TT>delete()</TT> method
- (proxy classes only), same as "javadestruct" but only used for derived
- proxy classes : default calls C++ destructor (or frees C memory) and
- resets <TT>swigCPtr</TT> and <TT>swigCMemOwn</TT> flags
-<BR>
-<BR> Note that the <TT>delete()</TT> method name is configurable and is
- specified by the <TT>methodname</TT> attribute. The method modifiers
- are also configurable via the <TT>methodmodifiers</TT> attribute.</DIV>
-<P><TT>%typemap(javaimports)</TT></P>
-<DIV class="indent"> import statements for Java class: empty default</DIV>
-<P><TT>%typemap(javainterfaces)</TT></P>
-<DIV class="indent"> interfaces (implements) for Java class: empty
- default</DIV>
-<P><TT>%typemap(javafinalize)</TT></P>
-<DIV class="indent"> the <TT>finalize()</TT> method (proxy classes
- only): default calls the <TT>delete()</TT> method
-<P> Note that the default javafinalize typemap must contain the full
- implementation of the finalize method. Any customization to this
- typemap must still declare a java finalize method with the correct
- signature. Note also that the name of the generated "delete" method may
- be affected by <TT>javadestruct</TT> and <TT>javadestruct_derived</TT>
- typemaps. Below shows an example modifying the finalizer, assuming the <TT>
-delete</TT> method has been renamed to <TT>swig_delete</TT>.</P>
+<P> Note that the 'C' JNI calling convention is used. Checking for any
+ thrown exceptions after JNI function calls has been omitted. When this
+ module is compiled, our wrapped C functions can be used by the
+ following Java program:</P>
<DIV class="code">
<PRE>
-%typemap(javafinalize) SWIGTYPE %{
- protected void finalize() {
- swig_delete(); // renamed to prevent conflict with existing delete method
- }
-]%
+// File runme.java
+
+public class runme {
+
+ static {
+ try {
+ System.loadLibrary("example");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. " + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+ String animals[] = {"Cat","Dog","Cow","Goat"};
+ example.print_args(animals);
+ String args[] = example.get_args();
+ for (int i=0; i<args.length; i++)
+ System.out.println(i + ":" + args[i]);
+ }
+}
</PRE>
-</DIV></DIV>
-<P><B> Compatibility Note:</B> In SWIG-1.3.21 and earlier releases,
- typemaps called "javagetcptr" and "javaptrconstructormodifiers" were
- available. These are deprecated and the "javabody" typemap can be used
- instead.</P>
-<P> In summary the contents of the typemaps make up a proxy class like
- this:</P>
+</DIV>
+<P> When compiled and run we get:</P>
<DIV class="code">
<PRE>
-[ javaimports typemap ]
-[ javaclassmodifiers typemap ] javaclassname extends [ javabase typemap ]
- implements [ javainterfaces typemap ] {
-[ javabody or javabody_derived typemap ]
-[ javafinalize typemap ]
-public synchronized void <I>delete</I>() [ javadestruct OR javadestruct_derived typemap ]
-[ javacode typemap ]
-... proxy functions ...
+$ java runme
+argv[0] = Cat
+argv[1] = Dog
+argv[2] = Cow
+argv[3] = Goat
+0:Dave
+1:Mike
+2:Susan
+3:John
+4:Michelle
+</PRE>
+</DIV>
+<P> In the example, a few different typemaps are used. The "in" typemap
+ is used to receive an input argument and convert it to a C array. Since
+ dynamic memory allocation is used to allocate memory for the array, the
+ "freearg" typemap is used to later release this memory after the
+ execution of the C function. The "out" typemap is used for function
+ return values. Lastly the "jni", "jtype" and "jstype" typemaps are also
+ required to specify what Java types to use.</P>
+<H3><A name="Java_expanding_java_object">25.10.5 Expanding a Java object
+ to multiple arguments</A></H3>
+<P> Suppose that you had a collection of C functions with arguments such
+ as the following:</P>
+<DIV class="code">
+<PRE>
+int foo(int argc, char **argv);
+</PRE>
+</DIV>
+<P> In the previous example, a typemap was written to pass a Java String
+ array as the <TT>char **argv</TT>. This allows the function to be used
+ from Java as follows:</P>
+<DIV class="code">
+<PRE>
+example.foo(4, new String[]{"red", "green", "blue", "white"});
+</PRE>
+</DIV>
+<P> Although this works, it's a little awkward to specify the argument
+ count. To fix this, a multi-argument typemap can be defined. This is
+ not very difficult--you only have to make slight modifications to the
+ previous example's typemaps:</P>
+<DIV class="code">
+<PRE>
+%typemap(in) (int argc, char **argv) {
+ int i = 0;
+ $1 = (*jenv)->GetArrayLength(jenv, $input);
+ $2 = (char **) malloc(($1+1)*sizeof(char *));
+ /* make a copy of each string */
+ for (i = 0; i<$1; i++) {
+ jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, $input, i);
+ const char * c_string = (*jenv)->GetStringUTFChars(jenv, j_string, 0);
+ $2[i] = malloc((strlen(c_string)+1)*sizeof(char));
+ strcpy($2[i], c_string);
+ (*jenv)->ReleaseStringUTFChars(jenv, j_string, c_string);
+ (*jenv)->DeleteLocalRef(jenv, j_string);
+ }
+ $2[i] = 0;
+}
+
+%typemap(freearg) (int argc, char **argv) {
+ int i;
+ for (i=0; i<$1-1; i++)
+ free($2[i]);
+ free($2);
}
+
+%typemap(jni) (int argc, char **argv) "jobjectArray"
+%typemap(jtype) (int argc, char **argv) "String[]"
+%typemap(jstype) (int argc, char **argv) "String[]"
+
+%typemap(javain) (int argc, char **argv) "$javainput"
</PRE>
</DIV>
-<P> Note the <TT><I>delete</I>()</TT> methodname and method modifiers
- are configurable, see "javadestruct" and "javadestruct_derived"
- typemaps above.</P>
-<P> The type wrapper class is similar in construction:</P>
+<P> When writing a multiple-argument typemap, each of the types is
+ referenced by a variable such as <TT>$1</TT> or <TT>$2</TT>. The
+ typemap code simply fills in the appropriate values from the supplied
+ Java parameter.</P>
+<P> With the above typemap in place, you will find it no longer
+ necessary to supply the argument count. This is automatically set by
+ the typemap code. For example:</P>
<DIV class="code">
<PRE>
-[ javaimports typemap ]
-[ javaclassmodifiers typemap ] javaclassname extends [ javabase typemap ]
- implements [ javainterfaces typemap ] {
-[ javabody typemap ]
-[ javacode typemap ]
-}
+example.foo(new String[]{"red", "green", "blue", "white"});
</PRE>
</DIV>
-<P>The enum class is also similar in construction:</P>
+<H3><A name="Java_using_typemaps_return_arguments">25.10.6 Using
+ typemaps to return arguments</A></H3>
+<P> A common problem in some C programs is that values may be returned
+ in function parameters rather than in the return value of a function.
+ The <TT>typemaps.i</TT> file defines INPUT, OUTPUT and INOUT typemaps
+ which can be used to solve some instances of this problem. This library
+ file uses an array as a means of moving data to and from Java when
+ wrapping a C function that takes non const pointers or non const
+ references as parameters.</P>
+<P> Now we are going to outline an alternative approach to using arrays
+ for C pointers. The INOUT typemap uses a <TT>double[]</TT> array for
+ receiving and returning the <TT>double*</TT> parameters. In this
+ approach we are able to use a Java class <TT>myDouble</TT> instead of <TT>
+double[]</TT> arrays where the C pointer <TT>double*</TT> is required.</P>
+<P> Here is our example function:</P>
<DIV class="code">
<PRE>
-[ javaimports typemap ]
-[ javaclassmodifiers typemap ] javaclassname extends [ javabase typemap ]
- implements [ javainterfaces typemap ] {
-... Enum values ...
-[ javabody typemap ]
-[ javacode typemap ]
-}
+/* Returns a status value and two values in out1 and out2 */
+int spam(double a, double b, double *out1, double *out2);
</PRE>
</DIV>
-<P> The "javaimports" typemap is ignored if the enum class is wrapped by
- an inner Java class, that is when wrapping an enum declared within a
- C++ class.</P>
-<P> The defaults can be overridden to tailor these classes. Here is an
- example which will change the <TT>getCPtr</TT> method and constructor
- from the default public access to protected access. If the classes in
- one package are not using the classes in another package, then these
- methods need not be public and removing access to these low level
- implementation details, is a good thing. If you are invoking SWIG more
- than once and generating the wrapped classes into different packages in
- each invocation, then you cannot do this as you will then have
- different packages.</P>
+<P> If we define a structure <TT>MyDouble</TT> containing a <TT>double</TT>
+ member variable and use some typemaps we can solve this problem. For
+ example we could put the following through SWIG:</P>
<DIV class="code">
<PRE>
-%typemap(javabody) SWIGTYPE %{
- private long swigCPtr;
- protected boolean swigCMemOwn;
+%module example
- protected $javaclassname(long cPtr, boolean cMemoryOwn) {
- swigCMemOwn = cMemoryOwn;
- swigCPtr = cPtr;
- }
+/* Define a new structure to use instead of double * */
+%inline %{
+typedef struct {
+ double value;
+} MyDouble;
+%}
- protected static long getCPtr($javaclassname obj) {
- return (obj == null) ? 0 : obj.swigCPtr;
- }
+
+%{
+/* Returns a status value and two values in out1 and out2 */
+int spam(double a, double b, double *out1, double *out2) {
+ int status = 1;
+ *out1 = a*10.0;
+ *out2 = b*100.0;
+ return status;
+}
%}
+
+/*
+This typemap will make any double * function parameters with name <TT>OUTVALUE</TT> take an
+argument of MyDouble instead of double *. This will
+allow the calling function to read the double * value after returning from the function.
+*/
+%typemap(in) double *OUTVALUE {
+ jclass clazz = jenv->FindClass("MyDouble");
+ jfieldID fid = jenv->GetFieldID(clazz, "swigCPtr", "J");
+ jlong cPtr = jenv->GetLongField($input, fid);
+ MyDouble *pMyDouble = NULL;
+ *(MyDouble **)&pMyDouble = *(MyDouble **)&cPtr;
+ $1 = &pMyDouble->value;
+}
+
+%typemap(jtype) double *OUTVALUE "MyDouble"
+%typemap(jstype) double *OUTVALUE "MyDouble"
+%typemap(jni) double *OUTVALUE "jobject"
+
+%typemap(javain) double *OUTVALUE "$javainput"
+
+/* Now we apply the typemap to the named variables */
+%apply double *OUTVALUE { double *out1, double *out2 };
+int spam(double a, double b, double *out1, double *out2);
</PRE>
</DIV>
-<P> The typemap code is the same that is in "<TT>java.swg</TT>", barring
- the last two method modifiers. Note that <TT>SWIGTYPE</TT> will target
- all proxy classes, but not the type wrapper classes. Also the above
- typemap is only used for proxy classes that are potential base classes.
- To target proxy classes that are derived from a wrapped class as well,
- the "javabody_derived" typemap should also be overridden.</P>
-<P> For the typemap to be used in all type wrapper classes, all the
- different types that type wrapper classes could be used for should be
- targeted:</P>
+<P> Note that the C++ JNI calling convention has been used this time and
+ so must be compiled as C++ and the -c++ commandline must be passed to
+ SWIG. JNI error checking has been omitted for clarity.</P>
+<P> What the typemaps do are make the named <TT>double*</TT> function
+ parameters use our new <TT>MyDouble</TT> wrapper structure. The "in"
+ typemap takes this structure, gets the C++ pointer to it, takes the <TT>
+double value</TT> member variable and passes it to the C++ <TT>spam</TT>
+ function. In Java, when the function returns, we use the SWIG created <TT>
+getValue()</TT> function to get the output value. The following Java
+ program demonstrates this:</P>
<DIV class="code">
<PRE>
-%typemap(javabody) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
- private long swigCPtr;
+// File: runme.java
- protected $javaclassname(long cPtr, boolean bFutureUse) {
- swigCPtr = cPtr;
- }
+public class runme {
- protected $javaclassname() {
- swigCPtr = 0;
+ static {
+ try {
+ System.loadLibrary("example");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. " + e);
+ System.exit(1);
+ }
}
- protected static long getCPtr($javaclassname obj) {
- return (obj == null) ? 0 : obj.swigCPtr;
+ public static void main(String argv[]) {
+ MyDouble out1 = new MyDouble();
+ MyDouble out2 = new MyDouble();
+ int ret = example.spam(1.2, 3.4, out1, out2);
+ System.out.println(ret + " " + out1.getValue() + " " + out2.getValue());
}
-%}
+}
</PRE>
</DIV>
-<P> Again this is the same that is in "<TT>java.swg</TT>", barring the
- method modifier for <TT>getCPtr</TT>.</P>
-<P> When using <A href="Modules.html">multiple modules</A> or the <A href="#Java_namespaces">
-nspace feature</A> it is common to invoke SWIG with a different <TT>
--package</TT> command line option for each module. However, by default
- the generated code may not compile if generated classes in one package
- use generated classes in another package. The visibility of the <TT>
-getCPtr()</TT> and pointer constructor generated from the <TT>javabody</TT>
- typemaps needs changing. The default visibility is <TT>protected</TT>
- but it needs to be <TT>public</TT> for access from a different package.
- Just changing 'protected' to 'public' in the typemap achieves this. Two
- macros are available in <TT>java.swg</TT> to make this easier and using
- them is the preferred approach over simply copying the typemaps and
- modifying as this is forward compatible with any changes in the <TT>
-javabody</TT> typemap in future versions of SWIG. The macros are for the
- proxy and typewrapper classes and can respectively be used to to make
- the method and constructor public:</P>
+<P> When compiled and run we get:</P>
<DIV class="code">
<PRE>
- SWIG_JAVABODY_PROXY(public, public, SWIGTYPE)
- SWIG_JAVABODY_TYPEWRAPPER(public, public, public, SWIGTYPE)
+$ java runme
+1 12.0 340.0
</PRE>
</DIV>
-<H3><A name="Java_directors_typemaps"></A>24.9.10 Director specific
- typemaps</H3>
-<P> The Java directors feature requires the "javadirectorin",
- "javadirectorout", "directorin" and the "directorout" typemaps in order
- to work properly. The "javapackage" typemap is an optional typemap used
- to identify the Java package path for individual SWIG generated proxy
- classes used in director methods.</P>
-<P><TT>%typemap(directorin)</TT></P>
-<DIV class="indent">
-<P> The "directorin" typemap is used for converting arguments in the C++
- director class to the appropriate JNI type before the upcall to Java.
- This typemap also specifies the JNI field descriptor for the type in
- the "descriptor" attribute. For example, integers are converted as
- follows:</P>
+<H3><A name="Java_adding_downcasts">25.10.7 Adding Java downcasts to
+ polymorphic return types</A></H3>
+<P> SWIG support for polymorphism works in that the appropriate virtual
+ function is called. However, the default generated code does not allow
+ for downcasting. Let's examine this with the following code:</P>
<DIV class="code">
<PRE>
-%typemap(directorin,descriptor="I") int "$input = (jint) $1;"
+%include "std_string.i"
+
+#include <iostream>
+using namespace std;
+class Vehicle {
+public:
+ virtual void start() = 0;
+...
+};
+
+class Ambulance : public Vehicle {
+ string vol;
+public:
+ Ambulance(string volume) : vol(volume) {}
+ virtual void start() {
+ cout << "Ambulance started" << endl;
+ }
+ void sound_siren() {
+ cout << vol << " siren sounded!" << endl;
+ }
+...
+};
+
+Vehicle *vehicle_factory() {
+ return new Ambulance("Very loud");
+}
</PRE>
</DIV>
-<P> <CODE>$input</CODE> is the SWIG name of the JNI temporary variable
- passed to Java in the upcall. The <CODE>descriptor="I"</CODE> will put
- an <CODE>I</CODE> into the JNI field descriptor that identifies the
- Java method that will be called from C++. For more about JNI field
- descriptors and their importance, refer to the <A href="#Java_typemaps">
-JNI documentation mentioned earlier</A>. A typemap for C character
- strings is:</P>
+<P> If we execute the following Java code:</P>
<DIV class="code">
<PRE>
-%typemap(directorin,descriptor="Ljava/lang/String;") char *
- %{ $input = jenv->NewStringUTF($1); %}
+Vehicle vehicle = example.vehicle_factory();
+vehicle.start();
+
+Ambulance ambulance = (Ambulance)vehicle;
+ambulance.sound_siren();
</PRE>
</DIV>
-<P> User-defined types have the default "descriptor" attribute "<CODE>
-L$packagepath/$javaclassname;</CODE>" where <CODE>$packagepath</CODE> is
- the package name passed from the SWIG command line and <CODE>
-$javaclassname</CODE> is the Java proxy class' name. If the <TT>-package</TT>
- commandline option is not used to specify the package, then
- '$packagepath/' will be removed from the resulting output JNI field
- descriptor.<B> Do not forget the terminating ';' for JNI field
- descriptors starting with 'L'.</B> If the ';' is left out, Java will
- generate a "method not found" runtime error.</P>
-</DIV>
-<P><TT>%typemap(directorout)</TT></P>
-<DIV class="indent">
-<P> The "directorout" typemap is used for converting the JNI return type
- in the C++ director class to the appropriate C++ type after the upcall
- to Java. For example, integers are converted as follows:</P>
+<P> We get:</P>
<DIV class="code">
<PRE>
-%typemap(directorout) int %{ $result = (int)$input; %}
+Ambulance started
+java.lang.ClassCastException
+ at runme.main(runme.java:16)
</PRE>
</DIV>
-<P> <CODE>$input</CODE> is the SWIG name of the JNI temporary variable
- returned from Java after the upcall. <CODE>$result</CODE> is the
- resulting output. A typemap for C character strings is:</P>
+<P> Even though we know from examination of the C++ code that <TT>
+vehicle_factory</TT> returns an object of type <TT>Ambulance</TT>, we
+ are not able to use this knowledge to perform the downcast in Java.
+ This occurs because the runtime type information is not completely
+ passed from C++ to Java when returning the type from <TT>
+vehicle_factory()</TT>. Usually this is not a problem as virtual
+ functions do work by default, such as in the case of <TT>start()</TT>.
+ There are a few solutions to getting downcasts to work.</P>
+<P> The first is not to use a Java cast but a call to C++ to make the
+ cast. Add this to your code:</P>
<DIV class="code">
<PRE>
-%typemap(directorout) char * {
- $1 = 0;
- if ($input) {
- $result = (char *)jenv->GetStringUTFChars($input, 0);
- if (!$1) return $null;
- }
+%exception Ambulance::dynamic_cast(Vehicle *vehicle) {
+ $action
+ if (!result) {
+ jclass excep = jenv->FindClass("java/lang/ClassCastException");
+ if (excep) {
+ jenv->ThrowNew(excep, "dynamic_cast exception");
+ }
+ }
}
+%extend Ambulance {
+ static Ambulance *dynamic_cast(Vehicle *vehicle) {
+ return dynamic_cast<Ambulance *>(vehicle);
+ }
+};
</PRE>
-</DIV></DIV>
-<P><TT>%typemap(javadirectorin)</TT></P>
-<DIV class="indent">
-<P> Conversion from jtype to jstype for director methods. These are Java
- code typemaps which transform the type used in the Java intermediary
- JNI class (as specified in the "jtype" typemap) to the Java type used
- in the Java module class, proxy classes and type wrapper classes (as
- specified in the "jstype" typemap). This typemap provides the
- conversion for the parameters in the director methods when calling up
- from C++ to Java.</P>
-<P> For primitive types, this typemap is usually specified as:</P>
+</DIV>
+<P> It would then be used from Java like this</P>
<DIV class="code">
<PRE>
-%typemap(javadirectorin) int "$jniinput"
+Ambulance ambulance = Ambulance.dynamic_cast(vehicle);
+ambulance.sound_siren();
</PRE>
</DIV>
-<P> The <CODE>$jniinput</CODE> special variable is analogous to <CODE>
-$javainput</CODE> special variable. It is replaced by the input
- parameter name.</P>
-</DIV>
-<P><TT>%typemap(javadirectorout)</TT></P>
-<DIV class="indent">
-<P> Conversion from jstype to jtype for director methods. These are Java
- code typemaps which transform the type used in the Java module class,
- proxy classes and type wrapper classes (as specified in the "jstype"
- typemap) to the type used in the Java intermediary JNI class (as
- specified in the "jtype" typemap). This typemap provides the conversion
- for the return type in the director methods when returning from the C++
- to Java upcall.</P>
-<P> For primitive types, this typemap is usually specified as:</P>
+<P> Should <TT>vehicle</TT> not be of type <TT>ambulance</TT> then a
+ Java <TT>ClassCastException</TT> is thrown. The next solution is a
+ purer solution in that Java downcasts can be performed on the types.
+ Add the following before the definition of <TT>vehicle_factory</TT>:</P>
<DIV class="code">
<PRE>
-%typemap(javadirectorout) int "$javacall"
+%typemap(out) Vehicle * {
+ Ambulance *downcast = dynamic_cast<Ambulance *>($1);
+ *(Ambulance **)&$result = downcast;
+}
+
+%typemap(javaout) Vehicle * {
+ return new Ambulance($jnicall, $owner);
+ }
</PRE>
</DIV>
-<P> The <CODE>$javacall</CODE> special variable is analogous to the <CODE>
-$jnicall</CODE> special variable. It is replaced by the call to the
- target Java method. The target method is the method in the Java proxy
- class which overrides the virtual C++ method in the C++ base class.</P>
-</DIV>
-<P><TT>%typemap(javapackage)</TT></P>
-<DIV class="indent">
-<P> The "javapackage" typemap is optional; it serves to identify a
- class's Java package. This typemap should be used in conjunction with
- classes that are defined outside of the current SWIG interface file.
- The typemap is only used if the type is used in a director method, that
- is, in a virtual method in a director class. For example:</P>
+<P> Here we are using our knowledge that <TT>vehicle_factory</TT> always
+ returns type <TT>Ambulance</TT> so that the Java proxy is created as a
+ type <TT>Ambulance</TT>. If <TT>vehicle_factory</TT> can manufacture
+ any type of <TT>Vehicle</TT> and we want to be able to downcast using
+ Java casts for any of these types, then a different approach is needed.
+ Consider expanding our example with a new Vehicle type and a more
+ flexible factory function:</P>
<DIV class="code">
<PRE>
-// class Foo is handled in a different interface file:
-%import "Foo.i"
-
-%feature("director") Example;
-
-%inline {
- class Bar { };
-
- class Example {
- public:
- virtual ~Example();
- virtual void ping(Foo *arg1, Bar *arg2);
- };
+class FireEngine : public Vehicle {
+public:
+ FireEngine() {}
+ virtual void start() {
+ cout << "FireEngine started" << endl;
+ }
+ void roll_out_hose() {
+ cout << "Hose rolled out" << endl;
+ }
+ ...
+};
+Vehicle *vehicle_factory(int vehicle_number) {
+ if (vehicle_number == 0)
+ return new Ambulance("Very loud");
+ else
+ return new FireEngine();
}
</PRE>
</DIV>
-<P> Assume that the Foo class is part of the Java package<I>
- com.wombat.foo</I> but the above interface file is part of the Java
- package<I> com.wombat.example</I>. Without the "javapackage" typemap,
- SWIG will assume that the Foo class belongs to<I> com.wombat.example</I>
- class. The corrected interface file looks like:</P>
+<P> To be able to downcast with this sort of Java code:</P>
<DIV class="code">
<PRE>
-// class Foo is handled in a different interface file:
-%import "Foo.i"
-%typemap("javapackage") Foo, Foo *, Foo & "com.wombat.foo";
-%feature("director") Example;
-
-%inline {
- class Bar { };
-
- class Example {
- public:
- virtual ~Example();
- virtual void ping(Foo *arg1, Bar *arg2);
- };
-}
+FireEngine fireengine = (FireEngine)example.vehicle_factory(1);
+fireengine.roll_out_hose();
+Ambulance ambulance = (Ambulance)example.vehicle_factory(0);
+ambulance.sound_siren();
</PRE>
</DIV>
-<P> SWIG looks up the package based on the<B> actual</B> type (plain
- Foo, Foo pointer and Foo reference), so it is important to associate
- all three types with the desired package. Practically speaking, you
- should create a separate SWIG interface file, which is %import-ed into
- each SWIG interface file, when you have multiple Java packages. Note
- the helper macros below, <CODE>OTHER_PACKAGE_SPEC</CODE> and <CODE>
-ANOTHER_PACKAGE_SPEC</CODE>, which reduce the amount of extra typing. "<CODE>
-TYPE...</CODE>" is useful when passing templated types to the macro,
- since multiargument template types appear to the SWIG preprocessor as
- multiple macro arguments.</P>
+<P> the following typemaps targeted at the <TT>vehicle_factory</TT>
+ function will achieve this. Note that in this case, the Java class is
+ constructed using JNI code rather than passing a pointer across the JNI
+ boundary in a Java long for construction in Java code.</P>
<DIV class="code">
<PRE>
-%typemap("javapackage") SWIGTYPE, SWIGTYPE *, SWIGTYPE &
- "package.for.most.classes";
-
-%define OTHER_PACKAGE_SPEC(TYPE...)
-%typemap("javapackage") TYPE, TYPE *, TYPE & "package.for.other.classes";
-%enddef
+%typemap(jni) Vehicle *vehicle_factory "jobject"
+%typemap(jtype) Vehicle *vehicle_factory "Vehicle"
+%typemap(jstype) Vehicle *vehicle_factory "Vehicle"
+%typemap(javaout) Vehicle *vehicle_factory {
+ return $jnicall;
+ }
-%define ANOTHER_PACKAGE_SPEC(TYPE...)
-%typemap("javapackage") TYPE, TYPE *, TYPE & "package.for.another.set";
-%enddef
+%typemap(out) Vehicle *vehicle_factory {
+ Ambulance *ambulance = dynamic_cast<Ambulance *>($1);
+ FireEngine *fireengine = dynamic_cast<FireEngine *>($1);
+ if (ambulance) {
+ // call the Ambulance(long cPtr, boolean cMemoryOwn) constructor
+ jclass clazz = jenv->FindClass("Ambulance");
+ if (clazz) {
+ jmethodID mid = jenv->GetMethodID(clazz, "<init>", "(JZ)V");
+ if (mid) {
+ jlong cptr = 0;
+ *(Ambulance **)&cptr = ambulance;
+ $result = jenv->NewObject(clazz, mid, cptr, false);
+ }
+ }
+ } else if (fireengine) {
+ // call the FireEngine(long cPtr, boolean cMemoryOwn) constructor
+ jclass clazz = jenv->FindClass("FireEngine");
+ if (clazz) {
+ jmethodID mid = jenv->GetMethodID(clazz, "<init>", "(JZ)V");
+ if (mid) {
+ jlong cptr = 0;
+ *(FireEngine **)&cptr = fireengine;
+ $result = jenv->NewObject(clazz, mid, cptr, false);
+ }
+ }
+ }
+ else {
+ cout << "Unexpected type " << endl;
+ }
-OTHER_PACKAGE_SPEC(Package_2_class_one)
-ANOTHER_PACKAGE_SPEC(Package_3_class_two)
-/* etc */
+ if (!$result)
+ cout << "Failed to create new java object" << endl;
+}
</PRE>
</DIV>
-<P> The basic strategy here is to provide a default package typemap for
- the majority of the classes, only providing "javapackage" typemaps for
- the exceptions.</P>
-</DIV>
-<H2><A name="Java_typemap_examples"></A>24.10 Typemap Examples</H2>
-<P> This section includes a few examples of typemaps. For more examples,
- you might look at the files "<TT>java.swg</TT>" and "<TT>typemaps.i</TT>
-" in the SWIG library.</P>
-<H3><A name="Java_simpler_enum_classes"></A>24.10.1 Simpler Java enums
- for enums without initializers</H3>
-<P> The default <A href="#Java_proper_enums_classes">Proper Java enums</A>
- approach to wrapping enums is somewhat verbose. This is to handle all
- possible C/C++ enums, in particular enums with initializers. The
- generated code can be simplified if the enum being wrapped does not
- have any initializers.</P>
-<P> The following shows how to remove the support methods that are
- generated by default and instead use the methods in the Java enum base
- class <TT>java.lang.Enum</TT> and <TT>java.lang.Class</TT> for
- marshalling enums between C/C++ and Java. The type used for the
- typemaps below is <TT>enum SWIGTYPE</TT> which is the default type used
- for all enums. The "enums.swg" file should be examined in order to see
- the original overridden versions of the typemaps.</P>
-<DIV class="code">
-<PRE>
-%include "enums.swg"
-
-%typemap(javain) enum SWIGTYPE "$javainput.ordinal()"
-%typemap(javaout) enum SWIGTYPE {
- return $javaclassname.class.getEnumConstants()[$jnicall];
+<P> Better error handling would need to be added into this code. There
+ are other solutions to this problem, but this last example demonstrates
+ some more involved JNI code. SWIG usually generates code which
+ constructs the proxy classes using Java code as it is easier to handle
+ error conditions and is faster. Note that the JNI code above uses a
+ number of string lookups to call a constructor, whereas this would not
+ occur using byte compiled Java code.</P>
+<H3><A name="Java_adding_equals_method">25.10.8 Adding an equals method
+ to the Java classes</A></H3>
+<P> When a pointer is returned from a JNI function, it is wrapped using
+ a new Java proxy class or type wrapper class. Even when the pointers
+ are the same, it will not be possible to know that the two Java classes
+ containing those pointers are actually the same object. It is common in
+ Java to use the <TT>equals()</TT> method to check whether two objects
+ are equivalent. The <TT>equals()</TT> method is usually accompanied by
+ a <TT>hashCode()</TT> method in order to fulfill the requirement that
+ the hash code is equal for equal objects. Pure Java code methods like
+ these can be easily added:</P>
+<DIV class="code">
+<PRE>
+%typemap(javacode) SWIGTYPE %{
+ public boolean equals(Object obj) {
+ boolean equal = false;
+ if (obj instanceof $javaclassname)
+ equal = ((($javaclassname)obj).swigCPtr == this.swigCPtr);
+ return equal;
+ }
+ public int hashCode() {
+ return (int)getPointer();
}
-%typemap(javabody) enum SWIGTYPE ""
-
-%inline %{
- enum HairType { blonde, ginger, brunette };
- void setHair(HairType h);
- HairType getHair();
%}
+
+class Foo { };
+Foo* returnFoo(Foo *foo) { return foo; }
</PRE>
</DIV>
-<P> SWIG will generate the following Java enum, which is somewhat
- simpler than the default:</P>
+<P> The following would display <TT>false</TT> without the <TT>javacode</TT>
+ typemap above. With the typemap defining the <TT>equals</TT> method the
+ result is <TT>true</TT>.</P>
<DIV class="code">
<PRE>
-public enum HairType {
- blonde,
- ginger,
- brunette;
-}
+Foo foo1 = new Foo();
+Foo foo2 = example.returnFoo(foo1);
+System.out.println("foo1? " + foo1.equals(foo2));
</PRE>
</DIV>
-<P> and the two Java proxy methods will be:</P>
+<H3><A name="Java_void_pointers">25.10.9 Void pointers and a common Java
+ base class</A></H3>
+<P> One might wonder why the common code that SWIG emits for the proxy
+ and type wrapper classes is not pushed into a base class. The reason is
+ that although <TT>swigCPtr</TT> could be put into a common base class
+ for all classes wrapping C structures, it would not work for C++
+ classes involved in an inheritance chain. Each class derived from a
+ base needs a separate <TT>swigCPtr</TT> because C++ compilers sometimes
+ use a different pointer value when casting a derived class to a base.
+ Additionally as Java only supports single inheritance, it would not be
+ possible to derive wrapped classes from your own pure Java classes if
+ the base class has been 'used up' by SWIG. However, you may want to
+ move some of the common code into a base class. Here is an example
+ which uses a common base class for all proxy classes and type wrapper
+ classes:</P>
<DIV class="code">
<PRE>
-public static void setHair(HairType h) {
- exampleJNI.setHair(h.ordinal());
-}
+%typemap(javabase) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [],
+ SWIGTYPE (CLASS::*) "SWIG"
-public static HairType getHair() {
- return HairType.class.getEnumConstants()[exampleJNI.getHair()];
-}
+%typemap(javacode) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [],
+ SWIGTYPE (CLASS::*) %{
+ protected long getPointer() {
+ return swigCPtr;
+ }
+%}
</PRE>
</DIV>
-<P> For marshalling Java enums to C/C++ enums, the <TT>ordinal</TT>
- method is used to convert the Java enum into an integer value for
- passing to the JNI layer, see the "javain" typemap. For marshalling
- C/C++ enums to Java enums, the C/C++ enum value is cast to an integer
- in the C/C++ typemaps (not shown). This integer value is then used to
- index into the array of enum constants that the Java language provides.
- See the <TT>getEnumConstants</TT> method in the "javaout" typemap.</P>
-<P> These typemaps can often be used as the default for wrapping enums
- as in many cases there won't be any enum initializers. In fact a good
- strategy is to always use these typemaps and to specifically handle
- enums with initializers using %apply. This would be done by using the
- original versions of these typemaps in "enums.swg" under another
- typemap name for applying using %apply.</P>
-<H3><A name="Java_exception_typemap"></A>24.10.2 Handling C++ exception
- specifications as Java exceptions</H3>
-<P> This example demonstrates various ways in which C++ exceptions can
- be tailored and converted into Java exceptions. Let's consider a simple
- file class <TT>SimpleFile</TT> and an exception class <TT>FileException</TT>
- which it may throw on error:</P>
+<P> Define new base class called SWIG:</P>
<DIV class="code">
<PRE>
-%include "std_string.i" // for std::string typemaps
-#include <string>
+public abstract class SWIG {
+ protected abstract long getPointer();
-class FileException {
- std::string message;
-public:
- FileException(const std::string& msg) : message(msg) {}
- std::string what() {
- return message;
+ public boolean equals(Object obj) {
+ boolean equal = false;
+ if (obj instanceof SWIG)
+ equal = (((SWIG)obj).getPointer() == this.getPointer());
+ return equal;
}
-};
-
-class SimpleFile {
- std::string filename;
-public:
- SimpleFile(const std::string& filename) : filename(filename) {}
- void open() throw(FileException) {
- ...
+
+ SWIGTYPE_p_void getVoidPointer() {
+ return new SWIGTYPE_p_void(getPointer(), false);
}
-};
+}
</PRE>
</DIV>
-<P> As the <TT>open</TT> method has a C++ exception specification, SWIG
- will parse this and know that the method can throw an exception. The <A href="#throws_typemap">
-"throws" typemap</A> is then used when SWIG encounters an exception
- specification. The default generic "throws" typemap looks like this:</P>
+<P> This example contains some useful functionality which you may want
+ in your code.</P>
+<UL>
+<LI> It has an <TT>equals()</TT> method. Unlike the previous example,
+ the method code isn't replicated in all classes.</LI>
+<LI> It also has a function which effectively implements a cast from the
+ type of the proxy/type wrapper class to a void pointer. This is
+ necessary for passing a proxy class or a type wrapper class to a
+ function that takes a void pointer.</LI>
+</UL>
+<H3><A name="Java_struct_pointer_pointer">25.10.10 Struct pointer to
+ pointer</A></H3>
+<P> Pointers to pointers are often used as output parameters in C
+ factory type functions. These are a bit more tricky to handle. Consider
+ the following situation where a <TT>Butler</TT> can be hired and fired:</P>
<DIV class="code">
<PRE>
-%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [ANY] %{
- SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
- "C++ $1_type exception thrown");
- return $null;
-%}
+typedef struct {
+ int hoursAvailable;
+ char *greeting;
+} Butler;
+
+// Note: HireButler will allocate the memory
+// The caller must free the memory by calling FireButler()!!
+extern int HireButler(Butler **ppButler);
+extern void FireButler(Butler *pButler);
</PRE>
</DIV>
-<P> Basically SWIG will generate a C++ try catch block and the body of
- the "throws" typemap constitutes the catch block. The above typemap
- calls a SWIG supplied method which throws a <TT>
-java.lang.RuntimeException</TT>. This exception class is a runtime
- exception and therefore not a checked exception. If, however, we wanted
- to throw a checked exception, say <TT>java.io.IOException</TT>, then we
- could use the following typemap:</P>
+<P> C code implementation:</P>
<DIV class="code">
<PRE>
-%typemap(throws, throws="java.io.IOException") FileException {
- jclass excep = jenv->FindClass("java/io/IOException");
- if (excep)
- jenv->ThrowNew(excep, $1.what().c_str());
- return $null;
+int HireButler(Butler **ppButler) {
+ Butler *pButler = (Butler *)malloc(sizeof(Butler));
+ pButler->hoursAvailable = 24;
+ pButler->greeting = (char *)malloc(32);
+ strcpy(pButler->greeting, "At your service Sir");
+ *ppButler = pButler;
+ return 1;
+}
+void FireButler(Butler *pButler) {
+ free(pButler->greeting);
+ free(pButler);
}
</PRE>
</DIV>
-<P> Note that this typemap uses the 'throws' <A href="#Java_typemap_attributes">
-typemap attribute</A> to ensure a throws clause is generated. The
- generated proxy method then specifies the checked exception by
- containing <TT>java.io.IOException</TT> in the throws clause:</P>
+<P> Let's take two approaches to wrapping this code. The first is to
+ provide a functional interface, much like the original C interface. The
+ following Java code shows how we intend the code to be used:</P>
<DIV class="code">
<PRE>
-public class SimpleFile {
- ...
- public void open() throws java.io.IOException { ... }
-}
+ Butler jeeves = new Butler();
+ example.HireButler(jeeves);
+ System.out.println("Greeting: " + jeeves.getGreeting());
+ System.out.println("Availability: " + jeeves.getHoursAvailable() + " hours per day");
+ example.FireButler(jeeves);
</PRE>
</DIV>
-<P> Lastly, if you don't want to map your C++ exception into one of the
- standard Java exceptions, the C++ class can be wrapped and turned into
- a custom Java exception class. If we go back to our example, the first
- thing we must do is get SWIG to wrap <TT>FileException</TT> and ensure
- that it derives from <TT>java.lang.Exception</TT>. Additionally, we
- might want to override the <TT>java.lang.Exception.getMessage()</TT>
- method. The typemaps to use then are as follows:</P>
-<DIV class="code">
+<P> Resulting in the following output when run:</P>
+<DIV class="shell">
<PRE>
-%typemap(javabase) FileException "java.lang.Exception";
-%typemap(javacode) FileException %{
- public String getMessage() {
- return what();
- }
-%}
+Greeting: At your service Sir
+Availability: 24 hours per day
</PRE>
</DIV>
-<P> This generates:</P>
+<P> Note the usage is very much like it would be used if we were writing
+ C code, that is, explicit memory management is needed. No C memory is
+ allocated in the construction of the <TT>Butler</TT> proxy class and
+ the proxy class will not destroy the underlying C memory when it is
+ collected. A number of typemaps and features are needed to implement
+ this approach. The following interface file code should be placed
+ before SWIG parses the above C code.</P>
<DIV class="code">
<PRE>
-public class FileException extends java.lang.Exception {
- ...
- public String getMessage() {
- return what();
- }
+%module example
- public FileException(String msg) { ... }
+// Do not generate the default proxy constructor or destructor
+%nodefaultctor Butler;
+%nodefaultdtor Butler;
- public String what() {
- return exampleJNI.FileException_what(swigCPtr, this);
+// Add in pure Java code proxy constructor
+%typemap(javacode) Butler %{
+ /** This constructor creates the proxy which initially does not create nor own any C memory */
+ public Butler() {
+ this(0, false);
}
+%}
+
+// Type typemaps for marshalling Butler **
+%typemap(jni) Butler ** "jobject"
+%typemap(jtype) Butler ** "Butler"
+%typemap(jstype) Butler ** "Butler"
+
+// Typemaps for Butler ** as a parameter output type
+%typemap(in) Butler ** (Butler *ppButler = 0) %{
+ $1 = &ppButler;
+%}
+%typemap(argout) Butler ** {
+ // Give Java proxy the C pointer (of newly created object)
+ jclass clazz = (*jenv)->FindClass(jenv, "Butler");
+ jfieldID fid = (*jenv)->GetFieldID(jenv, clazz, "swigCPtr", "J");
+ jlong cPtr = 0;
+ *(Butler **)&cPtr = *$1;
+ (*jenv)->SetLongField(jenv, $input, fid, cPtr);
}
+%typemap(javain) Butler ** "$javainput"
</PRE>
</DIV>
-<P> We could alternatively have used <TT>%rename</TT> to rename <TT>
-what()</TT> into <TT>getMessage()</TT>.</P>
-<H3><A name="Java_nan_exception_typemap"></A>24.10.3 NaN Exception -
- exception handling for a particular type</H3>
-<P> A Java exception can be thrown from any Java or JNI code. Therefore,
- as most typemaps contain either Java or JNI code, just about any
- typemap could throw an exception. The following example demonstrates
- exception handling on a type by type basis by checking for 'Not a
- number' (NaN) whenever a parameter of type <TT>float</TT> is wrapped.</P>
-<P> Consider the following C++ code:</P>
-<DIV class="code">
-<PRE>
-bool calculate(float first, float second);
-</PRE>
-</DIV>
-<P> To validate every <TT>float</TT> being passed to C++, we could
- precede the code being wrapped by the following typemap which throws a
- runtime exception whenever the <TT>float</TT> is 'Not a Number':</P>
+<P> Note that the JNI code sets the proxy's <TT>swigCPtr</TT> member
+ variable to point to the newly created object. The <TT>swigCMemOwn</TT>
+ remains unchanged (at false), so that the proxy does not own the
+ memory.</P>
+<P> Note: The old %nodefault directive disabled the default constructor
+ and destructor at the same time. This is unsafe in most of the cases,
+ and you can use the explicit %nodefaultctor and %nodefaultdtor
+ directives to achieve the same result if needed.</P>
+<P> The second approach offers a more object oriented interface to the
+ Java user. We do this by making the Java proxy class's constructor call
+ the <TT>HireButler()</TT> method to create the underlying C object.
+ Additionally we get the proxy to take ownership of the memory so that
+ the finalizer will call the <TT>FireButler()</TT> function. The proxy
+ class will thus take ownership of the memory and clean it up when no
+ longer needed. We will also prevent the user from being able to
+ explicitly call the <TT>HireButler()</TT> and <TT>FireButler()</TT>
+ functions. Usage from Java will simply be:</P>
<DIV class="code">
<PRE>
-%module example
-%typemap(javain) float "$module.CheckForNaN($javainput)"
-%pragma(java) modulecode=%{
- /** Simply returns the input value unless it is not a number,
- whereupon an exception is thrown. */
- static protected float CheckForNaN(float num) {
- if (Float.isNaN(num))
- throw new RuntimeException("Not a number");
- return num;
- }
-%}
+Butler jeeves = new Butler();
+System.out.println("Greeting: " + jeeves.getGreeting());
+System.out.println("Availability: " + jeeves.getHoursAvailable() + " hours per day");
</PRE>
</DIV>
-<P> Note that the <TT>CheckForNaN</TT> support method has been added to
- the module class using the <TT>modulecode</TT> pragma. The following
- shows the generated code of interest:</P>
+<P> Note that the Butler class is used just like any other Java class
+ and no extra coding by the user needs to be written to clear up the
+ underlying C memory as the finalizer will be called by the garbage
+ collector which in turn will call the <TT>FireButler()</TT> function.
+ To implement this, we use the above interface file code but remove the <TT>
+javacode</TT> typemap and add the following:</P>
<DIV class="code">
<PRE>
-public class example {
- ...
-
- /** Simply returns the input value unless it is not a number,
- whereupon an exception is thrown. */
- static protected float CheckForNaN(float num) {
- if (Float.isNaN(num))
- throw new RuntimeException("Not a number");
- return num;
- }
+// Don't expose the memory allocation/de-allocation functions
+%ignore FireButler(Butler *pButler);
+%ignore HireButler(Butler **ppButler);
- public static boolean calculate(float first, float second) {
- return exampleJNI.calculate(example.CheckForNaN(first), example.CheckForNaN(second));
+// Add in a custom proxy constructor and destructor
+%extend Butler {
+ Butler() {
+ Butler *pButler = 0;
+ HireButler(&pButler);
+ return pButler;
}
+ ~Butler() {
+ FireButler($self);
+ }
}
</PRE>
</DIV>
-<P> Note that the "javain" typemap is used for every occurrence of a <TT>
-float</TT> being used as an input. Of course, we could have targeted the
- typemap at a particular parameter by using <TT>float first</TT>, say,
- instead of just <TT>float</TT>.</P>
-<P> The exception checking could alternatively have been placed into the
- 'pre' attribute that the "javain" typemap supports. The "javain"
- typemap above could be replaced with the following:</P>
-<DIV class="code">
-<PRE>
-%typemap(javain, pre=" $module.CheckForNaN($javainput);") float "$javainput"
-</PRE>
-</DIV>
-<P> which would modify the <TT>calculate</TT> function to instead be
- generated as:</P>
+<P> Note that the code in <TT>%extend</TT> is using a C++ type
+ constructor and destructor, yet the generated code will still compile
+ as C code, see <A href="#SWIG_adding_member_functions">Adding member
+ functions to C structures</A>. The C functional interface has been
+ completely morphed into an object-oriented interface and the Butler
+ class would behave much like any pure Java class and feel more natural
+ to Java users.</P>
+<H3><A name="Java_memory_management_member_variables">25.10.11 Memory
+ management when returning references to member variables</A></H3>
+<P> This example shows how to prevent premature garbage collection of
+ objects when the underlying C++ class returns a pointer or reference to
+ a member variable.</P>
+<P> Consider the following C++ code:</P>
<DIV class="code">
<PRE>
-public class example {
- ...
- public static boolean calculate(float first, float second) {
- example.CheckForNaN(first);
- example.CheckForNaN(second);
- {
- return exampleJNI.calculate(first, second);
- }
- }
-}
+struct Wheel {
+ int size;
+ Wheel(int sz) : size(sz) {}
+};
+
+class Bike {
+ Wheel wheel;
+public:
+ Bike(int val) : wheel(val) {}
+ Wheel& getWheel() { return wheel; }
+};
</PRE>
</DIV>
-<P> See the <A href="#Java_date_marshalling">Date marshalling example</A>
- for an example using further "javain" typemap attributes.</P>
-<P> If we decide that what we actually want is a checked exception
- instead of a runtime exception, we can change this easily enough. The
- proxy method that uses <TT>float</TT> as an input, must then add the
- exception class to the throws clause. SWIG can handle this as it
- supports the 'throws' <A href="#Java_typemap_attributes">typemap
- attribute</A> for specifying classes for the throws clause. Thus we can
- modify the pragma and the typemap for the throws clause:</P>
+<P> and the following usage from Java after running the code through
+ SWIG:</P>
<DIV class="code">
<PRE>
-%typemap(javain, throws="java.lang.Exception") float "$module.CheckForNaN($javainput)"
-%pragma(java) modulecode=%{
- /** Simply returns the input value unless it is not a number,
- whereupon an exception is thrown. */
- static protected float CheckForNaN(float num) throws java.lang.Exception {
- if (Float.isNaN(num))
- throw new RuntimeException("Not a number");
- return num;
- }
-%}
+ Wheel wheel = new Bike(10).getWheel();
+ System.out.println("wheel size: " + wheel.getSize());
+ // Simulate a garbage collection
+ System.gc();
+ System.runFinalization();
+ System.out.println("wheel size: " + wheel.getSize());
</PRE>
</DIV>
-<P> The <TT>calculate</TT> method now has a throws clause and even
- though the typemap is used twice for both <TT>float first</TT> and <TT>
-float second</TT>, the throws clause contains a single instance of <TT>
-java.lang.Exception</TT>:</P>
-<DIV class="code">
+<P> Don't be surprised that if the resulting output gives strange
+ results such as...</P>
+<DIV class="shell">
<PRE>
-public class example {
- ...
-
- /** Simply returns the input value unless it is not a number,
- whereupon an exception is thrown. */
- static protected float CheckForNaN(float num) throws java.lang.Exception {
- if (Float.isNaN(num))
- throw new RuntimeException("Not a number");
- return num;
- }
-
- public static boolean calculate(float first, float second) throws java.lang.Exception {
- return exampleJNI.calculate(example.CheckForNaN(first), example.CheckForNaN(second));
- }
-}
+wheel size: 10
+wheel size: 135019664
</PRE>
</DIV>
-<P> If we were a martyr to the JNI cause, we could replace the succinct
- code within the "javain" typemap with a few pages of JNI code. If we
- had, we would have put it in the "in" typemap which, like all JNI and
- Java typemaps, also supports the 'throws' attribute.</P>
-<H3><A name="Java_converting_java_string_arrays"></A>24.10.4 Converting
- Java String arrays to char **</H3>
-<P> A common problem in many C programs is the processing of command
- line arguments, which are usually passed in an array of NULL terminated
- strings. The following SWIG interface file allows a Java String array
- to be used as a <TT>char **</TT> object.</P>
+<P> What has happened here is the garbage collector has collected the <TT>
+Bike</TT> instance as it doesn't think it is needed any more. The proxy
+ instance, <TT>wheel</TT>, contains a reference to memory that was
+ deleted when the <TT>Bike</TT> instance was collected. In order to
+ prevent the garbage collector from collecting the <TT>Bike</TT>
+ instance a reference to the <TT>Bike</TT> must be added to the <TT>
+wheel</TT> instance. You can do this by adding the reference when the <TT>
+getWheel()</TT> method is called using the following typemaps.</P>
<DIV class="code">
<PRE>
-%module example
-
-/* This tells SWIG to treat char ** as a special case when used as a parameter
- in a function call */
-%typemap(in) char ** (jint size) {
- int i = 0;
- size = (*jenv)->GetArrayLength(jenv, $input);
- $1 = (char **) malloc((size+1)*sizeof(char *));
- /* make a copy of each string */
- for (i = 0; i<size; i++) {
- jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, $input, i);
- const char * c_string = (*jenv)->GetStringUTFChars(jenv, j_string, 0);
- $1[i] = malloc((strlen(c_string)+1)*sizeof(char));
- strcpy($1[i], c_string);
- (*jenv)->ReleaseStringUTFChars(jenv, j_string, c_string);
- (*jenv)->DeleteLocalRef(jenv, j_string);
- }
- $1[i] = 0;
-}
-
-/* This cleans up the memory we malloc'd before the function call */
-%typemap(freearg) char ** {
- int i;
- for (i=0; i<size$argnum-1; i++)
- free($1[i]);
- free($1);
-}
-
-/* This allows a C function to return a char ** as a Java String array */
-%typemap(out) char ** {
- int i;
- int len=0;
- jstring temp_string;
- const jclass clazz = (*jenv)->FindClass(jenv, "java/lang/String");
-
- while ($1[len]) len++;
- jresult = (*jenv)->NewObjectArray(jenv, len, clazz, NULL);
- /* exception checking omitted */
-
- for (i=0; i<len; i++) {
- temp_string = (*jenv)->NewStringUTF(jenv, *result++);
- (*jenv)->SetObjectArrayElement(jenv, jresult, i, temp_string);
- (*jenv)->DeleteLocalRef(jenv, temp_string);
- }
-}
-
-/* These 3 typemaps tell SWIG what JNI and Java types to use */
-%typemap(jni) char ** "jobjectArray"
-%typemap(jtype) char ** "String[]"
-%typemap(jstype) char ** "String[]"
-
-/* These 2 typemaps handle the conversion of the jtype to jstype typemap type
- and vice versa */
-%typemap(javain) char ** "$javainput"
-%typemap(javaout) char ** {
- return $jnicall;
- }
-
-/* Now a few test functions */
-%inline %{
-
-int print_args(char **argv) {
- int i = 0;
- while (argv[i]) {
- printf("argv[%d] = %s\n", i, argv[i]);
- i++;
- }
- return i;
-}
-
-char **get_args() {
- static char *values[] = { "Dave", "Mike", "Susan", "John", "Michelle", 0};
- return &values[0];
-}
-
+%typemap(javacode) Wheel %{
+ // Ensure that the GC doesn't collect any Bike instance set from Java
+ private Bike bikeReference;
+ protected void addReference(Bike bike) {
+ bikeReference = bike;
+ }
%}
+
+// Add a Java reference to prevent premature garbage collection and resulting use
+// of dangling C++ pointer. Intended for methods that return pointers or
+// references to a member variable.
+%typemap(javaout) Wheel& getWheel {
+ long cPtr = $jnicall;
+ $javaclassname ret = null;
+ if (cPtr != 0) {
+ ret = new $javaclassname(cPtr, $owner);
+ ret.addReference(this);
+ }
+ return ret;
+ }
</PRE>
</DIV>
-<P> Note that the 'C' JNI calling convention is used. Checking for any
- thrown exceptions after JNI function calls has been omitted. When this
- module is compiled, our wrapped C functions can be used by the
- following Java program:</P>
+<P> The code in the first typemap gets added to the <TT>Wheel</TT> proxy
+ class. The code in the second typemap constitutes the bulk of the code
+ in the generated <TT>getWheel()</TT> function:</P>
<DIV class="code">
<PRE>
-// File runme.java
-
-public class runme {
-
- static {
- try {
- System.loadLibrary("example");
- } catch (UnsatisfiedLinkError e) {
- System.err.println("Native code library failed to load. " + e);
- System.exit(1);
- }
+public class Wheel {
+ ...
+ // Ensure that the GC doesn't collect any bike set from Java
+ private Bike bikeReference;
+ protected void addReference(Bike bike) {
+ bikeReference = bike;
}
+}
- public static void main(String argv[]) {
- String animals[] = {"Cat","Dog","Cow","Goat"};
- example.print_args(animals);
- String args[] = example.get_args();
- for (int i=0; i<args.length; i++)
- System.out.println(i + ":" + args[i]);
+public class Bike {
+ ...
+ public Wheel getWheel() {
+ long cPtr = exampleJNI.Bike_getWheel(swigCPtr, this);
+ Wheel ret = null;
+ if (cPtr != 0) {
+ ret = new Wheel(cPtr, false);
+ ret.addReference(this);
+ }
+ return ret;
}
}
</PRE>
</DIV>
-<P> When compiled and run we get:</P>
+<P> Note the <TT>addReference</TT> call.</P>
+<H3><A name="Java_memory_management_objects">25.10.12 Memory management
+ for objects passed to the C++ layer</A></H3>
+<P> Managing memory can be tricky when using C++ and Java proxy classes.
+ The previous example shows one such case and this example looks at
+ memory management for a class passed to a C++ method which expects the
+ object to remain in scope after the function has returned. Consider the
+ following two C++ classes:</P>
<DIV class="code">
<PRE>
-$ java runme
-argv[0] = Cat
-argv[1] = Dog
-argv[2] = Cow
-argv[3] = Goat
-0:Dave
-1:Mike
-2:Susan
-3:John
-4:Michelle
+struct Element {
+ int value;
+ Element(int val) : value(val) {}
+};
+class Container {
+ Element* element;
+public:
+ Container() : element(0) {}
+ void setElement(Element* e) { element = e; }
+ Element* getElement() { return element; }
+};
</PRE>
</DIV>
-<P> In the example, a few different typemaps are used. The "in" typemap
- is used to receive an input argument and convert it to a C array. Since
- dynamic memory allocation is used to allocate memory for the array, the
- "freearg" typemap is used to later release this memory after the
- execution of the C function. The "out" typemap is used for function
- return values. Lastly the "jni", "jtype" and "jstype" typemaps are also
- required to specify what Java types to use.</P>
-<H3><A name="Java_expanding_java_object"></A>24.10.5 Expanding a Java
- object to multiple arguments</H3>
-<P> Suppose that you had a collection of C functions with arguments such
- as the following:</P>
+<P> and usage from C++</P>
<DIV class="code">
<PRE>
-int foo(int argc, char **argv);
+ Container container;
+ Element element(20);
+ container.setElement(&element);
+ cout << "element.value: " << container.getElement()->value << endl;
</PRE>
</DIV>
-<P> In the previous example, a typemap was written to pass a Java String
- array as the <TT>char **argv</TT>. This allows the function to be used
- from Java as follows:</P>
+<P> and more or less equivalent usage from Java</P>
<DIV class="code">
<PRE>
-example.foo(4, new String[]{"red", "green", "blue", "white"});
+ Container container = new Container();
+ container.setElement(new Element(20));
+ System.out.println("element value: " + container.getElement().getValue());
</PRE>
</DIV>
-<P> Although this works, it's a little awkward to specify the argument
- count. To fix this, a multi-argument typemap can be defined. This is
- not very difficult--you only have to make slight modifications to the
- previous example's typemaps:</P>
+<P> The C++ code will always print out 20, but the value printed out may
+ not be this in the Java equivalent code. In order to understand why,
+ consider a garbage collection occuring...</P>
<DIV class="code">
<PRE>
-%typemap(in) (int argc, char **argv) {
- int i = 0;
- $1 = (*jenv)->GetArrayLength(jenv, $input);
- $2 = (char **) malloc(($1+1)*sizeof(char *));
- /* make a copy of each string */
- for (i = 0; i<$1; i++) {
- jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, $input, i);
- const char * c_string = (*jenv)->GetStringUTFChars(jenv, j_string, 0);
- $2[i] = malloc((strlen(c_string)+1)*sizeof(char));
- strcpy($2[i], c_string);
- (*jenv)->ReleaseStringUTFChars(jenv, j_string, c_string);
- (*jenv)->DeleteLocalRef(jenv, j_string);
- }
- $2[i] = 0;
-}
-
-%typemap(freearg) (int argc, char **argv) {
- int i;
- for (i=0; i<$1-1; i++)
- free($2[i]);
- free($2);
-}
-
-%typemap(jni) (int argc, char **argv) "jobjectArray"
-%typemap(jtype) (int argc, char **argv) "String[]"
-%typemap(jstype) (int argc, char **argv) "String[]"
-
-%typemap(javain) (int argc, char **argv) "$javainput"
+ Container container = new Container();
+ container.setElement(new Element(20));
+ // Simulate a garbage collection
+ System.gc();
+ System.runFinalization();
+ System.out.println("element value: " + container.getElement().getValue());
</PRE>
</DIV>
-<P> When writing a multiple-argument typemap, each of the types is
- referenced by a variable such as <TT>$1</TT> or <TT>$2</TT>. The
- typemap code simply fills in the appropriate values from the supplied
- Java parameter.</P>
-<P> With the above typemap in place, you will find it no longer
- necessary to supply the argument count. This is automatically set by
- the typemap code. For example:</P>
+<P> The temporary element created with <TT>new Element(20)</TT> could
+ get garbage collected which ultimately means the <TT>container</TT>
+ variable is holding a dangling pointer, thereby printing out any old
+ random value instead of the expected value of 20. One solution is to
+ add in the appropriate references in the Java layer...</P>
<DIV class="code">
<PRE>
-example.foo(new String[]{"red", "green", "blue", "white"});
+public class Container {
+
+ ...
+
+ // Ensure that the GC doesn't collect any Element set from Java
+ // as the underlying C++ class stores a shallow copy
+ private Element elementReference;
+ private long getCPtrAndAddReference(Element element) {
+ elementReference = element;
+ return Element.getCPtr(element);
+ }
+
+ public void setElement(Element e) {
+ exampleJNI.Container_setElement(swigCPtr, this, getCPtrAndAddReference(e), e);
+ }
+}
</PRE>
</DIV>
-<H3><A name="Java_using_typemaps_return_arguments"></A>24.10.6 Using
- typemaps to return arguments</H3>
-<P> A common problem in some C programs is that values may be returned
- in function parameters rather than in the return value of a function.
- The <TT>typemaps.i</TT> file defines INPUT, OUTPUT and INOUT typemaps
- which can be used to solve some instances of this problem. This library
- file uses an array as a means of moving data to and from Java when
- wrapping a C function that takes non const pointers or non const
- references as parameters.</P>
-<P> Now we are going to outline an alternative approach to using arrays
- for C pointers. The INOUT typemap uses a <TT>double[]</TT> array for
- receiving and returning the <TT>double*</TT> parameters. In this
- approach we are able to use a Java class <TT>myDouble</TT> instead of <TT>
-double[]</TT> arrays where the C pointer <TT>double*</TT> is required.</P>
-<P> Here is our example function:</P>
+<P> The following typemaps will generate the desired code. The 'javain'
+ typemap matches the input parameter type for the <TT>setElement</TT>
+ method. The 'javacode' typemap simply adds in the specified code into
+ the Java proxy class.</P>
<DIV class="code">
<PRE>
-/* Returns a status value and two values in out1 and out2 */
-int spam(double a, double b, double *out1, double *out2);
+%typemap(javain) Element *e "getCPtrAndAddReference($javainput)"
+
+%typemap(javacode) Container %{
+ // Ensure that the GC doesn't collect any element set from Java
+ // as the underlying C++ class stores a shallow copy
+ private Element elementReference;
+ private long getCPtrAndAddReference(Element element) {
+ elementReference = element;
+ return Element.getCPtr(element);
+ }
+%}
</PRE>
</DIV>
-<P> If we define a structure <TT>MyDouble</TT> containing a <TT>double</TT>
- member variable and use some typemaps we can solve this problem. For
- example we could put the following through SWIG:</P>
+<H3><A name="Java_date_marshalling">25.10.13 Date marshalling using the
+ javain typemap and associated attributes</A></H3>
+<P> The <A href="#Java_nan_exception_typemap">NaN Exception example</A>
+ is a simple example of the "javain" typemap and its 'pre' attribute.
+ This example demonstrates how a C++ date class, say <TT>CDate</TT>, can
+ be mapped onto the standard Java date class, <TT>
+java.util.GregorianCalendar</TT> by using the 'pre', 'post' and
+ 'pgcppname' attributes of the "javain" typemap. The idea is that the <TT>
+GregorianCalendar</TT> is used wherever the C++ API uses a <TT>CDate</TT>
+. Let's assume the code being wrapped is as follows:</P>
<DIV class="code">
<PRE>
-%module example
-
-/* Define a new structure to use instead of double * */
-%inline %{
-typedef struct {
- double value;
-} MyDouble;
-%}
-
-
-%{
-/* Returns a status value and two values in out1 and out2 */
-int spam(double a, double b, double *out1, double *out2) {
- int status = 1;
- *out1 = a*10.0;
- *out2 = b*100.0;
- return status;
+class CDate {
+public:
+ CDate(int year, int month, int day);
+ int getYear();
+ int getMonth();
+ int getDay();
+ ...
+};
+struct Action {
+ static int doSomething(const CDate &dateIn, CDate &dateOut);
+ Action(const CDate &date, CDate &dateOut);
};
-%}
-
-/*
-This typemap will make any double * function parameters with name <TT>OUTVALUE</TT> take an
-argument of MyDouble instead of double *. This will
-allow the calling function to read the double * value after returning from the function.
-*/
-%typemap(in) double *OUTVALUE {
- jclass clazz = jenv->FindClass("MyDouble");
- jfieldID fid = jenv->GetFieldID(clazz, "swigCPtr", "J");
- jlong cPtr = jenv->GetLongField($input, fid);
- MyDouble *pMyDouble = NULL;
- *(MyDouble **)&pMyDouble = *(MyDouble **)&cPtr;
- $1 = &pMyDouble->value;
-}
-
-%typemap(jtype) double *OUTVALUE "MyDouble"
-%typemap(jstype) double *OUTVALUE "MyDouble"
-%typemap(jni) double *OUTVALUE "jobject"
-
-%typemap(javain) double *OUTVALUE "$javainput"
-
-/* Now we apply the typemap to the named variables */
-%apply double *OUTVALUE { double *out1, double *out2 };
-int spam(double a, double b, double *out1, double *out2);
</PRE>
</DIV>
-<P> Note that the C++ JNI calling convention has been used this time and
- so must be compiled as C++ and the -c++ commandline must be passed to
- SWIG. JNI error checking has been omitted for clarity.</P>
-<P> What the typemaps do are make the named <TT>double*</TT> function
- parameters use our new <TT>MyDouble</TT> wrapper structure. The "in"
- typemap takes this structure, gets the C++ pointer to it, takes the <TT>
-double value</TT> member variable and passes it to the C++ <TT>spam</TT>
- function. In Java, when the function returns, we use the SWIG created <TT>
-getValue()</TT> function to get the output value. The following Java
- program demonstrates this:</P>
+<P> Note that <TT>dateIn</TT> is const and therefore read only and <TT>
+dateOut</TT> is a non-const output type.</P>
+<P> First let's look at the code that is generated by default, where the
+ Java proxy class <TT>CDate</TT> is used in the proxy interface:</P>
<DIV class="code">
<PRE>
-// File: runme.java
-
-public class runme {
-
- static {
- try {
- System.loadLibrary("example");
- } catch (UnsatisfiedLinkError e) {
- System.err.println("Native code library failed to load. " + e);
- System.exit(1);
- }
+public class Action {
+ ...
+ public static int doSomething(CDate dateIn, CDate dateOut) {
+ return exampleJNI.Action_doSomething(CDate.getCPtr(dateIn), dateIn,
+ CDate.getCPtr(dateOut), dateOut);
}
- public static void main(String argv[]) {
- MyDouble out1 = new MyDouble();
- MyDouble out2 = new MyDouble();
- int ret = example.spam(1.2, 3.4, out1, out2);
- System.out.println(ret + " " + out1.getValue() + " " + out2.getValue());
+ public Action(CDate date, CDate dateOut) {
+ this(exampleJNI.new_Action(CDate.getCPtr(date), date,
+ CDate.getCPtr(dateOut), dateOut), true);
}
}
</PRE>
</DIV>
-<P> When compiled and run we get:</P>
+<P> The <TT>CDate &</TT> and <TT>const CDate &</TT> Java code is
+ generated from the following two default typemaps:</P>
<DIV class="code">
<PRE>
-$ java runme
-1 12.0 340.0
+%typemap(jstype) SWIGTYPE & "$javaclassname"
+%typemap(javain) SWIGTYPE & "$javaclassname.getCPtr($javainput)"
</PRE>
</DIV>
-<H3><A name="Java_adding_downcasts"></A>24.10.7 Adding Java downcasts to
- polymorphic return types</H3>
-<P> SWIG support for polymorphism works in that the appropriate virtual
- function is called. However, the default generated code does not allow
- for downcasting. Let's examine this with the following code:</P>
+<P> where '$javaclassname' is translated into the proxy class name, <TT>
+CDate</TT> and '$javainput' is translated into the name of the
+ parameter, eg <TT>dateIn</TT>. From Java, the intention is then to call
+ into a modifed API with something like:</P>
<DIV class="code">
<PRE>
-%include "std_string.i"
+java.util.GregorianCalendar calendarIn =
+ new java.util.GregorianCalendar(2011, java.util.Calendar.APRIL, 13, 0, 0, 0);
+java.util.GregorianCalendar calendarOut = new java.util.GregorianCalendar();
-#include <iostream>
-using namespace std;
-class Vehicle {
-public:
- virtual void start() = 0;
-...
-};
+// Note in calls below, calendarIn remains unchanged and calendarOut
+// is set to a new value by the C++ call
+Action.doSomething(calendarIn, calendarOut);
+Action action = new Action(calendarIn, calendarOut);
+</PRE>
+</DIV>
+<P> To achieve this mapping, we need to alter the default code
+ generation slightly so that at the Java layer, a <TT>GregorianCalendar</TT>
+ is converted into a <TT>CDate</TT>. The JNI intermediary layer will
+ still take a pointer to the underlying <TT>CDate</TT> class. The
+ typemaps to achieve this are shown below.</P>
+<DIV class="code">
+<PRE>
+%typemap(jstype) const CDate& "java.util.GregorianCalendar"
+%typemap(javain,
+ pre=" CDate temp$javainput = new CDate($javainput.get(java.util.Calendar.YEAR), "
+ "$javainput.get(java.util.Calendar.MONTH), $javainput.get(java.util.Calendar.DATE));",
+ pgcppname="temp$javainput") const CDate &
+ "$javaclassname.getCPtr(temp$javainput)"
-class Ambulance : public Vehicle {
- string vol;
-public:
- Ambulance(string volume) : vol(volume) {}
- virtual void start() {
- cout << "Ambulance started" << endl;
+%typemap(jstype) CDate& "java.util.Calendar"
+%typemap(javain,
+ pre=" CDate temp$javainput = new CDate($javainput.get(java.util.Calendar.YEAR), "
+ "$javainput.get(java.util.Calendar.MONTH), $javainput.get(java.util.Calendar.DATE));",
+ post=" $javainput.set(temp$javainput.getYear(), temp$javainput.getMonth(), "
+ "temp$javainput.getDay(), 0, 0, 0);",
+ pgcppname="temp$javainput") CDate &
+ "$javaclassname.getCPtr(temp$javainput)"
+</PRE>
+</DIV>
+<P> The resulting generated proxy code in the <TT>Action</TT> class
+ follows:</P>
+<DIV class="code">
+<PRE>
+public class Action {
+ ...
+ public static int doSomething(java.util.GregorianCalendar dateIn,
+ java.util.Calendar dateOut) {
+ CDate tempdateIn = new CDate(dateIn.get(java.util.Calendar.YEAR),
+ dateIn.get(java.util.Calendar.MONTH),
+ dateIn.get(java.util.Calendar.DATE));
+ CDate tempdateOut = new CDate(dateOut.get(java.util.Calendar.YEAR),
+ dateOut.get(java.util.Calendar.MONTH),
+ dateOut.get(java.util.Calendar.DATE));
+ try {
+ return exampleJNI.Action_doSomething(CDate.getCPtr(tempdateIn), tempdateIn,
+ CDate.getCPtr(tempdateOut), tempdateOut);
+ } finally {
+ dateOut.set(tempdateOut.getYear(), tempdateOut.getMonth(), tempdateOut.getDay(), 0, 0, 0);
}
- void sound_siren() {
- cout << vol << " siren sounded!" << endl;
+ }
+
+ static private long SwigConstructAction(java.util.GregorianCalendar date,
+ java.util.Calendar dateOut) {
+ CDate tempdate = new CDate(date.get(java.util.Calendar.YEAR),
+ date.get(java.util.Calendar.MONTH),
+ date.get(java.util.Calendar.DATE));
+ CDate tempdateOut = new CDate(dateOut.get(java.util.Calendar.YEAR),
+ dateOut.get(java.util.Calendar.MONTH),
+ dateOut.get(java.util.Calendar.DATE));
+ try {
+ return exampleJNI.new_Action(CDate.getCPtr(tempdate), tempdate,
+ CDate.getCPtr(tempdateOut), tempdateOut);
+ } finally {
+ dateOut.set(tempdateOut.getYear(), tempdateOut.getMonth(), tempdateOut.getDay(), 0, 0, 0);
}
-...
-};
+ }
-Vehicle *vehicle_factory() {
- return new Ambulance("Very loud");
+ public Action(java.util.GregorianCalendar date, java.util.Calendar dateOut) {
+ this(Action.SwigConstructAction(date, dateOut), true);
+ }
}
</PRE>
</DIV>
-<P> If we execute the following Java code:</P>
+<P> A few things to note:</P>
+<UL>
+<LI> The "javatype" typemap has changed the parameter type to <TT>
+java.util.GregorianCalendar</TT> or <TT>java.util.Calendar</TT> instead
+ of the default generated <TT>CDate</TT> proxy.</LI>
+<LI> The code in the 'pre' attribute appears before the JNI call (<TT>
+exampleJNI.new_Action</TT> / <TT>exampleJNI.Action_doSomething</TT>).</LI>
+<LI> The code in the 'post' attribute appears after the JNI call.</LI>
+<LI> A try .. finally block is generated with the JNI call in the try
+ block and 'post' code in the finally block. The alternative of just
+ using a temporary variable for the return value from the JNI call and
+ the 'post' code being generated before the return statement is not
+ possible given that the JNI call is in one line and comes from the
+ "javaout" typemap.</LI>
+<LI> The temporary variables in the "javain" typemaps are called <TT>
+temp$javain</TT>, where "$javain" is replaced with the parameter name.
+ "$javain" is used to mangle the variable name so that more than one <TT>
+CDate &</TT> type can be used as a parameter in a method, otherwise two
+ or more local variables with the same name would be generated.</LI>
+<LI> The use of the "javain" typemap causes a constructor helper
+ function (<TT>SwigConstructAction</TT>) to be generated. This allows
+ Java code to be called before the JNI call and is required as the Java
+ compiler won't compile code inserted before the 'this' call.</LI>
+<LI> The 'pgcppname' attribute is used to modify the object being passed
+ as the <A href="#Java_pgcpp">premature garbage collection prevention
+ parameter</A> (the 2nd and 4th parameters in the JNI calls).</LI>
+</UL>
+<H2><A name="Java_directors_faq">25.11 Living with Java Directors</A></H2>
+<P> This section is intended to address frequently asked questions and
+ frequently encountered problems when using Java directors.</P>
+<OL>
+<LI><I>When my program starts up, it complains that</I> method_foo<I>
+ cannot be found in a Java method called</I> swig_module_init<I>. How do
+ I fix this?</I>
+<P> Open up the C++ wrapper source code file and look for <CODE>
+"method_foo"</CODE> (include the double quotes, they are important!)
+ Look at the JNI field descriptor and make sure that each class that
+ occurs in the descriptor has the correct package name in front of it.
+ If the package name is incorrect, put a "javapackage" typemap in your
+ SWIG interface file.</P>
+</LI>
+<LI><I>I'm compiling my code and I'm using templates. I provided a
+ javapackage typemap, but SWIG doesn't generate the right JNI field
+ descriptor.</I>
+<P> Use the template's renamed name as the argument to the "javapackage"
+ typemap:</P>
<DIV class="code">
<PRE>
-Vehicle vehicle = example.vehicle_factory();
-vehicle.start();
-
-Ambulance ambulance = (Ambulance)vehicle;
-ambulance.sound_siren();
+%typemap(javapackage) std::vector<int> "your.package.here"
+%template(VectorOfInt) std::vector<int>;
</PRE>
-</DIV>
-<P> We get:</P>
+</DIV></LI>
+<LI>
+<P><I>When I pass class pointers or references through a C++ upcall and
+ I try to type cast them, Java complains with a ClassCastException. What
+ am I doing wrong?</I></P>
+<P> Normally, a non-director generated Java proxy class creates
+ temporary Java objects as follows:</P>
<DIV class="code">
<PRE>
-Ambulance started
-java.lang.ClassCastException
- at runme.main(runme.java:16)
+public static void MyClass_method_upcall(MyClass self, long jarg1)
+{
+ Foo darg1 = new Foo(jarg1, false);
+
+ self.method_upcall(darg1);
+}
</PRE>
</DIV>
-<P> Even though we know from examination of the C++ code that <TT>
-vehicle_factory</TT> returns an object of type <TT>Ambulance</TT>, we
- are not able to use this knowledge to perform the downcast in Java.
- This occurs because the runtime type information is not completely
- passed from C++ to Java when returning the type from <TT>
-vehicle_factory()</TT>. Usually this is not a problem as virtual
- functions do work by default, such as in the case of <TT>start()</TT>.
- There are a few solutions to getting downcasts to work.</P>
-<P> The first is not to use a Java cast but a call to C++ to make the
- cast. Add this to your code:</P>
-<DIV class="code">
-<PRE>
-%exception Ambulance::dynamic_cast(Vehicle *vehicle) {
- $action
- if (!result) {
- jclass excep = jenv->FindClass("java/lang/ClassCastException");
- if (excep) {
- jenv->ThrowNew(excep, "dynamic_cast exception");
- }
- }
+<P>Unfortunately, this loses the Java type information that is part of
+ the underlying Foo director proxy class's Java object pointer causing
+ the type cast to fail. The SWIG Java module's director code attempts to
+ correct the problem,<B> but only for director-enabled classes</B>,
+ since the director class retains a global reference to its Java object.
+ Thus, for director-enabled classes<B> and only for director-enabled
+ classes</B>, the generated proxy Java code looks something like:</P>
+<DIV class="code">
+<PRE>
+public static void MyClass_method_upcall(MyClass self, long jarg1,
+ Foo jarg1_object)
+{
+ Foo darg1 = (jarg1_object != null ? jarg1_object : new Foo(jarg1, false));
+
+ self.method_upcall(darg1);
}
-%extend Ambulance {
- static Ambulance *dynamic_cast(Vehicle *vehicle) {
- return dynamic_cast<Ambulance *>(vehicle);
- }
-};
</PRE>
</DIV>
-<P> It would then be used from Java like this</P>
+<P> When you import a SWIG interface file containing class definitions,
+ the classes you want to be director-enabled must be have the <CODE>
+feature("director")</CODE> enabled for type symmetry to work. This
+ applies even when the class being wrapped isn't a director-enabled
+ class but takes parameters that are director-enabled classes.</P>
+<P> The current "type symmetry" design will work for simple C++
+ inheritance, but will most likely fail for anything more complicated
+ such as tree or diamond C++ inheritance hierarchies. Those who are
+ interested in challenging problems are more than welcome to hack the <CODE>
+Java::Java_director_declaration</CODE> method in <CODE>
+Source/Modules/java.cxx</CODE>.</P>
+<P> If all else fails, you can use the downcastXXXXX() method to attempt
+ to recover the director class's Java object pointer. For the Java Foo
+ proxy class, the Foo director class's java object pointer can be
+ accessed through the javaObjectFoo() method. The generated method's
+ signature is:</P>
<DIV class="code">
<PRE>
-Ambulance ambulance = Ambulance.dynamic_cast(vehicle);
-ambulance.sound_siren();
+ public static Foo javaObjectFoo(Foo obj);
</PRE>
</DIV>
-<P> Should <TT>vehicle</TT> not be of type <TT>ambulance</TT> then a
- Java <TT>ClassCastException</TT> is thrown. The next solution is a
- purer solution in that Java downcasts can be performed on the types.
- Add the following before the definition of <TT>vehicle_factory</TT>:</P>
+<P> From your code, this method is invoked as follows:</P>
<DIV class="code">
<PRE>
-%typemap(out) Vehicle * {
- Ambulance *downcast = dynamic_cast<Ambulance *>($1);
- *(Ambulance **)&$result = downcast;
-}
-
-%typemap(javaout) Vehicle * {
- return new Ambulance($jnicall, $owner);
+public class MyClassDerived {
+ public void method_upcall(Foo foo_object)
+ {
+ FooDerived derived = (foo_object != null ?
+ (FooDerived) Foo.downcastFoo(foo_object) : null);
+ /* rest of your code here */
}
+}
</PRE>
</DIV>
-<P> Here we are using our knowledge that <TT>vehicle_factory</TT> always
- returns type <TT>Ambulance</TT> so that the Java proxy is created as a
- type <TT>Ambulance</TT>. If <TT>vehicle_factory</TT> can manufacture
- any type of <TT>Vehicle</TT> and we want to be able to downcast using
- Java casts for any of these types, then a different approach is needed.
- Consider expanding our example with a new Vehicle type and a more
- flexible factory function:</P>
+<P> An good approach for managing downcasting is placing a static method
+ in each derived class that performs the downcast from the superclass,
+ e.g.,</P>
<DIV class="code">
<PRE>
-class FireEngine : public Vehicle {
-public:
- FireEngine() {}
- virtual void start() {
- cout << "FireEngine started" << endl;
+public class FooDerived extends Foo {
+ /* ... */
+ public static FooDerived downcastFooDerived(Foo foo_object)
+ {
+ try {
+ return (foo_object != null ? (FooDerived) Foo.downcastFoo(foo_object);
}
- void roll_out_hose() {
- cout << "Hose rolled out" << endl;
+
+ catch (ClassCastException exc) {
+ // Wasn't a FooDerived object, some other subclass of Foo
+ return null;
}
- ...
-};
-Vehicle *vehicle_factory(int vehicle_number) {
- if (vehicle_number == 0)
- return new Ambulance("Very loud");
- else
- return new FireEngine();
+ }
}
</PRE>
</DIV>
-<P> To be able to downcast with this sort of Java code:</P>
+<P> Then change the code in MyClassDerived as follows:</P>
<DIV class="code">
<PRE>
-FireEngine fireengine = (FireEngine)example.vehicle_factory(1);
-fireengine.roll_out_hose();
-Ambulance ambulance = (Ambulance)example.vehicle_factory(0);
-ambulance.sound_siren();
+public class MyClassDerived extends MyClass {
+ /* ... */
+ public void method_upcall(Foo foo_object)
+ {
+ FooDerived derived = FooDerived.downcastFooDerived(foo_object);
+ /* rest of your code here */
+ }
+}
</PRE>
-</DIV>
-<P> the following typemaps targeted at the <TT>vehicle_factory</TT>
- function will achieve this. Note that in this case, the Java class is
- constructed using JNI code rather than passing a pointer across the JNI
- boundary in a Java long for construction in Java code.</P>
+</DIV></LI>
+<LI>
+<P><I>Why isn't the proxy class declared abstract? Why aren't the
+ director upcall methods in the proxy class declared abstract?</I></P>
+<P> Declaring the proxy class and its methods abstract would break the
+ JNI argument marshalling and SWIG's downcall functionality (going from
+ Java to C++.) Create an abstract Java subclass that inherits from the
+ director-enabled class instead. Using the previous Foo class example:</P>
<DIV class="code">
<PRE>
-%typemap(jni) Vehicle *vehicle_factory "jobject"
-%typemap(jtype) Vehicle *vehicle_factory "Vehicle"
-%typemap(jstype) Vehicle *vehicle_factory "Vehicle"
-%typemap(javaout) Vehicle *vehicle_factory {
- return $jnicall;
- }
+public abstract class UserVisibleFoo extends Foo {
+ /** Make sure user overrides this method, it's where the upcall
+ * happens.
+ */
+ public abstract void method_upcall(Foo foo_object);
-%typemap(out) Vehicle *vehicle_factory {
- Ambulance *ambulance = dynamic_cast<Ambulance *>($1);
- FireEngine *fireengine = dynamic_cast<FireEngine *>($1);
- if (ambulance) {
- // call the Ambulance(long cPtr, boolean cMemoryOwn) constructor
- jclass clazz = jenv->FindClass("Ambulance");
- if (clazz) {
- jmethodID mid = jenv->GetMethodID(clazz, "<init>", "(JZ)V");
- if (mid) {
- jlong cptr = 0;
- *(Ambulance **)&cptr = ambulance;
- $result = jenv->NewObject(clazz, mid, cptr, false);
- }
- }
- } else if (fireengine) {
- // call the FireEngine(long cPtr, boolean cMemoryOwn) constructor
- jclass clazz = jenv->FindClass("FireEngine");
- if (clazz) {
- jmethodID mid = jenv->GetMethodID(clazz, "<init>", "(JZ)V");
- if (mid) {
- jlong cptr = 0;
- *(FireEngine **)&cptr = fireengine;
- $result = jenv->NewObject(clazz, mid, cptr, false);
- }
- }
- }
- else {
- cout << "Unexpected type " << endl;
+ /// Downcast from Foo to UserVisibleFoo
+ public static UserVisibleFoo downcastUserVisibleFoo(Foo foo_object)
+ {
+ try {
+ return (foo_object != null ? (FooDerived) Foo.downcastFoo(foo_object) : null);
}
- if (!$result)
- cout << "Failed to create new java object" << endl;
+ catch (ClassCastException exc) {
+ // Wasn't a FooDerived object, some other subclass of Foo
+ return null;
+ }
+ }
}
</PRE>
</DIV>
-<P> Better error handling would need to be added into this code. There
- are other solutions to this problem, but this last example demonstrates
- some more involved JNI code. SWIG usually generates code which
- constructs the proxy classes using Java code as it is easier to handle
- error conditions and is faster. Note that the JNI code above uses a
- number of string lookups to call a constructor, whereas this would not
- occur using byte compiled Java code.</P>
-<H3><A name="Java_adding_equals_method"></A>24.10.8 Adding an equals
- method to the Java classes</H3>
-<P> When a pointer is returned from a JNI function, it is wrapped using
- a new Java proxy class or type wrapper class. Even when the pointers
- are the same, it will not be possible to know that the two Java classes
- containing those pointers are actually the same object. It is common in
- Java to use the <TT>equals()</TT> method to check whether two objects
- are equivalent. The <TT>equals()</TT> method is usually accompanied by
- a <TT>hashCode()</TT> method in order to fulfill the requirement that
- the hash code is equal for equal objects. Pure Java code methods like
- these can be easily added:</P>
+<P>This doesn't prevent the user from creating subclasses derived from
+ Foo, however, UserVisibleFoo provides the safety net that reminds the
+ user to override the <CODE>method_upcall()</CODE> method.</P>
+</LI>
+</OL>
+<H2><A name="Java_odds_ends">25.12 Odds and ends</A></H2>
+<H3><A name="Java_javadoc_comments">25.12.1 JavaDoc comments</A></H3>
+<P> The SWIG documentation system is currently deprecated. When it is
+ resurrected JavaDoc comments will be fully supported. If you can't wait
+ for the full documentation system a couple of workarounds are
+ available. The <TT>%javamethodmodifiers</TT> feature can be used for
+ adding proxy class method comments and module class method comments.
+ The "javaimports" typemap can be hijacked for adding in proxy class
+ JavaDoc comments. The <TT>jniclassimports</TT> or <TT>
+jniclassclassmodifiers</TT> pragmas can also be used for adding
+ intermediary JNI class comments and likewise the <TT>moduleimports</TT>
+ or <TT>moduleclassmodifiers</TT> pragmas for the module class. Here is
+ an example adding in a proxy class and method comment:</P>
<DIV class="code">
<PRE>
-%typemap(javacode) SWIGTYPE %{
- public boolean equals(Object obj) {
- boolean equal = false;
- if (obj instanceof $javaclassname)
- equal = ((($javaclassname)obj).swigCPtr == this.swigCPtr);
- return equal;
- }
- public int hashCode() {
- return (int)getPointer();
- }
-%}
+%javamethodmodifiers Barmy::lose_marbles() "
+ /**
+ * Calling this method will make you mad.
+ * Use with <b>utmost</b> caution.
+ */
+ public";
-class Foo { };
-Foo* returnFoo(Foo *foo) { return foo; }
+%typemap(javaimports) Barmy "
+/** The crazy class. Use as a last resort. */"
+
+class Barmy {
+public:
+ void lose_marbles() {}
+};
</PRE>
</DIV>
-<P> The following would display <TT>false</TT> without the <TT>javacode</TT>
- typemap above. With the typemap defining the <TT>equals</TT> method the
- result is <TT>true</TT>.</P>
+<P> Note the "public" added at the end of the <TT>%javamethodmodifiers</TT>
+ as this is the default for this feature. The generated proxy class with
+ JavaDoc comments is then as follows:</P>
<DIV class="code">
<PRE>
-Foo foo1 = new Foo();
-Foo foo2 = example.returnFoo(foo1);
-System.out.println("foo1? " + foo1.equals(foo2));
+/** The crazy class. Use as a last resort. */
+public class Barmy {
+...
+ /**
+ * Calling this method will make you mad.
+ * Use with <b>utmost</b> caution.
+ */
+ public void lose_marbles() {
+ ...
+ }
+...
+}
</PRE>
</DIV>
-<H3><A name="Java_void_pointers"></A>24.10.9 Void pointers and a common
- Java base class</H3>
-<P> One might wonder why the common code that SWIG emits for the proxy
- and type wrapper classes is not pushed into a base class. The reason is
- that although <TT>swigCPtr</TT> could be put into a common base class
- for all classes wrapping C structures, it would not work for C++
- classes involved in an inheritance chain. Each class derived from a
- base needs a separate <TT>swigCPtr</TT> because C++ compilers sometimes
- use a different pointer value when casting a derived class to a base.
- Additionally as Java only supports single inheritance, it would not be
- possible to derive wrapped classes from your own pure Java classes if
- the base class has been 'used up' by SWIG. However, you may want to
- move some of the common code into a base class. Here is an example
- which uses a common base class for all proxy classes and type wrapper
- classes:</P>
+<H3><A name="Java_functional_interface">25.12.2 Functional interface
+ without proxy classes</A></H3>
+<P> It is possible to run SWIG in a mode that does not produce proxy
+ classes by using the -noproxy commandline option. The interface is
+ rather primitive when wrapping structures or classes and is accessed
+ through function calls to the module class. All the functions in the
+ module class are wrapped by functions with identical names as those in
+ the intermediary JNI class.</P>
+<P> Consider the example we looked at when examining proxy classes:</P>
<DIV class="code">
<PRE>
-%typemap(javabase) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [],
- SWIGTYPE (CLASS::*) "SWIG"
-
-%typemap(javacode) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [],
- SWIGTYPE (CLASS::*) %{
- protected long getPointer() {
- return swigCPtr;
- }
-%}
+class Foo {
+public:
+ int x;
+ int spam(int num, Foo* foo);
+};
</PRE>
</DIV>
-<P> Define new base class called SWIG:</P>
+<P> When using <TT>-noproxy</TT>, type wrapper classes are generated
+ instead of proxy classes. Access to all the functions and variables is
+ through a C like set of functions where the first parameter passed is
+ the pointer to the class, that is an instance of a type wrapper class.
+ Here is what the module class looks like:</P>
<DIV class="code">
<PRE>
-public abstract class SWIG {
- protected abstract long getPointer();
-
- public boolean equals(Object obj) {
- boolean equal = false;
- if (obj instanceof SWIG)
- equal = (((SWIG)obj).getPointer() == this.getPointer());
- return equal;
- }
-
- SWIGTYPE_p_void getVoidPointer() {
- return new SWIGTYPE_p_void(getPointer(), false);
- }
+public class example {
+ public static void Foo_x_get(SWIGTYPE_p_Foo self, int x) {...}
+ public static int Foo_x_get(SWIGTYPE_p_Foo self) {...}
+ public static int Foo_spam(SWIGTYPE_p_Foo self, int num, SWIGTYPE_p_Foo foo) {...}
+ public static SWIGTYPE_p_Foo new_Foo() {...}
+ public static void delete_Foo(SWIGTYPE_p_Foo self) {...}
}
</PRE>
</DIV>
-<P> This example contains some useful functionality which you may want
- in your code.</P>
-<UL>
-<LI> It has an <TT>equals()</TT> method. Unlike the previous example,
- the method code isn't replicated in all classes.</LI>
-<LI> It also has a function which effectively implements a cast from the
- type of the proxy/type wrapper class to a void pointer. This is
- necessary for passing a proxy class or a type wrapper class to a
- function that takes a void pointer.</LI>
-</UL>
-<H3><A name="Java_struct_pointer_pointer"></A>24.10.10 Struct pointer to
- pointer</H3>
-<P> Pointers to pointers are often used as output parameters in C
- factory type functions. These are a bit more tricky to handle. Consider
- the following situation where a <TT>Butler</TT> can be hired and fired:</P>
+<P> This approach is not nearly as natural as using proxy classes as the
+ functions need to be used like this:</P>
<DIV class="code">
<PRE>
-typedef struct {
- int hoursAvailable;
- char *greeting;
-} Butler;
-
-// Note: HireButler will allocate the memory
-// The caller must free the memory by calling FireButler()!!
-extern int HireButler(Butler **ppButler);
-extern void FireButler(Butler *pButler);
+SWIGTYPE_p_Foo foo = example.new_Foo();
+example.Foo_x_set(foo, 10);
+int var = example.Foo_x_get(foo);
+example.Foo_spam(foo, 20, foo);
+example.delete_Foo(foo);
</PRE>
</DIV>
-<P> C code implementation:</P>
+<P> Unlike proxy classes, there is no attempt at tracking memory. All
+ destructors have to be called manually for example the <TT>
+delete_Foo(foo)</TT> call above.</P>
+<H3><A name="Java_using_own_jni_functions">25.12.3 Using your own JNI
+ functions</A></H3>
+<P> You may have some hand written JNI functions that you want to use in
+ addition to the SWIG generated JNI functions. Adding these to your SWIG
+ generated package is possible using the <TT>%native</TT> directive. If
+ you don't want SWIG to wrap your JNI function then of course you can
+ simply use the <TT>%ignore</TT> directive. However, if you want SWIG to
+ generate just the Java code for a JNI function then use the <TT>%native</TT>
+ directive. The C types for the parameters and return type must be
+ specified in place of the JNI types and the function name must be the
+ native method name. For example:</P>
<DIV class="code">
<PRE>
-int HireButler(Butler **ppButler) {
- Butler *pButler = (Butler *)malloc(sizeof(Butler));
- pButler->hoursAvailable = 24;
- pButler->greeting = (char *)malloc(32);
- strcpy(pButler->greeting, "At your service Sir");
- *ppButler = pButler;
- return 1;
-}
-void FireButler(Butler *pButler) {
- free(pButler->greeting);
- free(pButler);
-}
+%native (HandRolled) void HandRolled(int, char *);
+%{
+JNIEXPORT void JNICALL Java_packageName_moduleName_HandRolled(JNIEnv *, jclass,
+ jlong, jstring);
+%}
</PRE>
</DIV>
-<P> Let's take two approaches to wrapping this code. The first is to
- provide a functional interface, much like the original C interface. The
- following Java code shows how we intend the code to be used:</P>
+<P> No C JNI function will be generated and the <TT>
+Java_packageName_moduleName_HandRolled</TT> function will be accessible
+ using the SWIG generated Java native method call in the intermediary
+ JNI class which will look like this:</P>
<DIV class="code">
<PRE>
- Butler jeeves = new Butler();
- example.HireButler(jeeves);
- System.out.println("Greeting: " + jeeves.getGreeting());
- System.out.println("Availability: " + jeeves.getHoursAvailable() + " hours per day");
- example.FireButler(jeeves);
+ public final static native void HandRolled(int jarg1, String jarg2);
</PRE>
</DIV>
-<P> Resulting in the following output when run:</P>
-<DIV class="shell">
+<P> and as usual this function is wrapped by another which for a global
+ C function would appear in the module class:</P>
+<DIV class="code">
<PRE>
-Greeting: At your service Sir
-Availability: 24 hours per day
+ public static void HandRolled(int arg0, String arg1) {
+ exampleJNI.HandRolled(arg0, arg1);
+ }
</PRE>
</DIV>
-<P> Note the usage is very much like it would be used if we were writing
- C code, that is, explicit memory management is needed. No C memory is
- allocated in the construction of the <TT>Butler</TT> proxy class and
- the proxy class will not destroy the underlying C memory when it is
- collected. A number of typemaps and features are needed to implement
- this approach. The following interface file code should be placed
- before SWIG parses the above C code.</P>
+<P> The <TT>packageName</TT> and <TT>moduleName</TT> must of course be
+ correct else you will get linker errors when the JVM dynamically loads
+ the JNI function. You may have to add in some "jtype", "jstype",
+ "javain" and "javaout" typemaps when wrapping some JNI types. Here the
+ default typemaps work for <TT>int</TT> and <TT>char *</TT>.</P>
+<P> In summary the <TT>%native</TT> directive is telling SWIG to
+ generate the Java code to access the JNI C code, but not the JNI C
+ function itself. This directive is only really useful if you want to
+ mix your own hand crafted JNI code and the SWIG generated code into one
+ Java class or package.</P>
+<H3><A name="Java_performance">25.12.4 Performance concerns and hints</A>
+</H3>
+<P> If you're directly manipulating huge arrays of complex objects from
+ Java, performance may suffer greatly when using the array functions in <TT>
+arrays_java.i</TT>. Try and minimise the expensive JNI calls to C/C++
+ functions, perhaps by using temporary Java variables instead of
+ accessing the information directly from the C/C++ object.</P>
+<P> Java classes without any finalizers generally speed up code
+ execution as there is less for the garbage collector to do. Finalizer
+ generation can be stopped by using an empty <TT>javafinalize</TT>
+ typemap:</P>
<DIV class="code">
<PRE>
-%module example
-
-// Do not generate the default proxy constructor or destructor
-%nodefaultctor Butler;
-%nodefaultdtor Butler;
-
-// Add in pure Java code proxy constructor
-%typemap(javacode) Butler %{
- /** This constructor creates the proxy which initially does not create nor own any C memory */
- public Butler() {
- this(0, false);
- }
-%}
-
-// Type typemaps for marshalling Butler **
-%typemap(jni) Butler ** "jobject"
-%typemap(jtype) Butler ** "Butler"
-%typemap(jstype) Butler ** "Butler"
-
-// Typemaps for Butler ** as a parameter output type
-%typemap(in) Butler ** (Butler *ppButler = 0) %{
- $1 = &ppButler;
-%}
-%typemap(argout) Butler ** {
- // Give Java proxy the C pointer (of newly created object)
- jclass clazz = (*jenv)->FindClass(jenv, "Butler");
- jfieldID fid = (*jenv)->GetFieldID(jenv, clazz, "swigCPtr", "J");
- jlong cPtr = 0;
- *(Butler **)&cPtr = *$1;
- (*jenv)->SetLongField(jenv, $input, fid, cPtr);
-}
-%typemap(javain) Butler ** "$javainput"
+%typemap(javafinalize) SWIGTYPE ""
</PRE>
</DIV>
-<P> Note that the JNI code sets the proxy's <TT>swigCPtr</TT> member
- variable to point to the newly created object. The <TT>swigCMemOwn</TT>
- remains unchanged (at false), so that the proxy does not own the
- memory.</P>
-<P> Note: The old %nodefault directive disabled the default constructor
- and destructor at the same time. This is unsafe in most of the cases,
- and you can use the explicit %nodefaultctor and %nodefaultdtor
- directives to achieve the same result if needed.</P>
-<P> The second approach offers a more object oriented interface to the
- Java user. We do this by making the Java proxy class's constructor call
- the <TT>HireButler()</TT> method to create the underlying C object.
- Additionally we get the proxy to take ownership of the memory so that
- the finalizer will call the <TT>FireButler()</TT> function. The proxy
- class will thus take ownership of the memory and clean it up when no
- longer needed. We will also prevent the user from being able to
- explicitly call the <TT>HireButler()</TT> and <TT>FireButler()</TT>
- functions. Usage from Java will simply be:</P>
+<P> However, you will have to be careful about memory management and
+ make sure that you code in a call to the <TT>delete()</TT> member
+ function. This method normally calls the C++ destructor or <TT>free()</TT>
+ for C code.</P>
+<H3><A name="Java_debugging">25.12.5 Debugging</A></H3>
+<P> The generated code can be debugged using both a Java debugger and a
+ C++ debugger using the usual debugging techniques. Breakpoints can be
+ set in either Java or C++ code and so both can be debugged
+ simultaneously. Most debuggers do not understand both Java and C++,
+ with one noteable exception of Sun Studio, where it is possible to step
+ from Java code into a JNI method within one environment.</P>
+<P> Alternatively, debugging can involve placing debug printout
+ statements in the JNI layer using the <TT>%exception</TT> directive.
+ See the <A href="#Customization_exception_special_variables">special
+ variables for %exception</A> section. Many of the default typemaps can
+ also be overridden and modified for adding in extra logging/debug
+ display information.</P>
+<P> The <TT>-Xcheck:jni</TT> and <TT>-Xcheck:nabounds</TT> Java
+ executable options are useful for debugging to make sure the JNI code
+ is behaving. The -verbose:jni and -verbose:gc are also useful options
+ for monitoring code behaviour.</P>
+<H2><A name="Java_examples">25.13 Java Examples</A></H2>
+<P> The directory Examples/java has a number of further examples. Take a
+ look at these if you want to see some of the techniques described in
+ action. The Examples/index.html file in the parent directory contains
+ the SWIG Examples Documentation and is a useful starting point. If your
+ SWIG installation went well Unix users should be able to type <TT>make</TT>
+ in each example directory, then <TT>java main</TT> to see them running.
+ For the benefit of Windows users, there are also Visual C++ project
+ files in a couple of the <A href="#Windows_examples">Windows Examples</A>
+. There are also many regression tests in the Examples/test-suite
+ directory. Many of these have runtime tests in the java subdirectory.</P>
+<HR NOSHADE>
+<H1><A name="Javascript">26 SWIG and Javascript</A></H1>
+
+<!-- INDEX -->
+<DIV class="sectiontoc">
+<UL>
+<LI><A href="#Javascript_overview">Overview</A></LI>
+<LI><A href="#Javascript_preliminaries">Preliminaries</A>
+<UL>
+<LI><A href="#Javascript_running_swig">Running SWIG</A></LI>
+<LI><A href="#Javascript_running_tests_examples">Running Tests and
+ Examples</A></LI>
+<LI><A href="#Javascript_known_issues">Known Issues</A></LI>
+</UL>
+</LI>
+<LI><A href="#Javascript_integration">Integration</A>
+<UL>
+<LI><A href="#Javascript_node_extensions">Creating node.js Extensions</A>
+<UL>
+<LI><A href="#Javascript_troubleshooting">Troubleshooting</A></LI>
+</UL>
+</LI>
+<LI><A href="#Javascript_embedded_webkit">Embedded Webkit</A>
+<UL>
+<LI><A href="#Javascript_osx">Mac OS X</A></LI>
+<LI><A href="#Javascript_gtk">GTK</A></LI>
+</UL>
+</LI>
+<LI><A href="#Javascript_applications_webkit">Creating Applications with
+ node-webkit</A></LI>
+</UL>
+</LI>
+<LI><A href="#Javascript_examples">Examples</A>
+<UL>
+<LI><A href="#Javascript_simple_example">Simple</A></LI>
+<LI><A href="#Javascript_class_example">Class</A></LI>
+</UL>
+</LI>
+<LI><A href="#Javascript_implementation">Implementation</A>
+<UL>
+<LI><A href="#Javascript_source_code">Source Code</A></LI>
+<LI><A href="#Javascript_code_templates">Code Templates</A></LI>
+<LI><A href="#Javascript_emitter">Emitter</A></LI>
+<LI><A href="#Javascript_emitter_states">Emitter states</A></LI>
+<LI><A href="#Javascript_jsc_exceptions">Handling Exceptions in
+ JavascriptCore</A></LI>
+</UL>
+</LI>
+</UL>
+</DIV>
+<!-- INDEX -->
+<P>This chapter describes SWIG's support of Javascript. It does not
+ cover SWIG basics, but only information that is specific to this
+ module.</P>
+<H2><A name="Javascript_overview">26.1 Overview</A></H2>
+<P>Javascript is a prototype-based scripting language that is dynamic,
+ weakly typed and has first-class functions. Its arguably the most
+ popular language for web development. Javascript has gone beyond being
+ a browser-based scripting language and with <A href="http://nodejs.org">
+node.js</A>, it is also used as a backend development language.</P>
+<P>Native Javascript extensions can be used for applications that embed
+ a web-browser view or that embed a Javascript engine (such as<EM>
+ node.js</EM>). Extending a general purpose web-browser is not possible
+ as this would be a severe security issue.</P>
+<P>SWIG Javascript currently supports<STRONG> JavascriptCore</STRONG>,
+ the Javascript engine used by <CODE>Safari/Webkit</CODE>, and <A href="https://developers.google.com/v8">
+<STRONG>v8</STRONG></A>, which is used by <CODE>Chromium</CODE> and <CODE>
+node.js</CODE>.</P>
+<P><A href="http://www.webkit.org/">WebKit</A> is a modern browser
+ implementation available as open-source which can be embedded into an
+ application. With <A href="https://github.com/rogerwang/node-webkit">
+node-webkit</A> there is a platform which uses Google's <CODE>Chromium</CODE>
+ as Web-Browser widget and <CODE>node.js</CODE> for javascript
+ extensions.</P>
+<H2><A name="Javascript_preliminaries">26.2 Preliminaries</A></H2>
+<H3><A name="Javascript_running_swig">26.2.1 Running SWIG</A></H3>
+<P>Suppose that you defined a SWIG module such as the following:</P>
<DIV class="code">
<PRE>
-Butler jeeves = new Butler();
-System.out.println("Greeting: " + jeeves.getGreeting());
-System.out.println("Availability: " + jeeves.getHoursAvailable() + " hours per day");
-</PRE>
+%module example
+%{
+#include "example.h"
+%}
+int gcd(int x, int y);
+extern double Foo;</PRE>
</DIV>
-<P> Note that the Butler class is used just like any other Java class
- and no extra coding by the user needs to be written to clear up the
- underlying C memory as the finalizer will be called by the garbage
- collector which in turn will call the <TT>FireButler()</TT> function.
- To implement this, we use the above interface file code but remove the <TT>
-javacode</TT> typemap and add the following:</P>
-<DIV class="code">
+<P>To build a Javascript module, run SWIG using the <CODE>-javascript</CODE>
+ option and a desired target engine <CODE>-jsc</CODE>, <CODE>-v8</CODE>,
+ or <CODE>-node</CODE>. The generator for <CODE>node</CODE> is
+ essentially delegating to the <CODE>v8</CODE> generator and adds some
+ necessary preprocessor definitions.</P>
+<DIV class="shell">
<PRE>
-// Don't expose the memory allocation/de-allocation functions
-%ignore FireButler(Butler *pButler);
-%ignore HireButler(Butler **ppButler);
-
-// Add in a custom proxy constructor and destructor
-%extend Butler {
- Butler() {
- Butler *pButler = 0;
- HireButler(&pButler);
- return pButler;
- }
- ~Butler() {
- FireButler($self);
- }
-}
-</PRE>
+$ swig -javascript -jsc example.i</PRE>
</DIV>
-<P> Note that the code in <TT>%extend</TT> is using a C++ type
- constructor and destructor, yet the generated code will still compile
- as C code, see <A href="#SWIG_adding_member_functions">Adding member
- functions to C structures</A>. The C functional interface has been
- completely morphed into an object-oriented interface and the Butler
- class would behave much like any pure Java class and feel more natural
- to Java users.</P>
-<H3><A name="Java_memory_management_member_variables"></A>24.10.11
- Memory management when returning references to member variables</H3>
-<P> This example shows how to prevent premature garbage collection of
- objects when the underlying C++ class returns a pointer or reference to
- a member variable.</P>
-<P> Consider the following C++ code:</P>
+<P>If building a C++ extension, add the -c++ option:</P>
+<DIV class="shell">
+<PRE>
+$ swig -c++ -javascript -jsc example.i</PRE>
+</DIV>
+<P>The V8 code that SWIG generates should work with most versions from
+ 3.11.10 up to 3.29.14 and later.</P>
+<P>The API headers for V8 >= 4.3.0 define constants which SWIG can use
+ to determine the V8 version it is compiling for. For versions < 4.3.0,
+ you need to specify the V8 version when running SWIG. 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. For example:</P>
+<DIV class="shell">
+<PRE>
+$ swig -c++ -javascript -v8 -DV8_VERSION=0x032530 example.i</PRE>
+</DIV>
+<P>If you're targetting V8 >= 4.3.0, you would just run swig like so:</P>
+<DIV class="shell">
+<PRE>
+$ swig -c++ -javascript -v8 example.i</PRE>
+</DIV>
+<P>This creates a C/C++ source file <CODE>example_wrap.c</CODE> or <CODE>
+example_wrap.cxx</CODE>. The generated C source file contains the
+ low-level wrappers that need to be compiled and linked with the rest of
+ your C/C++ application to create an extension module.</P>
+<P>The name of the wrapper file is derived from the name of the input
+ file. For example, if the input file is <CODE>example.i</CODE>, the
+ name of the wrapper file is <CODE>example_wrap.c</CODE>. To change
+ this, you can use the -o option. The wrapped module will export one
+ function which must be called to register the module with the
+ Javascript interpreter. For example, if your module is named <CODE>
+example</CODE> the corresponding initializer for JavascriptCore would be</P>
<DIV class="code">
<PRE>
-struct Wheel {
- int size;
- Wheel(int sz) : size(sz) {}
-};
-
-class Bike {
- Wheel wheel;
-public:
- Bike(int val) : wheel(val) {}
- Wheel& getWheel() { return wheel; }
-};
-</PRE>
+bool example_initialize(JSGlobalContextRef context, JSObjectRef *exports)</PRE>
</DIV>
-<P> and the following usage from Java after running the code through
- SWIG:</P>
+<P>and for v8:</P>
<DIV class="code">
<PRE>
- Wheel wheel = new Bike(10).getWheel();
- System.out.println("wheel size: " + wheel.getSize());
- // Simulate a garbage collection
- System.gc();
- System.runFinalization();
- System.out.println("wheel size: " + wheel.getSize());
-</PRE>
+void example_initialize(v8::Handle<v8::Object> exports)</PRE>
</DIV>
-<P> Don't be surprised that if the resulting output gives strange
- results such as...</P>
+<P><B> Note</B>: be aware that <CODE>v8</CODE> has a C++ API, and thus,
+ the generated modules must be compiled as C++.</P>
+<H3><A name="Javascript_running_tests_examples">26.2.2 Running Tests and
+ Examples</A></H3>
+<P>The configuration for tests and examples currently supports Linux and
+ Mac only and not MinGW (Windows) yet.</P>
+<P>The default interpreter is <CODE>node.js</CODE> as it is available on
+ all platforms and convenient to use.</P>
+<P>Running the examples with JavascriptCore requires <CODE>
+libjavascriptcoregtk-1.0</CODE> to be installed, e.g., under Ubuntu with</P>
<DIV class="shell">
<PRE>
-wheel size: 10
-wheel size: 135019664
-</PRE>
+$ sudo apt-get install libjavascriptcoregtk-1.0-dev</PRE>
</DIV>
-<P> What has happened here is the garbage collector has collected the <TT>
-Bike</TT> instance as it doesn't think it is needed any more. The proxy
- instance, <TT>wheel</TT>, contains a reference to memory that was
- deleted when the <TT>Bike</TT> instance was collected. In order to
- prevent the garbage collector from collecting the <TT>Bike</TT>
- instance a reference to the <TT>Bike</TT> must be added to the <TT>
-wheel</TT> instance. You can do this by adding the reference when the <TT>
-getWheel()</TT> method is called using the following typemaps.</P>
-<DIV class="code">
+<P>Running with <CODE>V8</CODE> requires <CODE>libv8</CODE>:</P>
+<DIV class="shell">
<PRE>
-%typemap(javacode) Wheel %{
- // Ensure that the GC doesn't collect any Bike instance set from Java
- private Bike bikeReference;
- protected void addReference(Bike bike) {
- bikeReference = bike;
- }
-%}
-
-// Add a Java reference to prevent premature garbage collection and resulting use
-// of dangling C++ pointer. Intended for methods that return pointers or
-// references to a member variable.
-%typemap(javaout) Wheel& getWheel {
- long cPtr = $jnicall;
- $javaclassname ret = null;
- if (cPtr != 0) {
- ret = new $javaclassname(cPtr, $owner);
- ret.addReference(this);
- }
- return ret;
- }
-</PRE>
+$ sudo apt-get install libv8-dev</PRE>
</DIV>
-<P> The code in the first typemap gets added to the <TT>Wheel</TT> proxy
- class. The code in the second typemap constitutes the bulk of the code
- in the generated <TT>getWheel()</TT> function:</P>
+<P>Examples can be run using</P>
+<DIV class="shell">
+<PRE>
+$ make check-javascript-examples ENGINE=jsc</PRE>
+</DIV>
+<P><CODE>ENGINE</CODE> can be <CODE>node</CODE>, <CODE>jsc</CODE>, or <CODE>
+v8</CODE>.</P>
+<P>The test-suite can be run using</P>
+<DIV class="shell">
+<PRE>
+$ make check-javascript-test-suite ENGINE=jsc</PRE>
+</DIV>
+<P>You can specify a specific <CODE>V8</CODE> version for running the
+ examples and tests</P>
+<DIV class="shell">
+<PRE>
+$ make check-javascript-examples V8_VERSION=0x032530 ENGINE=v8</PRE>
+</DIV>
+<H3><A name="Javascript_known_issues">26.2.3 Known Issues</A></H3>
+<P>At the moment, the Javascript generators pass all tests
+ syntactically, i.e., the generated source code compiles. However, there
+ are still remaining runtime issues.</P>
+<UL>
+<LI>
+<P>Default optional arguments do not work for all targeted interpreters</P>
+</LI>
+<LI>
+<P>Multiple output arguments do not work for JSC</P>
+</LI>
+<LI>
+<P>C89 incompatibily: the JSC generator might still generate C89
+ violating code</P>
+</LI>
+<LI>
+<P><CODE>long long</CODE> is not supported</P>
+</LI>
+<LI>
+<P><CODE>%native</CODE> is not supported</P>
+</LI>
+<LI>
+<P>Javascript callbacks are not supported</P>
+</LI>
+<LI>
+<P><CODE>instanceOf</CODE> does not work under JSC</P>
+</LI>
+</UL>
+<P>The primary development environment has been Linux (Ubuntu 12.04).
+ Windows and Mac OS X have been tested sporadically. Therefore, the
+ generators might have more issues on those platforms. Please report
+ back any problem you observe to help us improving this module quickly.</P>
+<H2><A name="Javascript_integration">26.3 Integration</A></H2>
+<P>This chapter gives a short introduction how to use a native
+ Javascript extension: as a <CODE>node.js</CODE> module, and as an
+ extension for an embedded Webkit.</P>
+<H3><A name="Javascript_node_extensions">26.3.1 Creating node.js
+ Extensions</A></H3>
+<P>To install <CODE>node.js</CODE> you can download an installer from
+ their <A href="https://launchpad.net/~chris-lea/+archive/node.js">
+web-site</A> for Mac OS X and Windows. For Linux you can either build
+ the source yourself and run <CODE>sudo checkinstall</CODE> or keep to
+ the (probably stone-age) packaged version. For Ubuntu there is a <A href="https://launchpad.net/~chris-lea/+archive/ubuntu/node.js/">
+PPA</A> available.</P>
+<DIV class="shell">
+<PRE>
+$ sudo add-apt-repository ppa:chris-lea/node.js
+$ sudo apt-get update
+$ sudo apt-get install nodejs</PRE>
+</DIV>
+<P>As <CODE>v8</CODE> is written in C++ and comes as a C++ library it is
+ crucial to compile your module using the same compiler flags as used
+ for building v8. To make things easier, <CODE>node.js</CODE> provides a
+ build tool called <CODE>node-gyp</CODE>.</P>
+<P>You have to install it using <CODE>npm</CODE>:</P>
+<DIV class="shell">
+<PRE>
+$ sudo npm install -g node-gyp</PRE>
+</DIV>
+<P><CODE>node-gyp</CODE> expects a configuration file named <CODE>
+binding.gyp</CODE> which is basically in JSON format and conforms to the
+ same format that is used with Google's build-tool <CODE>gyp</CODE>.</P>
+<P><CODE>binding.gyp</CODE>:</P>
<DIV class="code">
<PRE>
-public class Wheel {
- ...
- // Ensure that the GC doesn't collect any bike set from Java
- private Bike bikeReference;
- protected void addReference(Bike bike) {
- bikeReference = bike;
- }
-}
-
-public class Bike {
- ...
- public Wheel getWheel() {
- long cPtr = exampleJNI.Bike_getWheel(swigCPtr, this);
- Wheel ret = null;
- if (cPtr != 0) {
- ret = new Wheel(cPtr, false);
- ret.addReference(this);
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "example.cxx", "example_wrap.cxx" ]
}
- return ret;
- }
-}
-</PRE>
+ ]
+}</PRE>
</DIV>
-<P> Note the <TT>addReference</TT> call.</P>
-<H3><A name="Java_memory_management_objects"></A>24.10.12 Memory
- management for objects passed to the C++ layer</H3>
-<P> Managing memory can be tricky when using C++ and Java proxy classes.
- The previous example shows one such case and this example looks at
- memory management for a class passed to a C++ method which expects the
- object to remain in scope after the function has returned. Consider the
- following two C++ classes:</P>
-<DIV class="code">
+<P>First create the wrapper using SWIG:</P>
+<DIV class="shell">
<PRE>
-struct Element {
- int value;
- Element(int val) : value(val) {}
-};
-class Container {
- Element* element;
-public:
- Container() : element(0) {}
- void setElement(Element* e) { element = e; }
- Element* getElement() { return element; }
-};
-</PRE>
+$ swig -javascript -node -c++ example.i</PRE>
</DIV>
-<P> and usage from C++</P>
-<DIV class="code">
+<P>Then run <CODE>node-gyp build</CODE> to actually create the module:</P>
+<DIV class="shell">
<PRE>
- Container container;
- Element element(20);
- container.setElement(&element);
- cout << "element.value: " << container.getElement()->value << endl;
-</PRE>
+$ node-gyp build</PRE>
</DIV>
-<P> and more or less equivalent usage from Java</P>
+<P>This will create a <CODE>build</CODE> folder containing the native
+ module. To use the extension you need to 'require' it in your
+ Javascript source file:</P>
<DIV class="code">
<PRE>
- Container container = new Container();
- container.setElement(new Element(20));
- System.out.println("element value: " + container.getElement().getValue());
-</PRE>
+require("./build/Release/example")</PRE>
</DIV>
-<P> The C++ code will always print out 20, but the value printed out may
- not be this in the Java equivalent code. In order to understand why,
- consider a garbage collection occuring...</P>
-<DIV class="code">
+<P>A more detailed explanation is given in the <A href="#Javascript_examples">
+Examples</A> section.</P>
+<H4><A name="Javascript_troubleshooting">26.3.1.1 Troubleshooting</A></H4>
+<UL>
+<LI><EM>'module' object has no attribute 'script_main'</EM></LI>
+</UL>
+<P>This error happens when <CODE>gyp</CODE> is installed as a
+ distribution package. It seems to be outdated. Removing it resolves the
+ problem.</P>
+<DIV class="shell">
<PRE>
- Container container = new Container();
- container.setElement(new Element(20));
- // Simulate a garbage collection
- System.gc();
- System.runFinalization();
- System.out.println("element value: " + container.getElement().getValue());
-</PRE>
+$ sudo apt-get remove gyp</PRE>
</DIV>
-<P> The temporary element created with <TT>new Element(20)</TT> could
- get garbage collected which ultimately means the <TT>container</TT>
- variable is holding a dangling pointer, thereby printing out any old
- random value instead of the expected value of 20. One solution is to
- add in the appropriate references in the Java layer...</P>
+<H3><A name="Javascript_embedded_webkit">26.3.2 Embedded Webkit</A></H3>
+<P>Webkit is pre-installed on Mac OS X and available as a library for
+ GTK.</P>
+<H4><A name="Javascript_osx">26.3.2.1 Mac OS X</A></H4>
+<P>There is general information about programming with WebKit on <A href="https://developer.apple.com/library/mac/documentation/cocoa/conceptual/DisplayWebContent/DisplayWebContent.html">
+Apple Developer Documentation</A>. Details about <CODE>Cocoa</CODE>
+ programming are not covered here.</P>
+<P>An integration of a native extension 'example' would look like this:</P>
<DIV class="code">
<PRE>
-public class Container {
+#import "appDelegate.h"
- ...
+extern bool example_initialize(JSGlobalContextRef context, JSObjectRef* exports);
- // Ensure that the GC doesn't collect any Element set from Java
- // as the underlying C++ class stores a shallow copy
- private Element elementReference;
- private long getCPtrAndAddReference(Element element) {
- elementReference = element;
- return Element.getCPtr(element);
- }
- public void setElement(Element e) {
- exampleJNI.Container_setElement(swigCPtr, this, getCPtrAndAddReference(e), e);
+@implementation ExampleAppDelegate
+
+@synthesize webView;
+
+- (void)addGlobalObject:(JSContextRef) context:(NSString *)objectName:(JSObjectRef) theObject {
+ JSObjectRef global = JSContextGetGlobalObject(context);
+ JSStringRef objectJSName = JSStringCreateWithCFString( (CFStringRef) objectName )
+ if ( objectJSName != NULL ) {
+ JSObjectSetProperty(context, global, objectJSName, theObject, kJSPropertyAttributeReadOnly, NULL);
+ JSStringRelease( objectJSName );
}
}
-</PRE>
+
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
+
+ // Start a webview with the bundled index.html file
+ NSString *path = [[NSBundle mainBundle] bundlePath];
+ NSString *url = [NSString stringWithFormat: @"file://%@/Contents/Assets/index.html", path];
+
+ WebFrame *webframe = [webView mainFrame];
+ JSGlobalContextRef context = [webframe globalContext];
+
+ JSObjectRef example;
+ example_initialize(context, &example);
+ [self addGlobalObject:context:@"example":example]
+
+ JSObjectSetProperty(context, global, JSStringRef propertyName, example, JSPropertyAttributes attributes, NULL);
+
+ [ [webView mainFrame] loadRequest:
+ [NSURLRequest requestWithURL: [NSURL URLWithString:url] ]
+ ];
+}
+
+@end</PRE>
</DIV>
-<P> The following typemaps will generate the desired code. The 'javain'
- typemap matches the input parameter type for the <TT>setElement</TT>
- method. The 'javacode' typemap simply adds in the specified code into
- the Java proxy class.</P>
+<H4><A name="Javascript_gtk">26.3.2.2 GTK</A></H4>
+<P>There is general information about programming GTK at <A href="https://developer.gnome.org/gtk2/">
+GTK documentation</A> and in the <A href="https://developer.gnome.org/gtk-tutorial">
+GTK tutorial</A>, and for Webkit there is a <A href="http://webkitgtk.org/reference/webkitgtk/stable/index.html">
+Webkit GTK+ API Reference</A>.</P>
+<P>An integration of a native extension 'example' would look like this:</P>
<DIV class="code">
<PRE>
-%typemap(javain) Element *e "getCPtrAndAddReference($javainput)"
+#include <gtk/gtk.h>
+#include <webkit/webkit.h>
-%typemap(javacode) Container %{
- // Ensure that the GC doesn't collect any element set from Java
- // as the underlying C++ class stores a shallow copy
- private Element elementReference;
- private long getCPtrAndAddReference(Element element) {
- elementReference = element;
- return Element.getCPtr(element);
- }
-%}
-</PRE>
+extern bool example_initialize(JSGlobalContextRef context);
+
+int main(int argc, char* argv[])
+{
+ // Initialize GTK+
+ gtk_init(&argc, &argv);
+
+ ...
+
+ // Create a browser instance
+ WebKitWebView *webView = WEBKIT_WEB_VIEW(webkit_web_view_new());
+ WebFrame *webframe = webkit_web_view_get_main_frame(webView);
+ JSGlobalContextRef context = webkit_web_frame_get_global_context(webFrame);
+ JSObjectRef global = JSContextGetGlobalObject(context);
+
+ JSObjectRef exampleModule;
+ example_initialize(context, &exampleModule);
+ JSStringRef jsName = JSStringCreateWithUTF8CString("example");
+ JSObjectSetProperty(context, global, jsName, exampleModule, kJSPropertyAttributeReadOnly, NULL);
+ JSStringRelease(jsName);
+
+ ...
+
+ // Load a web page into the browser instance
+ webkit_web_view_load_uri(webView, "http://www.webkitgtk.org/");
+
+ ...
+
+ // Run the main GTK+ event loop
+ gtk_main();
+
+ return 0;
+}</PRE>
</DIV>
-<H3><A name="Java_date_marshalling"></A>24.10.13 Date marshalling using
- the javain typemap and associated attributes</H3>
-<P> The <A href="#Java_nan_exception_typemap">NaN Exception example</A>
- is a simple example of the "javain" typemap and its 'pre' attribute.
- This example demonstrates how a C++ date class, say <TT>CDate</TT>, can
- be mapped onto the standard Java date class, <TT>
-java.util.GregorianCalendar</TT> by using the 'pre', 'post' and
- 'pgcppname' attributes of the "javain" typemap. The idea is that the <TT>
-GregorianCalendar</TT> is used wherever the C++ API uses a <TT>CDate</TT>
-. Let's assume the code being wrapped is as follows:</P>
+<H3><A name="Javascript_applications_webkit">26.3.3 Creating
+ Applications with node-webkit</A></H3>
+<P>To get started with <CODE>node-webkit</CODE> there is a very
+ informative set of <A href="https://github.com/rogerwang/node-webkit/wiki">
+wiki pages</A>.</P>
+<P>Similar to <CODE>node.js</CODE>, <CODE>node-webkit</CODE> is started
+ from command line within a <CODE>node.js</CODE> project directory.
+ Native extensions are created in the very same way as for <CODE>node.js</CODE>
+, except that a customized <CODE>gyp</CODE> derivate has to be used: <A href="https://github.com/rogerwang/nw-gyp">
+nw-gyp</A>.</P>
+<P> A simple example would have the following structure:</P>
<DIV class="code">
<PRE>
-class CDate {
-public:
- CDate(int year, int month, int day);
- int getYear();
- int getMonth();
- int getDay();
- ...
-};
-struct Action {
- static int doSomething(const CDate &dateIn, CDate &dateOut);
- Action(const CDate &date, CDate &dateOut);
-};
+- package.json
+- app.html
+- app.js
+- node_modules
+ / example
+ ... (as known from node.js)
</PRE>
</DIV>
-<P> Note that <TT>dateIn</TT> is const and therefore read only and <TT>
-dateOut</TT> is a non-const output type.</P>
-<P> First let's look at the code that is generated by default, where the
- Java proxy class <TT>CDate</TT> is used in the proxy interface:</P>
+<P> The configuration file essentially conforms to <CODE>node.js</CODE>
+ syntax. It has some extras to configure <CODE>node-webkit</CODE>. See
+ the <A href="https://github.com/rogerwang/node-webkit/wiki/Manifest-format">
+Manifest</A> specification for more details.</P>
+<P> <CODE>package.json</CODE>:</P>
<DIV class="code">
<PRE>
-public class Action {
- ...
- public static int doSomething(CDate dateIn, CDate dateOut) {
- return exampleJNI.Action_doSomething(CDate.getCPtr(dateIn), dateIn,
- CDate.getCPtr(dateOut), dateOut);
- }
-
- public Action(CDate date, CDate dateOut) {
- this(exampleJNI.new_Action(CDate.getCPtr(date), date,
- CDate.getCPtr(dateOut), dateOut), true);
+{
+ "name": "example",
+ "main": "app.html",
+ "window": {
+ "show": true,
+ "width": 800,
+ "height": 600
}
-}
-</PRE>
+}</PRE>
</DIV>
-<P> The <TT>CDate &</TT> and <TT>const CDate &</TT> Java code is
- generated from the following two default typemaps:</P>
+<P> The <CODE>'main'</CODE> property of <CODE>package.json</CODE>
+ specifies a web-page to be rendered in the main window.</P>
+<P> <CODE>app.html</CODE>:</P>
+<DIV class="code">
+<PRE>
+<html>
+ <head>
+ <script src="app.js"></script>
+ </head>
+ <body>
+ <div>
+ The greatest common divisor of
+ <span id="x"></span> and
+ <span id="y"></span> is
+ <span id="z"></span>.
+ </div>
+ </body>
+</html></PRE>
+</DIV>
+<P> As known from <CODE>node.js</CODE> one can use <CODE>require</CODE>
+ to load javascript modules. Additionally, <CODE>node-webkit</CODE>
+ provides an API that allows to manipulate the window's menu, open new
+ windows, and many more things.</P>
+<P> <CODE>app.js</CODE>:</P>
+<DIV class="code">
+<PRE>window.onload = function() {
+ var example = require("example");
+ var x = 18;
+ var y = 24;
+ var z = example.gcd(x,y);
+ document.querySelector('#x').innerHTML = x;
+ document.querySelector('#y').innerHTML = y;
+ document.querySelector('#z').innerHTML = z;
+};</PRE>
+</DIV>
+<H2><A name="Javascript_examples">26.4 Examples</A></H2>
+<P>Some basic examples are shown here in more detail.</P>
+<H3><A name="Javascript_simple_example">26.4.1 Simple</A></H3>
+<P>The common example <CODE>simple</CODE> looks like this:</P>
<DIV class="code">
<PRE>
-%typemap(jstype) SWIGTYPE & "$javaclassname"
-%typemap(javain) SWIGTYPE & "$javaclassname.getCPtr($javainput)"
-</PRE>
+/* File : example.i */
+%module example
+
+%inline %{
+extern int gcd(int x, int y);
+extern double Foo;
+%}</PRE>
</DIV>
-<P> where '$javaclassname' is translated into the proxy class name, <TT>
-CDate</TT> and '$javainput' is translated into the name of the
- parameter, eg <TT>dateIn</TT>. From Java, the intention is then to call
- into a modifed API with something like:</P>
+<P>To make this available as a node extension a <CODE>binding.gyp</CODE>
+ has to be created:</P>
<DIV class="code">
<PRE>
-java.util.GregorianCalendar calendarIn =
- new java.util.GregorianCalendar(2011, java.util.Calendar.APRIL, 13, 0, 0, 0);
-java.util.GregorianCalendar calendarOut = new java.util.GregorianCalendar();
-
-// Note in calls below, calendarIn remains unchanged and calendarOut
-// is set to a new value by the C++ call
-Action.doSomething(calendarIn, calendarOut);
-Action action = new Action(calendarIn, calendarOut);
-</PRE>
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "example.cxx", "example_wrap.cxx" ]
+ }
+ ]
+}</PRE>
</DIV>
-<P> To achieve this mapping, we need to alter the default code
- generation slightly so that at the Java layer, a <TT>GregorianCalendar</TT>
- is converted into a <TT>CDate</TT>. The JNI intermediary layer will
- still take a pointer to the underlying <TT>CDate</TT> class. The
- typemaps to achieve this are shown below.</P>
+<P>Then <CODE>node-gyp</CODE> is used to build the extension:</P>
+<DIV class="shell">
+<PRE>
+$ node-gyp configure build</PRE>
+</DIV>
+<P>From a 'nodejs` application the extension would be used like this:</P>
<DIV class="code">
<PRE>
-%typemap(jstype) const CDate& "java.util.GregorianCalendar"
-%typemap(javain,
- pre=" CDate temp$javainput = new CDate($javainput.get(java.util.Calendar.YEAR), "
- "$javainput.get(java.util.Calendar.MONTH), $javainput.get(java.util.Calendar.DATE));",
- pgcppname="temp$javainput") const CDate &
- "$javaclassname.getCPtr(temp$javainput)"
+// import the extension via require
+var example = require("./build/Release/example");
-%typemap(jstype) CDate& "java.util.Calendar"
-%typemap(javain,
- pre=" CDate temp$javainput = new CDate($javainput.get(java.util.Calendar.YEAR), "
- "$javainput.get(java.util.Calendar.MONTH), $javainput.get(java.util.Calendar.DATE));",
- post=" $javainput.set(temp$javainput.getYear(), temp$javainput.getMonth(), "
- "temp$javainput.getDay(), 0, 0, 0);",
- pgcppname="temp$javainput") CDate &
- "$javaclassname.getCPtr(temp$javainput)"
-</PRE>
+// calling the global method
+var x = 42;
+var y = 105;
+var g = example.gcd(x,y);
+
+// Accessing the global variable
+var f = example.Foo;
+example.Foo = 3.1415926;</PRE>
</DIV>
-<P> The resulting generated proxy code in the <TT>Action</TT> class
- follows:</P>
+<P>First the module <CODE>example</CODE> is loaded from the previously
+ built extension. Global methods and variables are available in the
+ scope of the module.</P>
+<P><B>Note</B>: ECMAScript 5, the currently implemented Javascript
+ standard, does not have modules. <CODE>node.js</CODE> and other
+ implementations provide this mechanism defined by the <A href="http://wiki.commonjs.org/wiki/CommonJS">
+CommonJS</A> group. For browsers this is provided by <A href="http://browserify.org">
+Browserify</A>, for instance.</P>
+<H3><A name="Javascript_class_example">26.4.2 Class</A></H3>
+<P>The common example <CODE>class</CODE> defines three classes, <CODE>
+Shape</CODE>, <CODE>Circle</CODE>, and <CODE>Square</CODE>:</P>
<DIV class="code">
<PRE>
-public class Action {
- ...
- public static int doSomething(java.util.GregorianCalendar dateIn,
- java.util.Calendar dateOut) {
- CDate tempdateIn = new CDate(dateIn.get(java.util.Calendar.YEAR),
- dateIn.get(java.util.Calendar.MONTH),
- dateIn.get(java.util.Calendar.DATE));
- CDate tempdateOut = new CDate(dateOut.get(java.util.Calendar.YEAR),
- dateOut.get(java.util.Calendar.MONTH),
- dateOut.get(java.util.Calendar.DATE));
- try {
- return exampleJNI.Action_doSomething(CDate.getCPtr(tempdateIn), tempdateIn,
- CDate.getCPtr(tempdateOut), tempdateOut);
- } finally {
- dateOut.set(tempdateOut.getYear(), tempdateOut.getMonth(), tempdateOut.getDay(), 0, 0, 0);
- }
+class Shape {
+public:
+ Shape() {
+ nshapes++;
}
-
- static private long SwigConstructAction(java.util.GregorianCalendar date,
- java.util.Calendar dateOut) {
- CDate tempdate = new CDate(date.get(java.util.Calendar.YEAR),
- date.get(java.util.Calendar.MONTH),
- date.get(java.util.Calendar.DATE));
- CDate tempdateOut = new CDate(dateOut.get(java.util.Calendar.YEAR),
- dateOut.get(java.util.Calendar.MONTH),
- dateOut.get(java.util.Calendar.DATE));
- try {
- return exampleJNI.new_Action(CDate.getCPtr(tempdate), tempdate,
- CDate.getCPtr(tempdateOut), tempdateOut);
- } finally {
- dateOut.set(tempdateOut.getYear(), tempdateOut.getMonth(), tempdateOut.getDay(), 0, 0, 0);
- }
+ virtual ~Shape() {
+ nshapes--;
}
+ double x, y;
+ void move(double dx, double dy);
+ virtual double area(void) = 0;
+ virtual double perimeter(void) = 0;
+ static int nshapes;
+};
- public Action(java.util.GregorianCalendar date, java.util.Calendar dateOut) {
- this(Action.SwigConstructAction(date, dateOut), true);
- }
-}
-</PRE>
+class Circle : public Shape {
+private:
+ double radius;
+public:
+ Circle(double r) : radius(r) { }
+ virtual double area(void);
+ virtual double perimeter(void);
+};
+
+class Square : public Shape {
+private:
+ double width;
+public:
+ Square(double w) : width(w) { }
+ virtual double area(void);
+ virtual double perimeter(void);
+};</PRE>
</DIV>
-<P> A few things to note:</P>
-<UL>
-<LI> The "javatype" typemap has changed the parameter type to <TT>
-java.util.GregorianCalendar</TT> or <TT>java.util.Calendar</TT> instead
- of the default generated <TT>CDate</TT> proxy.</LI>
-<LI> The code in the 'pre' attribute appears before the JNI call (<TT>
-exampleJNI.new_Action</TT> / <TT>exampleJNI.Action_doSomething</TT>).</LI>
-<LI> The code in the 'post' attribute appears after the JNI call.</LI>
-<LI> A try .. finally block is generated with the JNI call in the try
- block and 'post' code in the finally block. The alternative of just
- using a temporary variable for the return value from the JNI call and
- the 'post' code being generated before the return statement is not
- possible given that the JNI call is in one line and comes from the
- "javaout" typemap.</LI>
-<LI> The temporary variables in the "javain" typemaps are called <TT>
-temp$javain</TT>, where "$javain" is replaced with the parameter name.
- "$javain" is used to mangle the variable name so that more than one <TT>
-CDate &</TT> type can be used as a parameter in a method, otherwise two
- or more local variables with the same name would be generated.</LI>
-<LI> The use of the "javain" typemap causes a constructor helper
- function (<TT>SwigConstructAction</TT>) to be generated. This allows
- Java code to be called before the JNI call and is required as the Java
- compiler won't compile code inserted before the 'this' call.</LI>
-<LI> The 'pgcppname' attribute is used to modify the object being passed
- as the <A href="#Java_pgcpp">premature garbage collection prevention
- parameter</A> (the 2nd and 4th parameters in the JNI calls).</LI>
-</UL>
-<H2><A name="Java_directors_faq"></A>24.11 Living with Java Directors</H2>
-<P> This section is intended to address frequently asked questions and
- frequently encountered problems when using Java directors.</P>
-<OL>
-<LI><I>When my program starts up, it complains that</I> method_foo<I>
- cannot be found in a Java method called</I> swig_module_init<I>. How do
- I fix this?</I>
-<P> Open up the C++ wrapper source code file and look for <CODE>
-"method_foo"</CODE> (include the double quotes, they are important!)
- Look at the JNI field descriptor and make sure that each class that
- occurs in the descriptor has the correct package name in front of it.
- If the package name is incorrect, put a "javapackage" typemap in your
- SWIG interface file.</P>
-</LI>
-<LI><I>I'm compiling my code and I'm using templates. I provided a
- javapackage typemap, but SWIG doesn't generate the right JNI field
- descriptor.</I>
-<P> Use the template's renamed name as the argument to the "javapackage"
- typemap:</P>
-<DIV class="code">
-<PRE>
-%typemap(javapackage) std::vector<int> "your.package.here"
-%template(VectorOfInt) std::vector<int>;
-</PRE>
-</DIV></LI>
-<LI>
-<P><I>When I pass class pointers or references through a C++ upcall and
- I try to type cast them, Java complains with a ClassCastException. What
- am I doing wrong?</I></P>
-<P> Normally, a non-director generated Java proxy class creates
- temporary Java objects as follows:</P>
+<P><CODE>Circle</CODE> and <CODE>Square</CODE> inherit from <CODE>Shape</CODE>
+. <CODE>Shape</CODE> has a static variable <CODE>nshapes</CODE>, a
+ function <CODE>move</CODE> that can't be overridden (non-virtual), and
+ two abstract functions <CODE>area</CODE> and <CODE>perimeter</CODE>
+ (pure virtual) that must be overridden by the sub-classes.</P>
+<P>A <CODE>nodejs</CODE> extension is built the same way as for the <CODE>
+simple</CODE> example.</P>
+<P>In Javascript it can be used as follows:</P>
<DIV class="code">
<PRE>
-public static void MyClass_method_upcall(MyClass self, long jarg1)
-{
- Foo darg1 = new Foo(jarg1, false);
+var example = require("./build/Release/example");
- self.method_upcall(darg1);
-}
-</PRE>
-</DIV>
-<P>Unfortunately, this loses the Java type information that is part of
- the underlying Foo director proxy class's Java object pointer causing
- the type cast to fail. The SWIG Java module's director code attempts to
- correct the problem,<B> but only for director-enabled classes</B>,
- since the director class retains a global reference to its Java object.
- Thus, for director-enabled classes<B> and only for director-enabled
- classes</B>, the generated proxy Java code looks something like:</P>
-<DIV class="code">
+// local aliases for convenience
+var Shape = example.Shape;
+var Circle = example.Circle;
+var Square = example.Square;
+
+// creating new instances using the 'new' operator
+var c = new Circle(10);
+var s = new Square(10);
+
+// accessing a static member
+Shape.nshapes;
+
+// accessing member variables
+c.x = 20;
+c.y = 30;
+s.x = -10;
+s.y = 5;
+
+// calling some methods
+c.area();
+c.perimeter();
+s.area();
+s.perimeter();
+
+// instantiation of Shape is not permitted
+new Shape();</PRE>
+</DIV>
+<P>Running these commands in an interactive node shell results in the
+ following output:</P>
+<DIV class="shell">
<PRE>
-public static void MyClass_method_upcall(MyClass self, long jarg1,
- Foo jarg1_object)
-{
- Foo darg1 = (jarg1_object != null ? jarg1_object : new Foo(jarg1, false));
+$ node -i
+& var example = require("./build/Release/example");
+undefined
+& var Shape = example.Shape;
+undefined
+& var Circle = example.Circle;
+undefined
+& var Square = example.Square;
+undefined
+& var c = new Circle(10);
+undefined
+& var s = new Square(10);
+undefined
+& Shape.nshapes;
+2
+& c.x = 20;
+20
+& c.y = 30;
+30
+& s.x = -10;
+-10
+& s.y = 5;
+5
+& c.area();
+314.1592653589793
+& c.perimeter();
+62.83185307179586
+& s.area();
+100
+& s.perimeter();
+40
+& c.move(40, 40)
+undefined
+& c.x
+60
+& c.y
+70
+& new Shape()
+Error: Class Shape can not be instantiated
+at repl:1:2
+at REPLServer.self.eval (repl.js:110:21)
+at Interface.<anonymous> (repl.js:239:12)
+at Interface.EventEmitter.emit (events.js:95:17)
+at Interface._onLine (readline.js:202:10)
+at Interface._line (readline.js:531:8)
+at Interface._ttyWrite (readline.js:760:14)
+at ReadStream.onkeypress (readline.js:99:10)
+at ReadStream.EventEmitter.emit (events.js:98:17)
+at emitKey (readline.js:1095:12)</PRE>
+</DIV>
+<P><B> Note</B>: In ECMAScript 5 there is no concept for classes.
+ Instead each function can be used as a constructor function which is
+ executed by the 'new' operator. Furthermore, during construction the
+ key property <CODE>prototype</CODE> of the constructor function is used
+ to attach a prototype instance to the created object. A prototype is
+ essentially an object itself that is the first-class delegate of a
+ class used whenever the access to a property of an object fails. The
+ very same prototype instance is shared among all instances of one type.
+ Prototypal inheritance is explained in more detail on in <A href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain">
+Inheritance and the prototype chain</A>, for instance.</P>
+<H2><A name="Javascript_implementation">26.5 Implementation</A></H2>
+<P>The Javascript Module implementation has taken a very different
+ approach compared to other language modules in order to support
+ different Javascript interpreters.</P>
+<H3><A name="Javascript_source_code">26.5.1 Source Code</A></H3>
+<P>The Javascript module is implemented in <CODE>
+Source/Modules/javascript.cxx</CODE>. It dispatches the code generation
+ to a <CODE>JSEmitter</CODE> instance, <CODE>V8Emitter</CODE> or <CODE>
+JSCEmitter</CODE>. Additionally there are some helpers: <CODE>Template</CODE>
+, for templated code generation, and <CODE>JSEmitterState</CODE>, which
+ is used to manage state information during AST traversal. This rough
+ map shall make it easier to find a way through this huge source file:</P>
+<DIV class="code">
+<PRE>
+// module wide defines
+
+#define NAME "name"
+...
- self.method_upcall(darg1);
-}
-</PRE>
+// ###############################
+// # Helper class declarations
+
+class JSEmitterState { ... };
+
+class Template { ... };
+
+// ###############################
+// # JSEmitter declaration
+
+class JSEmitter { ... };
+
+// Emitter factory declarations
+
+JSEmitter *swig_javascript_create_JSCEmitter();
+JSEmitter *swig_javascript_create_V8Emitter();
+
+// ###############################
+// # Javascript module
+
+// Javascript module declaration
+
+class JAVASCRIPT:public Language { ... };
+
+// Javascript module implementation
+
+int JAVASCRIPT::functionWrapper(Node *n) { ... }
+...
+
+// Module factory implementation
+
+static Language *new_swig_javascript() { ... }
+
+extern "C" Language *swig_javascript(void) { ... }
+
+// ###############################
+// # JSEmitter base implementation
+
+JSEmitter::JSEmitter() { ... }
+
+Template JSEmitter::getTemplate(const String *name) { ... }
+...
+
+// ###############################
+// # JSCEmitter
+
+// JSCEmitter declaration
+
+class JSCEmitter: public JSEmitter { ... };
+
+// JSCEmitter implementation
+
+JSCEmitter::JSCEmitter() { ... }
+
+void JSCEmitter::marshalInputArgs(Node *n, ParmList *parms, Wrapper *wrapper, MarshallingMode mode, bool is_member, bool is_static) { ... }
+...
+
+// JSCEmitter factory
+
+JSEmitter *swig_javascript_create_JSCEmitter() { ... }
+
+
+// ###############################
+// # V8Emitter
+
+// V8Emitter declaration
+
+class V8Emitter: public JSEmitter { ... };
+
+// V8Emitter implementation
+
+V8Emitter::V8Emitter() { ... }
+
+int V8Emitter::initialize(Node *n) { ... }
+
+// V8Emitter factory
+
+JSEmitter *swig_javascript_create_V8Emitter() { ... }
+
+
+// ###############################
+// # Helper implementation (JSEmitterState, Template)
+
+JSEmitterState::JSEmitterState() { ... }
+...
+
+Template::Template(const String *code_) { ... }
+...</PRE>
</DIV>
-<P> When you import a SWIG interface file containing class definitions,
- the classes you want to be director-enabled must be have the <CODE>
-feature("director")</CODE> enabled for type symmetry to work. This
- applies even when the class being wrapped isn't a director-enabled
- class but takes parameters that are director-enabled classes.</P>
-<P> The current "type symmetry" design will work for simple C++
- inheritance, but will most likely fail for anything more complicated
- such as tree or diamond C++ inheritance hierarchies. Those who are
- interested in challenging problems are more than welcome to hack the <CODE>
-Java::Java_director_declaration</CODE> method in <CODE>
-Source/Modules/java.cxx</CODE>.</P>
-<P> If all else fails, you can use the downcastXXXXX() method to attempt
- to recover the director class's Java object pointer. For the Java Foo
- proxy class, the Foo director class's java object pointer can be
- accessed through the javaObjectFoo() method. The generated method's
- signature is:</P>
-<DIV class="code">
+<H3><A name="Javascript_code_templates">26.5.2 Code Templates</A></H3>
+<P>All generated code is created on the basis of code templates. The
+ templates for<EM> JavascriptCore</EM> can be found in <CODE>
+Lib/javascript/jsc/javascriptcode.swg</CODE>, for<EM> v8</EM> in <CODE>
+Lib/javascript/v8/javascriptcode.swg</CODE>.</P>
+<P>To track the originating code template for generated code you can run</P>
+<DIV class="shell">
<PRE>
- public static Foo javaObjectFoo(Foo obj);
-</PRE>
+$ swig -javascript -jsc -debug-codetemplates</PRE>
</DIV>
-<P> From your code, this method is invoked as follows:</P>
+<P>which wraps generated code with a descriptive comment</P>
<DIV class="code">
<PRE>
-public class MyClassDerived {
- public void method_upcall(Foo foo_object)
- {
- FooDerived derived = (foo_object != null ?
- (FooDerived) Foo.downcastFoo(foo_object) : null);
- /* rest of your code here */
- }
-}
-</PRE>
+/* begin fragment("template_name") */
+
+...generated code ...
+
+/* end fragment("template_name") */</PRE>
</DIV>
-<P> An good approach for managing downcasting is placing a static method
- in each derived class that performs the downcast from the superclass,
- e.g.,</P>
+<P>The Template class is used like this:</P>
<DIV class="code">
<PRE>
-public class FooDerived extends Foo {
- /* ... */
- public static FooDerived downcastFooDerived(Foo foo_object)
- {
- try {
- return (foo_object != null ? (FooDerived) Foo.downcastFoo(foo_object);
- }
-
- catch (ClassCastException exc) {
- // Wasn't a FooDerived object, some other subclass of Foo
- return null;
- }
- }
-}
-</PRE>
+Template t_register = getTemplate("jsv8_register_static_variable");
+t_register.replace("$jsparent", state.clazz(NAME_MANGLED))
+ .replace("$jsname", state.variable(NAME))
+ .replace("$jsgetter", state.variable(GETTER))
+ .replace("$jssetter", state.variable(SETTER))
+ .trim().
+ print(f_init_static_wrappers);</PRE>
</DIV>
-<P> Then change the code in MyClassDerived as follows:</P>
+<P>A code template is registered with the<EM> JSEmitter</EM> via <CODE>
+fragment(name, "template")</CODE>, e.g.,</P>
<DIV class="code">
<PRE>
-public class MyClassDerived extends MyClass {
- /* ... */
- public void method_upcall(Foo foo_object)
- {
- FooDerived derived = FooDerived.downcastFooDerived(foo_object);
- /* rest of your code here */
- }
-}
-</PRE>
-</DIV></LI>
-<LI>
-<P><I>Why isn't the proxy class declared abstract? Why aren't the
- director upcall methods in the proxy class declared abstract?</I></P>
-<P> Declaring the proxy class and its methods abstract would break the
- JNI argument marshalling and SWIG's downcall functionality (going from
- Java to C++.) Create an abstract Java subclass that inherits from the
- director-enabled class instead. Using the previous Foo class example:</P>
+%fragment ("jsc_variable_declaration", "templates")
+%{
+ {"$jsname", $jsgetter, $jssetter, kJSPropertyAttributeNone},
+%}</PRE>
+</DIV>
+<P><CODE>Template</CODE> creates a copy of that string and <CODE>
+Template::replace</CODE> uses Swig's <CODE>Replaceall</CODE> to replace
+ variables in the template. <CODE>Template::trim</CODE> can be used to
+ eliminate leading and trailing whitespaces. <CODE>Template::print</CODE>
+ is used to write the final template string to a Swig <CODE>DOH</CODE>
+ (based on <CODE>Printv</CODE>). All methods allow chaining.</P>
+<H3><A name="Javascript_emitter">26.5.3 Emitter</A></H3>
+<P>The Javascript module delegates code generation to a <CODE>JSEmitter</CODE>
+ instance. The following extract shows the essential interface:</P>
<DIV class="code">
<PRE>
-public abstract class UserVisibleFoo extends Foo {
- /** Make sure user overrides this method, it's where the upcall
- * happens.
+class JSEmitter {
+ ...
+
+ /**
+ * Opens output files and temporary output DOHs.
*/
- public abstract void method_upcall(Foo foo_object);
+ virtual int initialize(Node *n);
- /// Downcast from Foo to UserVisibleFoo
- public static UserVisibleFoo downcastUserVisibleFoo(Foo foo_object)
- {
- try {
- return (foo_object != null ? (FooDerived) Foo.downcastFoo(foo_object) : null);
- }
+ /**
+ * Writes all collected code into the output file(s).
+ */
+ virtual int dump(Node *n) = 0;
- catch (ClassCastException exc) {
- // Wasn't a FooDerived object, some other subclass of Foo
- return null;
- }
+ /**
+ * Cleans up all open output DOHs.
+ */
+ virtual int close() = 0;
+
+ ...
+
+ /**
+ * Invoked at the beginning of the classHandler.
+ */
+ virtual int enterClass(Node *);
+
+ /**
+ * Invoked at the end of the classHandler.
+ */
+ virtual int exitClass(Node *) {
+ return SWIG_OK;
}
-}
-</PRE>
-</DIV>
-<P>This doesn't prevent the user from creating subclasses derived from
- Foo, however, UserVisibleFoo provides the safety net that reminds the
- user to override the <CODE>method_upcall()</CODE> method.</P>
-</LI>
-</OL>
-<H2><A name="Java_odds_ends"></A>24.12 Odds and ends</H2>
-<H3><A name="Java_javadoc_comments"></A>24.12.1 JavaDoc comments</H3>
-<P> The SWIG documentation system is currently deprecated. When it is
- resurrected JavaDoc comments will be fully supported. If you can't wait
- for the full documentation system a couple of workarounds are
- available. The <TT>%javamethodmodifiers</TT> feature can be used for
- adding proxy class method comments and module class method comments.
- The "javaimports" typemap can be hijacked for adding in proxy class
- JavaDoc comments. The <TT>jniclassimports</TT> or <TT>
-jniclassclassmodifiers</TT> pragmas can also be used for adding
- intermediary JNI class comments and likewise the <TT>moduleimports</TT>
- or <TT>moduleclassmodifiers</TT> pragmas for the module class. Here is
- an example adding in a proxy class and method comment:</P>
-<DIV class="code">
-<PRE>
-%javamethodmodifiers Barmy::lose_marbles() "
+
/**
- * Calling this method will make you mad.
- * Use with <b>utmost</b> caution.
- */
- public";
+ * Invoked at the beginning of the variableHandler.
+ */
+ virtual int enterVariable(Node *);
-%typemap(javaimports) Barmy "
-/** The crazy class. Use as a last resort. */"
+ /**
+ * Invoked at the end of the variableHandler.
+ */
+ virtual int exitVariable(Node *) {
+ return SWIG_OK;
+ }
-class Barmy {
-public:
- void lose_marbles() {}
-};
-</PRE>
-</DIV>
-<P> Note the "public" added at the end of the <TT>%javamethodmodifiers</TT>
- as this is the default for this feature. The generated proxy class with
- JavaDoc comments is then as follows:</P>
-<DIV class="code">
-<PRE>
-/** The crazy class. Use as a last resort. */
-public class Barmy {
-...
/**
- * Calling this method will make you mad.
- * Use with <b>utmost</b> caution.
- */
- public void lose_marbles() {
- ...
+ * Invoked at the beginning of the functionHandler.
+ */
+ virtual int enterFunction(Node *);
+
+ /**
+ * Invoked at the end of the functionHandler.
+ */
+ virtual int exitFunction(Node *) {
+ return SWIG_OK;
}
-...
-}
-</PRE>
-</DIV>
-<H3><A name="Java_functional_interface"></A>24.12.2 Functional interface
- without proxy classes</H3>
-<P> It is possible to run SWIG in a mode that does not produce proxy
- classes by using the -noproxy commandline option. The interface is
- rather primitive when wrapping structures or classes and is accessed
- through function calls to the module class. All the functions in the
- module class are wrapped by functions with identical names as those in
- the intermediary JNI class.</P>
-<P> Consider the example we looked at when examining proxy classes:</P>
-<DIV class="code">
-<PRE>
-class Foo {
-public:
- int x;
- int spam(int num, Foo* foo);
-};
-</PRE>
+
+ /**
+ * Invoked by functionWrapper callback after call to Language::functionWrapper.
+ */
+ virtual int emitWrapperFunction(Node *n);
+
+ /**
+ * Invoked from constantWrapper after call to Language::constantWrapper.
+ **/
+ virtual int emitConstant(Node *n);
+
+ /**
+ * Registers a given code snippet for a given key name.
+ *
+ * This method is called by the fragmentDirective handler
+ * of the JAVASCRIPT language module.
+ **/
+ int registerTemplate(const String *name, const String *code);
+
+ /**
+ * Retrieve the code template registered for a given name.
+ */
+ Template getTemplate(const String *name);
+
+ State &getState();
+
+ ...
+
+}</PRE>
</DIV>
-<P> When using <TT>-noproxy</TT>, type wrapper classes are generated
- instead of proxy classes. Access to all the functions and variables is
- through a C like set of functions where the first parameter passed is
- the pointer to the class, that is an instance of a type wrapper class.
- Here is what the module class looks like:</P>
+<P>The module calls <CODE>initialize</CODE>, <CODE>dump</CODE>, and <CODE>
+close</CODE> from within the <CODE>top</CODE> method:</P>
<DIV class="code">
<PRE>
-public class example {
- public static void Foo_x_get(SWIGTYPE_p_Foo self, int x) {...}
- public static int Foo_x_get(SWIGTYPE_p_Foo self) {...}
- public static int Foo_spam(SWIGTYPE_p_Foo self, int num, SWIGTYPE_p_Foo foo) {...}
- public static SWIGTYPE_p_Foo new_Foo() {...}
- public static void delete_Foo(SWIGTYPE_p_Foo self) {...}
-}
-</PRE>
+int JAVASCRIPT::top(Node *n) {
+ emitter->initialize(n);
+
+ Language::top(n);
+
+ emitter->dump(n);
+ emitter->close();
+
+ return SWIG_OK;
+}</PRE>
</DIV>
-<P> This approach is not nearly as natural as using proxy classes as the
- functions need to be used like this:</P>
+<P>The methods <CODE>enterClass</CODE> and <CODE>exitClass</CODE> are
+ called from within the <CODE>classHandler</CODE> method:</P>
<DIV class="code">
<PRE>
-SWIGTYPE_p_Foo foo = example.new_Foo();
-example.Foo_x_set(foo, 10);
-int var = example.Foo_x_get(foo);
-example.Foo_spam(foo, 20, foo);
-example.delete_Foo(foo);
-</PRE>
+int JAVASCRIPT::classHandler(Node *n) {
+
+ emitter->enterClass(n);
+ Language::classHandler(n);
+ emitter->exitClass(n);
+
+ return SWIG_OK;
+}</PRE>
</DIV>
-<P> Unlike proxy classes, there is no attempt at tracking memory. All
- destructors have to be called manually for example the <TT>
-delete_Foo(foo)</TT> call above.</P>
-<H3><A name="Java_using_own_jni_functions"></A>24.12.3 Using your own
- JNI functions</H3>
-<P> You may have some hand written JNI functions that you want to use in
- addition to the SWIG generated JNI functions. Adding these to your SWIG
- generated package is possible using the <TT>%native</TT> directive. If
- you don't want SWIG to wrap your JNI function then of course you can
- simply use the <TT>%ignore</TT> directive. However, if you want SWIG to
- generate just the Java code for a JNI function then use the <TT>%native</TT>
- directive. The C types for the parameters and return type must be
- specified in place of the JNI types and the function name must be the
- native method name. For example:</P>
+<P>In <CODE>enterClass</CODE> the emitter stores state information that
+ is necessary when processing class members. In <CODE>exitClass</CODE>
+ the wrapper code for the whole class is generated.</P>
+<H3><A name="Javascript_emitter_states">26.5.4 Emitter states</A></H3>
+<P>For storing information during the AST traversal the emitter provides
+ a <CODE>JSEmitterState</CODE> with different slots to store data
+ representing the scopes global, class, function, and variable.</P>
<DIV class="code">
<PRE>
-%native (HandRolled) void HandRolled(int, char *);
-%{
-JNIEXPORT void JNICALL Java_packageName_moduleName_HandRolled(JNIEnv *, jclass,
- jlong, jstring);
-%}
-</PRE>
+class JSEmitterState {
+
+public:
+
+ JSEmitterState();
+
+ ~JSEmitterState();
+
+ DOH *global();
+
+ DOH *global(const char* key, DOH *initial = 0);
+
+ DOH *clazz(bool reset = false);
+
+ DOH *clazz(const char* key, DOH *initial = 0);
+
+ DOH *function(bool reset = false);
+
+ DOH *function(const char* key, DOH *initial = 0);
+
+ DOH *variable(bool reset = false);
+
+ DOH *variable(const char* key, DOH *initial = 0);
+
+ static int IsSet(DOH *val);
+
+ ...
+};</PRE>
</DIV>
-<P> No C JNI function will be generated and the <TT>
-Java_packageName_moduleName_HandRolled</TT> function will be accessible
- using the SWIG generated Java native method call in the intermediary
- JNI class which will look like this:</P>
+<P>When entering a scope, such as in <CODE>enterClass</CODE>, the
+ corresponding state is reset and new data is stored:</P>
<DIV class="code">
<PRE>
- public final static native void HandRolled(int jarg1, String jarg2);
-</PRE>
+state.clazz(RESET);
+state.clazz(NAME, Getattr(n, "sym:name"));</PRE>
</DIV>
-<P> and as usual this function is wrapped by another which for a global
- C function would appear in the module class:</P>
+<P>State information can be retrieved using <CODE>state.clazz(NAME)</CODE>
+ or with <CODE>Getattr</CODE> on <CODE>state.clazz()</CODE> which
+ actually returns a <CODE>Hash</CODE> instance.</P>
+<H3><A name="Javascript_jsc_exceptions">26.5.5 Handling Exceptions in
+ JavascriptCore</A></H3>
+<P>Applications with an embedded JavascriptCore should be able to
+ present detailed exception messages that occur in the Javascript
+ engine. Below is an example derived from code provided by Brian Barnes
+ on how these exception details can be extracted.</P>
<DIV class="code">
<PRE>
- public static void HandRolled(int arg0, String arg1) {
- exampleJNI.HandRolled(arg0, arg1);
+void script_exception_to_string(JSContextRef js_context,JSValueRef exception_value_ref,char* return_error_string, int return_error_string_max_length)
+{
+ JSObjectRef exception_object;
+ JSValueRef value_ref;
+ JSStringRef jsstring_property_name = NULL;
+ JSValueRef temporary_exception = NULL;
+ JSStringRef js_return_string = NULL;
+ size_t bytes_needed;
+ char* c_result_string = NULL;
+ exception_object = JSValueToObject(js_context, exception_value_ref, NULL);
+
+ /* source url */
+ strcpy(return_error_string,"[");
+ jsstring_property_name = JSStringCreateWithUTF8CString("sourceURL");
+ value_ref = JSObjectGetProperty(js_context, exception_object, jsstring_property_name, &temporary_exception);
+ JSStringRelease(jsstring_property_name);
+ js_return_string = JSValueToStringCopy(js_context, value_ref, NULL);
+ bytes_needed = JSStringGetMaximumUTF8CStringSize(js_return_string);
+ c_result_string = (char*)calloc(bytes_needed, sizeof(char));
+ JSStringGetUTF8CString(js_return_string, c_result_string, bytes_needed);
+ JSStringRelease(js_return_string);
+ strncat(return_error_string, c_result_string, return_error_string_max_length-1);
+ free(c_result_string);
+
+ strncat(return_error_string, ":", return_error_string_max_length-1);
+
+ /* line number */
+
+ jsstring_property_name = JSStringCreateWithUTF8CString("line");
+ value_ref = JSObjectGetProperty(js_context, exception_object, jsstring_property_name, &temporary_exception);
+ JSStringRelease(jsstring_property_name);
+ js_return_string = JSValueToStringCopy(js_context, value_ref, NULL);
+ bytes_needed = JSStringGetMaximumUTF8CStringSize(js_return_string);
+ c_result_string = (char*)calloc(bytes_needed, sizeof(char));
+ JSStringGetUTF8CString(js_return_string, c_result_string, bytes_needed);
+ JSStringRelease(js_return_string);
+ strncat(return_error_string, c_result_string, return_error_string_max_length-1);
+ free(c_result_string);
+
+ strncat(return_error_string, "]", return_error_string_max_length-1);
+
+ /* error message */
+
+ jsstring_property_name = JSStringCreateWithUTF8CString("message");
+ value_ref = JSObjectGetProperty(js_context, exception_object, jsstring_property_name, &temporary_exception);
+ JSStringRelease(jsstring_property_name);
+ if(NULL == value_ref)
+ {
+ strncat(return_error_string, "Unknown Error", return_error_string_max_length-1);
}
-</PRE>
+ else
+ {
+ js_return_string = JSValueToStringCopy(js_context, value_ref, NULL);
+ bytes_needed = JSStringGetMaximumUTF8CStringSize(js_return_string);
+ c_result_string = (char*)calloc(bytes_needed, sizeof(char));
+ JSStringGetUTF8CString(js_return_string, c_result_string, bytes_needed);
+ JSStringRelease(js_return_string);
+ strncat(return_error_string, c_result_string, return_error_string_max_length-1);
+ free(c_result_string);
+ }
+}</PRE>
</DIV>
-<P> The <TT>packageName</TT> and <TT>moduleName</TT> must of course be
- correct else you will get linker errors when the JVM dynamically loads
- the JNI function. You may have to add in some "jtype", "jstype",
- "javain" and "javaout" typemaps when wrapping some JNI types. Here the
- default typemaps work for <TT>int</TT> and <TT>char *</TT>.</P>
-<P> In summary the <TT>%native</TT> directive is telling SWIG to
- generate the Java code to access the JNI C code, but not the JNI C
- function itself. This directive is only really useful if you want to
- mix your own hand crafted JNI code and the SWIG generated code into one
- Java class or package.</P>
-<H3><A name="Java_performance"></A>24.12.4 Performance concerns and
- hints</H3>
-<P> If you're directly manipulating huge arrays of complex objects from
- Java, performance may suffer greatly when using the array functions in <TT>
-arrays_java.i</TT>. Try and minimise the expensive JNI calls to C/C++
- functions, perhaps by using temporary Java variables instead of
- accessing the information directly from the C/C++ object.</P>
-<P> Java classes without any finalizers generally speed up code
- execution as there is less for the garbage collector to do. Finalizer
- generation can be stopped by using an empty <TT>javafinalize</TT>
- typemap:</P>
+<P>It would be used in the following way:</P>
<DIV class="code">
<PRE>
-%typemap(javafinalize) SWIGTYPE ""
-</PRE>
-</DIV>
-<P> However, you will have to be careful about memory management and
- make sure that you code in a call to the <TT>delete()</TT> member
- function. This method normally calls the C++ destructor or <TT>free()</TT>
- for C code.</P>
-<H3><A name="Java_debugging"></A>24.12.5 Debugging</H3>
-<P> The generated code can be debugged using both a Java debugger and a
- C++ debugger using the usual debugging techniques. Breakpoints can be
- set in either Java or C++ code and so both can be debugged
- simultaneously. Most debuggers do not understand both Java and C++,
- with one noteable exception of Sun Studio, where it is possible to step
- from Java code into a JNI method within one environment.</P>
-<P> Alternatively, debugging can involve placing debug printout
- statements in the JNI layer using the <TT>%exception</TT> directive.
- See the <A href="#Customization_exception_special_variables">special
- variables for %exception</A> section. Many of the default typemaps can
- also be overidden and modified for adding in extra logging/debug
- display information.</P>
-<P> The <TT>-Xcheck:jni</TT> and <TT>-Xcheck:nabounds</TT> Java
- executable options are useful for debugging to make sure the JNI code
- is behaving. The -verbose:jni and -verbose:gc are also useful options
- for monitoring code behaviour.</P>
-<H2><A name="Java_examples"></A>24.13 Java Examples</H2>
-<P> The directory Examples/java has a number of further examples. Take a
- look at these if you want to see some of the techniques described in
- action. The Examples/index.html file in the parent directory contains
- the SWIG Examples Documentation and is a useful starting point. If your
- SWIG installation went well Unix users should be able to type <TT>make</TT>
- in each example directory, then <TT>java main</TT> to see them running.
- For the benefit of Windows users, there are also Visual C++ project
- files in a couple of the <A href="#Windows_examples">Windows Examples</A>
-. There are also many regression tests in the Examples/test-suite
- directory. Many of these have runtime tests in the java subdirectory.</P>
-<HR NOSHADE>
-<H1><A name="Lisp"></A>25 SWIG and Common Lisp</H1>
+if(js_exception)
+{
+ char return_error_string[256];
+ script_exception_to_string(js_context, js_exception, return_error_string, 256);
+ printf("Compile error is %s", return_error_string);
+}</PRE>
+</DIV><HR NOSHADE>
+<H1><A name="Lisp">27 SWIG and Common Lisp</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
foreign function interfaces. SWIG currently supports only the Allegro
Common Lisp, Common Foreign Function Interface(CFFI), CLisp and UFFI
foreign function interfaces.</P>
-<H2><A name="Lisp_nn2"></A>25.1 Allegro Common Lisp</H2>
+<H2><A name="Lisp_nn2">27.1 Allegro Common Lisp</A></H2>
<P> Allegro Common Lisp support in SWIG has been updated to include
support for both C and C++. You can read about the interface <A href="#Allegrocl">
here</A></P>
-<H2><A name="Lisp_nn3"></A>25.2 Common Foreign Function Interface(CFFI)</H2>
+<H2><A name="Lisp_nn3">27.2 Common Foreign Function Interface(CFFI)</A></H2>
<P> CFFI, the Common Foreign Function Interface, is a portable foreign
function interface for ANSI Common Lisp systems, similar in spirit to
UFFI. Unlike UFFI, CFFI requires only a small set of low-level
<P> But a better was of using all the power of SWIG is to write SWIG
interface files. Below we will explain how to write interface files and
the various things which you can do with them.</P>
-<H3><A name="Lisp_nn4"></A>25.2.1 Additional Commandline Options</H3>
+<H3><A name="Lisp_nn4">27.2.1 Additional Commandline Options</A></H3>
<P> The following table list the additional commandline options
available for the CLISP module. They can also be seen by using:</P>
<DIV class="code">
wrappers. These macros, functions may still be used by generated
wrapper code.</TD></TR>
</TABLE>
-<H3><A name="Lisp_nn5"></A>25.2.2 Generating CFFI bindings</H3>
+<H3><A name="Lisp_nn5">27.2.2 Generating CFFI bindings</A></H3>
As we mentioned earlier the ideal way to use SWIG is to use interface
- files. To illustrate the use of it, lets assume that we have a file
+ files. To illustrate the use of it, let's assume that we have a file
named<I> test.h</I> with the following C code:<DIV class="code">
<PRE>
#define y 5
(cl:defconstant x (cl:ash 5 -1))
(cffi:defcstruct bar
- (p :short)
- (q :short)
- (a :char)
- (b :char)
- (z :pointer)
- (n :pointer))
+ (p :short)
+ (q :short)
+ (a :char)
+ (b :char)
+ (z :pointer)
+ (n :pointer))
(cffi:defcvar ("my_struct" my_struct)
:pointer)
(cffi:defcstruct foo
- (a :int)
- (b :pointer))
+ (a :int)
+ (b :pointer))
(cffi:defcfun ("pointer_func" pointer_func) :int
(ClosureFun :pointer)
(array :pointer))
(cffi:defcenum color
- :RED
- :BLUE
- :GREEN)
+ :RED
+ :BLUE
+ :GREEN)
</PRE>
</DIV>
<P> The<I> SWIG wrapper</I> code refers to the special code which SWIG
%feature("export");
%feature("inline") lispsort_double;
-
%feature("intern_function", "my-lispify") lispsort_double;
+%feature("export", package="'some-other-package") lispsort_double;
+
%rename func123 renamed_cool_func;
+
%ignore "pointer_func";
%include "test.h"
%feature("intern_function", "my-lispify") lispsort_double;</I>, here we
are using an additional feature which allows us to use our lispify
function.</P>
-<P>The<I> export</I> feature allows us to export the symbols. The<I>
- inline</I> feature declaims the declared function as inline. The<I>
- rename</I> directive allows us to change the name(it is useful when
- generating C wrapper code for handling overloaded functions). The<I>
- ignore</I> directive ignores a certain declaration.</P>
+<P>The<I> export</I> feature allows us to export the symbols. If the<I>
+ package</I> argument is given, then the symbol will be exported to the
+ specified Lisp package. The<I> inline</I> feature declaims the declared
+ function as inline. The<I> rename</I> directive allows us to change the
+ name(it is useful when generating C wrapper code for handling
+ overloaded functions). The<I> ignore</I> directive ignores a certain
+ declaration.</P>
<P>There are several other things which are possible, to see some
example of usage of SWIG look at the Lispbuilder and wxCL projects. The
generated code with 'noswig-lisp' option is:</P>
(cl:export '#.(swig-lispify "x" 'constant))
(cffi:defcstruct #.(swig-lispify "bar" 'classname)
- (#.(swig-lispify "p" 'slotname) :short)
- (#.(swig-lispify "q" 'slotname) :short)
- (#.(swig-lispify "a" 'slotname) :char)
- (#.(swig-lispify "b" 'slotname) :char)
- (#.(swig-lispify "z" 'slotname) :pointer)
- (#.(swig-lispify "n" 'slotname) :pointer))
+ (#.(swig-lispify "p" 'slotname) :short)
+ (#.(swig-lispify "q" 'slotname) :short)
+ (#.(swig-lispify "a" 'slotname) :char)
+ (#.(swig-lispify "b" 'slotname) :char)
+ (#.(swig-lispify "z" 'slotname) :pointer)
+ (#.(swig-lispify "n" 'slotname) :pointer))
(cl:export '#.(swig-lispify "bar" 'classname))
(cl:export '#.(swig-lispify "my_struct" 'variable))
(cffi:defcstruct #.(swig-lispify "foo" 'classname)
- (#.(swig-lispify "a" 'slotname) :int)
- (#.(swig-lispify "b" 'slotname) :pointer))
+ (#.(swig-lispify "a" 'slotname) :int)
+ (#.(swig-lispify "b" 'slotname) :pointer))
(cl:export '#.(swig-lispify "foo" 'classname))
(n :int)
(array :pointer))
-(cl:export '#.(my-lispify "lispsort_double" 'function))
+(cl:export '#.(my-lispify "lispsort_double" 'function) 'some-other-package)
(cffi:defcenum #.(swig-lispify "color" 'enumname)
- #.(swig-lispify "RED" 'enumvalue :keyword)
- #.(swig-lispify "BLUE" 'enumvalue :keyword)
- #.(swig-lispify "GREEN" 'enumvalue :keyword))
+ #.(swig-lispify "RED" 'enumvalue :keyword)
+ #.(swig-lispify "BLUE" 'enumvalue :keyword)
+ #.(swig-lispify "GREEN" 'enumvalue :keyword))
(cl:export '#.(swig-lispify "color" 'enumname))
</PRE>
</DIV>
-<H3><A name="Lisp_nn6"></A>25.2.3 Generating CFFI bindings for C++ code</H3>
+<H3><A name="Lisp_nn6">27.2.3 Generating CFFI bindings for C++ code</A></H3>
<P>This feature to SWIG (for CFFI) is very new and still far from
complete. Pitch in with your patches, bug reports and feature requests
to improve it.</P>
<P> If you have any questions, suggestions, patches, etc., related to
CFFI module feel free to contact us on the SWIG mailing list, and also
please add a "[CFFI]" tag in the subject line.</P>
-<H3><A name="Lisp_nn7"></A>25.2.4 Inserting user code into generated
- files</H3>
+<H3><A name="Lisp_nn7">27.2.4 Inserting user code into generated files</A>
+</H3>
<P> It is often necessary to <A href="#SWIG_nn40">include user-defined
code</A> into the automatically generated interface files. For example,
when building a C++ interface, example_wrap.cxx will likely not compile
</UL>
<P> Note that the block <TT>%{ ... %}</TT> is effectively a shortcut for
<TT>%insert("header") %{ ... %}</TT>.</P>
-<H2><A name="Lisp_nn8"></A>25.3 CLISP</H2>
+<H2><A name="Lisp_nn8">27.3 CLISP</A></H2>
<P> <A href="http://clisp.cons.org">CLISP</A> is a feature-loaded
implementation of common lisp which is portable across most of the
operating system environments and hardware. CLISP includes an
modify them. The good thing is that you don't need to complex interface
file for the CLISP module. The CLISP module tries to produce code which
is both human readable and easily modifyable.</P>
-<H3><A name="Lisp_nn9"></A>25.3.1 Additional Commandline Options</H3>
+<H3><A name="Lisp_nn9">27.3.1 Additional Commandline Options</A></H3>
<P> The following table list the additional commandline options
available for the CLISP module. They can also be seen by using:</P>
<DIV class="code">
def-c-type will be used to generate
<BR> shortcuts according to the typedefs in the input.</TD></TR>
</TABLE>
-<H3><A name="Lisp_nn10"></A>25.3.2 Details on CLISP bindings</H3>
+<H3><A name="Lisp_nn10">27.3.2 Details on CLISP bindings</A></H3>
<P> As mentioned earlier the CLISP bindings generated by SWIG may need
some modifications. The clisp module creates a lisp file with the same
name as the module name. This lisp file contains a 'defpackage'
(ffi:def-call-out pointer_func
(:name "pointer_func")
(:arguments (ClosureFun (ffi:c-function (:arguments (arg0 (ffi:c-pointer NIL))
- (arg1 (ffi:c-pointer NIL))
- (arg2 (ffi:c-pointer NIL)))
- (:return-type NIL)))
- (y ffi:int))
+ (arg1 (ffi:c-pointer NIL))
+ (arg2 (ffi:c-pointer NIL)))
+ (:return-type NIL)))
+ (y ffi:int))
(:return-type ffi:int)
(:library +library-name+))
(ffi:def-call-out func123
(:name "func123")
(:arguments (x (ffi:c-pointer div_t))
- (z (ffi:c-ptr (ffi:c-array (ffi:c-ptr (ffi:c-ptr ffi:int)) 100)))
- (y (ffi:c-ptr (ffi:c-ptr (ffi:c-array ffi:int (1000 10))))))
+ (z (ffi:c-ptr (ffi:c-array (ffi:c-ptr (ffi:c-ptr ffi:int)) 100)))
+ (y (ffi:c-ptr (ffi:c-ptr (ffi:c-array ffi:int (1000 10))))))
(:return-type ffi:int)
(:library +library-name+))
(ffi:def-call-out lispsort_double
(:name "lispsort_double")
(:arguments (n ffi:int)
- (array (ffi:c-ptr DOUBLE-FLOAT)))
+ (array (ffi:c-ptr DOUBLE-FLOAT)))
(:return-type NIL)
(:library +library-name+))
(ffi:def-call-out test123
(:name "test")
(:arguments (x SINGLE-FLOAT)
- (y DOUBLE-FLOAT))
+ (y DOUBLE-FLOAT))
(:return-type NIL)
(:library +library-name+))
</PRE>
</DIV>
-<H2><A name="Lisp_nn11"></A>25.4 UFFI</H2>
+<H2><A name="Lisp_nn11">27.4 UFFI</A></H2>
<HR NOSHADE>
-<H1><A name="Lua"></A>26 SWIG and Lua</H1>
+<H1><A name="Lua">28 SWIG and Lua</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<LI><A href="#Lua_nn8">Modules</A></LI>
<LI><A href="#Lua_nn9">Functions</A></LI>
<LI><A href="#Lua_nn10">Global variables</A></LI>
-<LI><A href="#Lua_nn11">Constants and enums</A></LI>
+<LI><A href="#Lua_nn11">Constants and enums</A>
+<UL>
+<LI><A href="#Lua_nn13">Constants/enums and classes/structures</A></LI>
+</UL>
+</LI>
<LI><A href="#Lua_nn12">Pointers</A></LI>
-<LI><A href="#Lua_nn13">Structures</A></LI>
+<LI><A href="#Lua_structures">Structures</A></LI>
<LI><A href="#Lua_nn14">C++ classes</A></LI>
<LI><A href="#Lua_nn15">C++ inheritance</A></LI>
<LI><A href="#Lua_nn16">Pointers, references, values, and arrays</A></LI>
<LI><A href="#Lua_nn21">C++ templates</A></LI>
<LI><A href="#Lua_nn22">C++ Smart Pointers</A></LI>
<LI><A href="#Lua_nn23">C++ Exceptions</A></LI>
+<LI><A href="#Lua_namespaces">Namespaces</A>
+<UL>
+<LI><A href="#Lua_nn27">Compatibility Note</A></LI>
+<LI><A href="#Lua_nn29">Names</A></LI>
+<LI><A href="#Lua_nn30">Inheritance</A></LI>
+</UL>
+</LI>
</UL>
</LI>
<LI><A href="#Lua_nn24">Typemaps</A>
<UL>
<LI><A href="#Lua_nn25">What is a typemap?</A></LI>
<LI><A href="#Lua_nn26">Using typemaps</A></LI>
-<LI><A href="#Lua_nn27">Typemaps and arrays</A></LI>
-<LI><A href="#Lua_nn28">Typemaps and pointer-pointer functions</A></LI>
+<LI><A href="#Lua_typemap_arrays">Typemaps and arrays</A></LI>
+<LI><A href="#Lua_typemaps_ptr_ptr_functions">Typemaps and
+ pointer-pointer functions</A></LI>
</UL>
</LI>
-<LI><A href="#Lua_nn29">Writing typemaps</A>
+<LI><A href="#Lua_writing_typemaps">Writing typemaps</A>
<UL>
-<LI><A href="#Lua_nn30">Typemaps you can write</A></LI>
+<LI><A href="#Lua_typemaps_write">Typemaps you can write</A></LI>
<LI><A href="#Lua_nn31">SWIG's Lua-C API</A></LI>
</UL>
</LI>
regular Lua desktop version. More information on eLua can be found
here: <A href="http://www.eluaproject.net">http://www.eluaproject.net</A>
</P>
-<H2><A name="Lua_nn2"></A>26.1 Preliminaries</H2>
+<H2><A name="Lua_nn2">28.1 Preliminaries</A></H2>
<P> The current SWIG implementation is designed to work with Lua 5.0.x,
5.1.x and 5.2.x. It should work with later versions of Lua, but
certainly not with Lua 4.0 due to substantial API changes. It is
possible to either static link or dynamic link a Lua module into the
interpreter (normally Lua static links its libraries, as dynamic
- linking is not available on all platforms). SWIG also supports eLua and
- works with eLua 0.8. SWIG generated code for eLua has been tested on
- Stellaris ARM Cortex-M3 LM3S and Infineon TriCore.</P>
-<H2><A name="Lua_nn3"></A>26.2 Running SWIG</H2>
+ linking is not available on all platforms). SWIG also has support for
+ eLua starting from eLua 0.8. Due to substantial changes between SWIG
+ 2.x and SWIG 3.0 and unavailability of testing platform, eLua status
+ was downgraded to 'experimental'.</P>
+<H2><A name="Lua_nn3">28.2 Running SWIG</A></H2>
<P> Suppose that you defined a SWIG module such as the following:</P>
<DIV class="code">
<PRE>
is a catch though: Metatables are not generated with <TT>-eluac</TT>.
To access any value from eLua, one must directly call the wrapper
function associated with that value.</P>
-<H3><A name="Lua_commandline"></A>26.2.1 Additional command line options</H3>
+<H3><A name="Lua_commandline">28.2.1 Additional command line options</A></H3>
<P> The following table list the additional commandline options
available for the Lua module. They can also be seen by using:</P>
<DIV class="code">
for elua.</TD></TR>
<TR><TD>-nomoduleglobal</TD><TD>Do not register the module name as a
global variable but return the module table from calls to require.</TD></TR>
+<TR><TD>-no-old-metatable-bindings</TD><TD>Disable backward
+ compatibility: old-style binding names generations and a few other
+ things. Explanations are included in appropriate later sections.</TD></TR>
+<TR><TD>-squash-bases</TD><TD>Squashes symbols from all inheritance tree
+ of a given class into itself. Emulates pre-SWIG3.0 inheritance.
+ Insignificantly speeds things up, but increases memory consumption.</TD>
+</TR>
</TABLE>
-<H3><A name="Lua_nn4"></A>26.2.2 Compiling and Linking and Interpreter</H3>
+<H3><A name="Lua_nn4">28.2.2 Compiling and Linking and Interpreter</A></H3>
<P> Normally Lua is embedded into another program and will be statically
linked. An extremely simple stand-alone interpreter (<TT>min.c</TT>) is
given below:</P>
return 0;
}
L=lua_open();
- luaopen_base(L); // load basic libs (eg. print)
- luaopen_example(L); // load the wrapped module
+ luaopen_base(L); // load basic libs (eg. print)
+ luaopen_example(L); // load the wrapped module
if (luaL_loadfile(L,argv[1])==0) // load and run the file
lua_pcall(L,0,0,0);
else
<P> More information on building and configuring eLua can be found here:
<A href="http://www.eluaproject.net/doc/v0.8/en_building.html">
http://www.eluaproject.net/doc/v0.8/en_building.html</A></P>
-<H3><A name="Lua_nn5"></A>26.2.3 Compiling a dynamic module</H3>
+<H3><A name="Lua_nn5">28.2.3 Compiling a dynamic module</A></H3>
<P> Most, but not all platforms support the dynamic loading of modules
(Windows & Linux do). Refer to the Lua manual to determine if your
platform supports it. For compiling a dynamically loaded module the
<DIV class="shell">
<PRE>
$ swig -lua example.i -o example_wrap.c
-$ gcc -I/usr/include/lua -c example_wrap.c -o example_wrap.o
-$ gcc -c example.c -o example.o
+$ gcc -fPIC -I/usr/include/lua -c example_wrap.c -o example_wrap.o
+$ gcc -fPIC -c example.c -o example.o
$ gcc -shared -I/usr/include/lua -L/usr/lib/lua example_wrap.o example.o -o example.so
</PRE>
</DIV>
<BR> <TT> 'loadlib' not installed/supported</TT>
<BR> Is quite obvious (Go back and consult the Lua documents on how to
enable loadlib for your platform).</P>
-<H3><A name="Lua_nn6"></A>26.2.4 Using your module</H3>
+<H3><A name="Lua_nn6">28.2.4 Using your module</A></H3>
<P> Assuming all goes well, you will be able to this:</P>
<DIV class="targetlang">
<PRE>
>
</PRE>
</DIV>
-<H2><A name="Lua_nn7"></A>26.3 A tour of basic C/C++ wrapping</H2>
+<H2><A name="Lua_nn7">28.3 A tour of basic C/C++ wrapping</A></H2>
<P> By default, SWIG tries to build a very natural Lua interface to your
C/C++ code. This section briefly covers the essential aspects of this
wrapping.</P>
-<H3><A name="Lua_nn8"></A>26.3.1 Modules</H3>
+<H3><A name="Lua_nn8">28.3.1 Modules</A></H3>
<P> The SWIG module directive specifies the name of the Lua module. If
you specify `module example', then everything is wrapped into a Lua
table 'example' containing all the functions and variables. When
choosing a module name, make sure you don't use the same name as a
built-in Lua command or standard module name.</P>
-<H3><A name="Lua_nn9"></A>26.3.2 Functions</H3>
+<H3><A name="Lua_nn9">28.3.2 Functions</A></H3>
<P> Global functions are wrapped as new Lua built-in functions. For
example,</P>
<DIV class="code">
>
</PRE>
</DIV>
-<P> To avoid name collisions, SWIG create a Lua table which it keeps all
- the functions and global variables in. It is possible to copy the
- functions out of this and into the global environment with the
+<P> To avoid name collisions, SWIG create a Lua table which keeps all
+ the functions, constants, classes and global variables in. It is
+ possible to copy the functions, constants and classes (but not
+ variables) out of this and into the global environment with the
following code. This can easily overwrite existing functions, so this
- must be used with care.</P>
+ must be used with care. This option is considered deprecated and will
+ be removed in the near future.</P>
<DIV class="targetlang">
<PRE>
> for k,v in pairs(example) do _G[k]=v end
24
</PRE>
</DIV>
-<H3><A name="Lua_nn10"></A>26.3.3 Global variables</H3>
+<H3><A name="Lua_nn10">28.3.3 Global variables</A></H3>
<P> Global variables (which are linked to C code) are supported, and
appear to be just another variable in Lua. However the actual mechanism
is more complex. Given a global variable:</P>
<P> In general, functions of the form <TT>"variable_get()"</TT> and <TT>
"variable_set()"</TT> are automatically generated by SWIG for use with <TT>
-eluac</TT>.</P>
-<H3><A name="Lua_nn11"></A>26.3.4 Constants and enums</H3>
+<H3><A name="Lua_nn11">28.3.4 Constants and enums</A></H3>
<P> Because Lua doesn't really have the concept of constants, C/C++
constants are not really constant in Lua. They are actually just a copy
of the value into the Lua interpreter. Therefore they can be changed
Hello World
</PRE>
</DIV>
-<H3><A name="Lua_nn12"></A>26.3.5 Pointers</H3>
+<H4><A name="Lua_nn13">28.3.4.1 Constants/enums and classes/structures</A>
+</H4>
+<P> Enums are exported into a class table. For example, given some
+ enums:</P>
+<DIV class="code">
+<PRE>%module example
+enum Days { SUNDAY = 0, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY };
+struct Test {
+ enum { TEST1 = 10, TEST2 = 20 };
+#ifdef __cplusplus // There are no static members in C
+ static const int ICONST = 12;
+#endif
+};
+</PRE>
+</DIV>
+<P> There is a slight difference in behaviour wrapping C and C++ code
+ due to the different scoping rules of C and C++. The wrapped C++ code
+ is used as follows from Lua code:</P>
+<DIV class="targetlang">
+<PRE>
+> print(example.SUNDAY)
+0
+> print(example.Test.TEST1)
+10
+> print(example.Test.ICONST)
+12
+</PRE>
+</DIV>
+<P>Enums within a C struct are in the global namespace and are used as
+ follows from Lua</P>
+<DIV class="targetlang">
+<PRE>
+> print(example.SUNDAY)
+0
+> -- See the difference here
+> print(example.TEST1)
+10
+</PRE>
+</DIV>
+<P><B> Compatibility Note:</B> Versions of SWIG prior to SWIG-3.0.0 did
+ not generate the class table members above. There is no change in the C
+ wrappers, but the following code was the only way to access these
+ constants/enums when wrapping C++ member constants:</P>
+<DIV class="targetlang">
+<PRE>
+> print(example.Test_TEST1)
+10
+> print(example.Test_ICONST)
+12
+</PRE>
+</DIV>
+<P> The old-style bindings are still generated in addition to the new
+ ones. If the <TT>-no-old-metatable-bindings</TT> option is used, then
+ these old-style bindings are not generated.</P>
+<P> It is worth mentioning, that <TT>example.Test.TEST1</TT> and <TT>
+example.Test_TEST1</TT> are different entities and changing one does not
+ change the other. Given the fact that these are constantes and they are
+ not supposed to be changed, it is up to you to avoid such issues.</P>
+<H3><A name="Lua_nn12">28.3.5 Pointers</A></H3>
<P> C/C++ pointers are fully supported by SWIG. Furthermore, SWIG has no
problem working with incomplete type information. Given a wrapping of
the <file.h> interface:</P>
nil
</PRE>
</DIV>
-<H3><A name="Lua_nn13"></A>26.3.6 Structures</H3>
+<H3><A name="Lua_structures">28.3.6 Structures</A></H3>
<P> If you wrap a C structure, it is also mapped to a Lua userdata. By
adding a metatable to the userdata, this provides a very natural
interface. For example,</P>
</DIV>
<P> Similar access is provided for unions and the data members of C++
classes.
-<BR> C structures are created using a function <TT>new_Point()</TT>, but
- for C++ classes are created using just the name <TT>Point()</TT>.</P>
+<BR> C structures can be created using a function <TT>new_Point()</TT>,
+ and both C structures and C++ classes can be created using just the
+ name <TT>Point()</TT>.</P>
<P> If you print out the value of p in the above example, you will see
something like this:</P>
<DIV class="targetlang">
"free_struct()"</TT> are automatically generated by SWIG for each
structure defined in C. (Please note: This doesn't apply for modules
generated with the <TT>-elua</TT> option)</P>
-<H3><A name="Lua_nn14"></A>26.3.7 C++ classes</H3>
+<H3><A name="Lua_nn14">28.3.7 C++ classes</A></H3>
<P> C++ classes are wrapped by a Lua userdata as well. For example, if
you have this class,</P>
<DIV class="code">
};
</PRE>
</DIV>
-<P> In Lua, the static members can be accessed as follows:</P>
+<P> In Lua, C++ static members can be accessed as follows:</P>
<DIV class="code">
<PRE>
-> example.Spam_foo() -- calling Spam::foo()
-> a=example.Spam_bar -- reading Spam::bar
-> example.Spam_bar=b -- writing to Spam::bar
+> example.Spam.foo() -- calling Spam::foo()
+> a=example.Spam.bar -- reading Spam::bar
+> example.Spam.bar=b -- writing to Spam::bar
</PRE>
</DIV>
<P> It is not (currently) possible to access static members of an
-- does NOT work
</PRE>
</DIV>
-<H3><A name="Lua_nn15"></A>26.3.8 C++ inheritance</H3>
+<P><B> Compatibility Note:</B> In versions prior to SWIG-3.0.0 only the
+ following names would work:</P>
+<DIV class="code">
+<PRE>
+> example.Spam_foo() -- calling Spam::foo()
+> a=example.Spam_bar -- reading Spam::bar
+> example.Spam_bar=b -- writing to Spam::bar
+</PRE>
+</DIV>
+<P> Both style names are generated by default now. However, if the <TT>
+-no-old-metatable-bindings</TT> option is used, then the backward
+ compatible names are not generated in addition to ordinary ones.</P>
+<H3><A name="Lua_nn15">28.3.8 C++ inheritance</A></H3>
<P> SWIG is fully aware of issues related to C++ inheritance. Therefore,
if you have classes like this</P>
<DIV class="code">
<P> then the function <TT>spam()</TT> accepts a Foo pointer or a pointer
to any class derived from Foo.</P>
<P> It is safe to use multiple inheritance with SWIG.</P>
-<H3><A name="Lua_nn16"></A>26.3.9 Pointers, references, values, and
- arrays</H3>
+<H3><A name="Lua_nn16">28.3.9 Pointers, references, values, and arrays</A>
+</H3>
<P> In C++, there are many different ways a function might receive and
manipulate objects. For example:</P>
<DIV class="code">
release this memory when the return value is garbage collected). The
other two are pointers which are assumed to be managed by the C code
and so will not be garbage collected.</P>
-<H3><A name="Lua_nn17"></A>26.3.10 C++ overloaded functions</H3>
+<H3><A name="Lua_nn17">28.3.10 C++ overloaded functions</A></H3>
<P> C++ overloaded functions, methods, and constructors are mostly
supported by SWIG. For example, if you have two functions like this:</P>
<DIV class="code">
</PRE>
</DIV>
<P> or</P>
-<DIV CLASS="CODE">
-<PRE>VOID FOO(bAR *B);
+<DIV class="code">
+<PRE>void foo(Bar *b);
void foo(Bar &b);
</PRE>
</DIV>
<P> Dealing with the Lua coercion mechanism, the priority is roughly
(integers, floats, strings, userdata). But it is better to rename the
functions rather than rely upon the ordering.</P>
-<H3><A name="Lua_nn18"></A>26.3.11 C++ operators</H3>
+<H3><A name="Lua_nn18">28.3.11 C++ operators</A></H3>
<P> Certain C++ overloaded operators can be handled automatically by
SWIG. For example, consider a class like this:</P>
<DIV class="code">
<LI><TT>__sub__</TT> operator-</LI>
<LI><TT>__mul__</TT> operator *</LI>
<LI><TT>__div__</TT> operator/</LI>
-<LI><TT>__neg__</TT> unary minus</LI>
+<LI><TT>__unm__</TT> unary minus</LI>
<LI><TT>__call__</TT> operator<TT>()</TT> (often used in functor
classes)</LI>
<LI><TT>__pow__</TT> the exponential fn (no C++ equivalent, Lua uses <TT>
^</TT>)</LI>
-<LI><TT>__concat__</TT> the concatenation operator (SWIG maps C++'s <TT>
-~</TT> to Lua's <TT>..</TT>)</LI>
+<LI><TT>__concat__</TT> the concatenation operator (Lua's <TT>..</TT>)</LI>
<LI><TT>__eq__</TT> operator<TT>==</TT></LI>
<LI><TT>__lt__</TT> operator<TT><</TT></LI>
<LI><TT>__le__</TT> operator<TT><=</TT></LI>
};
</PRE>
</DIV>
-<H3><A name="Lua_nn19"></A>26.3.12 Class extension with %extend</H3>
+<P> C++ operators are mapped to Lua predefined metafunctions. Class
+ inherits from its bases the following list of metafunctions ( thus
+ inheriting the folloging operators and pseudo-operators):</P>
+<UL>
+<LI><TT>__add__</TT></LI>
+<LI><TT>__sub__</TT></LI>
+<LI><TT>__mul__</TT></LI>
+<LI><TT>__div__</TT></LI>
+<LI><TT>__unm__</TT></LI>
+<LI><TT>__mod__</TT></LI>
+<LI><TT>__call__</TT></LI>
+<LI><TT>__pow__</TT></LI>
+<LI><TT>__concat__</TT></LI>
+<LI><TT>__eq__</TT></LI>
+<LI><TT>__lt__</TT></LI>
+<LI><TT>__le__</TT></LI>
+<LI><TT>__len__</TT></LI>
+<LI><TT>__getitem__</TT></LI>
+<LI><TT>__setitem__</TT></LI>
+<LI><TT>__tostring</TT> used internally by Lua for tostring() function.
+ __str__ is mapped to this function</LI>
+</UL>
+<P>No other lua metafunction is inherited. For example, __gc is not
+ inherited and must be redefined in every class. <TT>__tostring</TT> is
+ subject to a special handling. If absent in class and in class bases, a
+ default one will be provided by SWIG.</P>
+<H3><A name="Lua_nn19">28.3.12 Class extension with %extend</A></H3>
<P> One of the more interesting features of SWIG is that it can extend
structures and classes with new methods. In the previous section, the
Complex class would have benefited greatly from an __str__() method as
return tmp;
}
bool operator==(const Complex& c)
- { return ($self->re()==c.re() && $self->im()==c.im();}
+ { return ($self->re()==c.re() && $self->im()==c.im());}
};
</PRE>
</DIV>
has to use the '$self' instead of 'this', and that you cannot access
protected/private members of the code (as you are not officially part
of the class).</P>
-<H3><A name="Lua_nn20"></A>26.3.13 Using %newobject to release memory</H3>
+<H3><A name="Lua_nn20">28.3.13 Using %newobject to release memory</A></H3>
<P> If you have a function that allocates memory like this,</P>
<DIV class="code">
<PRE>char *foo() {
</PRE>
</DIV>
<P> This will release the allocated memory.</P>
-<H3><A name="Lua_nn21"></A>26.3.14 C++ templates</H3>
+<H3><A name="Lua_nn21">28.3.14 C++ templates</A></H3>
<P> C++ templates don't present a huge problem for SWIG. However, in
order to create wrappers, you have to tell SWIG to create wrappers for
a particular template instantiation. To do this, you use the template
<P> Obviously, there is more to template wrapping than shown in this
example. More details can be found in the SWIG and C++ chapter. Some
more complicated examples will appear later.</P>
-<H3><A name="Lua_nn22"></A>26.3.15 C++ Smart Pointers</H3>
+<H3><A name="Lua_nn22">28.3.15 C++ Smart Pointers</A></H3>
<P> In certain C++ programs, it is common to use classes that have been
wrapped by so-called "smart pointers." Generally, this involves the use
of a template class that implements operator->() like this:</P>
> f = p:__deref__() -- Returns underlying Foo *
</PRE>
</DIV>
-<H3><A name="Lua_nn23"></A>26.3.16 C++ Exceptions</H3>
+<H3><A name="Lua_nn23">28.3.16 C++ Exceptions</A></H3>
<P> Lua does not natively support exceptions, but it has errors which
are similar. When a Lua function terminates with an error it returns
one value back to the caller. SWIG automatically maps any basic type
Exception handling with %catches</A>" section and the "<A href="#Customization_exception">
Exception handling with %exception</A>" section, for more details on how
to add exception specification to functions or globally (respectively).</P>
-<H2><A name="Lua_nn24"></A>26.4 Typemaps</H2>
+<H3><A name="Lua_namespaces">28.3.17 Namespaces</A></H3>
+<P> Since SWIG-3.0.0 C++ namespaces are supported via the %nspace
+ feature.</P>
+<P> Namespaces are mapped into Lua tables. Each of those tables contains
+ names that were defined within appropriate namespace. Namespaces
+ structure (a.k.a nested namespaces) is preserved. Consider the
+ following C++ code:</P>
+<DIV class="code">
+<PRE>%module example
+%nspace MyWorld::Nested::Dweller;
+%nspace MyWorld::World;
+
+int module_function() { return 7; }
+int module_variable = 9;
+
+namespace MyWorld {
+ class World {
+ public:
+ World() : world_max_count(9) {}
+ int create_world() { return 17; }
+ const int world_max_count; // = 9
+ };
+ namespace Nested {
+ class Dweller {
+ public:
+ enum Gender { MALE = 0, FEMALE = 1 };
+ static int count() { return 19; }
+ };
+ }
+}
+</PRE>
+</DIV>
+<P> Now, from Lua usage is as follows:</P>
+<DIV class="targetlang">
+<PRE>
+> print(example.module_function())
+7
+> print(example.module_variable)
+9
+> print(example.MyWorld.World():create_world())
+17
+> print(example.MyWorld.World.world_max_count)
+9
+> print(example.MyWorld.Nested.Dweller.MALE)
+0
+> print(example.MyWorld.Nested.Dweller.count())
+19
+>
+</PRE>
+</DIV>
+<H4><A name="Lua_nn27">28.3.17.1 Compatibility Note</A></H4>
+<P> If SWIG is running in a backwards compatible way, i.e. without the <TT>
+-no-old-metatable-bindings</TT> option, then additional old-style names
+ are generated (notice the underscore):</P>
+<DIV class="targetlang">
+<PRE>
+9
+> print(example.MyWorld.Nested.Dweller_MALE)
+0
+> print(example.MyWorld.Nested.Dweller_count())
+11
+>
+</PRE>
+</DIV>
+<H4><A name="Lua_nn29">28.3.17.2 Names</A></H4>
+<P> If SWIG is launched without <TT>-no-old-metatable-bindings</TT>
+ option, then it enters backward-compatible mode. While in this mode, it
+ tries to generate additional names for static functions, class static
+ constants and class enums. Those names are in a form <TT>
+$classname_$symbolname</TT> and are added to the scope surrounding the
+ class. If %nspace is enabled, then class namespace is taken as scope.
+ If there is no namespace, or %nspace is disabled, then module is
+ considered a class namespace.</P>
+<P> Consider the following C++ code</P>
+<DIV class="code">
+<PRE>%module example
+%nspace MyWorld::Test;
+namespace MyWorld {
+class Test {
+ public:
+ enum { TEST1 = 10, TEST2 }
+ static const int ICONST = 12;
+};
+class Test2 {
+ public:
+ enum { TEST3 = 20, TEST4 }
+ static const int ICONST2 = 23;
+}
+</PRE>
+</DIV>
+<P> When in backward compatible mode, in addition to the usual names,
+ the following ones will be generated (notice the underscore):</P>
+<DIV class="targetlang">
+<PRE>
+9
+> print(example.MyWorld.Test_TEST1) -- Test has %nspace enabled
+10
+> print(example.MyWorld.Test_ICONST) -- Test has %nspace enabled
+12
+> print(example.Test2_TEST3) -- Test2 doesn't have %nspace enabled
+20
+> print(example.Test2_ICONST2) -- Test2 doesn't have %nspace enabled
+23
+>
+</PRE>
+</DIV>
+<P> There is a slight difference with enums when in C mode. As per C
+ standard, enums from C structures are exported to surrounding scope
+ without any prefixing. Pretending that Test2 is a struct, not class,
+ that would be:</P>
+<DIV class="targetlang">
+<PRE>
+> print(example.TEST3) -- NOT Test2_TEST3
+20
+>
+</PRE>
+</DIV>
+<H4><A name="Lua_nn30">28.3.17.3 Inheritance</A></H4>
+<P> The internal organization of inheritance has changed. Consider the
+ following C++ code:</P>
+<DIV class="code">
+<PRE>%module example
+class Base {
+ public:
+ int base_func()
+};
+class Derived : public Base {
+ public:
+ int derived_func()
+}
+</PRE>
+</DIV>
+<P>Lets assume for a moment that class member functions are stored in <TT>
+.fn</TT> table. Previously, when classes were exported to Lua during
+ module initialization, for every derived class all service tables <TT>
+ST(i.e. ".fn")</TT> were squashed and added to corresponding derived
+ class <TT>ST</TT>: Everything from <TT>.fn</TT> table of class Base was
+ copied to <TT>.fn</TT> table of class Derived and so on. This was a
+ recursive procedure, so in the end the whole inheritance tree of
+ derived class was squashed into derived class.</P>
+<P> That means that any changes done to class Base after module
+ initialization wouldn't affect class Derived:</P>
+<DIV class="targetlang">
+<PRE>
+base = example.Base()
+der = example.Derived()
+> print(base.base_func)
+function: 0x1367940
+> getmetatable(base)[".fn"].new_func = function (x) return x -- Adding new function to class Base (to class, not to an instance!)
+> print(base.new_func) -- Checking this function
+function
+> print(der.new_func) -- Wouldn't work. Derived doesn't check Base any more.
+nil
+>
+</PRE>
+</DIV>
+<P> This behaviour was changed. Now unless -squash-bases option is
+ provided, Derived store a list of it's bases and if some symbol is not
+ found in it's own service tables then its bases are searched for it.
+ Option -squash-bases will effectively return old behaviour.<DIV class="targetlang">
+<PRE>
+> print(der.new_func) -- Now it works
+function
+>
+</PRE>
+</DIV></P>
+<H2><A name="Lua_nn24">28.4 Typemaps</A></H2>
<P>This section explains what typemaps are and how to use them. The
default wrapping behaviour of SWIG is enough in most cases. However
sometimes SWIG may need a little additional assistance to know which
typemap to apply to provide the best wrapping. This section will be
explaining how to use typemaps to best effect</P>
-<H3><A name="Lua_nn25"></A>26.4.1 What is a typemap?</H3>
+<H3><A name="Lua_nn25">28.4.1 What is a typemap?</A></H3>
<P>A typemap is nothing more than a code generation rule that is
attached to a specific C datatype. For example, to convert integers
from Lua to C, you might define a typemap like this:</P>
<PRE>%module example
%typemap(in) int {
- $1 = (int) lua_tonumber(L,$input);
- printf("Received an integer : %d\n",$1);
+ $1 = (int) lua_tonumber(L,$input);
+ printf("Received an integer : %d\n",$1);
}
%inline %{
extern int fact(int n);
720
</PRE>
</DIV>
-<H3><A name="Lua_nn26"></A>26.4.2 Using typemaps</H3>
+<H3><A name="Lua_nn26">28.4.2 Using typemaps</A></H3>
<P>There are many ready written typemaps built into SWIG for all common
types (int, float, short, long, char*, enum and more), which SWIG uses
automatically, with no effort required on your part.</P>
<P>Note: C++ references must be handled exactly the same way. However
SWIG will automatically wrap a <TT>const int&</TT> as an input
parameter (since that it obviously input).</P>
-<H3><A name="Lua_nn27"></A>26.4.3 Typemaps and arrays</H3>
+<H3><A name="Lua_typemap_arrays">28.4.3 Typemaps and arrays</A></H3>
<P>Arrays present a challenge for SWIG, because like pointers SWIG does
not know whether these are input or output values, nor does SWIG have
any indication of how large an array should be. However with the proper
accordingly. Take note of this behaviour if you have a C function which
returns indexes.</P>
<P>Note: SWIG also can support arrays of pointers in a similar manner.</P>
-<H3><A name="Lua_nn28"></A>26.4.4 Typemaps and pointer-pointer functions</H3>
+<H3><A name="Lua_typemaps_ptr_ptr_functions">28.4.4 Typemaps and
+ pointer-pointer functions</A></H3>
<P>Several C++ libraries use a pointer-pointer functions to create its
objects. These functions require a pointer to a pointer which is then
filled with the pointer to the new object. Microsoft's COM and DirectX
ptr=nil -- the iMath* will be GC'ed as normal
</PRE>
</DIV>
-<H2><A name="Lua_nn29"></A>26.5 Writing typemaps</H2>
+<H2><A name="Lua_writing_typemaps">28.5 Writing typemaps</A></H2>
<P>This section describes how you can modify SWIG's default wrapping
behavior for various C/C++ datatypes using the <TT>%typemap</TT>
directive. This is an advanced topic that assumes familiarity with the
You should not attempt to write your own typemaps until you have read
and can understand both of these files (they may well also give you an
idea to base your work on).</P>
-<H3><A name="Lua_nn30"></A>26.5.1 Typemaps you can write</H3>
+<H3><A name="Lua_typemaps_write">28.5.1 Typemaps you can write</A></H3>
<P>There are many different types of typemap that can be written, the
full list can be found in the "<A href="#Typemaps">Typemaps</A>"
chapter. However the following are the most commonly used ones.</P>
function should be called (the syntax for the typecheck is different
from the typemap, see typemaps for details).</LI>
</UL>
-<H3><A name="Lua_nn31"></A>26.5.2 SWIG's Lua-C API</H3>
+<H3><A name="Lua_nn31">28.5.2 SWIG's Lua-C API</A></H3>
<P>This section explains the SWIG specific Lua-C API. It does not cover
the main Lua-C api, as this is well documented and not worth covering.</P>
<P><TT>int SWIG_ConvertPtr(lua_State* L,int index,void**
type);</TT></P>
<DIV class="indent"> Similar to SWIG_fail_arg, except that it will
display the swig_type_info information instead.</DIV>
-<H2><A name="Lua_nn32"></A>26.6 Customization of your Bindings</H2>
+<H2><A name="Lua_nn32">28.6 Customization of your Bindings</A></H2>
<P> This section covers adding of some small extra bits to your module
to add the last finishing touches.</P>
-<H3><A name="Lua_nn33"></A>26.6.1 Writing your own custom wrappers</H3>
+<H3><A name="Lua_nn33">28.6.1 Writing your own custom wrappers</A></H3>
<P> Sometimes, it may be necessary to add your own special functions,
which bypass the normal SWIG wrapper method, and just use the native
Lua API calls. These 'native' functions allow direct adding of your own
to be added into the module under the name '<TT>my_func</TT>'. SWIG
will not add any wrapper for this function, beyond adding it into the
function table. How you write your code is entirely up to you.</P>
-<H3><A name="Lua_nn34"></A>26.6.2 Adding additional Lua code</H3>
+<H3><A name="Lua_nn34">28.6.2 Adding additional Lua code</A></H3>
<P> As well as adding additional C/C++ code, it's also possible to add
your own Lua code to the module as well. This code is executed once all
other initialisation, including the %init code has been called.</P>
<P> Good uses for this feature is adding of new code, or writing helper
functions to simplify some of the code. See Examples/lua/arrays for an
example of this code.</P>
-<H2><A name="Lua_nn35"></A>26.7 Details on the Lua binding</H2>
+<H2><A name="Lua_nn35">28.7 Details on the Lua binding</A></H2>
<P> In the previous section, a high-level view of Lua wrapping was
presented. Obviously a lot of stuff happens behind the scenes to make
this happen. This section will explain some of the low-level details on
stop reading here. This is going into the guts of the code and how it
works. It's mainly for people who need to know what's going on within
the code.</I></P>
-<H3><A name="Lua_nn36"></A>26.7.1 Binding global data into the module.</H3>
+<H3><A name="Lua_nn36">28.7.1 Binding global data into the module.</A></H3>
<P> Assuming that you had some global data that you wanted to share
between C and Lua. How does SWIG do it?</P>
<DIV class="code">
'Foo_get()'. Similarly for the code '<TT>example.Foo=10</TT>', the
interpreter will check the table, then call the __newindex which will
then check the '.set' table and call the C function 'Foo_set(10)'.</P>
-<H3><A name="Lua_nn37"></A>26.7.2 Userdata and Metatables</H3>
+<H3><A name="Lua_nn37">28.7.2 Userdata and Metatables</A></H3>
<P> As mentioned earlier, classes and structures, are all held as
pointer, using the Lua 'userdata' structure. This structure is actually
a pointer to a C structure 'swig_lua_userdata', which contains the
The current implementation is a bit rough as it will add any member
function beginning with '__' into the metatable too, assuming its an
operator overload.</P>
-<H3><A name="Lua_nn38"></A>26.7.3 Memory management</H3>
+<H3><A name="Lua_nn38">28.7.3 Memory management</A></H3>
<P> Lua is very helpful with the memory management. The
'swig_lua_userdata' is fully managed by the interpreter itself. This
means that neither the C code nor the Lua code can damage it. Once a
the data (unlike most other scripting languages, Lua does not permit
access to the data from within the interpreter).</P>
<HR NOSHADE>
-<H1><A name="Modula3"></A>27 SWIG and Modula-3</H1>
+<H1><A name="Modula3">29 SWIG and Modula-3</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
</UL>
</DIV>
<!-- INDEX -->
-<P> This chapter describes SWIG's support
of <A href="http://modula3.org/">
+<P> This chapter describes SWIG's support
for <A href="http://modula3.org/">
Modula-3</A>. You should be familiar with the <A href="#SWIG">basics</A>
of SWIG, especially <A href="#Typemaps">typemaps</A>.</P>
-<H2><A name="Modula3_modula3_overview"></A>27.1 Overview</H2>
+<H2><A name="Modula3_modula3_overview">29.1 Overview</A></H2>
<P> Modula-3 is a compiled language in the tradition of Niklaus Wirth's
Modula 2, which is in turn a successor to Pascal.</P>
<P> SWIG's Modula-3 support is currently very basic and highly
<LI> <A href="http://www.elegosoft.com/cgi-bin/cvsweb.cgi/cm3/m3-libs/fftw/">
FFTW</A></LI>
</OL>
-<H3><A name="Modula3_motivation"></A>27.1.1 Motivation</H3>
+<H3><A name="Modula3_motivation">29.1.1 Motivation</A></H3>
<P> Although it is possible to write Modula-3 code that performs as well
as C/C++ most existing libraries are not written in Modula-3 but in C
or C++, and even libraries in other languages may provide C header
typemaps you can pass <TT>TEXT</TT>s or open arrays, and convert error
return codes into exceptions.</P>
<P> If the library API is ill designed writing appropriate typemaps can
- be still time-consuming. E.g. C programmers are very creative to
+ still be time-consuming. E.g. C programmers are very creative to
work-around missing data types like (real) enumerations and sets. You
should turn such work-arounds back to the Modula-3 way otherwise you
lose static safety and consistency.</P>
<P> Without SWIG you would probably never consider trying to call C++
libraries from Modula-3, but with SWIG this is becomes feasible. SWIG
can generate C wrappers to C++ functions and object methods that may
- throw exceptions, and then wrap these C wrappers for Module-3. To make
+ throw exceptions, and then wrap these C wrappers for Modula-3. To make
it complete you can then hide the C interface with Modula-3 classes and
exceptions.</P>
<P> SWIG allows you to call C and C++ libraries from Modula-3 (even with
call back functions), but it doesn't allow you to easily integrate a
- Module-3 module into a C/C++ project.</P>
-<H2><A name="Modula3_conception"></A>27.2 Conception</H2>
-<H3><A name="Modula3_cinterface"></A>27.2.1 Interfaces to C libraries</H3>
+ Modula-3 module into a C/C++ project.</P>
+<H2><A name="Modula3_conception">29.2 Conception</A></H2>
+<H3><A name="Modula3_cinterface">29.2.1 Interfaces to C libraries</A></H3>
<P> Modula-3 has integrated support for calling C functions. This is
also extensively used by the standard Modula-3 libraries to call OS
functions. The Modula-3 part of SWIG and the corresponding SWIG library
(different SWIG interfaces can share common data) per module.
Identifiers belonging to a different module may ignored (<TT>%ignore</TT>
) and the principal type must be renamed (<TT>%typemap</TT>).</P>
-<H3><A name="Modula3_cppinterface"></A>27.2.2 Interfaces to C++
- libraries</H3>
+<H3><A name="Modula3_cppinterface">29.2.2 Interfaces to C++ libraries</A>
+</H3>
<P> Interfaces to C++ files are much more complicated and there are some
more design decisions that are not made, yet. Modula-3 has no support
for C++ functions but C++ compilers should support generating C++
</UL>
<P> Be warned: There is no C++ library I wrote a SWIG interface for, so
I'm not sure if this is possible or sensible, yet.</P>
-<H2><A name="Modula3_preliminaries"></A>27.3 Preliminaries</H2>
-<H3><A name="Modula3_compilers"></A>27.3.1 Compilers</H3>
+<H2><A name="Modula3_preliminaries">29.3 Preliminaries</A></H2>
+<H3><A name="Modula3_compilers">29.3.1 Compilers</A></H3>
<P> There are different Modula-3 compilers around: cm3, pm3, ezm3,
Klagenfurth Modula-3, Cambridge Modula-3. SWIG itself does not contain
compiler specific code but the modula3.swg library file may do so. For
testing examples I use Critical Mass cm3.</P>
-<H3><A name="Modula3_commandline"></A>27.3.2 Additional Commandline
- Options</H3>
+<H3><A name="Modula3_commandline">29.3.2 Additional Commandline Options</A>
+</H3>
<P> There are some experimental command line options that prevent SWIG
from generating interface files. Instead files are emitted that may
assist you when writing SWIG interface files.</P>
of interfaces and wrappers. Instead generate templates for some basic
typemaps.</TD></TR>
</TABLE>
-<H2><A name="Modula3_typemaps"></A>27.4 Modula-3 typemaps</H2>
-<H3><A name="Modula3_inoutparam"></A>27.4.1 Inputs and outputs</H3>
+<H2><A name="Modula3_typemaps">29.4 Modula-3 typemaps</A></H2>
+<H3><A name="Modula3_inoutparam">29.4.1 Inputs and outputs</A></H3>
<P> Each C procedure has a bunch of inputs and outputs. Inputs are
passed as function arguments, outputs are updated referential arguments
and the function value.</P>
step should never be skipped, SWIG will put it in the <TT>FINALLY</TT>
branch of a <TT>TRY .. FINALLY</TT> structure.</TD></TR>
</TABLE>
-<H3><A name="Modula3_ordinals"></A>27.4.2 Subranges, Enumerations, Sets</H3>
+<H3><A name="Modula3_ordinals">29.4.2 Subranges, Enumerations, Sets</A></H3>
<P> Subranges, enumerations, and sets are machine oriented types that
make Modula very strong and expressive compared with the type systems
of many other languages.</P>
satisfying. So the best what you can currently do is to rewrite
constant definitions manually. Though this is a tedious work that I'd
like to automate.</P>
-<H3><A name="Modula3_class"></A>27.4.3 Objects</H3>
+<H3><A name="Modula3_class">29.4.3 Objects</A></H3>
<P> Declarations of C++ classes are mapped to <TT>OBJECT</TT> types
while it is tried to retain the access hierarchy "public - protected -
private" using partial revelation. Though the example in
Examples/modula3/class/example.i is not really useful, yet.</P>
-<H3><A name="Modula3_imports"></A>27.4.4 Imports</H3>
+<H3><A name="Modula3_imports">29.4.4 Imports</A></H3>
<P> Pieces of Modula-3 code provided by typemaps may contain identifiers
from foreign modules. If the typemap <TT>m3wrapinconv</TT> for <TT>blah
*</TT> contains code using the function <TT>M3toC.SharedTtoS</TT> you
%}
</PRE>
</DIV>
-<H3><A name="Modula3_exceptions"></A>27.4.5 Exceptions</H3>
+<H3><A name="Modula3_exceptions">29.4.5 Exceptions</A></H3>
<P> Modula-3 provides another possibility of an output of a function:
exceptions.</P>
<P> Any piece of Modula-3 code that SWIG inserts due to a typemap can
*</TT> contains code that may raise the exceptions <TT>OSError.E</TT>
you should declare <TT>%typemap("m3wrapinconv:throws") blah *
%{OSError.E%}</TT>.</P>
-<H3><A name="Modula3_typemap_example"></A>27.4.6 Example</H3>
+<H3><A name="Modula3_typemap_example">29.4.6 Example</A></H3>
<P> The generation of wrappers in Modula-3 needs very fine control to
take advantage of the language features. Here is an example of a
generated wrapper where almost everything is generated by a typemap:</P>
END Name;
</PRE>
</DIV>
-<H2><A name="Modula3_hints"></A>27.5 More hints to the generator</H2>
-<H3><A name="Modula3_features"></A>27.5.1 Features</H3>
+<H2><A name="Modula3_hints">29.5 More hints to the generator</A></H2>
+<H3><A name="Modula3_features">29.5.1 Features</A></H3>
<TABLE border summary="Modula-3 features">
<TR><TH>Feature</TH><TH>Example</TH><TH>Description</TH></TR>
<TR><TD>multiretval</TD><TD><TT>%m3multiretval get_box;</TT> or <TT>
option</A>. In future it may be generalized to other kind of values such
as strings.</TD></TR>
</TABLE>
-<H3><A name="Modula3_pragmas"></A>27.5.2 Pragmas</H3>
+<H3><A name="Modula3_pragmas">29.5.2 Pragmas</A></H3>
<TABLE border summary="Modula-3 pragmas">
<TR><TH>Pragma</TH><TH>Example</TH><TH>Description</TH></TR>
<TR><TD>unsafe</TD><TD><TT>%pragma(modula3) unsafe="true";</TT></TD><TD>
Specifies the library name for the wrapper library to be created. It
should be distinct from the name of the library to be wrapped.</TD></TR>
</TABLE>
-<H2><A name="Modula3_remarks"></A>27.6 Remarks</H2>
+<H2><A name="Modula3_remarks">29.6 Remarks</A></H2>
<UL>
<LI> The Modula-3 part of SWIG doesn't try to generate nicely formatted
code. If you need to read the generated code, use <TT>m3pp</TT> to
postprocess the Modula files.</LI>
</UL>
<HR NOSHADE>
-
-<!-- Hand-written HTML -->
-<H1><A name="Mzscheme"></A>28 SWIG and MzScheme/Racket</H1>
+<H1><A name="Mzscheme">30 SWIG and MzScheme/Racket</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<!-- INDEX -->
<P> This section contains information on SWIG's support of Racket,
formally known as MzScheme.</P>
-<H2><A name="MzScheme_nn2"></A>28.1 Creating native structures</H2>
+<H2><A name="MzScheme_nn2">30.1 Creating native structures</A></H2>
<P> Example interface file:</P>
<DIV class="code">
<PRE>
<P> Then in scheme, you can use regular struct access procedures like</P>
<DIV class="code">
<PRE>
- ; suppose a function created a struct foo as
- ; (define foo (make-diag-cntrs (#x1 #x2 #x3) (make-inspector))
- ; Then you can do
- (format "0x~x" (diag-cntrs-field1 foo))
- (format "0x~x" (diag-cntrs-field2 foo))
- ;etc...
+ ; suppose a function created a struct foo as
+ ; (define foo (make-diag-cntrs (#x1 #x2 #x3) (make-inspector))
+ ; Then you can do
+ (format "0x~x" (diag-cntrs-field1 foo))
+ (format "0x~x" (diag-cntrs-field2 foo))
+ ;etc...
</PRE>
</DIV>
-<H2><A name="MzScheme_simple"></A>28.2 Simple example</H2>
+<H2><A name="MzScheme_simple">30.2 Simple example</A></H2>
<P> A few examples are available in the Examples/mzscheme directory. The
code and log of a session using SWIG below should help getting started.</P>
<P> C header file:</P>
better performance, but work is still required for SWIG to emit code
which is compatible with it.</LI>
</UL>
-<H2><A name="MzScheme_external_docs"></A>28.3 External documentation</H2>
+<H2><A name="MzScheme_external_docs">30.3 External documentation</A></H2>
<P> See the <A href="http://docs.racket-lang.org/inside/index.html">C
API</A> for more description of using the mechanism for adding
extensions. The main documentation is <A href="http://docs.racket-lang.org/">
<P> Tip: mzc's --vv option is very useful for debugging the inevitable
library problems you'll encounter.</P>
<HR NOSHADE>
- <A name="n1"></A>
-<H1><A name="Ocaml"></A>29 SWIG and Ocaml</H1>
+<H1><A name="Ocaml">31 SWIG and Ocaml</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<LI><A href="#Ocaml_nn24">Overriding Methods in Ocaml</A></LI>
<LI><A href="#Ocaml_nn25">Director Usage Example</A></LI>
<LI><A href="#Ocaml_nn26">Creating director objects</A></LI>
-<LI><A href="#Ocaml_nn27">Typemaps for directors, <TT>directorin,
- directorout, directorargout</TT></A></LI>
-<LI><A href="#Ocaml_nn28"><TT>directorin</TT> typemap</A></LI>
-<LI><A href="#Ocaml_nn29"><TT>directorout</TT> typemap</A></LI>
-<LI><A href="#Ocaml_nn30"><TT>directorargout</TT> typemap</A></LI>
+<LI><A href="#Ocaml_nn27">Typemaps for directors, directorin,
+ directorout, directorargout</A></LI>
+<LI><A href="#Ocaml_nn28">typemap</A></LI>
+<LI><A href="#Ocaml_nn29">directorout typemap</A></LI>
+<LI><A href="#Ocaml_nn30">directorargout typemap</A></LI>
</UL>
</LI>
<LI><A href="#Ocaml_nn31">Exceptions</A></LI>
</UL>
</DIV>
<!-- INDEX -->
-<P> This chapter describes SWIG's support of Ocaml. Ocaml is a
- relatively recent addition to the ML family, and is a recent addition
- to SWIG. It's the second compiled, typed language to be added. Ocaml
- has widely acknowledged benefits for engineers, mostly derived from a
- sophisticated type system, compile-time checking which eliminates
- several classes of common programming errors, and good native
- performance. While all of this is wonderful, there are well-written C
- and C++ libraries that Ocaml users will want to take advantage of as
- part of their arsenal (such as SSL and gdbm), as well as their own
- mature C and C++ code. SWIG allows this code to be used in a natural,
- type-safe way with Ocaml, by providing the necessary, but repetitive
- glue code which creates and uses Ocaml values to communicate with C and
- C++ code. In addition, SWIG also produces the needed Ocaml source that
- binds variants, functions, classes, etc.</P>
+<P> This chapter describes SWIG's support of Ocaml.</P>
+<P> Ocaml is a relatively recent addition to the ML family, and is a
+ recent addition to SWIG. It's the second compiled, typed language to be
+ added. Ocaml has widely acknowledged benefits for engineers, mostly
+ derived from a sophisticated type system, compile-time checking which
+ eliminates several classes of common programming errors, and good
+ native performance. While all of this is wonderful, there are
+ well-written C and C++ libraries that Ocaml users will want to take
+ advantage of as part of their arsenal (such as SSL and gdbm), as well
+ as their own mature C and C++ code. SWIG allows this code to be used in
+ a natural, type-safe way with Ocaml, by providing the necessary, but
+ repetitive glue code which creates and uses Ocaml values to communicate
+ with C and C++ code. In addition, SWIG also produces the needed Ocaml
+ source that binds variants, functions, classes, etc.</P>
<P> If you're not familiar with the Objective Caml language, you can
- visit <A href="http://www.ocaml.org/">The Ocaml Website</A>.</P>
-<H2><A name="Ocaml_nn2"></A>29.1 Preliminaries</H2>
-<P> SWIG 1.3 works with Ocaml 3.04 and above. Given the choice, you
+ visit <A href="http://ocaml.org/">The Ocaml Website</A>.</P>
+<H2><A name="Ocaml_nn2">31.1 Preliminaries</A></H2>
+<P> SWIG 3.0 works with Ocaml 3.08.3 and above. Given the choice, you
should use the latest stable release. The SWIG Ocaml module has been
tested on Linux (x86,PPC,Sparc) and Cygwin on Windows. The best way to
determine whether your system will work is to compile the examples and
check</TT> from the SWIG root directory after installing SWIG. The
Ocaml module has been tested using the system's dynamic linking (the
usual -lxxx against libxxx.so, as well as with Gerd Stolpmann's <A href="http://download.camlcity.org/download/">
-Dl package</A> . The ocaml_dynamic and ocaml_dynamic_cpp targets in the
+Dl package</A>. The ocaml_dynamic and ocaml_dynamic_cpp targets in the
file Examples/Makefile illustrate how to compile and link SWIG modules
that will be loaded dynamically. This has only been tested on Linux so
far.</P>
-<H3><A name="Ocaml_nn3"></A>29.1.1 Running SWIG</H3>
+<H3><A name="Ocaml_nn3">31.1.1 Running SWIG</A></H3>
<P> The basics of getting a SWIG Ocaml module up and running can be seen
from one of SWIG's example Makefiles, but is also described here. To
build an Ocaml module, run SWIG using the <TT>-ocaml</TT> option.</P>
<DIV class="code">
<PRE>
%swig -ocaml example.i
- </PRE>
+</PRE>
</DIV>
-<P> This will produce 3 files. The file <TT>example_wrap.c</TT> contains
+<P>This will produce 3 files. The file <TT>example_wrap.c</TT> contains
all of the C code needed to build an Ocaml module. To build the module,
you will compile the file <TT>example_wrap.c</TT> with <TT>ocamlc</TT>
or <TT>ocamlopt</TT> to create the needed .o file. You will need to
compile the resulting .ml and .mli files as well, and do the final link
with -custom (not needed for native link).</P>
-<H3><A name="Ocaml_nn4"></A>29.1.2 Compiling the code</H3>
+<H3><A name="Ocaml_nn4">31.1.2 Compiling the code</A></H3>
<P> The OCaml SWIG module now requires you to compile a module (<TT>Swig</TT>
) separately. In addition to aggregating common SWIG functionality, the
Swig module contains the data structure that represents C/C++ values.
% ocamlc -c -ccopt "-I/usr/include/foo" example_wrap.c
% ocamlc -c example.mli
% ocamlc -c example.ml
- </PRE>
+</PRE>
</DIV>
-<P> <TT>ocamlc</TT> is aware of .c files and knows how to handle them.
+<P><TT>ocamlc</TT> is aware of .c files and knows how to handle them.
Unfortunately, it does not know about .cxx, .cc, or .cpp files, so when
SWIG is invoked in C++ mode, you must:</P>
<DIV class="code">
<PRE>
% cp example_wrap.cxx example_wrap.cxx.c
-<BR>% ocamlc -c ... -ccopt -xc++ example_wrap.cxx.c
-<BR>% ...
-<BR>
- </PRE>
+% ocamlc -c ... -ccopt -xc++ example_wrap.cxx.c
+% ...
+</PRE>
</DIV>
-<H3><A name="Ocaml_nn5"></A>29.1.3 The camlp4 module</H3>
+<H3><A name="Ocaml_nn5">31.1.3 The camlp4 module</A></H3>
<P> The camlp4 module (swigp4.ml -> swigp4.cmo) contains a simple
rewriter which makes C++ code blend more seamlessly with objective caml
- code. It's use is optional, but encouraged. The source file is included
+ code. Its use is optional, but encouraged. The source file is included
in the Lib/ocaml directory of the SWIG source distribution. You can
checkout this file with <TT>"swig -ocaml -co swigp4.ml"</TT>. You
should compile the file with <TT>"ocamlc -I `camlp4 -where` -pp
(_atoi (C_string "2"))
<BR> let b = C_string (getenv "PATH")</TD></TR>
</TABLE>
-<H3><A name="Ocaml_nn6"></A>29.1.4 Using your module</H3>
+<H3><A name="Ocaml_nn6">31.1.4 Using your module</A></H3>
<P> You can test-drive your module by building a toplevel ocaml
interpreter. Consult the ocaml manual for details.</P>
<P> When linking any ocaml bytecode with your module, use the -custom
option to build your functions into the primitive list. This option is
not needed when you build native code.</P>
-<H3><A name="Ocaml_nn7"></A>29.1.5 Compilation problems and compiling
- with C++</H3>
+<H3><A name="Ocaml_nn7">31.1.5 Compilation problems and compiling with
+ C++</A></H3>
<P> As mentioned above, .cxx files need special handling to be compiled
with <TT>ocamlc</TT>. Other than that, C code that uses <TT>class</TT>
as a non-keyword, and C code that is too liberal with pointer types may
not compile under the C++ compiler. Most code meant to be compiled as
C++ will not have problems.</P>
-<H2><A name="Ocaml_nn8"></A>29.2 The low-level Ocaml/C interface</H2>
+<H2><A name="Ocaml_nn8">31.2 The low-level Ocaml/C interface</A></H2>
<P> In order to provide access to overloaded functions, and provide
sensible outputs from them, all C entities are represented as members
of the c_obj type:</P>
<P> In the code as seen by the typemap writer, there is a value,
swig_result, that always contains the current return data. It is a
list, and must be appended with the caml_list_append function, or with
- functions and macros provided by objective caml.
-<BR></P>
+ functions and macros provided by objective caml.</P>
<DIV class="code">
<PRE>
type c_obj =
</DIV>
<P> A few functions exist which generate and return these:</P>
<UL>
-<LI>caml_ptr_val receives a c_obj and returns a void *. This should be
+<LI>caml_ptr_val receives a c_obj and returns a void *. This should be
used for all pointer purposes.</LI>
-<LI>caml_long_val receives a c_obj and returns a long. This should be
- used for most integral purposes.
-<BR></LI>
+<LI>caml_long_val receives a c_obj and returns a long. This should be
+ used for most integral purposes.</LI>
<LI>caml_val_ptr receives a void * and returns a c_obj.</LI>
-<LI>caml_val_bool receives a C int and returns a c_obj representing it's
+<LI>caml_val_bool receives a C int and returns a c_obj representing its
bool value.</LI>
<LI>caml_val_(u)?(char|short|int|long|float|double) receives an
appropriate C value and returns a c_obj representing it.</LI>
C_obj, which contains a closure giving method access.</LI>
</UL>
<P> Because of this style, a typemap can return any kind of value it
- wants from a function. This enables out typemaps and inout typemaps to
- work well. The one thing to remember about outputting values is that
+ wants from a function. This enables out typemaps and inout typemaps to
+ work well. The one thing to remember about outputting values is that
you must append them to the return list with swig_result =
caml_list_append(swig_result,v).</P>
-<P> This function will return a new list that has your element
- appended. Upon return to caml space, the fnhelper function beautifies
- the result. A list containing a single item degrades to only that item
- (i.e. [ C_int 3 ] -> C_int 3), and a list containing more than one item
- is wrapped in C_list (i.e. [ C_char 'a' ; C_char 'b' -> C_list [ C_char
- 'a' ; C_char b ]). This is in order to make return values easier to
+<P> This function will return a new list that has your element appended.
+ Upon return to caml space, the fnhelper function beautifies the result.
+ A list containing a single item degrades to only that item (i.e. [
+ C_int 3 ] -> C_int 3), and a list containing more than one item is
+ wrapped in C_list (i.e. [ C_char 'a' ; C_char 'b' -> C_list [ C_char
+ 'a' ; C_char b ]). This is in order to make return values easier to
handle when functions have only one return value, such as constructors,
- and operators. In addition, string, pointer, and object values are
+ and operators. In addition, string, pointer, and object values are
interchangeable with respect to caml_ptr_val, so you can allocate
memory as caml strings and still use the resulting pointers for C
purposes, even using them to construct simple objects on. Note, though,
the SWIG interface does.</P>
<P> The wild card type that you can use in lots of different ways is
C_obj. It allows you to wrap any type of thing you like as an object
- using the same mechanism that the ocaml module does. When evaluated in
+ using the same mechanism that the ocaml module does. When evaluated in
caml_ptr_val, the returned value is the result of a call to the
object's "&" operator, taken as a pointer.</P>
<P> You should only construct values using objective caml, or using the
provide everything a typemap needs to produce values. In addition,
value items pass through directly, but you must make your own type
signature for a function that uses value in this way.</P>
-<H3><A name="Ocaml_nn9"></A>29.2.1 The generated module</H3>
+<H3><A name="Ocaml_nn9">31.2.1 The generated module</A></H3>
<P> The SWIG <TT>%module</TT> directive specifies the name of the Ocaml
module to be generated. If you specified `<TT>%module example</TT>',
then your Ocaml code will be accessible in the module Example. The
because it describes the output SWIG will generate for class
definitions.</TD></TR>
</TABLE>
-<H3><A name="Ocaml_nn10"></A>29.2.2 Enums</H3>
+<H3><A name="Ocaml_nn10">31.2.2 Enums</A></H3>
<P> SWIG will wrap enumerations as polymorphic variants in the output
- Ocaml code, as above in C_enum. In order to support all C++-style uses
+ Ocaml code, as above in C_enum. In order to support all C++-style uses
of enums, the function int_to_enum and enum_to_int are provided for
- ocaml code to produce and consume these values as integers. Other than
- that, correct uses of enums will not have a problem. Since enum labels
+ ocaml code to produce and consume these values as integers. Other than
+ that, correct uses of enums will not have a problem. Since enum labels
may overlap between enums, the enum_to_int and int_to_enum functions
take an enum type label as an argument. Example:</P>
<DIV class="code">
<DIV class="code">
<PRE>
bash-2.05a$ ocamlmktop -custom enum_test_wrap.o enum_test.cmo -o enum_test_top
-bash-2.05a$ ./enum_test_top
+bash-2.05a$ ./enum_test_top
Objective Caml version 3.04
# open Enum_test ;;
- : Enum_test.c_obj = C_enum `c
</PRE>
</DIV>
-<H4><A name="Ocaml_nn11"></A>29.2.2.1 Enum typing in Ocaml</H4>
+<H4><A name="Ocaml_nn11">31.2.2.1 Enum typing in Ocaml</A></H4>
<P> The ocaml SWIG module now has support for loading and using multiple
SWIG modules at the same time. This enhances modularity, but presents
problems when used with a language which assumes that each module's
values are shared between functions imported from different modules.
You must convert values to master values using the swig_val function
before sharing them with another module.</P>
-<H3><A name="Ocaml_nn12"></A>29.2.3 Arrays</H3>
-<H4><A name="Ocaml_nn13"></A>29.2.3.1 Simple types of bounded arrays</H4>
+<H3><A name="Ocaml_nn12">31.2.3 Arrays</A></H3>
+<H4><A name="Ocaml_nn13">31.2.3.1 Simple types of bounded arrays</A></H4>
<P> SWIG has support for array types, but you generally will need to
provide a typemap to handle them. You can currently roll your own, or
expand some of the macros provided (but not included by default) with
<P> <TT>%make_simple_array_typemap</TT> is the easiest way to get access
to arrays of simple types with known bounds in your code, but this only
works for arrays whose bounds are completely specified.</P>
-<H4><A name="Ocaml_nn14"></A>29.2.3.2 Complex and unbounded arrays</H4>
+<H4><A name="Ocaml_nn14">31.2.3.2 Complex and unbounded arrays</A></H4>
<P> Unfortunately, unbounded arrays and pointers can't be handled in a
completely general way by SWIG, because the end-condition of such an
array can't be predicted. In some cases, it will be by consent (e.g. an
*buffer, int len), and sometimes by sentinel value (0,-1,etc.). SWIG
can't predict which of these methods will be used in the array, so you
have to specify it for yourself in the form of a typemap.</P>
-<H4><A name="Ocaml_nn15"></A>29.2.3.3 Using an object</H4>
+<H4><A name="Ocaml_nn15">31.2.3.3 Using an object</A></H4>
<P> It's possible to use C++ to your advantage by creating a simple
object that provides access to your array. This may be more desirable
in some cases, since the object can provide bounds checking, etc., that
prevents crashes.</P>
<P> Consider writing an object when the ending condition of your array
is complex, such as using a required sentinel, etc.</P>
-<H4><A name="Ocaml_nn16"></A>29.2.3.4 Example typemap for a function
- taking float * and int</H4>
+<H4><A name="Ocaml_nn16">31.2.3.4 Example typemap for a function taking
+ float * and int</A></H4>
<P> This is a simple example <TT>in</TT> typemap for an array of float,
where the length of the array is specified as an extra parameter. Other
such typemaps will work similarly. In the example, the function
#include <stdio.h>
void printfloats( float *tab, int len ) {
- int i;
+ int i;
- for( i = 0; i < len; i++ ) {
- printf( "%f ", tab[i] );
- }
+ for( i = 0; i < len; i++ ) {
+ printf( "%f ", tab[i] );
+ }
- printf( "\n" );
+ printf( "\n" );
}
%}
%typemap(in) (float *tab, int len) {
- int i;
- /* $*1_type */
- $2 = caml_array_len($input);
- $1 = ($*1_type *)malloc( $2 * sizeof( float ) );
- for( i = 0; i < $2; i++ ) {
- $1[i] = caml_double_val(caml_array_nth($input,i));
- }
+ int i;
+ /* $*1_type */
+ $2 = caml_array_len($input);
+ $1 = ($*1_type *)malloc( $2 * sizeof( float ) );
+ for( i = 0; i < $2; i++ ) {
+ $1[i] = caml_double_val(caml_array_nth($input,i));
+ }
}
void printfloats( float *tab, int len );
</PRE>
</TD></TR>
</TABLE>
-<H3><A name="Ocaml_nn17"></A>29.2.4 C++ Classes</H3>
+<H3><A name="Ocaml_nn17">31.2.4 C++ Classes</A></H3>
<P> C++ classes, along with structs and unions are represented by C_obj
- (string -> c_obj -> c_obj) wrapped closures. These objects contain a
+ (string -> c_obj -> c_obj) wrapped closures. These objects contain a
method list, and a type, which allow them to be used like C++ objects.
When passed into typemaps that use pointers, they degrade to pointers
- through their "&" method. Every method an object has is represented as
+ through their "&" method. Every method an object has is represented as
a string in the object's method table, and each method table exists in
- memory only once. In addition to any other operators an object might
+ memory only once. In addition to any other operators an object might
have, certain builtin ones are provided by SWIG: (all of these take no
arguments (C_void))</P>
<TABLE summary="SWIG provided operators">
<P> Note that this string belongs to the wrapper object, and not the
underlying pointer, so using create_[x]_from_ptr alters the returned
value for the same object.</P>
-<H4><A name="Ocaml_nn18"></A>29.2.4.1 STL vector and string Example</H4>
+<H4><A name="Ocaml_nn18">31.2.4.1 STL vector and string Example</A></H4>
<P> Standard typemaps are now provided for STL vector and string. More
are in the works. STL strings are passed just like normal strings, and
returned as strings. STL string references don't mutate the original
%include <stl.i>
namespace std {
- %template(StringVector) std::vector < string >;
+ %template(StringVector) std::vector < string >;
};
%include "example.h"
camlp4 module.</P>
<DIV class="code">
<PRE>
-bash-2.05a$ ./example_top
+bash-2.05a$ ./example_top
Objective Caml version 3.06
Camlp4 Parsing version 3.06
- : Example.c_obj = C_void
# x '[1] ;;
- : Example.c_obj = C_string "spam"
-# for i = 0 to (x -> size() as int) - 1 do
- print_endline ((x '[i to int]) as string)
+# for i = 0 to (x -> size() as int) - 1 do
+ print_endline ((x '[i to int]) as string)
done ;;
foo
bar
baz
- : unit = ()
-#
+#
</PRE>
</DIV>
-<H4><A name="Ocaml_nn19"></A>29.2.4.2 C++ Class Example</H4>
+<H4><A name="Ocaml_nn19">31.2.4.2 C++ Class Example</A></H4>
<P> Here's a simple example using Trolltech's Qt Library:</P>
<TABLE bgcolor="#dddddd" border="1" summary="Qt Library example">
<TR><TH>
%}
class QApplication {
public:
- QApplication( int argc, char **argv );
- void setMainWidget( QWidget *widget );
- void exec();
+ QApplication( int argc, char **argv );
+ void setMainWidget( QWidget *widget );
+ void exec();
};
class QPushButton {
public:
- QPushButton( char *str, QWidget *w );
- void resize( int x, int y );
- void show();
+ QPushButton( char *str, QWidget *w );
+ void resize( int x, int y );
+ void show();
};
</PRE>
</TD></TR>
</TABLE>
-<H4><A name="Ocaml_nn20"></A>29.2.4.3 Compiling the example</H4>
+<H4><A name="Ocaml_nn20">31.2.4.3 Compiling the example</A></H4>
<DIV class="code">
<PRE>
bash-2.05a$ QTPATH=/your/qt/path
bash-2.05a$ for file in swig.mli swig.ml swigp4.ml ; do swig -ocaml -co $file ; done
bash-2.05a$ ocamlc -c swig.mli ; ocamlc -c swig.ml
bash-2.05a$ ocamlc -I `camlp4 -where` -pp "camlp4o pa_extend.cmo q_MLast.cmo" -c swigp4.ml
-bash-2.05a$ swig -ocaml -c++ -I$QTPATH/include qt.i
+bash-2.05a$ swig -ocaml -c++ -I$QTPATH/include qt.i
bash-2.05a$ mv qt_wrap.cxx qt_wrap.c
-bash-2.05a$ ocamlc -c -ccopt -xc++ -ccopt -g -g -ccopt -I$QTPATH/include qt_wrap.c
+bash-2.05a$ ocamlc -c -ccopt -xc++ -ccopt -g -g -ccopt -I$QTPATH/include qt_wrap.c
bash-2.05a$ ocamlc -c qt.mli
bash-2.05a$ ocamlc -c qt.ml
bash-2.05a$ ocamlmktop -custom swig.cmo -I `camlp4 -where` \
-L$QTPATH/lib -cclib -lqt
</PRE>
</DIV>
-<H4><A name="Ocaml_nn21"></A>29.2.4.4 Sample Session</H4>
+<H4><A name="Ocaml_nn21">31.2.4.4 Sample Session</A></H4>
<DIV class="code">
<PRE>
-bash-2.05a$ ./qt_top
+bash-2.05a$ ./qt_top
Objective Caml version 3.06
Camlp4 Parsing version 3.06
</DIV>
<P> Assuming you have a working installation of QT, you will see a
window containing the string "hi" in a button.</P>
-<H3><A name="Ocaml_nn22"></A>29.2.5 Director Classes</H3>
-<H4><A name="Ocaml_nn23"></A>29.2.5.1 Director Introduction</H4>
+<H3><A name="Ocaml_nn22">31.2.5 Director Classes</A></H3>
+<H4><A name="Ocaml_nn23">31.2.5.1 Director Introduction</A></H4>
<P> Director classes are classes which allow Ocaml code to override the
public methods of a C++ object. This facility allows the user to use
C++ libraries that require a derived class to provide application
};
</PRE>
</DIV>
-<H4><A name="Ocaml_nn24"></A>29.2.5.2 Overriding Methods in Ocaml</H4>
+<H4><A name="Ocaml_nn24">31.2.5.2 Overriding Methods in Ocaml</A></H4>
<P> Because the Ocaml language module treats C++ method calls as calls
to a certain function, all you need to do is to define the function
that will handle the method calls in terms of the public methods of the
<P> In this example, I'll examine the objective caml code involved in
providing an overloaded class. This example is contained in
Examples/ocaml/shapes.</P>
-<H4><A name="Ocaml_nn25"></A>29.2.5.3 Director Usage Example</H4>
+<H4><A name="Ocaml_nn25">31.2.5.3 Director Usage Example</A></H4>
<TABLE bgcolor="#dddddd" border="1" summary="Director usage example">
<TR><TH>
<CENTER>example_prog.ml</CENTER>
"cover" ->
(match args with
C_list [ x_arg ; y_arg ] ->
- let xa = x_arg as float
- and ya = y_arg as float in
- (point_in_triangle pts xa ya) to bool
+ let xa = x_arg as float
+ and ya = y_arg as float in
+ (point_in_triangle pts xa ya) to bool
| _ -> raise (Failure "cover needs two double arguments."))
| _ -> (invoke ob) meth args ;;
let triangle =
- new_derived_object
+ new_derived_object
new_shape
(triangle_class ((0.0,0.0),(0.5,1.0),(1.0,0.0)))
'() ;;
returns bool). This might allow a tricky shape implementation, such as
a boolean combination, to be expressed in a more effortless style in
ocaml, while leaving the "engine" part of the program in C++.</P>
-<H4><A name="Ocaml_nn26"></A>29.2.5.4 Creating director objects</H4>
+<H4><A name="Ocaml_nn26">31.2.5.4 Creating director objects</A></H4>
<P> The definition of the actual object triangle can be described this
way:</P>
<DIV class="code">
<PRE>
let triangle =
- new_derived_object
+ new_derived_object
new_shape
(triangle_class ((0.0,0.0),(0.5,1.0),(1.0,0.0)))
'()
actual raise is from an inner function used by new_derived_object, and
throws NotObject). This prevents a deleted C++ object from causing a
core dump, as long as the object is destroyed properly.</P>
-<H4><A name="Ocaml_nn27"></A>29.2.5.5 Typemaps for directors, <TT>
-directorin, directorout, directorargout</TT></H4>
+<H4><A name="Ocaml_nn27">31.2.5.5 Typemaps for directors, directorin,
+ directorout, directorargout</A></H4>
<P> Special typemaps exist for use with directors, the <TT>directorin,
directorout, directorargout</TT> are used in place of <TT>in, out,
argout</TT> typemaps, except that their direction is reversed. They
provide for you to provide argout values, as well as a function return
value in the same way you provide function arguments, and to receive
arguments the same way you normally receive function returns.</P>
-<H4><A name="Ocaml_nn28"></A>29.2.5.6 <TT>directorin</TT> typemap</H4>
+<H4><A name="Ocaml_nn28">31.2.5.6 typemap</A></H4>
<P> The <TT>directorin</TT> typemap is used when you will receive
arguments from a call made by C++ code to you, therefore, values will
be translated from C++ to ocaml. You must provide some valid C_obj
value. This is the value your ocaml code receives when you are called.
In general, a simple <TT>directorin</TT> typemap can use the same body
as a simple <TT>out</TT> typemap.</P>
-<H4><A name="Ocaml_nn29"></A>29.2.5.7 <TT>directorout</TT> typemap</H4>
+<H4><A name="Ocaml_nn29">31.2.5.7 directorout typemap</A></H4>
<P> The <TT>directorout</TT> typemap is used when you will send an
argument from your code back to the C++ caller. That is; directorout
specifies a function return conversion. You can usually use the same
body as an <TT>in</TT> typemap for the same type, except when there are
special requirements for object ownership, etc.</P>
-<H4><A name="Ocaml_nn30"></A>29.2.5.8 <TT>directorargout</TT> typemap</H4>
+<H4><A name="Ocaml_nn30">31.2.5.8 directorargout typemap</A></H4>
<P> C++ allows function arguments which are by pointer (*) and by
reference (&) to receive a value from the called function, as well as
sending one there. Sometimes, this is the main purpose of the argument
typemaps. In the event that you don't specify all of the necessary
values, integral values will read zero, and struct or object returns
have undefined results.</P>
-<H3><A name="Ocaml_nn31"></A>29.2.6 Exceptions</H3>
+<H3><A name="Ocaml_nn31">31.2.6 Exceptions</A></H3>
<P> Catching exceptions is now supported using SWIG's %exception
feature. A simple but not too useful example is provided by the
throw_exception testcase in Examples/test-suite. You can provide your
own exceptions, too.</P>
<HR NOSHADE>
-<H1><A name="Octave"></A>30 SWIG and Octave</H1>
+<H1><A name="Octave">32 SWIG and Octave</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<LI><A href="#Octave_nn18">C++ operators</A></LI>
<LI><A href="#Octave_nn19">Class extension with %extend</A></LI>
<LI><A href="#Octave_nn20">C++ templates</A></LI>
-<LI><A href="#Octave_nn21">C++ Smart Pointers</A></LI>
+<LI><A href="#Octave_nn21">C++ Smart Pointers</A>
+<UL>
+<LI><A href="#Octave_smart_pointers_shared_ptr">The shared_ptr Smart
+ Pointer</A></LI>
+<LI><A href="#Octave_smart_pointers_generic">Generic Smart Pointers</A></LI>
+</UL>
+</LI>
<LI><A href="#Octave_nn22">Directors (calling Octave from C++ code)</A></LI>
<LI><A href="#Octave_nn23">Threads</A></LI>
<LI><A href="#Octave_nn24">Memory management</A></LI>
specific to Octave. Also, there are a dozen or so examples in the
Examples/octave directory, and hundreds in the test suite
(Examples/test-suite and Examples/test-suite/octave).</P>
-<H2><A name="Octave_nn2"></A>30.1 Preliminaries</H2>
-<P> As of SWIG 3.0.0, the Octave module has been tested with Octave
- versions 3.0.5, 3.2.4, 3.4.3, 3.6.4, and 3.8.0. Use of Octave versions
- older than 3.x.x is not recommended, as these versions are no longer
- tested with SWIG.</P>
-<H2><A name="Octave_nn3"></A>30.2 Running SWIG</H2>
+<H2><A name="Octave_nn2">32.1 Preliminaries</A></H2>
+<P> As of SWIG 3.0.7, the Octave module is regularly tested with Octave
+ versions 3.2.4, 3.8.1, and 4.0.0. Use of older Octave versions is not
+ recommended, as these versions are no longer tested with SWIG. The SWIG
+ runtime exports the function <TT>swig_octave_prereq()</TT> for checking
+ the version of Octave.</P>
+<H2><A name="Octave_nn3">32.2 Running SWIG</A></H2>
<P> Let's start with a very simple SWIG interface file, example.i:</P>
<DIV class="code">
<PRE>
source file contains the low-level wrappers that need to be compiled
and linked with the rest of your C/C++ application (in this case, the
gcd implementation) to create an extension module.</P>
-<H3><A name="Octave_nn4"></A>30.2.1 Command-line options</H3>
+<H3><A name="Octave_nn4">32.2.1 Command-line options</A></H3>
<P> The swig command line has a number of options you can use, like to
redirect its output. Use <TT>swig -help</TT> to learn about these.
Options specific to the Octave module are:</P>
i.e. alongside C functions and structs exported by the module. The<EM>
-opprefix</EM> options sets the prefix of the names of global/friend <A href="#Octave_nn18">
operator</A> functions.</P>
-<H3><A name="Octave_nn5"></A>30.2.2 Compiling a dynamic module</H3>
+<H3><A name="Octave_nn5">32.2.2 Compiling a dynamic module</A></H3>
<P> Octave modules are DLLs/shared objects having the ".oct" suffix.
Building an oct file is usually done with the mkoctfile command (either
within Octave itself, or from the shell). For example,</P>
<DIV class="targetlang">
<PRE>octave:1> swigexample</PRE>
</DIV>
-<H3><A name="Octave_nn6"></A>30.2.3 Using your module</H3>
+<H3><A name="Octave_nn6">32.2.3 Using your module</A></H3>
<P> Assuming all goes well, you will be able to do this:
<BR></P>
<DIV class="targetlang">
octave:5> swigexample.cvar.Foo
ans = 4 </PRE>
</DIV>
-<H2><A name="Octave_nn7"></A>30.3 A tour of basic C/C++ wrapping</H2>
-<H3><A name="Octave_nn8"></A>30.3.1 Modules</H3>
+<H2><A name="Octave_nn7">32.3 A tour of basic C/C++ wrapping</A></H2>
+<H3><A name="Octave_nn8">32.3.1 Modules</A></H3>
<P> The SWIG module directive specifies the name of the Octave module.
If you specify "module swigexample", then in Octave everything in the
module will be accessible under "swigexample", as in the above example.
ans = 2
</PRE>
</DIV>
-<H3><A name="Octave_nn9"></A>30.3.2 Functions</H3>
+<H3><A name="Octave_nn9">32.3.2 Functions</A></H3>
<P> Global functions are wrapped as new Octave built-in functions. For
example,</P>
<DIV class="code">
<PRE>octave:1> swigexample.fact(4)
24 </PRE>
</DIV>
-<H3><A name="Octave_nn10"></A>30.3.3 Global variables</H3>
+<H3><A name="Octave_nn10">32.3.3 Global variables</A></H3>
<P> Global variables are a little special in Octave. Given a global
variable:</P>
<DIV class="code">
octave:3> swigexample.PI
ans = 3.1420 </PRE>
</DIV>
-<H3><A name="Octave_nn11"></A>30.3.4 Constants and enums</H3>
+<H3><A name="Octave_nn11">32.3.4 Constants and enums</A></H3>
<P> Because Octave doesn't really have the concept of constants, C/C++
constants are not really constant in Octave. They are actually just a
copy of the value into the Octave interpreter. Therefore they can be
swigexample.SUNDAY=0
.... </PRE>
</DIV>
-<H3><A name="Octave_nn12"></A>30.3.5 Pointers</H3>
+<H3><A name="Octave_nn12">32.3.5 Pointers</A></H3>
<P> C/C++ pointers are fully supported by SWIG. Furthermore, SWIG has no
problem working with incomplete type information. Given a wrapping of
the <file.h> interface: C/C++ pointers are fully supported by SWIG.
octave:4> swigexample.fclose(f);
</PRE>
</DIV>
-<P> Simply printing the value of a wrapped C++ type will print it's
+<P> Simply printing the value of a wrapped C++ type will print its
typename. E.g.,</P>
<DIV class="targetlang">
<PRE>octave:1> swigexample;
error: value on right hand side of assignment is undefined
error: evaluating assignment expression near line 2, column 2 </PRE>
</DIV>
-<H3><A name="Octave_nn13"></A>30.3.6 Structures and C++ classes</H3>
+<H3><A name="Octave_nn13">32.3.6 Structures and C++ classes</A></H3>
<P> SWIG wraps C structures and C++ classes by using a special Octave
type called a <TT>swig_ref</TT>. A <TT>swig_ref</TT> contains a
reference to one or more instances of C/C++ objects, or just the type
<P> Depending on the ownership setting of a <TT>swig_ref</TT>, it may
call C++ destructors when its reference count goes to zero. See the
section on memory management below for details.</P>
-<H3><A name="Octave_nn15"></A>30.3.7 C++ inheritance</H3>
+<H3><A name="Octave_nn15">32.3.7 C++ inheritance</A></H3>
<P> Single and multiple inheritance are fully supported. The <TT>
swig_ref</TT> type carries type information along with any C++ object
pointer it holds. This information contains the full class hierarchy.
When an indexing operation (such as a method invocation) occurs, the
tree is walked to find a match in the current class as well as any of
its bases. The lookup is then cached in the <TT>swig_ref</TT>.</P>
-<H3><A name="Octave_nn17"></A>30.3.8 C++ overloaded functions</H3>
+<H3><A name="Octave_nn17">32.3.8 C++ overloaded functions</A></H3>
<P> Overloaded functions are supported, and handled as in other modules.
That is, each overload is wrapped separately (under internal names),
and a dispatch function is also emitted under the external/visible
based on the passed arguments. <TT>typecheck</TT> typemaps are used to
analyze each argument, as well as assign precedence. See the chapter on
typemaps for details.</P>
-<H3><A name="Octave_nn18"></A>30.3.9 C++ operators</H3>
+<H3><A name="Octave_nn18">32.3.9 C++ operators</A></H3>
<P> C++ operator overloading is supported, in a way similar to other
modules. The <TT>swig_ref</TT> type supports all unary and binary
operators between itself and all other types that exist in the system
named is derived from the types of the operands (either both or just
the lhs or rhs).</P>
<P> For example, if <TT>a</TT> and <TT>b</TT> are SWIG variables in
- Octave, <TT>a+b</TT> becomes <TT>a.__add(b)</TT>. The wrapper is then
- free to implement __add to do whatever it wants. A wrapper may define
- the <TT>__add</TT> function manually, %rename some other function to
+ Octave, <TT>a+b</TT> becomes <TT>a.__add__(b)</TT>. The wrapper is then
+ free to implement __add__ to do whatever it wants. A wrapper may define
+ the <TT>__add__</TT> function manually, %rename some other function to
it, or %rename a C++ operator to it.</P>
<P> By default the C++ operators are renamed to their corresponding
Octave operators. So without doing any work, the following interface</P>
<P> Octave operators are mapped in the following way:</P>
<DIV class="code">
<PRE>
-__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
+__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
</PRE>
</DIV>
<P> On the C++ side, the default mappings are as follows:</P>
<DIV class="code">
<PRE>
-%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(__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(__rshift__) *::operator-->
>;
-%rename(__el_and) *::operator&&;
-%rename(__el_or) *::operator||;
-%rename(__xor) *::operator^;
-%rename(__invert) *::operator~;
-%rename(__lt) *::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(__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[];
+%rename(__ge__) *::operator>=;
+%rename(__eq__) *::operator==;
+%rename(__ne__) *::operator!=;
+%rename(__not__) *::operator!;
+%rename(__incr__) *::operator++;
+%rename(__decr__) *::operator--;
+%rename(__paren__) *::operator();
+%rename(__brace__) *::operator[];
</PRE>
</DIV>
<P> Octave can also utilise friend (i.e. non-member) operators with a
simple %rename: see the example in the Examples/octave/operator
directory.</P>
-<H3><A name="Octave_nn19"></A>30.3.10 Class extension with %extend</H3>
+<H3><A name="Octave_nn19">32.3.10 Class extension with %extend</A></H3>
<P> The %extend directive works the same as in other modules.</P>
<P> You can use it to define special behavior, like for example defining
Octave operators not mapped to C++ operators, or defining certain
Octave mechanisms such as how an object prints. For example, the <TT>
octave_value::{is_string,string_value,print}</TT> functions are routed
- to a special method <TT>__str</TT> that can be defined inside an
+ to a special method <TT>__str__</TT> that can be defined inside an
%extend.</P>
<DIV class="code">
<PRE>
%extend A {
-string __str() {
+string __str__() {
stringstream sout;
sout<<$self->value;
return sout.str();
a = 4
octave:3> printf("%s\n",a);
4
-octave:4> a.__str()
+octave:4> a.__str__()
4
</PRE>
</DIV>
-<H3><A name="Octave_nn20"></A>30.3.11 C++ templates</H3>
+<P> Similarly, Octave can use the <TT>__float__</TT> method to convert
+ an object to a numeric value.</P>
+<P> Octave 3.8.0 and later versions will also map unary functions X() to
+ the corresponding <TT>__X__</TT> method, where X includes: abs(),
+ acos(), acosh(), angle(), arg(), asin(), asinh(), atan(), atanh(),
+ cbrt(), ceil(), conj(), cos(), cosh(), dawson(), erf(), erfc(),
+ erfcinv(), erfcx(), erfi(), erfinv(), exp(), expm1(), finite(), fix(),
+ floor(), gamma(), imag(), isalnum(), isalpha(), isascii(), iscntrl(),
+ isdigit(), isgraph(), isinf(), islower(), isna(), isnan(), isprint(),
+ ispunct(), isspace(), isupper(), isxdigit(), lgamma(), log(), log10(),
+ log1p(), log2(), real(), round(), roundb(), signbit(), signum(), sin(),
+ sinh(), sqrt(), tan(), tanh(), toascii(), tolower(), toupper()</P>
+<H3><A name="Octave_nn20">32.3.11 C++ templates</A></H3>
<P> C++ class and function templates are fully supported as in other
modules, in that the %template directive may used to create explicit
instantiations of templated types. For example, function templates can
s+=_s;
return *this;
}
- std::string __str() const {
+ std::string __str__() const {
std::stringstream sout;
sout<<s;
return sout.str();
(7,4)
</PRE>
</DIV>
-<H3><A name="Octave_nn21"></A>30.3.12 C++ Smart Pointers</H3>
+<H3><A name="Octave_nn21">32.3.12 C++ Smart Pointers</A></H3>
+<H4><A name="Octave_smart_pointers_shared_ptr">32.3.12.1 The shared_ptr
+ Smart Pointer</A></H4>
+<P> The C++11 standard provides <TT>std::shared_ptr</TT> which was
+ derived from the Boost implementation, <TT>boost::shared_ptr</TT>. Both
+ of these are available for Octave in the SWIG library and usage is
+ outlined in the <A href="#Library_std_shared_ptr">shared_ptr smart
+ pointer</A> library section.</P>
+<H4><A name="Octave_smart_pointers_generic">32.3.12.2 Generic Smart
+ Pointers</A></H4>
<P> C++ smart pointers are fully supported as in other modules.</P>
-<H3><A name="Octave_nn22"></A>30.3.13 Directors (calling Octave from C++
- code)</H3>
+<H3><A name="Octave_nn22">32.3.13 Directors (calling Octave from C++
+ code)</A></H3>
<P> There is full support for SWIG Directors, which permits Octave code
to subclass C++ classes, and implement their virtual methods.</P>
<P> Octave has no direct support for object oriented programming,
octave-side routine called
</PRE>
</DIV>
-<H3><A name="Octave_nn23"></A>30.3.14 Threads</H3>
+<H3><A name="Octave_nn23">32.3.14 Threads</A></H3>
<P> The use of threads in wrapped Director code is not supported; i.e.,
an Octave-side implementation of a C++ class must be called from the
Octave interpreter's thread. Anything fancier (apartment/queue model,
to the limitation that Octave must drive the module... like, for
example, an optimization package that calls Octave to evaluate an
objective function.</P>
-<H3><A name="Octave_nn24"></A>30.3.15 Memory management</H3>
+<H3><A name="Octave_nn24">32.3.15 Memory management</A></H3>
<P> As noted above, <TT>swig_ref</TT> represents a reference counted
pointer to a C/C++-side object. It also contains a flag indicating
whether Octave or the C/C++ code owns the object. If Octave owns it,
the object will invalidate the Octave-side object if it still exists
(and call destructors of other C++ bases in the case of multiple
inheritance/<TT>subclass()</TT>'ing).</P>
-<H3><A name="Octave_nn25"></A>30.3.16 STL support</H3>
+<H3><A name="Octave_nn25">32.3.16 STL support</A></H3>
<P> Various STL library files are provided for wrapping STL containers.</P>
-<H3><A name="Octave_nn26"></A>30.3.17 Matrix typemaps</H3>
+<H3><A name="Octave_nn26">32.3.17 Matrix typemaps</A></H3>
<P> Octave provides a rich set of classes for dealing with matrices.
Currently there are no built-in typemaps to deal with those. However,
these are relatively straight forward for users to add themselves (see
</PRE>
</DIV> <TT>
<BR></TT><HR NOSHADE>
-<H1><A name="Perl5"></A>31 SWIG and Perl5</H1>
+<H1><A name="Perl5">33 SWIG and Perl5</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
</UL>
</LI>
<LI><A href="#Perl5_nn47">Adding additional Perl code</A></LI>
+<LI><A href="#Perl5_directors">Cross language polymorphism</A>
+<UL>
+<LI><A href="#Perl5_nn48">Enabling directors</A></LI>
+<LI><A href="#Perl5_nn49">Director classes</A></LI>
+<LI><A href="#Perl5_nn50">Ownership and object destruction</A></LI>
+<LI><A href="#Perl5_nn51">Exception unrolling</A></LI>
+<LI><A href="#Perl5_nn52">Overhead and code bloat</A></LI>
+<LI><A href="#Perl5_nn53">Typemaps</A></LI>
+</UL>
+</LI>
</UL>
</DIV>
<!-- INDEX -->
results, it is recommended that SWIG be used with Perl 5.8 or later.
We're no longer testing regularly with older versions, but Perl 5.6
seems to mostly work, while older versions don't.</P>
-<H2><A name="Perl5_nn2"></A>31.1 Overview</H2>
+<H2><A name="Perl5_nn2">33.1 Overview</A></H2>
<P> To build Perl extension modules, SWIG uses a layered approach. At
the lowest level, simple procedural wrappers are generated for
functions, classes, methods, and other declarations in the input file.
interface is presented. Finally, proxy classes are described. Advanced
customization features, typemaps, and other options are found near the
end of the chapter.</P>
-<H2><A name="Perl5_nn3"></A>31.2 Preliminaries</H2>
+<H2><A name="Perl5_nn3">33.2 Preliminaries</A></H2>
<P> To build a Perl5 module, run SWIG using the <TT>-perl</TT> option as
follows:</P>
<DIV class="code">
properly load the module.</P>
<P> To build the module, you will need to compile the file <TT>
example_wrap.c</TT> and link it with the rest of your program.</P>
-<H3><A name="Perl5_nn4"></A>31.2.1 Getting the right header files</H3>
+<H3><A name="Perl5_nn4">33.2.1 Getting the right header files</A></H3>
<P> In order to compile, SWIG extensions need the following Perl5 header
files:</P>
<DIV class="code">
/usr/lib/perl/5.14
</PRE>
</DIV>
-<H3><A name="Perl5_nn5"></A>31.2.2 Compiling a dynamic module</H3>
+<H3><A name="Perl5_nn5">33.2.2 Compiling a dynamic module</A></H3>
<P> The preferred approach to building an extension module is to compile
it into a shared object file or DLL. Assuming you have code you need to
link to in a file called <TT>example.c</TT>, you will need to compile
%module example</TT>', then the target should be named `<TT>example.so</TT>
', `<TT>example.sl</TT>', or the appropriate dynamic module name on your
system.</P>
-<H3><A name="Perl5_nn6"></A>31.2.3 Building a dynamic module with
- MakeMaker</H3>
+<H3><A name="Perl5_nn6">33.2.3 Building a dynamic module with MakeMaker</A>
+</H3>
<P> It is also possible to use Perl to build dynamically loadable
modules for you using the MakeMaker utility. To do this, write a Perl
script such as the following:</P>
# File : Makefile.PL
use ExtUtils::MakeMaker;
WriteMakefile(
- `NAME' => `example', # Name of package
- `LIBS' => [`-lm'], # Name of custom libraries
- `OBJECT' => `example.o example_wrap.o' # Object files
+ `NAME' => `example', # Name of package
+ `LIBS' => [`-lm'], # Name of custom libraries
+ `OBJECT' => `example.o example_wrap.o' # Object files
);
</PRE>
the preferred approach to compilation. More information about MakeMaker
can be found in "Programming Perl, 2nd ed." by Larry Wall, Tom
Christiansen, and Randal Schwartz.</P>
-<H3><A name="Perl5_nn7"></A>31.2.4 Building a static version of Perl</H3>
+<H3><A name="Perl5_nn7">33.2.4 Building a static version of Perl</A></H3>
<P> If you machine does not support dynamic loading or if you've tried
to use it without success, you can build a new version of the Perl
interpreter with your SWIG extensions added to it. To build a static
<DIV class="code">
<PRE>
$ gcc example.o example_wrap.o -L/usr/lib/perl/5.14/CORE \
- -lperl -lsocket -lnsl -lm -o myperl
+ -lperl -lsocket -lnsl -lm -o myperl
</PRE>
</DIV>
<P> This will produce a new version of Perl called <TT>myperl</TT>. It
should be functionality identical to Perl with your C/C++ extension
added to it. Depending on your machine, you may need to link with
additional libraries such as <TT>-lsocket, -lnsl, -ldl</TT>, etc.</P>
-<H3><A name="Perl5_nn8"></A>31.2.5 Using the module</H3>
+<H3><A name="Perl5_nn8">33.2.5 Using the module</A></H3>
<P> To use the module, simply use the Perl <TT>use</TT> statement. If
all goes well, you will be able to do this:</P>
<DIV class="targetlang">
crle</TT> (Solaris) to add additional search paths to the default system
configuration (this requires root access and you will need to read the
man pages).</P>
-<H3><A name="Perl5_nn9"></A>31.2.6 Compilation problems and compiling
- with C++</H3>
+<H3><A name="Perl5_nn9">33.2.6 Compilation problems and compiling with
+ C++</A></H3>
<P> Compilation of C++ extensions has traditionally been a tricky
problem. Since the Perl interpreter is written in C, you need to take
steps to make sure C++ is properly initialized and that modules are
<DIV class="code">
<PRE>
$ swig -c++ -perl example.i
-$ CC -c example.cxx
-$ CC -c example_wrap.cxx -I/usr/lib/perl/5.14/i386-linux/CORE
+$ CC -Kpic -c example.cxx
+$ CC -Kpic -c example_wrap.cxx -I/usr/lib/perl/5.14/i386-linux/CORE
$ CC -shared example.o example_wrap.o -o example.so <B>-lCrun</B>
</PRE>
</DIV>
wrapper, you will have to find the macro that conflicts and add an
#undef into the .i file. Please report any conflicting macros you find
to <A href="http://www.swig.org/mail.html">swig-user mailing list</A>.</P>
-<H3><A name="Perl5_nn10"></A>31.2.7 Compiling for 64-bit platforms</H3>
+<H3><A name="Perl5_nn10">33.2.7 Compiling for 64-bit platforms</A></H3>
<P> On platforms that support 64-bit applications (Solaris, Irix, etc.),
special care is required when building extension modules. On these
machines, 64-bit applications are compiled and linked using a different
that software. This may prevent the use of 64-bit extensions. It may
also introduce problems on platforms that support more than one linking
standard (e.g., -o32 and -n32 on Irix).</P>
-<H2><A name="Perl5_nn11"></A>31.3 Building Perl Extensions under Windows</H2>
+<H2><A name="Perl5_nn11">33.3 Building Perl Extensions under Windows</A></H2>
<P> Building a SWIG extension to Perl under Windows is roughly similar
to the process used with Unix. Normally, you will want to produce a DLL
that can be loaded into the Perl interpreter. This section assumes you
are using SWIG with Microsoft Visual C++ although the procedure may be
similar with other compilers.</P>
-<H3><A name="Perl5_nn12"></A>31.3.1 Running SWIG from Developer Studio</H3>
+<H3><A name="Perl5_nn12">33.3.1 Running SWIG from Developer Studio</A></H3>
<P> If you are developing your application within Microsoft developer
studio, SWIG can be invoked as a custom build option. The process
roughly requires these steps:</P>
</PRE>
</DIV>
-<H3><A name="Perl5_nn13"></A>31.3.2 Using other compilers</H3>
+<H3><A name="Perl5_nn13">33.3.2 Using other compilers</A></H3>
<P> SWIG is known to work with Cygwin and may work with other compilers
on Windows. For general hints and suggestions refer to the <A href="#Windows">
Windows</A> chapter.</P>
-<H2><A name="Perl5_nn14"></A>31.4 The low-level interface</H2>
+<H2><A name="Perl5_nn14">33.4 The low-level interface</A></H2>
<P> At its core, the Perl module uses a simple low-level interface to C
function, variables, constants, and classes. This low-level interface
can be used to control your application. However, it is also used to
construct more user-friendly proxy classes as described in the next
section.</P>
-<H3><A name="Perl5_nn15"></A>31.4.1 Functions</H3>
+<H3><A name="Perl5_nn15">33.4.1 Functions</A></H3>
<P> C functions are converted into new Perl built-in commands (or
subroutines). For example:</P>
<DIV class="targetlang">
$a = &example::fact(2);
</PRE>
</DIV>
-<H3><A name="Perl5_nn16"></A>31.4.2 Global variables</H3>
+<H3><A name="Perl5_nn16">33.4.2 Global variables</A></H3>
<P> Global variables are handled using Perl's magic variable mechanism.
SWIG generates a pair of functions that intercept read/write operations
and attaches them to a Perl variable with the same name as the C global
extern char *path; // Declared later in the input
</PRE>
</DIV>
-<H3><A name="Perl5_nn17"></A>31.4.3 Constants</H3>
+<H3><A name="Perl5_nn17">33.4.3 Constants</A></H3>
<P> By default, constants are wrapped as read-only Perl variables. For
example:</P>
<DIV class="code">
print example::FOO,"\n";
</PRE>
</DIV>
-<H3><A name="Perl5_nn18"></A>31.4.4 Pointers</H3>
+<H3><A name="Perl5_nn18">33.4.4 Pointers</A></H3>
<P> SWIG represents pointers as blessed references. A blessed reference
is the same as a Perl reference except that it has additional
information attached to it indicating what kind of reference it is.
<DIV class="targetlang">
<PRE>
if (defined($ptr)) {
- print "Not a NULL pointer.";
+ print "Not a NULL pointer.";
} else {
- print "Is a NULL pointer.";
+ print "Is a NULL pointer.";
}
</PRE>
<DIV class="targetlang">
<PRE>
if ($$a == $$b) {
- print "a and b point to the same thing in C";
+ print "a and b point to the same thing in C";
} else {
- print "a and b point to different objects.";
+ print "a and b point to different objects.";
}
</PRE>
preserve the same pointer naming conventions as XS and <TT>xsubpp</TT>.
Given the advancement of the SWIG typesystem and the growing
differences between SWIG and XS, this is no longer supported.</P>
-<H3><A name="Perl5_nn19"></A>31.4.5 Structures</H3>
+<H3><A name="Perl5_nn19">33.4.5 Structures</A></H3>
<P> Access to the contents of a structure are provided through a set of
low-level accessor functions as described in the "SWIG Basics" chapter.
For example,</P>
<DIV class="code">
<PRE>
struct Vector {
- double x,y,z;
+ double x,y,z;
};
</PRE>
</DIV>
}
</PRE>
</DIV>
-<H3><A name="Perl5_nn20"></A>31.4.6 C++ classes</H3>
+<H3><A name="Perl5_nn20">33.4.6 C++ classes</A></H3>
<P> C++ classes are wrapped by building a set of low level accessor
functions. Consider the following class:</P>
<DIV class="code">
fairly primitive, it provides direct access to C++ objects. A higher
level interface using Perl proxy classes can be built using these
low-level accessors. This is described shortly.</P>
-<H3><A name="Perl5_nn21"></A>31.4.7 C++ classes and type-checking</H3>
+<H3><A name="Perl5_nn21">33.4.7 C++ classes and type-checking</A></H3>
<P> The SWIG type-checker is fully aware of C++ inheritance. Therefore,
if you have classes like this</P>
<DIV class="code">
pointer to any class derived from <TT>Foo</TT>. If necessary, the
type-checker also adjusts the value of the pointer (as is necessary
when multiple inheritance is used).</P>
-<H3><A name="Perl5_nn22"></A>31.4.8 C++ overloaded functions</H3>
+<H3><A name="Perl5_nn22">33.4.8 C++ overloaded functions</A></H3>
<P> If you have a C++ program with overloaded functions or methods, you
will need to disambiguate those methods using <TT>%rename</TT>. For
example:</P>
</PRE>
</DIV>
<P> Please refer to the "SWIG Basics" chapter for more information.</P>
-<H3><A name="Perl5_nn23"></A>31.4.9 Operators</H3>
+<H3><A name="Perl5_nn23">33.4.9 Operators</A></H3>
<P> As of version 1.3.27 SWIG automatically renames the most common C++
operators, and maps them into the perl module with the proper 'use
overload ...' so you don't need to do any work.</P>
<LI>operator and</LI>
<LI>operator or</LI>
</UL>
-<H3><A name="Perl5_nn24"></A>31.4.10 Modules and packages</H3>
+<H3><A name="Perl5_nn24">33.4.10 Modules and packages</A></H3>
<P> When you create a SWIG extension, everything gets placed into a
single Perl module. The name of the module is determined by the <TT>
%module</TT> directive. To use the module, do the following:</P>
print Foo::fact(4),"\n"; # Call a function in package FooBar
</pre></div>
-->
-<H2><A name="Perl5_nn25"></A>31.5 Input and output parameters</H2>
+<H2><A name="Perl5_nn25">33.5 Input and output parameters</A></H2>
<P> A common problem in some C programs is handling parameters passed as
simple pointers. For example:</P>
<DIV class="code">
</DIV>
<P><B> Note:</B> The <TT>REFERENCE</TT> feature is only currently
supported for numeric types (integers and floating point).</P>
-<H2><A name="Perl5_nn26"></A>31.6 Exception handling</H2>
+<H2><A name="Perl5_nn26">33.6 Exception handling</A></H2>
<P> The SWIG <TT>%exception</TT> directive can be used to create a
user-definable exception handler for converting exceptions in your
C/C++ program into Perl exceptions. The chapter on customization
<P> This is still supported, but it is deprecated. The newer <TT>
%exception</TT> directive provides the same functionality, but it has
additional capabilities that make it more powerful.</P>
-<H2><A name="Perl5_nn27"></A>31.7 Remapping datatypes with typemaps</H2>
+<H2><A name="Perl5_nn27">33.7 Remapping datatypes with typemaps</A></H2>
<P> This section describes how you can modify SWIG's default wrapping
behavior for various C/C++ datatypes using the <TT>%typemap</TT>
directive. This is an advanced topic that assumes familiarity with the
a required part of using SWIG---the default wrapping behavior is enough
in most cases. Typemaps are only used if you want to change some aspect
of the primitive C-Perl interface.</P>
-<H3><A name="Perl5_nn28"></A>31.7.1 A simple typemap example</H3>
+<H3><A name="Perl5_nn28">33.7.1 A simple typemap example</A></H3>
<P> A typemap is nothing more than a code generation rule that is
attached to a specific C datatype. For example, to convert integers
from Perl to C, you might define a typemap like this:</P>
%module example
%typemap(in) int {
- $1 = (int) SvIV($input);
- printf("Received an integer : %d\n", $1);
+ $1 = (int) SvIV($input);
+ printf("Received an integer : %d\n", $1);
}
...
%inline %{
<DIV class="targetlang">
<PRE>
%typemap(in) int n {
- $1 = (int) SvIV($input);
- printf("n = %d\n",$1);
+ $1 = (int) SvIV($input);
+ printf("n = %d\n",$1);
}
%inline %{
typedef int Integer;
>>>
</PRE>
</DIV>
-<H3><A name="Perl5_nn29"></A>31.7.2 Perl5 typemaps</H3>
+<H3><A name="Perl5_nn29">33.7.2 Perl5 typemaps</A></H3>
<P> The previous section illustrated an "in" typemap for converting Perl
objects to C. A variety of different typemap methods are defined by the
Perl module. For example, to convert a C integer back into a Perl
<DIV class="indent"> Return of C++ member data (all languages).</DIV>
<P> <TT>%typemap(check)</TT></P>
<DIV class="indent"> Check value of input parameter.</DIV>
-<H3><A name="Perl5_nn30"></A>31.7.3 Typemap variables</H3>
+<H3><A name="Perl5_nn30">33.7.3 Typemap variables</A></H3>
<P> Within typemap code, a number of special variables prefaced with a <TT>
$</TT> may appear. A full list of variables can be found in the "<A href="#Typemaps">
Typemaps</A>" chapter. This is a list of the most common variables:</P>
<P> <TT>$symname</TT></P>
<DIV class="indent"> The Perl name of the wrapper function being
created.</DIV>
-<H3><A name="Perl5_nn31"></A>31.7.4 Useful functions</H3>
+<H3><A name="Perl5_nn31">33.7.4 Useful functions</A></H3>
<P> When writing typemaps, it is necessary to work directly with Perl5
objects. This, unfortunately, can be a daunting task. Consult the
"perlguts" man-page for all of the really ugly details. A short summary
int sv_isa(SV *, char *0;
</PRE>
</DIV>
-<H2><A name="Perl5_nn32"></A>31.8 Typemap Examples</H2>
+<H2><A name="Perl5_nn32">33.8 Typemap Examples</A></H2>
<P> This section includes a few examples of typemaps. For more examples,
you might look at the files "<TT>perl5.swg</TT>" and "<TT>typemaps.i</TT>
" in the SWIG library.</P>
-<H3><A name="Perl5_nn33"></A>31.8.1 Converting a Perl5 array to a char
- **</H3>
+<H3><A name="Perl5_nn33">33.8.1 Converting a Perl5 array to a char **</A>
+</H3>
<P> A common problem in many C programs is the processing of command
line arguments, which are usually passed in an array of NULL terminated
strings. The following SWIG interface file allows a Perl5 array
// This tells SWIG to treat char ** as a special case
%typemap(in) char ** {
- AV *tempav;
- I32 len;
- int i;
- SV **tv;
- if (!SvROK($input))
- croak("Argument $argnum is not a reference.");
- if (SvTYPE(SvRV($input)) != SVt_PVAV)
- croak("Argument $argnum is not an array.");
- tempav = (AV*)SvRV($input);
- len = av_len(tempav);
- $1 = (char **) malloc((len+2)*sizeof(char *));
- for (i = 0; i <= len; i++) {
- tv = av_fetch(tempav, i, 0);
- $1[i] = (char *) SvPV(*tv,PL_na);
- }
- $1[i] = NULL;
+ AV *tempav;
+ I32 len;
+ int i;
+ SV **tv;
+ if (!SvROK($input))
+ croak("Argument $argnum is not a reference.");
+ if (SvTYPE(SvRV($input)) != SVt_PVAV)
+ croak("Argument $argnum is not an array.");
+ tempav = (AV*)SvRV($input);
+ len = av_len(tempav);
+ $1 = (char **) malloc((len+2)*sizeof(char *));
+ for (i = 0; i <= len; i++) {
+ tv = av_fetch(tempav, i, 0);
+ $1[i] = (char *) SvPV(*tv,PL_na);
+ }
+ $1[i] = NULL;
};
// This cleans up the char ** array after the function call
%typemap(freearg) char ** {
- free($1);
+ free($1);
}
// Creates a new Perl array and places a NULL-terminated char ** into it
%typemap(out) char ** {
- AV *myav;
- SV **svs;
- int i = 0,len = 0;
- /* Figure out how many elements we have */
- while ($1[len])
- len++;
- svs = (SV **) malloc(len*sizeof(SV *));
- for (i = 0; i < len ; i++) {
- svs[i] = sv_newmortal();
- sv_setpv((SV*)svs[i],$1[i]);
- };
- myav = av_make(len,svs);
- free(svs);
- $result = newRV_noinc((SV*)myav);
- sv_2mortal($result);
- argvi++;
+ AV *myav;
+ SV **svs;
+ int i = 0,len = 0;
+ /* Figure out how many elements we have */
+ while ($1[len])
+ len++;
+ svs = (SV **) malloc(len*sizeof(SV *));
+ for (i = 0; i < len ; i++) {
+ svs[i] = sv_newmortal();
+ sv_setpv((SV*)svs[i],$1[i]);
+ };
+ myav = av_make(len,svs);
+ free(svs);
+ $result = newRV_noinc((SV*)myav);
+ sv_2mortal($result);
+ argvi++;
}
// Now a few test functions
print @$b,"\n"; # Print it out
</PRE>
</DIV>
-<H3><A name="Perl5_nn34"></A>31.8.2 Return values</H3>
+<H3><A name="Perl5_nn34">33.8.2 Return values</A></H3>
<P> Return values are placed on the argument stack of each wrapper
function. The current value of the argument stack pointer is contained
in a variable <TT>argvi</TT>. Whenever a new output value is added, it
<DIV class="code">
<PRE>
%typemap(argout) int *OUTPUT {
- if (argvi >= items) {
- EXTEND(sp,1); /* Extend the stack by 1 object */
- }
- $result = sv_newmortal();
- sv_setiv($target,(IV) *($1));
- argvi++;
+ if (argvi >= items) {
+ EXTEND(sp,1); /* Extend the stack by 1 object */
+ }
+ $result = sv_newmortal();
+ sv_setiv($target,(IV) *($1));
+ argvi++;
}
</PRE>
</DIV>
-<H3><A name="Perl5_nn35"></A>31.8.3 Returning values from arguments</H3>
+<H3><A name="Perl5_nn35">33.8.3 Returning values from arguments</A></H3>
<P> Sometimes it is desirable for a function to return a value in one of
its arguments. This example describes the implementation of the <TT>
OUTPUT</TT> typemap.</P>
// an output value.
%typemap(argout) double *OUTPUT {
- $result = sv_newmortal();
- sv_setnv($result, *$input);
- argvi++; /* Increment return count -- important! */
+ $result = sv_newmortal();
+ sv_setnv($result, *$input);
+ argvi++; /* Increment return count -- important! */
}
// We don't care what the input value is. Ignore, but set to a temporary variable
%typemap(in,numinputs=0) double *OUTPUT(double junk) {
- $1 = &junk;
+ $1 = &junk;
}
// Now a function to test it
%{
/* Returns the first two input arguments */
int multout(double a, double b, double *out1, double *out2) {
- *out1 = a;
- *out2 = b;
- return 0;
+ *out1 = a;
+ *out2 = b;
+ return 0;
};
%}
($x,$y) = multout(7,13);
</PRE>
</DIV>
-<H3><A name="Perl5_nn36"></A>31.8.4 Accessing array structure members</H3>
+<H3><A name="Perl5_nn36">33.8.4 Accessing array structure members</A></H3>
<P> Consider the following data structure:</P>
<DIV class="code">
<PRE>
the "in" typemap in the previous section would be used to convert an <TT>
int[]</TT> array to C whereas the "memberin" typemap would be used to
copy the converted array into a C data structure.</P>
-<H3><A name="Perl5_nn37"></A>31.8.5 Turning Perl references into C
- pointers</H3>
+<H3><A name="Perl5_nn37">33.8.5 Turning Perl references into C pointers</A>
+</H3>
<P> A frequent confusion on the SWIG mailing list is errors caused by
the mixing of Perl references and C pointers. For example, suppose you
have a C function that modifies its arguments like this:</P>
<DIV class="code">
<PRE>
void add(double a, double b, double *c) {
- *c = a + b;
+ *c = a + b;
}
</PRE>
</DIV>
</PRE>
</DIV>
-<H3><A name="Perl5_nn38"></A>31.8.6 Pointer handling</H3>
+<H3><A name="Perl5_nn38">33.8.6 Pointer handling</A></H3>
<P> Occasionally, it might be necessary to convert pointer values that
have been stored using the SWIG typed-pointer representation. To
convert a pointer from Perl to C, the following function is used:</P>
}
</PRE>
</DIV>
-<H2><A name="Perl5_nn39"></A>31.9 Proxy classes</H2>
+<H2><A name="Perl5_nn39">33.9 Proxy classes</A></H2>
<P><B> Out of date. Needs update.</B></P>
<P> Using the low-level procedural interface, SWIG can also construct a
high-level object oriented interface to C structures and C++ classes.
This is done by constructing a Perl proxy class (also known as a shadow
class) that provides an OO wrapper to the underlying code. This section
describes the implementation details of the proxy interface.</P>
-<H3><A name="Perl5_nn40"></A>31.9.1 Preliminaries</H3>
+<H3><A name="Perl5_nn40">33.9.1 Preliminaries</A></H3>
<P> Proxy classes, are generated by default. If you want to turn them
off, use the <TT>-noproxy</TT> command line option. For example:</P>
<DIV class="code">
original module, SWIG creates a collection of high-level Perl wrappers.
In your scripts, you will use these high level wrappers. The wrappers,
in turn, interact with the low-level procedural module.</P>
-<H3><A name="Perl5_nn41"></A>31.9.2 Structure and class wrappers</H3>
+<H3><A name="Perl5_nn41">33.9.2 Structure and class wrappers</A></H3>
<P> Suppose you have the following SWIG interface file:</P>
<DIV class="code">
<PRE>
%module example
struct Vector {
- Vector(double x, double y, double z);
- ~Vector();
- double x,y,z;
+ Vector(double x, double y, double z);
+ ~Vector();
+ double x,y,z;
};
</PRE>
my $self = tied(%{$_[0]});
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- examplec::delete_Vector($self));
- delete $OWNER{$self};
+ examplec::delete_Vector($self));
+ delete $OWNER{$self};
+ }
}
sub FETCH {
# Assignment of all members
%$v = ( x=>3,
- y=>9,
- z=>-2);
+ y=>9,
+ z=>-2);
# Reading members
$x = $v->{x};
</PRE>
</DIV>
-<H3><A name="Perl5_nn42"></A>31.9.3 Object Ownership</H3>
+<H3><A name="Perl5_nn42">33.9.3 Object Ownership</A></H3>
<P> In order for proxy classes to work properly, it is necessary for
Perl to manage some mechanism of object ownership. Here's the crux of
the problem---suppose you had a function like this:</P>
<DIV class="code">
<PRE>
Vector *Vector_get(Vector *v, int index) {
- return &v[i];
+ return &v[i];
}
</PRE>
</DIV>
<DIV class="code">
<PRE>
Vector *new_Vector(double x, double y, double z) {
- Vector *v;
- v = new Vector(x,y,z); // Call C++ constructor
- return v;
+ Vector *v;
+ v = new Vector(x,y,z); // Call C++ constructor
+ return v;
}
</PRE>
</DIV>
<P> As always, a little care is in order. SWIG does not provide
reference counting, garbage collection, or advanced features one might
find in sophisticated languages.</P>
-<H3><A name="Perl5_nn43"></A>31.9.4 Nested Objects</H3>
+<H3><A name="Perl5_nn43">33.9.4 Nested Objects</A></H3>
<P> Suppose that we have a new object that looks like this:</P>
<DIV class="code">
<PRE>
struct Particle {
- Vector r;
- Vector v;
- Vector f;
- int type;
+ Vector r;
+ Vector v;
+ Vector f;
+ int type;
}
</PRE>
package Particle;
...
%BLESSEDMEMBERS = (
- r => `Vector',
- v => `Vector',
- f => `Vector',
+ r => `Vector',
+ v => `Vector',
+ f => `Vector',
);
</PRE>
%${$p->{v}} = ( x=>0, y=>0, z=>0);
</PRE>
</DIV>
-<H3><A name="Perl5_nn44"></A>31.9.5 Proxy Functions</H3>
+<H3><A name="Perl5_nn44">33.9.5 Proxy Functions</A></H3>
<P> When functions take arguments involving a complex object, it is
sometimes necessary to write a proxy function. For example:</P>
<DIV class="code">
</DIV>
<P> This function replaces the original function, but operates in an
identical manner.</P>
-<H3><A name="Perl5_nn45"></A>31.9.6 Inheritance</H3>
+<H3><A name="Perl5_nn45">33.9.6 Inheritance</A></H3>
<P> Simple C++ inheritance is handled using the Perl <TT>@ISA</TT> array
in each class package. For example, if you have the following interface
file:</P>
class Shape {
public:
- virtual double area() = 0;
- virtual double perimeter() = 0;
- void set_location(double x, double y);
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
+ void set_location(double x, double y);
};
class Circle : public Shape {
public:
- Circle(double radius);
- ~Circle();
- double area();
- double perimeter();
+ Circle(double radius);
+ ~Circle();
+ double area();
+ double perimeter();
};
class Square : public Shape {
public:
- Square(double size);
- ~Square();
- double area();
- double perimeter();
+ Square(double size);
+ ~Square();
+ double area();
+ double perimeter();
}
</PRE>
be forewarned that this is not a trivial problem. In particular,
inheritance of data members is extremely tricky (and I'm not even sure
if it really works).</P>
-<H3><A name="Perl5_nn46"></A>31.9.7 Modifying the proxy methods</H3>
+<H3><A name="Perl5_nn46">33.9.7 Modifying the proxy methods</A></H3>
<P> It is possible to override the SWIG generated proxy/shadow methods,
using <TT>%feature("shadow")</TT>. It works like all the other <A href="#Customization_features">
%feature directives</A>. Here is a simple example showing how to add
};
</PRE>
</DIV>
-<H2><A name="Perl5_nn47"></A>31.10 Adding additional Perl code</H2>
+<H2><A name="Perl5_nn47">33.10 Adding additional Perl code</A></H2>
<P> If writing support code in C isn't enough, it is also possible to
write code in Perl. This code gets inserted in to the <TT>.pm</TT> file
created by SWIG. One use of Perl code might be to supply a high-level
[0,0,0,1]];
set_transform($im, $a);
</PRE>
-</DIV><HR NOSHADE>
+</DIV>
+<H2><A name="Perl5_directors">33.11 Cross language polymorphism</A></H2>
+<P> Proxy classes provide a more natural, object-oriented way to access
+ extension classes. As described above, each proxy instance has an
+ associated C++ instance, and method calls to the proxy are passed to
+ the C++ instance transparently via C wrapper functions.</P>
+<P> This arrangement is asymmetric in the sense that no corresponding
+ mechanism exists to pass method calls down the inheritance chain from
+ C++ to Perl. In particular, if a C++ class has been extended in Perl
+ (by extending the proxy class), these extensions will not be visible
+ from C++ code. Virtual method calls from C++ are thus not able access
+ the lowest implementation in the inheritance chain.</P>
+<P> Changes have been made to SWIG to address this problem and make the
+ relationship between C++ classes and proxy classes more symmetric. To
+ achieve this goal, new classes called directors are introduced at the
+ bottom of the C++ inheritance chain. The job of the directors is to
+ route method calls correctly, either to C++ implementations higher in
+ the inheritance chain or to Perl implementations lower in the
+ inheritance chain. The upshot is that C++ classes can be extended in
+ Perl and from C++ these extensions look exactly like native C++
+ classes. Neither C++ code nor Perl code needs to know where a
+ particular method is implemented: the combination of proxy classes,
+ director classes, and C wrapper functions takes care of all the
+ cross-language method routing transparently.</P>
+<H3><A name="Perl5_nn48">33.11.1 Enabling directors</A></H3>
+<P> The director feature is disabled by default. To use directors you
+ must make two changes to the interface file. First, add the "directors"
+ option to the %module directive, like this:</P>
+<DIV class="code">
+<PRE>
+%module(directors="1") modulename
+</PRE>
+</DIV>
+<P> Without this option no director code will be generated. Second, you
+ must use the %feature("director") directive to tell SWIG which classes
+ and methods should get directors. The %feature directive can be applied
+ globally, to specific classes, and to specific methods, like this:</P>
+<DIV class="code">
+<PRE>
+// generate directors for all classes that have virtual methods
+%feature("director");
+
+// generate directors for all virtual methods in class Foo
+%feature("director") Foo;
+</PRE>
+</DIV>
+<P> You can use the %feature("nodirector") directive to turn off
+ directors for specific classes or methods. So for example,</P>
+<DIV class="code">
+<PRE>
+%feature("director") Foo;
+%feature("nodirector") Foo::bar;
+</PRE>
+</DIV>
+<P> will generate directors for all virtual methods of class Foo except
+ bar().</P>
+<P> Directors can also be generated implicitly through inheritance. In
+ the following, class Bar will get a director class that handles the
+ methods one() and two() (but not three()):</P>
+<DIV class="code">
+<PRE>
+%feature("director") Foo;
+class Foo {
+public:
+ Foo(int foo);
+ virtual void one();
+ virtual void two();
+};
-<!-- Hand crafted HTML -->
-<H1><A name="Php"></A>32 SWIG and PHP</H1>
+class Bar: public Foo {
+public:
+ virtual void three();
+};
+</PRE>
+</DIV>
+<P> then at the Perl side you can define</P>
+<DIV class="targetlang">
+<PRE>
+use mymodule;
+
+package MyFoo;
+use base 'mymodule::Foo';
+
+sub one {
+ print "one from Perl\n";
+}
+</PRE>
+</DIV>
+<H3><A name="Perl5_nn49">33.11.2 Director classes</A></H3>
+<P> For each class that has directors enabled, SWIG generates a new
+ class that derives from both the class in question and a special <TT>
+Swig::Director</TT> class. These new classes, referred to as director
+ classes, can be loosely thought of as the C++ equivalent of the Perl
+ proxy classes. The director classes store a pointer to their underlying
+ Perl object and handle various issues related to object ownership.</P>
+<P> For simplicity let's ignore the <TT>Swig::Director</TT> class and
+ refer to the original C++ class as the director's base class. By
+ default, a director class extends all virtual methods in the
+ inheritance chain of its base class (see the preceding section for how
+ to modify this behavior). Thus all virtual method calls, whether they
+ originate in C++ or in Perl via proxy classes, eventually end up in at
+ the implementation in the director class. The job of the director
+ methods is to route these method calls to the appropriate place in the
+ inheritance chain. By "appropriate place" we mean the method that would
+ have been called if the C++ base class and its extensions in Perl were
+ seamlessly integrated. That seamless integration is exactly what the
+ director classes provide, transparently skipping over all the messy
+ extension API glue that binds the two languages together.</P>
+<P> In reality, the "appropriate place" is one of only two
+ possibilities: C++ or Perl. Once this decision is made, the rest is
+ fairly easy. If the correct implementation is in C++, then the lowest
+ implementation of the method in the C++ inheritance chain is called
+ explicitly. If the correct implementation is in Perl, the Perl API is
+ used to call the method of the underlying Perl object (after which the
+ usual virtual method resolution in Perl automatically finds the right
+ implementation).</P>
+<P> Now how does the director decide which language should handle the
+ method call? The basic rule is to handle the method in Perl, unless
+ there's a good reason not to. The reason for this is simple: Perl has
+ the most "extended" implementation of the method. This assertion is
+ guaranteed, since at a minimum the Perl proxy class implements the
+ method. If the method in question has been extended by a class derived
+ from the proxy class, that extended implementation will execute exactly
+ as it should. If not, the proxy class will route the method call into a
+ C wrapper function, expecting that the method will be resolved in C++.
+ The wrapper will call the virtual method of the C++ instance, and since
+ the director extends this the call will end up right back in the
+ director method. Now comes the "good reason not to" part. If the
+ director method were to blindly call the Perl method again, it would
+ get stuck in an infinite loop. We avoid this situation by adding
+ special code to the C wrapper function that tells the director method
+ to not do this. The C wrapper function compares the pointer to the Perl
+ object that called the wrapper function to the pointer stored by the
+ director. If these are the same, then the C wrapper function tells the
+ director to resolve the method by calling up the C++ inheritance chain,
+ preventing an infinite loop.</P>
+<P> One more point needs to be made about the relationship between
+ director classes and proxy classes. When a proxy class instance is
+ created in Perl, SWIG creates an instance of the original C++ class.
+ This is exactly what happens without directors and is true even if
+ directors are enabled for the particular class in question. When a
+ class<I> derived</I> from a proxy class is created, however, SWIG then
+ creates an instance of the corresponding C++ director class. The reason
+ for this difference is that user-defined subclasses may override or
+ extend methods of the original class, so the director class is needed
+ to route calls to these methods correctly. For unmodified proxy
+ classes, all methods are ultimately implemented in C++ so there is no
+ need for the extra overhead involved with routing the calls through
+ Perl.</P>
+<H3><A name="Perl5_nn50">33.11.3 Ownership and object destruction</A></H3>
+<P> Memory management issues are slightly more complicated with
+ directors than for proxy classes alone. Perl instances hold a pointer
+ to the associated C++ director object, and the director in turn holds a
+ pointer back to a Perl object. By default, proxy classes own their C++
+ director object and take care of deleting it when they are garbage
+ collected.</P>
+<P> This relationship can be reversed by calling the special <TT>
+DISOWN()</TT> method of the proxy class. After calling this method the
+ director class increments the reference count of the Perl object. When
+ the director class is deleted it decrements the reference count.
+ Assuming no outstanding references to the Perl object remain, the Perl
+ object will be destroyed at the same time. This is a good thing, since
+ directors and proxies refer to each other and so must be created and
+ destroyed together. Destroying one without destroying the other will
+ likely cause your program to segfault.</P>
+<P> Also note that due to the proxy implementation, the <TT>DESTROY()</TT>
+ method on directors can be called for several reasons, many of which
+ have little to do with the teardown of an object instance. To help
+ disambiguate this, a second argument is added to the <TT>DESTROY()</TT>
+ call when a C++ director object is being released. So, to avoid running
+ your clean-up code when an object is not really going away, or after it
+ has already been reclaimed, it is suggested that custom destructors in
+ Perl subclasses looks something like:</P>
+<DIV class="targetlang">
+<PRE>
+sub DESTROY {
+ my($self, $final) = @_;
+ if($final) {
+ # real teardown code
+ }
+ shift->SUPER::DESTROY(@_);
+}
+</PRE>
+</DIV>
+<H3><A name="Perl5_nn51">33.11.4 Exception unrolling</A></H3>
+<P> With directors routing method calls to Perl, and proxies routing
+ them to C++, the handling of exceptions is an important concern. By
+ default, the directors ignore exceptions that occur during method calls
+ that are resolved in Perl. To handle such exceptions correctly, it is
+ necessary to temporarily translate them into C++ exceptions. This can
+ be done with the %feature("director:except") directive. The following
+ code should suffice in most cases:</P>
+<DIV class="code">
+<PRE>
+%feature("director:except") {
+ if ($error != NULL) {
+ throw Swig::DirectorMethodException();
+ }
+}
+</PRE>
+</DIV>
+<P> This code will check the Perl error state after each method call
+ from a director into Perl, and throw a C++ exception if an error
+ occurred. This exception can be caught in C++ to implement an error
+ handler.</P>
+<P> It may be the case that a method call originates in Perl, travels up
+ to C++ through a proxy class, and then back into Perl via a director
+ method. If an exception occurs in Perl at this point, it would be nice
+ for that exception to find its way back to the original caller. This
+ can be done by combining a normal %exception directive with the <TT>
+director:except</TT> handler shown above. Here is an example of a
+ suitable exception handler:</P>
+<DIV class="code">
+<PRE>
+%exception {
+ try { $action }
+ catch (Swig::DirectorException &e) { SWIG_fail; }
+}
+</PRE>
+</DIV>
+<P> The class Swig::DirectorException used in this example is actually a
+ base class of Swig::DirectorMethodException, so it will trap this
+ exception. Because the Perl error state is still set when
+ Swig::DirectorMethodException is thrown, Perl will register the
+ exception as soon as the C wrapper function returns.</P>
+<H3><A name="Perl5_nn52">33.11.5 Overhead and code bloat</A></H3>
+<P> Enabling directors for a class will generate a new director method
+ for every virtual method in the class' inheritance chain. This alone
+ can generate a lot of code bloat for large hierarchies. Method
+ arguments that require complex conversions to and from target language
+ types can result in large director methods. For this reason it is
+ recommended that you selectively enable directors only for specific
+ classes that are likely to be extended in Perl and used in C++.</P>
+<P> Compared to classes that do not use directors, the call routing in
+ the director methods does add some overhead. In particular, at least
+ one dynamic cast and one extra function call occurs per method call
+ from Perl. Relative to the speed of Perl execution this is probably
+ completely negligible. For worst case routing, a method call that
+ ultimately resolves in C++ may take one extra detour through Perl in
+ order to ensure that the method does not have an extended Perl
+ implementation. This could result in a noticeable overhead in some
+ cases.</P>
+<P> Although directors make it natural to mix native C++ objects with
+ Perl objects (as director objects) via a common base class pointer, one
+ should be aware of the obvious fact that method calls to Perl objects
+ will be much slower than calls to C++ objects. This situation can be
+ optimized by selectively enabling director methods (using the %feature
+ directive) for only those methods that are likely to be extended in
+ Perl.</P>
+<H3><A name="Perl5_nn53">33.11.6 Typemaps</A></H3>
+<P> Typemaps for input and output of most of the basic types from
+ director classes have been written. These are roughly the reverse of
+ the usual input and output typemaps used by the wrapper code. The
+ typemap operation names are 'directorin', 'directorout', and
+ 'directorargout'. The director code does not currently use any of the
+ other kinds of typemaps. It is not clear at this point which kinds are
+ appropriate and need to be supported.</P>
+<HR NOSHADE>
+<H1><A name="Php">34 SWIG and PHP</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<LI><A href="#Php_nn2_5">Pointers and References</A></LI>
<LI><A href="#Php_nn2_6">Structures and C++ classes</A>
<UL>
-<LI><A href="#Php_nn2_6_1">Using <TT>-noproxy</TT></A></LI>
+<LI><A href="#Php_nn2_6_1">Using -noproxy</A></LI>
<LI><A href="#Php_nn2_6_2">Constructors and Destructors</A></LI>
<LI><A href="#Php_nn2_6_3">Static Member Variables</A></LI>
<LI><A href="#Php_nn2_6_4">Static Member Functions</A></LI>
+<LI><A href="#Php_nn2_6_5">Specifying Implemented Interfaces</A></LI>
</UL>
</LI>
<LI><A href="#Php_nn2_7">PHP Pragmas, Startup and Shutdown code</A></LI>
. To use the built PHP module you will need either the php binary or the
Apache php module. If you want to build your extension into php
directly, you will need the complete PHP source tree available.</P>
-<H2><A name="Php_nn1"></A>32.1 Generating PHP Extensions</H2>
+<H2><A name="Php_nn1">34.1 Generating PHP Extensions</A></H2>
<P> To build a PHP extension, run swig using the <TT>-php</TT> option as
follows:</P>
<DIV class="code">
more detail in <A href="#Php_nn2_6">section 27.2.6</A>.</P>
<P> The usual (and recommended) way is to build the extension as a
separate dynamically loaded module (which is supported by all modern
- operating systems). You can then specify that this be loaded
- automatically in <TT>php.ini</TT> or load it explicitly for any script
- which needs it.</P>
+ operating systems).</P>
<P> It is also possible to rebuild PHP from source so that your module
is statically linked into the php executable/library. This is a lot
more work, and also requires a full rebuild of PHP to update your
module, and it doesn't play nicely with package system. We don't
recommend this approach, or provide explicit support for it.</P>
-<H3><A name="Php_nn1_1"></A>32.1.1 Building a loadable extension</H3>
+<H3><A name="Php_nn1_1">34.1.1 Building a loadable extension</A></H3>
<P> To build your module as a dynamically loadable extension, use
compilation commands like these (if you aren't using GCC, the commands
will be different, and there may be some variation between platforms -
these commands should at least work for Linux though):</P>
<DIV class="code">
<PRE>
- gcc `php-config --includes` -fpic -c example_wrap.c
- gcc -shared example_wrap.o -o example.so
+ gcc `php-config --includes` -fpic -c example_wrap.c example.c
+ gcc -shared example_wrap.o example.o -o example.so
</PRE>
</DIV>
-<H3><A name="Php_nn1_3"></A>32.1.2 Using PHP Extensions</H3>
-<P> To test the extension from a PHP script, you need to load it first.
- You can load it for every script by adding this line to the <TT>[PHP]</TT>
+<H3><A name="Php_nn1_3">34.1.2 Using PHP Extensions</A></H3>
+<P> To test the extension from a PHP script, you first need to tell PHP
+ to load it. To do this, add a line like this to the <TT>[PHP]</TT>
section of <TT>php.ini</TT>:</P>
<DIV class="code">
<PRE>
- extension=/path/to/modulename.so
+ extension=/path/to/modulename.so
</PRE>
</DIV>
-<P> Alternatively, you can load it explicitly only for scripts which
- need it by adding this line to the start of each such PHP script::</P>
+<P> If the module is in PHP's default extension directory, you can omit
+ the path.</P>
+<P> For some SAPIs (for example, the CLI SAPI) you can instead use the <A
+href="http://php.net/manual/en/function.dl.php">dl() function</A> to
+ load an extension at run time, by adding a like like this to the start
+ of each PHP script which uses your extension:</P>
<DIV class="code">
<PRE>
- dl("/path/to/modulename.so"); // Load the module
+ dl("/path/to/modulename.so"); // Load the module
</PRE>
</DIV>
-<P> SWIG also generates a php module, which attempts to do the <TT>dl()</TT>
- call for you:</P>
+<P> But note that this doesn't work when running PHP through a webserver
+ in PHP5.3 and later - you'll need to use <TT>extension</TT> in <TT>
+php.ini</TT> as described above.</P>
+<P> The PHP module which SWIG generates will also attempt to do the <TT>
+dl()</TT> call for you if the extension isn't already loaded:</P>
<DIV class="code">
<PRE>
- include("example.php");
+ include("example.php");
</PRE>
</DIV>
-<H2><A name="Php_nn2"></A>32.2 Basic PHP interface</H2>
+<P> This PHP module also defines the PHP classes for the wrapped API, so
+ you'll almost certainly want to include it anyway.</P>
+<H2><A name="Php_nn2">34.2 Basic PHP interface</A></H2>
<P> It is important to understand that PHP uses a single global
namespace into which all symbols from extension modules are loaded. It
is quite possible for names of symbols in one extension module to clash
with other symbols unless care is taken to <TT>%rename</TT> them. At
present SWIG doesn't have support for the namespace feature added in
PHP 5.3.</P>
-<H3><A name="Php_nn2_1"></A>32.2.1 Constants</H3>
+<H3><A name="Php_nn2_1">34.2.1 Constants</A></H3>
<P> These work in much the same way as in C/C++. Constants can be
defined by using either the normal C pre-processor declarations, or the
<TT>%constant</TT> SWIG directive. These will then be available from
</DIV>
<P> There's one peculiarity of how constants work in PHP which it is
useful to note (this is not specific to SWIG though) - if you try to
- use an undeclared constant, PHP will issue a warning and then expand
- the constant to a string version of the constant's name. The warning
- will often be missed though as if you're using PHP in a webserver, it
+ use an undeclared constant, PHP will emit a notice and then expand the
+ constant to a string version of the constant's name. Unfortunately it
+ is easy to miss the notice if you're using PHP in a webserver, as it
will probably end up in error.log or similar.</P>
<P> For example,</P>
<DIV class="code">
<PRE>
%module example
-#define EASY_TO_MISPELL 0
+#define EASY_TO_MISPELL 0
</PRE>
</DIV>
<P> accessed incorrectly in PHP,</P>
include("example.php");
if(EASY_TO_MISPEL) {
- ....
+ ...
} else {
- ....
+ ...
}
</PRE>
<P> The mis-spelled constant will become the string 'EASY_TO_MISPEL',
which is treated as true by the if test, when the value of the intended
constant would be treated as false!</P>
-<H3><A name="Php_nn2_2"></A>32.2.2 Global Variables</H3>
+<H3><A name="Php_nn2_2">34.2.2 Global Variables</A></H3>
<P> Because PHP does not provide a mechanism to intercept access and
assignment of global variables, global variables are supported through
the use of automatically generated accessor functions.</P>
<PRE>
include("example.php");
print seki_get();
-seki_set( seki_get() * 2); # The C variable is now 4.
+seki_set( seki_get() * 2); # The C variable is now 4.
print seki_get();
</PRE>
</DIV>
method will result in a php fatal error because the function is
undefined.</P>
<P> At this time SWIG does not support custom accessor methods.</P>
-<H3><A name="Php_nn2_3"></A>32.2.3 Functions</H3>
+<H3><A name="Php_nn2_3">34.2.3 Functions</A></H3>
<P> C functions are converted into PHP functions. Default/optional
arguments are also allowed. An interface file like this :</P>
<DIV class="code">
include("example.php");
$a = foo(2);
$b = bar(3.5, -1.5);
-$c = bar(3.5); # Use default argument for 2nd parameter
+$c = bar(3.5); # Use default argument for 2nd parameter
</PRE>
</DIV>
print $s; # The value of $s was not changed.
</pre></div>
-->
-<H3><A name="Php_nn2_4"></A>32.2.4 Overloading</H3>
+<H3><A name="Php_nn2_4">34.2.4 Overloading</A></H3>
<P> Although PHP does not support overloading functions natively, swig
will generate dispatch functions which will use <TT>%typecheck</TT>
typemaps to allow overloading. This dispatch function's operation and
taking the integer argument.
</p>
-->
-<H3><A name="Php_nn2_5"></A>32.2.5 Pointers and References</H3>
+<H3><A name="Php_nn2_5">34.2.5 Pointers and References</A></H3>
<P> Pointers to C/C++ objects are represented as PHP resources, rather
like MySQL connection handles.</P>
<P> There are multiple ways to wrap pointers to simple types. Given the
<P> Because PHP has a native concept of reference, it may seem more
natural to the PHP developer to use references to pass pointers. To
enable this, one needs to include<B> phppointers.i</B> which defines
- the named typemap REFERENCE.</P>
-<P> However, this relies on call-time pass-by-reference, which has been
- deprecated in PHP for some time, and was finally<B> removed in PHP 5.4</B>
-. So you should avoid creating new wrappers which rely on this approach.</P>
+ the named typemap REF.</P>
+<P> Prior to SWIG 3.0, the REF typemaps relied on PHP's call-time
+ pass-by-reference, which was deprecated in PHP 5.3 and removed in PHP
+ 5.4. So if you use these REF typemaps, you should ensure that SWIG≥3.0
+ is used to generate wrappers from your interface file.</P>
+<P> In case you write your own typemaps, SWIG supports an attribute
+ called <TT>byref</TT>: if you set that, then SWIG will make sure that
+ the generated wrapper function will want the input parameter as a
+ reference.</P>
<DIV class="code">
<PRE>
%module example
$in1 = 3;
$in2 = 5;
$result = 0;
-add(&$in1,&$in2,&$result);
+add($in1,$in2,$result);
echo "The sum $in1 + $in2 = $result\n";
?>
is sometimes required in C libraries. A NULL pointer can be created in
PHP in a number of ways: by using <TT>unset</TT> on an existing
variable, or assigning <TT>NULL</TT> to a variable.</P>
-<H3><A name="Php_nn2_6"></A>32.2.6 Structures and C++ classes</H3>
+<H3><A name="Php_nn2_6">34.2.6 Structures and C++ classes</A></H3>
<P> SWIG defaults to wrapping C++ structs and classes with PHP classes -
this is done by generating a PHP wrapper script which defines proxy
classes which calls a set of flat functions which actually wrap the C++
class Vector {
public:
- double x,y,z;
- Vector();
- ~Vector();
- double magnitude();
+ double x,y,z;
+ Vector();
+ ~Vector();
+ double magnitude();
};
struct Complex {
</DIV>
<P> Member variables and methods are accessed using the <TT>-></TT>
operator.</P>
-<H4><A name="Php_nn2_6_1"></A>32.2.6.1 Using <TT>-noproxy</TT></H4>
+<H4><A name="Php_nn2_6_1">34.2.6.1 Using -noproxy</A></H4>
<P> The <TT>-noproxy</TT> option flattens the object structure and
generates collections of named functions (these are the functions which
the PHP5 class wrappers call). The above example results in the
Complex_im_get($obj);
</PRE>
</DIV>
-<H4><A name="Php_nn2_6_2"></A>32.2.6.2 Constructors and Destructors</H4>
+<H4><A name="Php_nn2_6_2">34.2.6.2 Constructors and Destructors</A></H4>
<P> The constructor is called when <TT>new Object()</TT> (or <TT>
new_Object()</TT> if using <TT>-noproxy</TT>) is used to create an
instance of the object. If multiple constructors are defined for an
the instance are reassigned or go out of scope. The destructor is not
available to be called manually. To force a destructor to be called the
programmer can either reassign the variable or call <TT>unset($v)</TT></P>
-<H4><A name="Php_nn2_6_3"></A>32.2.6.3 Static Member Variables</H4>
+<H4><A name="Php_nn2_6_3">34.2.6.3 Static Member Variables</A></H4>
<P> Static member variables in C++ are not wrapped as such in PHP as it
does not appear to be possible to intercept accesses to such variables.
Therefore, static member variables are wrapped using a class function
%module example
class Ko {
- static int threats;
+ static int threats;
};
</PRE>
</PRE>
</DIV>
-<H4><A name="Php_nn2_6_4"></A>32.2.6.4 Static Member Functions</H4>
+<H4><A name="Php_nn2_6_4">34.2.6.4 Static Member Functions</A></H4>
<P> Static member functions are supported in PHP using the <TT>
class::function()</TT> syntax. For example</P>
<DIV class="code">
Ko::threats();
</PRE>
</DIV>
-<H3><A name="Php_nn2_7"></A>32.2.7 PHP Pragmas, Startup and Shutdown
- code</H3>
+<H4><A name="Php_nn2_6_5">34.2.6.5 Specifying Implemented Interfaces</A></H4>
+<P> PHP supports the concept of abstract interfaces which a class can
+ implement. Since SWIG 3.0.3, you can tell SWIG that a wrapped class
+ (for example <CODE>MyIterator</CODE>) implements the <CODE>Iterator</CODE>
+ interface like so:</P>
+<DIV class="code">
+<PRE>
+%typemap("phpinterfaces") MyIterator "Iterator";
+</PRE>
+</DIV>
+<P> If there are multiple interfaces, just list them separated by
+ commas.</P>
+<H3><A name="Php_nn2_7">34.2.7 PHP Pragmas, Startup and Shutdown code</A>
+</H3>
<P> To place PHP code in the generated "example.php" file one can use
the<B> code</B> pragma. The code is inserted after loading the shared
object.</P>
<P> The <TT>%rinit</TT> and <TT>%rshutdown</TT> statements are very
similar but insert code into the request init (PHP_RINIT_FUNCTION) and
request shutdown (PHP_RSHUTDOWN_FUNCTION) code respectively.</P>
-<H2><A name="Php_nn3"></A>32.3 Cross language polymorphism</H2>
+<H2><A name="Php_nn3">34.3 Cross language polymorphism</A></H2>
<P> Proxy classes provide a more natural, object-oriented way to access
extension classes. As described above, each proxy instance has an
associated C++ instance, and method calls to the proxy are passed to
know where a particular method is implemented: the combination of proxy
classes, director classes, and C wrapper functions takes care of all
the cross-language method routing transparently.</P>
-<H3><A name="Php_nn3_1"></A>32.3.1 Enabling directors</H3>
+<H3><A name="Php_nn3_1">34.3.1 Enabling directors</A></H3>
<P> The director feature is disabled by default. To use directors you
must make two changes to the interface file. First, add the "directors"
option to the %module directive, like this:</P>
}
</PRE>
</DIV>
-<H3><A name="Php_nn3_2"></A>32.3.2 Director classes</H3>
+<H3><A name="Php_nn3_2">34.3.2 Director classes</A></H3>
<P> For each class that has directors enabled, SWIG generates a new
class that derives from both the class in question and a special <TT>
Swig::Director</TT> class. These new classes, referred to as director
unmodified proxy classes, all methods are ultimately implemented in C++
so there is no need for the extra overhead involved with routing the
calls through PHP.</P>
-<H3><A name="Php_nn3_3"></A>32.3.3 Ownership and object destruction</H3>
+<H3><A name="Php_nn3_3">34.3.3 Ownership and object destruction</A></H3>
<P> Memory management issues are slightly more complicated with
directors than for proxy classes alone. PHP instances hold a pointer to
the associated C++ director object, and the director in turn holds a
</DIV>
<P> In this example, we are assuming that FooContainer will take care of
deleting all the Foo pointers it contains at some point.</P>
-<H3><A name="Php_nn3_4"></A>32.3.4 Exception unrolling</H3>
+<H3><A name="Php_nn3_4">34.3.4 Exception unrolling</A></H3>
<P> With directors routing method calls to PHP, and proxies routing them
to C++, the handling of exceptions is an important concern. By default,
the directors ignore exceptions that occur during method calls that are
exception. Because the PHP error state is still set when
Swig::DirectorMethodException is thrown, PHP will register the
exception as soon as the C wrapper function returns.</P>
-<H3><A name="Php_nn3_5"></A>32.3.5 Overhead and code bloat</H3>
+<H3><A name="Php_nn3_5">34.3.5 Overhead and code bloat</A></H3>
<P> Enabling directors for a class will generate a new director method
for every virtual method in the class' inheritance chain. This alone
can generate a lot of code bloat for large hierarchies. Method
optimized by selectively enabling director methods (using the %feature
directive) for only those methods that are likely to be extended in
PHP.</P>
-<H3><A name="Php_nn3_6"></A>32.3.6 Typemaps</H3>
+<H3><A name="Php_nn3_6">34.3.6 Typemaps</A></H3>
<P> Typemaps for input and output of most of the basic types from
director classes have been written. These are roughly the reverse of
the usual input and output typemaps used by the wrapper code. The
'directorargout'. The director code does not currently use any of the
other kinds of typemaps. It is not clear at this point which kinds are
appropriate and need to be supported.</P>
-<H3><A name="Php_nn3_7"></A>32.3.7 Miscellaneous</H3>
+<H3><A name="Php_nn3_7">34.3.7 Miscellaneous</A></H3>
<P> Director typemaps for STL classes are mostly in place, and hence you
should be able to use std::string, etc., as you would any other type.</P>
<HR NOSHADE>
-<H1><A name="Pike"></A>33 SWIG and Pike</H1>
+<H1><A name="Pike">35 SWIG and Pike</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
least, make sure you read the "<A href="#SWIG">SWIG Basics</A>"
chapter.
<BR></P>
-<H2><A name="Pike_nn2"></A>33.1 Preliminaries</H2>
-<H3><A name="Pike_nn3"></A>33.1.1 Running SWIG</H3>
+<H2><A name="Pike_nn2">35.1 Preliminaries</A></H2>
+<H3><A name="Pike_nn3">35.1.1 Running SWIG</A></H3>
<P> Suppose that you defined a SWIG module such as the following:</P>
<DIV class="code">
<PRE>%module example
<PRE>$ <B>swig -pike -o pseudonym.c example.i</B>
<BR></PRE>
</DIV>
-<H3><A name="Pike_nn4"></A>33.1.2 Getting the right header files</H3>
+<H3><A name="Pike_nn4">35.1.2 Getting the right header files</A></H3>
<P> In order to compile the C/C++ wrappers, the compiler needs to know
the path to the Pike header files. These files are usually contained in
a directory such as</P>
location of these files, so you may need to hunt around for them.
You're looking for files with the names <TT>global.h</TT>, <TT>
program.h</TT> and so on.</P>
-<H3><A name="Pike_nn5"></A>33.1.3 Using your module</H3>
+<H3><A name="Pike_nn5">35.1.3 Using your module</A></H3>
<P> To use your module, simply use Pike's <TT>import</TT> statement:</P>
<DIV class="code">
<PRE>
(1) Result: 24
</PRE>
</DIV>
-<H2><A name="Pike_nn6"></A>33.2 Basic C/C++ Mapping</H2>
-<H3><A name="Pike_nn7"></A>33.2.1 Modules</H3>
+<H2><A name="Pike_nn6">35.2 Basic C/C++ Mapping</A></H2>
+<H3><A name="Pike_nn7">35.2.1 Modules</A></H3>
<P> All of the code for a given SWIG module is wrapped into a single
Pike module. Since the name of the shared library that implements your
module ultimately determines the module's name (as far as Pike is
concerned), SWIG's <TT>%module</TT> directive doesn't really have any
significance.</P>
-<H3><A name="Pike_nn8"></A>33.2.2 Functions</H3>
+<H3><A name="Pike_nn8">35.2.2 Functions</A></H3>
<P> Global functions are wrapped as new Pike built-in functions. For
example,</P>
<DIV class="code">
(1) Result: 24
</PRE>
</DIV>
-<H3><A name="Pike_nn9"></A>33.2.3 Global variables</H3>
+<H3><A name="Pike_nn9">35.2.3 Global variables</A></H3>
<P> Global variables are currently wrapped as a pair of functions, one
to get the current value of the variable and another to set it. For
example, the declaration</P>
(3) Result: 3.141590
</PRE>
</DIV>
-<H3><A name="Pike_nn10"></A>33.2.4 Constants and enumerated types</H3>
+<H3><A name="Pike_nn10">35.2.4 Constants and enumerated types</A></H3>
<P> Enumerated types in C/C++ declarations are wrapped as Pike
constants, not as Pike enums.</P>
-<H3><A name="Pike_nn11"></A>33.2.5 Constructors and Destructors</H3>
+<H3><A name="Pike_nn11">35.2.5 Constructors and Destructors</A></H3>
<P> Constructors are wrapped as <TT>create()</TT> methods, and
destructors are wrapped as <TT>destroy()</TT> methods, for Pike
classes.</P>
-<H3><A name="Pike_nn12"></A>33.2.6 Static Members</H3>
+<H3><A name="Pike_nn12">35.2.6 Static Members</A></H3>
<P> Since Pike doesn't support static methods or data for Pike classes,
static member functions in your C++ classes are wrapped as regular
functions and static member variables are wrapped as pairs of functions
methods, <TT>Shape_nshapes_get()</TT> and <TT>Shape_nshapes_set()</TT>,
to get and set the value of <TT>Shape::nshapes</TT>.</P>
<HR NOSHADE>
-<H1><A name="Python"></A>34 SWIG and Python</H1>
+<H1><A name="Python">36 SWIG and Python</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<LI><A href="#Python_nn24">C++ operators</A></LI>
<LI><A href="#Python_nn25">C++ namespaces</A></LI>
<LI><A href="#Python_nn26">C++ templates</A></LI>
-<LI><A href="#Python_nn27">C++ Smart Pointers</A></LI>
+<LI><A href="#Python_nn27">C++ Smart Pointers</A>
+<UL>
+<LI><A href="#Python_smart_pointers_shared_ptr">The shared_ptr Smart
+ Pointer</A></LI>
+<LI><A href="#Python_smart_pointers_generic">Generic Smart Pointers</A></LI>
+</UL>
+</LI>
<LI><A href="#Python_nn27a">C++ reference counted objects</A></LI>
</UL>
</LI>
<LI><A href="#Python_nn47">Simple pointers</A></LI>
<LI><A href="#Python_nn48">Unbounded C Arrays</A></LI>
<LI><A href="#Python_nn49">String handling</A></LI>
+<LI><A href="#Python_default_args">Default arguments</A></LI>
</UL>
</LI>
<LI><A href="#Python_nn53">Typemaps</A>
<LI><A href="#Python_nn71">%feature("docstring")</A></LI>
</UL>
</LI>
-<LI><A href="#Python_nn72">Python Packages</A></LI>
+<LI><A href="#Python_nn72">Python Packages</A>
+<UL>
+<LI><A href="#Python_modulepackage">Setting the Python package</A></LI>
+<LI><A href="#Python_absrelimports">Absolute and relative imports</A></LI>
+<LI><A href="#Python_absimport">Enforcing absolute import semantics</A></LI>
+<LI><A href="#Python_importfrominit">Importing from __init__.py</A></LI>
+<LI><A href="#Python_implicit_namespace_packages">Implicit Namespace
+ Packages</A></LI>
+<LI><A href="#Python_package_search">Searching for the wrapper module</A>
+<UL>
+<LI><A href="#Python_package_search_both_package_modules">Both modules
+ in the same package</A></LI>
+<LI><A href="#Python_package_search_wrapper_split">Split modules</A></LI>
+<LI><A href="#Python_package_search_both_global_modules">Both modules
+ are global</A></LI>
+<LI><A href="#Python_package_search_static">Statically linked C modules</A>
+</LI>
+</UL>
+</LI>
+</UL>
+</LI>
<LI><A href="#Python_python3support">Python 3 Support</A>
<UL>
<LI><A href="#Python_nn74">Function annotation</A></LI>
<LI><A href="#Python_nn75">Buffer interface</A></LI>
<LI><A href="#Python_nn76">Abstract base classes</A></LI>
+<LI><A href="#Python_nn77">Byte string output conversion</A></LI>
+<LI><A href="#Python_2_unicode">Python 2 Unicode</A></LI>
</UL>
</LI>
</UL>
details are covered in less depth than in earlier chapters. At the very
least, make sure you read the "<A href="#SWIG">SWIG Basics</A>"
chapter.</P>
-<H2><A name="Python_nn2"></A>34.1 Overview</H2>
+<H2><A name="Python_nn2">36.1 Overview</A></H2>
<P> To build Python extension modules, SWIG uses a layered approach in
which parts of the extension module are defined in C and other parts
are defined in Python. The C layer contains low-level wrappers whereas
Next, the Python interface to common C and C++ programming features is
described. Advanced customization features such as typemaps are then
described followed by a discussion of low-level implementation details.</P>
-<H2><A name="Python_nn3"></A>34.2 Preliminaries</H2>
-<H3><A name="Python_nn4"></A>34.2.1 Running SWIG</H3>
+<H2><A name="Python_nn3">36.2 Preliminaries</A></H2>
+<H3><A name="Python_nn4">36.2.1 Running SWIG</A></H3>
<P> Suppose that you defined a SWIG module such as the following:</P>
<DIV class="code">
<PRE>
example</TT>, then a file <TT>example.py</TT> is created.</P>
<P> The following sections have further practical examples and details
on how you might go about compiling and using the generated files.</P>
-<H3><A name="Python_nn6"></A>34.2.2 Using distutils</H3>
+<H3><A name="Python_nn6">36.2.2 Using distutils</A></H3>
<P> The preferred approach to building an extension module for python is
to compile it with distutils, which comes with all recent versions of
- python (<A href="http://docs.python.org/distutils/index.html">Distutils
- Docs</A>).</P>
+ python (<A href="https://docs.python.org/library/distutils.html">
+Distutils Docs</A>).</P>
<P> Distutils takes care of making sure that your extension is built
with all the correct flags, headers, etc. for the version of Python it
is run with. Distutils will compile your extension into a shared object
<P> This same approach works on all platforms if the appropriate
compiler is installed. (it can even build extensions to the standard
Windows Python using MingGW)</P>
-<H3><A name="Python_nn7"></A>34.2.3 Hand compiling a dynamic module</H3>
+<H3><A name="Python_nn7">36.2.3 Hand compiling a dynamic module</A></H3>
<P> While the preferred approach to building an extension module is to
use the distutils, some people like to integrate building extensions
with a larger build system, and thus may wish to compile their modules
socket</TT> module actually consists of two files; <TT>socket.py</TT>
and <TT>_socket.so</TT>. Many other built-in Python modules follow a
similar convention.</P>
-<H3><A name="Python_nn8"></A>34.2.4 Static linking</H3>
+<H3><A name="Python_nn8">36.2.4 Static linking</A></H3>
<P> An alternative approach to dynamic linking is to rebuild the Python
interpreter with your extension module added to it. In the past, this
approach was sometimes necessary due to limitations in dynamic loading
interpreter, you simply do something like this:</P>
<DIV class="shell">
<PRE>
-$ swig -python example.i
+$ swig -python -lembed.i example.i
$ gcc example.c example_wrap.c \
-Xlinker -export-dynamic \
- -DHAVE_CONFIG_H -I/usr/local/include/python2.1 \
- -I/usr/local/lib/python2.1/config \
- -L/usr/local/lib/python2.1/config -lpython2.1 -lm -ldl \
- -o mypython
-
+ -DHAVE_CONFIG_H -I/usr/include/python2.7 \
+ -I/usr/lib/python2.7/config-x86_64-linux-gnu \
+ -I/usr/lib/python2.7/config \
+ -L/usr/lib/python2.7/config -lpython2.7 -lm -ldl \
+ -o mypython
</PRE>
</DIV>
<P> You will need to supply the same libraries that were used to build
situations (and quite frankly not worth the extra hassle in the opinion
of this author).</P>
<P><B> Compatibility note:</B> The <TT>embed.i</TT> library file is
- deprecated and has not been maintained for several years. Even though
- it appears to "work" with Python 2.1, no future support is guaranteed.
- If using static linking, you might want to rely on a different approach
- (perhaps using distutils).</P>
-<H3><A name="Python_nn9"></A>34.2.5 Using your module</H3>
+ deprecated and has not been actively maintained for many years. Even
+ though it appears to "work" with Python 2.7, no future support is
+ guaranteed. If using static linking, you might want to rely on a
+ different approach (perhaps using distutils).</P>
+<H3><A name="Python_nn9">36.2.5 Using your module</A></H3>
<P> To use your module, simply use the Python <TT>import</TT> statement.
If all goes well, you will be able to this:</P>
<DIV class="targetlang">
crle</TT> (Solaris) to add additional search paths to the default system
configuration (this requires root access and you will need to read the
man pages).</P>
-<H3><A name="Python_nn10"></A>34.2.6 Compilation of C++ extensions</H3>
+<H3><A name="Python_nn10">36.2.6 Compilation of C++ extensions</A></H3>
<P> Compilation of C++ extensions has traditionally been a tricky
problem. Since the Python interpreter is written in C, you need to take
steps to make sure C++ is properly initialized and that modules are
you will need to take steps to avoid segmentation faults and other
erratic program behavior. If working with lots of software components,
you might want to investigate using a more formal standard such as COM.</P>
-<H3><A name="Python_nn11"></A>34.2.7 Compiling for 64-bit platforms</H3>
+<H3><A name="Python_nn11">36.2.7 Compiling for 64-bit platforms</A></H3>
<P> On platforms that support 64-bit applications (Solaris, Irix, etc.),
special care is required when building extension modules. On these
machines, 64-bit applications are compiled and linked using a different
compatibility (under /usr/lib). Also, the compiler options -m32 and
-m64 allow you to choose the desired binary format for your python
extension.</P>
-<H3><A name="Python_nn12"></A>34.2.8 Building Python Extensions under
- Windows</H3>
+<H3><A name="Python_nn12">36.2.8 Building Python Extensions under
+ Windows</A></H3>
<P> Building a SWIG extension to Python under Windows is roughly similar
to the process used with Unix. Using the distutils, it is essentially
identical. If you have the same version of the MS compiler that Python
DLLs with these compilers tends to be rather problematic. For the
latest information, you may want to consult the <A href="http://www.dabeaz.com/cgi-bin/wiki.pl">
SWIG Wiki</A>.</P>
-<H2><A name="Python_nn13"></A>34.3 A tour of basic C/C++ wrapping</H2>
+<H2><A name="Python_nn13">36.3 A tour of basic C/C++ wrapping</A></H2>
<P> By default, SWIG tries to build a very natural Python interface to
your C/C++ code. Functions are wrapped as functions, classes are
wrapped as classes, and so forth. This section briefly covers the
essential aspects of this wrapping.</P>
-<H3><A name="Python_nn14"></A>34.3.1 Modules</H3>
+<H3><A name="Python_nn14">36.3.1 Modules</A></H3>
<P> The SWIG <TT>%module</TT> directive specifies the name of the Python
module. If you specify `<TT>%module example</TT>', then everything is
wrapped into a Python '<TT>example</TT>' module. Underneath the covers,
low-level extension module <TT>_example.so</TT>. When choosing a module
name, make sure you don't use the same name as a built-in Python
command or standard module name.</P>
-<H3><A name="Python_nn15"></A>34.3.2 Functions</H3>
+<H3><A name="Python_nn15">36.3.2 Functions</A></H3>
<P> Global functions are wrapped as new Python built-in functions. For
example,</P>
<DIV class="code">
>>>
</PRE>
</DIV>
-<H3><A name="Python_nn16"></A>34.3.3 Global variables</H3>
+<H3><A name="Python_nn16">36.3.3 Global variables</A></H3>
<P> C/C++ global variables are fully supported by SWIG. However, the
underlying mechanism is somewhat different than you might expect due to
the way that Python assignment works. When you type the following in
the module by giving it a name that starts with a leading underscore.
SWIG does not create <TT>cvar</TT> if there are no global variables in
a module.</P>
-<H3><A name="Python_nn17"></A>34.3.4 Constants and enums</H3>
+<H3><A name="Python_nn17">36.3.4 Constants and enums</A></H3>
<P> C/C++ constants are installed as Python objects containing the
appropriate value. To create a constant, use <TT>#define</TT>, <TT>enum</TT>
, or the <TT>%constant</TT> directive. For example:</P>
of the constant could be accidentally reassigned to refer to some other
object. Unfortunately, there is no easy way for SWIG to generate code
that prevents this. You will just have to be careful.</P>
-<H3><A name="Python_nn18"></A>34.3.5 Pointers</H3>
+<H3><A name="Python_nn18">36.3.5 Pointers</A></H3>
<P> C/C++ pointers are fully supported by SWIG. Furthermore, SWIG has no
problem working with incomplete type information. Here is a rather
simple interface:</P>
<DIV class="targetlang">
<PRE>
>>> import example
->>> f = example.fopen("junk","w")
+>>> f = example.fopen("junk", "w")
>>> example.fputs("Hello World\n", f)
>>> example.fclose(f)
</PRE>
style casts. For example, in the above code, the C-style cast may
return a bogus result whereas as the C++-style cast will return <TT>
None</TT> if the conversion can't be performed.</P>
-<H3><A name="Python_nn19"></A>34.3.6 Structures</H3>
+<H3><A name="Python_nn19">36.3.6 Structures</A></H3>
<P> If you wrap a C structure, it is wrapped by a Python class. This
provides a very natural interface. For example,</P>
<DIV class="code">
<PRE>
struct Vector {
- double x,y,z;
+ double x,y,z;
};
</PRE>
>>> x.a = 3 # Modifies the same structure
</PRE>
</DIV>
-<H3><A name="Python_nn20"></A>34.3.7 C++ classes</H3>
+<H3><A name="Python_nn20">36.3.7 C++ classes</A></H3>
<P> C++ classes are wrapped by Python classes as well. For example, if
you have this class,</P>
<DIV class="code">
7
</PRE>
</DIV>
-<H3><A name="Python_nn21"></A>34.3.8 C++ inheritance</H3>
+<H3><A name="Python_nn21">36.3.8 C++ inheritance</A></H3>
<P> SWIG is fully aware of issues related to C++ inheritance. Therefore,
if you have classes like this</P>
<DIV class="code">
<P> then the function <TT>spam()</TT> accepts <TT>Foo *</TT> or a
pointer to any class derived from <TT>Foo</TT>.</P>
<P> It is safe to use multiple inheritance with SWIG.</P>
-<H3><A name="Python_nn22"></A>34.3.9 Pointers, references, values, and
- arrays</H3>
+<H3><A name="Python_nn22">36.3.9 Pointers, references, values, and
+ arrays</A></H3>
<P> In C++, there are many different ways a function might receive and
manipulate objects. For example:</P>
<DIV class="code">
collected). The fourth case (spam9) which returns a const reference, in
most of the cases will be treated as a returning value, and it will
follow the same allocation/deallocation process.</P>
-<H3><A name="Python_nn23"></A>34.3.10 C++ overloaded functions</H3>
+<H3><A name="Python_nn23">36.3.10 C++ overloaded functions</A></H3>
<P> C++ overloaded functions, methods, and constructors are mostly
supported by SWIG. For example, if you have two functions like this:</P>
<DIV class="code">
arises--in this case, the first declaration takes precedence.</P>
<P> Please refer to the "SWIG and C++" chapter for more information
about overloading.</P>
-<H3><A name="Python_nn24"></A>34.3.11 C++ operators</H3>
+<H3><A name="Python_nn24">36.3.11 C++ operators</A></H3>
<P> Certain C++ overloaded operators can be handled automatically by
SWIG. For example, consider a class like this:</P>
<DIV class="code">
<P> Also, be aware that certain operators don't map cleanly to Python.
For instance, overloaded assignment operators don't map to Python
semantics and will be ignored.</P>
-<H3><A name="Python_nn25"></A>34.3.12 C++ namespaces</H3>
+<H3><A name="Python_nn25">36.3.12 C++ namespaces</A></H3>
<P> SWIG is aware of C++ namespaces, but namespace names do not appear
in the module nor do namespaces result in a module that is broken up
into submodules or packages. For example, if you have a file like this,</P>
extension modules for each namespace separately. If your program
utilizes thousands of small deeply nested namespaces each with
identical symbol names, well, then you get what you deserve.</P>
-<H3><A name="Python_nn26"></A>34.3.13 C++ templates</H3>
+<H3><A name="Python_nn26">36.3.13 C++ templates</A></H3>
<P> C++ templates don't present a huge problem for SWIG. However, in
order to create wrappers, you have to tell SWIG to create wrappers for
a particular template instantiation. To do this, you use the <TT>
<P> Obviously, there is more to template wrapping than shown in this
example. More details can be found in the <A href="#SWIGPlus">SWIG and
C++</A> chapter. Some more complicated examples will appear later.</P>
-<H3><A name="Python_nn27"></A>34.3.14 C++ Smart Pointers</H3>
+<H3><A name="Python_nn27">36.3.14 C++ Smart Pointers</A></H3>
+<H4><A name="Python_smart_pointers_shared_ptr">36.3.14.1 The shared_ptr
+ Smart Pointer</A></H4>
+<P> The C++11 standard provides <TT>std::shared_ptr</TT> which was
+ derived from the Boost implementation, <TT>boost::shared_ptr</TT>. Both
+ of these are available for Python in the SWIG library and usage is
+ outlined in the <A href="#Library_std_shared_ptr">shared_ptr smart
+ pointer</A> library section.</P>
+<H4><A name="Python_smart_pointers_generic">36.3.14.2 Generic Smart
+ Pointers</A></H4>
<P> In certain C++ programs, it is common to use classes that have been
wrapped by so-called "smart pointers." Generally, this involves the use
of a template class that implements <TT>operator->()</TT> like this:</P>
>>> f = p.__deref__() # Returns underlying Foo *
</PRE>
</DIV>
-<H3><A name="Python_nn27a"></A>34.3.15 C++ reference counted objects</H3>
+<H3><A name="Python_nn27a">36.3.15 C++ reference counted objects</A></H3>
<P> The <A href="#SWIGPlus_ref_unref">C++ reference counted objects</A>
section contains Python examples of memory management using referencing
counting.</P>
-<H2><A name="Python_nn28"></A>34.4 Further details on the Python class
- interface</H2>
+<H2><A name="Python_nn28">36.4 Further details on the Python class
+ interface</A></H2>
<P> In the previous section, a high-level view of Python wrapping was
presented. A key component of this wrapping is that structures and
classes are wrapped by Python proxy classes. This provides a very
following section ("Proxy classes") does not apply. Details on the use
of the <TT>-builtin</TT> option are in the <A href="#Python_builtin_types">
Built-in Types</A> section.</P>
-<H3><A name="Python_nn29"></A>34.4.1 Proxy classes</H3>
+<H3><A name="Python_nn29">36.4.1 Proxy classes</A></H3>
<P> In the <A href="#SWIG">"SWIG basics"</A> and <A href="#SWIGPlus">
"SWIG and C++"</A> chapters, details of low-level structure and class
wrapping are described. To summarize those chapters, if you have a
import _example
class Foo(object):
- def __init__(self):
- self.this = _example.new_Foo()
- self.thisown = 1
- def __del__(self):
- if self.thisown:
- _example.delete_Foo(self.this)
- def spam(self,arg1):
- return _example.Foo_spam(self.this,arg1)
- x = property(_example.Foo_x_get, _example.Foo_x_set)
+ def __init__(self):
+ self.this = _example.new_Foo()
+ self.thisown = 1
+ def __del__(self):
+ if self.thisown:
+ _example.delete_Foo(self.this)
+ def spam(self,arg1):
+ return _example.Foo_spam(self.this,arg1)
+ x = property(_example.Foo_x_get, _example.Foo_x_set)
</PRE>
</DIV>
<P> This class merely holds a pointer to the underlying C++ object (<TT>
offers certain advantages. For instance, you can attach new Python
methods to the class and you can even inherit from it (something not
supported by Python built-in types until Python 2.2).</P>
-<H3><A name="Python_builtin_types"></A>34.4.2 Built-in Types</H3>
+<H3><A name="Python_builtin_types">36.4.2 Built-in Types</A></H3>
<P> The <TT>-builtin</TT> option provides a significant performance
improvement in the wrapped code. To understand the difference between
proxy classes and built-in types, let's take a look at what a wrapped
<DIV class="targetlang">
<PRE>
class Foo(object):
- def __init__(self):
- self.this = _example.new_Foo()
- self.thisown = 1
+ def __init__(self):
+ self.this = _example.new_Foo()
+ self.thisown = 1
</PRE>
</DIV>
<P>When a <TT>Foo</TT> instance is created, the call to <TT>
python documentation:</P>
<P><A href="http://docs.python.org/extending/newtypes.html">
http://docs.python.org/extending/newtypes.html</A></P>
-<H4><A name="Python_builtin_limitations"></A>34.4.2.1 Limitations</H4>
+<H4><A name="Python_builtin_limitations">36.4.2.1 Limitations</A></H4>
<P>Use of the <TT>-builtin</TT> option implies a couple of limitations:</P>
<UL>
<LI>
exception:</P>
<DIV class="targetlang">
<PRE>
-class MyPyException (Exception) :
- def __init__(self, msg, *args) :
+class MyPyException(Exception):
+ def __init__(self, msg, *args):
Exception.__init__(self, *args)
self.myexc = MyException(msg)
- def what (self) :
+ def what(self):
return self.myexc.what()
</PRE>
</DIV></LI>
</PRE>
</DIV></LI>
</UL>
-<H4><A name="Python_builtin_overloads"></A>34.4.2.2 Operator overloads
- -- use them!</H4>
+<H4><A name="Python_builtin_overloads">36.4.2.2 Operator overloads --
+ use them!</A></H4>
<P>The entire justification for the <TT>-builtin</TT> option is improved
performance. To that end, the best way to squeeze maximum performance
out of your wrappers is to<B> use operator overloads.</B> Named method
<P>You may override (almost) all of the slots defined in the <TT>
PyTypeObject, PyNumberMethods, PyMappingMethods, PySequenceMethods</TT>,
and <TT>PyBufferProcs</TT> structs.</P>
-<H3><A name="Python_nn30"></A>34.4.3 Memory management</H3>
+<H3><A name="Python_nn30">36.4.3 Memory management</A></H3>
<P>NOTE: Although this section refers to proxy objects, everything here
also applies when the <TT>-builtin</TT> option is used.</P>
<P> Associated with proxy object, is an ownership flag <TT>.thisown</TT>
</DIV>
<P> It is also possible to deal with situations like this using
typemaps--an advanced topic discussed later.</P>
-<H3><A name="Python_nn31"></A>34.4.4 Python 2.2 and classic classes</H3>
+<H3><A name="Python_nn31">36.4.4 Python 2.2 and classic classes</A></H3>
<P> SWIG makes every attempt to preserve backwards compatibility with
older versions of Python to the extent that it is possible. However, in
Python-2.2, an entirely new type of class system was introduced. This
new-style class system offers many enhancements including static member
functions, properties (managed attributes), and class methods. Details
- about all of these changes can be found on <A href="http://www.python.org">
+ about all of these changes can be found on <A href="https://www.python.org">
www.python.org</A> and is not repeated here.</P>
<P> To address differences between Python versions, SWIG currently emits
dual-mode proxy class wrappers. In Python-2.2 and newer releases, these
old-style classes are used instead.</P>
<P> This dual-nature of the wrapper code means that you can create
extension modules with SWIG and those modules will work with all
- versions of Python ranging from Python-1.4 to the very latest release.
+ versions of Python ranging from Python-2.0 to the very latest release.
Moreover, the wrappers take advantage of Python-2.2 features when
available.</P>
<P> For the most part, the interface presented to users is the same
can be accessed via the class itself. In Python-2.1 and earlier, they
have to be accessed as a global function or through an instance (see
the earlier section).</P>
-<H2><A name="Python_directors"></A>34.5 Cross language polymorphism</H2>
+<H2><A name="Python_directors">36.5 Cross language polymorphism</A></H2>
<P> Proxy classes provide a more natural, object-oriented way to access
extension classes. As described above, each proxy instance has an
associated C++ instance, and method calls to the proxy are passed to
to know where a particular method is implemented: the combination of
proxy classes, director classes, and C wrapper functions takes care of
all the cross-language method routing transparently.</P>
-<H3><A name="Python_nn33"></A>34.5.1 Enabling directors</H3>
+<H3><A name="Python_nn33">36.5.1 Enabling directors</A></H3>
<P> The director feature is disabled by default. To use directors you
must make two changes to the interface file. First, add the "directors"
option to the %module directive, like this:</P>
class Foo {
public:
Foo(int foo);
+ virtual ~Foo();
virtual void one();
virtual void two();
};
import mymodule
class MyFoo(mymodule.Foo):
- def __init__(self, foo):
- mymodule.Foo(self, foo)
+ def __init__(self, foo):
+ mymodule.Foo.__init__(self, foo)
+# super().__init__(foo) # Alternative construction for Python3
- def one(self):
- print "one from python"
+ def one(self):
+ print "one from python"
</PRE>
</DIV>
-<H3><A name="Python_nn34"></A>34.5.2 Director classes</H3>
+<H3><A name="Python_nn34">36.5.2 Director classes</A></H3>
<P> For each class that has directors enabled, SWIG generates a new
class that derives from both the class in question and a special <TT>
Swig::Director</TT> class. These new classes, referred to as director
unmodified proxy classes, all methods are ultimately implemented in C++
so there is no need for the extra overhead involved with routing the
calls through Python.</P>
-<H3><A name="Python_nn35"></A>34.5.3 Ownership and object destruction</H3>
+<H3><A name="Python_nn35">36.5.3 Ownership and object destruction</A></H3>
<P> Memory management issues are slightly more complicated with
directors than for proxy classes alone. Python instances hold a pointer
to the associated C++ director object, and the director in turn holds a
<P> In this example, we are assuming that FooContainer will take care of
deleting all the Foo pointers it contains at some point. Note that no
hard references to the Foo objects remain in Python.</P>
-<H3><A name="Python_nn36"></A>34.5.4 Exception unrolling</H3>
+<H3><A name="Python_nn36">36.5.4 Exception unrolling</A></H3>
<P> With directors routing method calls to Python, and proxies routing
them to C++, the handling of exceptions is an important concern. By
default, the directors ignore exceptions that occur during method calls
exception. Because the Python error state is still set when
Swig::DirectorMethodException is thrown, Python will register the
exception as soon as the C wrapper function returns.</P>
-<H3><A name="Python_nn37"></A>34.5.5 Overhead and code bloat</H3>
+<H3><A name="Python_nn37">36.5.5 Overhead and code bloat</A></H3>
<P> Enabling directors for a class will generate a new director method
for every virtual method in the class' inheritance chain. This alone
can generate a lot of code bloat for large hierarchies. Method
can be optimized by selectively enabling director methods (using the
%feature directive) for only those methods that are likely to be
extended in Python.</P>
-<H3><A name="Python_nn38"></A>34.5.6 Typemaps</H3>
+<H3><A name="Python_nn38">36.5.6 Typemaps</A></H3>
<P> Typemaps for input and output of most of the basic types from
director classes have been written. These are roughly the reverse of
the usual input and output typemaps used by the wrapper code. The
'directorargout'. The director code does not currently use any of the
other kinds of typemaps. It is not clear at this point which kinds are
appropriate and need to be supported.</P>
-<H3><A name="Python_nn39"></A>34.5.7 Miscellaneous</H3>
+<H3><A name="Python_nn39">36.5.7 Miscellaneous</A></H3>
<P> Director typemaps for STL classes are in place, and hence you should
be able to use std::vector, std::string, etc., as you would any other
type.</P>
<P> If that is not possible, the user should avoid enabling the director
feature for reentrant, recursive or threaded member methods that return
const references.</P>
-<H2><A name="Python_nn40"></A>34.6 Common customization features</H2>
+<H2><A name="Python_nn40">36.6 Common customization features</A></H2>
<P> The last section presented the absolute basics of C/C++ wrapping. If
you do nothing but feed SWIG a header file, you will get an interface
that mimics the behavior described. However, sometimes this isn't
be missing or the interface to certain functions might be awkward. This
section describes some common SWIG features that are used to improve
your the interface to an extension module.</P>
-<H3><A name="Python_nn41"></A>34.6.1 C/C++ helper functions</H3>
+<H3><A name="Python_nn41">36.6.1 C/C++ helper functions</A></H3>
<P> Sometimes when you create a module, it is missing certain bits of
functionality. For example, if you had a function like this</P>
<DIV class="code">
it works and it wasn't too hard to implement. It is possible to clean
this up using Python code, typemaps, and other customization features
as covered in later sections.</P>
-<H3><A name="Python_nn42"></A>34.6.2 Adding additional Python code</H3>
+<H3><A name="Python_nn42">36.6.2 Adding additional Python code</A></H3>
<P> If writing support code in C isn't enough, it is also possible to
write code in Python. This code gets inserted in to the <TT>.py</TT>
file created by SWIG. One use of Python code might be to supply a
</PRE>
</DIV>
+<P>When using <TT>%pythoncode</TT> and <TT>%pythonbegin</TT> you
+ generally want to make sure that the block is delimited by <TT>%{</TT>
+ and <TT>%}</TT>. If you delimit it with <TT>{</TT> and <TT>}</TT> then
+ any lines with a leading <TT>#</TT> will be handled by SWIG as
+ preprocessor directives, when you probably meant them as Python
+ comments. Prior to SWIG 3.0.3, invalid preprocessor directives were
+ silently ignored, so generally using the wrong delimiters resulted in
+ such comments not appearing in the generated output (though a comment
+ starting with a valid preprocessor directive could cause problems, for
+ example: <TT># error handling</TT>). SWIG 3.0.3 and later report an
+ error for invalid preprocessor directives, so you may have to update
+ existing interface files to delimit blocks of Python code correctly.</P>
+<P>As an alternative to providing a block containing Python code, you
+ can include python code from a file. The code is inserted exactly as in
+ the file, so this avoids any issues with the SWIG preprocessor. It's a
+ good approach if you have a non-trivial chunk of Python code to insert.
+ To use this feature you specify a filename in double quotes, for
+ example:</P>
+<DIV class="code">
+<PRE>
+%pythoncode "somecode.py"
+</PRE>
+</DIV>
<P>Sometimes you may want to replace or modify the wrapper function that
SWIG creates in the proxy <TT>.py</TT> file. The Python module in SWIG
provides some features that enable you to do this. First, to entirely
class Foo {
public:
int bar(int x);
-}
+};
</PRE>
</DIV>
<P> where <TT>$action</TT> will be replaced by the call to the C/C++
class Foo {
public:
int bar(int x);
-}
+};
</PRE>
</DIV>
<P> Notes: Usually the <TT>pythonappend</TT> and <TT>pythonprepend</TT>
class Foo {
public:
int bar(int x);
-}
+};
</PRE>
</DIV>
<P> Note that when the underlying C++ method is overloaded, there is
public:
int bar(int x);
int bar();
-}
+};
</PRE>
</DIV>
<P> The same applies for overloaded constructors.</P>
-<H3><A name="Python_nn43"></A>34.6.3 Class extension with %extend</H3>
+<H3><A name="Python_nn43">36.6.3 Class extension with %extend</A></H3>
<P> One of the more interesting features of SWIG is that it can extend
structures and classes with new methods--at least in the Python
interface. Here is a simple example:</P>
<P> <TT>%extend</TT> works with both C and C++ code. It does not modify
the underlying object in any way---the extensions only show up in the
Python interface.</P>
-<H3><A name="Python_nn44"></A>34.6.4 Exception handling with %exception</H3>
+<H3><A name="Python_nn44">36.6.4 Exception handling with %exception</A></H3>
<P> If a C or C++ function throws an error, you may want to convert that
error into a Python exception. To do this, you can use the <TT>
%exception</TT> directive. <TT>%exception</TT> simply lets you rewrite
<P> The language-independent <TT>exception.i</TT> library file can also
be used to raise exceptions. See the <A href="#Library">SWIG Library</A>
chapter.</P>
-<H2><A name="Python_nn45"></A>34.7 Tips and techniques</H2>
+<H2><A name="Python_nn45">36.7 Tips and techniques</A></H2>
<P> Although SWIG is largely automatic, there are certain types of
wrapping problems that require additional user input. Examples include
dealing with output parameters, strings, binary data, and arrays. This
chapter discusses the common techniques for solving these problems.</P>
-<H3><A name="Python_nn46"></A>34.7.1 Input and output parameters</H3>
+<H3><A name="Python_nn46">36.7.1 Input and output parameters</A></H3>
<P> A common problem in some C programs is handling parameters passed as
simple pointers. For example:</P>
<DIV class="code">
</DIV>
<P> may not have the intended effect since <TT>typemaps.i</TT> does not
define an OUTPUT rule for <TT>Bar</TT>.</P>
-<H3><A name="Python_nn47"></A>34.7.2 Simple pointers</H3>
+<H3><A name="Python_nn47">36.7.2 Simple pointers</A></H3>
<P> If you must work with simple pointers such as <TT>int *</TT> or <TT>
double *</TT> and you don't want to use <TT>typemaps.i</TT>, consider
using the <TT>cpointer.i</TT> library file. For example:</P>
</DIV>
<P> See the <A href="#Library">SWIG Library</A> chapter for further
details.</P>
-<H3><A name="Python_nn48"></A>34.7.3 Unbounded C Arrays</H3>
+<H3><A name="Python_nn48">36.7.3 Unbounded C Arrays</A></H3>
<P> Sometimes a C function expects an array to be passed as a pointer.
For example,</P>
<DIV class="code">
other hand, this low-level approach is extremely efficient and well
suited for applications in which you need to create buffers, package
binary data, etc.</P>
-<H3><A name="Python_nn49"></A>34.7.4 String handling</H3>
+<H3><A name="Python_nn49">36.7.4 String handling</A></H3>
<P> If a C function has an argument of <TT>char *</TT>, then a Python
string can be passed as input. For example:</P>
<DIV class="code">
<P> If you need to return binary data, you might use the <TT>cstring.i</TT>
library file. The <TT>cdata.i</TT> library can also be used to extra
binary data from arbitrary pointers.</P>
-<H2><A name="Python_nn53"></A>34.8 Typemaps</H2>
+<H3><A name="Python_default_args">36.7.5 Default arguments</A></H3>
+<P> C++ default argument code generation is documented in the main <A href="#SWIGPlus_default_args">
+Default arguments</A> section. There is also an optional Python specific
+ feature that can be used called the <TT>python:cdefaultargs</TT> <A href="#Customization_feature_flags">
+feature flag</A>. By default, SWIG attempts to convert C++ default
+ argument values into Python values and generates code into the Python
+ layer containing these values. For example:</P>
+<DIV class="code">
+<PRE>
+struct CDA {
+ int fff(int a = 1, bool b = false);
+};
+</PRE>
+</DIV>
+<P> From Python this can be called as follows:</P>
+<DIV class="targetlang">
+<PRE>
+>>> CDA().fff() # C++ layer receives a=1 and b=false
+>>> CDA().fff(2) # C++ layer receives a=2 and b=false
+>>> CDA().fff(3, True) # C++ layer receives a=3 and b=true
+</PRE>
+</DIV>
+<P> The default code generation in the Python layer is:</P>
+<DIV class="targetlang">
+<PRE>
+class CDA(object):
+ ...
+ def fff(self, a=1, b=False):
+ return _default_args.CDA_fff(self, a, b)
+</PRE>
+</DIV>
+<P> Adding the feature:</P>
+<DIV class="code">
+<PRE>
+%feature("python:cdefaultargs") CDA::fff;
+struct CDA {
+ int fff(int a = 1, bool b = false);
+</PRE>
+</DIV>
+<P> results in identical behaviour when called from Python, however, it
+ results in different code generation:</P>
+<DIV class="targetlang">
+<PRE>
+class CDA(object):
+ ...
+ def fff(self, *args):
+ return _default_args.CDA_fff(self, *args)
+</PRE>
+</DIV>
+<P> The default arguments are obtained in the C++ wrapper layer instead
+ of the Python layer. Some code generation modes are quite different, eg
+ <TT>-builtin</TT> and <TT>-fastproxy</TT>, and are unaffected by <TT>
+python:cdefaultargs</TT> as the default values are always obtained from
+ the C++ layer.</P>
+<P> Note that not all default arguments can be converted into a Python
+ equivalent. When SWIG does not convert them, it will generate code to
+ obtain them from the C++ layer as if <TT>python:cdefaultargs</TT> was
+ specified. This will happen if just one argument cannot be converted
+ into a Python equivalent. This occurs typically when the argument is
+ not fully numeric, such as <TT>int(1)</TT>:</P>
+<DIV class="code">
+<PRE>
+struct CDA {
+ int fff(int a = int(1), bool b = false);
+};
+</PRE>
+</DIV>
+<P><B> Compatibility Note:</B> SWIG-3.0.6 introduced the <TT>
+python:cdefaultargs</TT> feature. Versions of SWIG prior to this varied
+ in their ability to convert C++ default values into equivalent Python
+ default argument values.</P>
+<H2><A name="Python_nn53">36.8 Typemaps</A></H2>
<P> This section describes how you can modify SWIG's default wrapping
behavior for various C/C++ datatypes using the <TT>%typemap</TT>
directive. This is an advanced topic that assumes familiarity with the
in most cases. Typemaps are only used if you want to change some aspect
of the primitive C-Python interface or if you want to elevate your guru
status.</P>
-<H3><A name="Python_nn54"></A>34.8.1 What is a typemap?</H3>
+<H3><A name="Python_nn54">36.8.1 What is a typemap?</A></H3>
<P> A typemap is nothing more than a code generation rule that is
attached to a specific C datatype. For example, to convert integers
from Python to C, you might define a typemap like this:</P>
%module example
%typemap(in) int {
- $1 = (int) PyLong_AsLong($input);
- printf("Received an integer : %d\n",$1);
+ $1 = (int) PyLong_AsLong($input);
+ printf("Received an integer : %d\n",$1);
}
%inline %{
extern int fact(int n);
%module example
%typemap(in) int nonnegative {
- $1 = (int) PyLong_AsLong($input);
- if ($1 < 0) {
- PyErr_SetString(PyExc_ValueError,"Expected a nonnegative value.");
- return NULL;
- }
+ $1 = (int) PyLong_AsLong($input);
+ if ($1 < 0) {
+ PyErr_SetString(PyExc_ValueError,"Expected a nonnegative value.");
+ return NULL;
+ }
}
%inline %{
extern int fact(int nonnegative);
<DIV class="code">
<PRE>
%typemap(in) int n {
- $1 = (int) PyLong_AsLong($input);
- printf("n = %d\n",$1);
+ $1 = (int) PyLong_AsLong($input);
+ printf("n = %d\n",$1);
}
%inline %{
typedef int Integer;
>>>
</PRE>
</DIV>
-<H3><A name="Python_nn55"></A>34.8.2 Python typemaps</H3>
+<H3><A name="Python_nn55">36.8.2 Python typemaps</A></H3>
<P> The previous section illustrated an "in" typemap for converting
Python objects to C. A variety of different typemap methods are defined
by the Python module. For example, to convert a C integer back into a
simplicity and pedagogic value.</P>
<P> To learn how to write a simple or your first typemap, you better
take a look at the SWIG library version 1.3.20 or so.</P>
-<H3><A name="Python_nn56"></A>34.8.3 Typemap variables</H3>
+<H3><A name="Python_nn56">36.8.3 Typemap variables</A></H3>
<P> Within typemap code, a number of special variables prefaced with a <TT>
$</TT> may appear. A full list of variables can be found in the "<A href="#Typemaps">
Typemaps</A>" chapter. This is a list of the most common variables:</P>
<P> <TT>$symname</TT></P>
<DIV class="indent"> The Python name of the wrapper function being
created.</DIV>
-<H3><A name="Python_nn57"></A>34.8.4 Useful Python Functions</H3>
+<H3><A name="Python_nn57">36.8.4 Useful Python Functions</A></H3>
<P> When you write a typemap, you usually have to work directly with
Python objects. The following functions may prove to be useful.</P>
<P><B> Python Integer Functions</B></P>
write me
</PRE>
</DIV>
-<H2><A name="Python_nn58"></A>34.9 Typemap Examples</H2>
+<H2><A name="Python_nn58">36.9 Typemap Examples</A></H2>
<P> This section includes a few examples of typemaps. For more examples,
you might look at the files "<TT>python.swg</TT>" and "<TT>typemaps.i</TT>
" in the SWIG library.</P>
-<H3><A name="Python_nn59"></A>34.9.1 Converting Python list to a char **</H3>
+<H3><A name="Python_nn59">36.9.1 Converting Python list to a char **</A></H3>
<P> A common problem in many C programs is the processing of command
line arguments, which are usually passed in an array of NULL terminated
strings. The following SWIG interface file allows a Python list object
for (i = 0; i < size; i++) {
PyObject *o = PyList_GetItem($input,i);
if (PyString_Check(o))
- $1[i] = PyString_AsString(PyList_GetItem($input,i));
+ $1[i] = PyString_AsString(PyList_GetItem($input,i));
else {
- PyErr_SetString(PyExc_TypeError,"list must contain strings");
- free($1);
- return NULL;
+ PyErr_SetString(PyExc_TypeError,"list must contain strings");
+ free($1);
+ return NULL;
}
}
$1[i] = 0;
<DIV class="targetlang">
<PRE>
>>> from argv import *
->>> print_args(["Dave","Mike","Mary","Jane","John"])
+>>> print_args(["Dave", "Mike", "Mary", "Jane", "John"])
argv[0] = Dave
argv[1] = Mike
argv[2] = Mary
dynamic memory allocation is used to allocate memory for the array, the
"freearg" typemap is used to later release this memory after the
execution of the C function.</P>
-<H3><A name="Python_nn60"></A>34.9.2 Expanding a Python object into
- multiple arguments</H3>
+<H3><A name="Python_nn60">36.9.2 Expanding a Python object into multiple
+ arguments</A></H3>
<P> Suppose that you had a collection of C functions with arguments such
as the following:</P>
<DIV class="code">
Python as follows:</P>
<DIV class="targetlang">
<PRE>
->>> foo(4, ["foo","bar","spam","1"])
+>>> foo(4, ["foo", "bar", "spam", "1"])
</PRE>
</DIV>
<P> Although this works, it's a little awkward to specify the argument
for (i = 0; i < $1; i++) {
PyObject *o = PyList_GetItem($input,i);
if (PyString_Check(o))
- $2[i] = PyString_AsString(PyList_GetItem($input,i));
+ $2[i] = PyString_AsString(PyList_GetItem($input,i));
else {
- PyErr_SetString(PyExc_TypeError,"list must contain strings");
- free($2);
- return NULL;
+ PyErr_SetString(PyExc_TypeError,"list must contain strings");
+ free($2);
+ return NULL;
}
}
$2[i] = 0;
the typemap code. For example:</P>
<DIV class="targetlang">
<PRE>
->>> foo(["foo","bar","spam","1"])
+>>> foo(["foo", "bar", "spam", "1"])
</PRE>
</DIV>
-<H3><A name="Python_nn61"></A>34.9.3 Using typemaps to return arguments</H3>
+<P> If your function is overloaded in C++, for example:</P>
+<DIV class="code">
+<PRE>
+int foo(int argc, char **argv);
+int foo();
+</PRE>
+</DIV>
+<P> don't forget to also provide a suitable <A href="#Typemaps_overloading">
+typecheck typemap for overloading</A> such as:</P>
+<DIV class="code">
+<PRE>
+%typecheck(SWIG_TYPECHECK_STRING_ARRAY) (int argc, char **argv) {
+ $1 = PyList_Check($input) ? 1 : 0;
+}
+</PRE>
+</DIV>
+<P> If you don't you'll get an error message along the lines of:</P>
+<DIV class="shell">
+<PRE>
+Traceback (most recent call last):
+ File "runme.py", line 3, in >module<
+ example.foo(["foo", "bar", "spam", "1"])
+NotImplementedError: Wrong number or type of arguments for overloaded function 'foo'.
+ Possible C/C++ prototypes are:
+ foo(int,char **)
+ foo()
+</PRE>
+</DIV>
+<H3><A name="Python_nn61">36.9.3 Using typemaps to return arguments</A></H3>
<P> A common problem in some C programs is that values may be returned
in arguments rather than in the return value of a function. For
example:</P>
<PRE>
/* Returns a status value and two values in out1 and out2 */
int spam(double a, double b, double *out1, double *out2) {
- ... Do a bunch of stuff ...
- *out1 = result1;
- *out2 = result2;
- return status;
-};
-
+ ... Do a bunch of stuff ...
+ *out1 = result1;
+ *out2 = result2;
+ return status;
+}
</PRE>
</DIV>
<P> A typemap can be used to handle this case as follows :</P>
// is guaranteed to be a List object by SWIG.
%typemap(argout) double *OutValue {
- PyObject *o, *o2, *o3;
- o = PyFloat_FromDouble(*$1);
- if ((!$result) || ($result == Py_None)) {
- $result = o;
- } else {
- if (!PyTuple_Check($result)) {
- PyObject *o2 = $result;
- $result = PyTuple_New(1);
- PyTuple_SetItem(target,0,o2);
- }
- o3 = PyTuple_New(1);
- PyTuple_SetItem(o3,0,o);
- o2 = $result;
- $result = PySequence_Concat(o2,o3);
- Py_DECREF(o2);
- Py_DECREF(o3);
+ PyObject *o, *o2, *o3;
+ o = PyFloat_FromDouble(*$1);
+ if ((!$result) || ($result == Py_None)) {
+ $result = o;
+ } else {
+ if (!PyTuple_Check($result)) {
+ PyObject *o2 = $result;
+ $result = PyTuple_New(1);
+ PyTuple_SetItem($result,0,o2);
}
+ o3 = PyTuple_New(1);
+ PyTuple_SetItem(o3,0,o);
+ o2 = $result;
+ $result = PySequence_Concat(o2,o3);
+ Py_DECREF(o2);
+ Py_DECREF(o3);
+ }
}
int spam(double a, double b, double *OutValue, double *OutValue);
>>>
</PRE>
</DIV>
-<H3><A name="Python_nn62"></A>34.9.4 Mapping Python tuples into small
- arrays</H3>
+<H3><A name="Python_nn62">36.9.4 Mapping Python tuples into small arrays</A>
+</H3>
<P> In some applications, it is sometimes desirable to pass small arrays
of numbers as arguments. For example :</P>
<DIV class="code">
<P> Since our mapping copies the contents of a Python tuple into a C
array, such an approach would not be recommended for huge arrays, but
for small structures, this approach works fine.</P>
-<H3><A name="Python_nn63"></A>34.9.5 Mapping sequences to C arrays</H3>
+<H3><A name="Python_nn63">36.9.5 Mapping sequences to C arrays</A></H3>
<P> Suppose that you wanted to generalize the previous example to handle
C arrays of different sizes. To do this, you might write a typemap as
follows:</P>
}
</PRE>
</DIV>
-<H3><A name="Python_nn64"></A>34.9.6 Pointer handling</H3>
+<H3><A name="Python_nn64">36.9.6 Pointer handling</A></H3>
<P> Occasionally, it might be necessary to convert pointer values that
have been stored using the SWIG typed-pointer representation. Since
there are several ways in which pointers can be represented, the
retrieve a pointer from any object that has a <TT>this</TT> attribute.
In addition, <TT>SWIG_NewPointerObj()</TT> can automatically generate a
proxy class object (if applicable).</P>
-<H2><A name="Python_nn65"></A>34.10 Docstring Features</H2>
+<H2><A name="Python_nn65">36.10 Docstring Features</A></H2>
<P> Using docstrings in Python code is becoming more and more important
and more tools are coming on the scene that take advantage of them,
everything from full-blown documentation generators to class browsers
docstrings to your modules, functions and methods that can then be used
by the various tools out there to make the programming experience of
your users much simpler.</P>
-<H3><A name="Python_nn66"></A>34.10.1 Module docstring</H3>
+<H3><A name="Python_nn66">36.10.1 Module docstring</A></H3>
<P> Python allows a docstring at the beginning of the <TT>.py</TT> file
before any other statements, and it is typically used to give a general
description of the entire module. SWIG supports this by setting an
%module(docstring=DOCSTRING) xrc
</PRE>
</DIV>
-<H3><A name="Python_nn67"></A>34.10.2 %feature("autodoc")</H3>
+<H3><A name="Python_nn67">36.10.2 %feature("autodoc")</A></H3>
<P> As alluded to above SWIG will generate all the function and method
proxy wrappers with just "*args" (or "*args, **kwargs" if the -keyword
option is used) for a parameter list and will then sort out the
four levels for autodoc controlled by the value given to the feature, <TT>
%feature("autodoc", "<I>level</I>")</TT>. The four values for<I> level</I>
are covered in the following sub-sections.</P>
-<H4><A name="Python_nn68"></A>34.10.2.1 %feature("autodoc", "0")</H4>
+<H4><A name="Python_nn68">36.10.2.1 %feature("autodoc", "0")</A></H4>
<P> When level "0" is used then the types of the parameters will<EM> not</EM>
be included in the autodoc string. For example, given this function
prototype:</P>
...
</PRE>
</DIV>
-<H4><A name="Python_nn69"></A>34.10.2.2 %feature("autodoc", "1")</H4>
+<H4><A name="Python_nn69">36.10.2.2 %feature("autodoc", "1")</A></H4>
<P> When level "1" is used then the parameter types<EM> will</EM> be
used in the autodoc string. In addition, an attempt is made to simplify
the type name such that it makes more sense to the Python user.
...
</PRE>
</DIV>
-<H4><A name="Python_autodoc2"></A>34.10.2.3 %feature("autodoc", "2")</H4>
+<H4><A name="Python_autodoc2">36.10.2.3 %feature("autodoc", "2")</A></H4>
<P> Level "2" results in the function prototype as per level "0". In
- addition, a line of documentation is generated for each parameter.
- Using the previous example, the generated code will be:</P>
+ addition, a line of documentation is generated for each parameter using
+ <A href="https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt">
+numpydoc</A> style. Using the previous example, the generated code will
+ be:</P>
<DIV class="targetlang">
<PRE>
def function_name(*args, **kwargs):
"""
function_name(x, y, foo=None, bar=None) -> bool
- Parameters:
- x: int
- y: int
- foo: Foo *
- bar: Bar *
+ Parameters
+ ----------
+ x: int
+ y: int
+ foo: Foo *
+ bar: Bar *
"""
...
"""
function_name(x, y, foo=None, bar=None) -> bool
- Parameters:
- x (C++ type: int) -- Input x dimension
- y: int
- foo: Foo *
- bar: Bar *
+ Parameters
+ ----------
+ x (C++ type: int) -- Input x dimension
+ y: int
+ foo: Foo *
+ bar: Bar *
"""
</PRE>
</DIV>
-<H4><A name="Python_autodoc3"></A>34.10.2.4 %feature("autodoc", "3")</H4>
+<H4><A name="Python_autodoc3">36.10.2.4 %feature("autodoc", "3")</A></H4>
<P> Level "3" results in the function prototype as per level "1" but
also contains the same additional line of documentation for each
parameter as per level "2". Using our earlier example again, the
"""
function_name(int x, int y, Foo foo=None, Bar bar=None) -> bool
- Parameters:
- x: int
- y: int
- foo: Foo *
- bar: Bar *
+ Parameters
+ ----------
+ x: int
+ y: int
+ foo: Foo *
+ bar: Bar *
"""
...
</PRE>
</DIV>
-<H4><A name="Python_nn70"></A>34.10.2.5 %feature("autodoc", "docstring")</H4>
+<H4><A name="Python_nn70">36.10.2.5 %feature("autodoc", "docstring")</A></H4>
<P> Finally, there are times when the automatically generated autodoc
string will make no sense for a Python programmer, particularly when a
typemap is involved. So if you give an explicit value for the autodoc
void GetPosition(int* OUTPUT, int* OUTPUT);
</PRE>
</DIV>
-<H3><A name="Python_nn71"></A>34.10.3 %feature("docstring")</H3>
+<H3><A name="Python_nn71">36.10.3 %feature("docstring")</A></H3>
<P> In addition to the autodoc strings described above, you can also
attach any arbitrary descriptive text to a node in the parse tree with
the "docstring" feature. When the proxy module is generated then any
"""
</PRE>
</DIV>
-<H2><A name="Python_nn72"></A>34.11 Python Packages</H2>
-<P> Using the <TT>package</TT> option of the <TT>%module</TT> directive
- allows you to specify what Python package that the module will be
- living in when installed.</P>
+<H2><A name="Python_nn72">36.11 Python Packages</A></H2>
+<P>Python has concepts of modules and packages. Modules are separate
+ units of code and may be grouped together to form a package. Packages
+ may be nested, that is they may contain subpackages. This leads to
+ tree-like hierarchy, with packages as intermediate nodes and modules as
+ leaf nodes.</P>
+<P>The hierarchy of Python packages/modules follows the hierarchy of <TT>
+*.py</TT> files found in a source tree (or, more generally, in the
+ Python path). Normally, the developer creates new module by placing a <TT>
+*.py</TT> file somewhere under Python path; the module is then named
+ after that <TT>*.py</TT> file. A package is created by placing an <TT>
+__init__.py</TT> file within a directory; the package is then named
+ after that directory. For example, the following source tree:</P>
+<DIV class="diagram">
+<PRE>
+mod1.py
+pkg1/__init__.py
+pkg1/mod2.py
+pkg1/pkg2/__init__.py
+pkg1/pkg2/mod3.py
+</PRE>
+</DIV>
+<P> defines the following Python packages and modules:</P>
+<DIV class="diagram">
+<PRE>
+pkg1 # package
+pkg1.pkg2 # package
+mod1 # module
+pkg1.mod2 # module
+pkg1.pkg2.mod3 # module
+</PRE>
+</DIV>
+<P> The purpose of an <TT>__init__.py</TT> file is two-fold. First, the
+ existence of <TT>__init__.py</TT> in a directory informs the Python
+ interpreter that this directory contains a Python package. Second, the
+ code in <TT>__init__.py</TT> is loaded/executed automatically when the
+ package is initialized (when it or its submodule/subpackage gets <TT>
+import</TT>'ed). By default, SWIG generates proxy Python code – one <TT>
+*.py</TT> file for each <TT>*.i</TT> interface. The <TT>__init__.py</TT>
+ files, however, are not generated by SWIG. They should be created by
+ other means. Both files (module <TT>*.py</TT> and <TT>__init__.py</TT>)
+ should be installed in appropriate destination directories in order to
+ obtain a desirable package/module hierarchy.</P>
+<P> Python3 adds another option for packages with <A href="https://www.python.org/dev/peps/pep-0420/">
+PEP 0420</A> (implicit namespace packages). Implicit namespace packages
+ no longer use __init__.py files. SWIG generated Python modules support
+ implicit namespace packages. See <A href="#Python_implicit_namespace_packages">
+36.11.5 Implicit Namespace Packages</A> for more information.</P>
+<P> If you place a SWIG generated module into a Python package then
+ there are details concerning the way SWIG <A href="#Python_package_search">
+searches for the wrapper module</A> that you may want to familiarize
+ yourself with.</P>
+<P>The way Python defines its modules and packages impacts SWIG users.
+ Some users may need to use special features such as the <TT>package</TT>
+ option in the <TT>%module</TT> directive or import related command line
+ options. These are explained in the following sections.</P>
+<H3><A name="Python_modulepackage">36.11.1 Setting the Python package</A>
+</H3>
+<P> Using the <TT>package</TT> option in the <TT>%module</TT> directive
+ allows you to specify a Python package that the module will be in when
+ installed.</P>
<DIV class="code">
<PRE>
%module(package="wx") xrc
<P> This is useful when the <TT>.i</TT> file is <TT>%import</TT>ed by
another <TT>.i</TT> file. By default SWIG will assume that the importer
is able to find the importee with just the module name, but if they
- live in separate Python packages then that won't work. However if the
+ live in separate Python packages then this won't work. However if the
importee specifies what its package is with the <TT>%module</TT> option
then the Python code generated for the importer will use that package
- name when importing the other module and also in base class
- declarations, etc. if the package name is different than its own.</P>
-<H2><A name="Python_python3support"></A>34.12 Python 3 Support</H2>
+ name when importing the other module and in base class declarations,
+ etc..</P>
+<P>SWIG assumes that the <TT>package</TT> option provided to <TT>%module</TT>
+ together with the <TT>module</TT> name (that is, <TT>wx.xrc</TT> in the
+ above example) forms a fully qualified (absolute) name of a module (in
+ Python terms). This is important especially for Python 3, where
+ absolute imports are used by default. It's up to you to place the
+ generated module files (<TT>.py</TT>, <TT>.so</TT>) in appropriate
+ subdirectories. For example, if you have an interface file <TT>foo.i</TT>
+ with:</P>
+<DIV class="code">
+<PRE>
+%module(package="pkg1.pkg2") foo
+</PRE>
+</DIV>
+<P> then the resulting directory layout should be</P>
+<DIV class="diagram">
+<PRE>
+pkg1/
+pkg1/__init__.py
+pkg1/pkg2/__init__.py
+pkg1/pkg2/foo.py # (generated by SWIG)
+pkg1/pkg2/_foo.so # (shared library built from C/C++ code generated by SWIG)
+</PRE>
+</DIV>
+<H3><A name="Python_absrelimports">36.11.2 Absolute and relative imports</A>
+</H3>
+<P>Suppose, we have the following hierarchy of files:</P>
+<DIV class="diagram">
+<PRE>
+pkg1/
+pkg1/__init__.py
+pkg1/mod2.py
+pkg1/pkg2/__init__.py
+pkg1/pkg2/mod3.py
+</PRE>
+</DIV>
+<P>Let the contents of <TT>pkg1/pkg2/mod3.py</TT> be</P>
+<DIV class="targetlang">
+<PRE>
+class M3: pass
+</PRE>
+</DIV>
+<P> We edit <TT>pkg1/mod2.py</TT> and want to import module <TT>
+pkg1/pkg2/mod3.py</TT> in order to derive from class <TT>M3</TT>. We can
+ write appropriate Python code in several ways, for example:</P>
+<OL>
+<LI>
+<P>Using "<TT>import <></TT>" syntax with absolute package name:</P>
+<DIV class="targetlang">
+<PRE>
+# pkg1/mod2.py
+import pkg1.pkg2.mod3
+class M2(pkg1.pkg2.mod3.M3): pass
+</PRE>
+</DIV></LI>
+<LI>
+<P>Using "<TT>import <></TT>" syntax with package name relative to <TT>
+pkg1</TT> (only in Python 2.7 and earlier):</P>
+<DIV class="targetlang">
+<PRE>
+# pkg1/mod2.py
+import pkg2.mod3
+class M2(pkg2.mod3.M3): pass
+</PRE>
+</DIV></LI>
+<LI>
+<P>Using "<TT>from <> import <></TT>" syntax (relative import syntax,
+ only in Python 2.5 and later):</P>
+<DIV class="targetlang">
+<PRE>
+# pkg1/mod2.py
+from .pkg2 import mod3
+class M2(mod3.M3): pass
+</PRE>
+</DIV></LI>
+<LI>
+<P>Other variants, for example the following construction in order to
+ have the <TT>pkg2.mod3.M3</TT> symbol available in <TT>mod2</TT> as in
+ point 2 above (but now under Python 3):</P>
+<DIV class="targetlang">
+<PRE>
+# pkg1/mod2.py
+from . import pkg2
+from .pkg2 import mod3
+class M2(pkg2.mod3.M3): pass
+</PRE>
+</DIV></LI>
+</OL>
+<P>Now suppose we have <TT>mod2.i</TT> with</P>
+<DIV class="code">
+<PRE>
+// mod2.i
+%module (package="pkg1") mod2
+%import "mod3.i"
+// ...
+</PRE>
+</DIV>
+<P>and <TT>mod3.i</TT> with</P>
+<DIV class="code">
+<PRE>
+// mod3.i
+%module (package="pkg1.pkg2") mod3
+// ...
+</PRE>
+</DIV>
+<P>By default, SWIG would generate <TT>mod2.py</TT> proxy file with <TT>
+import</TT> directive as in point 1. This can be changed with the <TT>
+-relativeimport</TT> command line option. The <TT>-relativeimport</TT>
+ instructs SWIG to organize imports as in point 2 (for Python < 2.7.0)
+ or as in point 4 for Python 2.7.0 and newer. This is a check done at
+ the time the module is imported. In short, if you have <TT>mod2.i</TT>
+ and <TT>mod3.i</TT> as above, then without <TT>-relativeimport</TT>
+ SWIG will write</P>
+<DIV class="targetlang">
+<PRE>
+import pkg1.pkg2.mod3
+</PRE>
+</DIV>
+<P>to <TT>mod2.py</TT> proxy file, and with <TT>-relativeimport</TT> it
+ will write</P>
+<DIV class="targetlang">
+<PRE>
+from sys import version_info
+if version_info >= (2, 7, 0):
+ from . import pkg2
+ import pkg1.pkg2.mod3
+else:
+ import pkg2.mod3
+del version_info
+</PRE>
+</DIV>
+<P>You should avoid using relative imports and use absolute ones
+ whenever possible. There are some cases, however, when relative imports
+ may be necessary. The first example is, when some (legacy) Python code
+ refers entities imported by proxy files generated by SWIG, and it
+ assumes that the proxy file uses relative imports. Second case is, when
+ one puts import directives in <TT>__init__.py</TT> to import symbols
+ from submodules or subpackages and the submodule depends on other
+ submodules (discussed later).</P>
+<H3><A name="Python_absimport">36.11.3 Enforcing absolute import
+ semantics</A></H3>
+<P>As you may know, there is an incompatibility in import semantics (for
+ the <TT>import <></TT> syntax) between Python 2 and 3. In Python 2.4
+ and earlier it is not clear whether</P>
+<DIV class="targetlang">
+<PRE>
+import foo
+</PRE>
+</DIV>
+<P>refers to a top-level module or to another module inside the current
+ package. In Python 3 it always refers to a top-level module (see <A href="https://www.python.org/dev/peps/pep-0328/">
+PEP 328</A>). To instruct Python 2.5 through 2.7 to use new semantics
+ (that is <TT>import foo</TT> is interpreted as absolute import), one
+ has to put the following line</P>
+<DIV class="targetlang">
+<PRE>
+from __future__ import absolute_import
+</PRE>
+</DIV>
+<P>at the very beginning of his proxy <TT>*.py</TT> file. In SWIG, it
+ may be accomplished with <TT>%pythonbegin</TT> directive as follows:</P>
+<DIV class="code">
+<PRE>
+%pythonbegin %{
+from __future__ import absolute_import
+%}
+</PRE>
+</DIV>
+<H3><A name="Python_importfrominit">36.11.4 Importing from __init__.py</A>
+</H3>
+<P>Imports in <TT>__init__.py</TT> are handy when you want to populate a
+ package's namespace with names imported from other modules. In SWIG
+ based projects this approach may also be used to split large pieces of
+ code into smaller modules, compile them in parallel and then
+ re-assemble everything at runtime by importing submodules' contents in <TT>
+__init__.py</TT>, for example.</P>
+<P>Unfortunately import directives in <TT>__init__.py</TT> may cause
+ problems, especially if they refer to a package's submodules. This is
+ caused by the way Python initializes packages. If you spot problems
+ with imports from <TT>__init__.py</TT> try using <TT>-relativeimport</TT>
+ option. Below we explain in detail one issue, for which the <TT>
+-relativeimport</TT> workaround may be helpful.</P>
+<P>Consider the following example (Python 3):</P>
+<DIV class="diagram">
+<PRE>
+pkg1/__init__.py # (empty)
+pkg1/pkg2/__init__.py # (imports something from bar.py)
+pkg1/pkg2/foo.py
+pkg1/pkg2/bar.py # (imports foo.py)
+</PRE>
+</DIV>
+<P>If the file contents are:</P>
+<UL>
+<LI>
+<P><TT>pkg1/pkg2/__init__.py:</TT></P>
+<DIV class="targetlang">
+<PRE>
+# pkg1/pkg2/__init__.py
+from .bar import Bar
+</PRE>
+</DIV></LI>
+<LI>
+<P><TT>pkg1/pkg2/foo.py:</TT></P>
+<DIV class="targetlang">
+<PRE>
+# pkg1/pkg2/foo.py
+class Foo: pass
+</PRE>
+</DIV></LI>
+<LI>
+<P><TT>pkg1/pkg2/bar.py:</TT></P>
+<DIV class="targetlang">
+<PRE>
+# pkg1/pkg2/bar.py
+import pkg1.pkg2.foo
+class Bar(pkg1.pkg2.foo.Foo): pass
+</PRE>
+</DIV></LI>
+</UL>
+<P>Now if one simply used <TT>import pkg1.pkg2</TT>, it will usually
+ fail:</P>
+<DIV class="diagram">
+<PRE>
+>>> import pkg1.pkg2
+Traceback (most recent call last):
+ File "<stdin>", line 1, in <module>
+ File "./pkg1/pkg2/__init__.py", line 2, in <module>
+ from .bar import Bar
+ File "./pkg1/pkg2/bar.py", line 3, in <module>
+ class Bar(pkg1.pkg2.foo.Foo): pass
+AttributeError: 'module' object has no attribute 'pkg2'
+</PRE>
+</DIV>
+<P>Surprisingly, if we execute the <TT>import pkg1.pkg2</TT> directive
+ for the second time, it succeeds. The reason seems to be following:
+ when Python spots the <TT>from .bar import Bar</TT> directive in <TT>
+pkg1/pkg2/__init__.py</TT> it starts loading <TT>pkg1/pkg2/bar.py</TT>.
+ This module imports <TT>pkg1.pkg2.foo</TT> in turn and tries to use <TT>
+pkg1.pkg2.foo.Foo</TT>, but the package <TT>pkg1</TT> is not fully
+ initialized yet (the initialization procedure is actually in progress)
+ and it seems like the effect of the already seen <TT>import
+ pkg1.pkg2.pkg3.foo</TT> is "delayed" or ignored. Exactly the same may
+ happen to a proxy module generated by SWIG.</P>
+<P>One workaround for this case is to use a relative import in <TT>
+pkg1/pkg2/bar.py</TT>. If we change <TT>bar.py</TT> to be:</P>
+<DIV class="targetlang">
+<PRE>
+from .pkg3 import foo
+class Bar(foo.Foo): pass
+</PRE>
+</DIV>
+<P>or</P>
+<DIV class="targetlang">
+<PRE>
+from . import pkg3
+from .pkg3 import foo
+class Bar(pkg3.foo.Foo): pass
+</PRE>
+</DIV>
+<P>then the example works again. With SWIG, you need to enable the <TT>
+-relativeimport</TT> option in order to have the above workaround in
+ effect (note, that the Python 2 case also needs the <TT>-relativeimport</TT>
+ workaround).</P>
+<H3><A name="Python_implicit_namespace_packages">36.11.5 Implicit
+ Namespace Packages</A></H3>
+<P> Python 3.3 introduced <A href="https://www.python.org/dev/peps/pep-0420/">
+PEP 0420</A> which implements implicit namespace packages. In a
+ nutshell, implicit namespace packages remove the requirement of an
+ __init__.py file and allow packages to be split across multiple PATH
+ elements. For example:</P>
+<DIV class="diagram">
+<PRE>
+/fragment1/pkg1/mod1.py
+/fragment2/pkg1/mod2.py
+/fragment3/pkg1/mod3.py
+</PRE>
+</DIV>
+<P>If PYTHONPATH is set to "/fragment1:/fragment2:/fragment3", then
+ mod1, mod2 and mod3 will be part of pkg1. This allows for splitting of
+ packages into separate pieces. This can be useful for SWIG generated
+ wrappers in the following way.</P>
+<P> Suppose you create a SWIG wrapper for a module called robin. The
+ SWIG generated code consists of two files robin.py and _robin.so. You
+ wish to make these modules part of a subpackage (brave.sir). With
+ implicit namespace packages you can place these files in the following
+ configurations:</P>
+<P>Using PYTHONPATH="/some/path"</P>
+<DIV class="diagram">
+<PRE>
+/some/path/brave/sir/robin.py
+/some/path/brave/sir/_robin.so
+</PRE>
+</DIV>
+<P>Using PYTHONPATH="/some/path:/some/other/path"<DIV class="diagram">
+<PRE>
+/some/path/brave/sir/robin.py
+/some/other/path/brave/sir/_robin.so
+</PRE>
+</DIV></P>
+<P> Finally suppose that your pure python code is stored in a .zip file
+ or some other way (database, web service connection, etc). Python can
+ load the robin.py module using a custom importer. But the _robin.so
+ module will need to be located on a file system. Implicit namespace
+ packages make this possible. For example, using
+ PYTHONPATH="/some/path/foo.zip:/some/other/path"</P>
+<P> Contents of foo.zip</P>
+<DIV class="diagram">
+<PRE>
+brave/
+brave/sir/
+brave/sir/robin.py
+</PRE>
+</DIV>
+<P> File system contents</P>
+<DIV class="diagram">
+<PRE>
+/some/other/path/brave/sir/_robin.so
+</PRE>
+</DIV>
+<P>Support for implicit namespace packages was added to python-3.3. The
+ zipimporter requires python-3.5.1 or newer to work with subpackages.</P>
+<P><B> Compatibility Note:</B> Support for implicit namespace packages
+ was added in SWIG-3.0.9.</P>
+<H3><A name="Python_package_search">36.11.6 Searching for the wrapper
+ module</A></H3>
+<P> When SWIG creates wrappers from an interface file, say foo.i, two
+ Python modules are created. There is a pure Python module module
+ (foo.py) and C/C++ code which is built and linked into a dynamically
+ (or statically) loaded module _foo (see the <A href="#Python_nn3">
+Preliminaries section</A> for details). So, the interface file really
+ defines two Python modules. How these two modules are loaded is covered
+ next.</P>
+<P> The pure Python module needs to load the C/C++ module in order to
+ link to the wrapped C/C++ methods. To do this it must make some
+ assumptions about what package the C/C++ module may be located in. The
+ approach the pure Python module uses to find the C/C++ module is as
+ follows:</P>
+<OL>
+<LI>
+<P>The pure Python module, foo.py, tries to load the C/C++ module, _foo,
+ from the same package foo.py is located in. The package name is
+ determined from the <TT>__name__</TT> attribute given to foo.py by the
+ Python loader that imported foo.py. If foo.py is not in a package then
+ _foo is loaded as a global module.</P>
+</LI>
+<LI>
+<P>If the above import of _foo results in an ImportError being thrown,
+ then foo.py makes a final attempt to load _foo as a global module.</P>
+</LI>
+</OL>
+<P> As an example suppose foo.i is compiled into foo.py and _foo.so.
+ Assuming /dir is on PYTHONPATH, then the two modules can be installed
+ and used in the following ways:</P>
+<H4><A name="Python_package_search_both_package_modules">36.11.6.1 Both
+ modules in the same package</A></H4>
+<P>Both modules are in one package:</P>
+<DIV class="diagram">
+<PRE>
+/dir/package/foo.py
+/dir/package/__init__.py
+/dir/package/_foo.so
+</PRE>
+</DIV>
+<P>And imported with</P>
+<DIV class="diagram">
+<PRE>
+from package import foo
+</PRE>
+</DIV>
+<H4><A name="Python_package_search_wrapper_split">36.11.6.2 Split
+ modules</A></H4>
+<P>The pure python module is in a package and the C/C++ module is
+ global:</P>
+<DIV class="diagram">
+<PRE>
+/dir/package/foo.py
+/dir/package/__init__.py
+/dir/_foo.so
+</PRE>
+</DIV>
+<P>And imported with</P>
+<DIV class="diagram">
+<PRE>
+from package import foo
+</PRE>
+</DIV>
+<H4><A name="Python_package_search_both_global_modules">36.11.6.3 Both
+ modules are global</A></H4>
+<P>Both modules are global:</P>
+<DIV class="diagram">
+<PRE>
+/dir/foo.py
+/dir/_foo.so
+</PRE>
+</DIV>
+<P>And imported with</P>
+<DIV class="diagram">
+<PRE>
+import foo
+</PRE>
+</DIV>
+<P> If _foo is statically linked into an embedded Python interpreter,
+ then it may or may not be in a Python package. This depends in the
+ exact way the module was loaded statically. The above search order will
+ still be used for statically loaded modules. So, one may place the
+ module either globally or in a package as desired.</P>
+<H4><A name="Python_package_search_static">36.11.6.4 Statically linked C
+ modules</A></H4>
+<P>It is strongly recommended to use dynamically linked modules for the
+ C portion of your pair of Python modules. If for some reason you still
+ need to link the C module of the pair of Python modules generated by
+ SWIG into your interpreter, then this section provides some details on
+ how this impacts the pure Python modules ability to locate the other
+ part of the pair. Please also see the <A href="#Python_nn8">Static
+ Linking</A> section.</P>
+<P>When Python is extended with C code the Python interpreter needs to
+ be informed about details of the new C functions that have been linked
+ into the executable. The code to do this is created by SWIG and is
+ automatically called in the correct way when the module is dynamically
+ loaded. However when the code is not dynamically loaded (because it is
+ statically linked) Then the initialization method for the module
+ created by SWIG is not called automatically and the Python interpreter
+ has no idea that the new SWIG C module exists.</P>
+<P>Before Python 3, one could simply call the init method created by
+ SWIG which would have normally been called when the shared object was
+ dynamically loaded. The specific name of this method is not given here
+ because statically linked modules are not encouraged with SWIG (<A href="#Python_nn8">
+Static Linking</A>). However one can find this init function in the C
+ file generated by SWIG.</P>
+<P>If you are really keen on static linking there are two ways to
+ initialize the SWIG generated C module with the init method. Which way
+ you use depends on what version of Python your module is being linked
+ with. Python 2 and Python 3 treat this init function differently. And
+ the way they treat it affects how the pure Python module will be able
+ to locate the C module.</P>
+<P>The details concerning this are covered completly in the
+ documentation for Python itself. Links to the relavent sections follow:</P>
+<UL>
+<LI><A href="https://docs.python.org/2/extending/extending.html#methodtable">
+Extending in python2</A></LI>
+<LI><A href="https://docs.python.org/3.6/extending/extending.html#the-module-s-method-table-and-initialization-function">
+Extending in python3</A></LI>
+</UL>
+<P>There are two keys things to understand. The first is that in Python
+ 2 the init() function returns void. In Python 3 the init() function
+ returns a PyObject * which points to the new module. Secondly, when you
+ call the init() method manually, you are the Python importer. So, you
+ determine which package the C module will be located in.</P>
+<P>So, if you are using Python 3 it is important that you follow what is
+ described in the Python documentation linked above. In particular, you
+ can't simply call the init() function generated by SWIG and cast the
+ PyObject pointer it returns over the side. If you do then Python 3 will
+ have no idea that your C module exists and the pure Python half of your
+ wrapper will not be able to find it. You need to register your module
+ with the Python interpreter as described in the Python docs.</P>
+<P>With Python 2 things are somewhat more simple. In this case the init
+ function returns void. Calling it will register your new C module as a<B>
+ global</B> module. The pure Python part of the SWIG wrapper will be
+ able to find it because it tries both the pure Python module it is part
+ of and the global module. If you wish not to have the statically linked
+ module be a global module then you will either need to refer to the
+ Python documentation on how to do this (remember you are now the Python
+ importer) or use dynamic linking.</P>
+<H2><A name="Python_python3support">36.12 Python 3 Support</A></H2>
<P> SWIG is able to support Python 3.0. The wrapper code generated by
SWIG can be compiled with both Python 2.x or 3.0. Further more, by
passing the <TT>-py3</TT> command line option to SWIG, wrapper code
</UL>
<P> The following are Python 3.0 new features that are currently
supported by SWIG.</P>
-<H3><A name="Python_nn74"></A>34.12.1 Function annotation</H3>
+<H3><A name="Python_nn74">36.12.1 Function annotation</A></H3>
<P> The <TT>-py3</TT> option will enable function annotation support.
When used SWIG is able to generate proxy method definitions like this:</P>
<DIV class="code">
may be append depend on whether you enabled the keyword argument. This
fallback is due to all overloaded functions share the same function in
SWIG generated proxy class.</P>
-<P> For detailed usage of function annotation, see <A href="http://www.python.org/dev/peps/pep-3107/">
+<P> For detailed usage of function annotation, see <A href="https://www.python.org/dev/peps/pep-3107/">
PEP 3107</A>.</P>
-<H3><A name="Python_nn75"></A>34.12.2 Buffer interface</H3>
+<H3><A name="Python_nn75">36.12.2 Buffer interface</A></H3>
<P> Buffer protocols were revised in Python 3. SWIG also gains a series
of new typemaps to support buffer interfaces. These typemap macros are
defined in <TT>pybuffer.i</TT>, which must be included in order to use
immutable buffers. As a result, the wrapped function should not modify
the buffer.</P>
</DIV>
-<P><B> %pybuffer_string(parm)</B></P>
-<DIV class="indent">
-<P> This macro maps an object's buffer as a string pointer <TT>parm</TT>
-. It is similar to <TT>%pybuffer_mutable_string</TT> but the buffer
- could be both mutable and immutable. And your function should not
- modify the buffer.</P>
+<P><B> %pybuffer_string(parm)</B></P>
+<DIV class="indent">
+<P> This macro maps an object's buffer as a string pointer <TT>parm</TT>
+. It is similar to <TT>%pybuffer_mutable_string</TT> but the buffer
+ could be both mutable and immutable. And your function should not
+ modify the buffer.</P>
+</DIV>
+<H3><A name="Python_nn76">36.12.3 Abstract base classes</A></H3>
+<P> By including <TT>pyabc.i</TT> and using the <TT>-py3</TT> command
+ line option when calling SWIG, the proxy classes of the STL containers
+ will automatically gain an appropriate abstract base class. For
+ example, the following SWIG interface:</P>
+<DIV class="code">
+<PRE>
+%include <pyabc.i>
+%include <std_map.i>
+%include <std_list.i>
+
+namespace std {
+ %template(Mapii) map<int, int>;
+ %template(IntList) list<int>;
+}
+</PRE>
+</DIV>
+<P> will generate a Python proxy class <TT>Mapii</TT> inheriting from <TT>
+collections.MutableMap</TT> and a proxy class <TT>IntList</TT>
+ inheriting from <TT>collections.MutableSequence</TT>.</P>
+<P> <TT>pyabc.i</TT> also provides a macro <TT>%pythonabc</TT> that
+ could be used to define an abstract base class for your own C++ class:</P>
+<DIV class="code">
+<PRE>
+%pythonabc(MySet, collections.MutableSet);
+</PRE>
+</DIV>
+<P> For details of abstract base class, please see <A href="https://www.python.org/dev/peps/pep-3119/">
+PEP 3119</A>.</P>
+<H3><A name="Python_nn77">36.12.4 Byte string output conversion</A></H3>
+<P> By default, any byte string (<TT>char*</TT> or <TT>std::string</TT>)
+ returned from C or C++ code is decoded to text as UTF-8. This decoding
+ uses the <TT>surrogateescape</TT> error handler under Python 3.1 or
+ higher -- this error handler decodes invalid byte sequences to high
+ surrogate characters in the range U+DC80 to U+DCFF. As an example,
+ consider the following SWIG interface, which exposes a byte string that
+ cannot be completely decoded as UTF-8:</P>
+<DIV class="code">
+<PRE>
+%module example
+
+%include <std_string.i>
+
+%inline %{
+
+const char* non_utf8_c_str(void) {
+ return "h\xe9llo w\xc3\xb6rld";
+}
+
+%}
+</PRE>
+</DIV>
+<P> When this method is called from Python 3, the return value is the
+ following text string:</P>
+<DIV class="targetlang">
+<PRE>
+>>> s = example.non_utf8_c_str()
+>>> s
+'h\udce9llo wörld'
+</PRE>
+</DIV>
+<P> Since the C string contains bytes that cannot be decoded as UTF-8,
+ those raw bytes are represented as high surrogate characters that can
+ be used to obtain the original byte sequence:</P>
+<DIV class="targetlang">
+<PRE>
+>>> b = s.encode('utf-8', errors='surrogateescape')
+>>> b
+b'h\xe9llo w\xc3\xb6rld'
+</PRE>
+</DIV>
+<P> One can then attempt a different encoding, if desired (or simply
+ leave the byte string as a raw sequence of bytes for use in binary
+ protocols):</P>
+<DIV class="targetlang">
+<PRE>
+>>> b.decode('latin-1')
+'héllo wörld'
+</PRE>
+</DIV>
+<P> Note, however, that text strings containing surrogate characters are
+ rejected with the default <TT>strict</TT> codec error handler. For
+ example:</P>
+<DIV class="targetlang">
+<PRE>
+>>> with open('test', 'w') as f:
+... print(s, file=f)
+...
+Traceback (most recent call last):
+ File "<stdin>", line 2, in <module>
+UnicodeEncodeError: 'utf-8' codec can't encode character '\udce9' in position 1: surrogates not allowed
+</PRE>
+</DIV>
+<P> This requires the user to check most strings returned by SWIG
+ bindings, but the alternative is for a non-UTF8 byte string to be
+ completely inaccessible in Python 3 code.</P>
+<P> For more details about the <TT>surrogateescape</TT> error handler,
+ please see <A href="https://www.python.org/dev/peps/pep-0383/">PEP 383</A>
+.</P>
+<P> In some cases, users may wish to instead handle all byte strings as
+ bytes objects in Python 3. This can be accomplished by adding <TT>
+SWIG_PYTHON_STRICT_BYTE_CHAR</TT> to the generated code:</P>
+<DIV class="code">
+<PRE>
+%module char_to_bytes
+%begin %{
+#define SWIG_PYTHON_STRICT_BYTE_CHAR
+%}
+
+char *charstring(char *s) {
+ return s;
+}
+</PRE>
+</DIV>
+<P> This will modify the behavior so that only Python 3 bytes objects
+ will be accepted and converted to a C/C++ string, and any string
+ returned from C/C++ will be converted to a bytes object in Python 3:</P>
+<DIV class="targetlang">
+<PRE>
+>>> from char_to_bytes import *
+>>> charstring(b"hi") # Byte string
+b'hi'
+>>> charstring("hi") # Unicode string
+Traceback (most recent call last):
+ File "<stdin>", line 1, in ?
+TypeError: in method 'charstring', argument 1 of type 'char *'
+</PRE>
+</DIV>
+<P> Note that in Python 2, defining <TT>SWIG_PYTHON_STRICT_BYTE_CHAR</TT>
+ has no effect, since strings in Python 2 are equivalent to Python 3
+ bytes objects. However, there is a similar capability to force
+ unicode-only handling for wide characters C/C++ strings (<TT>wchar_t *</TT>
+ or <TT>std::wstring</TT> types) in Python 2. By default, in Python 2
+ both strings and unicode strings are converted to C/C++ wide strings,
+ and returned wide strings are converted to a Python unicode string. To
+ instead only convert unicode strings to wide strings, users can add <TT>
+SWIG_PYTHON_STRICT_UNICODE_WCHAR</TT> to the generated code:</P>
+<DIV class="code">
+<PRE>
+%module wchar_to_unicode
+%begin %{
+#define SWIG_PYTHON_STRICT_UNICODE_WCHAR
+%}
+
+wchar_t *wcharstring(wchar_t *s) {
+ return s;
+}
+</PRE>
+</DIV>
+<P> This ensures that only unicode strings are accepted by wcharstring
+ in both Python 2 and Python 3:</P>
+<DIV class="targetlang">
+<PRE>
+>>> from wchar_to_unicode import *
+>>> wcharstring(u"hi") # Unicode string
+u'hi'
+>>> wcharstring(b"hi") # Byte string
+Traceback (most recent call last):
+ File "<stdin>", line 1, in ?
+TypeError: in method 'charstring', argument 1 of type 'wchar_t *'
+</PRE>
+</DIV>
+<P> By defining both <TT>SWIG_PYTHON_STRICT_BYTE_CHAR</TT> and <TT>
+SWIG_PYTHON_STRICT_UNICODE_WCHAR</TT>, Python wrapper code can support
+ overloads taking both std::string (as Python bytes) and std::wstring
+ (as Python unicode).</P>
+<H3><A name="Python_2_unicode">36.12.5 Python 2 Unicode</A></H3>
+<P> A Python 3 string is a Unicode string so by default a Python 3
+ string that contains Unicode characters passed to C/C++ will be
+ accepted and converted to a C/C++ string (<TT>char *</TT> or <TT>
+std::string</TT> types). A Python 2 string is not a unicode string by
+ default and should a Unicode string be passed to C/C++ it will fail to
+ convert to a C/C++ string (<TT>char *</TT> or <TT>std::string</TT>
+ types). The Python 2 behavior can be made more like Python 3 by
+ defining <TT>SWIG_PYTHON_2_UNICODE</TT> when compiling the generated
+ C/C++ code. By default when the following is wrapped:</P>
+<DIV class="code">
+<PRE>
+%module unicode_strings
+char *charstring(char *s) {
+ return s;
+}
+</PRE>
</DIV>
-<H3><A name="Python_nn76"></A>34.12.3 Abstract base classes</H3>
-<P> By including <TT>pyabc.i</TT> and using the <TT>-py3</TT> command
- line option when calling SWIG, the proxy classes of the STL containers
- will automatically gain an appropriate abstract base class. For
- example, the following SWIG interface:</P>
+<P> An error will occur when using Unicode strings in Python 2:</P>
+<DIV class="targetlang">
+<PRE>
+>>> from unicode_strings import *
+>>> charstring("hi")
+'hi'
+>>> charstring(u"hi")
+Traceback (most recent call last):
+ File "<stdin>", line 1, in ?
+TypeError: in method 'charstring', argument 1 of type 'char *'
+</PRE>
+</DIV>
+<P> When the <TT>SWIG_PYTHON_2_UNICODE</TT> macro is added to the
+ generated code:</P>
<DIV class="code">
<PRE>
-%include <pyabc.i>
-%include <std_map.i>
-%include <std_list.i>
+%module unicode_strings
+%begin %{
+#define SWIG_PYTHON_2_UNICODE
+%}
-namespace std {
- %template(Mapii) map<int, int>;
- %template(IntList) list<int>;
+char *charstring(char *s) {
+ return s;
}
</PRE>
</DIV>
-<P> will generate a Python proxy class <TT>Mapii</TT> inheriting from <TT>
-collections.MutableMap</TT> and a proxy class <TT>IntList</TT>
- inheriting from <TT>collections.MutableSequence</TT>.</P>
-<P> <TT>pyabc.i</TT> also provides a macro <TT>%pythonabc</TT> that
- could be used to define an abstract base class for your own C++ class:</P>
-<DIV class="code">
+<P> Unicode strings will be successfully accepted and converted from
+ UTF-8, but note that they are returned as a normal Python 2 string:</P>
+<DIV class="targetlang">
<PRE>
-%pythonabc(MySet, collections.MutableSet);
+>>> from unicode_strings import *
+>>> charstring("hi")
+'hi'
+>>> charstring(u"hi")
+'hi'
+>>>
</PRE>
</DIV>
-<P> For details of abstract base class, please see <A href="http://www.python.org/dev/peps/pep-3119/">
-PEP 3119</A>.</P>
+<P> Note that defining both <TT>SWIG_PYTHON_2_UNICODE</TT> and <TT>
+SWIG_PYTHON_STRICT_BYTE_CHAR</TT> at the same time is not allowed, since
+ the first is allowing unicode conversion and the second is explicitly
+ prohibiting it.</P>
<!-- LocalWords: polymorphism Typemaps STL typemap typemaps Docstring autodoc
-->
<!-- LocalWords: lnsl lpthread distutils enums namespaces
-->
<HR NOSHADE>
-<H1><A name="R"></A>35 SWIG and R</H1>
+<H1><A name="R">37 SWIG and R</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
have been used to compile and run an R interface to QuantLib running on
Mandriva Linux with gcc. The R bindings also work on Microsoft Windows
using Visual C++.</P>
-<H2><A name="R_nn2"></A>35.1 Bugs</H2>
+<H2><A name="R_nn2">37.1 Bugs</A></H2>
<P> Currently the following features are not implemented or broken:</P>
<UL>
<LI>Garbage collection of created objects</LI>
<LI>C Array wrappings</LI>
</UL>
-<H2><A name="R_nn3"></A>35.2 Using R and SWIG</H2>
+<H2><A name="R_nn3">37.2 Using R and SWIG</A></H2>
<P> To use R and SWIG in C mode, execute the following commands where
example.c is the name of the file with the functions in them</P>
<DIV class="shell">
</DIV> The cacheMetaData(1) will cause R to refresh its object tables.
Without it, inheritance of wrapped objects may fail.
<P> These two files can be loaded in any order</P>
-<H2><A name="R_nn4"></A>35.3 Precompiling large R files</H2>
+<P> If you are compiling code yourself (not using R itself), there are a
+ few things to watch out for:</P>
+<UL>
+<LI>The output shared library name (to the left of the file extension)
+ MUST match the module name, or alternatively, you can also set the
+ -package NAME command line argument. See swig -r -help for more
+ information</LI>
+<LI>If you do not set the output file name appropriately, you might see
+ errors like<DIV class="shell">
+<PRE>
+> fact(4)
+Error in .Call("R_swig_fact", s_arg1, as.logical(.copy), PACKAGE = "example") :
+ "R_swig_fact" not available for .Call() for package "example"
+</PRE>
+</DIV></LI>
+<LI>Make sure the architecture of the shared library(x64 for instance),
+ matches the architecture of the R program you want to load your shared
+ library into</LI>
+</UL>
+<H2><A name="R_nn4">37.3 Precompiling large R files</A></H2>
In cases where the R file is large, one make save a lot of loading time
by precompiling the R wrapper. This can be done by creating the file
makeRData.R which contains the following
</PRE>
This will generate a compiled R file called BigFile.RData that will
save a large amount of loading time.
-<H2><A name="R_nn5"></A>35.4 General policy</H2>
+<H2><A name="R_nn5">37.4 General policy</A></H2>
<P> The general policy of the module is to treat the C/C++ as a basic
wrapping over the underlying functions and rely on the R type system to
provide R syntax.</P>
-<H2><A name="R_language_conventions"></A>35.5 Language conventions</H2>
+<H2><A name="R_language_conventions">37.5 Language conventions</A></H2>
<P> getitem and setitem use C++ conventions (i.e. zero based indices). [
<!---
and [ are overloaded to allow for R syntax (one based indices and
slices)
</p-->
</P>
-<H2><A name="R_nn6"></A>35.6 C++ classes</H2>
+<H2><A name="R_nn6">37.6 C++ classes</A></H2>
<P> C++ objects are implemented as external pointer objects with the
class being the mangled name of the class. The C++ classes are
encapsulated as an SEXP with an external pointer type. The class is the
mangled name of the class. The nice thing about R is that is allows you
to keep track of the pointer object which removes the necessity for a
lot of the proxy class baggage you see in other languages.</P>
-<H2><A name="R_nn7"></A>35.7 Enumerations</H2>
+<H2><A name="R_nn7">37.7 Enumerations</A></H2>
<P> enumerations are characters which are then converted back and forth
to ints before calling the C routines. All of the enumeration code is
done in R.</P>
<HR NOSHADE>
-<H1><A name="Ruby"></A>36 SWIG and Ruby</H1>
+<H1><A name="Ruby">38 SWIG and Ruby</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<LI><A href="#Ruby_nn23_1">C++ Standard Template Library (STL)</A></LI>
<LI><A href="#Ruby_C_STL_Functors">C++ STL Functors</A></LI>
<LI><A href="#Ruby_C_Iterators">C++ STL Iterators</A></LI>
-<LI><A href="#Ruby_nn24">C++ Smart Pointers</A></LI>
+<LI><A href="#Ruby_nn24">C++ Smart Pointers</A>
+<UL>
+<LI><A href="#Ruby_smart_pointers_shared_ptr">The shared_ptr Smart
+ Pointer</A></LI>
+<LI><A href="#Ruby_smart_pointers_generic">Generic Smart Pointers</A></LI>
+</UL>
+</LI>
<LI><A href="#Ruby_nn25">Cross-Language Polymorphism</A>
<UL>
<LI><A href="#Ruby_nn26">Exception Unrolling</A></LI>
</DIV>
<!-- INDEX -->
<P>This chapter describes SWIG's support of Ruby.</P>
-<H2><A name="Ruby_nn2"></A>36.1 Preliminaries</H2>
-<P> SWIG 1.3 is known to work with Ruby versions 1.6 and later. Given
+<H2><A name="Ruby_nn2">38.1 Preliminaries</A></H2>
+<P> SWIG 3.0 is known to work with Ruby versions 1.8 and later. Given
the choice, you should use the latest stable version of Ruby. You
should also determine if your system supports shared libraries and
dynamic loading. SWIG will work with or without dynamic loading, but
found in earlier chapters. At the very least, make sure you also read
the "<A href="#SWIG">SWIG Basics</A>" chapter. It is also assumed that
the reader has a basic understanding of Ruby.</P>
-<H3><A name="Ruby_nn3"></A>36.1.1 Running SWIG</H3>
+<H3><A name="Ruby_nn3">38.1.1 Running SWIG</A></H3>
<P> To build a Ruby module, run SWIG using the <TT>-ruby</TT> option:</P>
<DIV class="code shell">
<PRE>$ swig -ruby example.i
if compiling a C++ extension) that contains all of the code needed to
build a Ruby extension module. To finish building the module, you need
to compile this file and link it with the rest of your program.</P>
-<H3><A name="Ruby_nn4"></A>36.1.2 Getting the right header files</H3>
+<H3><A name="Ruby_nn4">38.1.2 Getting the right header files</A></H3>
<P> In order to compile the wrapper code, the compiler needs the <TT>
ruby.h</TT> header file. This file is usually contained in a directory
such as</P>
<DIV class="code shell diagram">
<PRE>/usr/lib/ruby/1.8/x86_64-linux-gnu/ruby.h
-/usr/local/lib/ruby/1.6/i686-linux/ruby.h
+/usr/include/ruby-2.1.0/ruby.h
</PRE>
</DIV>
<P> The exact location may vary on your machine, but the above location
can run Ruby to find out. For example:</P>
<DIV class="code shell">
<PRE>$ ruby -e 'puts $:.join("\n")'
-/usr/local/lib/ruby/site_ruby/1.6 /usr/local/lib/ruby/site_ruby/1.6/i686-linux
-/usr/local/lib/ruby/site_ruby /usr/local/lib/ruby/1.6 /usr/local/lib/ruby/1.6/i686-linux .
+/usr/local/lib/site_ruby/2.1.0
+/usr/local/lib/x86_64-linux-gnu/site_ruby
+/usr/local/lib/site_ruby
+/usr/lib/ruby/vendor_ruby/2.1.0
+/usr/lib/x86_64-linux-gnu/ruby/vendor_ruby/2.1.0
+/usr/lib/ruby/vendor_ruby
+/usr/lib/ruby/2.1.0
+/usr/lib/x86_64-linux-gnu/ruby/2.1.0
</PRE>
</DIV>
-<H3><A name="Ruby_nn5"></A>36.1.3 Compiling a dynamic module</H3>
+<H3><A name="Ruby_nn5">38.1.3 Compiling a dynamic module</A></H3>
<P> Ruby extension modules are typically compiled into shared libraries
that the interpreter loads dynamically at runtime. Since the exact
commands for doing this vary from platform to platform, your best bet
system would look something like this:</P>
<DIV class="code shell">
<PRE>$ swig -ruby example.i
-$ gcc -c example.c
-$ gcc -c example_wrap.c -I/usr/local/lib/ruby/1.6/i686-linux
+$ gcc -O2 -fPIC -c example.c
+$ gcc -O2 -fPIC -c example_wrap.c -I/usr/include/ruby-2.1.0
$ gcc -shared example.o example_wrap.o -o example.so
</PRE>
</DIV>
-<P> For other platforms it may be necessary to compile with the <TT>
--fPIC</TT> option to generate position-independent code. If in doubt,
- consult the manual pages for your compiler and linker to determine the
- correct set of options. You might also check the <A href="http://www.dabeaz.com/cgi-bin/wiki.pl">
+<P> The -fPIC option tells GCC to generate position-independent code
+ (PIC) which is required for most architectures (it's not vital on x86,
+ but still a good idea as it allows code pages from the library to be
+ shared between processes). Other compilers may need a different option
+ specified instead of -fPIC.</P>
+<P> If in doubt, consult the manual pages for your compiler and linker
+ to determine the correct set of options. You might also check the <A href="http://www.dabeaz.com/cgi-bin/wiki.pl">
SWIG Wiki</A> for additional information.</P>
-<H3><A name="Ruby_nn6"></A>36.1.4 Using your module</H3>
+<H3><A name="Ruby_nn6">38.1.4 Using your module</A></H3>
<P> Ruby<I> module</I> names must be capitalized, but the convention for
Ruby<I> feature</I> names is to use lowercase names. So, for example,
the<B> Etc</B> extension module is imported by requiring the<B> etc</B>
</DIV>
<P> will result in an extension module using the feature name "example"
and Ruby module name "Example".</P>
-<H3><A name="Ruby_nn7"></A>36.1.5 Static linking</H3>
+<H3><A name="Ruby_nn7">38.1.5 Static linking</A></H3>
<P> An alternative approach to dynamic linking is to rebuild the Ruby
interpreter with your extension module added to it. In the past, this
approach was sometimes necessary due to limitations in dynamic loading
the Ruby source, adding an entry to the <TT>ext/Setup</TT> file, adding
your directory to the list of extensions in the file, and finally
rebuilding Ruby.</P>
-<H3><A name="Ruby_nn8"></A>36.1.6 Compilation of C++ extensions</H3>
+<H3><A name="Ruby_nn8">38.1.6 Compilation of C++ extensions</A></H3>
<P> On most machines, C++ extension modules should be linked using the
C++ compiler. For example:</P>
<DIV class="code shell">
<PRE>
$ swig -c++ -ruby example.i
-$ g++ -c example.cxx
-$ g++ -c example_wrap.cxx -I/usr/local/lib/ruby/1.6/i686-linux
+$ g++ -fPIC -c example.cxx
+$ g++ -fPIC -c example_wrap.cxx -I/usr/include/ruby-2.1.0
$ g++ -shared example.o example_wrap.o -o example.so
</PRE>
</DIV>
$libs = append_library($libs, "supc++")
create_makefile('example')</PRE>
</DIV>
-<H2><A name="Ruby_nn9"></A>36.2 Building Ruby Extensions under Windows
- 95/NT</H2>
+<H2><A name="Ruby_nn9">38.2 Building Ruby Extensions under Windows 95/NT</A>
+</H2>
<P> Building a SWIG extension to Ruby under Windows 95/NT is roughly
similar to the process used with Unix. Normally, you will want to
produce a DLL that can be loaded into the Ruby interpreter. For all
order to build extensions, you may need to download the source
distribution to the Ruby package, as you will need the Ruby header
files.</P>
-<H3><A name="Ruby_nn10"></A>36.2.1 Running SWIG from Developer Studio</H3>
+<H3><A name="Ruby_nn10">38.2.1 Running SWIG from Developer Studio</A></H3>
<P> If you are developing your application within Microsoft developer
studio, SWIG can be invoked as a custom build option. The process
roughly follows these steps :</P>
Foo = 3.0
</PRE>
</DIV>
-<H2><A name="Ruby_nn11"></A>36.3 The Ruby-to-C/C++ Mapping</H2>
+<H2><A name="Ruby_nn11">38.3 The Ruby-to-C/C++ Mapping</A></H2>
<P> This section describes the basics of how SWIG maps C or C++
declarations in your SWIG interface files to Ruby constructs.</P>
-<H3><A name="Ruby_nn12"></A>36.3.1 Modules</H3>
+<H3><A name="Ruby_nn12">38.3.1 Modules</A></H3>
<P> The SWIG <TT>%module</TT> directive specifies the name of the Ruby
module. If you specify:</P>
<DIV class="code">
$ swig -ruby -prefix "foo::bar::" example.i
</PRE>
</DIV>
-<P> Starting with SWIG 1.3.20, you can also choose to wrap everything
- into the global module by specifying the <TT>-globalmodule</TT> option
- on the SWIG command line, i.e.</P>
-<DIV class="code shell">
-<PRE>
-$ swig -ruby -globalmodule example.i
-</PRE>
+<P> Starting with SWIG 1.3.20, you can also choose to wrap everything
+ into the global module by specifying the <TT>-globalmodule</TT> option
+ on the SWIG command line, i.e.</P>
+<DIV class="code shell">
+<PRE>
+$ swig -ruby -globalmodule example.i
+</PRE>
+</DIV>
+<P> Note that this does not relieve you of the requirement of specifying
+ the SWIG module name with the <TT>%module</TT> directive (or the <TT>
+-module</TT> command-line option) as described earlier.</P>
+<P>When choosing a module name, do not use the same name as a built-in
+ Ruby command or standard module name, as the results may be
+ unpredictable. Similarly, if you're using the <TT>-globalmodule</TT>
+ option to wrap everything into the global module, take care that the
+ names of your constants, classes and methods don't conflict with any of
+ Ruby's built-in names.</P>
+<H3><A name="Ruby_nn13">38.3.2 Functions</A></H3>
+<P> Global functions are wrapped as Ruby module methods. For example,
+ given the SWIG interface file <TT>example.i</TT>:</P>
+<DIV class="code">
+<PRE>%module example
+
+int fact(int n);</PRE>
+</DIV>
+<P> and C source file <TT>example.c</TT>:</P>
+<DIV class="code">
+<PRE>int fact(int n) {
+ if (n == 0)
+ return 1;
+ return (n * fact(n-1));
+}</PRE>
+</DIV>
+<P> SWIG will generate a method<I> fact</I> in the<I> Example</I> module
+ that can be used like so:</P>
+<DIV class="code targetlang">
+<PRE>$ <B>irb</B>
+irb(main):001:0> <B>require 'example'</B>
+true
+irb(main):002:0> <B>Example.fact(4)</B>
+24</PRE>
+</DIV>
+<H3><A name="Ruby_nn14">38.3.3 Variable Linking</A></H3>
+<P> C/C++ global variables are wrapped as a pair of singleton methods
+ for the module: one to get the value of the global variable and one to
+ set it. For example, the following SWIG interface file declares two
+ global variables:</P>
+<DIV class="code">
+<PRE>// SWIG interface file with global variables
+%module example
+...
+%inline %{
+ extern int variable1;
+ extern double Variable2;
+%}
+...</PRE>
+</DIV>
+<P> Now look at the Ruby interface:</P>
+<DIV class="code targetlang">
+<PRE>$ <B>irb</B>
+irb(main):001:0> <B>require 'Example'</B>
+true
+irb(main):002:0> <B>Example.variable1 = 2</B>
+2
+irb(main):003:0> <B>Example.Variable2 = 4 * 10.3</B>
+41.2
+irb(main):004:0> <B>Example.Variable2</B>
+41.2</PRE>
+</DIV>
+<P> If you make an error in variable assignment, you will receive an
+ error message. For example:</P>
+<DIV class="code targetlang">
+<PRE>irb(main):005:0> <B>Example.Variable2 = "hello"</B>
+TypeError: no implicit conversion to float from string
+from (irb):5:in `Variable2='
+from (irb):5</PRE>
+</DIV>
+<P> If a variable is declared as <TT>const</TT>, it is wrapped as a
+ read-only variable. Attempts to modify its value will result in an
+ error.</P>
+<P>To make ordinary variables read-only, you can also use the <TT>
+%immutable</TT> directive. For example:</P>
+<DIV class="code">
+<PRE>%immutable;
+%inline %{
+ extern char *path;
+%}
+%mutable;</PRE>
+</DIV>
+<P> The <TT>%immutable</TT> directive stays in effect until it is
+ explicitly disabled using <TT>%mutable</TT>.</P>
+<H3><A name="Ruby_nn15">38.3.4 Constants</A></H3>
+<P> C/C++ constants are wrapped as module constants initialized to the
+ appropriate value. To create a constant, use <TT>#define</TT> or the <TT>
+%constant</TT> directive. For example:</P>
+<DIV class="code">
+<PRE>#define PI 3.14159
+#define VERSION "1.0"
+
+%constant int FOO = 42;
+%constant const char *path = "/usr/local";
+
+const int BAR = 32;</PRE>
+</DIV>
+<P> Remember to use the :: operator in Ruby to get at these constant
+ values, e.g.</P>
+<DIV class="code targetlang">
+<PRE>$ <B>irb</B>
+irb(main):001:0> <B>require 'Example'</B>
+true
+irb(main):002:0> <B>Example::PI</B>
+3.14159</PRE>
+</DIV>
+<H3><A name="Ruby_nn16">38.3.5 Pointers</A></H3>
+<P> "Opaque" pointers to arbitrary C/C++ types (i.e. types that aren't
+ explicitly declared in your SWIG interface file) are wrapped as data
+ objects. So, for example, consider a SWIG interface file containing
+ only the declarations:</P>
+<DIV class="code">
+<PRE>Foo *get_foo();
+void set_foo(Foo *foo);</PRE>
+</DIV>
+<P> For this case, the<I> get_foo()</I> method returns an instance of an
+ internally generated Ruby class:</P>
+<DIV class="code targetlang">
+<PRE>irb(main):001:0> <B>foo = Example::get_foo()</B>
+#<SWIG::TYPE_p_Foo:0x402b1654></PRE>
+</DIV>
+<P> A <TT>NULL</TT> pointer is always represented by the Ruby <TT>nil</TT>
+ object.</P>
+<H3><A name="Ruby_nn17">38.3.6 Structures</A></H3>
+<P> C/C++ structs are wrapped as Ruby classes, with accessor methods
+ (i.e. "getters" and "setters") for all of the struct members. For
+ example, this struct declaration:</P>
+<DIV class="code">
+<PRE>struct Vector {
+ double x, y;
+};</PRE>
+</DIV>
+<P> gets wrapped as a <TT>Vector</TT> class, with Ruby instance methods <TT>
+x</TT>, <TT>x=</TT>, <TT>y</TT> and <TT>y=</TT>. These methods can be
+ used to access structure data from Ruby as follows:</P>
+<DIV class="code targetlang">
+<PRE>$ <B>irb</B>
+irb(main):001:0> <B>require 'Example'</B>
+true
+irb(main):002:0> <B>f = Example::Vector.new</B>
+#<Example::Vector:0x4020b268>
+irb(main):003:0> <B>f.x = 10</B>
+nil
+irb(main):004:0> <B>f.x</B>
+10.0</PRE>
+</DIV>
+<P> Similar access is provided for unions and the public data members of
+ C++ classes.</P>
+<P><TT>const</TT> members of a structure are read-only. Data members can
+ also be forced to be read-only using the <TT>%immutable</TT> directive
+ (in C++, <TT>private</TT> may also be used). For example:</P>
+<DIV class="code">
+<PRE>struct Foo {
+ ...
+ %immutable;
+ int x; /* Read-only members */
+ char *name;
+ %mutable;
+ ...
+};</PRE>
+</DIV>
+<P> When <TT>char *</TT> members of a structure are wrapped, the
+ contents are assumed to be dynamically allocated using <TT>malloc</TT>
+ or <TT>new</TT> (depending on whether or not SWIG is run with the <TT>
+-c++</TT> option). When the structure member is set, the old contents
+ will be released and a new value created. If this is not the behavior
+ you want, you will have to use a typemap (described shortly).</P>
+<P>Array members are normally wrapped as read-only. For example, this
+ code:</P>
+<DIV class="code">
+<PRE>struct Foo {
+ int x[50];
+};</PRE>
+</DIV>
+<P> produces a single accessor function like this:</P>
+<DIV class="code">
+<PRE>int *Foo_x_get(Foo *self) {
+ return self->x;
+};</PRE>
+</DIV>
+<P> If you want to set an array member, you will need to supply a
+ "memberin" typemap described in the <A href="#Ruby_memberin_typemap">
+section on typemaps</A>. As a special case, SWIG does generate code to
+ set array members of type <TT>char</TT> (allowing you to store a Ruby
+ string in the structure).</P>
+<P>When structure members are wrapped, they are handled as pointers. For
+ example,</P>
+<DIV class="code">
+<PRE>struct Foo {
+ ...
+};
+
+struct Bar {
+ Foo f;
+};</PRE>
+</DIV>
+<P> generates accessor functions such as this:</P>
+<DIV class="code">
+<PRE>Foo *Bar_f_get(Bar *b) {
+ return &b->f;
+}
+
+void Bar_f_set(Bar *b, Foo *val) {
+ b->f = *val;
+}</PRE>
+</DIV>
+<H3><A name="Ruby_nn18">38.3.7 C++ classes</A></H3>
+<P> Like structs, C++ classes are wrapped by creating a new Ruby class
+ of the same name with accessor methods for the public class member
+ data. Additionally, public member functions for the class are wrapped
+ as Ruby instance methods, and public static member functions are
+ wrapped as Ruby singleton methods. So, given the C++ class declaration:</P>
+<DIV class="code">
+<PRE>class List {
+public:
+ List();
+ ~List();
+ int search(char *item);
+ void insert(char *item);
+ void remove(char *item);
+ char *get(int n);
+ int length;
+ static void print(List *l);
+};</PRE>
+</DIV>
+<P> SWIG would create a <TT>List</TT> class with:</P>
+<UL>
+<LI> instance methods<I> search</I>,<I> insert</I>,<I> remove</I>, and<I>
+ get</I>;</LI>
+<LI> instance methods<I> length</I> and<I> length=</I> (to get and set
+ the value of the<I> length</I> data member); and,</LI>
+<LI> a<I> print</I> singleton method for the class.</LI>
+</UL>
+<P> In Ruby, these functions are used as follows:</P>
+<DIV class="code targetlang">
+<PRE>require 'Example'
+
+l = Example::List.new
+
+l.insert("Ale")
+l.insert("Stout")
+l.insert("Lager")
+Example.print(l)
+l.length()
+----- produces the following output
+Lager
+Stout
+Ale
+3</PRE>
+</DIV>
+<H3><A name="Ruby_nn19">38.3.8 C++ Inheritance</A></H3>
+<P> The SWIG type-checker is fully aware of C++ inheritance. Therefore,
+ if you have classes like this:</P>
+<DIV class="code">
+<PRE>class Parent {
+ ...
+};
+
+class Child : public Parent {
+ ...
+};</PRE>
+</DIV>
+<P> those classes are wrapped into a hierarchy of Ruby classes that
+ reflect the same inheritance structure. All of the usual Ruby utility
+ methods work normally:</P>
+<DIV class="code">
+<PRE>irb(main):001:0> <B>c = Child.new</B>
+#<Bar:0x4016efd4>
+irb(main):002:0> <B>c.instance_of? Child</B>
+true
+irb(main):003:0> <B>b.instance_of? Parent</B>
+false
+irb(main):004:0> <B>b.is_a? Child</B>
+true
+irb(main):005:0> <B>b.is_a? Parent</B>
+true
+irb(main):006:0> <B>Child < Parent</B>
+true
+irb(main):007:0> <B>Child > Parent</B>
+false</PRE>
+</DIV>
+<P> Furthermore, if you have a function like this:</P>
+<DIV class="code">
+<PRE>void spam(Parent *f);</PRE>
+</DIV>
+<P> then the function <TT>spam()</TT> accepts <TT>Parent</TT>* or a
+ pointer to any class derived from <TT>Parent</TT>.</P>
+<P>Until recently, the Ruby module for SWIG didn't support multiple
+ inheritance, and this is still the default behavior. This doesn't mean
+ that you can't wrap C++ classes which inherit from multiple base
+ classes; it simply means that only the<B> first</B> base class listed
+ in the class declaration is considered, and any additional base classes
+ are ignored. As an example, consider a SWIG interface file with a
+ declaration like this:</P>
+<DIV class="code">
+<PRE>class Derived : public Base1, public Base2
+{
+ ...
+};</PRE>
+</DIV>
+<P> For this case, the resulting Ruby class (<TT>Derived</TT>) will only
+ consider <TT>Base1</TT> as its superclass. It won't inherit any of <TT>
+Base2</TT>'s member functions or data and it won't recognize <TT>Base2</TT>
+ as an "ancestor" of <TT>Derived</TT> (i.e. the<EM> is_a?</EM>
+ relationship would fail). When SWIG processes this interface file,
+ you'll see a warning message like:</P>
+<DIV class="code shell">
+<PRE>example.i:5: Warning 802: Warning for Derived: Base Base2 ignored.
+Multiple inheritance is not supported in Ruby.</PRE>
+</DIV>
+<P> Starting with SWIG 1.3.20, the Ruby module for SWIG provides limited
+ support for multiple inheritance. Because the approach for dealing with
+ multiple inheritance introduces some limitations, this is an optional
+ feature that you can activate with the <TT>-minherit</TT> command-line
+ option:</P>
+<DIV class="code shell">
+<PRE>
+$ swig -c++ -ruby -minherit example.i
+</PRE>
+</DIV>
+<P> Using our previous example, if your SWIG interface file contains a
+ declaration like this:</P>
+<DIV class="code">
+<PRE>class Derived : public Base1, public Base2
+{
+ ...
+};</PRE>
+</DIV>
+<P> and you run SWIG with the <TT>-minherit</TT> command-line option,
+ then you will end up with a Ruby class <TT>Derived</TT> that appears to
+ "inherit" the member data and functions from both <TT>Base1</TT> and <TT>
+Base2</TT>. What actually happens is that three different top-level
+ classes are created, with Ruby's <TT>Object</TT> class as their
+ superclass. Each of these classes defines a nested module named <TT>
+Impl</TT>, and it's in these nested <TT>Impl</TT> modules that the
+ actual instance methods for the classes are defined, i.e.</P>
+<DIV class="code targetlang">
+<PRE>class Base1
+ module Impl
+ # Define Base1 methods here
+ end
+ include Impl
+end
+
+class Base2
+ module Impl
+ # Define Base2 methods here
+ end
+ include Impl
+end
+
+class Derived
+ module Impl
+ include Base1::Impl
+ include Base2::Impl
+ # Define Derived methods here
+ end
+ include Impl
+end</PRE>
+</DIV>
+<P> Observe that after the nested <TT>Impl</TT> module for a class is
+ defined, it is mixed-in to the class itself. Also observe that the <TT>
+Derived::Impl</TT> module first mixes-in its base classes' <TT>Impl</TT>
+ modules, thus "inheriting" all of their behavior.</P>
+<P>The primary drawback is that, unlike the default mode of operation,
+ neither <TT>Base1</TT> nor <TT>Base2</TT> is a true superclass of <TT>
+Derived</TT> anymore:</P>
+<DIV class="code targetlang">
+<PRE>obj = Derived.new
+obj.is_a? Base1 # this will return false...
+obj.is_a? Base2 # ... and so will this</PRE>
+</DIV>
+<P> In most cases, this is not a serious problem since objects of type <TT>
+Derived</TT> will otherwise behave as though they inherit from both <TT>
+Base1</TT> and <TT>Base2</TT> (i.e. they exhibit <A href="http://c2.com/cgi/wiki?DuckTyping">
+"Duck Typing"</A>).</P>
+<H3><A name="Ruby_nn20">38.3.9 C++ Overloaded Functions</A></H3>
+<P> C++ overloaded functions, methods, and constructors are mostly
+ supported by SWIG. For example, if you have two functions like this:</P>
+<DIV class="code">
+<PRE>void foo(int);
+void foo(char *c);</PRE>
+</DIV>
+<P> You can use them in Ruby in a straightforward manner:</P>
+<DIV class="code targetlang">
+<PRE>irb(main):001:0> <B>foo(3)</B> # foo(int)
+irb(main):002:0> <B>foo("Hello")</B> # foo(char *c)</PRE>
+</DIV>
+<P>Similarly, if you have a class like this,</P>
+<DIV class="code">
+<PRE>class Foo {
+public:
+ Foo();
+ Foo(const Foo &);
+ ...
+};</PRE>
+</DIV>
+<P>you can write Ruby code like this:</P>
+<DIV class="code targetlang">
+<PRE>irb(main):001:0> <B>f = Foo.new</B> # Create a Foo
+irb(main):002:0> <B>g = Foo.new(f)</B> # Copy f</PRE>
+</DIV>
+<P> Overloading support is not quite as flexible as in C++. Sometimes
+ there are methods that SWIG can't disambiguate. For example:</P>
+<DIV class="code">
+<PRE>void spam(int);
+void spam(short);</PRE>
+</DIV>
+<P>or</P>
+<DIV class="code">
+<PRE>void foo(Bar *b);
+void foo(Bar &b);</PRE>
+</DIV>
+<P> If declarations such as these appear, you will get a warning message
+ like this:</P>
+<DIV class="code shell">
+<PRE>
+example.i:12: Warning 509: Overloaded method spam(short) effectively ignored,
+example.i:11: Warning 509: as it is shadowed by spam(int).
+</PRE>
+</DIV>
+<P> To fix this, you either need to ignore or rename one of the methods.
+ For example:</P>
+<DIV class="code">
+<PRE>%rename(spam_short) spam(short);
+...
+void spam(int);
+void spam(short); // Accessed as spam_short</PRE>
+</DIV>
+<P>or</P>
+<DIV class="code">
+<PRE>%ignore spam(short);
+...
+void spam(int);
+void spam(short); // Ignored</PRE>
+</DIV>
+<P> SWIG resolves overloaded functions and methods using a
+ disambiguation scheme that ranks and sorts declarations according to a
+ set of type-precedence rules. The order in which declarations appear in
+ the input does not matter except in situations where ambiguity
+ arises--in this case, the first declaration takes precedence.</P>
+<P>Please refer to the <A href="#SWIGPlus">"SWIG and C++"</A> chapter
+ for more information about overloading.</P>
+<H3><A name="Ruby_nn21">38.3.10 C++ Operators</A></H3>
+<P> For the most part, overloaded operators are handled automatically by
+ SWIG and do not require any special treatment on your part. So if your
+ class declares an overloaded addition operator, e.g.</P>
+<DIV class="code">
+<PRE>class Complex {
+ ...
+ Complex operator+(Complex &);
+ ...
+};</PRE>
+</DIV>
+<P> the resulting Ruby class will also support the addition (+) method
+ correctly.</P>
+<P>For cases where SWIG's built-in support is not sufficient, C++
+ operators can be wrapped using the <TT>%rename</TT> directive
+ (available on SWIG 1.3.10 and later releases). All you need to do is
+ give the operator the name of a valid Ruby identifier. For example:</P>
+<DIV class="code">
+<PRE>%rename(add_complex) operator+(Complex &, Complex &);
+...
+Complex operator+(Complex &, Complex &);</PRE>
+</DIV>
+<P>Now, in Ruby, you can do this:</P>
+<DIV class="code targetlang">
+<PRE>a = Example::Complex.new(2, 3)
+b = Example::Complex.new(4, -1)
+c = Example.add_complex(a, b)</PRE>
</DIV>
-<P> Note that this does not relieve you of the requirement of specifying
- the SWIG module name with the <TT>%module</TT> directive (or the <TT>
--module</TT> command-line option) as described earlier.</P>
-<P>When choosing a module name, do not use the same name as a built-in
- Ruby command or standard module name, as the results may be
- unpredictable. Similarly, if you're using the <TT>-globalmodule</TT>
- option to wrap everything into the global module, take care that the
- names of your constants, classes and methods don't conflict with any of
- Ruby's built-in names.</P>
-<H3><A name="Ruby_nn13"></A>36.3.2 Functions</H3>
-<P> Global functions are wrapped as Ruby module methods. For example,
- given the SWIG interface file <TT>example.i</TT>:</P>
+<P> More details about wrapping C++ operators into Ruby operators is
+ discussed in the <A href="#Ruby_operator_overloading">section on
+ operator overloading</A>.</P>
+<H3><A name="Ruby_nn22">38.3.11 C++ namespaces</A></H3>
+<P> SWIG is aware of C++ namespaces, but namespace names do not appear
+ in the module nor do namespaces result in a module that is broken up
+ into submodules or packages. For example, if you have a file like this,</P>
<DIV class="code">
<PRE>%module example
-int fact(int n);</PRE>
-</DIV>
-<P> and C source file <TT>example.c</TT>:</P>
-<DIV class="code">
-<PRE>int fact(int n) {
- if (n == 0)
- return 1;
- return (n * fact(n-1));
-}</PRE>
+namespace foo {
+ int fact(int n);
+ struct Vector {
+ double x,y,z;
+ };
+};</PRE>
</DIV>
-<P> SWIG will generate a method<I> fact</I> in the<I> Example</I> module
- that can be used like so:</P>
+<P>it works in Ruby as follows:</P>
<DIV class="code targetlang">
-<PRE>$ <B>irb</B>
-irb(main):001:0> <B>require 'example'</B>
+<PRE>irb(main):001:0> <B>require 'example'</B>
true
-irb(main):002:0> <B>Example.fact(4)</B>
-24</PRE>
+irb(main):002:0> <B>Example.fact(3)</B>
+6
+irb(main):003:0> <B>v = Example::Vector.new</B>
+#<Example::Vector:0x4016f4d4>
+irb(main):004:0> <B>v.x = 3.4</B>
+3.4
+irb(main):004:0> <B>v.y</B>
+0.0</PRE>
</DIV>
-<H3><A name="Ruby_nn14"></A>36.3.3 Variable Linking</H3>
-<P> C/C++ global variables are wrapped as a pair of singleton methods
- for the module: one to get the value of the global variable and one to
- set it. For example, the following SWIG interface file declares two
- global variables:</P>
+<P> If your program has more than one namespace, name conflicts (if any)
+ can be resolved using <TT>%rename</TT> For example:</P>
<DIV class="code">
-<PRE>// SWIG interface file with global variables
-%module example
-...
-%inline %{
- extern int variable1;
- extern double Variable2;
+<PRE>%rename(Bar_spam) Bar::spam;
+
+namespace Foo {
+ int spam();
+}
+
+namespace Bar {
+ int spam();
+}</PRE>
+</DIV>
+<P> If you have more than one namespace and your want to keep their
+ symbols separate, consider wrapping them as separate SWIG modules. For
+ example, make the module name the same as the namespace and create
+ extension modules for each namespace separately. If your program
+ utilizes thousands of small deeply nested namespaces each with
+ identical symbol names, well, then you get what you deserve.</P>
+<H3><A name="Ruby_nn23">38.3.12 C++ templates</A></H3>
+<P> C++ templates don't present a huge problem for SWIG. However, in
+ order to create wrappers, you have to tell SWIG to create wrappers for
+ a particular template instantiation. To do this, you use the <TT>
+%template</TT> directive. For example:</P>
+<DIV class="code">
+<PRE>%module example
+
+%{
+#include "pair.h"
%}
-...</PRE>
+
+template<class T1, class T2>
+struct pair {
+ typedef T1 first_type;
+ typedef T2 second_type;
+ T1 first;
+ T2 second;
+ pair();
+ pair(const T1&, const T2&);
+ ~pair();
+};
+
+%template(Pairii) pair<int,int>;</PRE>
</DIV>
-<P> Now look at the Ruby interface:</P>
+<P>In Ruby:</P>
<DIV class="code targetlang">
-<PRE>$ <B>irb</B>
-irb(main):001:0> <B>require 'Example'</B>
+<PRE>irb(main):001:0> <B>require 'example'</B>
true
-irb(main):002:0> <B>Example.variable1 = 2</B>
-2
-irb(main):003:0> <B>Example.Variable2 = 4 * 10.3</B>
-41.2
-irb(main):004:0> <B>Example.Variable2</B>
-41.2</PRE>
+irb(main):002:0> <B>p = Example::Pairii.new(3, 4)</B>
+#<Example:Pairii:0x4016f4df>
+irb(main):003:0> <B>p.first</B>
+3
+irb(main):004:0> <B>p.second</B>
+4</PRE>
</DIV>
-<P> If you make an error in variable assignment, you will receive an
- error message. For example:</P>
-<DIV class="code targetlang">
-<PRE>irb(main):005:0> <B>Example.Variable2 = "hello"</B>
-TypeError: no implicit conversion to float from string
-from (irb):5:in `Variable2='
-from (irb):5</PRE>
+<H3><A name="Ruby_nn23_1">38.3.13 C++ Standard Template Library (STL)</A>
+</H3>
+<P> On a related note, the standard SWIG library contains a number of
+ modules that provide typemaps for standard C++ library classes (such as
+ <TT>std::pair</TT>, <TT>std::string</TT> and <TT>std::vector</TT>).
+ These library modules don't provide wrappers around the templates
+ themselves, but they do make it convenient for users of your extension
+ module to pass Ruby objects (such as arrays and strings) to wrapped C++
+ code that expects instances of standard C++ templates. For example,
+ suppose the C++ library you're wrapping has a function that expects a
+ vector of floats:</P>
+<DIV class="code">
+<PRE>%module example
+
+float sum(const std::vector<float>& values);</PRE>
</DIV>
-<P> If a variable is declared as <TT>const</TT>, it is wrapped as a
- read-only variable. Attempts to modify its value will result in an
- error.</P>
-<P>To make ordinary variables read-only, you can also use the <TT>
-%immutable</TT> directive. For example:</P>
+<P> Rather than go through the hassle of writing an "in" typemap to
+ convert an array of Ruby numbers into a std::vector<float>, you can
+ just use the <TT>std_vector.i</TT> module from the standard SWIG
+ library:</P>
<DIV class="code">
-<PRE>%immutable;
-%inline %{
- extern char *path;
-%}
-%mutable;</PRE>
+<PRE>%module example
+
+%include std_vector.i
+float sum(const std::vector<float>& values);</PRE>
</DIV>
-<P> The <TT>%immutable</TT> directive stays in effect until it is
- explicitly disabled using <TT>%mutable</TT>.</P>
-<H3><A name="Ruby_nn15"></A>36.3.4 Constants</H3>
-<P> C/C++ constants are wrapped as module constants initialized to the
- appropriate value. To create a constant, use <TT>#define</TT> or the <TT>
-%constant</TT> directive. For example:</P>
+<P>Ruby's STL wrappings provide additional methods to make them behave
+ more similarly to Ruby's native classes.</P>
+<P>Thus, you can do, for example:</P>
+<DIV class="targetlang">
+<PRE>v = IntVector.new
+v << 2
+v << 3
+v << 4
+v.each { |x| puts x }
+
+=> 2
+3
+4
+v.delete_if { |x| x == 3 }
+=> [2,4]</PRE>
+</DIV>
+<P>The SWIG Ruby module provides also the ability for all the STL
+ containers to carry around Ruby native objects (Fixnum, Classes, etc)
+ making them act almost like Ruby's own Array, Hash, etc. To do that,
+ you need to define a container that contains a swig::GC_VALUE, like:</P>
<DIV class="code">
-<PRE>#define PI 3.14159
-#define VERSION "1.0"
+<PRE>
+%module nativevector
-%constant int FOO = 42;
-%constant const char *path = "/usr/local";
+%{
+std::vector< swig::GC_VALUE > NativeVector;
+%}
-const int BAR = 32;</PRE>
+%template(NativeVector) std::vector< swig::GC_VALUE >;
+</PRE>
</DIV>
-<P> Remember to use the :: operator in Ruby to get at these constant
- values, e.g.</P>
-<DIV class="code targetlang">
-<PRE>$ <B>irb</B>
-irb(main):001:0> <B>require 'Example'</B>
-true
-irb(main):002:0> <B>Example::PI</B>
-3.14159</PRE>
+<P>This vector can then contain any Ruby object, making them almost
+ identical to Ruby's own Array class.</P>
+<DIV class="targetlang">
+<PRE>require 'nativevector'
+include NativeVector
+
+v = NativeVector.new
+v << 1
+v << [1,2]
+v << 'hello'
+
+class A; end
+
+v << A.new
+
+puts v
+=> [1, [1,2], 'hello', #<A:0x245325>]
+</PRE>
</DIV>
-<H3><A name="Ruby_nn16"></A>36.3.5 Pointers</H3>
-<P> "Opaque" pointers to arbitrary C/C++ types (i.e. types that aren't
- explicitly declared in your SWIG interface file) are wrapped as data
- objects. So, for example, consider a SWIG interface file containing
- only the declarations:</P>
+<P>Obviously, there is a lot more to template wrapping than shown in
+ these examples. More details can be found in the <A href="#SWIGPlus">
+SWIG and C++</A> chapter.</P>
+<H3><A name="Ruby_C_STL_Functors">38.3.14 C++ STL Functors</A></H3>
+<P>Some containers in the STL allow you to modify their default behavior
+ by using so called functors or function objects. Functors are often
+ just a very simple struct with <TT>operator()</TT> redefined or an
+ actual C/C++ function. This allows you, for example, to always keep the
+ sort order of a STL container to your liking.</P>
+<P>The Ruby STL mappings allows you to modify those containers that
+ support functors using Ruby procs or methods, instead. Currently, this
+ includes <TT>std::set</TT>, <TT>set::map</TT>, <TT>std::multiset</TT>
+ and <TT>std::multimap</TT>.</P>
+<P>The functors in swig are called <TT>swig::UnaryFunction</TT> and <TT>
+swig::BinaryFunction</TT>. For C++ predicates (ie. functors that must
+ return bool as a result) <TT>swig::UnaryPredicate</TT> and <TT>
+swig::BinaryPredicate</TT> are provided.</P>
+<P>As an example, if given this swig file:</P>
<DIV class="code">
-<PRE>Foo *get_foo();
-void set_foo(Foo *foo);</PRE>
+<PRE>
+%module intset;
+
+%include <std_set.i>
+
+%template(IntSet) std::set< int, swig::BinaryPredicate >;
+</PRE>
</DIV>
-<P> For this case, the<I> get_foo()</I> method returns an instance of an
- internally generated Ruby class:</P>
-<DIV class="code targetlang">
-<PRE>irb(main):001:0> <B>foo = Example::get_foo()</B>
-#<SWIG::TYPE_p_Foo:0x402b1654></PRE>
+<P>You can then use the set from Ruby with or without a proc object as a
+ predicate:</P>
+<DIV class="targetlang">
+<PRE>
+require 'intset'
+include Intset
+
+# Default sorting behavior defined in C++
+a = IntSet.new
+a << 1
+a << 2
+a << 3
+a
+<B>=> [1,2,3]</B>
+
+# Custom sorting behavior defined by a Ruby proc
+b = IntSet.new( proc { |a,b| a > b } )
+b << 1
+b << 2
+b << 3
+b
+<B>=> [3,2,1]</B>
+</PRE>
</DIV>
-<P> A <TT>NULL</TT> pointer is always represented by the Ruby <TT>nil</TT>
- object.</P>
-<H3><A name="Ruby_nn17"></A>36.3.6 Structures</H3>
-<P> C/C++ structs are wrapped as Ruby classes, with accessor methods
- (i.e. "getters" and "setters") for all of the struct members. For
- example, this struct declaration:</P>
+<H3><A name="Ruby_C_Iterators">38.3.15 C++ STL Iterators</A></H3>
+<P>The STL is well known for the use of iterators. There are a number of
+ iterators possible with different properties, but in general there are
+ two main categories: const iterators and non-const iterators. The const
+ iterators can access and not modify the values they point at, while the
+ non-const iterators can both read and modify the values.</P>
+<P>The Ruby STL wrappings support both type of iterators by using a
+ proxy class in-between. This proxy class is <TT>swig::Iterator</TT> or <TT>
+swig::ConstIterator</TT>. Derived from them are template classes that
+ need to be initialized with the actual iterator for the container you
+ are wrapping and often times with the beginning and ending points of
+ the iteration range.</P>
+<P>The SWIG STL library already provides typemaps to all the standard
+ containers to do this wrapping automatically for you, but if you have
+ your own STL-like iterator, you will need to write your own typemap for
+ them. For out typemaps, the special functions <TT>make_const_iterator</TT>
+ and <TT>make_nonconst_iterator</TT> are provided.</P>
+<P>These can be used either like:</P>
<DIV class="code">
-<PRE>struct Vector {
- double x, y;
-};</PRE>
+<PRE>
+make_const_iterator( iterator, rubyclass );
+make_const_iterator( iterator, iterator_begin, iterator_end, rubyclass );
+</PRE>
</DIV>
-<P> gets wrapped as a <TT>Vector</TT> class, with Ruby instance methods <TT>
-x</TT>, <TT>x=</TT>, <TT>y</TT> and <TT>y=</TT>. These methods can be
- used to access structure data from Ruby as follows:</P>
-<DIV class="code targetlang">
-<PRE>$ <B>irb</B>
-irb(main):001:0> <B>require 'Example'</B>
-true
-irb(main):002:0> <B>f = Example::Vector.new</B>
-#<Example::Vector:0x4020b268>
-irb(main):003:0> <B>f.x = 10</B>
-nil
-irb(main):004:0> <B>f.x</B>
-10.0</PRE>
+<P>The iterators support a <TT>next()</TT> and <TT>previous()</TT>
+ member function to just change the iterator without returning anything.
+ <TT>previous()</TT> should obviously only be used for bidirectional
+ iterators. You can also advance the iterator multiple steps by using
+ standard math operations like <TT>+=</TT>.</P>
+<P>The value the iterator points at can be accessed with <TT>value()</TT>
+ -- this is equivalent to dereferencing it with <TT>*i</TT>. For
+ non-const iterators, a <TT>value=()</TT> function is also provided
+ which allows you to change the value pointed by the iterator. This is
+ equivalent to the C++ construct of dereferencing and assignment, like <TT>
+*i = something</TT>.</P>
+<P>Thus, given say a vector class of doubles defined as:</P>
+<DIV class="code">
+<PRE>
+%module doublevector
+
+%include std_vector.i
+
+%template(DoubleVector) std::vector<double>;
+</PRE>
</DIV>
-<P> Similar access is provided for unions and the public data members of
- C++ classes.</P>
-<P><TT>const</TT> members of a structure are read-only. Data members can
- also be forced to be read-only using the <TT>%immutable</TT> directive
- (in C++, <TT>private</TT> may also be used). For example:</P>
+<P>Its iterator can then be used from Ruby like:</P>
+<DIV class="targetlang">
+<PRE>
+require 'doublevector'
+include Doublevector
+
+v = DoubleVector.new
+v << 1
+v << 2
+v << 3
+
+#
+# an elaborate and less efficient way of doing v.map! { |x| x+2 }
+#
+i = v.begin
+e = v.end
+while i != e
+ val = i.value
+ val += 2
+ i.value = val
+ i.next
+end
+i
+<B>>> [3, 4, 5 ]</B>
+</PRE>
+</DIV>
+<P>If you'd rather have STL classes without any iterators, you should
+ define <TT>-DSWIG_NO_EXPORT_ITERATOR_METHODS</TT> when running swig.</P>
+<H3><A name="Ruby_nn24">38.3.16 C++ Smart Pointers</A></H3>
+<H4><A name="Ruby_smart_pointers_shared_ptr">38.3.16.1 The shared_ptr
+ Smart Pointer</A></H4>
+<P> The C++11 standard provides <TT>std::shared_ptr</TT> which was
+ derived from the Boost implementation, <TT>boost::shared_ptr</TT>. Both
+ of these are available for Ruby in the SWIG library and usage is
+ outlined in the <A href="#Library_std_shared_ptr">shared_ptr smart
+ pointer</A> library section.</P>
+<H4><A name="Ruby_smart_pointers_generic">38.3.16.2 Generic Smart
+ Pointers</A></H4>
+<P> In certain C++ programs, it is common to use classes that have been
+ wrapped by so-called "smart pointers." Generally, this involves the use
+ of a template class that implements <TT>operator->()</TT> like this:</P>
<DIV class="code">
-<PRE>struct Foo {
+<PRE>template<class T> class SmartPtr {
...
- %immutable;
- int x; /* Read-only members */
- char *name;
- %mutable;
+ T *operator->();
...
-};</PRE>
+}</PRE>
</DIV>
-<P> When <TT>char *</TT> members of a structure are wrapped, the
- contents are assumed to be dynamically allocated using <TT>malloc</TT>
- or <TT>new</TT> (depending on whether or not SWIG is run with the <TT>
--c++</TT> option). When the structure member is set, the old contents
- will be released and a new value created. If this is not the behavior
- you want, you will have to use a typemap (described shortly).</P>
-<P>Array members are normally wrapped as read-only. For example, this
- code:</P>
+<P>Then, if you have a class like this,</P>
<DIV class="code">
-<PRE>struct Foo {
- int x[50];
+<PRE>class Foo {
+public:
+ int x;
+ int bar();
};</PRE>
</DIV>
-<P> produces a single accessor function like this:</P>
+<P>A smart pointer would be used in C++ as follows:</P>
<DIV class="code">
-<PRE>int *Foo_x_get(Foo *self) {
- return self->x;
-};</PRE>
+<PRE>SmartPtr<Foo> p = CreateFoo(); // Created somehow (not shown)
+...
+p->x = 3; // Foo::x
+int y = p->bar(); // Foo::bar</PRE>
</DIV>
-<P> If you want to set an array member, you will need to supply a
- "memberin" typemap described in the <A href="#Ruby_memberin_typemap">
-section on typemaps</A>. As a special case, SWIG does generate code to
- set array members of type <TT>char</TT> (allowing you to store a Ruby
- string in the structure).</P>
-<P>When structure members are wrapped, they are handled as pointers. For
- example,</P>
+<P> To wrap this in Ruby, simply tell SWIG about the <TT>SmartPtr</TT>
+ class and the low-level <TT>Foo</TT> object. Make sure you instantiate <TT>
+SmartPtr</TT> using <TT>%template</TT> if necessary. For example:</P>
<DIV class="code">
-<PRE>struct Foo {
- ...
-};
-
-struct Bar {
- Foo f;
-};</PRE>
+<PRE>%module example
+...
+%template(SmartPtrFoo) SmartPtr<Foo>;
+...</PRE>
</DIV>
-<P> generates accessor functions such as this:</P>
+<P>Now, in Ruby, everything should just "work":</P>
+<DIV class="code targetlang">
+<PRE>irb(main):001:0> <B>p = Example::CreateFoo()</B> # Create a smart-pointer somehow
+#<Example::SmartPtrFoo:0x4016f4df>
+irb(main):002:0> <B>p.x = 3</B> # Foo::x
+3
+irb(main):003:0> <B>p.bar()</B> # Foo::bar</PRE>
+</DIV>
+<P> If you ever need to access the underlying pointer returned by <TT>
+operator->()</TT> itself, simply use the <TT>__deref__()</TT> method.
+ For example:</P>
+<DIV class="code targetlang">
+<PRE>irb(main):004:0> <B>f = p.__deref__()</B> # Returns underlying Foo *</PRE>
+</DIV>
+<H3><A name="Ruby_nn25">38.3.17 Cross-Language Polymorphism</A></H3>
+<P> SWIG's Ruby module supports cross-language polymorphism (a.k.a. the
+ "directors" feature) similar to that for SWIG's Python module. Rather
+ than duplicate the information presented in the <A href="#Python">
+Python</A> chapter, this section just notes the differences that you
+ need to be aware of when using this feature with Ruby.</P>
+<H4><A name="Ruby_nn26">38.3.17.1 Exception Unrolling</A></H4>
+<P> Whenever a C++ director class routes one of its virtual member
+ function calls to a Ruby instance method, there's always the
+ possibility that an exception will be raised in the Ruby code. By
+ default, those exceptions are ignored, which simply means that the
+ exception will be exposed to the Ruby interpreter. If you would like to
+ change this behavior, you can use the <TT>%feature("director:except")</TT>
+ directive to indicate what action should be taken when a Ruby exception
+ is raised. The following code should suffice in most cases:</P>
<DIV class="code">
-<PRE>Foo *Bar_f_get(Bar *b) {
- return &b->f;
-}
-
-void Bar_f_set(Bar *b, Foo *val) {
- b->f = *val;
+<PRE>%feature("director:except") {
+ throw Swig::DirectorMethodException($error);
}</PRE>
</DIV>
-<H3><A name="Ruby_nn18"></A>36.3.7 C++ classes</H3>
-<P> Like structs, C++ classes are wrapped by creating a new Ruby class
- of the same name with accessor methods for the public class member
- data. Additionally, public member functions for the class are wrapped
- as Ruby instance methods, and public static member functions are
- wrapped as Ruby singleton methods. So, given the C++ class declaration:</P>
+<P> When this feature is activated, the call to the Ruby instance method
+ is "wrapped" using the <TT>rb_rescue2()</TT> function from Ruby's C
+ API. If any Ruby exception is raised, it will be caught here and a C++
+ exception is raised in its place.</P>
+<H2><A name="Ruby_nn27">38.4 Naming</A></H2>
+<P>Ruby has several common naming conventions. Constants are generally
+ in upper case, module and class names are in camel case and methods are
+ in lower case with underscores. For example:</P>
+<DIV class="code">
+<UL>
+<LI><STRONG>MATH::PI</STRONG> is a constant name</LI>
+<LI><STRONG>MyClass</STRONG> is a class name</LI>
+<LI><STRONG>my_method</STRONG> is a method name</LI>
+</UL>
+</DIV>
+<P>Prior to version 1.3.28, SWIG did not support these Ruby conventions.
+ The only modifications it made to names was to capitalize the first
+ letter of constants (which includes module and class names).</P>
+<P>SWIG 1.3.28 introduces the new -autorename command line parameter.
+ When this parameter is specified, SWIG will automatically change
+ constant, class and method names to conform with the standard Ruby
+ naming conventions. For example:</P>
+<DIV class="code shell">
+<PRE>$ swig -ruby -autorename example.i
+</PRE>
+</DIV>
+<P>To disable renaming use the -noautorename command line option.</P>
+<P>Since this change significantly changes the wrapper code generated by
+ SWIG, it is turned off by default in SWIG 1.3.28. However, it is
+ planned to become the default option in future releases.</P>
+<H3><A name="Ruby_nn28">38.4.1 Defining Aliases</A></H3>
+<P> It's a fairly common practice in the Ruby built-ins and standard
+ library to provide aliases for method names. For example,<EM>
+ Array#size</EM> is an alias for<EM> Array#length</EM>. If you would
+ like to provide an alias for one of your class' instance methods, one
+ approach is to use SWIG's <TT>%extend</TT> directive to add a new
+ method of the aliased name that calls the original function. For
+ example:</P>
<DIV class="code">
-<PRE>class List {
+<PRE>class MyArray {
public:
- List();
- ~List();
- int search(char *item);
- void insert(char *item);
- void remove(char *item);
- char *get(int n);
- int length;
- static void print(List *l);
-};</PRE>
-</DIV>
-<P> SWIG would create a <TT>List</TT> class with:</P>
-<UL>
-<LI> instance methods<I> search</I>,<I> insert</I>,<I> remove</I>, and<I>
- get</I>;</LI>
-<LI> instance methods<I> length</I> and<I> length=</I> (to get and set
- the value of the<I> length</I> data member); and,</LI>
-<LI> a<I> print</I> singleton method for the class.</LI>
-</UL>
-<P> In Ruby, these functions are used as follows:</P>
-<DIV class="code targetlang">
-<PRE>require 'Example'
+ // Construct an empty array
+ MyArray();
-l = Example::List.new
+ // Return the size of this array
+ size_t length() const;
+};
-l.insert("Ale")
-l.insert("Stout")
-l.insert("Lager")
-Example.print(l)
-l.length()
------ produces the following output
-Lager
-Stout
-Ale
-3</PRE>
+%extend MyArray {
+ // MyArray#size is an alias for MyArray#length
+ size_t size() const {
+ return $self->length();
+ }
+}
+ </PRE>
</DIV>
-<H3><A name="Ruby_nn19"></A>36.3.8 C++ Inheritance</H3>
-<P> The SWIG type-checker is fully aware of C++ inheritance. Therefore,
- if you have classes like this:</P>
+<P> A better solution is to use the <TT>%alias</TT> directive (unique to
+ SWIG's Ruby module). The previous example could then be rewritten as:</P>
<DIV class="code">
-<PRE>class Parent {
- ...
-};
+<PRE>// MyArray#size is an alias for MyArray#length
+%alias MyArray::length "size";
-class Child : public Parent {
- ...
+class MyArray {
+public:
+ // Construct an empty array
+ MyArray();
+
+ // Return the size of this array
+ size_t length() const;
};</PRE>
</DIV>
-<P> those classes are wrapped into a hierarchy of Ruby classes that
- reflect the same inheritance structure. All of the usual Ruby utility
- methods work normally:</P>
-<DIV class="code">
-<PRE>irb(main):001:0> <B>c = Child.new</B>
-#<Bar:0x4016efd4>
-irb(main):002:0> <B>c.instance_of? Child</B>
-true
-irb(main):003:0> <B>b.instance_of? Parent</B>
-false
-irb(main):004:0> <B>b.is_a? Child</B>
-true
-irb(main):005:0> <B>b.is_a? Parent</B>
-true
-irb(main):006:0> <B>Child < Parent</B>
-true
-irb(main):007:0> <B>Child > Parent</B>
-false</PRE>
-</DIV>
-<P> Furthermore, if you have a function like this:</P>
+<P> Multiple aliases can be associated with a method by providing a
+ comma-separated list of aliases to the <TT>%alias</TT> directive, e.g.</P>
<DIV class="code">
-<PRE>void spam(Parent *f);</PRE>
+<PRE>%alias MyArray::length "amount,quantity,size";</PRE>
</DIV>
-<P> then the function <TT>spam()</TT> accepts <TT>Parent</TT>* or a
- pointer to any class derived from <TT>Parent</TT>.</P>
-<P>Until recently, the Ruby module for SWIG didn't support multiple
- inheritance, and this is still the default behavior. This doesn't mean
- that you can't wrap C++ classes which inherit from multiple base
- classes; it simply means that only the<B> first</B> base class listed
- in the class declaration is considered, and any additional base classes
- are ignored. As an example, consider a SWIG interface file with a
- declaration like this:</P>
+<P> From an end-user's standpoint, there's no functional difference
+ between these two approaches; i.e. they should get the same result from
+ calling either<EM> MyArray#size</EM> or<EM> MyArray#length</EM>.
+ However, when the <TT>%alias</TT> directive is used, SWIG doesn't need
+ to generate all of the wrapper code that's usually associated with
+ added methods like our<EM> MyArray::size()</EM> example.</P>
+<P>Note that the <TT>%alias</TT> directive is implemented using SWIG's
+ "features" mechanism and so the same name matching rules used for other
+ kinds of features apply (see the chapter on <A href="#Customization">
+"Customization Features"</A>) for more details).</P>
+<H3><A name="Ruby_nn29">38.4.2 Predicate Methods</A></H3>
+<P> Ruby methods that return a boolean value and end in a question mark
+ are known as predicate methods. Examples of predicate methods in
+ standard Ruby classes include<EM> Array#empty?</EM> (which returns <TT>
+true</TT> for an array containing no elements) and<EM>
+ Object#instance_of?</EM> (which returns <TT>true</TT> if the object is
+ an instance of the specified class). For consistency with Ruby
+ conventions, methods that return boolean values should be marked as
+ predicate methods.</P>
+<P>One cumbersome solution to this problem is to rename the method
+ (using SWIG's <TT>%rename</TT> directive) and provide a custom typemap
+ that converts the function's actual return type to Ruby's <TT>true</TT>
+ or <TT>false</TT>. For example:</P>
<DIV class="code">
-<PRE>class Derived : public Base1, public Base2
-{
- ...
-};</PRE>
-</DIV>
-<P> For this case, the resulting Ruby class (<TT>Derived</TT>) will only
- consider <TT>Base1</TT> as its superclass. It won't inherit any of <TT>
-Base2</TT>'s member functions or data and it won't recognize <TT>Base2</TT>
- as an "ancestor" of <TT>Derived</TT> (i.e. the<EM> is_a?</EM>
- relationship would fail). When SWIG processes this interface file,
- you'll see a warning message like:</P>
-<DIV class="code shell">
-<PRE>example.i:5: Warning 802: Warning for Derived: Base Base2 ignored.
-Multiple inheritance is not supported in Ruby.</PRE>
-</DIV>
-<P> Starting with SWIG 1.3.20, the Ruby module for SWIG provides limited
- support for multiple inheritance. Because the approach for dealing with
- multiple inheritance introduces some limitations, this is an optional
- feature that you can activate with the <TT>-minherit</TT> command-line
- option:</P>
-<DIV class="code shell">
-<PRE>
-$ swig -c++ -ruby -minherit example.i
-</PRE>
+<PRE>%rename("is_it_safe?") is_it_safe();
+
+%typemap(out) int is_it_safe "$result = ($1 != 0) ? Qtrue : Qfalse;";
+
+int is_it_safe();</PRE>
</DIV>
-<P> Using our previous example, if your SWIG interface file contains a
- declaration like this:</P>
+<P> A better solution is to use the <TT>%predicate</TT> directive
+ (unique to SWIG's Ruby module) to designate a method as a predicate
+ method. For the previous example, this would look like:</P>
<DIV class="code">
-<PRE>class Derived : public Base1, public Base2
-{
- ...
-};</PRE>
-</DIV>
-<P> and you run SWIG with the <TT>-minherit</TT> command-line option,
- then you will end up with a Ruby class <TT>Derived</TT> that appears to
- "inherit" the member data and functions from both <TT>Base1</TT> and <TT>
-Base2</TT>. What actually happens is that three different top-level
- classes are created, with Ruby's <TT>Object</TT> class as their
- superclass. Each of these classes defines a nested module named <TT>
-Impl</TT>, and it's in these nested <TT>Impl</TT> modules that the
- actual instance methods for the classes are defined, i.e.</P>
-<DIV class="code targetlang">
-<PRE>class Base1
- module Impl
- # Define Base1 methods here
- end
- include Impl
-end
-
-class Base2
- module Impl
- # Define Base2 methods here
- end
- include Impl
-end
+<PRE>%predicate is_it_safe();
-class Derived
- module Impl
- include Base1::Impl
- include Base2::Impl
- # Define Derived methods here
- end
- include Impl
-end</PRE>
+int is_it_safe();</PRE>
</DIV>
-<P> Observe that after the nested <TT>Impl</TT> module for a class is
- defined, it is mixed-in to the class itself. Also observe that the <TT>
-Derived::Impl</TT> module first mixes-in its base classes' <TT>Impl</TT>
- modules, thus "inheriting" all of their behavior.</P>
-<P>The primary drawback is that, unlike the default mode of operation,
- neither <TT>Base1</TT> nor <TT>Base2</TT> is a true superclass of <TT>
-Derived</TT> anymore:</P>
+<P>This method would be invoked from Ruby code like this:</P>
<DIV class="code targetlang">
-<PRE>obj = Derived.new
-obj.is_a? Base1 # this will return false...
-obj.is_a? Base2 # ... and so will this</PRE>
+<PRE>irb(main):001:0> <B>Example::is_it_safe?</B>
+true</PRE>
</DIV>
-<P> In most cases, this is not a serious problem since objects of type <TT>
-Derived</TT> will otherwise behave as though they inherit from both <TT>
-Base1</TT> and <TT>Base2</TT> (i.e. they exhibit <A href="http://c2.com/cgi/wiki?DuckTyping">
-"Duck Typing"</A>).</P>
-<H3><A name="Ruby_nn20"></A>36.3.9 C++ Overloaded Functions</H3>
-<P> C++ overloaded functions, methods, and constructors are mostly
- supported by SWIG. For example, if you have two functions like this:</P>
+<P> The <TT>%predicate</TT> directive is implemented using SWIG's
+ "features" mechanism and so the same name matching rules used for other
+ kinds of features apply (see the chapter on <A href="#Customization">
+"Customization Features"</A>) for more details).</P>
+<H3><A name="Ruby_nn30">38.4.3 Bang Methods</A></H3>
+<P> Ruby methods that modify an object in-place and end in an
+ exclamation mark are known as bang methods. An example of a bang method
+ is<EM> Array#sort!</EM> which changes the ordering of items in an
+ array. Contrast this with<EM> Array#sort</EM>, which returns a copy of
+ the array with the items sorted instead of modifying the original
+ array. For consistency with Ruby conventions, methods that modify
+ objects in place should be marked as bang methods.</P>
+<P>Bang methods can be marked using the <TT>%bang</TT> directive which
+ is unique to the Ruby module and was introduced in SWIG 1.3.28. For
+ example:</P>
<DIV class="code">
-<PRE>void foo(int);
-void foo(char *c);</PRE>
+<PRE>%bang sort(int arr[]);
+
+int sort(int arr[]); </PRE>
</DIV>
-<P> You can use them in Ruby in a straightforward manner:</P>
-<DIV class="code targetlang">
-<PRE>irb(main):001:0> <B>foo(3)</B> # foo(int)
-irb(main):002:0> <B>foo("Hello")</B> # foo(char *c)</PRE>
+<P>This method would be invoked from Ruby code like this:</P>
+<DIV class="code">
+<PRE>irb(main):001:0> <B>Example::sort!(arr)</B></PRE>
</DIV>
-<P>Similarly, if you have a class like this,</P>
+<P> The <TT>%bang</TT> directive is implemented using SWIG's "features"
+ mechanism and so the same name matching rules used for other kinds of
+ features apply (see the chapter on <A href="#Customization">
+"Customization Features"</A>) for more details).</P>
+<H3><A name="Ruby_nn31">38.4.4 Getters and Setters</A></H3>
+<P> Often times a C++ library will expose properties through getter and
+ setter methods. For example:</P>
<DIV class="code">
<PRE>class Foo {
-public:
- Foo();
- Foo(const Foo &);
- ...
+ Foo() {}
+ int getValue() { return value_; }
+ void setValue(int value) { value_ = value; }
+
+private:
+ int value_;
};</PRE>
</DIV>
-<P>you can write Ruby code like this:</P>
-<DIV class="code targetlang">
-<PRE>irb(main):001:0> <B>f = Foo.new</B> # Create a Foo
-irb(main):002:0> <B>g = Foo.new(f)</B> # Copy f</PRE>
+<P>By default, SWIG will expose these methods to Ruby as <TT>get_value</TT>
+ and <TT>set_value.</TT> However, it more natural for these methods to
+ be exposed in Ruby as <TT>value</TT> and <TT>value=.</TT> That allows
+ the methods to be used like this:</P>
+<DIV class="code">
+<PRE>irb(main):001:0> <B>foo = Foo.new()</B>
+irb(main):002:0> <B>foo.value = 5</B>
+irb(main):003:0> <B>puts foo.value</B></PRE>
</DIV>
-<P> Overloading support is not quite as flexible as in C++. Sometimes
- there are methods that SWIG can't disambiguate. For example:</P>
+<P> This can be done by using the %rename directive:</P>
<DIV class="code">
-<PRE>void spam(int);
-void spam(short);</PRE>
+<PRE>%rename("value") Foo::getValue();
+%rename("value=") Foo::setValue(int value);</PRE>
</DIV>
-<P>or</P>
+<H2><A name="Ruby_nn32">38.5 Input and output parameters</A></H2>
+<P> A common problem in some C programs is handling parameters passed as
+ simple pointers. For example:</P>
<DIV class="code">
-<PRE>void foo(Bar *b);
-void foo(Bar &b);</PRE>
+<PRE>void add(int x, int y, int *result) {
+ *result = x + y;
+}</PRE>
</DIV>
-<P> If declarations such as these appear, you will get a warning message
- like this:</P>
-<DIV class="code shell">
+<P> or</P>
+<DIV class="code">
<PRE>
-example.i:12: Warning 509: Overloaded method spam(short) effectively ignored,
-example.i:11: Warning 509: as it is shadowed by spam(int).
-</PRE>
+int sub(int *x, int *y) {
+ return *x-*y;
+}</PRE>
</DIV>
-<P> To fix this, you either need to ignore or rename one of the methods.
- For example:</P>
+<P> The easiest way to handle these situations is to use the <TT>
+typemaps.i</TT> file. For example:</P>
<DIV class="code">
-<PRE>%rename(spam_short) spam(short);
-...
-void spam(int);
-void spam(short); // Accessed as spam_short</PRE>
+<PRE>%module Example
+%include "typemaps.i"
+
+void add(int, int, int *OUTPUT);
+int sub(int *INPUT, int *INPUT);</PRE>
</DIV>
-<P>or</P>
+<P>In Ruby, this allows you to pass simple values. For example:</P>
+<DIV class="code targetlang">
+<PRE>a = Example.add(3,4)
+puts a
+7
+b = Example.sub(7,4)
+puts b
+3</PRE>
+</DIV>
+<P> Notice how the <TT>INPUT</TT> parameters allow integer values to be
+ passed instead of pointers and how the <TT>OUTPUT</TT> parameter
+ creates a return result.</P>
+<P>If you don't want to use the names <TT>INPUT</TT> or <TT>OUTPUT</TT>,
+ use the <TT>%apply</TT> directive. For example:</P>
<DIV class="code">
-<PRE>%ignore spam(short);
-...
-void spam(int);
-void spam(short); // Ignored</PRE>
+<PRE>%module Example
+%include "typemaps.i"
+
+%apply int *OUTPUT { int *result };
+%apply int *INPUT { int *x, int *y};
+
+void add(int x, int y, int *result);
+int sub(int *x, int *y);</PRE>
</DIV>
-<P> SWIG resolves overloaded functions and methods using a
- disambiguation scheme that ranks and sorts declarations according to a
- set of type-precedence rules. The order in which declarations appear in
- the input does not matter except in situations where ambiguity
- arises--in this case, the first declaration takes precedence.</P>
-<P>Please refer to the <A href="#SWIGPlus">"SWIG and C++"</A> chapter
- for more information about overloading.</P>
-<H3><A name="Ruby_nn21"></A>36.3.10 C++ Operators</H3>
-<P> For the most part, overloaded operators are handled automatically by
- SWIG and do not require any special treatment on your part. So if your
- class declares an overloaded addition operator, e.g.</P>
+<P> If a function mutates one of its parameters like this,</P>
<DIV class="code">
-<PRE>class Complex {
- ...
- Complex operator+(Complex &);
- ...
-};</PRE>
+<PRE>void negate(int *x) {
+ *x = -(*x);
+}</PRE>
</DIV>
-<P> the resulting Ruby class will also support the addition (+) method
- correctly.</P>
-<P>For cases where SWIG's built-in support is not sufficient, C++
- operators can be wrapped using the <TT>%rename</TT> directive
- (available on SWIG 1.3.10 and later releases). All you need to do is
- give the operator the name of a valid Ruby identifier. For example:</P>
+<P>you can use <TT>INOUT</TT> like this:</P>
<DIV class="code">
-<PRE>%rename(add_complex) operator+(Complex &, Complex &);
+<PRE>%include "typemaps.i"
...
-Complex operator+(Complex &, Complex &);</PRE>
+void negate(int *INOUT);</PRE>
</DIV>
-<P>Now, in Ruby, you can do this:</P>
+<P>In Ruby, a mutated parameter shows up as a return value. For example:</P>
<DIV class="code targetlang">
-<PRE>a = Example::Complex.new(2, 3)
-b = Example::Complex.new(4, -1)
-c = Example.add_complex(a, b)</PRE>
+<PRE>a = Example.negate(3)
+print a
+-3</PRE>
</DIV>
-<P> More details about wrapping C++ operators into Ruby operators is
- discussed in the <A href="#Ruby_operator_overloading">section on
- operator overloading</A>.</P>
-<H3><A name="Ruby_nn22"></A>36.3.11 C++ namespaces</H3>
-<P> SWIG is aware of C++ namespaces, but namespace names do not appear
- in the module nor do namespaces result in a module that is broken up
- into submodules or packages. For example, if you have a file like this,</P>
+<P> The most common use of these special typemap rules is to handle
+ functions that return more than one value. For example, sometimes a
+ function returns a result as well as a special error code:</P>
+<DIV class="code">
+<PRE>/* send message, return number of bytes sent, success code, and error_code */
+int send_message(char *text, int *success, int *error_code);</PRE>
+</DIV>
+<P> To wrap such a function, simply use the <TT>OUTPUT</TT> rule above.
+ For example:</P>
<DIV class="code">
<PRE>%module example
-
-namespace foo {
- int fact(int n);
- struct Vector {
- double x,y,z;
- };
-};</PRE>
+%include "typemaps.i"
+...
+int send_message(char *, int *OUTPUT, int *OUTPUT);</PRE>
</DIV>
-<P>it works in Ruby as follows:</P>
+<P> When used in Ruby, the function will return an array of multiple
+ values.</P>
<DIV class="code targetlang">
-<PRE>irb(main):001:0> <B>require 'example'</B>
-true
-irb(main):002:0> <B>Example.fact(3)</B>
-6
-irb(main):003:0> <B>v = Example::Vector.new</B>
-#<Example::Vector:0x4016f4d4>
-irb(main):004:0> <B>v.x = 3.4</B>
-3.4
-irb(main):004:0> <B>v.y</B>
-0.0</PRE>
-</DIV>
-<P> If your program has more than one namespace, name conflicts (if any)
- can be resolved using <TT>%rename</TT> For example:</P>
-<DIV class="code">
-<PRE>%rename(Bar_spam) Bar::spam;
-
-namespace Foo {
- int spam();
-}
-
-namespace Bar {
- int spam();
-}</PRE>
+<PRE>bytes, success, error_code = send_message("Hello World")
+if not success
+ print "error #{error_code} : in send_message"
+else
+ print "Sent", bytes
+end</PRE>
</DIV>
-<P> If you have more than one namespace and your want to keep their
- symbols separate, consider wrapping them as separate SWIG modules. For
- example, make the module name the same as the namespace and create
- extension modules for each namespace separately. If your program
- utilizes thousands of small deeply nested namespaces each with
- identical symbol names, well, then you get what you deserve.</P>
-<H3><A name="Ruby_nn23"></A>36.3.12 C++ templates</H3>
-<P> C++ templates don't present a huge problem for SWIG. However, in
- order to create wrappers, you have to tell SWIG to create wrappers for
- a particular template instantiation. To do this, you use the <TT>
-%template</TT> directive. For example:</P>
+<P> Another way to access multiple return values is to use the <TT>
+%apply</TT> rule. In the following example, the parameters rows and
+ columns are related to SWIG as <TT>OUTPUT</TT> values through the use
+ of <TT>%apply</TT></P>
<DIV class="code">
-<PRE>%module example
-
-%{
-#include "pair.h"
-%}
-
-template<class T1, class T2>
-struct pair {
- typedef T1 first_type;
- typedef T2 second_type;
- T1 first;
- T2 second;
- pair();
- pair(const T1&, const T2&);
- ~pair();
-};
-
-%template(Pairii) pair<int,int>;</PRE>
+<PRE>%module Example
+%include "typemaps.i"
+%apply int *OUTPUT { int *rows, int *columns };
+...
+void get_dimensions(Matrix *m, int *rows, int*columns);</PRE>
</DIV>
<P>In Ruby:</P>
<DIV class="code targetlang">
-<PRE>irb(main):001:0> <B>require 'example'</B>
-true
-irb(main):002:0> <B>p = Example::Pairii.new(3, 4)</B>
-#<Example:Pairii:0x4016f4df>
-irb(main):003:0> <B>p.first</B>
-3
-irb(main):004:0> <B>p.second</B>
-4</PRE>
+<PRE>r, c = Example.get_dimensions(m)</PRE>
+</DIV>
+<H2><A name="Ruby_nn33">38.6 Exception handling</A></H2>
+<H3><A name="Ruby_nn34">38.6.1 Using the %exception directive</A></H3>
+<P>The SWIG <TT>%exception</TT> directive can be used to define a
+ user-definable exception handler that can convert C/C++ errors into
+ Ruby exceptions. The chapter on <A href="#Customization">Customization
+ Features</A> contains more details, but suppose you have a C++ class
+ like the following :</P>
+<DIV class="code">
+<PRE>class DoubleArray {
+private:
+ int n;
+ double *ptr;
+public:
+ // Create a new array of fixed size
+ DoubleArray(int size) {
+ ptr = new double[size];
+ n = size;
+ }
+
+ // Destroy an array
+ ~DoubleArray() {
+ delete ptr;
+ }
+
+ // Return the length of the array
+ int length() {
+ return n;
+ }
+
+ // Get an array item and perform bounds checking.
+ double getitem(int i) {
+ if ((i >= 0) && (i < n))
+ return ptr[i];
+ else
+ throw RangeError();
+ }
+
+ // Set an array item and perform bounds checking.
+ void setitem(int i, double val) {
+ if ((i >= 0) && (i < n))
+ ptr[i] = val;
+ else {
+ throw RangeError();
+ }
+ }
+};</PRE>
</DIV>
-<H3><A name="Ruby_nn23_1"></A>36.3.13 C++ Standard Template Library
- (STL)</H3>
-<P> On a related note, the standard SWIG library contains a number of
- modules that provide typemaps for standard C++ library classes (such as
- <TT>std::pair</TT>, <TT>std::string</TT> and <TT>std::vector</TT>).
- These library modules don't provide wrappers around the templates
- themselves, but they do make it convenient for users of your extension
- module to pass Ruby objects (such as arrays and strings) to wrapped C++
- code that expects instances of standard C++ templates. For example,
- suppose the C++ library you're wrapping has a function that expects a
- vector of floats:</P>
+<P> Since several methods in this class can throw an exception for an
+ out-of-bounds access, you might want to catch this in the Ruby
+ extension by writing the following in an interface file:</P>
<DIV class="code">
-<PRE>%module example
+<PRE>%exception {
+ try {
+ $action
+ }
+ catch (const RangeError&) {
+ static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
+ rb_raise(cpperror, "Range error.");
+ }
+}
-float sum(const std::vector<float>& values);</PRE>
+class DoubleArray {
+ ...
+};</PRE>
</DIV>
-<P> Rather than go through the hassle of writing an "in" typemap to
- convert an array of Ruby numbers into a std::vector<float>, you can
- just use the <TT>std_vector.i</TT> module from the standard SWIG
- library:</P>
+<P> The exception handling code is inserted directly into generated
+ wrapper functions. When an exception handler is defined, errors can be
+ caught and used to gracefully raise a Ruby exception instead of forcing
+ the entire program to terminate with an uncaught error.</P>
+<P>As shown, the exception handling code will be added to every wrapper
+ function. Because this is somewhat inefficient, you might consider
+ refining the exception handler to only apply to specific methods like
+ this:</P>
<DIV class="code">
-<PRE>%module example
-
-%include std_vector.i
-float sum(const std::vector<float>& values);</PRE>
-</DIV>
-<P>Ruby's STL wrappings provide additional methods to make them behave
- more similarly to Ruby's native classes.</P>
-<P>Thus, you can do, for example:</P>
-<DIV class="targetlang">
-<PRE>v = IntVector.new
-v << 2
-v << 3
-v << 4
-v.each { |x| puts x }
-
-=> 2
-3
-4
-v.delete_if { |x| x == 3 }
-=> [2,4]</PRE>
+<PRE>%exception getitem {
+ try {
+ $action
+ } catch (const RangeError&) {
+ static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
+ rb_raise(cpperror, "Range error in getitem.");
+ }
+}
+
+%exception setitem {
+ try {
+ $action
+ } catch (const RangeError&) {
+ static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
+ rb_raise(cpperror, "Range error in setitem.");
+ }
+}</PRE>
</DIV>
-<P>The SWIG Ruby module provides also the ability for all the STL
- containers to carry around Ruby native objects (Fixnum, Classes, etc)
- making them act almost like Ruby's own Array, Hash, etc. To do that,
- you need to define a container that contains a swig::GC_VALUE, like:</P>
+<P> In this case, the exception handler is only attached to methods and
+ functions named <TT>getitem</TT> and <TT>setitem</TT>.</P>
+<P>Since SWIG's exception handling is user-definable, you are not
+ limited to C++ exception handling. See the chapter on <A href="#Customization">
+Customization Features</A> for more examples.</P>
+<H3><A name="Ruby_nn34_2">38.6.2 Handling Ruby Blocks</A></H3>
+<P>One of the highlights of Ruby and most of its standard library is the
+ use of blocks, which allow the easy creation of continuations and other
+ niceties. Blocks in ruby are also often used to simplify the passing of
+ many arguments to a class.</P>
+<P>In order to make your class constructor support blocks, you can take
+ advantage of the %exception directive, which will get run after the C++
+ class' constructor was called.</P>
+<P>For example, this yields the class over after its construction:</P>
<DIV class="code">
-<PRE>
-%module nativevector
-
-%{
-std::vector< swig::GC_VALUE > NativeVector;
-%}
+<PRE>class Window
+{
+public:
+ Window(int x, int y, int w, int h);
+ // .... other methods here ....
+};
-%template(NativeVector) std::vector< swig::GC_VALUE >;
-</PRE>
+// Add support for yielding self in the Class' constructor.
+%exception Window::Window {
+ $action
+ if (rb_block_given_p()) {
+ rb_yield(self);
+ }
+}</PRE>
</DIV>
-<P>This vector can then contain any Ruby object, making them almost
- identical to Ruby's own Array class.</P>
+<P> Then, in ruby, it can be used like:</P>
<DIV class="targetlang">
-<PRE>require 'nativevector'
-include NativeVector
-
-v = NativeVector.new
-v << 1
-v << [1,2]
-v << 'hello'
-
-class A; end
-
-v << A.new
-
-puts v
-=> [1, [1,2], 'hello', #<A:0x245325>]
+<PRE>
+Window.new(0,0,360,480) { |w|
+ w.color = Fltk::RED
+ w.border = false
+}
</PRE>
</DIV>
-<P>Obviously, there is a lot more to template wrapping than shown in
- these examples. More details can be found in the <A href="#SWIGPlus">
-SWIG and C++</A> chapter.</P>
-<H3><A name="Ruby_C_STL_Functors"></A>36.3.14 C++ STL Functors</H3>
-<P>Some containers in the STL allow you to modify their default behavior
- by using so called functors or function objects. Functors are often
- just a very simple struct with <TT>operator()</TT> redefined or an
- actual C/C++ function. This allows you, for example, to always keep the
- sort order of a STL container to your liking.</P>
-<P>The Ruby STL mappings allows you to modify those containers that
- support functors using Ruby procs or methods, instead. Currently, this
- includes <TT>std::set</TT>, <TT>set::map</TT>, <TT>std::multiset</TT>
- and <TT>std::multimap</TT>.</P>
-<P>The functors in swig are called <TT>swig::UnaryFunction</TT> and <TT>
-swig::BinaryFunction</TT>. For C++ predicates (ie. functors that must
- return bool as a result) <TT>swig::UnaryPredicate</TT> and <TT>
-swig::BinaryPredicate</TT> are provided.</P>
-<P>As an example, if given this swig file:</P>
+<P>For other methods, you can usually use a dummy parameter with a
+ special in typemap, like:</P>
<DIV class="code">
<PRE>
-%module intset;
+//
+// original function was:
+//
+// void func(int x);
-%include <std_set.i>
+%typemap(in,numinputs=0) int RUBY_YIELD_SELF {
+ if ( !rb_block_given_p() )
+ rb_raise("No block given");
+ return rb_yield(self);
+}
-%typemap(IntSet) std::set< int, swig::BinaryPredicate >;
+%extend {
+ void func(int x, int RUBY_YIELD_SELF );
+}
</PRE>
</DIV>
-<P>You can then use the set from Ruby with or without a proc object as a
- predicate:</P>
-<DIV class="targetlang">
-<PRE>
-require 'intset'
-include Intset
-
-# Default sorting behavior defined in C++
-a = IntSet.new
-a << 1
-a << 2
-a << 3
-a
-<B>=> [1,2,3]</B>
-
-# Custom sorting behavior defined by a Ruby proc
-b = IntSet.new( proc { |a,b| a > b } )
-b << 1
-b << 2
-b << 3
-b
-<B>=> [3,2,1]</B>
-</PRE>
+<P>For more information on typemaps, see <A href="#Ruby_nn37">Typemaps</A>
+.</P>
+<H3><A name="Ruby_nn35">38.6.3 Raising exceptions</A></H3>
+<P>There are three ways to raise exceptions from C++ code to Ruby.</P>
+<P>The first way is to use <TT>SWIG_exception(int code, const char *msg)</TT>
+. The following table shows the mappings from SWIG error codes to Ruby
+ exceptions:</P>
+<DIV class="diagram">
+<TABLE border="1" class="diagram" summary="Mapping between SWIG error codes and Ruby exceptions."
+width="80%"><TBODY></TBODY>
+<TR><TD class="diagram"><DIV>SWIG_MemoryError</DIV></TD><TD><DIV>
+rb_eNoMemError</DIV></TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_IOError</DIV></TD><TD><DIV>rb_eIOError</DIV>
+</TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_RuntimeError</DIV></TD><TD><DIV>
+rb_eRuntimeError</DIV></TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_IndexError</DIV></TD><TD><DIV>
+rb_eIndexError</DIV></TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_TypeError</DIV></TD><TD><DIV>
+rb_eTypeError</DIV></TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_DivisionByZero</DIV></TD><TD><DIV>
+rb_eZeroDivError</DIV></TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_OverflowError</DIV></TD><TD><DIV>
+rb_eRangeError</DIV></TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_SyntaxError</DIV></TD><TD><DIV>
+rb_eSyntaxError</DIV></TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_ValueError</DIV></TD><TD><DIV>
+rb_eArgError</DIV></TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_SystemError</DIV></TD><TD><DIV>
+rb_eFatal</DIV></TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_AttributeError</DIV></TD><TD><DIV>
+rb_eRuntimeError</DIV></TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_NullReferenceError</DIV></TD><TD><DIV>
+rb_eNullReferenceError*</DIV></TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_ObjectPreviouslyDeletedError</DIV></TD><TD>
+<DIV>rb_eObjectPreviouslyDeleted*</DIV></TD></TR>
+<TR><TD class="diagram"><DIV>SWIG_UnknownError</DIV></TD><TD><DIV>
+rb_eRuntimeError</DIV></TD></TR>
+<TR class="diagram"><TD colspan="2"><DIV>* These error classes are
+ created by SWIG and are not built-in Ruby exception classes</DIV></TD></TR>
+</TABLE>
</DIV>
-<H3><A name="Ruby_C_Iterators"></A>36.3.15 C++ STL Iterators</H3>
-<P>The STL is well known for the use of iterators. There are a number of
- iterators possible with different properties, but in general there are
- two main categories: const iterators and non-const iterators. The const
- iterators can access and not modify the values they point at, while the
- non-const iterators can both read and modify the values.</P>
-<P>The Ruby STL wrappings support both type of iterators by using a
- proxy class in-between. This proxy class is <TT>swig::Iterator or
- swig::ConstIterator.</TT> Derived from them are template classes that
- need to be initialized with the actual iterator for the container you
- are wrapping and often times with the beginning and ending points of
- the iteration range.</P>
-<P>The SWIG STL library already provides typemaps to all the standard
- containers to do this wrapping automatically for you, but if you have
- your own STL-like iterator, you will need to write your own typemap for
- them. For out typemaps, the special functions <TT>make_const_iterator</TT>
- and <TT>make_nonconst_iterator</TT> are provided.</P>
-<P>These can be used either like:</P>
+<P>The second way to raise errors is to use <TT>SWIG_Raise(obj, type,
+ desc)</TT>. Obj is a C++ instance of an exception class, type is a
+ string specifying the type of exception (for example, "MyError") and
+ desc is the SWIG description of the exception class. For example:</P>
<DIV class="code">
<PRE>
-make_const_iterator( iterator, rubyclass );
-make_const_iterator( iterator, iterator_begin, iterator_end, rubyclass );
+%raise(SWIG_NewPointerObj(e, SWIGTYPE_p_AssertionFailedException, 0), ":AssertionFailedException", SWIGTYPE_p_AssertionFailedException);
</PRE>
</DIV>
-<P>The iterators support a <TT>next()</TT> and <TT>previous()</TT>
- member function to just change the iterator without returning anything.
- <TT>previous()</TT> should obviously only be used for bidirectional
- iterators. You can also advance the iterator multiple steps by using
- standard math operations like <TT>+=</TT>.</P>
-<P>The value the iterator points at can be accessed with <TT>value()</TT>
- -- this is equivalent to dereferencing it with <TT>*i</TT>. For
- non-const iterators, a <TT>value=()</TT> function is also provided
- which allows you to change the value pointed by the iterator. This is
- equivalent to the C++ construct of dereferencing and assignment, like <TT>
-*i = something</TT>.</P>
-<P>Thus, given say a vector class of doubles defined as:</P>
+<P>This is useful when you want to pass the current exception object
+ directly to Ruby, particularly when the object is an instance of class
+ marked as an <TT>%exceptionclass</TT> (see the next section for more
+ information).</P>
+<P>Last, you can raise an exception by directly calling Ruby's C api.
+ This is done by invoking the <TT>rb_raise()</TT> function. The first
+ argument passed to <TT>rb_raise()</TT> is the exception type. You can
+ raise a custom exception type or one of the built-in Ruby exception
+ types.</P>
+<H3><A name="Ruby_nn36">38.6.4 Exception classes</A></H3>
+<P>Starting with SWIG 1.3.28, the Ruby module supports the <TT>
+%exceptionclass</TT> directive, which is used to identify C++ classes
+ that are used as exceptions. Classes that are marked with the <TT>
+%exceptionclass</TT> directive are exposed in Ruby as child classes of <TT>
+rb_eRuntimeError</TT>. This allows C++ exceptions to be directly mapped
+ to Ruby exceptions, providing for a more natural integration between
+ C++ code and Ruby code.</P>
<DIV class="code">
-<PRE>
-%module doublevector
+<PRE>%exceptionclass CustomError;
-%include std_vector.i
+%inline %{
+ class CustomError { };
-%template(DoubleVector) std::vector<double>;
-</PRE>
+ class Foo {
+ public:
+ void test() { throw CustomError; }
+ };
+%}</PRE>
</DIV>
-<P>Its iterator can then be used from Ruby like:</P>
-<DIV class="targetlang">
-<PRE>
-require 'doublevector'
-include Doublevector
-
-v = DoubleVector.new
-v << 1
-v << 2
-v << 3
-
-#
-# an elaborate and less efficient way of doing v.map! { |x| x+2 }
-#
-i = v.begin
-e = v.end
-while i != e
- val = i.value
- val += 2
- i.value = val
- i.next
-end
-i
-<B>>> [3, 4, 5 ]</B>
-</PRE>
+<P>From Ruby you can now call this method like this:</P>
+<DIV class="code targetlang">
+<PRE>foo = Foo.new
+begin
+ foo.test()
+rescue CustomError => e
+ puts "Caught custom error"
+end </PRE>
</DIV>
-<P>If you'd rather have STL classes without any iterators, you should
- define <TT>-DSWIG_NO_EXPORT_ITERATOR_METHODS</TT> when running swig.</P>
-<H3><A name="Ruby_nn24"></A>36.3.16 C++ Smart Pointers</H3>
-<P> In certain C++ programs, it is common to use classes that have been
- wrapped by so-called "smart pointers." Generally, this involves the use
- of a template class that implements <TT>operator->()</TT> like this:</P>
+<P>For another example look at swig/Examples/ruby/exception_class.</P>
+<H2><A name="Ruby_nn37">38.7 Typemaps</A></H2>
+<P> This section describes how you can modify SWIG's default wrapping
+ behavior for various C/C++ datatypes using the <TT>%typemap</TT>
+ directive. This is an advanced topic that assumes familiarity with the
+ Ruby C API as well as the material in the "<A href="#Typemaps">Typemaps</A>
+" chapter.</P>
+<P>Before proceeding, it should be stressed that typemaps are not a
+ required part of using SWIG---the default wrapping behavior is enough
+ in most cases. Typemaps are only used if you want to change some aspect
+ of the primitive C-Ruby interface.</P>
+<H3><A name="Ruby_nn38">38.7.1 What is a typemap?</A></H3>
+<P> A typemap is nothing more than a code generation rule that is
+ attached to a specific C datatype. The general form of this declaration
+ is as follows ( parts enclosed in [...] are optional ):</P>
<DIV class="code">
-<PRE>template<class T> class SmartPtr {
- ...
- T *operator->();
- ...
-}</PRE>
+<PRE>
+%typemap( method [, modifiers...] ) typelist code;
+</PRE>
</DIV>
-<P>Then, if you have a class like this,</P>
-<DIV class="code">
-<PRE>class Foo {
-public:
- int x;
- int bar();
-};</PRE>
+<P><EM> method</EM> is a simply a name that specifies what kind of
+ typemap is being defined. It is usually a name like <TT>"in"</TT>, <TT>
+"out"</TT>, or <TT>"argout"</TT> (or its director variations). The
+ purpose of these methods is described later.</P>
+<P><EM> modifiers</EM> is an optional comma separated list of <TT>
+name="value"</TT> values. These are sometimes to attach extra
+ information to a typemap and is often target-language dependent.</P>
+<P><EM> typelist</EM> is a list of the C++ type patterns that the
+ typemap will match. The general form of this list is as follows:</P>
+<DIV class="diagram">
+<PRE>typelist : typepattern [, typepattern, typepattern, ... ] ;
+
+typepattern : type [ (parms) ]
+ | type name [ (parms) ]
+ | ( typelist ) [ (parms) ]</PRE>
</DIV>
-<P>A smart pointer would be used in C++ as follows:</P>
-<DIV class="code">
-<PRE>SmartPtr<Foo> p = CreateFoo(); // Created somehow (not shown)
-...
-p->x = 3; // Foo::x
-int y = p->bar(); // Foo::bar</PRE>
+<P> Each type pattern is either a simple type, a simple type and
+ argument name, or a list of types in the case of multi-argument
+ typemaps. In addition, each type pattern can be parameterized with a
+ list of temporary variables (parms). The purpose of these variables
+ will be explained shortly.</P>
+<P><EM>code</EM> specifies the C code used in the typemap. It can take
+ any one of the following forms:</P>
+<DIV class="diagram">
+<PRE>code : { ... }
+ | " ... "
+ | %{ ... %}</PRE>
</DIV>
-<P> To wrap this in Ruby, simply tell SWIG about the <TT>SmartPtr</TT>
- class and the low-level <TT>Foo</TT> object. Make sure you instantiate <TT>
-SmartPtr</TT> using <TT>%template</TT> if necessary. For example:</P>
+<P>For example, to convert integers from Ruby to C, you might define a
+ typemap like this:</P>
<DIV class="code">
<PRE>%module example
-...
-%template(SmartPtrFoo) SmartPtr<Foo>;
-...</PRE>
-</DIV>
-<P>Now, in Ruby, everything should just "work":</P>
-<DIV class="code targetlang">
-<PRE>irb(main):001:0> <B>p = Example::CreateFoo()</B> # Create a smart-pointer somehow
-#<Example::SmartPtrFoo:0x4016f4df>
-irb(main):002:0> <B>p.x = 3</B> # Foo::x
-3
-irb(main):003:0> <B>p.bar()</B> # Foo::bar</PRE>
+
+%typemap(in) int {
+ $1 = (int) NUM2INT($input);
+ printf("Received an integer : %d\n",$1);
+}
+
+%inline %{
+ extern int fact(int n);
+%}</PRE>
</DIV>
-<P> If you ever need to access the underlying pointer returned by <TT>
-operator->()</TT> itself, simply use the <TT>__deref__()</TT> method.
- For example:</P>
+<P> Typemaps are always associated with some specific aspect of code
+ generation. In this case, the "in" method refers to the conversion of
+ input arguments to C/C++. The datatype <TT>int</TT> is the datatype to
+ which the typemap will be applied. The supplied C code is used to
+ convert values. In this code a number of special variables prefaced by
+ a <TT>$</TT> are used. The <TT>$1</TT> variable is placeholder for a
+ local variable of type <TT>int</TT>. The <TT>$input</TT> variable is
+ the input Ruby object.</P>
+<P>When this example is compiled into a Ruby module, the following
+ sample code:</P>
<DIV class="code targetlang">
-<PRE>irb(main):004:0> <B>f = p.__deref__()</B> # Returns underlying Foo *</PRE>
-</DIV>
-<H3><A name="Ruby_nn25"></A>36.3.17 Cross-Language Polymorphism</H3>
-<P> SWIG's Ruby module supports cross-language polymorphism (a.k.a. the
- "directors" feature) similar to that for SWIG's Python module. Rather
- than duplicate the information presented in the <A href="#Python">
-Python</A> chapter, this section just notes the differences that you
- need to be aware of when using this feature with Ruby.</P>
-<H4><A name="Ruby_nn26"></A>36.3.17.1 Exception Unrolling</H4>
-<P> Whenever a C++ director class routes one of its virtual member
- function calls to a Ruby instance method, there's always the
- possibility that an exception will be raised in the Ruby code. By
- default, those exceptions are ignored, which simply means that the
- exception will be exposed to the Ruby interpreter. If you would like to
- change this behavior, you can use the <TT>%feature("director:except")</TT>
- directive to indicate what action should be taken when a Ruby exception
- is raised. The following code should suffice in most cases:</P>
-<DIV class="code">
-<PRE>%feature("director:except") {
- throw Swig::DirectorMethodException($error);
-}</PRE>
-</DIV>
-<P> When this feature is activated, the call to the Ruby instance method
- is "wrapped" using the <TT>rb_rescue2()</TT> function from Ruby's C
- API. If any Ruby exception is raised, it will be caught here and a C++
- exception is raised in its place.</P>
-<H2><A name="Ruby_nn27"></A>36.4 Naming</H2>
-<P>Ruby has several common naming conventions. Constants are generally
- in upper case, module and class names are in camel case and methods are
- in lower case with underscores. For example:</P>
-<DIV class="code">
-<UL>
-<LI><STRONG>MATH::PI</STRONG> is a constant name</LI>
-<LI><STRONG>MyClass</STRONG> is a class name</LI>
-<LI><STRONG>my_method</STRONG> is a method name</LI>
-</UL>
+<PRE>require 'example'
+
+puts Example.fact(6)</PRE>
</DIV>
-<P>Prior to version 1.3.28, SWIG did not support these Ruby conventions.
- The only modifications it made to names was to capitalize the first
- letter of constants (which includes module and class names).</P>
-<P>SWIG 1.3.28 introduces the new -autorename command line parameter.
- When this parameter is specified, SWIG will automatically change
- constant, class and method names to conform with the standard Ruby
- naming conventions. For example:</P>
+<P>prints the result:</P>
<DIV class="code shell">
-<PRE>$ swig -ruby -autorename example.i
+<PRE>
+Received an integer : 6
+720
</PRE>
</DIV>
-<P>To disable renaming use the -noautorename command line option.</P>
-<P>Since this change significantly changes the wrapper code generated by
- SWIG, it is turned off by default in SWIG 1.3.28. However, it is
- planned to become the default option in future releases.</P>
-<H3><A name="Ruby_nn28"></A>36.4.1 Defining Aliases</H3>
-<P> It's a fairly common practice in the Ruby built-ins and standard
- library to provide aliases for method names. For example,<EM>
- Array#size</EM> is an alias for<EM> Array#length</EM>. If you would
- like to provide an alias for one of your class' instance methods, one
- approach is to use SWIG's <TT>%extend</TT> directive to add a new
- method of the aliased name that calls the original function. For
- example:</P>
-<DIV class="code">
-<PRE>class MyArray {
-public:
- // Construct an empty array
- MyArray();
-
- // Return the size of this array
- size_t length() const;
-};
+<P> In this example, the typemap is applied to all occurrences of the <TT>
+int</TT> datatype. You can refine this by supplying an optional
+ parameter name. For example:</P>
+<DIV class="code">
+<PRE>%module example
-%extend MyArray {
- // MyArray#size is an alias for MyArray#length
- size_t size() const {
- return $self->length();
- }
+%typemap(in) int n {
+ $1 = (int) NUM2INT($input);
+ printf("n = %d\n",$1);
}
- </PRE>
+
+%inline %{
+ extern int fact(int n);
+%}</PRE>
</DIV>
-<P> A better solution is to use the <TT>%alias</TT> directive (unique to
- SWIG's Ruby module). The previous example could then be rewritten as:</P>
+<P> In this case, the typemap code is only attached to arguments that
+ exactly match "<TT>int n</TT>".</P>
+<P>The application of a typemap to specific datatypes and argument names
+ involves more than simple text-matching--typemaps are fully integrated
+ into the SWIG type-system. When you define a typemap for <TT>int</TT>,
+ that typemap applies to <TT>int</TT> and qualified variations such as <TT>
+const int</TT>. In addition, the typemap system follows <TT>typedef</TT>
+ declarations. For example:</P>
<DIV class="code">
-<PRE>// MyArray#size is an alias for MyArray#length
-%alias MyArray::length "size";
+<PRE>%typemap(in) int n {
+ $1 = (int) NUM2INT($input);
+ printf("n = %d\n",$1);
+}
-class MyArray {
-public:
- // Construct an empty array
- MyArray();
-
- // Return the size of this array
- size_t length() const;
-};</PRE>
+typedef int Integer;
+extern int fact(Integer n); // Above typemap is applied</PRE>
</DIV>
-<P> Multiple aliases can be associated with a method by providing a
- comma-separated list of aliases to the <TT>%alias</TT> directive, e.g.</P>
+<P> However, the matching of <TT>typedef</TT> only occurs in one
+ direction. If you defined a typemap for <TT>Integer</TT>, it is not
+ applied to arguments of type <TT>int</TT>.</P>
+<P>Typemaps can also be defined for groups of consecutive arguments. For
+ example:</P>
<DIV class="code">
-<PRE>%alias MyArray::length "amount,quantity,size";</PRE>
+<PRE>%typemap(in) (char *str, int len) {
+ $1 = StringValuePtr($input);
+ $2 = (int) RSTRING($input)->len;
+};
+
+int count(char c, char *str, int len);</PRE>
</DIV>
-<P> From an end-user's standpoint, there's no functional difference
- between these two approaches; i.e. they should get the same result from
- calling either<EM> MyArray#size</EM> or<EM> MyArray#length</EM>.
- However, when the <TT>%alias</TT> directive is used, SWIG doesn't need
- to generate all of the wrapper code that's usually associated with
- added methods like our<EM> MyArray::size()</EM> example.</P>
-<P>Note that the <TT>%alias</TT> directive is implemented using SWIG's
- "features" mechanism and so the same name matching rules used for other
- kinds of features apply (see the chapter on <A href="#Customization">
-"Customization Features"</A>) for more details).</P>
-<H3><A name="Ruby_nn29"></A>36.4.2 Predicate Methods</H3>
-<P> Ruby methods that return a boolean value and end in a question mark
- are known as predicate methods. Examples of predicate methods in
- standard Ruby classes include<EM> Array#empty?</EM> (which returns <TT>
-true</TT> for an array containing no elements) and<EM>
- Object#instance_of?</EM> (which returns <TT>true</TT> if the object is
- an instance of the specified class). For consistency with Ruby
- conventions, methods that return boolean values should be marked as
- predicate methods.</P>
-<P>One cumbersome solution to this problem is to rename the method
- (using SWIG's <TT>%rename</TT> directive) and provide a custom typemap
- that converts the function's actual return type to Ruby's <TT>true</TT>
- or <TT>false</TT>. For example:</P>
+<P> When a multi-argument typemap is defined, the arguments are always
+ handled as a single Ruby object. This allows the function <TT>count</TT>
+ to be used as follows (notice how the length parameter is omitted):</P>
+<DIV class="code targetlang">
+<PRE>puts Example.count('o','Hello World')
+2</PRE>
+</DIV>
+<H3><A name="Ruby_Typemap_scope">38.7.2 Typemap scope</A></H3>
+<P> Once defined, a typemap remains in effect for all of the
+ declarations that follow. A typemap may be redefined for different
+ sections of an input file. For example:</P>
<DIV class="code">
-<PRE>%rename("is_it_safe?") is_it_safe();
+<PRE>// typemap1
+%typemap(in) int {
+ ...
+}
-%typemap(out) int is_it_safe "$result = ($1 != 0) ? Qtrue : Qfalse;";
+int fact(int); // typemap1
+int gcd(int x, int y); // typemap1
-int is_it_safe();</PRE>
+// typemap2
+%typemap(in) int {
+ ...
+}
+
+int isprime(int); // typemap2</PRE>
</DIV>
-<P> A better solution is to use the <TT>%predicate</TT> directive
- (unique to SWIG's Ruby module) to designate a method as a predicate
- method. For the previous example, this would look like:</P>
+<P> One exception to the typemap scoping rules pertains to the <TT>
+%extend</TT> declaration. <TT>%extend</TT> is used to attach new
+ declarations to a class or structure definition. Because of this, all
+ of the declarations in an <TT>%extend</TT> block are subject to the
+ typemap rules that are in effect at the point where the class itself is
+ defined. For example:</P>
<DIV class="code">
-<PRE>%predicate is_it_safe();
+<PRE>class Foo {
+ ...
+};
-int is_it_safe();</PRE>
+%typemap(in) int {
+ ...
+}
+
+%extend Foo {
+ int blah(int x); // typemap has no effect. Declaration is attached to Foo which
+ // appears before the %typemap declaration.
+};</PRE>
</DIV>
-<P>This method would be invoked from Ruby code like this:</P>
-<DIV class="code targetlang">
-<PRE>irb(main):001:0> <B>Example::is_it_safe?</B>
-true</PRE>
+<H3><A name="Ruby_Copying_a_typemap">38.7.3 Copying a typemap</A></H3>
+<P> A typemap is copied by using assignment. For example:</P>
+<DIV class="code">
+<PRE>%typemap(in) Integer = int;</PRE>
</DIV>
-<P> The <TT>%predicate</TT> directive is implemented using SWIG's
- "features" mechanism and so the same name matching rules used for other
- kinds of features apply (see the chapter on <A href="#Customization">
-"Customization Features"</A>) for more details).</P>
-<H3><A name="Ruby_nn30"></A>36.4.3 Bang Methods</H3>
-<P> Ruby methods that modify an object in-place and end in an
- exclamation mark are known as bang methods. An example of a bang method
- is<EM> Array#sort!</EM> which changes the ordering of items in an
- array. Contrast this with<EM> Array#sort</EM>, which returns a copy of
- the array with the items sorted instead of modifying the original
- array. For consistency with Ruby conventions, methods that modify
- objects in place should be marked as bang methods.</P>
-<P>Bang methods can be marked using the <TT>%bang</TT> directive which
- is unique to the Ruby module and was introduced in SWIG 1.3.28. For
+<P> or this:</P>
+<DIV class="code">
+<PRE>%typemap(in) Integer, Number, int32_t = int;</PRE>
+</DIV>
+<P> Types are often managed by a collection of different typemaps. For
example:</P>
<DIV class="code">
-<PRE>%bang sort(int arr[]);
-
-int sort(int arr[]); </PRE>
+<PRE>%typemap(in) int { ... }
+%typemap(out) int { ... }
+%typemap(varin) int { ... }
+%typemap(varout) int { ... }</PRE>
</DIV>
-<P>This method would be invoked from Ruby code like this:</P>
+<P> To copy all of these typemaps to a new type, use <TT>%apply</TT>.
+ For example:</P>
<DIV class="code">
-<PRE>irb(main):001:0> <B>Example::sort!(arr)</B></PRE>
+<PRE>%apply int { Integer }; // Copy all int typemaps to Integer
+%apply int { Integer, Number }; // Copy all int typemaps to both Integer and Number</PRE>
</DIV>
-<P> The <TT>%bang</TT> directive is implemented using SWIG's "features"
- mechanism and so the same name matching rules used for other kinds of
- features apply (see the chapter on <A href="#Customization">
-"Customization Features"</A>) for more details).</P>
-<H3><A name="Ruby_nn31"></A>36.4.4 Getters and Setters</H3>
-<P> Often times a C++ library will expose properties through getter and
- setter methods. For example:</P>
+<P> The patterns for <TT>%apply</TT> follow the same rules as for <TT>
+%typemap</TT>. For example:</P>
<DIV class="code">
-<PRE>class Foo {
- Foo() {}
- int getValue() { return value_; }
- void setValue(int value) { value_ = value; }
-
-private:
- int value_;
-};</PRE>
+<PRE>%apply int *output { Integer *output }; // Typemap with name
+%apply (char *buf, int len) { (char *buffer, int size) }; // Multiple arguments</PRE>
</DIV>
-<P>By default, SWIG will expose these methods to Ruby as <TT>get_value</TT>
- and <TT>set_value.</TT> However, it more natural for these methods to
- be exposed in Ruby as <TT>value</TT> and <TT>value=.</TT> That allows
- the methods to be used like this:</P>
+<H3><A name="Ruby_Deleting_a_typemap">38.7.4 Deleting a typemap</A></H3>
+<P> A typemap can be deleted by simply defining no code. For example:</P>
<DIV class="code">
-<PRE>irb(main):001:0> <B>foo = Foo.new()</B>
-irb(main):002:0> <B>foo.value = 5</B>
-irb(main):003:0> <B>puts foo.value</B></PRE>
+<PRE>%typemap(in) int; // Clears typemap for int
+%typemap(in) int, long, short; // Clears typemap for int, long, short
+%typemap(in) int *output; </PRE>
</DIV>
-<P> This can be done by using the %rename directive:</P>
+<P> The <TT>%clear</TT> directive clears all typemaps for a given type.
+ For example:</P>
<DIV class="code">
-<PRE>%rename("value") Foo::getValue();
-%rename("value=") Foo::setValue(int value);</PRE>
+<PRE>%clear int; // Removes all types for int
+%clear int *output, long *output;</PRE>
</DIV>
-<H2><A name="Ruby_nn32"></A>36.5 Input and output parameters</H2>
-<P> A common problem in some C programs is handling parameters passed as
- simple pointers. For example:</P>
+<P><B> Note:</B> Since SWIG's default behavior is defined by typemaps,
+ clearing a fundamental type like <TT>int</TT> will make that type
+ unusable unless you also define a new set of typemaps immediately after
+ the clear operation.</P>
+<H3><A name="Ruby_Placement_of_typemaps">38.7.5 Placement of typemaps</A>
+</H3>
+<P> Typemap declarations can be declared in the global scope, within a
+ C++ namespace, and within a C++ class. For example:</P>
<DIV class="code">
-<PRE>void add(int x, int y, int *result) {
- *result = x + y;
-}</PRE>
+<PRE>%typemap(in) int {
+ ...
+}
+
+namespace std {
+ class string;
+ %typemap(in) string {
+ ...
+ }
+}
+
+class Bar {
+public:
+ typedef const int & const_reference;
+ %typemap(out) const_reference {
+ ...
+ }
+};</PRE>
</DIV>
-<P> or</P>
+<P> When a typemap appears inside a namespace or class, it stays in
+ effect until the end of the SWIG input (just like before). However, the
+ typemap takes the local scope into account. Therefore, this code</P>
<DIV class="code">
-<PRE>
-int sub(int *x, int *y) {
- return *x-*y;
+<PRE>namespace std {
+ class string;
+ %typemap(in) string {
+ ...
+ }
}</PRE>
</DIV>
-<P> The easiest way to handle these situations is to use the <TT>
-typemaps.i</TT> file. For example:</P>
+<P> is really defining a typemap for the type <TT>std::string</TT>. You
+ could have code like this:</P>
<DIV class="code">
-<PRE>%module Example
-%include "typemaps.i"
+<PRE>namespace std {
+ class string;
+ %typemap(in) string { /* std::string */
+ ...
+ }
+}
-void add(int, int, int *OUTPUT);
-int sub(int *INPUT, int *INPUT);</PRE>
+namespace Foo {
+ class string;
+ %typemap(in) string { /* Foo::string */
+ ...
+ }
+}</PRE>
</DIV>
-<P>In Ruby, this allows you to pass simple values. For example:</P>
-<DIV class="code targetlang">
-<PRE>a = Example.add(3,4)
-puts a
-7
-b = Example.sub(7,4)
-puts b
-3</PRE>
+<P> In this case, there are two completely distinct typemaps that apply
+ to two completely different types (<TT>std::string</TT> and <TT>
+Foo::string</TT>).</P>
+<P> It should be noted that for scoping to work, SWIG has to know that <TT>
+string</TT> is a typename defined within a particular namespace. In this
+ example, this is done using the class declaration <TT>class string</TT>
+ .</P>
+<H3><A name="Ruby_nn39">38.7.6 Ruby typemaps</A></H3>
+<P>The following list details all of the typemap methods that can be
+ used by the Ruby module:</P>
+<H4><A name="Ruby_in_typemap">38.7.6.1 "in" typemap</A></H4>
+<P>Converts Ruby objects to input function arguments. For example:</P>
+<DIV class="code">
+<PRE>%typemap(in) int {
+ $1 = NUM2INT($input);
+}</PRE>
</DIV>
-<P> Notice how the <TT>INPUT</TT> parameters allow integer values to be
- passed instead of pointers and how the <TT>OUTPUT</TT> parameter
- creates a return result.</P>
-<P>If you don't want to use the names <TT>INPUT</TT> or <TT>OUTPUT</TT>,
- use the <TT>%apply</TT> directive. For example:</P>
+<P> The following special variables are available:</P>
+<DIV class="diagram">
+<TABLE border="1" cellpadding="2" cellspacing="2" summary="Special variables - in typemap"
+width="100%"><TBODY></TBODY>
+<TR><TD>$input</TD><TD> Input object holding value to be converted.</TD></TR>
+<TR><TD>$symname</TD><TD> Name of function/method being wrapped</TD></TR>
+<TR><TD>$1...n</TD><TD> Argument being sent to the function</TD></TR>
+<TR><TD>$1_name</TD><TD> Name of the argument (if provided)</TD></TR>
+<TR><TD>$1_type</TD><TD> The actual C datatype matched by the typemap.</TD>
+</TR>
+<TR><TD>$1_ltype</TD><TD> The assignable version of the C datatype
+ matched by the typemap.</TD></TR>
+</TABLE>
+</DIV>
+<P> This is probably the most commonly redefined typemap because it can
+ be used to implement customized conversions.</P>
+<P> In addition, the "in" typemap allows the number of converted
+ arguments to be specified. For example:</P>
<DIV class="code">
-<PRE>%module Example
-%include "typemaps.i"
-
-%apply int *OUTPUT { int *result };
-%apply int *INPUT { int *x, int *y};
-
-void add(int x, int y, int *result);
-int sub(int *x, int *y);</PRE>
+<PRE>// Ignored argument.
+%typemap(in, numinputs=0) int *out (int temp) {
+ $1 = &temp;
+}</PRE>
</DIV>
-<P> If a function mutates one of its parameters like this,</P>
+<P> At this time, only zero or one arguments may be converted.</P>
+<H4><A name="Ruby_typecheck_typemap">38.7.6.2 "typecheck" typemap</A></H4>
+<P> The "typecheck" typemap is used to support overloaded functions and
+ methods. It merely checks an argument to see whether or not it matches
+ a specific type. For example:</P>
<DIV class="code">
-<PRE>void negate(int *x) {
- *x = -(*x);
+<PRE>%typemap(typecheck,precedence=SWIG_TYPECHECK_INTEGER) int {
+ $1 = FIXNUM_P($input) ? 1 : 0;
}</PRE>
</DIV>
-<P>you can use <TT>INOUT</TT> like this:</P>
+<P> For typechecking, the $1 variable is always a simple integer that is
+ set to 1 or 0 depending on whether or not the input argument is the
+ correct type.</P>
+<P> If you define new "in" typemaps<EM> and</EM> your program uses
+ overloaded methods, you should also define a collection of "typecheck"
+ typemaps. More details about this follow in a later section on
+ "Typemaps and Overloading."</P>
+<H4><A name="Ruby_out_typemap">38.7.6.3 "out" typemap</A></H4>
+<P>Converts return value of a C function to a Ruby object.</P>
<DIV class="code">
-<PRE>%include "typemaps.i"
-...
-void negate(int *INOUT);</PRE>
+<PRE>%typemap(out) int {
+ $result = INT2NUM( $1 );
+}
+</PRE>
</DIV>
-<P>In Ruby, a mutated parameter shows up as a return value. For example:</P>
-<DIV class="code targetlang">
-<PRE>a = Example.negate(3)
-print a
--3</PRE>
+<P> The following special variables are available.</P>
+<DIV class="diagram">
+<TABLE border="1" cellpadding="2" cellspacing="2" summary="Special variables - out typemap"
+width="100%"><TBODY></TBODY>
+<TR><TD>$result</TD><TD> Result object returned to target language.</TD></TR>
+<TR><TD>$symname</TD><TD> Name of function/method being wrapped</TD></TR>
+<TR><TD>$1...n</TD><TD> Argument being wrapped</TD></TR>
+<TR><TD>$1_name</TD><TD> Name of the argument (if provided)</TD></TR>
+<TR><TD>$1_type</TD><TD> The actual C datatype matched by the typemap.</TD>
+</TR>
+<TR><TD>$1_ltype</TD><TD> The assignable version of the C datatype
+ matched by the typemap.</TD></TR>
+</TABLE>
</DIV>
-<P> The most common use of these special typemap rules is to handle
- functions that return more than one value. For example, sometimes a
- function returns a result as well as a special error code:</P>
+<H4><A name="Ruby_arginit_typemap">38.7.6.4 "arginit" typemap</A></H4>
+<P> The "arginit" typemap is used to set the initial value of a function
+ argument--before any conversion has occurred. This is not normally
+ necessary, but might be useful in highly specialized applications. For
+ example:</P>
<DIV class="code">
-<PRE>/* send message, return number of bytes sent, success code, and error_code */
-int send_message(char *text, int *success, int *error_code);</PRE>
+<PRE>// Set argument to NULL before any conversion occurs
+%typemap(arginit) int *data {
+ $1 = NULL;
+}</PRE>
</DIV>
-<P> To wrap such a function, simply use the <TT>OUTPUT</TT> rule above.
- For example:</P>
+<H4><A name="Ruby_default_typemap">38.7.6.5 "default" typemap</A></H4>
+<P> The "default" typemap is used to turn an argument into a default
+ argument. For example:</P>
<DIV class="code">
-<PRE>%module example
-%include "typemaps.i"
+<PRE>%typemap(default) int flags {
+ $1 = DEFAULT_FLAGS;
+}
...
-int send_message(char *, int *OUTPUT, int *OUTPUT);</PRE>
+int foo(int x, int y, int flags);</PRE>
</DIV>
-<P> When used in Ruby, the function will return an array of multiple
- values.</P>
-<DIV class="code targetlang">
-<PRE>bytes, success, error_code = send_message("Hello World")
-if not success
- print "error #{error_code} : in send_message"
-else
- print "Sent", bytes
-end</PRE>
+<P> The primary use of this typemap is to either change the wrapping of
+ default arguments or specify a default argument in a language where
+ they aren't supported (like C). Target languages that do not support
+ optional arguments, such as Java and C#, effectively ignore the value
+ specified by this typemap as all arguments must be given.</P>
+<P> Once a default typemap has been applied to an argument, all
+ arguments that follow must have default values. See the <A href="#SWIG_default_args">
+ Default/optional arguments</A> section for further information on
+ default argument wrapping.</P>
+<H4><A name="Ruby_check_typemap">38.7.6.6 "check" typemap</A></H4>
+<P> The "check" typemap is used to supply value checking code during
+ argument conversion. The typemap is applied<EM> after</EM> arguments
+ have been converted. For example:</P>
+<DIV class="code">
+<PRE>%typemap(check) int positive {
+ if ($1 <= 0) {
+ SWIG_exception(SWIG_ValueError,"Expected positive value.");
+ }
+}</PRE>
</DIV>
-<P> Another way to access multiple return values is to use the <TT>
-%apply</TT> rule. In the following example, the parameters rows and
- columns are related to SWIG as <TT>OUTPUT</TT> values through the use
- of <TT>%apply</TT></P>
+<H4><A name="Ruby_argout_typemap_">38.7.6.7 "argout" typemap</A></H4>
+<P> The "argout" typemap is used to return values from arguments. This
+ is most commonly used to write wrappers for C/C++ functions that need
+ to return multiple values. The "argout" typemap is almost always
+ combined with an "in" typemap---possibly to ignore the input value. For
+ example:</P>
<DIV class="code">
-<PRE>%module Example
-%include "typemaps.i"
-%apply int *OUTPUT { int *rows, int *columns };
-...
-void get_dimensions(Matrix *m, int *rows, int*columns);</PRE>
+<PRE>/* Set the input argument to point to a temporary variable */
+%typemap(in, numinputs=0) int *out (int temp) {
+ $1 = &temp;
+}
+
+%typemap(argout, fragment="output_helper") int *out {
+ // Append output value $1 to $result (assuming a single integer in this case)
+ $result = output_helper( $result, INT2NUM(*$1) );
+}</PRE>
</DIV>
-<P>In Ruby:</P>
-<DIV class="code targetlang">
-<PRE>r, c = Example.get_dimensions(m)</PRE>
+<P> The following special variables are available.</P>
+<DIV class="diagram">
+<TABLE border="1" cellpadding="2" cellspacing="2" summary="Special variables - argout typemap"
+width="100%"><TBODY></TBODY>
+<TR><TD>$result</TD><TD> Result object returned to target language.</TD></TR>
+<TR><TD>$input</TD><TD> The original input object passed.</TD></TR>
+<TR><TD>$symname</TD><TD> Name of function/method being wrapped.</TD></TR>
+</TABLE>
</DIV>
-<H2><A name="Ruby_nn33"></A>36.6 Exception handling</H2>
-<H3><A name="Ruby_nn34"></A>36.6.1 Using the %exception directive</H3>
-<P>The SWIG <TT>%exception</TT> directive can be used to define a
- user-definable exception handler that can convert C/C++ errors into
- Ruby exceptions. The chapter on <A href="#Customization">Customization
- Features</A> contains more details, but suppose you have a C++ class
- like the following :</P>
+<P> The code supplied to the "argout" typemap is always placed after the
+ "out" typemap. If multiple return values are used, the extra return
+ values are often appended to return value of the function.</P>
+<P>Output helper is a fragment that usually defines a macro to some
+ function like SWIG_Ruby_AppendOutput.</P>
+<P> See the <TT>typemaps.i</TT> library for examples.</P>
+<H4><A name="Ruby_freearg_typemap_">38.7.6.8 "freearg" typemap</A></H4>
+<P> The "freearg" typemap is used to cleanup argument data. It is only
+ used when an argument might have allocated resources that need to be
+ cleaned up when the wrapper function exits. The "freearg" typemap
+ usually cleans up argument resources allocated by the "in" typemap. For
+ example:</P>
<DIV class="code">
-<PRE>class DoubleArray {
-private:
- int n;
- double *ptr;
-public:
- // Create a new array of fixed size
- DoubleArray(int size) {
- ptr = new double[size];
- n = size;
- }
-
- // Destroy an array
- ~DoubleArray() {
- delete ptr;
- }
-
- // Return the length of the array
- int length() {
- return n;
- }
-
- // Get an array item and perform bounds checking.
- double getitem(int i) {
- if ((i >= 0) && (i < n))
- return ptr[i];
- else
- throw RangeError();
- }
-
- // Set an array item and perform bounds checking.
- void setitem(int i, double val) {
- if ((i >= 0) && (i < n))
- ptr[i] = val;
- else {
- throw RangeError();
- }
- }
-};</PRE>
+<PRE>// Get a list of integers
+%typemap(in) int *items {
+ int nitems = Length($input);
+ $1 = (int *) malloc(sizeof(int)*nitems);
+}
+// Free the list
+%typemap(freearg) int *items {
+ free($1);
+}</PRE>
</DIV>
-<P> Since several methods in this class can throw an exception for an
- out-of-bounds access, you might want to catch this in the Ruby
- extension by writing the following in an interface file:</P>
+<P> The "freearg" typemap inserted at the end of the wrapper function,
+ just before control is returned back to the target language. This code
+ is also placed into a special variable <TT>$cleanup</TT> that may be
+ used in other typemaps whenever a wrapper function needs to abort
+ prematurely.</P>
+<H4><A name="Ruby_newfree_typemap">38.7.6.9 "newfree" typemap</A></H4>
+<P> The "newfree" typemap is used in conjunction with the <TT>%newobject</TT>
+ directive and is used to deallocate memory used by the return result of
+ a function. For example:</P>
<DIV class="code">
-<PRE>%exception {
- try {
- $action
- }
- catch (const RangeError&) {
- static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
- rb_raise(cpperror, "Range error.");
- }
+<PRE>%typemap(newfree) string * {
+ delete $1;
}
+%typemap(out) string * {
+ $result = PyString_FromString($1->c_str());
+}
+...
-class DoubleArray {
- ...
-};</PRE>
+%newobject foo;
+...
+string *foo();</PRE>
</DIV>
-<P> The exception handling code is inserted directly into generated
- wrapper functions. When an exception handler is defined, errors can be
- caught and used to gracefully raise a Ruby exception instead of forcing
- the entire program to terminate with an uncaught error.</P>
-<P>As shown, the exception handling code will be added to every wrapper
- function. Because this is somewhat inefficient, you might consider
- refining the exception handler to only apply to specific methods like
- this:</P>
+<P> See <A href="#Customization_ownership">Object ownership and
+ %newobject</A> for further details.</P>
+<H4><A name="Ruby_memberin_typemap">38.7.6.10 "memberin" typemap</A></H4>
+<P> The "memberin" typemap is used to copy data from<EM> an already
+ converted input value</EM> into a structure member. It is typically
+ used to handle array members and other special cases. For example:</P>
<DIV class="code">
-<PRE>%exception getitem {
- try {
- $action
- } catch (const RangeError&) {
- static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
- rb_raise(cpperror, "Range error in getitem.");
- }
-}
-
-%exception setitem {
- try {
- $action
- } catch (const RangeError&) {
- static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
- rb_raise(cpperror, "Range error in setitem.");
- }
+<PRE>%typemap(memberin) int [4] {
+ memmove($1, $input, 4*sizeof(int));
}</PRE>
</DIV>
-<P> In this case, the exception handler is only attached to methods and
- functions named <TT>getitem</TT> and <TT>setitem</TT>.</P>
-<P>Since SWIG's exception handling is user-definable, you are not
- limited to C++ exception handling. See the chapter on <A href="#Customization">
-Customization Features</A> for more examples.</P>
-<H3><A name="Ruby_nn34_2"></A>36.6.2 Handling Ruby Blocks</H3>
-<P>One of the highlights of Ruby and most of its standard library is the
- use of blocks, which allow the easy creation of continuations and other
- niceties. Blocks in ruby are also often used to simplify the passing of
- many arguments to a class.</P>
-<P>In order to make your class constructor support blocks, you can take
- advantage of the %exception directive, which will get run after the C++
- class' constructor was called.</P>
-<P>For example, this yields the class over after its construction:</P>
+<P> It is rarely necessary to write "memberin" typemaps---SWIG already
+ provides a default implementation for arrays, strings, and other
+ objects.</P>
+<H4><A name="Ruby_varin_typemap">38.7.6.11 "varin" typemap</A></H4>
+<P> The "varin" typemap is used to convert objects in the target
+ language to C for the purposes of assigning to a C/C++ global variable.
+ This is implementation specific.</P>
+<H4><A name="Ruby_varout_typemap_">38.7.6.12 "varout" typemap</A></H4>
+<P> The "varout" typemap is used to convert a C/C++ object to an object
+ in the target language when reading a C/C++ global variable. This is
+ implementation specific.</P>
+<H4><A name="Ruby_throws_typemap">38.7.6.13 "throws" typemap</A></H4>
+<P> The "throws" typemap is only used when SWIG parses a C++ method with
+ an exception specification or has the <TT>%catches</TT> feature
+ attached to the method. It provides a default mechanism for handling
+ C++ methods that have declared the exceptions they will throw. The
+ purpose of this typemap is to convert a C++ exception into an error or
+ exception in the target language. It is slightly different to the other
+ typemaps as it is based around the exception type rather than the type
+ of a parameter or variable. For example:</P>
<DIV class="code">
-<PRE>class Window
-{
-public:
- Window(int x, int y, int w, int h);
- // .... other methods here ....
-};
-
-// Add support for yielding self in the Class' constructor.
-%exception Window::Window {
- $action
- if (rb_block_given_p()) {
- rb_yield(self);
- }
-}</PRE>
+<PRE>%typemap(throws) const char * %{
+ rb_raise(rb_eRuntimeError, $1);
+ SWIG_fail;
+%}
+void bar() throw (const char *);</PRE>
</DIV>
-<P> Then, in ruby, it can be used like:</P>
-<DIV class="targetlang">
-<PRE>
-Window.new(0,0,360,480) { |w|
- w.color = Fltk::RED
- w.border = false
+<P> As can be seen from the generated code below, SWIG generates an
+ exception handler with the catch block comprising the "throws" typemap
+ content.</P>
+<DIV class="code">
+<PRE>...
+try {
+ bar();
}
-</PRE>
+catch(char const *_e) {
+ rb_raise(rb_eRuntimeError, _e);
+ SWIG_fail;
+}
+...</PRE>
</DIV>
-<P>For other methods, you can usually use a dummy parameter with a
- special in typemap, like:</P>
+<P> Note that if your methods do not have an exception specification yet
+ they do throw exceptions, SWIG cannot know how to deal with them. For a
+ neat way to handle these, see the <A href="#Customization_exception">
+Exception handling with %exception</A> section.</P>
+<H4><A name="Ruby_directorin_typemap">38.7.6.14 directorin typemap</A></H4>
+<P>Converts C++ objects in director member functions to ruby objects. It
+ is roughly the opposite of the "in" typemap, making its typemap rule
+ often similar to the "out" typemap.</P>
<DIV class="code">
<PRE>
-//
-// original function was:
-//
-// void func(int x);
-
-%typemap(in,numinputs=0) int RUBY_YIELD_SELF {
- if ( !rb_block_given_p() )
- rb_raise("No block given");
- return rb_yield(self);
-}
-
-%extend {
- void func(int x, int RUBY_YIELD_SELF );
+%typemap(directorin) int {
+ $result = INT2NUM($1);
}
</PRE>
</DIV>
-<P>For more information on typemaps, see <A href="#Ruby_nn37">Typemaps</A>
-.</P>
-<H3><A name="Ruby_nn35"></A>36.6.3 Raising exceptions</H3>
-<P>There are three ways to raise exceptions from C++ code to Ruby.</P>
-<P>The first way is to use <TT>SWIG_exception(int code, const char *msg)</TT>
-. The following table shows the mappings from SWIG error codes to Ruby
- exceptions:</P>
+<P> The following special variables are available.</P>
<DIV class="diagram">
-<TABLE border="1" class="diagram" summary="Mapping between SWIG error codes and Ruby exceptions."
-width="80%"><TBODY></TBODY>
-<TR><TD class="diagram"><DIV>SWIG_MemoryError</DIV></TD><TD><DIV>
-rb_eNoMemError</DIV></TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_IOError</DIV></TD><TD><DIV>rb_eIOError</DIV>
-</TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_RuntimeError</DIV></TD><TD><DIV>
-rb_eRuntimeError</DIV></TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_IndexError</DIV></TD><TD><DIV>
-rb_eIndexError</DIV></TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_TypeError</DIV></TD><TD><DIV>
-rb_eTypeError</DIV></TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_DivisionByZero</DIV></TD><TD><DIV>
-rb_eZeroDivError</DIV></TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_OverflowError</DIV></TD><TD><DIV>
-rb_eRangeError</DIV></TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_SyntaxError</DIV></TD><TD><DIV>
-rb_eSyntaxError</DIV></TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_ValueError</DIV></TD><TD><DIV>
-rb_eArgError</DIV></TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_SystemError</DIV></TD><TD><DIV>
-rb_eFatal</DIV></TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_AttributeError</DIV></TD><TD><DIV>
-rb_eRuntimeError</DIV></TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_NullReferenceError</DIV></TD><TD><DIV>
-rb_eNullReferenceError*</DIV></TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_ObjectPreviouslyDeletedError</DIV></TD><TD>
-<DIV>rb_eObjectPreviouslyDeleted*</DIV></TD></TR>
-<TR><TD class="diagram"><DIV>SWIG_UnknownError</DIV></TD><TD><DIV>
-rb_eRuntimeError</DIV></TD></TR>
-<TR class="diagram"><TD colspan="2"><DIV>* These error classes are
- created by SWIG and are not built-in Ruby exception classes</DIV></TD></TR>
+<TABLE border="1" cellpadding="2" cellspacing="2" summary="Special variables - directorin typemap"
+width="100%"><TBODY></TBODY>
+<TR><TD>$result</TD><TD> Result object returned to target language.</TD></TR>
+<TR><TD>$symname</TD><TD> Name of function/method being wrapped</TD></TR>
+<TR><TD>$1...n</TD><TD> Argument being wrapped</TD></TR>
+<TR><TD>$1_name</TD><TD> Name of the argument (if provided)</TD></TR>
+<TR><TD>$1_type</TD><TD> The actual C datatype matched by the typemap.</TD>
+</TR>
+<TR><TD>$1_ltype</TD><TD> The assignable version of the C datatype
+ matched by the typemap.</TD></TR>
+<TR><TD>this</TD><TD> C++ this, referring to the class itself.</TD></TR>
</TABLE>
</DIV>
-<P>The second way to raise errors is to use <TT>SWIG_Raise(obj, type,
- desc)</TT>. Obj is a C++ instance of an exception class, type is a
- string specifying the type of exception (for example, "MyError") and
- desc is the SWIG description of the exception class. For example:</P>
+<H4><A name="Ruby_directorout_typemap">38.7.6.15 directorout typemap</A></H4>
+<P>Converts Ruby objects in director member functions to C++ objects. It
+ is roughly the opposite of the "out" typemap, making its rule often
+ similar to the "in" typemap.</P>
<DIV class="code">
<PRE>
-%raise(SWIG_NewPointerObj(e, SWIGTYPE_p_AssertionFailedException, 0), ":AssertionFailedException", SWIGTYPE_p_AssertionFailedException);
+%typemap(directorout) int {
+ $result = NUM2INT($1);
+}
</PRE>
</DIV>
-<P>This is useful when you want to pass the current exception object
- directly to Ruby, particularly when the object is an instance of class
- marked as an <TT>%exceptionclass</TT> (see the next section for more
- information).</P>
-<P>Last, you can raise an exception by directly calling Ruby's C api.
- This is done by invoking the <TT>rb_raise()</TT> function. The first
- argument passed to <TT>rb_raise()</TT> is the exception type. You can
- raise a custom exception type or one of the built-in Ruby exception
- types.</P>
-<H3><A name="Ruby_nn36"></A>36.6.4 Exception classes</H3>
-<P>Starting with SWIG 1.3.28, the Ruby module supports the <TT>
-%exceptionclass</TT> directive, which is used to identify C++ classes
- that are used as exceptions. Classes that are marked with the <TT>
-%exceptionclass</TT> directive are exposed in Ruby as child classes of <TT>
-rb_eRuntimeError</TT>. This allows C++ exceptions to be directly mapped
- to Ruby exceptions, providing for a more natural integration between
- C++ code and Ruby code.</P>
-<DIV class="code">
-<PRE>%exceptionclass CustomError;
-
-%inline %{
- class CustomError { };
-
- class Foo {
- public:
- void test() { throw CustomError; }
- };
-%}</PRE>
+<P> The following special variables are available:</P>
+<DIV class="diagram">
+<TABLE border="1" cellpadding="2" cellspacing="2" summary="Special variables - directorout typemap"
+width="100%"><TBODY></TBODY>
+<TR><TD>$input</TD><TD>Ruby object being sent to the function</TD></TR>
+<TR><TD>$symname</TD><TD>Name of function/method being wrapped</TD></TR>
+<TR><TD>$1...n</TD><TD>Argument being sent to the function</TD></TR>
+<TR><TD>$1_name</TD><TD> Name of the argument (if provided)</TD></TR>
+<TR><TD>$1_type</TD><TD> The actual C datatype matched by the typemap.</TD>
+</TR>
+<TR><TD>$1_ltype</TD><TD> The assignable version of the C datatype
+ matched by the typemap.</TD></TR>
+<TR><TD>this</TD><TD> C++ this, referring to the class itself.</TD></TR>
+</TABLE>
</DIV>
-<P>From Ruby you can now call this method like this:</P>
-<DIV class="code targetlang">
-<PRE>foo = Foo.new
-begin
- foo.test()
-rescue CustomError => e
- puts "Caught custom error"
-end </PRE>
+<P>Currently, the directorout nor the out typemap support the option <TT>
+numoutputs</TT>, but the Ruby module provides that functionality through
+ a %feature directive. Thus, a function can be made to return "nothing"
+ if you do:</P>
+<DIV class="code">
+<PRE>
+%feature("numoutputs","0") MyClass::function;
+</PRE>
</DIV>
-<P>For another example look at swig/Examples/ruby/exception_class.</P>
-<H2><A name="Ruby_nn37"></A>36.7 Typemaps</H2>
-<P> This section describes how you can modify SWIG's default wrapping
- behavior for various C/C++ datatypes using the <TT>%typemap</TT>
- directive. This is an advanced topic that assumes familiarity with the
- Ruby C API as well as the material in the "<A href="#Typemaps">Typemaps</A>
-" chapter.</P>
-<P>Before proceeding, it should be stressed that typemaps are not a
- required part of using SWIG---the default wrapping behavior is enough
- in most cases. Typemaps are only used if you want to change some aspect
- of the primitive C-Ruby interface.</P>
-<H3><A name="Ruby_nn38"></A>36.7.1 What is a typemap?</H3>
-<P> A typemap is nothing more than a code generation rule that is
- attached to a specific C datatype. The general form of this declaration
- is as follows ( parts enclosed in [...] are optional ):</P>
+<P>This feature can be useful if a function returns a status code, which
+ you want to discard but still use the typemap to raise an exception.</P>
+<H4><A name="Ruby_directorargout_typemap">38.7.6.16 directorargout
+ typemap</A></H4>
+<P>Output argument processing in director member functions.</P>
<DIV class="code">
<PRE>
-%typemap( method [, modifiers...] ) typelist code;
+%typemap(directorargout,
+fragment="output_helper") int {
+ $result = output_helper( $result, NUM2INT($1) );
+}
</PRE>
</DIV>
-<P><EM> method</EM> is a simply a name that specifies what kind of
- typemap is being defined. It is usually a name like <TT>"in"</TT>, <TT>
-"out"</TT>, or <TT>"argout"</TT> (or its director variations). The
- purpose of these methods is described later.</P>
-<P><EM> modifiers</EM> is an optional comma separated list of <TT>
-name="value"</TT> values. These are sometimes to attach extra
- information to a typemap and is often target-language dependent.</P>
-<P><EM> typelist</EM> is a list of the C++ type patterns that the
- typemap will match. The general form of this list is as follows:</P>
+<P> The following special variables are available:</P>
<DIV class="diagram">
-<PRE>typelist : typepattern [, typepattern, typepattern, ... ] ;
-
-typepattern : type [ (parms) ]
- | type name [ (parms) ]
- | ( typelist ) [ (parms) ]</PRE>
+<TABLE border="1" cellpadding="2" cellspacing="2" style="text-align: left; width: 100%;"
+summary="Special variables - directorargout typemap"><TBODY></TBODY>
+<TR><TD>$result</TD><TD>Result that the director function returns</TD></TR>
+<TR><TD>$input</TD><TD>Ruby object being sent to the function</TD></TR>
+<TR><TD>$symname</TD><TD>name of the function/method being wrapped</TD></TR>
+<TR><TD>$1...n</TD><TD>Argument being sent to the function</TD></TR>
+<TR><TD>$1_name</TD><TD>Name of the argument (if provided)</TD></TR>
+<TR><TD>$1_type</TD><TD>The actual C datatype matched by the typemap</TD>
+</TR>
+<TR><TD>$1_ltype</TD><TD>The assignable version of the C datatype
+ matched by the typemap</TD></TR>
+<TR><TD>this</TD><TD>C++ this, referring to the instance of the class
+ itself</TD></TR>
+</TABLE>
</DIV>
-<P> Each type pattern is either a simple type, a simple type and
- argument name, or a list of types in the case of multi-argument
- typemaps. In addition, each type pattern can be parameterized with a
- list of temporary variables (parms). The purpose of these variables
- will be explained shortly.</P>
-<P><EM>code</EM> specifies the C code used in the typemap. It can take
- any one of the following forms:</P>
+<H4><A name="Ruby_ret_typemap">38.7.6.17 ret typemap</A></H4>
+<P>Cleanup of function return values</P>
+<H4><A name="Ruby_globalin_typemap">38.7.6.18 globalin typemap</A></H4>
+<P>Setting of C global variables</P>
+<H3><A name="Ruby_nn40">38.7.7 Typemap variables</A></H3>
+<P> Within a typemap, a number of special variables prefaced with a <TT>
+$</TT> may appear. A full list of variables can be found in the "<A href="#Typemaps">
+Typemaps</A>" chapter. This is a list of the most common variables:</P>
+<P><TT>$1</TT></P>
+<DIV class="indent">A C local variable corresponding to the actual type
+ specified in the <TT>%typemap</TT> directive. For input values, this is
+ a C local variable that is supposed to hold an argument value. For
+ output values, this is the raw result that is supposed to be returned
+ to Ruby.</DIV>
+<P><TT>$input</TT></P>
+<DIV class="indent">A <TT>VALUE</TT> holding a raw Ruby object with an
+ argument or variable value.</DIV>
+<P><TT>$result</TT></P>
+<DIV class="indent">A <TT>VALUE</TT> that holds the result to be
+ returned to Ruby.</DIV>
+<P><TT>$1_name</TT></P>
+<DIV class="indent">The parameter name that was matched.</DIV>
+<P><TT>$1_type</TT></P>
+<DIV class="indent">The actual C datatype matched by the typemap.</DIV>
+<P><TT>$1_ltype</TT></P>
+<DIV class="indent">An assignable version of the datatype matched by the
+ typemap (a type that can appear on the left-hand-side of a C assignment
+ operation). This type is stripped of qualifiers and may be an altered
+ version of <TT>$1_type</TT>. All arguments and local variables in
+ wrapper functions are declared using this type so that their values can
+ be properly assigned.</DIV>
+<P><TT>$symname</TT></P>
+<DIV class="indent">The Ruby name of the wrapper function being created.</DIV>
+<H3><A name="Ruby_nn41">38.7.8 Useful Functions</A></H3>
+<P> When you write a typemap, you usually have to work directly with
+ Ruby objects. The following functions may prove to be useful. (These
+ functions plus many more can be found in<EM> Programming Ruby</EM>
+ book, by David Thomas and Andrew Hunt.)</P>
+<P>In addition, we list equivalent functions that SWIG defines, which
+ provide a language neutral conversion (these functions are defined for
+ each swig language supported). If you are trying to create a swig file
+ that will work under multiple languages, it is recommended you stick to
+ the swig functions instead of the native Ruby functions. That should
+ help you avoid having to rewrite a lot of typemaps across multiple
+ languages.</P>
+<H4><A name="Ruby_nn42">38.7.8.1 C Datatypes to Ruby Objects</A></H4>
<DIV class="diagram">
-<PRE>code : { ... }
- | " ... "
- | %{ ... %}</PRE>
+<TABLE border="1" cellpadding="2" cellspacing="2" style="width: 100%;" summary="Datatypes">
+<TBODY></TBODY>
+<TR><TH><B>RUBY</B></TH><TH><B>SWIG</B></TH><TD></TD></TR>
+<TR><TD>INT2NUM(long or int)</TD><TD>SWIG_From_int(int x)</TD><TD> int
+ to Fixnum or Bignum</TD></TR>
+<TR><TD>INT2FIX(long or int)</TD><TD></TD><TD> int to Fixnum (faster
+ than INT2NUM)</TD></TR>
+<TR><TD>CHR2FIX(char)</TD><TD>SWIG_From_char(char x)</TD><TD> char to
+ Fixnum</TD></TR>
+<TR><TD>rb_str_new2(char*)</TD><TD>SWIG_FromCharPtrAndSize(char*,
+ size_t)</TD><TD> char* to String</TD></TR>
+<TR><TD>rb_float_new(double)</TD><TD>SWIG_From_double(double),
+<BR> SWIG_From_float(float)</TD><TD>float/double to Float</TD></TR>
+</TABLE>
</DIV>
-<P>For example, to convert integers from Ruby to C, you might define a
- typemap like this:</P>
+<H4><A name="Ruby_nn43">38.7.8.2 Ruby Objects to C Datatypes</A></H4>
+<P>Here, while the Ruby versions return the value directly, the SWIG
+ versions do not, but return a status value to indicate success (<TT>
+SWIG_OK</TT>). While more akward to use, this allows you to write
+ typemaps that report more helpful error messages, like:</P>
<DIV class="code">
-<PRE>%module example
-
-%typemap(in) int {
- $1 = (int) NUM2INT($input);
- printf("Received an integer : %d\n",$1);
+<PRE>
+%typemap(in) size_t (int ok)
+ ok = SWIG_AsVal_size_t($input, &$1);
+ if (!SWIG_IsOK(ok)) {
+ SWIG_exception_fail(SWIG_ArgError(ok), Ruby_Format_TypeError( "$1_name", "$1_type","$symname", $argnum, $input));
+ }
}
+</PRE>
+</DIV><DIV class="diagram">
+<TABLE border="1" cellpadding="2" cellspacing="2" summary="Ruby objects" width="100%">
+<TBODY></TBODY>
+<TR><TD>int NUM2INT(Numeric)</TD><TD>SWIG_AsVal_int(VALUE, int*)</TD></TR>
+<TR><TD>int FIX2INT(Numeric)</TD><TD>SWIG_AsVal_int(VALUE, int*)</TD></TR>
+<TR><TD>unsigned int NUM2UINT(Numeric)</TD><TD>
+SWIG_AsVal_unsigned_SS_int(VALUE, int*)</TD></TR>
+<TR><TD>unsigned int FIX2UINT(Numeric)</TD><TD>
+SWIG_AsVal_unsigned_SS_int(VALUE, int*)</TD></TR>
+<TR><TD>long NUM2LONG(Numeric)</TD><TD>SWIG_AsVal_long(VALUE, long*)</TD>
+</TR>
+<TR><TD>long FIX2LONG(Numeric)</TD><TD>SWIG_AsVal_long(VALUE, long*)</TD>
+</TR>
+<TR><TD>unsigned long FIX2ULONG(Numeric)</TD><TD>
+SWIG_AsVal_unsigned_SS_long(VALUE, unsigned long*)</TD></TR>
+<TR><TD>char NUM2CHR(Numeric or String)</TD><TD>SWIG_AsVal_char(VALUE,
+ int*)</TD></TR>
+<TR><TD>char * StringValuePtr(String)</TD><TD>
+SWIG_AsCharPtrAndSize(VALUE, char*, size_t, int* alloc)</TD></TR>
+<TR><TD>char * rb_str2cstr(String, int*length)</TD><TD></TD></TR>
+<TR><TD>double NUM2DBL(Numeric)</TD><TD>(double) SWIG_AsVal_int(VALUE)
+ or similar</TD></TR>
+</TABLE>
+</DIV>
+<H4><A name="Ruby_nn44">38.7.8.3 Macros for VALUE</A></H4>
+<P> <TT>RSTRING_LEN(str)</TT></P>
+<DIV class="indent">length of the Ruby string</DIV>
+<P><TT>RSTRING_PTR(str)</TT></P>
+<DIV class="indent">pointer to string storage</DIV>
+<P><TT>RARRAY_LEN(arr)</TT></P>
+<DIV class="indent">length of the Ruby array</DIV>
+<P><TT>RARRAY(arr)->capa</TT></P>
+<DIV class="indent">capacity of the Ruby array</DIV>
+<P><TT>RARRAY_PTR(arr)</TT></P>
+<DIV class="indent">pointer to array storage</DIV>
+<H4><A name="Ruby_nn45">38.7.8.4 Exceptions</A></H4>
+<P> <TT>void rb_raise(VALUE exception, const char *fmt, ...)</TT></P>
+<DIV class="indent"> Raises an exception. The given format string<I> fmt</I>
+ and remaining arguments are interpreted as with <TT>printf()</TT>.</DIV>
+<P><TT>void rb_fatal(const char *fmt, ...)</TT></P>
+<DIV class="indent"> Raises a fatal exception, terminating the process.
+ No rescue blocks are called, but ensure blocks will be called. The
+ given format string<I> fmt</I> and remaining arguments are interpreted
+ as with <TT>printf()</TT>.</DIV>
+<P><TT>void rb_bug(const char *fmt, ...)</TT></P>
+<DIV class="indent"> Terminates the process immediately -- no handlers
+ of any sort will be called. The given format string<I> fmt</I> and
+ remaining arguments are interpreted as with <TT>printf()</TT>. You
+ should call this function only if a fatal bug has been exposed.</DIV>
+<P><TT>void rb_sys_fail(const char *msg)</TT></P>
+<DIV class="indent"> Raises a platform-specific exception corresponding
+ to the last known system error, with the given string<I> msg</I>.</DIV>
+<P><TT>VALUE rb_rescue(VALUE (*body)(VALUE), VALUE args,
+ VALUE(*rescue)(VALUE, VALUE), VALUE rargs)</TT></P>
+<DIV class="indent"> Executes<I> body</I> with the given<I> args</I>. If
+ a <TT>StandardError</TT> exception is raised, then execute<I> rescue</I>
+ with the given<I> rargs</I>.</DIV>
+<P><TT>VALUE rb_ensure(VALUE(*body)(VALUE), VALUE args,
+ VALUE(*ensure)(VALUE), VALUE eargs)</TT></P>
+<DIV class="indent"> Executes<I> body</I> with the given<I> args</I>.
+ Whether or not an exception is raised, execute<I> ensure</I> with the
+ given<I> rargs</I> after<I> body</I> has completed.</DIV>
+<P><TT>VALUE rb_protect(VALUE (*body)(VALUE), VALUE args, int *result)</TT>
+</P>
+<DIV class="indent"> Executes<I> body</I> with the given<I> args</I> and
+ returns nonzero in result if any exception was raised.</DIV>
+<P><TT>void rb_notimplement()</TT></P>
+<DIV class="indent"> Raises a <TT>NotImpError</TT> exception to indicate
+ that the enclosed function is not implemented yet, or not available on
+ this platform.</DIV>
+<P><TT>void rb_exit(int status)</TT></P>
+<DIV class="indent"> Exits Ruby with the given<I> status</I>. Raises a <TT>
+SystemExit</TT> exception and calls registered exit functions and
+ finalizers.</DIV>
+<P><TT>void rb_warn(const char *fmt, ...)</TT></P>
+<DIV class="indent"> Unconditionally issues a warning message to
+ standard error. The given format string<I> fmt</I> and remaining
+ arguments are interpreted as with <TT>printf()</TT>.</DIV>
+<P><TT>void rb_warning(const char *fmt, ...)</TT></P>
+<DIV class="indent"> Conditionally issues a warning message to standard
+ error if Ruby was invoked with the <TT>-w</TT> flag. The given format
+ string<I> fmt</I> and remaining arguments are interpreted as with <TT>
+printf()</TT>.</DIV>
+<H4><A name="Ruby_nn46">38.7.8.5 Iterators</A></H4>
+<P> <TT>void rb_iter_break()</TT></P>
+<DIV class="indent"> Breaks out of the enclosing iterator block.</DIV>
+<P><TT>VALUE rb_each(VALUE obj)</TT></P>
+<DIV class="indent"> Invokes the <TT>each</TT> method of the given<I>
+ obj</I>.</DIV>
+<P><TT>VALUE rb_yield(VALUE arg)</TT></P>
+<DIV class="indent"> Transfers execution to the iterator block in the
+ current context, passing<I> arg</I> as an argument. Multiple values may
+ be passed in an array.</DIV>
+<P><TT>int rb_block_given_p()</TT></P>
+<DIV class="indent"> Returns <TT>true</TT> if <TT>yield</TT> would
+ execute a block in the current context; that is, if a code block was
+ passed to the current method and is available to be called.</DIV>
+<P><TT>VALUE rb_iterate(VALUE (*method)(VALUE), VALUE args, VALUE
+ (*block)(VALUE, VALUE), VALUE arg2)</TT></P>
+<DIV class="indent"> Invokes<I> method</I> with argument<I> args</I> and
+ block<I> block</I>. A <TT>yield</TT> from that method will invoke<I>
+ block</I> with the argument given to <TT>yield</TT>, and a second
+ argument<I> arg2</I>.</DIV>
+<P><TT>VALUE rb_catch(const char *tag, VALUE (*proc)(VALUE, VALUE),
+ VALUE value)</TT></P>
+<DIV class="indent"> Equivalent to Ruby's <TT>catch</TT>.</DIV>
+<P><TT>void rb_throw(const char *tag, VALUE value)</TT></P>
+<DIV class="indent"> Equivalent to Ruby's <TT>throw</TT>.</DIV>
+<H3><A name="Ruby_nn47">38.7.9 Typemap Examples</A></H3>
+<P> This section includes a few examples of typemaps. For more examples,
+ you might look at the examples in the <TT>Example/ruby</TT> directory.</P>
+<H3><A name="Ruby_nn48">38.7.10 Converting a Ruby array to a char **</A></H3>
+<P> A common problem in many C programs is the processing of command
+ line arguments, which are usually passed in an array of <TT>NULL</TT>
+ terminated strings. The following SWIG interface file allows a Ruby
+ Array instance to be used as a <TT>char **</TT> object.</P>
+<DIV class="code">
+<PRE>%module argv
-%inline %{
- extern int fact(int n);
-%}</PRE>
-</DIV>
-<P> Typemaps are always associated with some specific aspect of code
- generation. In this case, the "in" method refers to the conversion of
- input arguments to C/C++. The datatype <TT>int</TT> is the datatype to
- which the typemap will be applied. The supplied C code is used to
- convert values. In this code a number of special variables prefaced by
- a <TT>$</TT> are used. The <TT>$1</TT> variable is placeholder for a
- local variable of type <TT>int</TT>. The <TT>$input</TT> variable is
- the input Ruby object.</P>
-<P>When this example is compiled into a Ruby module, the following
- sample code:</P>
-<DIV class="code targetlang">
-<PRE>require 'example'
+// This tells SWIG to treat char ** as a special case
+%typemap(in) char ** {
+ /* Get the length of the array */
+ int size = RARRAY($input)->len;
+ int i;
+ $1 = (char **) malloc((size+1)*sizeof(char *));
+ /* Get the first element in memory */
+ VALUE *ptr = RARRAY($input)->ptr;
+ for (i=0; i < size; i++, ptr++) {
+ /* Convert Ruby Object String to char* */
+ $1[i]= StringValuePtr(*ptr);
+ }
+ $1[i]=NULL; /* End of list */
+}
-puts Example.fact(6)</PRE>
-</DIV>
-<P>prints the result:</P>
-<DIV class="code shell">
-<PRE>
-Received an integer : 6
-720
-</PRE>
-</DIV>
-<P> In this example, the typemap is applied to all occurrences of the <TT>
-int</TT> datatype. You can refine this by supplying an optional
- parameter name. For example:</P>
-<DIV class="code">
-<PRE>%module example
+// This cleans up the char ** array created before
+// the function call
-%typemap(in) int n {
- $1 = (int) NUM2INT($input);
- printf("n = %d\n",$1);
+%typemap(freearg) char ** {
+ free((char *) $1);
}
+// Now a test function
%inline %{
- extern int fact(int n);
+int print_args(char **argv) {
+ int i = 0;
+ while (argv[i]) {
+ printf("argv[%d] = %s\n", i,argv[i]);
+ i++;
+ }
+ return i;
+}
%}</PRE>
</DIV>
-<P> In this case, the typemap code is only attached to arguments that
- exactly match "<TT>int n</TT>".</P>
-<P>The application of a typemap to specific datatypes and argument names
- involves more than simple text-matching--typemaps are fully integrated
- into the SWIG type-system. When you define a typemap for <TT>int</TT>,
- that typemap applies to <TT>int</TT> and qualified variations such as <TT>
-const int</TT>. In addition, the typemap system follows <TT>typedef</TT>
- declarations. For example:</P>
-<DIV class="code">
-<PRE>%typemap(in) int n {
- $1 = (int) NUM2INT($input);
- printf("n = %d\n",$1);
-}
-
-typedef int Integer;
-extern int fact(Integer n); // Above typemap is applied</PRE>
+<P> When this module is compiled, the wrapped C function now operates as
+ follows :</P>
+<DIV class="code targetlang">
+<PRE>require 'Argv'
+Argv.print_args(["Dave","Mike","Mary","Jane","John"])
+argv[0] = Dave
+argv[1] = Mike
+argv[2] = Mary
+argv[3] = Jane
+argv[4] = John</PRE>
</DIV>
-<P> However, the matching of <TT>typedef</TT> only occurs in one
- direction. If you defined a typemap for <TT>Integer</TT>, it is not
- applied to arguments of type <TT>int</TT>.</P>
-<P>Typemaps can also be defined for groups of consecutive arguments. For
- example:</P>
+<P> In the example, two different typemaps are used. The "in" typemap is
+ used to receive an input argument and convert it to a C array. Since
+ dynamic memory allocation is used to allocate memory for the array, the
+ "freearg" typemap is used to later release this memory after the
+ execution of the C function.</P>
+<H3><A name="Ruby_nn49">38.7.11 Collecting arguments in a hash</A></H3>
+<P> Ruby's solution to the "keyword arguments" capability of some other
+ languages is to allow the programmer to pass in one or more key-value
+ pairs as arguments to a function. All of those key-value pairs are
+ collected in a single <TT>Hash</TT> argument that's presented to the
+ function. If it makes sense, you might want to provide similar
+ functionality for your Ruby interface. For example, suppose you'd like
+ to wrap this C function that collects information about people's vital
+ statistics:</P>
<DIV class="code">
-<PRE>%typemap(in) (char *str, int len) {
- $1 = StringValuePtr($input);
- $2 = (int) RSTRING($input)->len;
-};
-
-int count(char c, char *str, int len);</PRE>
+<PRE>void setVitalStats(const char *person, int nattributes, const char **names, int *values);</PRE>
</DIV>
-<P> When a multi-argument typemap is defined, the arguments are always
- handled as a single Ruby object. This allows the function <TT>count</TT>
- to be used as follows (notice how the length parameter is omitted):</P>
+<P> and you'd like to be able to call it from Ruby by passing in an
+ arbitrary number of key-value pairs as inputs, e.g.</P>
<DIV class="code targetlang">
-<PRE>puts Example.count('o','Hello World')
-2</PRE>
+<PRE>setVitalStats("Fred",
+ 'weight' => 270,
+ 'age' => 42
+)</PRE>
</DIV>
-<H3><A name="Ruby_Typemap_scope"></A>36.7.2 Typemap scope</H3>
-<P> Once defined, a typemap remains in effect for all of the
- declarations that follow. A typemap may be redefined for different
- sections of an input file. For example:</P>
+<P> To make this work, you need to write a typemap that expects a Ruby <TT>
+Hash</TT> as its input and somehow extracts the last three arguments (<I>
+nattributes</I>,<I> names</I> and<I> values</I>) needed by your C
+ function. Let's start with the basics:</P>
<DIV class="code">
-<PRE>// typemap1
-%typemap(in) int {
- ...
-}
-
-int fact(int); // typemap1
-int gcd(int x, int y); // typemap1
-
-// typemap2
-%typemap(in) int {
- ...
+<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
+ (VALUE keys_arr, int i, VALUE key, VALUE val) {
}
-
-int isprime(int); // typemap2</PRE>
+ </PRE>
</DIV>
-<P> One exception to the typemap scoping rules pertains to the <TT>
-%extend</TT> declaration. <TT>%extend</TT> is used to attach new
- declarations to a class or structure definition. Because of this, all
- of the declarations in an <TT>%extend</TT> block are subject to the
- typemap rules that are in effect at the point where the class itself is
- defined. For example:</P>
+<P> This <TT>%typemap</TT> directive tells SWIG that we want to match
+ any function declaration that has the specified types and names of
+ arguments somewhere in the argument list. The fact that we specified
+ the argument names (<I>nattributes</I>,<I> names</I> and<I> values</I>)
+ in our typemap is significant; this ensures that SWIG won't try to
+ apply this typemap to<I> other</I> functions it sees that happen to
+ have a similar declaration with different argument names. The arguments
+ that appear in the second set of parentheses (<I>keys_arr</I>,<I> i</I>
+,<I> key</I> and<I> val</I>) define local variables that our typemap
+ will need.</P>
+<P>Since we expect the input argument to be a <TT>Hash</TT>, let's next
+ add a check for that:</P>
<DIV class="code">
-<PRE>class Foo {
- ...
-};
-
-%typemap(in) int {
- ...
-}
-
-%extend Foo {
- int blah(int x); // typemap has no effect. Declaration is attached to Foo which
- // appears before the %typemap declaration.
-};</PRE>
+<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
+ (VALUE keys_arr, int i, VALUE key, VALUE val) {
+ <B>Check_Type($input, T_HASH);</B>
+}</PRE>
</DIV>
-<H3><A name="Ruby_Copying_a_typemap"></A>36.7.3 Copying a typemap</H3>
-<P> A typemap is copied by using assignment. For example:</P>
+<P> <TT>Check_Type()</TT> is just a macro (defined in the Ruby header
+ files) that confirms that the input argument is of the correct type; if
+ it isn't, an exception will be raised.</P>
+<P>The next task is to determine how many key-value pairs are present in
+ the hash; we'll assign this number to the first typemap argument (<TT>
+$1</TT>). This is a little tricky since the Ruby/C API doesn't provide a
+ public function for querying the size of a hash, but we can get around
+ that by calling the hash's<I> size</I> method directly and converting
+ its result to a C <TT>int</TT> value:</P>
<DIV class="code">
-<PRE>%typemap(in) Integer = int;</PRE>
+<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
+ (VALUE keys_arr, int i, VALUE key, VALUE val) {
+ Check_Type($input, T_HASH);
+ <B>$1 = NUM2INT(rb_funcall($input, rb_intern("size"), 0, NULL));</B>
+}</PRE>
</DIV>
-<P> or this:</P>
+<P> So now we know the number of attributes. Next we need to initialize
+ the second and third typemap arguments (i.e. the two C arrays) to <TT>
+NULL</TT> and set the stage for extracting the keys and values from the
+ hash:</P>
<DIV class="code">
-<PRE>%typemap(in) Integer, Number, int32_t = int;</PRE>
+<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
+ (VALUE keys_arr, int i, VALUE key, VALUE val) {
+ Check_Type($input, T_HASH);
+ $1 = NUM2INT(rb_funcall($input, rb_intern("size"), 0, NULL));
+ <B>$2 = NULL;
+ $3 = NULL;
+ if ($1 > 0) {
+ $2 = (char **) malloc($1*sizeof(char *));
+ $3 = (int *) malloc($1*sizeof(int));
+ }</B>
+}</PRE>
</DIV>
-<P> Types are often managed by a collection of different typemaps. For
- example:</P>
+<P> There are a number of ways we could extract the keys and values from
+ the input hash, but the simplest approach is to first call the hash's<I>
+ keys</I> method (which returns a Ruby array of the keys) and then start
+ looping over the elements in that array:</P>
<DIV class="code">
-<PRE>%typemap(in) int { ... }
-%typemap(out) int { ... }
-%typemap(varin) int { ... }
-%typemap(varout) int { ... }</PRE>
+<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
+ (VALUE keys_arr, int i, VALUE key, VALUE val) {
+ Check_Type($input, T_HASH);
+ $1 = NUM2INT(rb_funcall($input, rb_intern("size"), 0, NULL));
+ $2 = NULL;
+ $3 = NULL;
+ if ($1 > 0) {
+ $2 = (char **) malloc($1*sizeof(char *));
+ $3 = (int *) malloc($1*sizeof(int));
+ <B>keys_arr = rb_funcall($input, rb_intern("keys"), 0, NULL);
+ for (i = 0; i < $1; i++) {
+ }</B>
+ }
+}</PRE>
</DIV>
-<P> To copy all of these typemaps to a new type, use <TT>%apply</TT>.
- For example:</P>
+<P> Recall that<I> keys_arr</I> and<I> i</I> are local variables for
+ this typemap. For each element in the<I> keys_arr</I> array, we want to
+ get the key itself, as well as the value corresponding to that key in
+ the hash:</P>
<DIV class="code">
-<PRE>%apply int { Integer }; // Copy all int typemaps to Integer
-%apply int { Integer, Number }; // Copy all int typemaps to both Integer and Number</PRE>
+<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
+ (VALUE keys_arr, int i, VALUE key, VALUE val) {
+ Check_Type($input, T_HASH);
+ $1 = NUM2INT(rb_funcall($input, rb_intern("size"), 0, NULL));
+ $2 = NULL;
+ $3 = NULL;
+ if ($1 > 0) {
+ $2 = (char **) malloc($1*sizeof(char *));
+ $3 = (int *) malloc($1*sizeof(int));
+ keys_arr = rb_funcall($input, rb_intern("keys"), 0, NULL);
+ for (i = 0; i < $1; i++) {
+ <B>key = rb_ary_entry(keys_arr, i);
+ val = rb_hash_aref($input, key);</B>
+ }
+ }
+}</PRE>
</DIV>
-<P> The patterns for <TT>%apply</TT> follow the same rules as for <TT>
-%typemap</TT>. For example:</P>
+<P> To be safe, we should again use the <TT>Check_Type()</TT> macro to
+ confirm that the key is a <TT>String</TT> and the value is a <TT>Fixnum</TT>
+:</P>
<DIV class="code">
-<PRE>%apply int *output { Integer *output }; // Typemap with name
-%apply (char *buf, int len) { (char *buffer, int size) }; // Multiple arguments</PRE>
+<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
+ (VALUE keys_arr, int i, VALUE key, VALUE val) {
+ Check_Type($input, T_HASH);
+ $1 = NUM2INT(rb_funcall($input, rb_intern("size"), 0, NULL));
+ $2 = NULL;
+ $3 = NULL;
+ if ($1 > 0) {
+ $2 = (char **) malloc($1*sizeof(char *));
+ $3 = (int *) malloc($1*sizeof(int));
+ keys_arr = rb_funcall($input, rb_intern("keys"), 0, NULL);
+ for (i = 0; i < $1; i++) {
+ key = rb_ary_entry(keys_arr, i);
+ val = rb_hash_aref($input, key);
+ <B>Check_Type(key, T_STRING);
+ Check_Type(val, T_FIXNUM);</B>
+ }
+ }
+}</PRE>
</DIV>
-<H3><A name="Ruby_Deleting_a_typemap"></A>36.7.4 Deleting a typemap</H3>
-<P> A typemap can be deleted by simply defining no code. For example:</P>
+<P> Finally, we can convert these Ruby objects into their C equivalents
+ and store them in our local C arrays:</P>
<DIV class="code">
-<PRE>%typemap(in) int; // Clears typemap for int
-%typemap(in) int, long, short; // Clears typemap for int, long, short
-%typemap(in) int *output; </PRE>
+<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
+ (VALUE keys_arr, int i, VALUE key, VALUE val) {
+ Check_Type($input, T_HASH);
+ $1 = NUM2INT(rb_funcall($input, rb_intern("size"), 0, NULL));
+ $2 = NULL;
+ $3 = NULL;
+ if ($1 > 0) {
+ $2 = (char **) malloc($1*sizeof(char *));
+ $3 = (int *) malloc($1*sizeof(int));
+ keys_arr = rb_funcall($input, rb_intern("keys"), 0, NULL);
+ for (i = 0; i < $1; i++) {
+ key = rb_ary_entry(keys_arr, i);
+ val = rb_hash_aref($input, key);
+ Check_Type(key, T_STRING);
+ Check_Type(val, T_FIXNUM);
+ <B>$2[i] = StringValuePtr(key);
+ $3[i] = NUM2INT(val);</B>
+ }
+ }
+}</PRE>
</DIV>
-<P> The <TT>%clear</TT> directive clears all typemaps for a given type.
- For example:</P>
+<P> We're not done yet. Since we used <TT>malloc()</TT> to dynamically
+ allocate the memory used for the<I> names</I> and<I> values</I>
+ arguments, we need to provide a corresponding "freearg" typemap to free
+ that memory so that there is no memory leak. Fortunately, this typemap
+ is a lot easier to write:</P>
<DIV class="code">
-<PRE>%clear int; // Removes all types for int
-%clear int *output, long *output;</PRE>
+<PRE>%typemap(freearg) (int nattributes, const char **names, const int *values) {
+ free((void *) $2);
+ free((void *) $3);
+}</PRE>
</DIV>
-<P><B> Note:</B> Since SWIG's default behavior is defined by typemaps,
- clearing a fundamental type like <TT>int</TT> will make that type
- unusable unless you also define a new set of typemaps immediately after
- the clear operation.</P>
-<H3><A name="Ruby_Placement_of_typemaps"></A>36.7.5 Placement of
- typemaps</H3>
-<P> Typemap declarations can be declared in the global scope, within a
- C++ namespace, and within a C++ class. For example:</P>
+<P> All of the code for this example, as well as a sample Ruby program
+ that uses the extension, can be found in the <TT>Examples/ruby/hashargs</TT>
+ directory of the SWIG distribution.</P>
+<H3><A name="Ruby_nn50">38.7.12 Pointer handling</A></H3>
+<P> Occasionally, it might be necessary to convert pointer values that
+ have been stored using the SWIG typed-pointer representation. Since
+ there are several ways in which pointers can be represented, the
+ following two functions are used to safely perform this conversion:</P>
+<P><TT>int SWIG_ConvertPtr(VALUE obj, void **ptr, swig_type_info *ty,
+ int flags)</TT></P>
+<DIV class="indent">Converts a Ruby object<I> obj</I> to a C pointer
+ whose address is<I> ptr</I> (i.e.<I> ptr</I> is a pointer to a
+ pointer). The third argument,<I> ty</I>, is a pointer to a SWIG type
+ descriptor structure. If<I> ty</I> is not <TT>NULL</TT>, that type
+ information is used to validate type compatibility and other aspects of
+ the type conversion. If<I> flags</I> is non-zero, any type errors
+ encountered during this validation result in a Ruby <TT>TypeError</TT>
+ exception being raised; if<I> flags</I> is zero, such type errors will
+ cause <TT>SWIG_ConvertPtr()</TT> to return -1 but not raise an
+ exception. If<I> ty</I> is <TT>NULL</TT>, no type-checking is
+ performed.</DIV>
+<P> <TT>VALUE SWIG_NewPointerObj(void *ptr, swig_type_info *ty, int own)</TT>
+</P>
+<DIV class="indent">Creates a new Ruby pointer object. Here,<I> ptr</I>
+ is the pointer to convert,<I> ty</I> is the SWIG type descriptor
+ structure that describes the type, and<I> own</I> is a flag that
+ indicates whether or not Ruby should take ownership of the pointer
+ (i.e. whether Ruby should free this data when the corresponding Ruby
+ instance is garbage-collected).</DIV>
+<P> Both of these functions require the use of a special SWIG
+ type-descriptor structure. This structure contains information about
+ the mangled name of the datatype, type-equivalence information, as well
+ as information about converting pointer values under C++ inheritance.
+ For a type of <TT>Foo *</TT>, the type descriptor structure is usually
+ accessed as follows:</P>
+<DIV class="indent code">
+<PRE>Foo *foo;
+SWIG_ConvertPtr($input, (void **) &foo, SWIGTYPE_p_Foo, 1);
+
+VALUE obj;
+obj = SWIG_NewPointerObj(f, SWIGTYPE_p_Foo, 0);</PRE>
+</DIV>
+<P> In a typemap, the type descriptor should always be accessed using
+ the special typemap variable <TT>$1_descriptor</TT>. For example:</P>
+<DIV class="indent code">
+<PRE>%typemap(in) Foo * {
+ SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+}</PRE>
+</DIV>
+<H4><A name="Ruby_nn51">38.7.12.1 Ruby Datatype Wrapping</A></H4>
+<P> <TT>VALUE Data_Wrap_Struct(VALUE class, void (*mark)(void *), void
+ (*free)(void *), void *ptr)</TT></P>
+<DIV class="indent">Given a pointer<I> ptr</I> to some C data, and the
+ two garbage collection routines for this data (<I>mark</I> and<I> free</I>
+), return a <TT>VALUE</TT> for the Ruby object.</DIV>
+<P><TT>VALUE Data_Make_Struct(VALUE class,<I> c-type</I>, void
+ (*mark)(void *), void (*free)(void *),<I> c-type</I> *ptr)</TT></P>
+<DIV class="indent">Allocates a new instance of a C data type<I> c-type</I>
+, assigns it to the pointer<I> ptr</I>, then wraps that pointer with <TT>
+Data_Wrap_Struct()</TT> as above.</DIV>
+<P><TT>Data_Get_Struct(VALUE obj,<I> c-type</I>,<I> c-type</I> *ptr)</TT>
+</P>
+<DIV class="indent">Retrieves the original C pointer of type<I> c-type</I>
+ from the data object<I> obj</I> and assigns that pointer to<I> ptr</I>.</DIV>
+<H3><A name="Ruby_nn52">38.7.13 Example: STL Vector to Ruby Array</A></H3>
+<P>Another use for macros and type maps is to create a Ruby array from a
+ STL vector of pointers. In essence, copy of all the pointers in the
+ vector into a Ruby array. The use of the macro is to make the typemap
+ so generic that any vector with pointers can use the type map. The
+ following is an example of how to construct this type of macro/typemap
+ and should give insight into constructing similar typemaps for other
+ STL structures:</P>
<DIV class="code">
-<PRE>%typemap(in) int {
- ...
+<PRE>%define PTR_VECTOR_TO_RUBY_ARRAY(vectorclassname, classname)
+%typemap(out) vectorclassname &, const vectorclassname & {
+ VALUE arr = rb_ary_new2($1->size());
+ vectorclassname::iterator i = $1->begin(), iend = $1->end();
+ for ( ; i!=iend; i++ )
+ rb_ary_push(arr, Data_Wrap_Struct(c ## classname.klass, 0, 0, *i));
+ $result = arr;
}
-
-namespace std {
- class string;
- %typemap(in) string {
- ...
+%typemap(out) vectorclassname, const vectorclassname {
+ VALUE arr = rb_ary_new2($1.size());
+ vectorclassname::iterator i = $1.begin(), iend = $1.end();
+ for ( ; i!=iend; i++ )
+ rb_ary_push(arr, Data_Wrap_Struct(c ## classname.klass, 0, 0, *i));
+ $result = arr;
+}
+%enddef</PRE>
+</DIV>
+<P> Note, that the "<TT>c ## classname.klass"</TT> is used in the
+ preprocessor step to determine the actual object from the class name.</P>
+<P>To use the macro with a class Foo, the following is used:</P>
+<DIV class="code">
+<PRE>PTR_VECTOR_TO_RUBY_ARRAY(vector<foo *="">, Foo)</PRE>
+</DIV>
+<P> It is also possible to create a STL vector of Ruby objects:</P>
+<DIV class="code">
+<PRE>%define RUBY_ARRAY_TO_PTR_VECTOR(vectorclassname, classname)
+%typemap(in) vectorclassname &, const vectorclassname & {
+ Check_Type($input, T_ARRAY);
+ vectorclassname *vec = new vectorclassname;
+ int len = RARRAY($input)->len;
+ for (int i=0; i!=len; i++) {
+ VALUE inst = rb_ary_entry($input, i);
+ //The following _should_ work but doesn't on HPUX
+ // Check_Type(inst, T_DATA);
+ classname *element = NULL;
+ Data_Get_Struct(inst, classname, element);
+ vec->push_back(element);
}
+ $1 = vec;
}
-class Bar {
-public:
- typedef const int & const_reference;
- %typemap(out) const_reference {
- ...
- }
-};</PRE>
+%typemap(freearg) vectorclassname &, const vectorclassname & {
+ delete $1;
+}
+%enddef</PRE>
</DIV>
-<P> When a typemap appears inside a namespace or class, it stays in
- effect until the end of the SWIG input (just like before). However, the
- typemap takes the local scope into account. Therefore, this code</P>
+<P> It is also possible to create a Ruby array from a vector of static
+ data types:</P>
<DIV class="code">
-<PRE>namespace std {
- class string;
- %typemap(in) string {
- ...
- }
-}</PRE>
+<PRE>%define VECTOR_TO_RUBY_ARRAY(vectorclassname, classname)
+%typemap(out) vectorclassname &, const vectorclassname & {
+ VALUE arr = rb_ary_new2($1->size());
+ vectorclassname::iterator i = $1->begin(), iend = $1->end();
+ for ( ; i!=iend; i++ )
+ rb_ary_push(arr, Data_Wrap_Struct(c ## classname.klass, 0, 0, &(*i)));
+ $result = arr;
+}
+%typemap(out) vectorclassname, const vectorclassname {
+ VALUE arr = rb_ary_new2($1.size());
+ vectorclassname::iterator i = $1.begin(), iend = $1.end();
+ for ( ; i!=iend; i++ )
+ rb_ary_push(arr, Data_Wrap_Struct(c ## classname.klass, 0, 0, &(*i)));
+ $result = arr;
+}
+%enddef</PRE>
+</DIV> Note that this is mostly an example of typemaps. If you want to
+ use the STL with ruby, you are advised to use the standard swig STL
+ library, which does much more than this. Refer to the section called
+ the<A href="#Ruby_nn23_1"> C++ Standard Template Library</A>.
+<H2><A name="Ruby_nn65">38.8 Docstring Features</A></H2>
+<P> Using ri and rdoc web pages in Ruby libraries is a common practice.
+ Given the way that SWIG generates the extensions by default, your users
+ will normally not get any documentation for it, even if they run 'rdoc'
+ on the resulting .c or .cxx file.</P>
+<P>The features described in this section make it easy for you to add
+ rdoc strings to your modules, functions and methods that can then be
+ read by Ruby's rdoc tool to generate html web pages, ri documentation,
+ Windows chm file and an .xml description.</P>
+<P>rdoc can then be run from a console or shell window on a swig
+ generated file.</P>
+<P>For example, to generate html web pages from a C++ file, you'd do:</P>
+<DIV class="code shell">
+<PRE>
+$ rdoc -E cxx=c -f html file_wrap.cxx
+</PRE>
+</DIV>
+<P>To generate ri documentation from a c wrap file, you could do:</P>
+<DIV class="code shell">
+<PRE>
+$ rdoc -r file_wrap.c
+</PRE>
+</DIV>
+<H3><A name="Ruby_nn66">38.8.1 Module docstring</A></H3>
+<P> Ruby allows a docstring at the beginning of the file before any
+ other statements, and it is typically used to give a general
+ description of the entire module. SWIG supports this by setting an
+ option of the <TT>%module</TT> directive. For example:</P>
+<DIV class="code">
+<PRE>%module(docstring="This is the example module's docstring") example</PRE>
</DIV>
-<P> is really defining a typemap for the type <TT>std::string</TT>. You
- could have code like this:</P>
+<P> When you have more than just a line or so then you can retain the
+ easy readability of the <TT>%module</TT> directive by using a macro.
+ For example:</P>
<DIV class="code">
-<PRE>namespace std {
- class string;
- %typemap(in) string { /* std::string */
- ...
- }
-}
+<PRE>%define DOCSTRING
+"The `XmlResource` class allows program resources defining menus,
+layout of controls on a panel, etc. to be loaded from an XML file."
+%enddef
-namespace Foo {
- class string;
- %typemap(in) string { /* Foo::string */
- ...
- }
-}</PRE>
+%module(docstring=DOCSTRING) xrc</PRE>
</DIV>
-<P> In this case, there are two completely distinct typemaps that apply
- to two completely different types (<TT>std::string</TT> and <TT>
-Foo::string</TT>).</P>
-<P> It should be noted that for scoping to work, SWIG has to know that <TT>
-string</TT> is a typename defined within a particular namespace. In this
- example, this is done using the class declaration <TT>class string</TT>
- .</P>
-<H3><A name="Ruby_nn39"></A>36.7.6 Ruby typemaps</H3>
-<P>The following list details all of the typemap methods that can be
- used by the Ruby module:</P>
-<H4><A name="Ruby_in_typemap"></A>36.7.6.1 "in" typemap</H4>
-<P>Converts Ruby objects to input function arguments. For example:</P>
+<H3><A name="Ruby_nn67">38.8.2 %feature("autodoc")</A></H3>
+<P>Since SWIG does know everything about the function it wraps, it is
+ possible to generate an rdoc containing the parameter types, names and
+ default values. Since Ruby ships with one of the best documentation
+ systems of any language, it makes sense to take advantage of it.</P>
+<P>SWIG's Ruby module provides support for the "autodoc" feature, which
+ when attached to a node in the parse tree will cause an rdoc comment to
+ be generated in the wrapper file that includes the name of the
+ function, parameter names, default values if any, and return type if
+ any. There are also several options for autodoc controlled by the value
+ given to the feature, described below.</P>
+<H4><A name="Ruby_nn68">38.8.2.1 %feature("autodoc", "0")</A></H4>
+<P> When the "0" option is given then the types of the parameters will<EM>
+ not</EM> be included in the autodoc string. For example, given this
+ function prototype:</P>
<DIV class="code">
-<PRE>%typemap(in) int {
- $1 = NUM2INT($input);
-}</PRE>
+<PRE>%feature("autodoc", "0");
+bool function_name(int x, int y, Foo* foo=NULL, Bar* bar=NULL);</PRE>
</DIV>
-<P> The following special variables are available:</P>
-<DIV class="diagram">
-<TABLE border="1" cellpadding="2" cellspacing="2" summary="Special variables - in typemap"
-width="100%"><TBODY></TBODY>
-<TR><TD>$input</TD><TD> Input object holding value to be converted.</TD></TR>
-<TR><TD>$symname</TD><TD> Name of function/method being wrapped</TD></TR>
-<TR><TD>$1...n</TD><TD> Argument being sent to the function</TD></TR>
-<TR><TD>$1_name</TD><TD> Name of the argument (if provided)</TD></TR>
-<TR><TD>$1_type</TD><TD> The actual C datatype matched by the typemap.</TD>
-</TR>
-<TR><TD>$1_ltype</TD><TD> The assignable version of the C datatype
- matched by the typemap.</TD></TR>
-</TABLE>
+<P> Then Ruby code like this will be generated:</P>
+<DIV class="targetlang">
+<PRE>function_name(x, y, foo=nil, bar=nil) -> bool
+ ...</PRE>
</DIV>
-<P> This is probably the most commonly redefined typemap because it can
- be used to implement customized conversions.</P>
-<P> In addition, the "in" typemap allows the number of converted
- arguments to be specified. For example:</P>
-<DIV class="code">
-<PRE>// Ignored argument.
-%typemap(in, numinputs=0) int *out (int temp) {
- $1 = &temp;
-}</PRE>
+<H4><A name="Ruby_autodoc1">38.8.2.2 %feature("autodoc", "1")</A></H4>
+<P> When the "1" option is used then the parameter types<EM> will</EM>
+ be used in the rdoc string. In addition, an attempt is made to simplify
+ the type name such that it makes more sense to the Ruby user. Pointer,
+ reference and const info is removed, <TT>%rename</TT>'s are evaluated,
+ etc. (This is not always successful, but works most of the time. See
+ the next section for what to do when it doesn't.) Given the example
+ above, then turning on the parameter types with the "1" option will
+ result in rdoc code like this:</P>
+<DIV class="targetlang">
+<PRE>function_name(int x, int y, Foo foo=nil, Bar bar=nil) -> bool
+ ...</PRE>
</DIV>
-<P> At this time, only zero or one arguments may be converted.</P>
-<H4><A name="Ruby_typecheck_typemap"></A>36.7.6.2 "typecheck" typemap</H4>
-<P> The "typecheck" typemap is used to support overloaded functions and
- methods. It merely checks an argument to see whether or not it matches
- a specific type. For example:</P>
-<DIV class="code">
-<PRE>%typemap(typecheck,precedence=SWIG_TYPECHECK_INTEGER) int {
- $1 = FIXNUM_P($input) ? 1 : 0;
-}</PRE>
+<H4><A name="Ruby_autodoc2">38.8.2.3 %feature("autodoc", "2")</A></H4>
+<P> When the "2" option is used then the parameter types will not be
+ used in the rdoc string. However, they will be listed in full after the
+ function. Given the example above, then turning on the parameter types
+ with the "2" option will result in Ruby code like this:</P>
+<H4><A name="Ruby_feature_autodoc3">38.8.2.4 %feature("autodoc", "3")</A>
+</H4>
+<P> When the "3" option is used then the function will be documented
+ using a combination of "1" and "2" above. Given the example above, then
+ turning on the parameter types with the "2" option will result in Ruby
+ code like this:</P>
+<DIV class="targetlang">
+<PRE>function_name(int x, int y, Foo foo=nil, Bar bar=nil) -> bool
+
+Parameters:
+ x - int
+ y - int
+ foo - Foo
+ bar - Bar</PRE>
</DIV>
-<P> For typechecking, the $1 variable is always a simple integer that is
- set to 1 or 0 depending on whether or not the input argument is the
- correct type.</P>
-<P> If you define new "in" typemaps<EM> and</EM> your program uses
- overloaded methods, you should also define a collection of "typecheck"
- typemaps. More details about this follow in a later section on
- "Typemaps and Overloading."</P>
-<H4><A name="Ruby_out_typemap"></A>36.7.6.3 "out" typemap</H4>
-<P>Converts return value of a C function to a Ruby object.</P>
+<H4><A name="Ruby_nn70">38.8.2.5 %feature("autodoc", "docstring")</A></H4>
+<P> Finally, there are times when the automatically generated autodoc
+ string will make no sense for a Ruby programmer, particularly when a
+ typemap is involved. So if you give an explicit value for the autodoc
+ feature then that string will be used in place of the automatically
+ generated string. For example:</P>
<DIV class="code">
-<PRE>%typemap(out) int {
- $result = INT2NUM( $1 );
-}
-</PRE>
+<PRE>%feature("autodoc", "GetPosition() -> (x, y)") GetPosition;
+void GetPosition(int* OUTPUT, int* OUTPUT);</PRE>
</DIV>
-<P> The following special variables are available.</P>
-<DIV class="diagram">
-<TABLE border="1" cellpadding="2" cellspacing="2" summary="Special variables - out typemap"
-width="100%"><TBODY></TBODY>
-<TR><TD>$result</TD><TD> Result object returned to target language.</TD></TR>
-<TR><TD>$symname</TD><TD> Name of function/method being wrapped</TD></TR>
-<TR><TD>$1...n</TD><TD> Argument being wrapped</TD></TR>
-<TR><TD>$1_name</TD><TD> Name of the argument (if provided)</TD></TR>
-<TR><TD>$1_type</TD><TD> The actual C datatype matched by the typemap.</TD>
-</TR>
-<TR><TD>$1_ltype</TD><TD> The assignable version of the C datatype
- matched by the typemap.</TD></TR>
+<H3><A name="Ruby_nn71">38.8.3 %feature("docstring")</A></H3>
+<P> In addition to the autodoc strings described above, you can also
+ attach any arbitrary descriptive text to a node in the parse tree with
+ the "docstring" feature. When the proxy module is generated then any
+ docstring associated with classes, function or methods are output. If
+ an item already has an autodoc string then it is combined with the
+ docstring and they are output together.</P>
+<H2><A name="Ruby_nn53">38.9 Advanced Topics</A></H2>
+<H3><A name="Ruby_operator_overloading">38.9.1 Operator overloading</A></H3>
+<P> SWIG allows operator overloading with, by using the <TT>%extend</TT>
+ or <TT>%rename</TT> commands in SWIG and the following operator names
+ (derived from Python):</P>
+<DIV class="code diagram">
+<TABLE border="1" cellpadding="2" cellspacing="2" style="width: 100%; font-family: monospace;"
+summary="operator names"><TBODY></TBODY>
+<TR><TD><B> General</B></TD></TR>
+<TR><TD>__repr__</TD><TD> inspect</TD></TR>
+<TR><TD>__str__</TD><TD> to_s</TD></TR>
+<TR><TD>__cmp__</TD><TD> <=></TD></TR>
+<TR><TD>__hash__</TD><TD> hash</TD></TR>
+<TR><TD>__nonzero__</TD><TD> nonzero?</TD></TR>
+<TR><TD></TD></TR>
+<TR><TD><B> Callable</B></TD></TR>
+<TR><TD>__call__</TD><TD> call</TD></TR>
+<TR><TD></TD></TR>
+<TR><TD><B> Collection</B></TD></TR>
+<TR><TD>__len__</TD><TD> length</TD></TR>
+<TR><TD>__getitem__</TD><TD> []</TD></TR>
+<TR><TD>__setitem__</TD><TD> []=</TD></TR>
+<TR><TD></TD></TR>
+<TR><TD><B> Numeric</B></TD></TR>
+<TR><TD>__add__</TD><TD> +</TD></TR>
+<TR><TD>__sub__</TD><TD> -</TD><TD></TD></TR>
+<TR><TD>__mul__</TD><TD> *</TD></TR>
+<TR><TD>__div__</TD><TD> /</TD></TR>
+<TR><TD>__mod__</TD><TD> %</TD></TR>
+<TR><TD>__divmod__</TD><TD> divmod</TD></TR>
+<TR><TD>__pow__</TD><TD> **</TD></TR>
+<TR><TD>__lshift__</TD><TD> <<</TD></TR>
+<TR><TD>__rshift__</TD><TD> >></TD></TR>
+<TR><TD>__and__</TD><TD> &</TD></TR>
+<TR><TD>__xor__</TD><TD> ^</TD></TR>
+<TR><TD>__or__</TD><TD> |</TD></TR>
+<TR><TD>__neg__</TD><TD> -@</TD><TD></TD></TR>
+<TR><TD>__pos__</TD><TD> +@</TD></TR>
+<TR><TD>__abs__</TD><TD> abs</TD></TR>
+<TR><TD>__invert__</TD><TD> ~</TD></TR>
+<TR><TD>__int__</TD><TD> to_i</TD></TR>
+<TR><TD>__float__</TD><TD> to_f</TD></TR>
+<TR><TD>__coerce__</TD><TD> coerce</TD></TR>
+<TR><TD></TD></TR>
+<TR><TD><B>Additions in 1.3.13</B></TD></TR>
+<TR><TD>__lt__</TD><TD> <</TD></TR>
+<TR><TD>__le__</TD><TD> <=</TD></TR>
+<TR><TD>__eq__</TD><TD> ==</TD></TR>
+<TR><TD>__gt__</TD><TD> ></TD></TR>
+<TR><TD>__ge__</TD><TD> >=</TD></TR>
</TABLE>
</DIV>
-<H4><A name="Ruby_arginit_typemap"></A>36.7.6.4 "arginit" typemap</H4>
-<P> The "arginit" typemap is used to set the initial value of a function
- argument--before any conversion has occurred. This is not normally
- necessary, but might be useful in highly specialized applications. For
- example:</P>
+<P> Note that although SWIG supports the <TT>__eq__</TT> magic method
+ name for defining an equivalence operator, there is no separate method
+ for handling<I> inequality</I> since Ruby parses the expression<I> a !=
+ b</I> as<I> !(a == b)</I>.</P>
+<H3><A name="Ruby_nn55">38.9.2 Creating Multi-Module Packages</A></H3>
+<P> The chapter on <A href="#Modules">Working with Modules</A> discusses
+ the basics of creating multi-module extensions with SWIG, and in
+ particular the considerations for sharing runtime type information
+ among the different modules.</P>
+<P>As an example, consider one module's interface file (<TT>shape.i</TT>
+) that defines our base class:</P>
<DIV class="code">
-<PRE>// Set argument to NULL before any conversion occurs
-%typemap(arginit) int *data {
- $1 = NULL;
-}</PRE>
+<PRE>%module shape
+
+%{
+#include "Shape.h"
+%}
+
+class Shape {
+protected:
+ double xpos;
+ double ypos;
+protected:
+ Shape(double x, double y);
+public:
+ double getX() const;
+ double getY() const;
+};</PRE>
</DIV>
-<H4><A name="Ruby_default_typemap"></A>36.7.6.5 "default" typemap</H4>
-<P> The "default" typemap is used to turn an argument into a default
- argument. For example:</P>
+<P> We also have a separate interface file (<TT>circle.i</TT>) that
+ defines a derived class:</P>
<DIV class="code">
-<PRE>%typemap(default) int flags {
- $1 = DEFAULT_FLAGS;
-}
-...
-int foo(int x, int y, int flags);</PRE>
+<PRE>%module circle
+
+%{
+#include "Shape.h"
+#include "Circle.h"
+%}
+
+// Import the base class definition from Shape module
+%import shape.i
+
+class Circle : public Shape {
+protected:
+ double radius;
+public:
+ Circle(double x, double y, double r);
+ double getRadius() const;
+};</PRE>
</DIV>
-<P> The primary use of this typemap is to either change the wrapping of
- default arguments or specify a default argument in a language where
- they aren't supported (like C). Target languages that do not support
- optional arguments, such as Java and C#, effectively ignore the value
- specified by this typemap as all arguments must be given.</P>
-<P> Once a default typemap has been applied to an argument, all
- arguments that follow must have default values. See the <A href="http://www.swig.org/Doc1.3/SWIGDocumentation.html#SWIG_default_args">
- Default/optional arguments</A> section for further information on
- default argument wrapping.</P>
-<H4><A name="Ruby_check_typemap"></A>36.7.6.6 "check" typemap</H4>
-<P> The "check" typemap is used to supply value checking code during
- argument conversion. The typemap is applied<EM> after</EM> arguments
- have been converted. For example:</P>
-<DIV class="code">
-<PRE>%typemap(check) int positive {
- if ($1 <= 0) {
- SWIG_exception(SWIG_ValueError,"Expected positive value.");
- }
-}</PRE>
+<P> We'll start by building the<B> Shape</B> extension module:</P>
+<DIV class="code shell">
+<PRE>$ swig -c++ -ruby shape.i
+</PRE>
</DIV>
-<H4><A name="Ruby_argout_typemap_"></A>36.7.6.7 "argout" typemap</H4>
-<P> The "argout" typemap is used to return values from arguments. This
- is most commonly used to write wrappers for C/C++ functions that need
- to return multiple values. The "argout" typemap is almost always
- combined with an "in" typemap---possibly to ignore the input value. For
- example:</P>
-<DIV class="code">
-<PRE>/* Set the input argument to point to a temporary variable */
-%typemap(in, numinputs=0) int *out (int temp) {
- $1 = &temp;
-}
+<P> SWIG generates a wrapper file named <TT>shape_wrap.cxx</TT>. To
+ compile this into a dynamically loadable extension for Ruby, prepare an
+ <TT>extconf.rb</TT> script using this template:</P>
+<DIV class="code targetlang">
+<PRE>require 'mkmf'
-%typemap(argout, fragment="output_helper") int *out {
- // Append output value $1 to $result (assuming a single integer in this case)
- $result = output_helper( $result, INT2NUM(*$1) );
-}</PRE>
+# Since the SWIG runtime support library for Ruby
+# depends on the Ruby library, make sure it's in the list
+# of libraries.
+$libs = append_library($libs, Config::CONFIG['RUBY_INSTALL_NAME'])
+
+# Create the makefile
+create_makefile('shape')</PRE>
</DIV>
-<P> The following special variables are available.</P>
-<DIV class="diagram">
-<TABLE border="1" cellpadding="2" cellspacing="2" summary="Special variables - argout typemap"
-width="100%"><TBODY></TBODY>
-<TR><TD>$result</TD><TD> Result object returned to target language.</TD></TR>
-<TR><TD>$input</TD><TD> The original input object passed.</TD></TR>
-<TR><TD>$symname</TD><TD> Name of function/method being wrapped.</TD></TR>
-</TABLE>
+<P> Run this script to create a <TT>Makefile</TT> and then type <TT>make</TT>
+ to build the shared library:</P>
+<DIV class="code targetlang">
+<PRE>$ <B>ruby extconf.rb</B>
+creating Makefile
+$ <B>make</B>
+g++ -fPIC -g -O2 -I. -I/usr/include/ruby-2.1.0 \
+-I. -c shape_wrap.cxx
+gcc -shared -L/usr/local/lib -o shape.so shape_wrap.o -L. \
+-lruby -lruby -lc</PRE>
</DIV>
-<P> The code supplied to the "argout" typemap is always placed after the
- "out" typemap. If multiple return values are used, the extra return
- values are often appended to return value of the function.</P>
-<P>Output helper is a fragment that usually defines a macro to some
- function like SWIG_Ruby_AppendOutput.</P>
-<P> See the <TT>typemaps.i</TT> library for examples.</P>
-<H4><A name="Ruby_freearg_typemap_"></A>36.7.6.8 "freearg" typemap</H4>
-<P> The "freearg" typemap is used to cleanup argument data. It is only
- used when an argument might have allocated resources that need to be
- cleaned up when the wrapper function exits. The "freearg" typemap
- usually cleans up argument resources allocated by the "in" typemap. For
- example:</P>
-<DIV class="code">
-<PRE>// Get a list of integers
-%typemap(in) int *items {
- int nitems = Length($input);
- $1 = (int *) malloc(sizeof(int)*nitems);
-}
-// Free the list
-%typemap(freearg) int *items {
- free($1);
-}</PRE>
+<P> Note that depending on your installation, the outputs may be
+ slightly different; these outputs are those for a Linux-based
+ development environment. The end result should be a shared library
+ (here, <TT>shape.so</TT>) containing the extension module code. Now
+ repeat this process in a separate directory for the<B> Circle</B>
+ module:</P>
+<OL>
+<LI> Run SWIG to generate the wrapper code (<TT>circle_wrap.cxx</TT>);</LI>
+<LI> Write an <TT>extconf.rb</TT> script that your end-users can use to
+ create a platform-specific <TT>Makefile</TT> for the extension;</LI>
+<LI> Build the shared library for this extension by typing <TT>make</TT>
+.</LI>
+</OL>
+<P> Once you've built both of these extension modules, you can test them
+ interactively in IRB to confirm that the <TT>Shape</TT> and <TT>Circle</TT>
+ modules are properly loaded and initialized:</P>
+<DIV class="code targetlang">
+<PRE>$ <B>irb</B>
+irb(main):001:0> <B>require 'shape'</B>
+true
+irb(main):002:0> <B>require 'circle'</B>
+true
+irb(main):003:0> <B>c = Circle::Circle.new(5, 5, 20)</B>
+#<Circle::Circle:0xa097208>
+irb(main):004:0> <B>c.kind_of? Shape::Shape</B>
+true
+irb(main):005:0> <B>c.getX()</B>
+5.0</PRE>
</DIV>
-<P> The "freearg" typemap inserted at the end of the wrapper function,
- just before control is returned back to the target language. This code
- is also placed into a special variable <TT>$cleanup</TT> that may be
- used in other typemaps whenever a wrapper function needs to abort
- prematurely.</P>
-<H4><A name="Ruby_newfree_typemap"></A>36.7.6.9 "newfree" typemap</H4>
-<P> The "newfree" typemap is used in conjunction with the <TT>%newobject</TT>
- directive and is used to deallocate memory used by the return result of
- a function. For example:</P>
-<DIV class="code">
-<PRE>%typemap(newfree) string * {
- delete $1;
-}
-%typemap(out) string * {
- $result = PyString_FromString($1->c_str());
-}
-...
-
-%newobject foo;
-...
-string *foo();</PRE>
+<H3><A name="Ruby_nn56">38.9.3 Specifying Mixin Modules</A></H3>
+<P> The Ruby language doesn't support multiple inheritance, but it does
+ allow you to mix one or more modules into a class using Ruby's <TT>
+include</TT> method. For example, if you have a Ruby class that defines
+ an<EM> each</EM> instance method, e.g.</P>
+<DIV class="code targetlang">
+<PRE>class Set
+ def initialize
+ @members = []
+ end
+
+ def each
+ @members.each { |m| yield m }
+ end
+end</PRE>
</DIV>
-<P> See <A href="#Customization_ownership">Object ownership and
- %newobject</A> for further details.</P>
-<H4><A name="Ruby_memberin_typemap"></A>36.7.6.10 "memberin" typemap</H4>
-<P> The "memberin" typemap is used to copy data from<EM> an already
- converted input value</EM> into a structure member. It is typically
- used to handle array members and other special cases. For example:</P>
+<P> then you can mix-in Ruby's <TT>Enumerable</TT> module to easily add
+ a lot of functionality to your class:</P>
+<DIV class="code targetlang">
+<PRE>class Set
+ <B>include Enumerable</B>
+ def initialize
+ @members = []
+ end
+ def each
+ @members.each { |m| yield m }
+ end
+end</PRE>
+</DIV>
+<P> To get the same benefit for your SWIG-wrapped classes, you can use
+ the <TT>%mixin</TT> directive to specify the names of one or more
+ modules that should be mixed-in to a class. For the above example, the
+ SWIG interface specification might look like this:</P>
<DIV class="code">
-<PRE>%typemap(memberin) int [4] {
- memmove($1, $input, 4*sizeof(int));
-}</PRE>
+<PRE>%mixin Set "Enumerable";
+
+class Set {
+public:
+ // Constructor
+ Set();
+
+ // Iterates through set members
+ void each();
+};</PRE>
</DIV>
-<P> It is rarely necessary to write "memberin" typemaps---SWIG already
- provides a default implementation for arrays, strings, and other
- objects.</P>
-<H4><A name="Ruby_varin_typemap"></A>36.7.6.11 "varin" typemap</H4>
-<P> The "varin" typemap is used to convert objects in the target
- language to C for the purposes of assigning to a C/C++ global variable.
- This is implementation specific.</P>
-<H4><A name="Ruby_varout_typemap_"></A>36.7.6.12 "varout" typemap</H4>
-<P> The "varout" typemap is used to convert a C/C++ object to an object
- in the target language when reading a C/C++ global variable. This is
- implementation specific.</P>
-<H4><A name="Ruby_throws_typemap"></A>36.7.6.13 "throws" typemap</H4>
-<P> The "throws" typemap is only used when SWIG parses a C++ method with
- an exception specification or has the <TT>%catches</TT> feature
- attached to the method. It provides a default mechanism for handling
- C++ methods that have declared the exceptions they will throw. The
- purpose of this typemap is to convert a C++ exception into an error or
- exception in the target language. It is slightly different to the other
- typemaps as it is based around the exception type rather than the type
- of a parameter or variable. For example:</P>
+<P> Multiple modules can be mixed into a class by providing a
+ comma-separated list of module names to the <TT>%mixin</TT> directive,
+ e.g.</P>
<DIV class="code">
-<PRE>%typemap(throws) const char * %{
- rb_raise(rb_eRuntimeError, $1);
- SWIG_fail;
-%}
-void bar() throw (const char *);</PRE>
+<PRE>%mixin Set "Fee,Fi,Fo,Fum";</PRE>
</DIV>
-<P> As can be seen from the generated code below, SWIG generates an
- exception handler with the catch block comprising the "throws" typemap
- content.</P>
+<P> Note that the <TT>%mixin</TT> directive is implemented using SWIG's
+ "features" mechanism and so the same name matching rules used for other
+ kinds of features apply (see the chapter on <A href="#Customization">
+"Customization Features"</A>) for more details).</P>
+<H2><A name="Ruby_nn57">38.10 Memory Management</A></H2>
+<P>One of the most common issues in generating SWIG bindings for Ruby is
+ proper memory management. The key to proper memory management is
+ clearly defining whether a wrapper Ruby object owns the underlying C
+ struct or C++ class. There are two possibilities:</P>
+<UL>
+<LI> The Ruby object is responsible for freeing the C struct or C++
+ object</LI>
+<LI> The Ruby object should not free the C struct or C++ object because
+ it will be freed by the underlying C or C++ code</LI>
+</UL>
+<P>To complicate matters, object ownership may transfer from Ruby to C++
+ (or vice versa) depending on what function or methods are invoked.
+ Clearly, developing a SWIG wrapper requires a thorough understanding of
+ how the underlying library manages memory.</P>
+<H3><A name="Ruby_nn58">38.10.1 Mark and Sweep Garbage Collector</A></H3>
+<P>Ruby uses a mark and sweep garbage collector. When the garbage
+ collector runs, it finds all the "root" objects, including local
+ variables, global variables, global constants, hardware registers and
+ the C stack. For each root object, the garbage collector sets its mark
+ flag to true and calls <TT>rb_gc_mark</TT> on the object. The job of <TT>
+rb_gc_mark</TT> is to recursively mark all the objects that a Ruby
+ object has a reference to (ignoring those objects that have already
+ been marked). Those objects, in turn, may reference other objects. This
+ process will continue until all active objects have been "marked."
+ After the mark phase comes the sweep phase. In the sweep phase, all
+ objects that have not been marked will be garbage collected.</P>
+<P>The Ruby C/API provides extension developers two hooks into the
+ garbage collector - a "mark" function and a "sweep" function. By
+ default these functions are set to NULL.</P>
+<P>If a C struct or C++ class references any other Ruby objects, then it
+ must provide a "mark" function. The "mark" function should identify any
+ referenced Ruby objects by calling the rb_gc_mark function for each
+ one. Unsurprisingly, this function will be called by the Ruby garbage
+ during the "mark" phase.</P>
+<P>During the sweep phase, Ruby destroys any unused objects. If any
+ memory has been allocated in creating the underlying C struct or C++
+ struct, then a "free" function must be defined that deallocates this
+ memory.</P>
+<H3><A name="Ruby_nn59">38.10.2 Object Ownership</A></H3>
+<P>As described above, memory management depends on clearly defining who
+ is responsible for freeing the underlying C struct or C++ class. If the
+ Ruby object is responsible for freeing the C++ object, then a "free"
+ function must be registered for the object. If the Ruby object is not
+ responsible for freeing the underlying memory, then a "free" function
+ must not be registered for the object.</P>
+<P>For the most part, SWIG takes care of memory management issues. The
+ rules it uses are:</P>
+<UL>
+<LI> When calling a C++ object's constructor from Ruby, SWIG will assign
+ a "free" function thereby making the Ruby object responsible for
+ freeing the C++ object</LI>
+<LI> When calling a C++ member function that returns a pointer, SWIG
+ will not assign a "free" function thereby making the underlying library
+ responsible for freeing the object.</LI>
+</UL>
+<P>To make this clearer, let's look at an example. Assume we have a Foo
+ and a Bar class.</P>
<DIV class="code">
-<PRE>...
-try {
- bar();
-}
-catch(char const *_e) {
- rb_raise(rb_eRuntimeError, _e);
- SWIG_fail;
-}
-...</PRE>
+<PRE>/* File "RubyOwernshipExample.h" */
+
+class Foo
+{
+public:
+ Foo() {}
+ ~Foo() {}
+};
+
+class Bar
+{
+ Foo *foo_;
+public:
+ Bar(): foo_(new Foo) {}
+ ~Bar() { delete foo_; }
+ Foo* get_foo() { return foo_; }
+ Foo* get_new_foo() { return new Foo; }
+ void set_foo(Foo *foo) { delete foo_; foo_ = foo; }
+};</PRE>
</DIV>
-<P> Note that if your methods do not have an exception specification yet
- they do throw exceptions, SWIG cannot know how to deal with them. For a
- neat way to handle these, see the <A href="http://www.swig.org/Doc1.3/SWIGDocumentation.html#exception">
-Exception handling with %exception</A> section.</P>
-<H4><A name="Ruby_directorin_typemap"></A>36.7.6.14 directorin typemap</H4>
-<P>Converts C++ objects in director member functions to ruby objects. It
- is roughly the opposite of the "in" typemap, making its typemap rule
- often similar to the "out" typemap.</P>
-<DIV class="code">
-<PRE>
-%typemap(directorin) int {
- $result = INT2NUM($1);
-}
-</PRE>
+<P>First, consider this Ruby code:</P>
+<DIV class="code targetlang">
+<PRE>foo = Foo.new</PRE>
</DIV>
-<P> The following special variables are available.</P>
-<DIV class="diagram">
-<TABLE border="1" cellpadding="2" cellspacing="2" summary="Special variables - directorin typemap"
-width="100%"><TBODY></TBODY>
-<TR><TD>$result</TD><TD> Result object returned to target language.</TD></TR>
-<TR><TD>$symname</TD><TD> Name of function/method being wrapped</TD></TR>
-<TR><TD>$1...n</TD><TD> Argument being wrapped</TD></TR>
-<TR><TD>$1_name</TD><TD> Name of the argument (if provided)</TD></TR>
-<TR><TD>$1_type</TD><TD> The actual C datatype matched by the typemap.</TD>
-</TR>
-<TR><TD>$1_ltype</TD><TD> The assignable version of the C datatype
- matched by the typemap.</TD></TR>
-<TR><TD>this</TD><TD> C++ this, referring to the class itself.</TD></TR>
-</TABLE>
+<P>In this case, the Ruby code calls the underlying <TT>Foo</TT> C++
+ constructor, thus creating a new <TT>foo</TT> object. By default, SWIG
+ will assign the new Ruby object a "free" function. When the Ruby object
+ is garbage collected, the "free" function will be called. It in turn
+ will call <TT>Foo</TT>'s destructor.</P>
+<P>Next, consider this code:</P>
+<DIV class="code targetlang">
+<PRE>bar = Bar.new
+foo = bar.get_foo()</PRE>
</DIV>
-<H4><A name="Ruby_directorout_typemap"></A>36.7.6.15 directorout typemap</H4>
-<P>Converts Ruby objects in director member functions to C++ objects. It
- is roughly the opposite of the "out" typemap, making its rule often
- similar to the "in" typemap.</P>
-<DIV class="code">
-<PRE>
-%typemap(directorout) int {
- $result = NUM2INT($1);
-}
-</PRE>
+<P>In this case, the Ruby code calls a C++ member function, <TT>get_foo</TT>
+. By default, SWIG will not assign the Ruby object a "free" function.
+ Thus, when the Ruby object is garbage collected the underlying C++ <TT>
+foo</TT> object is not affected.</P>
+<P>Unfortunately, the real world is not as simple as the examples above.
+ For example:</P>
+<DIV class="code targetlang">
+<PRE>bar = Bar.new
+foo = bar.get_new_foo()</PRE>
</DIV>
-<P> The following special variables are available:</P>
-<DIV class="diagram">
-<TABLE border="1" cellpadding="2" cellspacing="2" summary="Special variables - directorout typemap"
-width="100%"><TBODY></TBODY>
-<TR><TD>$input</TD><TD>Ruby object being sent to the function</TD></TR>
-<TR><TD>$symname</TD><TD>Name of function/method being wrapped</TD></TR>
-<TR><TD>$1...n</TD><TD>Argument being sent to the function</TD></TR>
-<TR><TD>$1_name</TD><TD> Name of the argument (if provided)</TD></TR>
-<TR><TD>$1_type</TD><TD> The actual C datatype matched by the typemap.</TD>
-</TR>
-<TR><TD>$1_ltype</TD><TD> The assignable version of the C datatype
- matched by the typemap.</TD></TR>
-<TR><TD>this</TD><TD> C++ this, referring to the class itself.</TD></TR>
-</TABLE>
+<P>In this case, the default SWIG behavior for calling member functions
+ is incorrect. The Ruby object should assume ownership of the returned
+ object. This can be done by using the %newobject directive. See <A href="#Customization_ownership">
+ Object ownership and %newobject</A> for more information.</P>
+<P>The SWIG default mappings are also incorrect in this case:</P>
+<DIV class="code targetlang">
+<PRE>foo = Foo.new
+bar = Bar.new
+bar.set_foo(foo)</PRE>
</DIV>
-<P>Currently, the directorout nor the out typemap support the option <TT>
-numoutputs</TT>, but the Ruby module provides that functionality through
- a %feature directive. Thus, a function can be made to return "nothing"
- if you do:</P>
+<P>Without modification, this code will cause a segmentation fault. When
+ the Ruby <TT>foo</TT> object goes out of scope, it will free the
+ underlying C++ <TT>foo</TT> object. However, when the Ruby bar object
+ goes out of scope, it will call the C++ bar destructor which will also
+ free the C++ <TT>foo</TT> object. The problem is that object ownership
+ is transferred from the Ruby object to the C++ object when the <TT>
+set_foo</TT> method is called. This can be done by using the special
+ DISOWN type map, which was added to the Ruby bindings in SWIG-1.3.26.</P>
+<P>Thus, a correct SWIG interface file correct mapping for these classes
+ is:</P>
<DIV class="code">
-<PRE>
-%feature("numoutputs","0") MyClass::function;
+<PRE>/* File RubyOwnershipExample.i */
+
+%module RubyOwnershipExample
+
+%{
+#include "RubyOwnershipExample.h"
+%}
+
+class Foo
+{
+public:
+ Foo();
+ ~Foo();
+};
+
+class Bar
+{
+ Foo *foo_;
+public:
+ Bar();
+ ~Bar();
+ Foo* get_foo();
+
+<B> %newobject get_new_foo;</B>
+ Foo* get_new_foo();
+
+<B> %apply SWIGTYPE *DISOWN {Foo *foo};</B>
+ void set_foo(Foo *foo);
+<B> %clear Foo *foo;</B>
+};
</PRE>
</DIV>
-<P>This feature can be useful if a function returns a status code, which
- you want to discard but still use the typemap to raise an exception.</P>
-<H4><A name="Ruby_directorargout_typemap"></A>36.7.6.16 directorargout
- typemap</H4>
-<P>Output argument processing in director member functions.</P>
+<P> This code can be seen in swig/examples/ruby/tracking.</P>
+<H3><A name="Ruby_nn60">38.10.3 Object Tracking</A></H3>
+<P>The remaining parts of this section will use the class library shown
+ below to illustrate different memory management techniques. The class
+ library models a zoo and the animals it contains.</P>
<DIV class="code">
-<PRE>
-%typemap(directorargout,
-fragment="output_helper") int {
- $result = output_helper( $result, NUM2INT($1) );
-}
-</PRE>
-</DIV>
-<P> The following special variables are available:</P>
-<DIV class="diagram">
-<TABLE border="1" cellpadding="2" cellspacing="2" style="text-align: left; width: 100%;"
-summary="Special variables - directorargout typemap"><TBODY></TBODY>
-<TR><TD>$result</TD><TD>Result that the director function returns</TD></TR>
-<TR><TD>$input</TD><TD>Ruby object being sent to the function</TD></TR>
-<TR><TD>$symname</TD><TD>name of the function/method being wrapped</TD></TR>
-<TR><TD>$1...n</TD><TD>Argument being sent to the function</TD></TR>
-<TR><TD>$1_name</TD><TD>Name of the argument (if provided)</TD></TR>
-<TR><TD>$1_type</TD><TD>The actual C datatype matched by the typemap</TD>
-</TR>
-<TR><TD>$1_ltype</TD><TD>The assignable version of the C datatype
- matched by the typemap</TD></TR>
-<TR><TD>this</TD><TD>C++ this, referring to the instance of the class
- itself</TD></TR>
-</TABLE>
+<PRE>%module zoo
+
+%{
+#include <string>
+#include <vector>
+
+#include "zoo.h"
+%}
+
+class Animal
+{
+private:
+ typedef std::vector<Animal*> AnimalsType;
+ typedef AnimalsType::iterator IterType;
+protected:
+ AnimalsType animals;
+protected:
+ std::string name_;
+public:
+ // Construct an animal with this name
+ Animal(const char* name) : name_(name) {}
+
+ // Return the animal's name
+ const char* get_name() const { return name.c_str(); }
+};
+
+class Zoo
+{
+protected:
+ std::vector<Animal *> animals;
+
+public:
+ // Construct an empty zoo
+ Zoo() {}
+
+ /* Create a new animal. */
+ static Animal* Zoo::create_animal(const char* name) {
+ return new Animal(name);
+ }
+
+ // Add a new animal to the zoo
+ void add_animal(Animal* animal) {
+ animals.push_back(animal);
+ }
+
+ Animal* remove_animal(size_t i) {
+ Animal* result = this->animals[i];
+ IterType iter = this->animals.begin();
+ std::advance(iter, i);
+ this->animals.erase(iter);
+
+ return result;
+ }
+
+ // Return the number of animals in the zoo
+ size_t get_num_animals() const {
+ return animals.size();
+ }
+
+ // Return a pointer to the ith animal
+ Animal* get_animal(size_t i) const {
+ return animals[i];
+ }
+};</PRE>
</DIV>
-<H4><A name="Ruby_ret_typemap"></A>36.7.6.17 ret typemap</H4>
-<P>Cleanup of function return values</P>
-<H4><A name="Ruby_globalin_typemap"></A>36.7.6.18 globalin typemap</H4>
-<P>Setting of C global variables</P>
-<H3><A name="Ruby_nn40"></A>36.7.7 Typemap variables</H3>
-<P> Within a typemap, a number of special variables prefaced with a <TT>
-$</TT> may appear. A full list of variables can be found in the "<A href="#Typemaps">
-Typemaps</A>" chapter. This is a list of the most common variables:</P>
-<P><TT>$1</TT></P>
-<DIV class="indent">A C local variable corresponding to the actual type
- specified in the <TT>%typemap</TT> directive. For input values, this is
- a C local variable that is supposed to hold an argument value. For
- output values, this is the raw result that is supposed to be returned
- to Ruby.</DIV>
-<P><TT>$input</TT></P>
-<DIV class="indent">A <TT>VALUE</TT> holding a raw Ruby object with an
- argument or variable value.</DIV>
-<P><TT>$result</TT></P>
-<DIV class="indent">A <TT>VALUE</TT> that holds the result to be
- returned to Ruby.</DIV>
-<P><TT>$1_name</TT></P>
-<DIV class="indent">The parameter name that was matched.</DIV>
-<P><TT>$1_type</TT></P>
-<DIV class="indent">The actual C datatype matched by the typemap.</DIV>
-<P><TT>$1_ltype</TT></P>
-<DIV class="indent">An assignable version of the datatype matched by the
- typemap (a type that can appear on the left-hand-side of a C assignment
- operation). This type is stripped of qualifiers and may be an altered
- version of <TT>$1_type</TT>. All arguments and local variables in
- wrapper functions are declared using this type so that their values can
- be properly assigned.</DIV>
-<P><TT>$symname</TT></P>
-<DIV class="indent">The Ruby name of the wrapper function being created.</DIV>
-<H3><A name="Ruby_nn41"></A>36.7.8 Useful Functions</H3>
-<P> When you write a typemap, you usually have to work directly with
- Ruby objects. The following functions may prove to be useful. (These
- functions plus many more can be found in<EM> Programming Ruby</EM>
- book, by David Thomas and Andrew Hunt.)</P>
-<P>In addition, we list equivalent functions that SWIG defines, which
- provide a language neutral conversion (these functions are defined for
- each swig language supported). If you are trying to create a swig file
- that will work under multiple languages, it is recommended you stick to
- the swig functions instead of the native Ruby functions. That should
- help you avoid having to rewrite a lot of typemaps across multiple
- languages.</P>
-<H4><A name="Ruby_nn42"></A>36.7.8.1 C Datatypes to Ruby Objects</H4>
-<DIV class="diagram">
-<TABLE border="1" cellpadding="2" cellspacing="2" style="width: 100%;" summary="Datatypes">
-<TBODY></TBODY>
-<TR><TH><B>RUBY</B></TH><TH><B>SWIG</B></TH><TD></TD></TR>
-<TR><TD>INT2NUM(long or int)</TD><TD>SWIG_From_int(int x)</TD><TD> int
- to Fixnum or Bignum</TD></TR>
-<TR><TD>INT2FIX(long or int)</TD><TD></TD><TD> int to Fixnum (faster
- than INT2NUM)</TD></TR>
-<TR><TD>CHR2FIX(char)</TD><TD>SWIG_From_char(char x)</TD><TD> char to
- Fixnum</TD></TR>
-<TR><TD>rb_str_new2(char*)</TD><TD>SWIG_FromCharPtrAndSize(char*,
- size_t)</TD><TD> char* to String</TD></TR>
-<TR><TD>rb_float_new(double)</TD><TD>SWIG_From_double(double),
-<BR> SWIG_From_float(float)</TD><TD>float/double to Float</TD></TR>
-</TABLE>
+<P>Let's say you SWIG this code and then run IRB:</P>
+<DIV class="code targetlang">
+<PRE>$ <B>irb</B>
+irb(main):001:0> <B>require 'example'</B>
+=> true
+
+irb(main):002:0> <B>tiger1 = Example::Animal.new("tiger1")</B>
+=> #<Example::Animal:0x2be3820>
+
+irb(main):004:0> <B>tiger1.get_name()</B>
+=> "tiger1"
+
+irb(main):003:0> <B>zoo = Example::Zoo.new()</B>
+=> #<Example::Zoo:0x2be0a60>
+
+irb(main):006:0> <B>zoo.add_animal(tiger)</B>
+=> nil
+
+irb(main):007:0> <B>zoo.get_num_animals()</B>
+=> 1
+
+irb(main):007:0> <B>tiger2 = zoo.remove_animal(0)</B>
+=> #<Example::Animal:0x2bd4a18>
+
+irb(main):008:0> <B>tiger2.get_name()</B>
+=> "tiger1"
+
+irb(main):009:0> <B>tiger1.equal?(tiger2)</B>
+=> false
+</PRE>
</DIV>
-<H4><A name="Ruby_nn43"></A>36.7.8.2 Ruby Objects to C Datatypes</H4>
-<P>Here, while the Ruby versions return the value directly, the SWIG
- versions do not, but return a status value to indicate success (<TT>
-SWIG_OK</TT>). While more akward to use, this allows you to write
- typemaps that report more helpful error messages, like:</P>
-<DIV class="code">
-<PRE>
-%typemap(in) size_t (int ok)
- ok = SWIG_AsVal_size_t($input, &$1);
- if (!SWIG_IsOK(ok)) {
- SWIG_exception_fail(SWIG_ArgError(ok), Ruby_Format_TypeError( "$1_name", "$1_type","$symname", $argnum, $input));
- }
-}
+<P>Pay particular attention to the code <TT>tiger1.equal?(tiger2)</TT>.
+ Note that the two Ruby objects are not the same - but they reference
+ the same underlying C++ object. This can cause problems. For example:</P>
+<DIV class="code targetlang">
+<PRE>irb(main):010:0> <B>tiger1 = nil</B>
+=> nil
+
+irb(main):011:0> <B>GC.start</B>
+=> nil
+
+irb(main):012:0> <B>tiger2.get_name()</B>
+(irb):12: [BUG] Segmentation fault
</PRE>
-</DIV><DIV class="diagram">
-<TABLE border="1" cellpadding="2" cellspacing="2" summary="Ruby objects" width="100%">
-<TBODY></TBODY>
-<TR><TD>int NUM2INT(Numeric)</TD><TD>SWIG_AsVal_int(VALUE, int*)</TD></TR>
-<TR><TD>int FIX2INT(Numeric)</TD><TD>SWIG_AsVal_int(VALUE, int*)</TD></TR>
-<TR><TD>unsigned int NUM2UINT(Numeric)</TD><TD>
-SWIG_AsVal_unsigned_SS_int(VALUE, int*)</TD></TR>
-<TR><TD>unsigned int FIX2UINT(Numeric)</TD><TD>
-SWIG_AsVal_unsigned_SS_int(VALUE, int*)</TD></TR>
-<TR><TD>long NUM2LONG(Numeric)</TD><TD>SWIG_AsVal_long(VALUE, long*)</TD>
-</TR>
-<TR><TD>long FIX2LONG(Numeric)</TD><TD>SWIG_AsVal_long(VALUE, long*)</TD>
-</TR>
-<TR><TD>unsigned long FIX2ULONG(Numeric)</TD><TD>
-SWIG_AsVal_unsigned_SS_long(VALUE, unsigned long*)</TD></TR>
-<TR><TD>char NUM2CHR(Numeric or String)</TD><TD>SWIG_AsVal_char(VALUE,
- int*)</TD></TR>
-<TR><TD>char * StringValuePtr(String)</TD><TD>
-SWIG_AsCharPtrAndSize(VALUE, char*, size_t, int* alloc)</TD></TR>
-<TR><TD>char * rb_str2cstr(String, int*length)</TD><TD></TD></TR>
-<TR><TD>double NUM2DBL(Numeric)</TD><TD>(double) SWIG_AsVal_int(VALUE)
- or similar</TD></TR>
-</TABLE>
</DIV>
-<H4><A name="Ruby_nn44"></A>36.7.8.3 Macros for VALUE</H4>
-<P> <TT>RSTRING_LEN(str)</TT></P>
-<DIV class="indent">length of the Ruby string</DIV>
-<P><TT>RSTRING_PTR(str)</TT></P>
-<DIV class="indent">pointer to string storage</DIV>
-<P><TT>RARRAY_LEN(arr)</TT></P>
-<DIV class="indent">length of the Ruby array</DIV>
-<P><TT>RARRAY(arr)->capa</TT></P>
-<DIV class="indent">capacity of the Ruby array</DIV>
-<P><TT>RARRAY_PTR(arr)</TT></P>
-<DIV class="indent">pointer to array storage</DIV>
-<H4><A name="Ruby_nn45"></A>36.7.8.4 Exceptions</H4>
-<P> <TT>void rb_raise(VALUE exception, const char *fmt, ...)</TT></P>
-<DIV class="indent"> Raises an exception. The given format string<I> fmt</I>
- and remaining arguments are interpreted as with <TT>printf()</TT>.</DIV>
-<P><TT>void rb_fatal(const char *fmt, ...)</TT></P>
-<DIV class="indent"> Raises a fatal exception, terminating the process.
- No rescue blocks are called, but ensure blocks will be called. The
- given format string<I> fmt</I> and remaining arguments are interpreted
- as with <TT>printf()</TT>.</DIV>
-<P><TT>void rb_bug(const char *fmt, ...)</TT></P>
-<DIV class="indent"> Terminates the process immediately -- no handlers
- of any sort will be called. The given format string<I> fmt</I> and
- remaining arguments are interpreted as with <TT>printf()</TT>. You
- should call this function only if a fatal bug has been exposed.</DIV>
-<P><TT>void rb_sys_fail(const char *msg)</TT></P>
-<DIV class="indent"> Raises a platform-specific exception corresponding
- to the last known system error, with the given string<I> msg</I>.</DIV>
-<P><TT>VALUE rb_rescue(VALUE (*body)(VALUE), VALUE args,
- VALUE(*rescue)(VALUE, VALUE), VALUE rargs)</TT></P>
-<DIV class="indent"> Executes<I> body</I> with the given<I> args</I>. If
- a <TT>StandardError</TT> exception is raised, then execute<I> rescue</I>
- with the given<I> rargs</I>.</DIV>
-<P><TT>VALUE rb_ensure(VALUE(*body)(VALUE), VALUE args,
- VALUE(*ensure)(VALUE), VALUE eargs)</TT></P>
-<DIV class="indent"> Executes<I> body</I> with the given<I> args</I>.
- Whether or not an exception is raised, execute<I> ensure</I> with the
- given<I> rargs</I> after<I> body</I> has completed.</DIV>
-<P><TT>VALUE rb_protect(VALUE (*body)(VALUE), VALUE args, int *result)</TT>
-</P>
-<DIV class="indent"> Executes<I> body</I> with the given<I> args</I> and
- returns nonzero in result if any exception was raised.</DIV>
-<P><TT>void rb_notimplement()</TT></P>
-<DIV class="indent"> Raises a <TT>NotImpError</TT> exception to indicate
- that the enclosed function is not implemented yet, or not available on
- this platform.</DIV>
-<P><TT>void rb_exit(int status)</TT></P>
-<DIV class="indent"> Exits Ruby with the given<I> status</I>. Raises a <TT>
-SystemExit</TT> exception and calls registered exit functions and
- finalizers.</DIV>
-<P><TT>void rb_warn(const char *fmt, ...)</TT></P>
-<DIV class="indent"> Unconditionally issues a warning message to
- standard error. The given format string<I> fmt</I> and remaining
- arguments are interpreted as with <TT>printf()</TT>.</DIV>
-<P><TT>void rb_warning(const char *fmt, ...)</TT></P>
-<DIV class="indent"> Conditionally issues a warning message to standard
- error if Ruby was invoked with the <TT>-w</TT> flag. The given format
- string<I> fmt</I> and remaining arguments are interpreted as with <TT>
-printf()</TT>.</DIV>
-<H4><A name="Ruby_nn46"></A>36.7.8.5 Iterators</H4>
-<P> <TT>void rb_iter_break()</TT></P>
-<DIV class="indent"> Breaks out of the enclosing iterator block.</DIV>
-<P><TT>VALUE rb_each(VALUE obj)</TT></P>
-<DIV class="indent"> Invokes the <TT>each</TT> method of the given<I>
- obj</I>.</DIV>
-<P><TT>VALUE rb_yield(VALUE arg)</TT></P>
-<DIV class="indent"> Transfers execution to the iterator block in the
- current context, passing<I> arg</I> as an argument. Multiple values may
- be passed in an array.</DIV>
-<P><TT>int rb_block_given_p()</TT></P>
-<DIV class="indent"> Returns <TT>true</TT> if <TT>yield</TT> would
- execute a block in the current context; that is, if a code block was
- passed to the current method and is available to be called.</DIV>
-<P><TT>VALUE rb_iterate(VALUE (*method)(VALUE), VALUE args, VALUE
- (*block)(VALUE, VALUE), VALUE arg2)</TT></P>
-<DIV class="indent"> Invokes<I> method</I> with argument<I> args</I> and
- block<I> block</I>. A <TT>yield</TT> from that method will invoke<I>
- block</I> with the argument given to <TT>yield</TT>, and a second
- argument<I> arg2</I>.</DIV>
-<P><TT>VALUE rb_catch(const char *tag, VALUE (*proc)(VALUE, VALUE),
- VALUE value)</TT></P>
-<DIV class="indent"> Equivalent to Ruby's <TT>catch</TT>.</DIV>
-<P><TT>void rb_throw(const char *tag, VALUE value)</TT></P>
-<DIV class="indent"> Equivalent to Ruby's <TT>throw</TT>.</DIV>
-<H3><A name="Ruby_nn47"></A>36.7.9 Typemap Examples</H3>
-<P> This section includes a few examples of typemaps. For more examples,
- you might look at the examples in the <TT>Example/ruby</TT> directory.</P>
-<H3><A name="Ruby_nn48"></A>36.7.10 Converting a Ruby array to a char **</H3>
-<P> A common problem in many C programs is the processing of command
- line arguments, which are usually passed in an array of <TT>NULL</TT>
- terminated strings. The following SWIG interface file allows a Ruby
- Array instance to be used as a <TT>char **</TT> object.</P>
+<P>After the garbage collector runs, as a result of our call to <TT>
+GC.start</TT>, calling<TT>tiger2.get_name()</TT> causes a segmentation
+ fault. The problem is that when <TT>tiger1</TT> is garbage collected,
+ it frees the underlying C++ object. Thus, when <TT>tiger2</TT> calls
+ the <TT>get_name()</TT> method it invokes it on a destroyed object.</P>
+<P>This problem can be avoided if SWIG enforces a one-to-one mapping
+ between Ruby objects and C++ classes. This can be done via the use of
+ the <TT>%trackobjects</TT> functionality available in SWIG-1.3.26. and
+ later.</P>
+<P>When the <TT>%trackobjects</TT> is turned on, SWIG automatically
+ keeps track of mappings between C++ objects and Ruby objects. Note that
+ enabling object tracking causes a slight performance degradation. Test
+ results show this degradation to be about 3% to 5% when creating and
+ destroying 100,000 animals in a row.</P>
+<P>Since <TT>%trackobjects</TT> is implemented as a <TT>%feature</TT>,
+ it uses the same name matching rules as other kinds of features (see
+ the chapter on <A href="#Customization"> "Customization Features"</A>)
+ . Thus it can be applied on a class-by-class basis if needed. To fix
+ the example above:</P>
<DIV class="code">
-<PRE>%module argv
-
-// This tells SWIG to treat char ** as a special case
-%typemap(in) char ** {
- /* Get the length of the array */
- int size = RARRAY($input)->len;
- int i;
- $1 = (char **) malloc((size+1)*sizeof(char *));
- /* Get the first element in memory */
- VALUE *ptr = RARRAY($input)->ptr;
- for (i=0; i < size; i++, ptr++) {
- /* Convert Ruby Object String to char* */
- $1[i]= StringValuePtr(*ptr);
- }
- $1[i]=NULL; /* End of list */
-}
+<PRE>%module example
-// This cleans up the char ** array created before
-// the function call
+%{
+#include "example.h"
+%}
-%typemap(freearg) char ** {
- free((char *) $1);
-}
+<B>/* Tell SWIG that create_animal creates a new object */</B>
+<B>%newobject Zoo::create_animal;</B>
-// Now a test function
-%inline %{
-int print_args(char **argv) {
- int i = 0;
- while (argv[i]) {
- printf("argv[%d] = %s\n", i,argv[i]);
- i++;
- }
- return i;
-}
-%}</PRE>
+<B>/* Tell SWIG to keep track of mappings between C/C++ structs/classes. */</B>
+<B>%trackobjects;</B>
+
+%include "example.h"</PRE>
</DIV>
-<P> When this module is compiled, the wrapped C function now operates as
- follows :</P>
+<P>When this code runs we see:</P>
<DIV class="code targetlang">
-<PRE>require 'Argv'
-Argv.print_args(["Dave","Mike","Mary","Jane","John"])
-argv[0] = Dave
-argv[1] = Mike
-argv[2] = Mary
-argv[3] = Jane
-argv[4] = John</PRE>
+<PRE>$ <B>irb</B>
+irb(main):001:0> <B>require 'example'</B>
+=> true
+
+irb(main):002:0> <B>tiger1 = Example::Animal.new("tiger1")</B>
+=> #<Example::Animal:0x2be37d8>
+
+irb(main):003:0> <B>zoo = Example::Zoo.new()</B>
+=> #<Example::Zoo:0x2be0a18>
+
+irb(main):004:0> <B>zoo.add_animal(tiger1)</B>
+=> nil
+
+irb(main):006:0> <B>tiger2 = zoo.remove_animal(0)</B>
+=> #<Example::Animal:0x2be37d8>
+
+irb(main):007:0> <B>tiger1.equal?(tiger2)</B>
+=> true
+
+irb(main):008:0> <B>tiger1 = nil</B>
+=> nil
+
+irb(main):009:0> <B>GC.start</B>
+=> nil
+
+irb(main):010:0> <B>tiger.get_name()</B>
+=> "tiger1"
+irb(main):011:0></PRE>
</DIV>
-<P> In the example, two different typemaps are used. The "in" typemap is
- used to receive an input argument and convert it to a C array. Since
- dynamic memory allocation is used to allocate memory for the array, the
- "freearg" typemap is used to later release this memory after the
- execution of the C function.</P>
-<H3><A name="Ruby_nn49"></A>36.7.11 Collecting arguments in a hash</H3>
-<P> Ruby's solution to the "keyword arguments" capability of some other
- languages is to allow the programmer to pass in one or more key-value
- pairs as arguments to a function. All of those key-value pairs are
- collected in a single <TT>Hash</TT> argument that's presented to the
- function. If it makes sense, you might want to provide similar
- functionality for your Ruby interface. For example, suppose you'd like
- to wrap this C function that collects information about people's vital
- statistics:</P>
+<P>For those who are interested, object tracking is implemented by
+ storing Ruby objects in a hash table and keying them on C++ pointers.
+ The underlying API is:</P>
<DIV class="code">
-<PRE>void setVitalStats(const char *person, int nattributes, const char **names, int *values);</PRE>
+<PRE>static void SWIG_RubyAddTracking(void* ptr, VALUE object);
+static VALUE SWIG_RubyInstanceFor(void* ptr) ;
+static void SWIG_RubyRemoveTracking(void* ptr);
+static void SWIG_RubyUnlinkObjects(void* ptr);</PRE>
</DIV>
-<P> and you'd like to be able to call it from Ruby by passing in an
- arbitrary number of key-value pairs as inputs, e.g.</P>
-<DIV class="code targetlang">
-<PRE>setVitalStats("Fred",
- 'weight' => 270,
- 'age' => 42
-)</PRE>
+<P>When an object is created, SWIG will automatically call the <TT>
+SWIG_RubyAddTracking</TT> method. Similarly, when an object is deleted,
+ SWIG will call the <TT>SWIG_RubyRemoveTracking</TT>. When an object is
+ returned to Ruby from C++, SWIG will use the <TT>SWIG_RubyInstanceFor</TT>
+ method to ensure a one-to-one mapping from Ruby to C++ objects. Last,
+ the <TT>RubyUnlinkObjects</TT> method unlinks a Ruby object from its
+ underlying C++ object.</P>
+<P>In general, you will only need to use the <TT>SWIG_RubyInstanceFor</TT>
+, which is required for implementing mark functions as shown below.
+ However, if you implement your own free functions (see below) you may
+ also have to call the <TT>SWIG_RubyRemoveTracking</TT> and <TT>
+RubyUnlinkObjects</TT> methods.</P>
+<H3><A name="Ruby_nn61">38.10.4 Mark Functions</A></H3>
+<P>With a bit more testing, we see that our class library still has
+ problems. For example:</P>
+<DIV class="targetlang">
+<PRE>$ <B>irb</B>
+irb(main):001:0> <B>require 'example'</B>
+=> true
+
+irb(main):002:0> tiger1 = <B>Example::Animal.new("tiger1")</B>
+=> #<Example::Animal:0x2bea6a8>
+
+irb(main):003:0> zoo = <B>Example::Zoo.new()</B>
+=> #<Example::Zoo:0x2be7960>
+
+irb(main):004:0> <B>zoo.add_animal(tiger1)</B>
+=> nil
+
+irb(main):007:0> <B>tiger1 = nil</B>
+=> nil
+
+irb(main):007:0> <B>GC.start</B>
+=> nil
+
+irb(main):005:0> <B>tiger2 = zoo.get_animal(0)</B>
+(irb):12: [BUG] Segmentation fault</PRE>
</DIV>
-<P> To make this work, you need to write a typemap that expects a Ruby <TT>
-Hash</TT> as its input and somehow extracts the last three arguments (<I>
-nattributes</I>,<I> names</I> and<I> values</I>) needed by your C
- function. Let's start with the basics:</P>
+<P>The problem is that Ruby does not know that the <TT>zoo</TT> object
+ contains a reference to a Ruby object. Thus, when Ruby garbage collects
+ <TT>tiger1</TT> it frees the underlying C++ object.</P>
+<P>This can be fixed by implementing a <TT>mark</TT> function as
+ described above in the <A href="#Ruby_nn52">Mark and Sweep Garbage
+ Collector</A> section. You can specify a mark function by using the <TT>
+%markfunc</TT> directive. Since the <TT>%markfunc</TT> directive is
+ implemented using SWIG's' "features" mechanism it uses the same name
+ matching rules as other kinds of features (see the chapter on <A href="#Customization">
+"Customization Features"</A> for more details).</P>
+<P>A <TT>mark</TT> function takes a single argument, which is a pointer
+ to the C++ object being marked; it should, in turn, call <TT>
+rb_gc_mark()</TT> for any instances that are reachable from the current
+ object. The mark function for our <TT>Zoo</TT> class should therefore
+ loop over all of the C++ animal objects in the zoo object, look up
+ their Ruby object equivalent, and then call <TT>rb_gc_mark()</TT>. One
+ possible implementation is:</P>
<DIV class="code">
-<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
- (VALUE keys_arr, int i, VALUE key, VALUE val) {
+<PRE>%module example
+
+%{
+#include "example.h"
+%}
+
+/* Keep track of mappings between C/C++ structs/classes
+ and Ruby objects so we can implement a mark function. */
+<B>%trackobjects;</B>
+
+/* Specify the mark function */
+<B>%markfunc Zoo "mark_Zoo";</B>
+
+%include "example.h"
+
+%header %{
+
+static void mark_Zoo(void* ptr) {
+ Zoo* zoo = (Zoo*) ptr;
+
+ /* Loop over each object and tell the garbage collector
+ that we are holding a reference to them. */
+ int count = zoo->get_num_animals();
+
+ for(int i = 0; i < count; ++i) {
+ Animal* animal = zoo->get_animal(i);
+ VALUE object = SWIG_RubyInstanceFor(animal);
+
+ if (object != Qnil) {
+ rb_gc_mark(object);
+ }
+ }
}
- </PRE>
+%}</PRE>
</DIV>
-<P> This <TT>%typemap</TT> directive tells SWIG that we want to match
- any function declaration that has the specified types and names of
- arguments somewhere in the argument list. The fact that we specified
- the argument names (<I>nattributes</I>,<I> names</I> and<I> values</I>)
- in our typemap is significant; this ensures that SWIG won't try to
- apply this typemap to<I> other</I> functions it sees that happen to
- have a similar declaration with different argument names. The arguments
- that appear in the second set of parentheses (<I>keys_arr</I>,<I> i</I>
-,<I> key</I> and<I> val</I>) define local variables that our typemap
- will need.</P>
-<P>Since we expect the input argument to be a <TT>Hash</TT>, let's next
- add a check for that:</P>
-<DIV class="code">
-<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
- (VALUE keys_arr, int i, VALUE key, VALUE val) {
- <B>Check_Type($input, T_HASH);</B>
-}</PRE>
+<P> Note the <TT>mark</TT> function is dependent on the <TT>
+SWIG_RUBY_InstanceFor</TT> method, and thus requires that <TT>
+%trackobjects</TT> is enabled. For more information, please refer to the
+ ruby_track_objects.i test case in the SWIG test suite.</P>
+<P>When this code is compiled we now see:</P>
+<DIV class="targetlang">
+<PRE>$ <B>irb
+</B>irb(main):002:0> <B>tiger1=Example::Animal.new("tiger1")</B>
+=> #<Example::Animal:0x2be3bf8>
+
+irb(main):003:0> <B>Example::Zoo.new()</B>
+=> #<Example::Zoo:0x2be1780>
+
+irb(main):004:0> <B>zoo = Example::Zoo.new()</B>
+=> #<Example::Zoo:0x2bde9c0>
+
+irb(main):005:0> <B>zoo.add_animal(tiger1)</B>
+=> nil
+
+irb(main):009:0> <B>tiger1 = nil</B>
+=> nil
+
+irb(main):010:0> <B>GC.start</B>
+=> nil
+irb(main):014:0> <B>tiger2 = zoo.get_animal(0)</B>
+=> #<Example::Animal:0x2be3bf8>
+
+irb(main):015:0> <B>tiger2.get_name()</B>
+=> "tiger1"
+irb(main):016:0></PRE>
</DIV>
-<P> <TT>Check_Type()</TT> is just a macro (defined in the Ruby header
- files) that confirms that the input argument is of the correct type; if
- it isn't, an exception will be raised.</P>
-<P>The next task is to determine how many key-value pairs are present in
- the hash; we'll assign this number to the first typemap argument (<TT>
-$1</TT>). This is a little tricky since the Ruby/C API doesn't provide a
- public function for querying the size of a hash, but we can get around
- that by calling the hash's<I> size</I> method directly and converting
- its result to a C <TT>int</TT> value:</P>
+<P>This code can be seen in swig/examples/ruby/mark_function.</P>
+<H3><A name="Ruby_nn62">38.10.5 Free Functions</A></H3>
+<P>By default, SWIG creates a "free" function that is called when a Ruby
+ object is garbage collected. The free function simply calls the C++
+ object's destructor.</P>
+<P>However, sometimes an appropriate destructor does not exist or
+ special processing needs to be performed before the destructor is
+ called. Therefore, SWIG allows you to manually specify a "free"
+ function via the use of the <TT>%freefunc</TT> directive. The <TT>
+%freefunc</TT> directive is implemented using SWIG's' "features"
+ mechanism and so the same name matching rules used for other kinds of
+ features apply (see the chapter on <A href="#Customization">
+"Customization Features"</A>) for more details).</P>
+<P>IMPORTANT ! - If you define your own free function, then you must
+ ensure that you call the underlying C++ object's destructor. In
+ addition, if object tracking is activated for the object's class, you
+ must also call the <TT>SWIG_RubyRemoveTracking</TT> function (of course
+ call this before you destroy the C++ object). Note that it is harmless
+ to call this method if object tracking if off so it is advised to
+ always call it.</P>
+<P>Note there is a subtle interaction between object ownership and free
+ functions. A custom defined free function will only be called if the
+ Ruby object owns the underlying C++ object. This also to Ruby objects
+ which are created, but then transfer ownership to C++ objects via the
+ use of the <TT>disown</TT> typemap described above.</P>
+<P>To show how to use the <TT>%freefunc</TT> directive, let's slightly
+ change our example. Assume that the zoo object is responsible for
+ freeing any animal that it contains. This means that the <TT>
+Zoo::add_animal</TT> function should be marked with a <TT>DISOWN</TT>
+ typemap and the destructor should be updated as below:</P>
<DIV class="code">
-<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
- (VALUE keys_arr, int i, VALUE key, VALUE val) {
- Check_Type($input, T_HASH);
- <B>$1 = NUM2INT(rb_funcall($input, rb_intern("size"), 0, NULL));</B>
-}</PRE>
+<PRE>
+Zoo::~Zoo() {
+ IterType iter = this->animals.begin();
+ IterType end = this->animals.end();
+
+ for(iter; iter != end; ++iter) {
+ Animal* animal = *iter;
+ delete animal;
+ }
+}
+</PRE>
</DIV>
-<P> So now we know the number of attributes. Next we need to initialize
- the second and third typemap arguments (i.e. the two C arrays) to <TT>
-NULL</TT> and set the stage for extracting the keys and values from the
- hash:</P>
-<DIV class="code">
-<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
- (VALUE keys_arr, int i, VALUE key, VALUE val) {
- Check_Type($input, T_HASH);
- $1 = NUM2INT(rb_funcall($input, rb_intern("size"), 0, NULL));
- <B>$2 = NULL;
- $3 = NULL;
- if ($1 > 0) {
- $2 = (char **) malloc($1*sizeof(char *));
- $3 = (int *) malloc($1*sizeof(int));
- }</B>
-}</PRE>
+<P>When we use these objects in IRB we see:</P>
+<DIV class="code targetlang">
+<PRE class="targetlang"><B>$irb</B>
+irb(main):002:0> <B>require 'example'</B>
+=> true
+
+irb(main):003:0> <B>zoo = Example::Zoo.new()</B>
+=> #<Example::Zoo:0x2be0fe8>
+
+irb(main):005:0> <B>tiger1 = Example::Animal.new("tiger1")</B>
+=> #<Example::Animal:0x2bda760>
+
+irb(main):006:0> <B>zoo.add_animal(tiger1)</B>
+=> nil
+
+irb(main):007:0> <B>zoo = nil</B>
+=> nil
+
+irb(main):008:0> <B>GC.start</B>
+=> nil
+
+irb(main):009:0> <B>tiger1.get_name()</B>
+(irb):12: [BUG] Segmentation fault
+</PRE>
</DIV>
-<P> There are a number of ways we could extract the keys and values from
- the input hash, but the simplest approach is to first call the hash's<I>
- keys</I> method (which returns a Ruby array of the keys) and then start
- looping over the elements in that array:</P>
+<P>The error happens because the C++ <TT>animal</TT> object is freed
+ when the <TT>zoo</TT> object is freed. Although this error is
+ unavoidable, we can at least prevent the segmentation fault. To do this
+ requires enabling object tracking and implementing a custom free
+ function that calls the <TT>SWIG_RubyUnlinkObjects</TT> function for
+ each animal object that is destroyed. The <TT>SWIG_RubyUnlinkObjects</TT>
+ function notifies SWIG that a Ruby object's underlying C++ object is no
+ longer valid. Once notified, SWIG will intercept any calls from the
+ existing Ruby object to the destroyed C++ object and raise an
+ exception.</P>
<DIV class="code">
-<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
- (VALUE keys_arr, int i, VALUE key, VALUE val) {
- Check_Type($input, T_HASH);
- $1 = NUM2INT(rb_funcall($input, rb_intern("size"), 0, NULL));
- $2 = NULL;
- $3 = NULL;
- if ($1 > 0) {
- $2 = (char **) malloc($1*sizeof(char *));
- $3 = (int *) malloc($1*sizeof(int));
- <B>keys_arr = rb_funcall($input, rb_intern("keys"), 0, NULL);
- for (i = 0; i < $1; i++) {
- }</B>
+<PRE>%module example
+
+%{
+#include "example.h"
+%}
+
+/* Specify that ownership is transferred to the zoo when calling add_animal */
+%apply SWIGTYPE *DISOWN { Animal* animal };
+
+/* Track objects */
+%trackobjects;
+
+/* Specify the mark function */
+%freefunc Zoo "free_Zoo";
+
+%include "example.h"
+
+%header %{
+ static void free_Zoo(void* ptr) {
+ Zoo* zoo = (Zoo*) ptr;
+
+ /* Loop over each animal */
+ int count = zoo->get_num_animals();
+
+ for(int i = 0; i < count; ++i) {
+ /* Get an animal */
+ Animal* animal = zoo->get_animal(i);
+
+ /* Unlink the Ruby object from the C++ object */
+ SWIG_RubyUnlinkObjects(animal);
+
+ /* Now remove the tracking for this animal */
+ SWIG_RubyRemoveTracking(animal);
}
-}</PRE>
+
+ /* Now call SWIG_RubyRemoveTracking for the zoo */
+ SWIG_RubyRemoveTracking(ptr);
+ /* Now free the zoo which will free the animals it contains */
+ delete zoo;
+ }
+%} </PRE>
</DIV>
-<P> Recall that<I> keys_arr</I> and<I> i</I> are local variables for
- this typemap. For each element in the<I> keys_arr</I> array, we want to
- get the key itself, as well as the value corresponding to that key in
- the hash:</P>
+<P>Now when we use these objects in IRB we see:</P>
+<DIV class="code targetlang">
+<PRE><B>$irb</B>
+irb(main):002:0> <B>require 'example'</B>
+=> true
+
+irb(main):003:0> <B>zoo = Example::Zoo.new()</B>
+=> #<Example::Zoo:0x2be0fe8>
+
+irb(main):005:0> <B>tiger1 = Example::Animal.new("tiger1")</B>
+=> #<Example::Animal:0x2bda760>
+
+irb(main):006:0> <B>zoo.add_animal(tiger1)</B>
+=> nil
+
+irb(main):007:0> <B>zoo = nil</B>
+=> nil
+
+irb(main):008:0> <B>GC.start</B>
+=> nil
+
+irb(main):009:0> <B>tiger1.get_name()</B>
+RuntimeError: This Animal * already released
+ from (irb):10:in `get_name'
+ from (irb):10
+irb(main):011:0></PRE>
+</DIV>
+<P>Notice that SWIG can now detect the underlying C++ object has been
+ freed, and thus raises a runtime exception.</P>
+<P>This code can be seen in swig/examples/ruby/free_function.</P>
+<H3><A name="Ruby_nn63">38.10.6 Embedded Ruby and the C++ Stack</A></H3>
+<P>As has been said, the Ruby GC runs and marks objects before its sweep
+ phase. When the garbage collector is called, it will also try to mark
+ any Ruby objects (VALUE) it finds in the machine registers and in the
+ C++ stack.</P>
+<P>The stack is basically the history of the functions that have been
+ called and also contains local variables, such as the ones you define
+ whenever you do inside a function:</P>
+<DIV class="diagram">VALUE obj;</DIV>
+<P>For ruby to determine where its stack space begins, during
+ initialization a normal Ruby interpreter will call the ruby_init()
+ function which in turn will call a function called Init_stack or
+ similar. This function will store a pointer to the location where the
+ stack points at that point in time.</P>
+<P>ruby_init() is presumed to always be called within the main()
+ function of your program and whenever the GC is called, ruby will
+ assume that the memory between the current location in memory and the
+ pointer that was stored previously represents the stack, which may
+ contain local (and temporary) VALUE ruby objects. Ruby will then be
+ careful not to remove any of those objects in that location.</P>
+<P>So far so good. For a normal Ruby session, all the above is
+ completely transparent and magic to the extensions developer.</P>
+<P>However, with an embedded Ruby, it may not always be possible to
+ modify main() to make sure ruby_init() is called there. As such,
+ ruby_init() will likely end up being called from within some other
+ function. This can lead Ruby to measure incorrectly where the stack
+ begins and can result in Ruby incorrectly collecting those temporary
+ VALUE objects that are created once another function is called. The end
+ result: random crashes and segmentation faults.</P>
+<P>This problem will often be seen in director functions that are used
+ for callbacks, for example.</P>
+<P>To solve the problem, SWIG can now generate code with director
+ functions containing the optional macros SWIG_INIT_STACK and
+ SWIG_RELEASE_STACK. These macros will try to force Ruby to reinitialize
+ the beginning of the stack the first time a director function is
+ called. This will lead Ruby to measure and not collect any VALUE
+ objects defined from that point on.</P>
+<P>To mark functions to either reset the ruby stack or not, you can use:</P>
<DIV class="code">
-<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
- (VALUE keys_arr, int i, VALUE key, VALUE val) {
- Check_Type($input, T_HASH);
- $1 = NUM2INT(rb_funcall($input, rb_intern("size"), 0, NULL));
- $2 = NULL;
- $3 = NULL;
- if ($1 > 0) {
- $2 = (char **) malloc($1*sizeof(char *));
- $3 = (int *) malloc($1*sizeof(int));
- keys_arr = rb_funcall($input, rb_intern("keys"), 0, NULL);
- for (i = 0; i < $1; i++) {
- <B>key = rb_ary_entry(keys_arr, i);
- val = rb_hash_aref($input, key);</B>
- }
- }
-}</PRE>
+<PRE>
+%initstack Class::memberfunction; // only re-init the stack in this director method
+%ignorestack Class::memberfunction; // do not re-init the stack in this director method
+%initstack Class; // init the stack on all the methods of this class
+%initstack; // all director functions will re-init the stack
+</PRE>
+</DIV><HR NOSHADE>
+<H1><A name="Scilab">39 SWIG and Scilab</A></H1>
+
+<!-- INDEX -->
+<DIV class="sectiontoc">
+<UL>
+<LI><A href="#Scilab_preliminaries">Preliminaries</A></LI>
+<LI><A href="#Scilab_running_swig">Running SWIG</A>
+<UL>
+<LI><A href="#Scilab_running_swig_generating_module">Generating the
+ module</A></LI>
+<LI><A href="#Scilab_running_swig_building_module">Building the module</A>
+</LI>
+<LI><A href="#Scilab_running_swig_loading_module">Loading the module</A></LI>
+<LI><A href="#Scilab_running_swig_using_module">Using the module</A></LI>
+<LI><A href="#Scilab_running_swig_options">Scilab command line options</A>
+</LI>
+</UL>
+</LI>
+<LI><A href="#Scilab_wrapping">A basic tour of C/C++ wrapping</A>
+<UL>
+<LI><A href="#Scilab_wrapping_overview">Overview</A></LI>
+<LI><A href="#Scilab_wrapping_identifiers">Identifiers</A></LI>
+<LI><A href="#Scilab_wrapping_functions">Functions</A>
+<UL>
+<LI><A href="#Scilab_nn13">Argument passing</A></LI>
+<LI><A href="#Scilab_nn14">Multiple output arguments</A></LI>
+</UL>
+</LI>
+<LI><A href="#Scilab_wrapping_global_variables">Global variables</A></LI>
+<LI><A href="#Scilab_wrapping_constants_and_enums">Constants and
+ enumerations</A>
+<UL>
+<LI><A href="#Scilab_wrapping_constants">Constants</A></LI>
+<LI><A href="#Scilab_wrapping_enums">Enumerations</A></LI>
+</UL>
+</LI>
+<LI><A href="#Scilab_wrapping_pointers">Pointers</A>
+<UL>
+<LI><A href="#Scilab_wrapping_pointers_pointer_adresses">Utility
+ functions</A></LI>
+<LI><A href="#Scilab_wrapping_pointers_null_pointers">Null pointers:</A></LI>
+</UL>
+</LI>
+<LI><A href="#Scilab_wrapping_structs">Structures</A></LI>
+<LI><A href="#Scilab_wrapping_cpp_classes">C++ classes</A></LI>
+<LI><A href="#Scilab_wrapping_cpp_inheritance">C++ inheritance</A></LI>
+<LI><A href="#Scilab_wrapping_cpp_overloading">C++ overloading</A></LI>
+<LI><A href="#Scilab_wrapping_pointers_references_values_arrays">
+Pointers, references, values, and arrays</A></LI>
+<LI><A href="#Scilab_wrapping_cpp_templates">C++ templates</A></LI>
+<LI><A href="#Scilab_wrapping_cpp_operators">C++ operators</A></LI>
+<LI><A href="#Scilab_wrapping_cpp_namespaces">C++ namespaces</A></LI>
+<LI><A href="#Scilab_wrapping_cpp_exceptions">C++ exceptions</A></LI>
+<LI><A href="#Scilab_wrapping_cpp_stl">C++ STL</A></LI>
+</UL>
+</LI>
+<LI><A href="#Scilab_typemaps">Type mappings and libraries</A>
+<UL>
+<LI><A href="#Scilab_typemaps_primitive_types">Default primitive type
+ mappings</A></LI>
+<LI><A href="#Scilab_typemaps_arrays">Arrays</A></LI>
+<LI><A href="#Scilab_typemaps_pointer-to-pointers">Pointer-to-pointers</A>
+</LI>
+<LI><A href="#Scilab_typemaps_matrices">Matrices</A></LI>
+<LI><A href="#Scilab_typemaps_stl">STL</A></LI>
+</UL>
+</LI>
+<LI><A href="#Scilab_module_initialization">Module initialization</A></LI>
+<LI><A href="#Scilab_building_modes">Building modes</A>
+<UL>
+<LI><A href="#Scilab_building_modes_nobuilder_mode">No-builder mode</A></LI>
+<LI><A href="#Scilab_building_modes_builder_mode">Builder mode</A></LI>
+</UL>
+</LI>
+<LI><A href="#Scilab_generated_scripts">Generated scripts</A>
+<UL>
+<LI><A href="#Scilab_generated_scripts_builder_script">Builder script</A>
+</LI>
+<LI><A href="#Scilab_generated_scripts_loader_script">Loader script</A></LI>
+</UL>
+</LI>
+<LI><A href="#Scilab_other_resources">Other resources</A></LI>
+</UL>
</DIV>
-<P> To be safe, we should again use the <TT>Check_Type()</TT> macro to
- confirm that the key is a <TT>String</TT> and the value is a <TT>Fixnum</TT>
-:</P>
+<!-- INDEX -->
+<P> Scilab is a scientific software package for numerical computations
+ providing a powerful open computing environment for engineering and
+ scientific applications that is mostly compatible with MATLAB. More
+ information can be found at <A href="http://www.scilab.org">
+www.scilab.org</A>.</P>
+<P> This chapter explains how to use SWIG for Scilab. After this
+ introduction, you should be able to generate with SWIG a Scilab
+ external module from a C/C++ library.</P>
+<H2><A name="Scilab_preliminaries">39.1 Preliminaries</A></H2>
+<P> SWIG for Scilab supports Linux. Other operating sytems haven't been
+ tested.</P>
+<P> Scilab is supported from version 5.3.3 onwards. The forthcoming
+ version 6, as of January 2015, is also supported.</P>
+<P> SWIG for Scilab supports C language. C++ is partially supported. See
+ <A href="#Scilab_wrapping">A basic tour of C/C++ wrapping</A> for
+ further details.</P>
+<H2><A name="Scilab_running_swig">39.2 Running SWIG</A></H2>
+<P> Let's see how to use SWIG for Scilab on a small example.
+<BR> In this example we bind from C a function and a global variable
+ into Scilab. The SWIG interface (stored in a file named <TT>example.i</TT>
+), is the following:</P>
<DIV class="code">
-<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
- (VALUE keys_arr, int i, VALUE key, VALUE val) {
- Check_Type($input, T_HASH);
- $1 = NUM2INT(rb_funcall($input, rb_intern("size"), 0, NULL));
- $2 = NULL;
- $3 = NULL;
- if ($1 > 0) {
- $2 = (char **) malloc($1*sizeof(char *));
- $3 = (int *) malloc($1*sizeof(int));
- keys_arr = rb_funcall($input, rb_intern("keys"), 0, NULL);
- for (i = 0; i < $1; i++) {
- key = rb_ary_entry(keys_arr, i);
- val = rb_hash_aref($input, key);
- <B>Check_Type(key, T_STRING);
- Check_Type(val, T_FIXNUM);</B>
- }
+<PRE>
+%module example
+
+%inline %{
+double Foo = 3.0;
+
+int fact(int n) {
+ if (n < 0) {
+ return 0;
}
-}</PRE>
-</DIV>
-<P> Finally, we can convert these Ruby objects into their C equivalents
- and store them in our local C arrays:</P>
-<DIV class="code">
-<PRE>%typemap(in) (int nattributes, const char **names, const int *values)
- (VALUE keys_arr, int i, VALUE key, VALUE val) {
- Check_Type($input, T_HASH);
- $1 = NUM2INT(rb_funcall($input, rb_intern("size"), 0, NULL));
- $2 = NULL;
- $3 = NULL;
- if ($1 > 0) {
- $2 = (char **) malloc($1*sizeof(char *));
- $3 = (int *) malloc($1*sizeof(int));
- keys_arr = rb_funcall($input, rb_intern("keys"), 0, NULL);
- for (i = 0; i < $1; i++) {
- key = rb_ary_entry(keys_arr, i);
- val = rb_hash_aref($input, key);
- Check_Type(key, T_STRING);
- Check_Type(val, T_FIXNUM);
- <B>$2[i] = StringValuePtr(key);
- $3[i] = NUM2INT(val);</B>
+ else if (n == 0) {
+ return 1;
}
- }
-}</PRE>
+ else {
+ return n * fact(n-1);
+ }
+}
+%}
+</PRE>
</DIV>
-<P> We're not done yet. Since we used <TT>malloc()</TT> to dynamically
- allocate the memory used for the<I> names</I> and<I> values</I>
- arguments, we need to provide a corresponding "freearg" typemap to free
- that memory so that there is no memory leak. Fortunately, this typemap
- is a lot easier to write:</P>
-<DIV class="code">
-<PRE>%typemap(freearg) (int nattributes, const char **names, const int *values) {
- free((void *) $2);
- free((void *) $3);
-}</PRE>
+<P> Note: a code in an <TT>%inline</TT> section is both parsed and
+ wrapped by SWIG, and inserted as is in the wrapper source file.</P>
+<H3><A name="Scilab_running_swig_generating_module">39.2.1 Generating
+ the module</A></H3>
+<P> The module is generated using the <TT>swig</TT> executable and its <TT>
+-scilab</TT> option.</P>
+<DIV class="shell">
+<PRE>
+$ swig -scilab example.i
+</PRE>
</DIV>
-<P> All of the code for this example, as well as a sample Ruby program
- that uses the extension, can be found in the <TT>Examples/ruby/hashargs</TT>
- directory of the SWIG distribution.</P>
-<H3><A name="Ruby_nn50"></A>36.7.12 Pointer handling</H3>
-<P> Occasionally, it might be necessary to convert pointer values that
- have been stored using the SWIG typed-pointer representation. Since
- there are several ways in which pointers can be represented, the
- following two functions are used to safely perform this conversion:</P>
-<P><TT>int SWIG_ConvertPtr(VALUE obj, void **ptr, swig_type_info *ty,
- int flags)</TT></P>
-<DIV class="indent">Converts a Ruby object<I> obj</I> to a C pointer
- whose address is<I> ptr</I> (i.e.<I> ptr</I> is a pointer to a
- pointer). The third argument,<I> ty</I>, is a pointer to a SWIG type
- descriptor structure. If<I> ty</I> is not <TT>NULL</TT>, that type
- information is used to validate type compatibility and other aspects of
- the type conversion. If<I> flags</I> is non-zero, any type errors
- encountered during this validation result in a Ruby <TT>TypeError</TT>
- exception being raised; if<I> flags</I> is zero, such type errors will
- cause <TT>SWIG_ConvertPtr()</TT> to return -1 but not raise an
- exception. If<I> ty</I> is <TT>NULL</TT>, no type-checking is
- performed.</DIV>
-<P> <TT>VALUE SWIG_NewPointerObj(void *ptr, swig_type_info *ty, int own)</TT>
-</P>
-<DIV class="indent">Creates a new Ruby pointer object. Here,<I> ptr</I>
- is the pointer to convert,<I> ty</I> is the SWIG type descriptor
- structure that describes the type, and<I> own</I> is a flag that
- indicates whether or not Ruby should take ownership of the pointer
- (i.e. whether Ruby should free this data when the corresponding Ruby
- instance is garbage-collected).</DIV>
-<P> Both of these functions require the use of a special SWIG
- type-descriptor structure. This structure contains information about
- the mangled name of the datatype, type-equivalence information, as well
- as information about converting pointer values under C++ inheritance.
- For a type of <TT>Foo *</TT>, the type descriptor structure is usually
- accessed as follows:</P>
-<DIV class="indent code">
-<PRE>Foo *foo;
-SWIG_ConvertPtr($input, (void **) &foo, SWIGTYPE_p_Foo, 1);
-
-VALUE obj;
-obj = SWIG_NewPointerObj(f, SWIGTYPE_p_Foo, 0);</PRE>
+<P> This command generates two files:</P>
+<UL>
+<LI><TT>example_wrap.c</TT>: a C source file containing the wrapping
+ code and also here the wrapped code (the <TT>fact()</TT> and <TT>Foo</TT>
+ definitions)</LI>
+<LI><TT>loader.sce</TT>: a Scilab script used to load the module into
+ Scilab</LI>
+</UL>
+<P> Note: if the following error is returned:</P>
+<DIV class="shell">
+<PRE>
+:1: Error: Unable to find 'swig.swg'
+:3: Error: Unable to find 'scilab.swg'
+</PRE>
+</DIV>
+<P> it may be because the SWIG library is not found. Check the <TT>
+SWIG_LIB</TT> environment variable or your SWIG installation.</P>
+<P> Note: SWIG for Scilab can work in two modes related to the way the
+ module is built, see the <A href="#Scilab_building_modes">Building
+ modes</A> section for details. This example uses the <TT>builder</TT>
+ mode.</P>
+<P> The <TT>swig</TT> executable has several other command line options
+ you can use. See <A href="#Scilab_running_swig_options">Scilab command
+ line options</A> for further details.</P>
+<H3><A name="Scilab_running_swig_building_module">39.2.2 Building the
+ module</A></H3>
+<P> To be loaded in Scilab, the wrapper has to be built into a dynamic
+ module (or shared library).</P>
+<P> The commands to compile and link the wrapper (with <TT>gcc</TT>)
+ into the shared library <TT>libexample.so</TT> are:</P>
+<DIV class="shell">
+<PRE>
+$ gcc -fPIC -c -I/usr/local/include/scilab example_wrap.c
+$ gcc -shared example_wrap.o -o libexample.so
+</PRE>
</DIV>
-<P> In a typemap, the type descriptor should always be accessed using
- the special typemap variable <TT>$1_descriptor</TT>. For example:</P>
-<DIV class="indent code">
-<PRE>%typemap(in) Foo * {
- SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
-}</PRE>
+<P> Note: we supposed in this example that the path to the Scilab
+ include directory is <TT>/usr/local/include/scilab</TT> (which is the
+ case in a Debian environment), this should be changed for another
+ environment.</P>
+<H3><A name="Scilab_running_swig_loading_module">39.2.3 Loading the
+ module</A></H3>
+<P> Loading a module is done by running the loader script in Scilab:</P>
+<DIV class="targetlang">
+<PRE>
+--> exec loader.sce
+</PRE>
</DIV>
-<H4><A name="Ruby_nn51"></A>36.7.12.1 Ruby Datatype Wrapping</H4>
-<P> <TT>VALUE Data_Wrap_Struct(VALUE class, void (*mark)(void *), void
- (*free)(void *), void *ptr)</TT></P>
-<DIV class="indent">Given a pointer<I> ptr</I> to some C data, and the
- two garbage collection routines for this data (<I>mark</I> and<I> free</I>
-), return a <TT>VALUE</TT> for the Ruby object.</DIV>
-<P><TT>VALUE Data_Make_Struct(VALUE class,<I> c-type</I>, void
- (*mark)(void *), void (*free)(void *),<I> c-type</I> *ptr)</TT></P>
-<DIV class="indent">Allocates a new instance of a C data type<I> c-type</I>
-, assigns it to the pointer<I> ptr</I>, then wraps that pointer with <TT>
-Data_Wrap_Struct()</TT> as above.</DIV>
-<P><TT>Data_Get_Struct(VALUE obj,<I> c-type</I>,<I> c-type</I> *ptr)</TT>
-</P>
-<DIV class="indent">Retrieves the original C pointer of type<I> c-type</I>
- from the data object<I> obj</I> and assigns that pointer to<I> ptr</I>.</DIV>
-<H3><A name="Ruby_nn52"></A>36.7.13 Example: STL Vector to Ruby Array</H3>
-<P>Another use for macros and type maps is to create a Ruby array from a
- STL vector of pointers. In essence, copy of all the pointers in the
- vector into a Ruby array. The use of the macro is to make the typemap
- so generic that any vector with pointers can use the type map. The
- following is an example of how to construct this type of macro/typemap
- and should give insight into constructing similar typemaps for other
- STL structures:</P>
+<P> Scilab should output the following messages:</P>
+<DIV class="targetlang">
+<PRE>
+Shared archive loaded.
+Link done.
+</PRE>
+</DIV>
+<P> which means that Scilab has successfully loaded the shared library.
+ The module functions and other symbols are now available in Scilab.</P>
+<H3><A name="Scilab_running_swig_using_module">39.2.4 Using the module</A>
+</H3>
+<P> In Scilab, the function <TT>fact()</TT> is simply called as
+ following:</P>
+<DIV class="targetlang">
+<PRE>
+--> fact(5)
+ans =
+
+ 120.
+</PRE>
+</DIV>
+<P>For the <TT>Foo</TT> global variable, the accessors need to be used:<DIV
+class="targetlang">
+<PRE>
+--> Foo_get
+ans =
+
+ 3.
+
+--> Foo_set(4);
+
+--> Foo_get
+ans =
+
+ 4.
+</PRE>
+</DIV></P>
+<P> Note: for conciseness, we assume in the subsequent Scilab code
+ examples that the modules have been beforehand built and loaded in
+ Scilab.</P>
+<H3><A name="Scilab_running_swig_options">39.2.5 Scilab command line
+ options</A></H3>
+<P> The following table lists the Scilab specific command line options
+ in addition to the generic SWIG options:</P>
+<TABLE summary="Scilab specific options">
+<TR><TD><TT>-builder</TT></TD><TD>Generate the Scilab builder script</TD>
+</TR>
+<TR><TD><TT>-buildercflags <cflags></TT></TD><TD>Add <cflags> to the
+ builder compiler flags</TD></TR>
+<TR><TD><TT>-builderldflags <ldflags></TT></TD><TD>Add <ldlags> to the
+ builder linker flags</TD></TR>
+<TR><TD><TT>-buildersources <files></TT></TD><TD>Add the (comma
+ separated) files <files> to the builder sources</TD></TR>
+<TR><TD><TT>-builderverbositylevel <level></TT></TD><TD>Set the build
+ verbosity level to <level> (default 0: off, 2: high)</TD></TR>
+<TR><TD><TT>-builderflagscript <file></TT></TD><TD>Use the Scilab script
+ <file> to configure the compiler and linker flags</TD></TR>
+<TR><TD><TT>-gatewayxml <gateway_id></TT></TD><TD>Generate the gateway
+ XML with the given <gateway_id></TD></TR>
+</TABLE>
+<P> These options can be displayed with:</P>
+<DIV class="shell">
+<PRE>
+$ swig -scilab -help
+</PRE>
+</DIV>
+<H2><A name="Scilab_wrapping">39.3 A basic tour of C/C++ wrapping</A></H2>
+<H3><A name="Scilab_wrapping_overview">39.3.1 Overview</A></H3>
+<P> SWIG for Scilab provides only a low-level C interface for Scilab
+ (see <A href="#Scripting">Scripting Languages</A> for the general
+ approach to wrapping). This means that functions, structs, classes,
+ variables, etc... are interfaced through C functions. These C functions
+ are mapped as Scilab functions. There are a few exceptions, such as
+ constants and enumerations, which can be wrapped directly as Scilab
+ variables.</P>
+<H3><A name="Scilab_wrapping_identifiers">39.3.2 Identifiers</A></H3>
+<P> In Scilab 5.x, identifier names are composed of 24 characters
+ maximum (this limitation should disappear from Scilab 6.0 onwards).
+<BR> Thus long function or variable names may be truncated and this can
+ cause ambiguities.</P>
+<P>This happens especially when wrapping structs/classes, for which the
+ wrapped function name is composed of the struct/class name and field
+ names. In these cases, the <A href="#SWIG_rename_ignore">%rename
+ directive</A> can be used to choose a different Scilab name.</P>
+<H3><A name="Scilab_wrapping_functions">39.3.3 Functions</A></H3>
+<P> Functions are wrapped as new Scilab built-in functions. For example:</P>
<DIV class="code">
-<PRE>%define PTR_VECTOR_TO_RUBY_ARRAY(vectorclassname, classname)
-%typemap(out) vectorclassname &, const vectorclassname & {
- VALUE arr = rb_ary_new2($1->size());
- vectorclassname::iterator i = $1->begin(), iend = $1->end();
- for ( ; i!=iend; i++ )
- rb_ary_push(arr, Data_Wrap_Struct(c ## classname.klass, 0, 0, *i));
- $result = arr;
-}
-%typemap(out) vectorclassname, const vectorclassname {
- VALUE arr = rb_ary_new2($1.size());
- vectorclassname::iterator i = $1.begin(), iend = $1.end();
- for ( ; i!=iend; i++ )
- rb_ary_push(arr, Data_Wrap_Struct(c ## classname.klass, 0, 0, *i));
- $result = arr;
+<PRE>
+%module example
+
+%inline %{
+int fact(int n) {
+ if (n > 1)
+ return n * fact(n - 1);
+ else
+ return 1;
}
-%enddef</PRE>
+%}
+</PRE>
</DIV>
-<P> Note, that the "<TT>c ## classname.klass"</TT> is used in the
- preprocessor step to determine the actual object from the class name.</P>
-<P>To use the macro with a class Foo, the following is used:</P>
-<DIV class="code">
-<PRE>PTR_VECTOR_TO_RUBY_ARRAY(vector<foo *="">, Foo)</PRE>
+<P> creates a built-in function <TT>fact(n)</TT> in Scilab:</P>
+<DIV class="targetlang">
+<PRE>
+--> fact(4)
+ans =
+
+ 24.
+</PRE>
</DIV>
-<P> It is also possible to create a STL vector of Ruby objects:</P>
+<H4><A name="Scilab_nn13">39.3.3.1 Argument passing</A></H4>
+<P> In the above example, the function parameter is a primitive type and
+ is marshalled by value. So this function is wrapped without any
+ additional customization. Argument values are converted between C types
+ and Scilab types through type mappings. There are several default type
+ mappings for primitive and complex types, described later in the <A href="#Scilab_typemaps">
+Scilab typemaps</A> section.</P>
+<P> When a parameter is not passed by value, such as a pointer or
+ reference, SWIG does not know if it is an input, output (or both)
+ parameter. The INPUT, OUTPUT, INOUT typemaps defined in the <TT>
+typemaps.i</TT> library can be used to specify this.</P>
+<P> Let's see this on two simple functions: <TT>sub()</TT> which has an
+ output parameter, and <TT>inc()</TT>, which as input/output parameter:</P>
<DIV class="code">
-<PRE>%define RUBY_ARRAY_TO_PTR_VECTOR(vectorclassname, classname)
-%typemap(in) vectorclassname &, const vectorclassname & {
- Check_Type($input, T_ARRAY);
- vectorclassname *vec = new vectorclassname;
- int len = RARRAY($input)->len;
- for (int i=0; i!=len; i++) {
- VALUE inst = rb_ary_entry($input, i);
- //The following _should_ work but doesn't on HPUX
- // Check_Type(inst, T_DATA);
- classname *element = NULL;
- Data_Get_Struct(inst, classname, element);
- vec->push_back(element);
- }
- $1 = vec;
-}
+<PRE>
+%module example
-%typemap(freearg) vectorclassname &, const vectorclassname & {
- delete $1;
+%include <typemaps.i>
+
+extern void sub(int *INPUT, int *INPUT, int *OUTPUT);
+extern void inc(int *INOUT, int *INPUT);
+
+%{
+void sub(int *x, int *y, int *result) {
+ *result = *x - *y;
}
-%enddef</PRE>
+void inc(int *x, int *delta) {
+ *x = *x + *delta;
+}
+%}
+</PRE>
</DIV>
-<P> It is also possible to create a Ruby array from a vector of static
- data types:</P>
+<P> In Scilab, parameters are passed by value. The output (and inout)
+ parameters are returned as the result of the functions:</P>
+<DIV class="targetlang">
+<PRE>
+--> sub(5, 3)
+ ans =
+
+ 2.
+
+--> inc(4, 3)
+ ans =
+
+ 7.
+</PRE>
+</DIV>
+<H4><A name="Scilab_nn14">39.3.3.2 Multiple output arguments</A></H4>
+<P> A C function can have several output parameters. They can all be
+ returned as results of the wrapped function as Scilab supports multiple
+ return values from a function when using the <TT>typemaps.i</TT>
+ library. If the C function itself returns a result, this is returned
+ first before the parameter outputs.</P>
+<P> The example below shows this for a C function returning 2 values and
+ a result:</P>
<DIV class="code">
-<PRE>%define VECTOR_TO_RUBY_ARRAY(vectorclassname, classname)
-%typemap(out) vectorclassname &, const vectorclassname & {
- VALUE arr = rb_ary_new2($1->size());
- vectorclassname::iterator i = $1->begin(), iend = $1->end();
- for ( ; i!=iend; i++ )
- rb_ary_push(arr, Data_Wrap_Struct(c ## classname.klass, 0, 0, &(*i)));
- $result = arr;
-}
-%typemap(out) vectorclassname, const vectorclassname {
- VALUE arr = rb_ary_new2($1.size());
- vectorclassname::iterator i = $1.begin(), iend = $1.end();
- for ( ; i!=iend; i++ )
- rb_ary_push(arr, Data_Wrap_Struct(c ## classname.klass, 0, 0, &(*i)));
- $result = arr;
+<PRE>
+%module example
+
+%include <typemaps.i>
+
+int divide(int n, int d, int *OUTPUT, int *OUTPUT);
+
+%{
+int divide(int n, int d, int q*, int *r) {
+ if (d != 0) {
+ *q = n / d;
+ *r = n % d;
+ return 1;
+ }
+ else return 0;
}
-%enddef</PRE>
-</DIV> Note that this is mostly an example of typemaps. If you want to
- use the STL with ruby, you are advised to use the standard swig STL
- library, which does much more than this. Refer to the section called
- the<A href="#Ruby_nn23_1"> C++ Standard Template Library</A>.
-<H2><A name="Ruby_nn65"></A>36.8 Docstring Features</H2>
-<P> Using ri and rdoc web pages in Ruby libraries is a common practice.
- Given the way that SWIG generates the extensions by default, your users
- will normally not get any documentation for it, even if they run 'rdoc'
- on the resulting .c or .cxx file.</P>
-<P>The features described in this section make it easy for you to add
- rdoc strings to your modules, functions and methods that can then be
- read by Ruby's rdoc tool to generate html web pages, ri documentation,
- Windows chm file and an .xml description.</P>
-<P>rdoc can then be run from a console or shell window on a swig
- generated file.</P>
-<P>For example, to generate html web pages from a C++ file, you'd do:</P>
-<DIV class="code shell">
+%}
+</PRE>
+</DIV>
+<BR><DIV class="targetlang">
<PRE>
-$ rdoc -E cxx=c -f html file_wrap.cxx
+--> [ret, q, r] = divide(20, 6)
+ r =
+
+ 2.
+ q =
+
+ 3.
+ ret =
+
+ 1.
</PRE>
</DIV>
-<P>To generate ri documentation from a c wrap file, you could do:</P>
-<DIV class="code shell">
+<H3><A name="Scilab_wrapping_global_variables">39.3.4 Global variables</A>
+</H3>
+<P> Global variables are manipulated through generated accessor
+ functions. For example, for a given <TT>Foo</TT> global variable, SWIG
+ actually generates two functions: <TT>Foo_get()</TT> to get the value
+ of <TT>Foo</TT>, and <TT>Foo_set()</TT> to set the value. These
+ functions are used as following:</P>
+<DIV class="targetlang">
<PRE>
-$ rdoc -r file_wrap.c
+--> exec loader.sce;
+--> c = Foo_get();
+
+--> Foo_set(4);
+
+--> c
+c =
+
+ 3.
+
+--> Foo_get()
+ans =
+
+ 4.
</PRE>
</DIV>
-<H3><A name="Ruby_nn66"></A>36.8.1 Module docstring</H3>
-<P> Ruby allows a docstring at the beginning of the file before any
- other statements, and it is typically used to give a general
- description of the entire module. SWIG supports this by setting an
- option of the <TT>%module</TT> directive. For example:</P>
+<P> It works for variables of primitive type, but also for non-primitive
+ types: arrays, and structs/classes which are described later. For now,
+ an example with two global primitive arrays x and y is shown:</P>
<DIV class="code">
-<PRE>%module(docstring="This is the example module's docstring") example</PRE>
+<PRE>
+%module example
+
+%inline %{
+int x[10];
+double y[7];
+
+void initArrays()
+{
+ int i;
+ for (i = 0; i < 10; i++)
+ x[i] = 1;
+ for (i = 0; i < 7; i++)
+ y[i] = 1.0f;
+}
+%}
+</PRE>
</DIV>
-<P> When you have more than just a line or so then you can retain the
- easy readability of the <TT>%module</TT> directive by using a macro.
- For example:</P>
-<DIV class="code">
-<PRE>%define DOCSTRING
-"The `XmlResource` class allows program resources defining menus,
-layout of controls on a panel, etc. to be loaded from an XML file."
-%enddef
+<P> It works the same:</P>
+<DIV class="targetlang">
+<PRE>
+--> exec loader.sce
-%module(docstring=DOCSTRING) xrc</PRE>
+--> initArrays();
+--> x_get()
+ ans =
+
+ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.
+
+--> y_set([0:6] / 10);
+--> y_get()
+ ans =
+
+ 0. 0.1 0.2 0.3 0.4 0.5 0.6
+</PRE>
</DIV>
-<H3><A name="Ruby_nn67"></A>36.8.2 %feature("autodoc")</H3>
-<P>Since SWIG does know everything about the function it wraps, it is
- possible to generate an rdoc containing the parameter types, names and
- default values. Since Ruby ships with one of the best documentation
- systems of any language, it makes sense to take advantage of it.</P>
-<P>SWIG's Ruby module provides support for the "autodoc" feature, which
- when attached to a node in the parse tree will cause an rdoc comment to
- be generated in the wrapper file that includes the name of the
- function, parameter names, default values if any, and return type if
- any. There are also several options for autodoc controlled by the value
- given to the feature, described below.</P>
-<H4><A name="Ruby_nn68"></A>36.8.2.1 %feature("autodoc", "0")</H4>
-<P> When the "0" option is given then the types of the parameters will<EM>
- not</EM> be included in the autodoc string. For example, given this
- function prototype:</P>
+<H3><A name="Scilab_wrapping_constants_and_enums">39.3.5 Constants and
+ enumerations</A></H3>
+<H4><A name="Scilab_wrapping_constants">39.3.5.1 Constants</A></H4>
+<P> There is not any constant in Scilab. By default, C/C++ constants are
+ wrapped as getter functions. For example, for the following constants:</P>
<DIV class="code">
-<PRE>%feature("autodoc", "0");
-bool function_name(int x, int y, Foo* foo=NULL, Bar* bar=NULL);</PRE>
+<PRE>
+%module example
+#define ICONST 42
+#define FCONST 2.1828
+#define CCONST 'x'
+#define CCONST2 '\n'
+#define SCONST "Hello World"
+#define SCONST2 "\"Hello World\""
+</PRE>
</DIV>
-<P> Then Ruby code like this will be generated:</P>
+<P> the following getter functions are generated:</P>
<DIV class="targetlang">
-<PRE>function_name(x, y, foo=nil, bar=nil) -> bool
- ...</PRE>
+<PRE>
+--> exec loader.sce;
+--> ICONST_get();
+ ans =
+
+ 42.
+
+--> FCONST_get();
+ ans =
+
+ 2.1828
+
+--> CCONST_get();
+ ans =
+
+ x
+
+--> CCONST2_get();
+ ans =
+
+--> SCONST_get();
+ ans =
+
+ Hello World
+
+--> SCONST2_get();
+ ans =
+
+ "Hello World"
+
+--> EXPR_get();
+ ans =
+
+ 48.5484
+
+--> iconst_get();
+ ans =
+
+ 37.
+
+--> fconst_get();
+ ans =
+
+ 3.14
+</PRE>
</DIV>
-<H4><A name="Ruby_autodoc1"></A>36.8.2.2 %feature("autodoc", "1")</H4>
-<P> When the "1" option is used then the parameter types<EM> will</EM>
- be used in the rdoc string. In addition, an attempt is made to simplify
- the type name such that it makes more sense to the Ruby user. Pointer,
- reference and const info is removed, <TT>%rename</TT>'s are evaluated,
- etc. (This is not always successful, but works most of the time. See
- the next section for what to do when it doesn't.) Given the example
- above, then turning on the parameter types with the "1" option will
- result in rdoc code like this:</P>
-<DIV class="targetlang">
-<PRE>function_name(int x, int y, Foo foo=nil, Bar bar=nil) -> bool
- ...</PRE>
+<P> There is another mode in which constants are wrapped as Scilab
+ variables. The variables are easier to use than functions, but the
+ drawback is that variables are not constant and so can be modified.</P>
+<P> This mode can be enabled/disabled at any time in the interface file
+ with <TT>%scilabconst()</TT>, which works like all the other <A href="#Customization_features">
+%feature directives</A>. Use the argument value "1" to enable and "0" to
+ disable this mode. For example in this mode the previous constants:</P>
+<DIV class="code">
+<PRE>
+%module example
+
+%scilabconst(1);
+#define ICONST 42
+#define FCONST 2.1828
+#define CCONST 'x'
+#define CCONST2 '\n'
+#define SCONST "Hello World"
+#define SCONST2 "\"Hello World\""
+</PRE>
</DIV>
-<H4><A name="Ruby_autodoc2"></A>36.8.2.3 %feature("autodoc", "2")</H4>
-<P> When the "2" option is used then the parameter types will not be
- used in the rdoc string. However, they will be listed in full after the
- function. Given the example above, then turning on the parameter types
- with the "2" option will result in Ruby code like this:</P>
-<H4><A name="Ruby_feature_autodoc3"></A>36.8.2.4 %feature("autodoc",
- "3")</H4>
-<P> When the "3" option is used then the function will be documented
- using a combination of "1" and "2" above. Given the example above, then
- turning on the parameter types with the "2" option will result in Ruby
- code like this:</P>
+<P> are mapped to Scilab variables, with the same name:</P>
<DIV class="targetlang">
-<PRE>function_name(int x, int y, Foo foo=nil, Bar bar=nil) -> bool
+<PRE>
+--> exec loader.sce;
+--> ICONST
+ ans =
-Parameters:
- x - int
- y - int
- foo - Foo
- bar - Bar</PRE>
+ 42
+
+--> FCONST
+ ans =
+
+ 2.1828
+
+--> CCONST
+ ans =
+
+ x
+
+--> CCONST2
+ ans =
+
+--> SCONST
+ ans =
+
+ Hello World
+
+--> SCONST2
+ ans =
+
+ "Hello World"
+
+--> EXPR
+ ans =
+
+ 48.5484
+
+--> iconst
+ ans =
+
+ 37
+
+--> fconst
+ ans =
+
+ 3.14
+</PRE>
</DIV>
-<H4><A name="Ruby_nn70"></A>36.8.2.5 %feature("autodoc", "docstring")</H4>
-<P> Finally, there are times when the automatically generated autodoc
- string will make no sense for a Ruby programmer, particularly when a
- typemap is involved. So if you give an explicit value for the autodoc
- feature then that string will be used in place of the automatically
- generated string. For example:</P>
+<H4><A name="Scilab_wrapping_enums">39.3.5.2 Enumerations</A></H4>
+<P> The wrapping of enums is the same as for constants. By default,
+ enums are wrapped as getter functions. For example, with the following
+ enumeration:</P>
<DIV class="code">
-<PRE>%feature("autodoc", "GetPosition() -> (x, y)") GetPosition;
-void GetPosition(int* OUTPUT, int* OUTPUT);</PRE>
+<PRE>%module example
+typedef enum { RED, BLUE, GREEN } color;
+</PRE>
</DIV>
-<H3><A name="Ruby_nn71"></A>36.8.3 %feature("docstring")</H3>
-<P> In addition to the autodoc strings described above, you can also
- attach any arbitrary descriptive text to a node in the parse tree with
- the "docstring" feature. When the proxy module is generated then any
- docstring associated with classes, function or methods are output. If
- an item already has an autodoc string then it is combined with the
- docstring and they are output together.</P>
-<H2><A name="Ruby_nn53"></A>36.9 Advanced Topics</H2>
-<H3><A name="Ruby_operator_overloading"></A>36.9.1 Operator overloading</H3>
-<P> SWIG allows operator overloading with, by using the <TT>%extend</TT>
- or <TT>%rename</TT> commands in SWIG and the following operator names
- (derived from Python):</P>
-<DIV class="code diagram">
-<TABLE border="1" cellpadding="2" cellspacing="2" style="width: 100%; font-family: monospace;"
-summary="operator names"><TBODY></TBODY>
-<TR><TD><B> General</B></TD></TR>
-<TR><TD>__repr__</TD><TD> inspect</TD></TR>
-<TR><TD>__str__</TD><TD> to_s</TD></TR>
-<TR><TD>__cmp__</TD><TD> <=></TD></TR>
-<TR><TD>__hash__</TD><TD> hash</TD></TR>
-<TR><TD>__nonzero__</TD><TD> nonzero?</TD></TR>
-<TR><TD></TD></TR>
-<TR><TD><B> Callable</B></TD></TR>
-<TR><TD>__call__</TD><TD> call</TD></TR>
-<TR><TD></TD></TR>
-<TR><TD><B> Collection</B></TD></TR>
-<TR><TD>__len__</TD><TD> length</TD></TR>
-<TR><TD>__getitem__</TD><TD> []</TD></TR>
-<TR><TD>__setitem__</TD><TD> []=</TD></TR>
-<TR><TD></TD></TR>
-<TR><TD><B> Numeric</B></TD></TR>
-<TR><TD>__add__</TD><TD> +</TD></TR>
-<TR><TD>__sub__</TD><TD> -</TD><TD></TD></TR>
-<TR><TD>__mul__</TD><TD> *</TD></TR>
-<TR><TD>__div__</TD><TD> /</TD></TR>
-<TR><TD>__mod__</TD><TD> %</TD></TR>
-<TR><TD>__divmod__</TD><TD> divmod</TD></TR>
-<TR><TD>__pow__</TD><TD> **</TD></TR>
-<TR><TD>__lshift__</TD><TD> <<</TD></TR>
-<TR><TD>__rshift__</TD><TD> >></TD></TR>
-<TR><TD>__and__</TD><TD> &</TD></TR>
-<TR><TD>__xor__</TD><TD> ^</TD></TR>
-<TR><TD>__or__</TD><TD> |</TD></TR>
-<TR><TD>__neg__</TD><TD> -@</TD><TD></TD></TR>
-<TR><TD>__pos__</TD><TD> +@</TD></TR>
-<TR><TD>__abs__</TD><TD> abs</TD></TR>
-<TR><TD>__invert__</TD><TD> ~</TD></TR>
-<TR><TD>__int__</TD><TD> to_i</TD></TR>
-<TR><TD>__float__</TD><TD> to_f</TD></TR>
-<TR><TD>__coerce__</TD><TD> coerce</TD></TR>
-<TR><TD></TD></TR>
-<TR><TD><B>Additions in 1.3.13</B></TD></TR>
-<TR><TD>__lt__</TD><TD> <</TD></TR>
-<TR><TD>__le__</TD><TD> <=</TD></TR>
-<TR><TD>__eq__</TD><TD> ==</TD></TR>
-<TR><TD>__gt__</TD><TD> ></TD></TR>
-<TR><TD>__ge__</TD><TD> >=</TD></TR>
-</TABLE>
+<P> a getter function will be generated for each value of the
+ enumeration:</P>
+<DIV class="targetlang">
+<PRE>
+--> exec loader.sce;
+--> RED_get()
+ ans =
+
+ 0.
+
+--> BLUE_get()
+ ans =
+
+ 1.
+
+--> GREEN_get()
+ ans =
+
+ 2.
+</PRE>
</DIV>
-<P> Note that although SWIG supports the <TT>__eq__</TT> magic method
- name for defining an equivalence operator, there is no separate method
- for handling<I> inequality</I> since Ruby parses the expression<I> a !=
- b</I> as<I> !(a == b)</I>.</P>
-<H3><A name="Ruby_nn55"></A>36.9.2 Creating Multi-Module Packages</H3>
-<P> The chapter on <A href="#Modules">Working with Modules</A> discusses
- the basics of creating multi-module extensions with SWIG, and in
- particular the considerations for sharing runtime type information
- among the different modules.</P>
-<P>As an example, consider one module's interface file (<TT>shape.i</TT>
-) that defines our base class:</P>
+<P> The <TT>%scilabconst()</TT> feature is also available for
+ enumerations:</P>
<DIV class="code">
-<PRE>%module shape
+<PRE>%module example
+%scilabconst(1) color;
+typedef enum { RED, BLUE, GREEN } color;
+</PRE>
+</DIV>
+<BR><DIV class="targetlang">
+<PRE>
+--> exec loader.sce;
+--> RED
+ ans =
-%{
-#include "Shape.h"
-%}
+ 0.
-class Shape {
-protected:
- double xpos;
- double ypos;
-protected:
- Shape(double x, double y);
-public:
- double getX() const;
- double getY() const;
-};</PRE>
+--> BLUE
+ ans =
+
+ 1.
+
+--> GREEN
+ ans =
+
+ 2.
+
+</PRE>
</DIV>
-<P> We also have a separate interface file (<TT>circle.i</TT>) that
- defines a derived class:</P>
+<H3><A name="Scilab_wrapping_pointers">39.3.6 Pointers</A></H3>
+<P> Pointers are supported by SWIG. A pointer can be returned from a
+ wrapped C/C++ function, stored in a Scilab variable, and used in input
+ argument of another C/C++ function.</P>
+<P> Also, thanks to the SWIG runtime which stores informations about
+ types, pointer types are tracked between exchanges Scilab and the
+ native code. Indeed pointer types are stored alongside the pointer
+ adress. A pointer is mapped to a Scilab structure (<A href="https://help.scilab.org/docs/5.5.2/en_US/tlist.html">
+tlist</A>), which contains as fields the pointer address and the pointer
+ type (in fact a pointer to the type information structure in the SWIG
+ runtime).
+<BR> Why a native pointer is not mapped to a Scilab pointer (type name:
+ "pointer", type ID: 128) ? The big advantage of mapping to a <TT>tlist</TT>
+ is that it exposes a new type for the pointer in Scilab, type which can
+ be acessed in Scilab with the <A href="https://help.scilab.org/docs/5.5.2/en_US/typeof.html">
+typeof</A> function, and manipulated using the <A href="https://help.scilab.org/docs/5.5.2/en_US/overloading.html">
+overloading</A> mechanism.</P>
+<P> Notes:</P>
+<UL>
+<LI>type tracking needs the SWIG runtime to be first initialized with
+ the appropriate function (see the <A href="#Scilab_module_initialization">
+Module initialization</A> section).</LI>
+<LI>for any reason, if a wrapped pointer type is unknown (or if the SWIG
+ runtime is not initialized), SWIG maps it to a Scilab pointer. Also, a
+ Scilab pointer is always accepted as a pointer argument of a wrapped
+ function. The drawaback is that pointer type is lost.</LI>
+</UL>
+<P> Following is an example of the wrapping of the C <TT>FILE*</TT>
+ pointer:</P>
<DIV class="code">
-<PRE>%module circle
+<PRE>
+%module example
%{
-#include "Shape.h"
-#include "Circle.h"
+#include <stdio.h>
%}
-// Import the base class definition from Shape module
-%import shape.i
+FILE *fopen(const char *filename, const char *mode);
+int fputs(const char *, FILE *);
+int fclose(FILE *);
+</PRE>
+</DIV>
+<P> These functions can be used the same way as in C from Scilab:</P>
+<DIV class="targetlang">
+<PRE>
+--> example_Init();
-class Circle : public Shape {
-protected:
- double radius;
-public:
- Circle(double x, double y, double r);
- double getRadius() const;
-};</PRE>
+--> f = fopen("junk", "w");
+--> typeof(f)
+ ans =
+
+ _p_FILE
+
+--> fputs("Hello World", f);
+--> fclose(f);
+</PRE>
</DIV>
-<P> We'll start by building the<B> Shape</B> extension module:</P>
-<DIV class="code shell">
-<PRE>$ swig -c++ -ruby shape.i
+<P> Note: the type name <TT>_p_FILE</TT> which means "pointer to FILE".</P>
+<P> The user of a pointer is responsible for freeing it or, like in the
+ example, closing any resources associated with it (just as is required
+ in a C program).</P>
+<H4><A name="Scilab_wrapping_pointers_pointer_adresses">39.3.6.1 Utility
+ functions</A></H4>
+<P> As a scripting language, Scilab does not provide functions to
+ manipulate pointers. However, in some cases it can be useful, such as
+ for testing or debugging.</P>
+<P> SWIG comes with two pointer utility functions:</P>
+<UL>
+<LI><TT>SWIG_this()</TT>: returns the address value of a pointer</LI>
+<LI><TT>SWIG_ptr()</TT>: creates a pointer from an address value</LI>
+</UL>
+<P> Note: a pointer created by <TT>SWIG_ptr()</TT> does not have any
+ type and is mapped as a Scilab pointer.</P>
+<P>Following we use the utility functions on the previous example:</P>
+<DIV class="targetlang">
+<PRE>
+--> f = fopen("junk", "w");
+--> fputs("Hello", f);
+--> addr = SWIG_this(f)
+ ans =
+
+ 8219088.
+
+--> p = SWIG_ptr(addr);
+--> typeof(p)
+ans =
+
+ pointer
+
+--> fputs(" World", p);
+--> fclose(f);
</PRE>
</DIV>
-<P> SWIG generates a wrapper file named <TT>shape_wrap.cxx</TT>. To
- compile this into a dynamically loadable extension for Ruby, prepare an
- <TT>extconf.rb</TT> script using this template:</P>
-<DIV class="code targetlang">
-<PRE>require 'mkmf'
+<H4><A name="Scilab_wrapping_pointers_null_pointers">39.3.6.2 Null
+ pointers:</A></H4>
+<P> Using the previous <TT>SWIG_this()</TT> and <TT>SWIG_ptr()</TT>, it
+ is possible to create and check null pointers:</P>
+<DIV class="targetlang">
+<PRE>
+--> p = SWIG_ptr(0);
+--> SWIG_this(p) == 0
+ ans =
-# Since the SWIG runtime support library for Ruby
-# depends on the Ruby library, make sure it's in the list
-# of libraries.
-$libs = append_library($libs, Config::CONFIG['RUBY_INSTALL_NAME'])
+ T
+</PRE>
+</DIV>
+<H3><A name="Scilab_wrapping_structs">39.3.7 Structures</A></H3>
+<P> Structs exist in Scilab, but C structs are not (at least in this
+ version of SWIG) mapped to Scilab structs. A C structure is wrapped
+ through low-level accessor functions, i.e. functions that give access
+ to the member variables of this structure. In Scilab, a structure is
+ manipulated through a pointer which is passed as an argument to the
+ accessor functions.</P>
+<P> Let's see it on an example of a struct with two members:</P>
+<DIV class="code">
+<PRE>
+%module example
-# Create the makefile
-create_makefile('shape')</PRE>
+%inline %{
+
+typedef struct {
+ int x;
+ int arr[4];
+} Foo;
+
+%}
+</PRE>
</DIV>
-<P> Run this script to create a <TT>Makefile</TT> and then type <TT>make</TT>
- to build the shared library:</P>
-<DIV class="code targetlang">
-<PRE>$ <B>ruby extconf.rb</B>
-creating Makefile
-$ <B>make</B>
-g++ -fPIC -g -O2 -I. -I/usr/local/lib/ruby/1.7/i686-linux \
--I. -c shape_wrap.cxx
-gcc -shared -L/usr/local/lib -o shape.so shape_wrap.o -L. \
--lruby -lruby -lc</PRE>
+<P> Several functions are generated:</P>
+<UL>
+<LI>a constructor function <TT>new_Foo()</TT> which returns a pointer to
+ a newly created struct <TT>Foo</TT>.</LI>
+<LI>two member getter functions <TT>Foo_x_get()</TT>, <TT>Foo_arr_get()</TT>
+, to get the values of <TT>x</TT> and <TT>y</TT> for the struct pointer
+ (provided as the first parameter to these functions)</LI>
+<LI>two member setter functions <TT>Foo_x_set()</TT>, <TT>Foo_arr_set()</TT>
+, to set the values of <TT>x</TT> and <TT>y</TT> for the struct pointer
+ (provided as the first parameter to these functions).</LI>
+<LI>a destructor function <TT>delete_Foo()</TT> to release the struct
+ pointer.</LI>
+</UL>
+<P> Usage example:</P>
+<DIV class="targetlang">
+<PRE>
+--> f = new_Foo();
+--> Foo_x_set(f, 100);
+--> Foo_x_get(f)
+ans =
+
+ 100.
+
+--> Foo_arr_set(f, [0:3]);
+--> Foo_arr_get(f)
+ans =
+
+ 0. 1. 2. 3.
+
+--> delete_Foo(f);
+</PRE>
</DIV>
-<P> Note that depending on your installation, the outputs may be
- slightly different; these outputs are those for a Linux-based
- development environment. The end result should be a shared library
- (here, <TT>shape.so</TT>) containing the extension module code. Now
- repeat this process in a separate directory for the<B> Circle</B>
- module:</P>
-<OL>
-<LI> Run SWIG to generate the wrapper code (<TT>circle_wrap.cxx</TT>);</LI>
-<LI> Write an <TT>extconf.rb</TT> script that your end-users can use to
- create a platform-specific <TT>Makefile</TT> for the extension;</LI>
-<LI> Build the shared library for this extension by typing <TT>make</TT>
-.</LI>
-</OL>
-<P> Once you've built both of these extension modules, you can test them
- interactively in IRB to confirm that the <TT>Shape</TT> and <TT>Circle</TT>
- modules are properly loaded and initialized:</P>
-<DIV class="code targetlang">
-<PRE>$ <B>irb</B>
-irb(main):001:0> <B>require 'shape'</B>
-true
-irb(main):002:0> <B>require 'circle'</B>
-true
-irb(main):003:0> <B>c = Circle::Circle.new(5, 5, 20)</B>
-#<Circle::Circle:0xa097208>
-irb(main):004:0> <B>c.kind_of? Shape::Shape</B>
-true
-irb(main):005:0> <B>c.getX()</B>
-5.0</PRE>
+<P> Members of a structure that are also structures are also accepted
+ and wrapped as a pointer:</P>
+<DIV class="code">
+<PRE>
+%module example
+
+%inline %{
+
+typedef struct {
+ int x;
+} Bar;
+
+typedef struct {
+ Bar b;
+} Foo;
+
+%}
+</PRE>
</DIV>
-<H3><A name="Ruby_nn56"></A>36.9.3 Specifying Mixin Modules</H3>
-<P> The Ruby language doesn't support multiple inheritance, but it does
- allow you to mix one or more modules into a class using Ruby's <TT>
-include</TT> method. For example, if you have a Ruby class that defines
- an<EM> each</EM> instance method, e.g.</P>
-<DIV class="code targetlang">
-<PRE>class Set
- def initialize
- @members = []
- end
-
- def each
- @members.each { |m| yield m }
- end
-end</PRE>
+<BR><DIV class="targetlang">
+<PRE>
+--> b = new_Bar();
+--> Bar_x_set(b, 20.);
+
+--> f = new_Foo();
+--> Foo_b_set(f, b);
+
+--> b2 = Foo_b_get(f);
+--> Bar_x_get(b2);
+ans =
+
+ 20.
+</PRE>
</DIV>
-<P> then you can mix-in Ruby's <TT>Enumerable</TT> module to easily add
- a lot of functionality to your class:</P>
-<DIV class="code targetlang">
-<PRE>class Set
- <B>include Enumerable</B>
- def initialize
- @members = []
- end
- def each
- @members.each { |m| yield m }
- end
-end</PRE>
+<P> Note: the pointer to the struct works as described in <A href="Scilab_wrapping_pointers">
+Pointers</A>. For example, the type of the struct pointer can be get
+ with <TT>typeof</TT>, as following:</P>
+<DIV class="targetlang">
+<PRE>
+--> example_Init();
+--> b = new_Bar();
+--> typeof(b)
+ ans =
+
+ _p_Bar
+--> delete_Bar(b);
+</PRE>
</DIV>
-<P> To get the same benefit for your SWIG-wrapped classes, you can use
- the <TT>%mixin</TT> directive to specify the names of one or more
- modules that should be mixed-in to a class. For the above example, the
- SWIG interface specification might look like this:</P>
+<H3><A name="Scilab_wrapping_cpp_classes">39.3.8 C++ classes</A></H3>
+<P> Classes do not exist in Scilab. The classes are wrapped the same way
+ as structs. Low-level accessor functions are generated for class
+ members. Also, constructor and destructor functions are generated to
+ create and destroy an instance of the class.</P>
+<P> For example, the following class:</P>
<DIV class="code">
-<PRE>%mixin Set "Enumerable";
+<PRE>
+%module example
-class Set {
+%inline %{
+
+class Point {
public:
- // Constructor
- Set();
-
- // Iterates through set members
- void each();
-};</PRE>
+ int x, y;
+ Point(int _x, int _y) : x(_x), y(_y) {}
+ double distance(const Point& rhs) {
+ return sqrt(pow(x-rhs.x, 2) + pow(y-rhs.y, 2));
+ }
+ void set(int _x, int _y) {
+ x=_x;
+ y=_y;
+ }
+};
+
+%}
+</PRE>
</DIV>
-<P> Multiple modules can be mixed into a class by providing a
- comma-separated list of module names to the <TT>%mixin</TT> directive,
- e.g.</P>
-<DIV class="code">
-<PRE>%mixin Set "Fee,Fi,Fo,Fum";</PRE>
+<P> can be used in Scilab like this:</P>
+<DIV class="targetlang">
+<PRE>
+--> p1 = Point_new(3, 5);
+--> p2 = Point_new(1, 2);
+--> p1.distance(p2)
+ans =
+
+ 3.6056
+
+--> delete_Point(p1);
+--> delete_Point(p2);
+</PRE>
</DIV>
-<P> Note that the <TT>%mixin</TT> directive is implemented using SWIG's
- "features" mechanism and so the same name matching rules used for other
- kinds of features apply (see the chapter on <A href="#Customization">
-"Customization Features"</A>) for more details).</P>
-<H2><A name="Ruby_nn57"></A>36.10 Memory Management</H2>
-<P>One of the most common issues in generating SWIG bindings for Ruby is
- proper memory management. The key to proper memory management is
- clearly defining whether a wrapper Ruby object owns the underlying C
- struct or C++ class. There are two possibilities:</P>
-<UL>
-<LI> The Ruby object is responsible for freeing the C struct or C++
- object</LI>
-<LI> The Ruby object should not free the C struct or C++ object because
- it will be freed by the underlying C or C++ code</LI>
-</UL>
-<P>To complicate matters, object ownership may transfer from Ruby to C++
- (or vice versa) depending on what function or methods are invoked.
- Clearly, developing a SWIG wrapper requires a thorough understanding of
- how the underlying library manages memory.</P>
-<H3><A name="Ruby_nn58"></A>36.10.1 Mark and Sweep Garbage Collector</H3>
-<P>Ruby uses a mark and sweep garbage collector. When the garbage
- collector runs, it finds all the "root" objects, including local
- variables, global variables, global constants, hardware registers and
- the C stack. For each root object, the garbage collector sets its mark
- flag to true and calls <TT>rb_gc_mark</TT> on the object. The job of <TT>
-rb_gc_mark</TT> is to recursively mark all the objects that a Ruby
- object has a reference to (ignoring those objects that have already
- been marked). Those objects, in turn, may reference other objects. This
- process will continue until all active objects have been "marked."
- After the mark phase comes the sweep phase. In the sweep phase, all
- objects that have not been marked will be garbage collected. For more
- information about the Ruby garbage collector please refer to <A href="http://rubygarden.org/ruby/ruby?GCAndExtensions">
+<P> Note: like structs, class pointers are mapped as described in <A href="Scilab_wrapping_pointers">
+Pointers</A>. Let's give an example which shows that each class pointer
+ type is a new type in Scilab that can be used for example (through <A href="https://help.scilab.org/docs/5.5.2/en_US/overloading.html">
+overloading</A>) to implement a custom print for the <TT>Point</TT>
+ class:</P>
+<DIV class="targetlang">
+<PRE>
+--> function %_p_Point_p(p)
+--> mprintf('[%d, %d]\n', Point_x_get(p), Point_y_get(p));
+--> endfunction
-<!--span style="text-decoration: underline;"-->
- http://rubygarden.org/ruby/ruby?GCAndExtensions</A>.</P>
-<P>The Ruby C/API provides extension developers two hooks into the
- garbage collector - a "mark" function and a "sweep" function. By
- default these functions are set to NULL.</P>
-<P>If a C struct or C++ class references any other Ruby objects, then it
- must provide a "mark" function. The "mark" function should identify any
- referenced Ruby objects by calling the rb_gc_mark function for each
- one. Unsurprisingly, this function will be called by the Ruby garbage
- during the "mark" phase.</P>
-<P>During the sweep phase, Ruby destroys any unused objects. If any
- memory has been allocated in creating the underlying C struct or C++
- struct, then a "free" function must be defined that deallocates this
- memory.</P>
-<H3><A name="Ruby_nn59"></A>36.10.2 Object Ownership</H3>
-<P>As described above, memory management depends on clearly defining who
- is responsible for freeing the underlying C struct or C++ class. If the
- Ruby object is responsible for freeing the C++ object, then a "free"
- function must be registered for the object. If the Ruby object is not
- responsible for freeing the underlying memory, then a "free" function
- must not be registered for the object.</P>
-<P>For the most part, SWIG takes care of memory management issues. The
- rules it uses are:</P>
-<UL>
-<LI> When calling a C++ object's constructor from Ruby, SWIG will assign
- a "free" function thereby making the Ruby object responsible for
- freeing the C++ object</LI>
-<LI> When calling a C++ member function that returns a pointer, SWIG
- will not assign a "free" function thereby making the underlying library
- responsible for freeing the object.</LI>
-</UL>
-<P>To make this clearer, let's look at an example. Assume we have a Foo
- and a Bar class.</P>
+--> example_Init();
+--> p = new_Point(1, 2)
+ p =
+
+[1, 2]
+
+--> delete_Point(p);
+</PRE>
+</DIV>
+<H3><A name="Scilab_wrapping_cpp_inheritance">39.3.9 C++ inheritance</A></H3>
+<P> Inheritance is supported. SWIG knows the inheritance relationship
+ between classes.</P>
+<P> A function is only generated for the class in which it is actually
+ declared. But if one of its parameters is a class, any instance of a
+ derived class is accepted as the argument.</P>
+<P> This mechanism also applies for accessor functions: they are
+ generated only in the class in which they are defined. But any instance
+ of a derived class can be used as the argument to these accessor
+ functions.</P>
+<P> For example, let's take a base class <TT>Shape</TT> and two derived
+ classes <TT>Circle</TT> and <TT>Square</TT>:</P>
<DIV class="code">
-<PRE>/* File "RubyOwernshipExample.h" */
+<PRE>
+%module example
-class Foo
-{
+%inline %{
+
+class Shape {
public:
- Foo() {}
- ~Foo() {}
+ double x, y;
+ void set_location(double _x, double _y) { x = _x; y = _y; }
+ virtual double get_perimeter() { return 0; };
};
-class Bar
-{
- Foo *foo_;
+class Circle : public Shape {
public:
- Bar(): foo_(new Foo) {}
- ~Bar() { delete foo_; }
- Foo* get_foo() { return foo_; }
- Foo* get_new_foo() { return new Foo; }
- void set_foo(Foo *foo) { delete foo_; foo_ = foo; }
-};</PRE>
-</DIV>
-<P>First, consider this Ruby code:</P>
-<DIV class="code targetlang">
-<PRE>foo = Foo.new</PRE>
-</DIV>
-<P>In this case, the Ruby code calls the underlying <TT>Foo</TT> C++
- constructor, thus creating a new <TT>foo</TT> object. By default, SWIG
- will assign the new Ruby object a "free" function. When the Ruby object
- is garbage collected, the "free" function will be called. It in turn
- will call <TT>Foo's</TT> destructor.</P>
-<P>Next, consider this code:</P>
-<DIV class="code targetlang">
-<PRE>bar = Bar.new
-foo = bar.get_foo()</PRE>
-</DIV>
-<P>In this case, the Ruby code calls a C++ member function, <TT>get_foo</TT>
-. By default, SWIG will not assign the Ruby object a "free" function.
- Thus, when the Ruby object is garbage collected the underlying C++ <TT>
-foo</TT> object is not affected.</P>
-<P>Unfortunately, the real world is not as simple as the examples above.
- For example:</P>
-<DIV class="code targetlang">
-<PRE>bar = Bar.new
-foo = bar.get_new_foo()</PRE>
+ int radius;
+ Circle(int _radius): radius(_radius) {};
+ virtual double get_perimeter() { return 6.28 * radius; }
+};
+
+class Square : public Shape {
+public:
+ int size;
+ Square(int _size): size(_size) {};
+ virtual double get_perimeter() { return 4 * size; }
+};
+
+%}
+</PRE>
</DIV>
-<P>In this case, the default SWIG behavior for calling member functions
- is incorrect. The Ruby object should assume ownership of the returned
- object. This can be done by using the %newobject directive. See <A href="#Customization_ownership">
- Object ownership and %newobject</A> for more information.</P>
-<P>The SWIG default mappings are also incorrect in this case:</P>
-<DIV class="code targetlang">
-<PRE>foo = Foo.new
-bar = Bar.new
-bar.set_foo(foo)</PRE>
+<P> To set the location of the <TT>Circle</TT>, we have to use the
+ function <TT>set_location()</TT> of the parent <TT>Shape</TT>. But we
+ can use either use the <TT>get_perimeter()</TT> function of the parent
+ class or the derived class:</P>
+<DIV class="targetlang">
+<PRE>
+--> c = new_Circle(3);
+
+--> Shape_set_location(c, 2, 3);
+--> Shape_x_get(c)
+ ans =
+
+ 2.
+
+--> Circle_get_perimeter(c)
+ ans =
+
+ 18.84
+
+--> Shape_get_perimeter(c)
+ ans =
+
+ 18.84
+</PRE>
</DIV>
-<P>Without modification, this code will cause a segmentation fault. When
- the Ruby <TT>foo</TT> object goes out of scope, it will free the
- underlying C++ <TT>foo</TT> object. However, when the Ruby bar object
- goes out of scope, it will call the C++ bar destructor which will also
- free the C++ <TT>foo</TT> object. The problem is that object ownership
- is transferred from the Ruby object to the C++ object when the <TT>
-set_foo</TT> method is called. This can be done by using the special
- DISOWN type map, which was added to the Ruby bindings in SWIG-1.3.26.</P>
-<P>Thus, a correct SWIG interface file correct mapping for these classes
- is:</P>
+<H3><A name="Scilab_wrapping_cpp_overloading">39.3.10 C++ overloading</A>
+</H3>
+<P> As explained in <A href="http://www.swig.org/Doc3.0/SWIGPlus.html#SWIGPlus_overloaded_methods">
+6.15</A> SWIG provides support for overloaded functions and
+ constructors.</P>
+<P>As SWIG knows pointer types, the overloading works also with pointer
+ types, here is is an example with a function <TT>magnify</TT>
+ overloaded for the previous classes <TT>Shape</TT> and <TT>Circle</TT>:</P>
<DIV class="code">
-<PRE>/* File RubyOwnershipExample.i */
+<PRE>
+%module example
-%module RubyOwnershipExample
+void magnify(Square *square, double factor) {
+ square->size *= factor;
+};
+
+void magnify(Circle *circle, double factor) {
+ square->radius *= factor;
+};
+</PRE>
+</DIV><DIV class="targetlang">
+<PRE>
+--> example_Init();
+--> c = new_Circle(3);
+--> s = new_Square(2);
+
+--> magnify(c, 10);
+--> Circle_get_radius(c)
+ ans =
+
+ 30;
+--> magnify(s, 10);
+--> Square_get_size(s)
+ ans =
+
+ 20;
+</PRE>
+</DIV>
+<H3><A name="Scilab_wrapping_pointers_references_values_arrays">39.3.11
+ Pointers, references, values, and arrays</A></H3>
+<P> In C++ objects can be passed by value, pointer, reference, or by an
+ array:</P>
+<DIV class="code">
+<PRE>
+%module example
%{
-#include "RubyOwnershipExample.h"
+#include <sciprint.h>
%}
-class Foo
-{
+%inline %{
+
+class Foo {
public:
- Foo();
- ~Foo();
+ Foo(int _x) : x(_x) {}
+ int x;
};
-class Bar
-{
- Foo *foo_;
-public:
- Bar();
- ~Bar();
- Foo* get_foo();
+void spam1(Foo *f) { sciprint("%d\n", f->x); } // Pass by pointer
+void spam2(Foo &f) { sciprint("%d\n", f.x); } // Pass by reference
+void spam3(Foo f) { sciprint("%d\n", f.x); } // Pass by value
+void spam4(Foo f[]) { sciprint("%d\n", f[0].x); } // Array of objects
-<B> %newobject get_new_foo;</B>
- Foo* get_new_foo();
+%}
+</PRE>
+</DIV>
+<P> In SWIG, there is no real distinction between these. So in Scilab,
+ it is perfectly legal to do this:</P>
+<DIV class="targetlang">
+<PRE>
+--> f = new_Foo()
+--> spam1(f)
+3
+--> spam2(f)
+3
+--> spam3(f)
+3
+--> spam4(f)
+3
+</PRE>
+</DIV>
+<P> Similar behaviour occurs for return values. For example, if you had
+ functions like this:</P>
+<DIV class="code">
+<PRE>
+Foo *spam5();
+Foo &spam6();
+Foo spam7();
+</PRE>
+</DIV>
+<P> All these functions will return a pointer to an instance of <TT>Foo</TT>
+. As the function <TT>spam7</TT> returns a value, new instance of <TT>
+Foo</TT> has to be allocated, and a pointer on this instance is
+ returned.</P>
+<H3><A name="Scilab_wrapping_cpp_templates">39.3.12 C++ templates</A></H3>
+<P> As in other languages, function and class templates are supported in
+ SWIG Scilab.</P>
+<P> You have to tell SWIG to create wrappers for a particular template
+ instantiation. The <TT>%template</TT> directive is used for this
+ purpose. For example:</P>
+<DIV class="code">
+<PRE>
+%module example
-<B> %apply SWIGTYPE *DISOWN {Foo *foo};</B>
- void set_foo(Foo *foo);
-<B> %clear Foo *foo;</B>
+template<class T1, class T2, class T3>
+struct triplet {
+ T1 first;
+ T2 second;
+ T3 third;
+ triplet(const T1& a, const T2& b, const T3& c) {
+ third = a; second = b; third = c;
+ }
};
+
+%template(IntTriplet) triplet<int,int,int>;
</PRE>
</DIV>
-<P> This code can be seen in swig/examples/ruby/tracking.</P>
-<H3><A name="Ruby_nn60"></A>36.10.3 Object Tracking</H3>
-<P>The remaining parts of this section will use the class library shown
- below to illustrate different memory management techniques. The class
- library models a zoo and the animals it contains.</P>
+<P> Then in Scilab:</P>
+<DIV class="targetlang">
+<PRE>
+--> t = new_IntTriplet(3, 4, 1);
+
+--> IntTriplet_first_get(t)
+ ans =
+
+ 3.
+
+--> IntTriplet_second_get(t)
+ ans =
+
+ 4.
+
+--> IntTriplet_third_get(t)
+ ans =
+
+ 1.
+
+--> delete_IntTriplet(t);
+</PRE>
+</DIV>
+<P> More details on template support can be found in the <A href="#SWIGPlus_nn30">
+templates</A> documentation.</P>
+<H3><A name="Scilab_wrapping_cpp_operators">39.3.13 C++ operators</A></H3>
+<P> C++ operators are partially supported. Operator overloading exists
+ in Scilab, but a C++ operator is not (in this version) wrapped by SWIG
+ as a Scilab operator, but as a function. It is not automatic, you have
+ to rename each operator (with the instruction <TT>%rename</TT>) with
+ the suitable wrapper name.</P>
+<P> Let's see it with an example of class with two operators <TT>+</TT>
+ and <TT>double()</TT>:</P>
<DIV class="code">
-<PRE>%module zoo
+<PRE>
+%module example
-%{
-#include <string>
-#include <vector>
+%rename(plus) operator +;
+%rename(toDouble) operator double();
-#include "zoo.h"
-%}
+%inline %{
-class Animal
-{
-private:
- typedef std::vector<Animal*> AnimalsType;
- typedef AnimalsType::iterator IterType;
-protected:
- AnimalsType animals;
-protected:
- std::string name_;
+class Complex {
public:
- // Construct an animal with this name
- Animal(const char* name) : name_(name) {}
-
- // Return the animal's name
- const char* get_name() const { return name.c_str(); }
-};
+ Complex(double re, double im) : real(re), imag(im) {};
-class Zoo
-{
-protected:
- std::vector<animal *=""> animals;
-
-public:
- // Construct an empty zoo
- Zoo() {}
-
- /* Create a new animal. */
- static Animal* Zoo::create_animal(const char* name) {
- return new Animal(name);
- }
-
- // Add a new animal to the zoo
- void add_animal(Animal* animal) {
- animals.push_back(animal);
- }
-
- Animal* remove_animal(size_t i) {
- Animal* result = this->animals[i];
- IterType iter = this->animals.begin();
- std::advance(iter, i);
- this->animals.erase(iter);
-
- return result;
- }
-
- // Return the number of animals in the zoo
- size_t get_num_animals() const {
- return animals.size();
- }
-
- // Return a pointer to the ith animal
- Animal* get_animal(size_t i) const {
- return animals[i];
+ Complex operator+(const Complex& other) {
+ double result_real = real + other.real;
+ double result_imaginary = imag + other.imag;
+ return Complex(result_real, result_imaginary);
}
-};</PRE>
+ operator double() { return real; }
+private:
+ double real;
+ double imag;
+};
+
+%}
+</PRE>
</DIV>
-<P>Let's say you SWIG this code and then run IRB:</P>
-<DIV class="code targetlang">
-<PRE>$ <B>irb</B>
-irb(main):001:0> <B>require 'example'</B>
-=> true
+<BR><DIV class="targetlang">
+<PRE>
+--> c1 = new_Complex(3, 7);
-irb(main):002:0> <B>tiger1 = Example::Animal.new("tiger1")</B>
-=> #<Example::Animal:0x2be3820>
+--> c2 = Complex_plus(c, new_Complex(1,1));
-irb(main):004:0> <B>tiger1.get_name()</B>
-=> "tiger1"
+--> Complex_toDouble(c2)
+ ans =
-irb(main):003:0> <B>zoo = Example::Zoo.new()</B>
-=> #<Example::Zoo:0x2be0a60>
+ 4.
+</PRE>
+</DIV>
+<H3><A name="Scilab_wrapping_cpp_namespaces">39.3.14 C++ namespaces</A></H3>
+<P> SWIG is aware of C++ namespaces, but does not use it for wrappers.
+ The module is not broken into submodules, nor do namespace appear in
+ functions names. All the namespaces are all flattened in the module.
+ For example with one namespace <TT>Foo</TT>:</P>
+<DIV class="code">
+<PRE>
+%module example
-irb(main):006:0> <B>zoo.add_animal(tiger)</B>
-=> nil
+%inline %{
-irb(main):007:0> <B>zoo.get_num_animals()</B>
-=> 1
+namespace foo {
+ int fact(int n) {
+ if (n > 1)
+ return n * fact(n-1);
+ else
+ return 1;
+ }
-irb(main):007:0> <B>tiger2 = zoo.remove_animal(0)</B>
-=> #<Example::Animal:0x2bd4a18>
+ struct Vector {
+ double x,y,z;
+ };
+};
-irb(main):008:0> <B>tiger2.get_name()</B>
-=> "tiger1"
+%}
-irb(main):009:0> <B>tiger1.equal?(tiger2)</B>
-=> false
</PRE>
</DIV>
-<P>Pay particular attention to the code <TT>tiger1.equal?(tiger2)</TT>.
- Note that the two Ruby objects are not the same - but they reference
- the same underlying C++ object. This can cause problems. For example:</P>
-<DIV class="code targetlang">
-<PRE>irb(main):010:0> <B>tiger1 = nil</B>
-=> nil
+<P> In Scilab, there is no need to the specify the <TT>Foo</TT>
+ namespace:</P>
+<DIV class="targetlang">
+<PRE>
+--> fact(3)
+ ans =
-irb(main):011:0> <B>GC.start</B>
-=> nil
+ 6.
-irb(main):012:0> <B>tiger2.get_name()</B>
-(irb):12: [BUG] Segmentation fault
+--> v = new_Vector();
+--> Vector_x_set(v, 3.4);
+--> Vector_y_get(v)
+ ans =
+
+ 0.
</PRE>
</DIV>
-<P>After the garbage collector runs, as a result of our call to <TT>
-GC.start</TT>, calling<TT>tiger2.get_name()</TT> causes a segmentation
- fault. The problem is that when <TT>tiger1</TT> is garbage collected,
- it frees the underlying C++ object. Thus, when <TT>tiger2</TT> calls
- the <TT>get_name()</TT> method it invokes it on a destroyed object.</P>
-<P>This problem can be avoided if SWIG enforces a one-to-one mapping
- between Ruby objects and C++ classes. This can be done via the use of
- the <TT>%trackobjects</TT> functionality available in SWIG-1.3.26. and
- later.</P>
-<P>When the <TT>%trackobjects</TT> is turned on, SWIG automatically
- keeps track of mappings between C++ objects and Ruby objects. Note that
- enabling object tracking causes a slight performance degradation. Test
- results show this degradation to be about 3% to 5% when creating and
- destroying 100,000 animals in a row.</P>
-<P>Since <TT>%trackobjects</TT> is implemented as a <TT>%feature</TT>,
- it uses the same name matching rules as other kinds of features (see
- the chapter on <A href="#Customization"> "Customization Features"</A>)
- . Thus it can be applied on a class-by-class basis if needed. To fix
- the example above:</P>
+<P> If your program has more than one namespace, name conflicts can be
+ resolved using <TT>%rename</TT>. For example:</P>
<DIV class="code">
-<PRE>%module example
-
-%{
-#include "example.h"
-%}
-
-<B>/* Tell SWIG that create_animal creates a new object */</B>
-<B>%newobject Zoo::create_animal;</B>
+<PRE>
+%rename(Bar_spam) Bar::spam;
-<B>/* Tell SWIG to keep track of mappings between C/C++ structs/classes. */</B><B>%trackobjects;</B>
+namespace Foo {
+ int spam();
+}
-%include "example.h"</PRE>
+namespace Bar {
+ int spam();
+}
+</PRE>
</DIV>
-<P>When this code runs we see:</P>
-<DIV class="code targetlang">
-<PRE>$ <B>irb</B>
-irb(main):001:0> <B>require 'example'</B>
-=> true
+<P> Note: the <A href="#SWIGPlus_nspace">nspace</A> feature is not
+ supported.</P>
+<H3><A name="Scilab_wrapping_cpp_exceptions">39.3.15 C++ exceptions</A></H3>
+<P> Scilab does not natively support exceptions, but has errors. When an
+ exception is thrown, SWIG catches it, and sets a Scilab error. An error
+ message is displayed in Scilab. For example:</P>
+<DIV class="code">
+<PRE>
+%module example
-irb(main):002:0> <B>tiger1 = Example::Animal.new("tiger1")</B>
-=> #<Example::Animal:0x2be37d8>
+%inline %{
+void throw_exception() throw(char const *) {
+ throw "Bye world !";
+}
+%}
+</PRE>
+</DIV>
+<BR><DIV class="targetlang">
+<PRE>
+-->throw_exception()
+ !--error 999
+SWIG/Scilab: Exception (char const *) occured: Bye world !
+</PRE>
+</DIV>
+<P> Scilab has a <TT>try-catch</TT> mechanism (and a similar instruction
+ <TT>execstr()</TT>) to handle exceptions. It can be used with the <TT>
+lasterror()</TT> function as following:</P>
+<DIV class="targetlang">
+<PRE>
+--> execstr('throw_exception()', 'errcatch');
+ ans =
-irb(main):003:0> <B>zoo = Example::Zoo.new()</B>
-=> #<Example::Zoo:0x2be0a18>
+ 999.
-irb(main):004:0> <B>zoo.add_animal(tiger1)</B>
-=> nil
+--> lasterror()
+ ans =
-irb(main):006:0> <B>tiger2 = zoo.remove_animal(0)</B>
-=> #<Example::Animal:0x2be37d8>
+ SWIG/Scilab: Exception (char const *) occured: Bye world !
+</PRE>
+</DIV>
+<P> If the function has a <TT>throw</TT> exception specification, SWIG
+ can automatically map the exception type and set an appropriate Scilab
+ error message. It works for a few primitive types, and also for STL
+ exceptions (the library <TT>std_except.i</TT> has to be included to get
+ the STL exception support):</P>
+<DIV class="code">
+<PRE>
+%module example
-irb(main):007:0> <B>tiger1.equal?(tiger2)</B>
-=> true
+%include <std_except.i>
-irb(main):008:0> <B>tiger1 = nil</B>
-=> nil
+%inline %{
+void throw_int() throw(int) {
+ throw 12;
+}
-irb(main):009:0> <B>GC.start</B>
-=> nil
+void throw_stl_invalid_arg(int i) throw(std::invalid_argument) {
+ if (i < 0)
+ throw std::invalid_argument("argument is negative.");
+}
+%}
+</PRE>
+</DIV>
+<BR><DIV class="targetlang">
+<PRE>
+--> throw_int();
+ !--error 999
+SWIG/Scilab: Exception (int) occured: 12
-irb(main):010:0> <B>tiger.get_name()</B>
-=> "tiger1"
-irb(main):011:0></PRE>
+-->throw_stl_invalid_arg(-1);
+ !--error 999
+SWIG/Scilab: ValueError: argument is negative.
+</PRE>
</DIV>
-<P>For those who are interested, object tracking is implemented by
- storing Ruby objects in a hash table and keying them on C++ pointers.
- The underlying API is:</P>
-<DIV class="code">
-<PRE>static void SWIG_RubyAddTracking(void* ptr, VALUE object);
-static VALUE SWIG_RubyInstanceFor(void* ptr) ;
-static void SWIG_RubyRemoveTracking(void* ptr);
-static void SWIG_RubyUnlinkObjects(void* ptr);</PRE>
+<P> More complex or custom exception types require specific exception
+ typemaps to be implemented in order to specifically handle a thrown
+ type. See the <A href="#SWIGPlus">SWIG C++ documentation</A> for more
+ details.</P>
+<H3><A name="Scilab_wrapping_cpp_stl">39.3.16 C++ STL</A></H3>
+<P> The Standard Template Library (STL) is partially supported. See <A href="#Scilab_typemaps_stl">
+STL</A> for more details.</P>
+<H2><A name="Scilab_typemaps">39.4 Type mappings and libraries</A></H2>
+<H3><A name="Scilab_typemaps_primitive_types">39.4.1 Default primitive
+ type mappings</A></H3>
+<P> The following table provides the equivalent Scilab type for C/C++
+ primitive types.</P>
+<DIV class="table">
+<TABLE border="1" summary="Scilab default primitive type mappings">
+<TR><TD><B>C/C++ type</B></TD><TD><B>Scilab type</B></TD></TR>
+<TR><TD>bool</TD><TD>boolean</TD></TR>
+<TR><TD>char</TD><TD>string</TD></TR>
+<TR><TD>signed char</TD><TD>double or int8</TD></TR>
+<TR><TD>unsigned char</TD><TD>double or uint8</TD></TR>
+<TR><TD>short</TD><TD>double or int16</TD></TR>
+<TR><TD>unsigned short</TD><TD>double or uint16</TD></TR>
+<TR><TD>int</TD><TD>double or int32</TD></TR>
+<TR><TD>unsigned int</TD><TD>double or uint32</TD></TR>
+<TR><TD>long</TD><TD>double or int32</TD></TR>
+<TR><TD>unsigned long</TD><TD>double or uint32</TD></TR>
+<TR><TD>signed long long</TD><TD>not supported in Scilab 5.x</TD></TR>
+<TR><TD>unsigned long long</TD><TD>not supported in Scilab 5.x</TD></TR>
+<TR><TD>float</TD><TD>double</TD></TR>
+<TR><TD>double</TD><TD>double</TD></TR>
+<TR><TD>char * or char[]</TD><TD>string</TD></TR>
+</TABLE>
</DIV>
-<P>When an object is created, SWIG will automatically call the <TT>
-SWIG_RubyAddTracking</TT> method. Similarly, when an object is deleted,
- SWIG will call the <TT>SWIG_RubyRemoveTracking</TT>. When an object is
- returned to Ruby from C++, SWIG will use the <TT>SWIG_RubyInstanceFor</TT>
- method to ensure a one-to-one mapping from Ruby to C++ objects. Last,
- the <TT>RubyUnlinkObjects</TT> method unlinks a Ruby object from its
- underlying C++ object.</P>
-<P>In general, you will only need to use the <TT>SWIG_RubyInstanceFor</TT>
-, which is required for implementing mark functions as shown below.
- However, if you implement your own free functions (see below) you may
- also have to call the <TT>SWIG_RubyRemoveTracking</TT> and <TT>
-RubyUnlinkObjects</TT> methods.</P>
-<H3><A name="Ruby_nn61"></A>36.10.4 Mark Functions</H3>
-<P>With a bit more testing, we see that our class library still has
- problems. For example:</P>
-<DIV class="targetlang">
-<PRE>$ <B>irb</B>
-irb(main):001:0> <B>require 'example'</B>
-=> true
+<P> Notes:</P>
+<UL>
+<LI>In Scilab the <TT>double</TT> type is far more used than any integer
+ type. This is why integer values (<TT>int32</TT>, <TT>uint32</TT>, ...)
+ are automatically converted to Scilab <TT>double</TT> values when
+ marshalled from C into Scilab. Additionally on input to a C function,
+ Scilab <TT>double</TT> values are converted into the related integer
+ type.</LI>
+<LI> When an integer is expected, if the input is a double, the value
+ must be an integer, i.e. it must not have any decimal part, otherwise a
+ SWIG value error occurs.</LI>
+<LI> In SWIG for Scilab 5.x, the <TT>long long</TT> type is not
+ supported, since Scilab 5.x does not have a 64-bit integer type. The
+ default behaviour is for SWIG to generate code that will give a runtime
+ error if <TT>long long</TT> type arguments are used from Scilab.</LI>
+</UL>
+<H3><A name="Scilab_typemaps_arrays">39.4.2 Arrays</A></H3>
+<P> Typemaps are available by default for arrays. Primitive type arrays
+ are automatically converted to/from Scilab matrices. Typemaps are also
+ provided to handle members of a struct or class that are arrays.</P>
+<P> In input, the matrix is usually one-dimensional (it can be either a
+ row or column vector). But it can also be a two-dimensional matrix.
+ Warning: in Scilab, the values are column-major ordered, unlike in C,
+ which is row-major ordered.</P>
+<P> The type mappings used for arrays is the same for primitive types,
+ described <A href="#Scilab_typemaps_primitive_types">earlier</A>. This
+ means that, if needed, a Scilab <TT>double</TT> vector is converted in
+ input into the related C integer array and this C integer array is
+ automatically converted on output into a Scilab <TT>double</TT> vector.
+ Note that unlike scalars, no control is done for arrays when a <TT>
+double</TT> is converted into an integer.</P>
+<P> The following example illustrates all this:</P>
+<DIV class="code">
+<PRE>
+%module example
-irb(main):002:0> tiger1 = <B>Example::Animal.new("tiger1")</B>
-=> #<Example::Animal:0x2bea6a8>
+%#include <stdio.h>
-irb(main):003:0> zoo = <B>Example::Zoo.new()</B>
-=> #<Example::Zoo:0x2be7960>
+%inline %{
-irb(main):004:0> <B>zoo.add_animal(tiger1)</B>
-=> nil
+void printArray(int values[], int len) {
+ int i = 0;
+ for (i = 0; i < len; i++) {
+ printf("%s %d %s", i==0?"[":"", values[i], i==len-1?"]\n":"");
+ }
+}
+%}
+</PRE>
+</DIV>
+<BR><DIV class="targetlang">
+<PRE>
+--> printArray([0 1 2 3], 4)
+[ 0 1 2 3 ]
-irb(main):007:0> <B>tiger1 = nil</B>
-=> nil
+--> printArray([0.2; -1.8; 2; 3.7], 4)
+[ 0 -1 2 3 ]
-irb(main):007:0> <B>GC.start</B>
-=> nil
+--> printArray([0 1; 2 3], 4)
+[ 0 2 1 3 ]
-irb(main):005:0> <B>tiger2 = zoo.get_animal(0)</B>
-(irb):12: [BUG] Segmentation fault</PRE>
+--> printArray([0; 1; 2; 3], 4)
+[ 0 1 2 3 ]
+</PRE>
</DIV>
-<P>The problem is that Ruby does not know that the <TT>zoo</TT> object
- contains a reference to a Ruby object. Thus, when Ruby garbage collects
- <TT>tiger1</TT> it frees the underlying C++ object.</P>
-<P>This can be fixed by implementing a <TT>mark</TT> function as
- described above in the <A href="#Ruby_nn52">Mark and Sweep Garbage
- Collector</A> section. You can specify a mark function by using the <TT>
-%markfunc</TT> directive. Since the <TT>%markfunc</TT> directive is
- implemented using SWIG's' "features" mechanism it uses the same name
- matching rules as other kinds of features (see the chapter on <A href="#Customization">
-"Customization Features"</A> for more details).</P>
-<P>A <TT>mark</TT> function takes a single argument, which is a pointer
- to the C++ object being marked; it should, in turn, call <TT>
-rb_gc_mark()</TT> for any instances that are reachable from the current
- object. The mark function for our <TT>Zoo</TT> class should therefore
- loop over all of the C++ animal objects in the zoo object, look up
- their Ruby object equivalent, and then call <TT>rb_gc_mark()</TT>. One
- possible implementation is:</P>
+<H3><A name="Scilab_typemaps_pointer-to-pointers">39.4.3
+ Pointer-to-pointers</A></H3>
+<P> There are no specific typemaps for pointer-to-pointers, they are are
+ mapped as pointers in Scilab.</P>
+<P> Pointer-to-pointers are sometimes used to implement matrices in C.
+ The following is a an example of this:</P>
<DIV class="code">
-<PRE>%module example
-
-%{
-#include "example.h"
-%}
-
-/* Keep track of mappings between C/C++ structs/classes
- and Ruby objects so we can implement a mark function. */
-<B>%trackobjects;</B>
+<PRE>
+%module example
+%inline %{
-/* Specify the mark function */
-<B>%markfunc Zoo "mark_Zoo";</B>
+// Returns the matrix [1 2; 3 4];
+double **create_matrix() {
+ double **M;
+ int i;
+ M = (double **) malloc(2 * sizeof(double *));
+ for (i = 0; i < 2; i++) {
+ M[i] = (double *) malloc(2 * sizeof(double));
+ M[i][0] = 2 * i + 1;
+ M[i][1] = 2 * i + 2;
+ }
+ return M;
+}
-%include "example.h"
+// Gets the item M(i,j) value
+double get_matrix(double **M, int i, int j) {
+ return M[i][j];
+}
-%header %{
+// Sets the item M(i,j) value to be val
+void set_matrix(double **M, int i, int j, double val) {
+ M[i][j] = val;
+}
-static void mark_Zoo(void* ptr) {
- Zoo* zoo = (Zoo*) ptr;
-
- /* Loop over each object and tell the garbage collector
- that we are holding a reference to them. */
- int count = zoo->get_num_animals();
-
- for(int i = 0; i < count; ++i) {
- Animal* animal = zoo->get_animal(i);
- VALUE object = SWIG_RubyInstanceFor(animal);
-
- if (object != Qnil) {
- rb_gc_mark(object);
+// Prints a matrix (2,2) to console
+void print_matrix(double **M, int nbRows, int nbCols) {
+ int i, j;
+ for (i = 0; i < 2; i++) {
+ for (j = 0; j < 2; j++) {
+ printf("%3g ", M[i][j]);
}
+ printf("\n");
}
}
-%}</PRE>
+
+%}
+</PRE>
</DIV>
-<P> Note the <TT>mark</TT> function is dependent on the <TT>
-SWIG_RUBY_InstanceFor</TT> method, and thus requires that <TT>
-%trackobjects</TT> is enabled. For more information, please refer to the
- track_object.i test case in the SWIG test suite.</P>
-<P>When this code is compiled we now see:</P>
+<P> These functions are used like this in Scilab:</P>
<DIV class="targetlang">
-<PRE>$ <B>irb
-</B>irb(main):002:0> <B>tiger1=Example::Animal.new("tiger1")</B>
-=> #<Example::Animal:0x2be3bf8>
+<PRE>
+--> m = create_matrix();
-irb(main):003:0> <B>Example::Zoo.new()</B>
-=> #<Example::Zoo:0x2be1780>
+--> print_matrix(m);
+ 1. 2.
+ 3. 4.
-irb(main):004:0> <B>zoo = Example::Zoo.new()</B>
-=> #<Example::Zoo:0x2bde9c0>
+--> set_matrix(m, 1, 1, 5.);
-irb(main):005:0> <B>zoo.add_animal(tiger1)</B>
-=> nil
+--> get_matrix(m, 1, 1)
+ ans =
-irb(main):009:0> <B>tiger1 = nil</B>
-=> nil
+ 5.
+</PRE>
+</DIV>
+<H3><A name="Scilab_typemaps_matrices">39.4.4 Matrices</A></H3>
+<P> The <TT>matrix.i</TT> library provides a set of typemaps which can
+ be useful when working with one-dimensional and two-dimensional
+ matrices.</P>
+<P> In order to use this library, just include it in the interface file:</P>
+<DIV class="code">
+<PRE>
+ %include <matrix.i>
+</PRE>
+</DIV>
+<P> Several typemaps are available for the common Scilab matrix types:</P>
+<UL>
+<LI><TT>double</TT></LI>
+<LI><TT>int</TT></LI>
+<LI><TT>char *</TT></LI>
+<LI><TT>bool</TT></LI>
+</UL>
+<P> For example: for a matrix of <TT>int</TT>, we have the typemaps, for
+ input:</P>
+<UL>
+<LI><TT>(int *IN, int IN_ROWCOUNT, int IN_COLCOUNT)</TT></LI>
+<LI><TT>(int IN_ROWCOUNT, int IN_COLCOUNT, int *IN)</TT></LI>
+<LI><TT>(int *IN, int IN_SIZE)</TT></LI>
+<LI><TT>(int IN_SIZE, int *IN)</TT></LI>
+</UL>
+<P> and output:</P>
+<UL>
+<LI><TT>(int **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)</TT></LI>
+<LI><TT>(int *OUT_ROWCOUNT, int *OUT_COLCOUNT, int **OUT)</TT></LI>
+<LI><TT>(int **OUT, int *OUT_SIZE)</TT></LI>
+<LI><TT>(int *OUT_SIZE, int **OUT)</TT></LI>
+</UL>
+<P> They marshall a Scilab matrix type into the appropriate 2 or 3 C
+ parameters. The following is an example using the typemaps in this
+ library:</P>
+<DIV class="code">
+<PRE>
+%module example
-irb(main):010:0> <B>GC.start</B>
-=> nil
-irb(main):014:0> <B>tiger2 = zoo.get_animal(0)</B>
-=> #<Example::Animal:0x2be3bf8>
+%include <matrix.i>
-irb(main):015:0> <B>tiger2.get_name()</B>
-=> "tiger1"
-irb(main):016:0></PRE>
+%apply (int *IN, int IN_ROWCOUNT, int IN_COLCOUNT) { (int *matrix, int matrixNbRow, int matrixNbCol) };
+%apply (int **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT) { (int **outMatrix, int *outMatrixNbRow, int *outMatrixNbCol) };
+
+%inline %{
+
+void absolute(int *matrix, int matrixNbRow, int matrixNbCol,
+ int **outMatrix, int *outMatrixNbRow, int *outMatrixNbCol) {
+ int i, j;
+ *outMatrixNbRow = matrixNbRow;
+ *outMatrixNbCol = matrixNbCol;
+ *outMatrix = malloc(matrixNbRow * matrixNbCol * sizeof(int));
+ for (i=0; i < matrixNbRow * matrixNbCol; i++) {
+ (*outMatrix)[i] = matrix[i] > 0 ? matrix[i]:-matrix[i];
+ }
+}
+
+%}
+</PRE>
</DIV>
-<P>This code can be seen in swig/examples/ruby/mark_function.</P>
-<H3><A name="Ruby_nn62"></A>36.10.5 Free Functions</H3>
-<P>By default, SWIG creates a "free" function that is called when a Ruby
- object is garbage collected. The free function simply calls the C++
- object's destructor.</P>
-<P>However, sometimes an appropriate destructor does not exist or
- special processing needs to be performed before the destructor is
- called. Therefore, SWIG allows you to manually specify a "free"
- function via the use of the <TT>%freefunc</TT> directive. The <TT>
-%freefunc</TT> directive is implemented using SWIG's' "features"
- mechanism and so the same name matching rules used for other kinds of
- features apply (see the chapter on <A href="#Customization">
-"Customization Features"</A>) for more details).</P>
-<P>IMPORTANT ! - If you define your own free function, then you must
- ensure that you call the underlying C++ object's destructor. In
- addition, if object tracking is activated for the object's class, you
- must also call the <TT>SWIG_RubyRemoveTracking</TT> function (of course
- call this before you destroy the C++ object). Note that it is harmless
- to call this method if object tracking if off so it is advised to
- always call it.</P>
-<P>Note there is a subtle interaction between object ownership and free
- functions. A custom defined free function will only be called if the
- Ruby object owns the underlying C++ object. This also to Ruby objects
- which are created, but then transfer ownership to C++ objects via the
- use of the <TT>disown</TT> typemap described above.</P>
-<P>To show how to use the <TT>%freefunc</TT> directive, let's slightly
- change our example. Assume that the zoo object is responsible for
- freeing animal that it contains. This means that the <TT>
-Zoo::add_animal</TT> function should be marked with a <TT>DISOWN</TT>
- typemap and the destructor should be updated as below:</P>
+<BR><DIV class="targetlang">
+<PRE>
+--> absolute([-0 1 -2; 3 4 -5])
+ ans =
+
+ 0. 1. 2.
+ 3. 4. 5.
+</PRE>
+</DIV>
+<P> The remarks made earlier for arrays also apply here:</P>
+<UL>
+<LI>The values of matrices in Scilab are column-major orderered,</LI>
+<LI>There is no control while converting <TT>double</TT> values to
+ integers, <TT>double</TT> values are truncated without any checking or
+ warning.</LI>
+</UL>
+<H3><A name="Scilab_typemaps_stl">39.4.5 STL</A></H3>
+<P> The STL library wraps some containers defined in the STL (Standard
+ Template Library), so that they can be manipulated in Scilab. This
+ library also provides the appropriate typemaps to use the containers in
+ functions and variables.</P>
+<P> The list of wrapped sequence containers are:</P>
+<UL>
+<LI><TT>std::vector</TT></LI>
+<LI><TT>std::list</TT></LI>
+<LI><TT>std::deque</TT></LI>
+</UL>
+<P> And associative containers are:</P>
+<UL>
+<LI><TT>std::set</TT></LI>
+<LI><TT>std::multiset</TT></LI>
+</UL>
+<P> Typemaps are available for the following container types:</P>
+<UL>
+<LI><TT>double</TT></LI>
+<LI><TT>float</TT></LI>
+<LI><TT>int</TT></LI>
+<LI><TT>string</TT></LI>
+<LI><TT>bool</TT></LI>
+<LI><TT>pointer</TT></LI>
+</UL>
+<P> Containers of other item types are not supported. Using them does
+ not break compilation, but provokes a runtime error. Containers of enum
+ are not supported yet.</P>
+<P> In order to use the STL, the library must first be included in the
+ SWIG interface file:</P>
+<DIV class="code">
+<PRE>
+%include <stl.i>
+</PRE>
+</DIV>
+<P>Then for each container used, the appropriate template must be
+ instantiated, in the <TT>std</TT> namespace:<DIV class="code">
+<PRE>
+namespace std {
+ %template(IntVector) vector<int>;
+ %template(DoubleVector) vector<double>;
+}
+</PRE>
+</DIV></P>
+<P> Additionally, the module initialization function has to be executed
+ first in Scilab, so that all the types are known to Scilab. See the <A href="#Scilab_module_initialization">
+Module initialization</A> section for more details.</P>
+<P> Because in Scilab matrices exist for basic types only, a sequence
+ container of pointers is mapped to a Scilab list. For other item types
+ (double, int, string...) the sequence container is mapped to a Scilab
+ matrix.</P>
+<P> The first example below shows how to create a vector (of <TT>int</TT>
+) in Scilab, add some values to the vector and pass it as an argument of
+ a function. It also shows, thanks to the typemaps, that we can also
+ pass a Scilab matrix of values directly into the function:</P>
<DIV class="code">
-<PRE>Zoo::~Zoo() {
- IterType iter = this->animals.begin();
- IterType end = this->animals.end();
+<PRE>
+%module example
- for(iter; iter != end; ++iter) {
- Animal* animal = *iter;
- delete animal;
- }
-}</PRE>
+%include <stl.i>
+
+namespace std {
+ %template(IntVector) vector<int>;
+}
+
+%{
+#include <numeric>
+%}
+
+%inline %{
+
+double average(std::vector<int> v) {
+ return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
+}
+
+%}
+</PRE>
</DIV>
-<P>When we use these objects in IRB we see:</P>
-<DIV class="code targetlang">
-<PRE class="targetlang"><B>$irb</B>
-irb(main):002:0> <B>require 'example'</B>
-=> true
+<BR><DIV class="targetlang">
+<PRE>
+--> example_Init();
-irb(main):003:0> <B>zoo = Example::Zoo.new()</B>
-=> #<Example::Zoo:0x2be0fe8>
+--> v = new_IntVector();
-irb(main):005:0> <B>tiger1 = Example::Animal.new("tiger1")</B>
-=> #<Example::Animal:0x2bda760>
+--> for i = 1:4
+--> IntVector_push_back(v, i);
+--> end;
-irb(main):006:0> <B>zoo.add_animal(tiger1)</B>
-=> nil
+--> average(v)
+ ans =
-irb(main):007:0> <B>zoo = nil</B>
-=> nil
+ 2.5
-irb(main):008:0> <B>GC.start</B>
-=> nil
+--> average([0 1 2 3])
+ ans =
-irb(main):009:0> <B>tiger1.get_name()</B>
-(irb):12: [BUG] Segmentation fault
+ 2.5
+
+--> delete_IntVector();
</PRE>
</DIV>
-<P>The error happens because the C++ <TT>animal</TT> object is freed
- when the <TT>zoo</TT> object is freed. Although this error is
- unavoidable, we can at least prevent the segmentation fault. To do this
- requires enabling object tracking and implementing a custom free
- function that calls the <TT>SWIG_RubyUnlinkObjects</TT> function for
- each animal object that is destroyed. The <TT>SWIG_RubyUnlinkObjects</TT>
- function notifies SWIG that a Ruby object's underlying C++ object is no
- longer valid. Once notified, SWIG will intercept any calls from the
- existing Ruby object to the destroyed C++ object and raise an
- exception.</P>
+<P> In the second example, a set of struct (<TT>Person</TT>) is wrapped.
+ A function performs a search in this set, and returns a subset. As one
+ can see, the result in Scilab is a list of pointers:</P>
<DIV class="code">
-<PRE>%module example
+<PRE>
+%module example
+
+%include <stl.i>
%{
-#include "example.h"
+#include <string>
%}
-/* Specify that ownership is transferred to the zoo
- when calling add_animal */
-%apply SWIGTYPE *DISOWN { Animal* animal };
+%inline %{
-/* Track objects */
-%trackobjects;
+struct Person {
+ Person(std::string _name, int _age) : name(_name), age(_age) {};
+ std::string name;
+ int age;
+};
+typedef Person * PersonPtr;
-/* Specify the mark function */
-%freefunc Zoo "free_Zoo";
+%}
-%include "example.h"
+namespace std {
+ %template(PersonPtrSet) set<PersonPtr>;
+}
-%header %{
- static void free_Zoo(void* ptr) {
- Zoo* zoo = (Zoo*) ptr;
+%inline %{
- /* Loop over each animal */
- int count = zoo->get_num_animals();
+std::set<PersonPtr> findPersonsByAge(std::set<PersonPtr> persons, int minAge, int maxAge) {
+ std::set<PersonPtr> foundPersons;
+ for (std::set<PersonPtr>::iterator it = persons.begin(); it != persons.end(); it++) {
+ if (((*it)->age >= minAge) && ((*it)->age <= maxAge)) {
+ foundPersons.insert(*it);
+ }
+ }
+ return foundPersons;
+}
- for(int i = 0; i < count; ++i) {
- /* Get an animal */
- Animal* animal = zoo->get_animal(i);
+%}
+</PRE>
+</DIV>
+<BR><DIV class="targetlang">
+<PRE>
+--> example_Init();
- /* Unlink the Ruby object from the C++ object */
- SWIG_RubyUnlinkObjects(animal);
+--> joe = new_Person("Joe", 25);
+--> susan = new_Person("Susan", 32);
+--> bill = new_Person("Bill", 50);
- /* Now remove the tracking for this animal */
- SWIG_RubyRemoveTracking(animal);
- }
+--> p = new_PersonPtrSet();
+--> PersonPtrSet_insert(p, susan);
+--> PersonPtrSet_insert(p, joe);
+--> PersonPtrSet_insert(p, bill);
- /* Now call SWIG_RubyRemoveTracking for the zoo */
- SWIG_RubyRemoveTracking(ptr);
- /* Now free the zoo which will free the animals it contains */
- delete zoo;
- }
-%} </PRE>
-</DIV>
-<P>Now when we use these objects in IRB we see:</P>
-<DIV class="code targetlang">
-<PRE><B>$irb</B>
-irb(main):002:0> <B>require 'example'</B>
-=> true
+--> l = findPersonsByAge(p, 20, 40);
-irb(main):003:0> <B>zoo = Example::Zoo.new()</B>
-=> #<Example::Zoo:0x2be0fe8>
+--> size(l)
+ ans =
-irb(main):005:0> <B>tiger1 = Example::Animal.new("tiger1")</B>
-=> #<Example::Animal:0x2bda760>
+ 2.
-irb(main):006:0> <B>zoo.add_animal(tiger1)</B>
-=> nil
+--> Person_name_get(l(1))
+ans =
-irb(main):007:0> <B>zoo = nil</B>
-=> nil
+ Susan
-irb(main):008:0> <B>GC.start</B>
-=> nil
+--> Person_name_get(l(2))
+ ans =
-irb(main):009:0> <B>tiger1.get_name()</B>
-RuntimeError: This Animal * already released
- from (irb):10:in `get_name'
- from (irb):10
-irb(main):011:0></PRE>
+ Joe
+
+--> delete_PersonPtrSet(p);
+</PRE>
</DIV>
-<P>Notice that SWIG can now detect the underlying C++ object has been
- freed, and thus raises a runtime exception.</P>
-<P>This code can be seen in swig/examples/ruby/free_function.</P>
-<H3><A name="Ruby_nn63"></A>36.10.6 Embedded Ruby and the C++ Stack</H3>
-<P>As has been said, the Ruby GC runs and marks objects before its sweep
- phase. When the garbage collector is called, it will also try to mark
- any Ruby objects (VALUE) it finds in the machine registers and in the
- C++ stack.</P>
-<P>The stack is basically the history of the functions that have been
- called and also contains local variables, such as the ones you define
- whenever you do inside a function:</P>
-<DIV class="diagram">VALUE obj;</DIV>
-<P>For ruby to determine where its stack space begins, during
- initialization a normal Ruby interpreter will call the ruby_init()
- function which in turn will call a function called Init_stack or
- similar. This function will store a pointer to the location where the
- stack points at that point in time.</P>
-<P>ruby_init() is presumed to always be called within the main()
- function of your program and whenever the GC is called, ruby will
- assume that the memory between the current location in memory and the
- pointer that was stored previously represents the stack, which may
- contain local (and temporary) VALUE ruby objects. Ruby will then be
- careful not to remove any of those objects in that location.</P>
-<P>So far so good. For a normal Ruby session, all the above is
- completely transparent and magic to the extensions developer.</P>
-<P>However, with an embedded Ruby, it may not always be possible to
- modify main() to make sure ruby_init() is called there. As such,
- ruby_init() will likely end up being called from within some other
- function. This can lead Ruby to measure incorrectly where the stack
- begins and can result in Ruby incorrectly collecting those temporary
- VALUE objects that are created once another function is called. The end
- result: random crashes and segmentation faults.</P>
-<P>This problem will often be seen in director functions that are used
- for callbacks, for example.</P>
-<P>To solve the problem, SWIG can now generate code with director
- functions containing the optional macros SWIG_INIT_STACK and
- SWIG_RELEASE_STACK. These macros will try to force Ruby to reinitiliaze
- the beginning of the stack the first time a director function is
- called. This will lead Ruby to measure and not collect any VALUE
- objects defined from that point on.</P>
-<P>To mark functions to either reset the ruby stack or not, you can use:</P>
-<DIV class="code">
+<H2><A name="Scilab_module_initialization">39.5 Module initialization</A>
+</H2>
+<P> The wrapped module contains an initialization function to:</P>
+<UL>
+<LI>initialize the SWIG runtime, needed for pointer type tracking or
+ when working with the STL</LI>
+<LI>initialize the module constants and enumerations declared with <TT>
+%scilabconst()</TT></LI>
+</UL>
+<P> This initialization function should be executed at the start of a
+ script, before the wrapped library has to be used.</P>
+<P> The function has the name of the module suffixed by <TT>_Init</TT>.
+ For example, to initialize the module <TT>example</TT>:</P>
+<DIV class="targetlang">
<PRE>
-%initstack Class::memberfunction; // only re-init the stack in this director method
-%ignorestack Class::memberfunction; // do not re-init the stack in this director method
-%initstack Class; // init the stack on all the methods of this class
-%initstack; // all director functions will re-init the stack
+--> example_Init();
</PRE>
-</DIV><HR NOSHADE>
-<H1><A name="Tcl"></A>37 SWIG and Tcl</H1>
+</DIV>
+<H2><A name="Scilab_building_modes">39.6 Building modes</A></H2>
+<P> The mechanism to load an external module in Scilab is called<I>
+ Dynamic Link</I> and works with dynamic modules (or shared libraries, <TT>
+.so</TT> files).</P>
+<P> To produce a dynamic module, when generating the wrapper, there are
+ two possibilities, or build modes:</P>
+<UL>
+<LI>the <TT>nobuilder</TT> mode, this is the default mode in SWIG. The
+ user is responsible of the build.</LI>
+<LI>the <TT>builder</TT> mode. In this mode, Scilab is responsible of
+ building.</LI>
+</UL>
+<H3><A name="Scilab_building_modes_nobuilder_mode">39.6.1 No-builder
+ mode</A></H3>
+<P> In this mode, used by default, SWIG generates the wrapper sources,
+ which have to be manually compiled and linked. A loader script <TT>
+loader.sce</TT> is also produced, this one is executed further in Scilab
+ to load the module.</P>
+<P> This mode is the best option to use when you have to integrate the
+ module build into a larger build process.</P>
+<H3><A name="Scilab_building_modes_builder_mode">39.6.2 Builder mode</A></H3>
+<P> In this mode, in addition to the wrapper sources, SWIG produces a
+ builder Scilab script (<TT>builder.sce</TT>), which is executed in
+ Scilab to build the module. In a few words, the Scilab <TT>ilib_build()</TT>
+ command is used, which produces the shared library file, and the loader
+ script <TT>loader.sce</TT> (and also a cleaner script <TT>cleaner.sce</TT>
+).</P>
+<P> An advantage of this mode is that it hides all the complexity of the
+ build and other platform issues. Also it allows the module to conform
+ to a Scilab external module convention which is that an external module
+ should be simply built by calling a builder script.</P>
+<P> The builder mode is activated with the <TT>-builder</TT> SWIG
+ option. In this mode, the following SWIG options may be used to setup
+ the build:</P>
+<UL>
+<LI><TT><B>-buildersources</B></TT>: to add sources to the build
+ (several files must be separated by a comma)</LI>
+<LI><TT><B>-buildercflags</B></TT>: to add flags to the builder compiler
+ flags, for example to set library dependencies include paths</LI>
+<LI><TT><B>-builderldflags</B></TT>: to add flags to the linker flags,
+ for example to set library dependency names and paths</LI>
+</UL>
+<P> Let's give an example how to build a module <TT>example</TT>,
+ composed of two sources, and using a library dependency:</P>
+<UL>
+<LI>the sources are <TT>baa1.c</TT> and <TT>baa2.c</TT> (and are stored
+ in in the current directory)</LI>
+<LI>the library is <TT>libfoo</TT> in <TT>/opt/foo</TT> (headers stored
+ in <TT>/opt/foo/include</TT>, and shared library in <TT>/opt/foo/lib</TT>
+)</LI>
+</UL>
+<P> The command is:</P>
+<DIV class="shell">
+<PRE>
+$ swig -scilab -builder -buildercflags -I/opt/foo/include -builderldflags "-L/opt/foo/lib -lfoo" -buildersources baa1.cxx,baa2.cxx example.i
+</PRE>
+</DIV>
+<H2><A name="Scilab_generated_scripts">39.7 Generated scripts</A></H2>
+<P> In this part we give some details about the generated Scilab
+ scripts.</P>
+<H3><A name="Scilab_generated_scripts_builder_script">39.7.1 Builder
+ script</A></H3>
+<P> <TT>builder.sce</TT> is the name of the builder script generated by
+ SWIG in <TT>builder</TT> mode. It contains code like this:</P>
+<DIV class="code">
+<PRE>
+ilib_name = "examplelib";
+files = ["example_wrap.c"];
+libs = [];
+table = ["fact","_wrap_fact";"Foo_set","_wrap_Foo_set";"Foo_get","_wrap_Foo_get";];
+ilib_build(ilib_name,table,files,libs);
+</PRE>
+</DIV>
+<P> <TT>ilib_build(lib_name,table,files,libs)</TT> is used to create
+ shared libraries, and to generate a loader file used to dynamically
+ load the shared library into Scilab.</P>
+<UL>
+<LI><TT><B>ilib_name</B></TT>: a character string, the generic name of
+ the library without path and extension.</LI>
+<LI><TT><B>files</B></TT>: string matrix containing objects files needed
+ for shared library creation.</LI>
+<LI><TT><B>libs</B></TT>: string matrix containing extra libraries
+ needed for shared library creation.</LI>
+<LI><TT><B>table</B></TT>: two column string matrix containing a table
+ of pairs of 'scilab function name', 'C function name'.</LI>
+</UL>
+<H3><A name="Scilab_generated_scripts_loader_script">39.7.2 Loader
+ script</A></H3>
+<P> The loader script is used to load in Scilab all the module
+ functions. When loaded, these functions can be used as other Scilab
+ functions.</P>
+<P> The loader script <TT>loader.sce</TT> contains code similar to:</P>
+<DIV class="code">
+<PRE>
+// ------------------------------------------------------
+// generated by builder.sce: Please do not edit this file
+// ------------------------------------------------------
+
+libexamplelib_path = get_file_path('loader.sce');
+list_functions = [ 'fact';
+ 'Foo_set';
+ 'Foo_get';
+];
+addinter(libexamplelib_path+'/libexamplelib.so','libexamplelib',list_functions);
+// remove temp. variables on stack
+clear libexamplelib_path;
+clear list_functions;
+clear get_file_path;
+// ------------------------------------------------------
+</PRE>
+</DIV>
+<P> <TT>addinter(files,spname,fcts)</TT> performs dynamic linking of a
+ compiled C interface function.</P>
+<UL>
+<LI><TT><B>files</B></TT>: a character string or a vector of character
+ strings defining the object files (containing the C interface
+ functions) to link with.</LI>
+<LI><TT><B>spname</B></TT>: a character string. Name of interface
+ routine entry point.</LI>
+<LI><TT><B>fcts</B></TT>: vector of character strings. The name of new
+ Scilab function.</LI>
+</UL>
+<H2><A name="Scilab_other_resources">39.8 Other resources</A></H2>
+<UL>
+<LI>Example use cases can be found in the <TT>Examples/scilab</TT>
+ directory.</LI>
+<LI>The test suite in the <TT>Examples/test-suite/scilab</TT> can be
+ another source of useful use cases.</LI>
+<LI>The <A href="http://help.scilab.org/docs/5.5.0/en_US/api_scilab.html">
+Scilab API</A> is used in the generated code and is a useful reference
+ when examining the output.</LI>
+<LI>This <A href="http://wiki.scilab.org/howto/Create%20a%20toolbox">
+guide</A> describes the Scilab external modules structure and files, in
+ particular the files that are generated by SWIG for Scilab.</LI>
+</UL>
+<HR NOSHADE>
+<H1><A name="Tcl">40 SWIG and Tcl</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
<P> This chapter discusses SWIG's support of Tcl. SWIG currently
requires Tcl 8.0 or a later release. Earlier releases of SWIG supported
Tcl 7.x, but this is no longer supported.</P>
-<H2><A name="Tcl_nn2"></A>37.1 Preliminaries</H2>
+<H2><A name="Tcl_nn2">40.1 Preliminaries</A></H2>
<P> To build a Tcl module, run SWIG using the <TT>-tcl</TT> option :</P>
<DIV class="code">
<PRE>
that contains all of the code needed to build a Tcl extension module.
To finish building the module, you need to compile this file and link
it with the rest of your program.</P>
-<H3><A name="Tcl_nn3"></A>37.1.1 Getting the right header files</H3>
+<H3><A name="Tcl_nn3">40.1.1 Getting the right header files</A></H3>
<P> In order to compile the wrapper code, the compiler needs the <TT>
tcl.h</TT> header file. This file is usually contained in the directory</P>
<DIV class="code">
version number attached to it. If this is the case, you should probably
make a symbolic link so that <TT>tcl.h</TT> points to the correct
header file.</P>
-<H3><A name="Tcl_nn4"></A>37.1.2 Compiling a dynamic module</H3>
+<H3><A name="Tcl_nn4">40.1.2 Compiling a dynamic module</A></H3>
<P> The preferred approach to building an extension module is to compile
it into a shared object file or DLL. Assuming you have code you need to
link to in a file called <TT>example.c</TT>, you will need to compile
<DIV class="code">
<PRE>
$ swig -tcl example.i
-$ gcc -c example.c
-$ gcc -c example_wrap.c -I/usr/local/include
+$ gcc -fPIC -c example.c
+$ gcc -fPIC -c example_wrap.c -I/usr/local/include
$ gcc -shared example.o example_wrap.o -o example.so
</PRE>
</DIV>
", the name of the corresponding object file should be "<TT>example.so</TT>
". The name of the module is specified using the <TT>%module</TT>
directive or the <TT>-module</TT> command line option.</P>
-<H3><A name="Tcl_nn5"></A>37.1.3 Static linking</H3>
+<H3><A name="Tcl_nn5">40.1.3 Static linking</A></H3>
<P> An alternative approach to dynamic linking is to rebuild the Tcl
interpreter with your extension module added to it. In the past, this
approach was sometimes necessary due to limitations in dynamic loading
$ gcc example.c example_wrap.c \
-Xlinker -export-dynamic \
-DHAVE_CONFIG_H -I/usr/local/include/ \
- -L/usr/local/lib -ltcl -lm -ldl \
- -o mytclsh
+ -L/usr/local/lib -ltcl -lm -ldl \
+ -o mytclsh
</PRE>
</DIV>
performance gained by static linking tends to be rather minimal in most
situations (and quite frankly not worth the extra hassle in the opinion
of this author).</P>
-<H3><A name="Tcl_nn6"></A>37.1.4 Using your module</H3>
+<H3><A name="Tcl_nn6">40.1.4 Using your module</A></H3>
<P> To use your module, simply use the Tcl <TT>load</TT> command. If all
goes well, you will be able to this:</P>
<DIV class="code">
<P> Finally, you can use a command such as <TT>ldconfig</TT> to add
additional search paths to the default system configuration (this
requires root access and you will need to read the man pages).</P>
-<H3><A name="Tcl_nn7"></A>37.1.5 Compilation of C++ extensions</H3>
+<H3><A name="Tcl_nn7">40.1.5 Compilation of C++ extensions</A></H3>
<P> Compilation of C++ extensions has traditionally been a tricky
problem. Since the Tcl interpreter is written in C, you need to take
steps to make sure C++ is properly initialized and that modules are
<DIV class="code">
<PRE>
% swig -c++ -tcl example.i
-% g++ -c example.cxx
-% g++ -c example_wrap.cxx -I/usr/local/include
+% g++ -fPIC -c example.cxx
+% g++ -fPIC -c example_wrap.cxx -I/usr/local/include
% g++ -shared example.o example_wrap.o -o example.so
</PRE>
</DIV>
<DIV class="code">
<PRE>
% swig -c++ -tcl example.i
-% CC -c example.cxx
-% CC -c example_wrap.cxx -I/usr/local/include
+% CC -KPIC -c example.cxx
+% CC -KPIC -c example_wrap.cxx -I/usr/local/include
% CC -G example.o example_wrap.o -L/opt/SUNWspro/lib -o example.so -lCrun
</PRE>
</DIV>
you will need to take steps to avoid segmentation faults and other
erratic program behavior. If working with lots of software components,
you might want to investigate using a more formal standard such as COM.</P>
-<H3><A name="Tcl_nn8"></A>37.1.6 Compiling for 64-bit platforms</H3>
+<H3><A name="Tcl_nn8">40.1.6 Compiling for 64-bit platforms</A></H3>
<P> On platforms that support 64-bit applications (Solaris, Irix, etc.),
special care is required when building extension modules. On these
machines, 64-bit applications are compiled and linked using a different
that software. This may prevent the use of 64-bit extensions. It may
also introduce problems on platforms that support more than one linking
standard (e.g., -o32 and -n32 on Irix).</P>
-<H3><A name="Tcl_nn9"></A>37.1.7 Setting a package prefix</H3>
+<H3><A name="Tcl_nn9">40.1.7 Setting a package prefix</A></H3>
<P> To avoid namespace problems, you can instruct SWIG to append a
package prefix to all of your functions and variables. This is done
using the -prefix option as follows :</P>
<P> If you have a function "<TT>bar</TT>" in the SWIG file, the prefix
option will append the prefix to the name when creating a command and
call it "<TT>Foo_bar</TT>".</P>
-<H3><A name="Tcl_nn10"></A>37.1.8 Using namespaces</H3>
+<H3><A name="Tcl_nn10">40.1.8 Using namespaces</A></H3>
<P> Alternatively, you can have SWIG install your module into a Tcl
namespace by specifying the <TT>-namespace</TT> option :</P>
<DIV class="code">
name, but you can override it using the <TT>-prefix</TT> option.</P>
<P> When the <TT>-namespace</TT> option is used, objects in the module
are always accessed with the namespace name such as <TT>Foo::bar</TT>.</P>
-<H2><A name="Tcl_nn11"></A>37.2 Building Tcl/Tk Extensions under Windows
- 95/NT</H2>
+<H2><A name="Tcl_nn11">40.2 Building Tcl/Tk Extensions under Windows
+ 95/NT</A></H2>
<P> Building a SWIG extension to Tcl/Tk under Windows 95/NT is roughly
similar to the process used with Unix. Normally, you will want to
produce a DLL that can be loaded into tclsh or wish. This section
covers the process of using SWIG with Microsoft Visual C++. although
the procedure may be similar with other compilers.</P>
-<H3><A name="Tcl_nn12"></A>37.2.1 Running SWIG from Developer Studio</H3>
+<H3><A name="Tcl_nn12">40.2.1 Running SWIG from Developer Studio</A></H3>
<P> If you are developing your application within Microsoft developer
studio, SWIG can be invoked as a custom build option. The process
roughly follows these steps :</P>
%
</PRE>
</DIV>
-<H3><A name="Tcl_nn13"></A>37.2.2 Using NMAKE</H3>
+<H3><A name="Tcl_nn13">40.2.2 Using NMAKE</A></H3>
<P> Alternatively, SWIG extensions can be built by writing a Makefile
for NMAKE. To do this, make sure the environment variables for MSVC++
are available and the MSVC++ tools are in your path. Now, just write a
TCL_INCLUDES = -Id:\tcl8.0a2\generic -Id:\tcl8.0a2\win
TCLLIB = d:\tcl8.0a2\win\tcl80.lib
-tcl::
- ..\..\swig -tcl -o $(WRAPFILE) $(INTERFACE)
- $(CC) $(CFLAGS) $(TCL_INCLUDES) $(SRCS) $(WRAPFILE)
- set LIB=$(TOOLS)\lib
- $(LINK) $(LOPT) -out:example.dll $(LIBS) $(TCLLIB) example.obj example_wrap.obj
+tcl:
+ ..\..\swig -tcl -o $(WRAPFILE) $(INTERFACE)
+ $(CC) $(CFLAGS) $(TCL_INCLUDES) $(SRCS) $(WRAPFILE)
+ set LIB=$(TOOLS)\lib
+ $(LINK) $(LOPT) -out:example.dll $(LIBS) $(TCLLIB) example.obj example_wrap.obj
</PRE>
</DIV>
first). This is a pretty minimal Makefile, but hopefully its enough to
get you started. With a little practice, you'll be making lots of Tcl
extensions.</P>
-<H2><A name="Tcl_nn14"></A>37.3 A tour of basic C/C++ wrapping</H2>
+<H2><A name="Tcl_nn14">40.3 A tour of basic C/C++ wrapping</A></H2>
<P> By default, SWIG tries to build a very natural Tcl interface to your
C/C++ code. Functions are wrapped as functions, classes are wrapped in
an interface that mimics the style of Tk widgets and [incr Tcl]
classes. This section briefly covers the essential aspects of this
wrapping.</P>
-<H3><A name="Tcl_nn15"></A>37.3.1 Modules</H3>
+<H3><A name="Tcl_nn15">40.3.1 Modules</A></H3>
<P> The SWIG <TT>%module</TT> directive specifies the name of the Tcl
module. If you specify `<TT>%module example</TT>', then everything is
compiled into an extension module <TT>example.so</TT>. When choosing a
% load ./md5.so md5
</PRE>
</DIV>
-<H3><A name="Tcl_nn16"></A>37.3.2 Functions</H3>
+<H3><A name="Tcl_nn16">40.3.2 Functions</A></H3>
<P> Global functions are wrapped as new Tcl built-in commands. For
example,</P>
<DIV class="code">
%
</PRE>
</DIV>
-<H3><A name="Tcl_nn17"></A>37.3.3 Global variables</H3>
+<H3><A name="Tcl_nn17">40.3.3 Global variables</A></H3>
<P> C/C++ global variables are wrapped by Tcl global variables. For
example:</P>
<DIV class="code">
extern char *path; // Read-only (due to %immutable)
</PRE>
</DIV>
-<H3><A name="Tcl_nn18"></A>37.3.4 Constants and enums</H3>
+<H3><A name="Tcl_nn18">40.3.4 Constants and enums</A></H3>
<P> C/C++ constants are installed as global Tcl variables containing the
appropriate value. To create a constant, use <TT>#define</TT>, <TT>enum</TT>
, or the <TT>%constant</TT> directive. For example:</P>
<P> When an identifier name is given, it is used to perform an implicit
hash-table lookup of the value during argument conversion. This allows
the <TT>global</TT> statement to be omitted.</P>
-<H3><A name="Tcl_nn19"></A>37.3.5 Pointers</H3>
+<H3><A name="Tcl_nn19">40.3.5 Pointers</A></H3>
<P> C/C++ pointers are fully supported by SWIG. Furthermore, SWIG has no
problem working with incomplete type information. Here is a rather
simple interface:</P>
style casts. For example, in the above code, the C-style cast may
return a bogus result whereas as the C++-style cast will return <TT>
None</TT> if the conversion can't be performed.</P>
-<H3><A name="Tcl_nn20"></A>37.3.6 Structures</H3>
+<H3><A name="Tcl_nn20">40.3.6 Structures</A></H3>
<P> If you wrap a C structure, it is wrapped by a Tcl interface that
somewhat resembles a Tk widget. This provides a very natural interface.
For example,</P>
<DIV class="code">
<PRE>
struct Vector {
- double x,y,z;
+ double x,y,z;
};
</PRE>
</DIV>
<P> Note: Tcl only destroys the underlying object if it has ownership.
See the memory management section that appears shortly.</P>
-<H3><A name="Tcl_nn21"></A>37.3.7 C++ classes</H3>
+<H3><A name="Tcl_nn21">40.3.7 C++ classes</A></H3>
<P> C++ classes are wrapped as an extension of structure wrapping. For
example, if you have this class,</P>
<DIV class="code">
% x insert Lager
% x get 1
Stout
-% puts [l cget -length]
+% puts [x cget -length]
3
%
</PRE>
% puts $Spam_bar # Spam::bar
</PRE>
</DIV>
-<H3><A name="Tcl_nn22"></A>37.3.8 C++ inheritance</H3>
+<H3><A name="Tcl_nn22">40.3.8 C++ inheritance</A></H3>
<P> SWIG is fully aware of issues related to C++ inheritance. Therefore,
if you have classes like this</P>
<DIV class="code">
</PRE>
</DIV>
<P> It is safe to use multiple inheritance with SWIG.</P>
-<H3><A name="Tcl_nn23"></A>37.3.9 Pointers, references, values, and
- arrays</H3>
+<H3><A name="Tcl_nn23">40.3.9 Pointers, references, values, and arrays</A>
+</H3>
<P> In C++, there are many different ways a function might receive and
manipulate objects. For example:</P>
<DIV class="code">
allocated memory is used to hold the result and a pointer is returned
(Tcl will release this memory when the return value is garbage
collected).</P>
-<H3><A name="Tcl_nn24"></A>37.3.10 C++ overloaded functions</H3>
+<H3><A name="Tcl_nn24">40.3.10 C++ overloaded functions</A></H3>
<P> C++ overloaded functions, methods, and constructors are mostly
supported by SWIG. For example, if you have two functions like this:</P>
<DIV class="code">
arises--in this case, the first declaration takes precedence.</P>
<P> Please refer to the "SWIG and C++" chapter for more information
about overloading.</P>
-<H3><A name="Tcl_nn25"></A>37.3.11 C++ operators</H3>
+<H3><A name="Tcl_nn25">40.3.11 C++ operators</A></H3>
<P> Certain C++ overloaded operators can be handled automatically by
SWIG. For example, consider a class like this:</P>
<DIV class="code">
</DIV>
<P> There are ways to make this operator appear as part of the class
using the <TT>%extend</TT> directive. Keep reading.</P>
-<H3><A name="Tcl_nn26"></A>37.3.12 C++ namespaces</H3>
+<H3><A name="Tcl_nn26">40.3.12 C++ namespaces</A></H3>
<P> SWIG is aware of C++ namespaces, but namespace names do not appear
in the module nor do namespaces result in a module that is broken up
into submodules or packages. For example, if you have a file like this,</P>
extension modules for each namespace separately. If your program
utilizes thousands of small deeply nested namespaces each with
identical symbol names, well, then you get what you deserve.</P>
-<H3><A name="Tcl_nn27"></A>37.3.13 C++ templates</H3>
+<H3><A name="Tcl_nn27">40.3.13 C++ templates</A></H3>
<P> C++ templates don't present a huge problem for SWIG. However, in
order to create wrappers, you have to tell SWIG to create wrappers for
a particular template instantiation. To do this, you use the <TT>
<P> Obviously, there is more to template wrapping than shown in this
example. More details can be found in the <A href="#SWIGPlus">SWIG and
C++</A> chapter. Some more complicated examples will appear later.</P>
-<H3><A name="Tcl_nn28"></A>37.3.14 C++ Smart Pointers</H3>
+<H3><A name="Tcl_nn28">40.3.14 C++ Smart Pointers</A></H3>
<P> In certain C++ programs, it is common to use classes that have been
wrapped by so-called "smart pointers." Generally, this involves the use
of a template class that implements <TT>operator->()</TT> like this:</P>
% set f [$p __deref__] # Returns underlying Foo *
</PRE>
</DIV>
-<H2><A name="Tcl_nn29"></A>37.4 Further details on the Tcl class
- interface</H2>
+<H2><A name="Tcl_nn29">40.4 Further details on the Tcl class interface</A>
+</H2>
<P> In the previous section, a high-level view of Tcl wrapping was
presented. A key component of this wrapping is that structures and
classes are wrapped by Tcl class-like objects. This provides a very
features such as operator overloading. However, a number of low-level
details were omitted. This section provides a brief overview of how the
proxy classes work.</P>
-<H3><A name="Tcl_nn30"></A>37.4.1 Proxy classes</H3>
+<H3><A name="Tcl_nn30">40.4.1 Proxy classes</A></H3>
<P> In the <A href="#SWIG">"SWIG basics"</A> and <A href="#SWIGPlus">
"SWIG and C++"</A> chapters, details of low-level structure and class
wrapping are described. To summarize those chapters, if you have a
<P> However, in addition to this, the classname <TT>Foo</TT> is used as
an object constructor function. This allows objects to be encapsulated
objects that look a lot like Tk widgets as shown in the last section.</P>
-<H3><A name="Tcl_nn31"></A>37.4.2 Memory management</H3>
+<H3><A name="Tcl_nn31">40.4.2 Memory management</A></H3>
<P> Associated with each wrapped object, is an ownership flag <TT>
thisown</TT> The value of this flag determines who is responsible for
deleting the underlying C++ object. If set to 1, the Tcl interpreter
</DIV>
<P> It is also possible to deal with situations like this using
typemaps--an advanced topic discussed later.</P>
-<H2><A name="Tcl_nn32"></A>37.5 Input and output parameters</H2>
+<H2><A name="Tcl_nn32">40.5 Input and output parameters</A></H2>
<P> A common problem in some C programs is handling parameters passed as
simple pointers. For example:</P>
<DIV class="code">
set c [lindex $dim 1]
</PRE>
</DIV>
-<H2><A name="Tcl_nn33"></A>37.6 Exception handling</H2>
+<H2><A name="Tcl_nn33">40.6 Exception handling</A></H2>
<P> The <TT>%exception</TT> directive can be used to create a
user-definable exception handler in charge of converting exceptions in
your C/C++ program into Tcl exceptions. The chapter on customization
$action // Gets substituted by actual function call
}
catch (RangeError) {
- Tcl_SetStringObj(tcl_result,"Array index out-of-bounds");
+ Tcl_SetResult(interp, (char *)"Array index out-of-bounds", TCL_STATIC);
return TCL_ERROR;
}
}
$action
}
catch (RangeError) {
- Tcl_SetStringObj(tcl_result,"Array index out-of-bounds");
+ Tcl_SetResult(interp, (char *)"Array index out-of-bounds", TCL_STATIC);
return TCL_ERROR;
}
}
$action
}
catch (RangeError) {
- Tcl_SetStringObj(tcl_result,"Array index out-of-bounds");
+ Tcl_SetResult(interp, (char *)"Array index out-of-bounds", TCL_STATIC);
return TCL_ERROR;
}
}
$action
}
catch (RangeError) {
- Tcl_SetStringObj(tcl_result,"Array index out-of-bounds");
+ Tcl_SetResult(interp, (char *)"Array index out-of-bounds", TCL_STATIC);
return TCL_ERROR;
}
}
<P> Since SWIG's exception handling is user-definable, you are not
limited to C++ exception handling. See the chapter on "<A href="#Customization">
Customization Features</A>" for more examples.</P>
-<H2><A name="Tcl_nn34"></A>37.7 Typemaps</H2>
+<H2><A name="Tcl_nn34">40.7 Typemaps</A></H2>
<P> This section describes how you can modify SWIG's default wrapping
behavior for various C/C++ datatypes using the <TT>%typemap</TT>
directive. This is an advanced topic that assumes familiarity with the
required part of using SWIG---the default wrapping behavior is enough
in most cases. Typemaps are only used if you want to change some aspect
of the primitive C-Tcl interface.</P>
-<H3><A name="Tcl_nn35"></A>37.7.1 What is a typemap?</H3>
+<H3><A name="Tcl_nn35">40.7.1 What is a typemap?</A></H3>
<P> A typemap is nothing more than a code generation rule that is
attached to a specific C datatype. For example, to convert integers
from Tcl to C, you might define a typemap like this:</P>
%module example
%typemap(in) int {
- if (Tcl_GetIntFromObj(interp,$input,&$1) == TCL_ERROR) return TCL_ERROR;
- printf("Received an integer : %d\n",$1);
+ if (Tcl_GetIntFromObj(interp,$input,&$1) == TCL_ERROR)
+ return TCL_ERROR;
+ printf("Received an integer : %d\n",$1);
}
%inline %{
extern int fact(int n);
%module example
%typemap(in) int n {
- if (Tcl_GetIntFromObj(interp,$input,&$1) == TCL_ERROR) return TCL_ERROR;
- printf("n = %d\n",$1);
+ if (Tcl_GetIntFromObj(interp,$input,&$1) == TCL_ERROR)
+ return TCL_ERROR;
+ printf("n = %d\n",$1);
}
%inline %{
extern int fact(int n);
<DIV class="code">
<PRE>
%typemap(in) int n {
- if (Tcl_GetIntFromObj(interp,$input,&$1) == TCL_ERROR) return TCL_ERROR;
- printf("n = %d\n",$1);
+ if (Tcl_GetIntFromObj(interp,$input,&$1) == TCL_ERROR)
+ return TCL_ERROR;
+ printf("n = %d\n",$1);
}
%inline %{
typedef int Integer;
1
</PRE>
</DIV>
-<H3><A name="Tcl_nn36"></A>37.7.2 Tcl typemaps</H3>
+<H3><A name="Tcl_nn36">40.7.2 Tcl typemaps</A></H3>
<P> The previous section illustrated an "in" typemap for converting Tcl
objects to C. A variety of different typemap methods are defined by the
Tcl module. For example, to convert a C integer back into a Tcl object,
<DIV class="indent"> Initialize an argument to a value before any
conversions occur.</DIV>
<P> Examples of these methods will appear shortly.</P>
-<H3><A name="Tcl_nn37"></A>37.7.3 Typemap variables</H3>
+<H3><A name="Tcl_nn37">40.7.3 Typemap variables</A></H3>
<P> Within typemap code, a number of special variables prefaced with a <TT>
$</TT> may appear. A full list of variables can be found in the "<A href="#Typemaps">
Typemaps</A>" chapter. This is a list of the most common variables:</P>
their values can be properly assigned.</DIV>
<P> <TT>$symname</TT></P>
<DIV class="indent"> The Tcl name of the wrapper function being created.</DIV>
-<H3><A name="Tcl_nn38"></A>37.7.4 Converting a Tcl list to a char **</H3>
+<H3><A name="Tcl_nn38">40.7.4 Converting a Tcl list to a char **</A></H3>
<P> A common problem in many C programs is the processing of command
line arguments, which are usually passed in an array of NULL terminated
strings. The following SWIG interface file allows a Tcl list to be used
3
</PRE>
</DIV>
-<H3><A name="Tcl_nn39"></A>37.7.5 Returning values in arguments</H3>
+<H3><A name="Tcl_nn39">40.7.5 Returning values in arguments</A></H3>
<P> The "argout" typemap can be used to return a value originating from
a function argument. For example :</P>
<DIV class="code">
%
</PRE>
</DIV>
-<H3><A name="Tcl_nn40"></A>37.7.6 Useful functions</H3>
+<H3><A name="Tcl_nn40">40.7.6 Useful functions</A></H3>
<P> The following tables provide some functions that may be useful in
writing Tcl typemaps.</P>
<P><B> Integers</B></P>
<DIV class="code">
<PRE>
Tcl_Obj *Tcl_NewStringObj(char *str, int len);
-void Tcl_SetStringObj(Tcl_Obj *obj, char *str, int len);
char *Tcl_GetStringFromObj(Tcl_Obj *obj, int *len);
void Tcl_AppendToObj(Tcl_Obj *obj, char *str, int len);
</PRE>
int Tcl_IsShared(Tcl_Obj *obj);
</PRE>
</DIV>
-<H3><A name="Tcl_nn41"></A>37.7.7 Standard typemaps</H3>
+<H3><A name="Tcl_nn41">40.7.7 Standard typemaps</A></H3>
<P> The following typemaps show how to convert a few common kinds of
objects between Tcl and C (and to give a better idea of how typemaps
work)</P>
<DIV class="code">
<PRE>
%typemap(in) int, short, long {
- int temp;
- if (Tcl_GetIntFromObj(interp, $input, &temp) == TCL_ERROR)
- return TCL_ERROR;
- $1 = ($1_ltype) temp;
+ int temp;
+ if (Tcl_GetIntFromObj(interp, $input, &temp) == TCL_ERROR)
+ return TCL_ERROR;
+ $1 = ($1_ltype) temp;
}
</PRE>
</DIV>
</DIV>
<BR><DIV class="code">
<PRE>
-%typemap(out) char * {
- Tcl_SetStringObj($result,$1);
+%typemap(out,noblock=1,fragment="SWIG_FromCharPtr") char *, const char * {
+ Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)$1));
}
+
</PRE>
</DIV>
-<H3><A name="Tcl_nn42"></A>37.7.8 Pointer handling</H3>
+<H3><A name="Tcl_nn42">40.7.8 Pointer handling</A></H3>
<P> SWIG pointers are mapped into Tcl strings containing the hexadecimal
value and type. The following functions can be used to create and read
pointer values.</P>
}
</PRE>
</DIV>
-<H2><A name="Tcl_nn43"></A>37.8 Turning a SWIG module into a Tcl
- Package.</H2>
+<H2><A name="Tcl_nn43">40.8 Turning a SWIG module into a Tcl Package.</A>
+</H2>
<P> Tcl 7.4 introduced the idea of an extension package. By default,
SWIG generates all of the code necessary to create a package. To set
the package version, simply use the <TT>-pkgversion</TT> option. For
<DIV class="code">
<PRE>
./example/
- pkgIndex.tcl # The file created by pkg_mkIndex
- example.so # The SWIG generated module
+ pkgIndex.tcl # The file created by pkg_mkIndex
+ example.so # The SWIG generated module
</PRE>
</DIV>
<P> Finally, assuming that you're not entirely confused at this point,
<P> As a final note, most SWIG examples do not yet use the <TT>package</TT>
commands. For simple extensions it may be easier just to use the <TT>
load</TT> command instead.</P>
-<H2><A name="Tcl_nn44"></A>37.9 Building new kinds of Tcl interfaces (in
- Tcl)</H2>
+<H2><A name="Tcl_nn44">40.9 Building new kinds of Tcl interfaces (in
+ Tcl)</A></H2>
<P> One of the most interesting aspects of Tcl and SWIG is that you can
create entirely new kinds of Tcl interfaces in Tcl using the low-level
SWIG accessor functions. For example, suppose you had a library of
<PRE>
set a [Array double 100] ;# Create a double [100]
for {set i 0} {$i < 100} {incr i 1} { ;# Clear the array
- $a set $i 0.0
+ $a set $i 0.0
}
$a set 3 3.1455 ;# Set an individual element
set b [$a get 10] ;# Retrieve an element
set ia [Array int 50] ;# Create an int[50]
for {set i 0} {$i < 50} {incr i 1} { ;# Clear it
- $ia set $i 0
+ $ia set $i 0
}
$ia set 3 7 ;# Set an individual element
set ib [$ia get 10] ;# Get an individual element
requested, the Tcl code would simply return with an error so there is
very little danger of blowing something up (although it is easily
accomplished with an out of bounds array access).</P>
-<H3><A name="Tcl_nn45"></A>37.9.1 Proxy classes</H3>
+<H3><A name="Tcl_nn45">40.9.1 Proxy classes</A></H3>
<P> A similar approach can be applied to proxy classes (also known as
shadow classes). The following example is provided by Erik Bierwagen
and Paul Saxe. To use it, run SWIG with the <TT>-noobject</TT> option
object wrapped by SWIG and requires no special compilation. Proof that
a short, but clever Tcl script can be combined with SWIG to do many
interesting things.</P>
-<H2><A name="Tcl_nn46"></A>37.10 Tcl/Tk Stubs</H2>
+<H2><A name="Tcl_nn46">40.10 Tcl/Tk Stubs</A></H2>
<P> For background information about the Tcl Stubs feature, see <A href="http://www.tcl.tk/doc/howto/stubs.html">
http://www.tcl.tk/doc/howto/stubs.html</A>.</P>
<P> As of SWIG 1.3.10, the generated C/C++ wrapper will use the Tcl
-DSWIG_TCL_STUBS_VERSION="8.3"</TT> or the version being compiled with
using <TT>-DSWIG_TCL_STUBS_VERSION=TCL_VERSION</TT>.</P>
<HR NOSHADE>
-<H1><A name="Extending"></A>38 Extending SWIG to support new languages</H1>
+<H1><A name="Extending">41 Extending SWIG to support new languages</A></H1>
<!-- INDEX -->
<DIV class="sectiontoc">
</UL>
</DIV>
<!-- INDEX -->
-<H2><A name="Extending_nn2"></A>38.1 Introduction</H2>
+<H2><A name="Extending_nn2">41.1 Introduction</A></H2>
<P> This chapter describes SWIG's internal organization and the process
by which new target languages can be developed. First, a brief word of
warning---SWIG is continually evolving. The information in this chapter
<P> Also, this chapter is not meant to be a hand-holding tutorial. As a
starting point, you should probably look at one of SWIG's existing
modules.</P>
-<H2><A name="Extending_nn3"></A>38.2 Prerequisites</H2>
+<H2><A name="Extending_nn3">41.2 Prerequisites</A></H2>
<P> In order to extend SWIG, it is useful to have the following
background:</P>
<UL>
an extension of the C++<EM> type</EM> system. At first glance, this
might not be obvious, but almost all SWIG directives as well as the
low-level generation of wrapper code are driven by C++ datatypes.</P>
-<H2><A name="Extending_nn4"></A>38.3 The Big Picture</H2>
+<H2><A name="Extending_nn4">41.3 The Big Picture</A></H2>
<P> SWIG is a special purpose compiler that parses C++ declarations to
generate wrapper code. To make this conversion possible, SWIG makes
three fundamental extensions to the C++ language:</P>
matching rules also play a critical role in making the system work. For
example, both typemaps and declaration annotation are based on pattern
matching and interact heavily with the underlying type system.</P>
-<H2><A name="Extending_nn5"></A>38.4 Execution Model</H2>
+<H2><A name="Extending_nn5">41.4 Execution Model</A></H2>
<P> When you run SWIG on an interface, processing is handled in stages
by a series of system components:</P>
<UL>
stage of compilation.</LI>
</UL>
<P> The next few sections briefly describe some of these stages.</P>
-<H3><A name="Extending_nn6"></A>38.4.1 Preprocessing</H3>
+<H3><A name="Extending_nn6">41.4.1 Preprocessing</A></H3>
<P> The preprocessor plays a critical role in the SWIG implementation.
This is because a lot of SWIG's processing and internal configuration
is managed not by code written in C, but by configuration files in the
probably isn't too useful in general, but it will show how macros have
been expanded as well as everything else that goes into the low-level
construction of the wrapper code.</P>
-<H3><A name="Extending_nn7"></A>38.4.2 Parsing</H3>
+<H3><A name="Extending_nn7">41.4.2 Parsing</A></H3>
<P> The current C++ parser handles a subset of C++. Most
incompatibilities with C are due to subtle aspects of how SWIG parses
declarations. Specifically, SWIG expects all C/C++ declarations to
interprets the above code as an abstract declarator for a function
returning a <TT>foo</TT> and taking types <TT>a</TT> and <TT>b</TT> as
arguments).</P>
-<H3><A name="Extending_nn8"></A>38.4.3 Parse Trees</H3>
+<H3><A name="Extending_nn8">41.4.3 Parse Trees</A></H3>
<P> The SWIG parser produces a complete parse tree of the input file
before any wrapper code is actually generated. Each item in the tree is
known as a "Node". Each node is identified by a symbolic tag.
| sym:symtab - 0x40194788
</PRE>
</DIV>
-<H3><A name="Extending_nn9"></A>38.4.4 Attribute namespaces</H3>
+<H3><A name="Extending_nn9">41.4.4 Attribute namespaces</A></H3>
<P> Attributes of parse tree nodes are often prepended with a namespace
qualifier. For example, the attributes <TT>sym:name</TT> and <TT>
sym:symtab</TT> are attributes related to symbol table management and
assist the generation of wrapper code. The convention for doing this is
to place these attributes in a namespace that matches the name of the
target language. For example, <TT>python:foo</TT> or <TT>perl:foo</TT>.</P>
-<H3><A name="Extending_nn10"></A>38.4.5 Symbol Tables</H3>
+<H3><A name="Extending_nn10">41.4.5 Symbol Tables</A></H3>
<P> During parsing, all symbols are managed in the space of the target
language. The <TT>sym:name</TT> attribute of each node contains the
symbol name selected by the parser. Normally, <TT>sym:name</TT> and <TT>
example.i:5. Previous declaration is foo_i(int )
</PRE>
</DIV>
-<H3><A name="Extending_nn11"></A>38.4.6 The %feature directive</H3>
+<H3><A name="Extending_nn11">41.4.6 The %feature directive</A></H3>
<P> A number of SWIG directives such as <TT>%exception</TT> are
implemented using the low-level <TT>%feature</TT> directive. For
example:</P>
recognize. The data stored in a feature attribute is usually just a raw
unparsed string. For example, the exception code above is simply stored
without any modifications.</P>
-<H3><A name="Extending_nn12"></A>38.4.7 Code Generation</H3>
+<H3><A name="Extending_nn12">41.4.7 Code Generation</A></H3>
<P> Language modules work by defining handler functions that know how to
respond to different types of parse-tree nodes. These handlers simply
look at the attributes of each node in order to produce low-level code.</P>
</PRE>
</DIV>
<P> The role of these functions is described shortly.</P>
-<H3><A name="Extending_nn13"></A>38.4.8 SWIG and XML</H3>
+<H3><A name="Extending_nn13">41.4.8 SWIG and XML</A></H3>
<P> Much of SWIG's current parser design was originally motivated by
interest in using XML to represent SWIG parse trees. Although XML is
not currently used in any direct manner, the parse tree structure, use
by aspects of XML parsing. Therefore, in trying to understand SWIG's
internal data structures, it may be useful to keep XML in the back of
your mind as a model.</P>
-<H2><A name="Extending_nn14"></A>38.5 Primitive Data Structures</H2>
+<H2><A name="Extending_nn14">41.5 Primitive Data Structures</A></H2>
<P> Most of SWIG is constructed using three basic data structures:
strings, hashes, and lists. These data structures are dynamic in same
way as similar structures found in many scripting languages. For
typedef Hash Typetab;
</PRE>
</DIV>
-<H3><A name="Extending_nn15"></A>38.5.1 Strings</H3>
+<H3><A name="Extending_nn15">41.5.1 Strings</A></H3>
<P><B> <TT>String *NewString(const String_or_char *val)</TT></B></P>
<DIV class="indent"> Creates a new string with initial value <TT>val</TT>
. <TT>val</TT> may be a <TT>char *</TT> or another <TT>String</TT>
</DIV>
<P> Returns the number of replacements made (if any).</P>
</DIV>
-<H3><A name="Extending_nn16"></A>38.5.2 Hashes</H3>
+<H3><A name="Extending_nn16">41.5.2 Hashes</A></H3>
<P><B> <TT>Hash *NewHash()</TT></B></P>
<DIV class="indent"> Creates a new empty hash table.</DIV>
<P><B> <TT>Hash *Copy(Hash *h)</TT></B></P>
Returns 1 if an object was removed, 0 otherwise.</DIV>
<P><B> <TT>List *Keys(Hash *h)</TT></B></P>
<DIV class="indent"> Returns the list of hash table keys.</DIV>
-<H3><A name="Extending_nn17"></A>38.5.3 Lists</H3>
+<H3><A name="Extending_nn17">41.5.3 Lists</A></H3>
<P><B> <TT>List *NewList()</TT></B></P>
<DIV class="indent"> Creates a new empty list.</DIV>
<P><B> <TT>List *Copy(List *x)</TT></B></P>
insertion at the end of the list (appending). If <TT>t</TT> is not a
standard object, it is assumed to be a <TT>char *</TT> and is used to
create a String object.</DIV>
-<H3><A name="Extending_nn18"></A>38.5.4 Common operations</H3>
+<H3><A name="Extending_nn18">41.5.4 Common operations</A></H3>
The following operations are applicable to all datatypes.
<P><B> <TT>Object *Copy(Object *x)</TT></B></P>
<DIV class="indent"> Make a copy of the object <TT>x</TT>.</DIV>
Used to track objects and report errors.</DIV>
<P><B> <TT>int Getline(Object *x)</TT></B></P>
<DIV class="indent"> Gets the line number associated with <TT>x</TT>.</DIV>
-<H3><A name="Extending_nn19"></A>38.5.5 Iterating over Lists and Hashes</H3>
+<H3><A name="Extending_nn19">41.5.5 Iterating over Lists and Hashes</A></H3>
To iterate over the elements of a list or a hash table, the following
functions are used:
<P><B> <TT>Iterator First(Object *x)</TT></B></P>
}
</PRE>
</DIV></DIV>
-<H3><A name="Extending_nn20"></A>38.5.6 I/O</H3>
+<H3><A name="Extending_nn20">41.5.6 I/O</A></H3>
Special I/O functions are used for all internal I/O. These operations
work on C <TT>FILE *</TT> objects, String objects, and special <TT>File</TT>
objects (which are merely a wrapper around <TT>FILE *</TT>).
<P><B> <TT>File *NewFileFromFile(FILE *f)</TT></B></P>
<DIV class="indent"> Create a File object wrapper around an existing <TT>
FILE *</TT> object.</DIV>
-<P><B> <TT>int Close(String_or_FILE *f)</TT></B></P>
-<DIV class="indent">
-<P>Closes a file. Has no effect on strings.</P>
+<P> There's no explicit function to close a file, just call <TT>
+Delete(f)</TT> - this decreases the reference count, and the file will
+ be closed when the reference count reaches zero.</P>
<P> The use of the above I/O functions and strings play a critical role
in SWIG. It is common to see small code fragments of code generated
using code like this:</P>
</PRE>
</DIV>
<P> Similarly, the preprocessor and parser all operate on string-files.</P>
-</DIV>
-<H2><A name="Extending_nn21"></A>38.6 Navigating and manipulating parse
- trees</H2>
+<H2><A name="Extending_nn21">41.6 Navigating and manipulating parse
+ trees</A></H2>
Parse trees are built as collections of hash tables. Each node is a
hash table in which arbitrary attributes can be stored. Certain
attributes in the hash table provide links to other parse tree nodes.
<DIV class="indent"> Deletes a node from the parse tree. Deletion
reconnects siblings and properly updates the parent so that sibling
nodes are unaffected.</DIV>
-<H2><A name="Extending_nn22"></A>38.7 Working with attributes</H2>
+<H2><A name="Extending_nn22">41.7 Working with attributes</A></H2>
<P> Since parse tree nodes are just hash tables, attributes are accessed
using the <TT>Getattr()</TT>, <TT>Setattr()</TT>, and <TT>Delattr()</TT>
operations. For example:</P>
copy of the attribute is saved as with <TT>Swig_save()</TT>. If an
attribute is specified as "?<EM>name</EM>", the attribute is optional. <TT>
Swig_restore()</TT> must always be called after using this function.</DIV>
-<H2><A name="Extending_nn23"></A>38.8 Type system</H2>
+<H2><A name="Extending_nn23">41.8 Type system</A></H2>
<P> SWIG implements the complete C++ type system including typedef,
inheritance, pointers, references, and pointers to members. A detailed
discussion of type theory is impossible here. However, let's cover the
highlights.</P>
-<H3><A name="Extending_nn24"></A>38.8.1 String encoding of types</H3>
+<H3><A name="Extending_nn24">41.8.1 String encoding of types</A></H3>
<P> All types in SWIG consist of a base datatype and a collection of
type operators that are applied to the base. A base datatype is almost
always some kind of primitive type such as <TT>int</TT> or <TT>double</TT>
int</TT>" and the declarator of type "<TT>a(30).p.</TT>". To make the
final type, the two parts are just joined together using string
concatenation.</P>
-<H3><A name="Extending_nn25"></A>38.8.2 Type construction</H3>
+<H3><A name="Extending_nn25">41.8.2 Type construction</A></H3>
<P> The following functions are used to construct types. You should use
these functions instead of trying to build the type strings yourself.</P>
<P><B> <TT>void SwigType_add_pointer(SwigType *ty)</TT></B></P>
<DIV class="indent"> Returns the prefix of a type. For example, if <TT>
ty</TT> is <TT>"p.a(20).int"</TT>, this function would return <TT>
"p.a(20)."</TT>. <TT>ty</TT> is unmodified.</DIV>
-<H3><A name="Extending_nn26"></A>38.8.3 Type tests</H3>
+<H3><A name="Extending_nn26">41.8.3 Type tests</A></H3>
<P> The following functions can be used to test properties of a
datatype.</P>
<P><B> <TT>int SwigType_ispointer(SwigType *ty)</TT></B></P>
<DIV class="indent"> Checks if <TT>ty</TT> is a varargs type.</DIV>
<P><B> <TT>int SwigType_istemplate(SwigType *ty)</TT></B></P>
<DIV class="indent"> Checks if <TT>ty</TT> is a templatized type.</DIV>
-<H3><A name="Extending_nn27"></A>38.8.4 Typedef and inheritance</H3>
+<H3><A name="Extending_nn27">41.8.4 Typedef and inheritance</A></H3>
<P> The behavior of <TT>typedef</TT> declaration is to introduce a type
alias. For instance, <TT>typedef int Integer</TT> makes the identifier <TT>
Integer</TT> an alias for <TT>int</TT>. The treatment of typedef in SWIG
<P><B> <TT>SwigType *SwigType_typedef_resolve_all(SwigType *ty)</TT></B></P>
<DIV class="indent"> Fully reduces <TT>ty</TT> according to typedef
rules. Resulting datatype will consist only of primitive typenames.</DIV>
-<H3><A name="Extending_nn28"></A>38.8.5 Lvalues</H3>
+<H3><A name="Extending_nn28">41.8.5 Lvalues</A></H3>
<P> When generating wrapper code, it is necessary to emit datatypes that
can be used on the left-hand side of an assignment operator (an
lvalue). However, not all C datatypes can be used in this
Literal y; // type = 'Literal', ltype='p.char'
</PRE>
</DIV>
-<H3><A name="Extending_nn29"></A>38.8.6 Output functions</H3>
+<H3><A name="Extending_nn29">41.8.6 Output functions</A></H3>
<P> The following functions produce strings that are suitable for
output.</P>
<P><B> <TT>String *SwigType_str(SwigType *ty, const String_or_char *id =
identifier. The resulting string is used in various parts of SWIG, but
is most commonly associated with type-descriptor objects that appear in
wrappers (e.g., <TT>SWIGTYPE_p_double</TT>).</DIV>
-<H2><A name="Extending_nn30"></A>38.9 Parameters</H2>
+<H2><A name="Extending_nn30">41.9 Parameters</A></H2>
<P> Several type-related functions involve parameter lists. These
include functions and templates. Parameter list are represented as a
list of nodes with the following attributes:</P>
<P><B> <TT>int ParmList_numrequired(ParmList *p);</TT></B></P>
<DIV class="indent"> Returns the number of required (non-optional)
arguments in <TT>p</TT>.</DIV>
-<H2><A name="Extending_nn31"></A>38.10 Writing a Language Module</H2>
+<H2><A name="Extending_nn31">41.10 Writing a Language Module</A></H2>
<P> One of the easiest routes to supporting a new language module is to
copy an already supported language module implementation and modify it.
Be sure to choose a language that is similar in nature to the new
language module from scratch. Since the code is relatively easy to
read, this section describes the creation of a minimal Python module.
You should be able to extrapolate this to other languages.</P>
-<H3><A name="Extending_nn32"></A>38.10.1 Execution model</H3>
+<H3><A name="Extending_nn32">41.10.1 Execution model</A></H3>
<P> Code generation modules are defined by inheriting from the <TT>
Language</TT> class, currently defined in the <TT>Source/Modules</TT>
directory of SWIG. Starting from the parsing of command line options,
all aspects of code generation are controlled by different methods of
the <TT>Language</TT> that must be defined by your module.</P>
-<H3><A name="Extending_starting_out"></A>38.10.2 Starting out</H3>
+<H3><A name="Extending_starting_out">41.10.2 Starting out</A></H3>
<P> To define a new language module, first create a minimal
implementation using this example as a guide:</P>
<DIV class="code">
<P> Once it finishes compiling, try running SWIG with the command-line
option that activates your module. For example, <TT>swig -python foo.i</TT>
. The messages from your new module should appear.</P>
-<H3><A name="Extending_nn34"></A>38.10.3 Command line options</H3>
+<H3><A name="Extending_nn34">41.10.3 Command line options</A></H3>
<P> When SWIG starts, the command line options are passed to your
language module. This occurs before any other processing occurs
(preprocessing, parsing, etc.). To capture the command line options,
Swig_mark_arg()</TT> to mark the option as valid. If you forget to do
this, SWIG will terminate with an unrecognized command line option
error.</P>
-<H3><A name="Extending_nn35"></A>38.10.4 Configuration and preprocessing</H3>
+<H3><A name="Extending_nn35">41.10.4 Configuration and preprocessing</A></H3>
<P> In addition to looking at command line options, the <TT>main()</TT>
method is responsible for some initial configuration of the SWIG
library and preprocessor. To do this, insert some code like this:</P>
<P> Just to review, your language module should now consist of two
files-- an implementation file <TT>python.cxx</TT> and a configuration
file <TT>python.swg</TT>.</P>
-<H3><A name="Extending_nn36"></A>38.10.5 Entry point to code generation</H3>
+<H3><A name="Extending_nn36">41.10.5 Entry point to code generation</A></H3>
<P> SWIG is a multi-pass compiler. Once the <TT>main()</TT> method has
been invoked, the language module does not execute again until
preprocessing, parsing, and a variety of semantic analysis passes have
}
</PRE>
</DIV>
-<H3><A name="Extending_nn37"></A>38.10.6 Module I/O and wrapper skeleton</H3>
+<H3><A name="Extending_nn37">41.10.6 Module I/O and wrapper skeleton</A></H3>
<!-- please report bugs in this section to mgossage -->
<P> Within SWIG wrappers, there are five main sections. These are (in
<LI>runtime: This section has most of the common SWIG runtime code.</LI>
<LI>header: This section holds declarations and inclusions from the .i
file.</LI>
-<LI>wrapper: This section holds all the wrappering code.</LI>
-<LI>init: This section holds the module initalisation function (the
+<LI>wrapper: This section holds all the wrapper code.</LI>
+<LI>init: This section holds the module initialisation function (the
entry point for the interpreter).</LI>
</UL>
<P> Different parts of the SWIG code will fill different sections, then
Delete(f_header);
Delete(f_wrappers);
Delete(f_init);
- Close(f_begin);
Delete(f_begin);
return SWIG_OK;
...
</PRE>
</DIV>
-<H3><A name="Extending_nn38"></A>38.10.7 Low-level code generators</H3>
+<H3><A name="Extending_nn38">41.10.7 Low-level code generators</A></H3>
<!-- please report bugs in this section to mgossage -->
<P> As ingenious as SWIG is, and despite all its capabilities and the
/* write typemaps(in) */
....
- /* write constriants */
+ /* write constraints */
....
/* Emit the function call */
</DIV>
<P> Executing this code will produce wrappers which have our basic
skeleton but without the typemaps, there is still work to do.</P>
-<H3><A name="Extending_configuration_files"></A>38.10.8 Configuration
- files</H3>
+<H3><A name="Extending_configuration_files">41.10.8 Configuration files</A>
+</H3>
<!-- please report bugs in this section to ttn -->
<P> At the time of this writing, SWIG supports nearly twenty languages,
check-test-suite</TT> politely displays the ignoring language message.</P>
</DD>
</DL>
-<H3><A name="Extending_nn40"></A>38.10.9 Runtime support</H3>
+<H3><A name="Extending_nn40">41.10.9 Runtime support</A></H3>
<P> Discuss the kinds of functions typically needed for SWIG runtime
support (e.g. <TT>SWIG_ConvertPtr()</TT> and <TT>SWIG_NewPointerObj()</TT>
) and the names of the SWIG files that implement those functions.</P>
-<H3><A name="Extending_nn41"></A>38.10.10 Standard library files</H3>
+<H3><A name="Extending_nn41">41.10.10 Standard library files</A></H3>
<P> The standard library files that most languages supply keeps growing
as SWIG matures. The following are the minimum that are usually
supported:</P>
<LI> stl.i</LI>
</UL>
<P> Please copy these and modify for any new language.</P>
-<H3><A name="Extending_nn42"></A>38.10.11 User examples</H3>
+<H3><A name="Extending_nn42">41.10.11 User examples</A></H3>
<P> Each of the language modules provides one or more examples. These
examples are used to demonstrate different features of the language
module to SWIG end-users, but you'll find that they're useful during
types <TT>make check</TT>. To ensure that your examples are
automatically run during this process, see the section on <A href="#Extending_configuration_files">
configuration files</A>.</P>
-<H3><A name="Extending_test_suite"></A>38.10.12 Test driven development
- and the test-suite</H3>
+<H3><A name="Extending_test_suite">41.10.12 Test driven development and
+ the test-suite</A></H3>
<P> A test driven development approach is central to the improvement and
development of SWIG. Most modifications to SWIG are accompanied by
additional regression tests and checking all tests to ensure that no
is therefore essential that the runtime tests are written in a manner
that displays nothing to stdout/stderr on success but error/exception
out with an error message on stderr on failure.</P>
-<H4><A name="Extending_running_test_suite"></A>38.10.12.1 Running the
- test-suite</H4>
+<H4><A name="Extending_running_test_suite">41.10.12.1 Running the
+ test-suite</A></H4>
<P> In order for the test-suite to work for a particular target
language, the language must be correctly detected and configured during
the configure stage so that the correct Makefiles are generated. Most
<PRE>
$ make check-python-test-suite
checking python test-suite
-checking testcase argcargvtest (with run test) under python
-checking testcase python_autodoc under python
-checking testcase python_append (with run test) under python
-checking testcase callback (with run test) under python
+checking python testcase argcargvtest (with run test)
+checking python testcase python_autodoc
+checking python testcase python_append (with run test)
+checking python testcase callback (with run test)
</PRE>
</DIV>
<P> The files generated on a previous run can be deleted using the clean
make ret_by_value.ctest SWIG_FEATURES="-debug-tmsearch"
</PRE>
</DIV>
-<H3><A name="Extending_nn43"></A>38.10.13 Documentation</H3>
+<P> There is also a special 'errors' test-suite which is a set of
+ regression tests checking SWIG warning and error messages. It can be
+ run in the same way as the other language test-suites, replacing [lang]
+ with errors, such as <TT>make check-errors-test-suite</TT>. The test
+ cases used and the way it works is described in <TT>
+Examples/test-suite/errors/Makefile.in</TT>.</P>
+<H3><A name="Extending_nn43">41.10.13 Documentation</A></H3>
<P> Don't forget to write end-user documentation for your language
module. Currently, each language module has a dedicated chapter You
shouldn't rehash things that are already covered in sufficient detail
process. Provide as much detail as appropriate, and links to other
resources if available.</LI>
</UL>
-<H3><A name="Extending_prerequisites"></A>38.10.14 Prerequisites for
- adding a new language module to the SWIG distribution</H3>
+<H3><A name="Extending_prerequisites">41.10.14 Prerequisites for adding
+ a new language module to the SWIG distribution</A></H3>
<P> If you wish for a new language module to be distributed with SWIG,
which we encourage for all popular languages, there are a few
requirements. While we appreciate that getting all aspects of a new
of runtime tests. Runtime tests should be for existing testcases and
new test cases should be added should there be an area not already
covered by the existing tests.</P>
-<H3><A name="Extending_coding_style_guidelines"></A>38.10.15 Coding
- style guidelines</H3>
+<H3><A name="Extending_coding_style_guidelines">41.10.15 Coding style
+ guidelines</A></H3>
<P> The coding guidelines for the C/C++ source code are pretty much K&R
C style. The style can be inferred from the existing code base and is
largely dictated by the <TT>indent</TT> code beautifier tool set to K&R
this style as close as possible. However, tabs should be avoided as
unlike the SWIG developers, users will never have consistent tab
settings.</P>
-<H2><A name="Extending_debugging_options"></A>38.11 Debugging Options</H2>
+<H2><A name="Extending_debugging_options">41.11 Debugging Options</A></H2>
<P> There are various command line options which can aid debugging a
SWIG interface as well as debugging the development of a language
module. These are as follows:</P>
</DIV>
<P> The complete list of command line options for SWIG are available by
running <TT>swig -help</TT>.</P>
-<H2><A name="Extending_nn46"></A>38.12 Guide to parse tree nodes</H2>
+<H2><A name="Extending_nn46">41.12 Guide to parse tree nodes</A></H2>
<P> This section describes the different parse tree nodes and their
attributes.</P>
<P><B> cdecl</B></P>
"name" - Name "C", "Fortran", etc.
</PRE>
</DIV>
-<H2><A name="Extending_further_info"></A>38.13 Further Development
- Information</H2>
+<H2><A name="Extending_further_info">41.13 Further Development
+ Information</A></H2>
<P> There is further documentation available on the internals of SWIG,
API documentation and debugging information. This is shipped with SWIG
in the <TT>Doc/Devel</TT> directory.</P>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and C++</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="SWIGPlus"></a>6 SWIG and C++</H1>
+<H1><a name="SWIGPlus">6 SWIG and C++</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
wrapping and that material will be useful in understanding this chapter.
</p>
-<H2><a name="SWIGPlus_nn2"></a>6.1 Comments on C++ Wrapping</H2>
+<H2><a name="SWIGPlus_nn2">6.1 Comments on C++ Wrapping</a></H2>
<p>
yourself in the foot. You will just have to be careful.
</p>
-<H2><a name="SWIGPlus_nn3"></a>6.2 Approach</H2>
+<H2><a name="SWIGPlus_nn3">6.2 Approach</a></H2>
<p>
for each target language.
</p>
-<H2><a name="SWIGPlus_nn4"></a>6.3 Supported C++ features</H2>
+<H2><a name="SWIGPlus_nn4">6.3 Supported C++ features</a></H2>
<p>
<ul>
<li>Overloaded versions of certain operators (new, delete, etc.)
-<li>Nested classes, see <a href="#SWIGPlus_nested_classes">Nested classes</a> for workarounds.
</ul>
<p>
good way to get problems fixed (wink).
</p>
-<H2><a name="SWIGPlus_nn5"></a>6.4 Command line options and compilation</H2>
+<H2><a name="SWIGPlus_nn5">6.4 Command line options and compilation</a></H2>
<p>
<div class="shell">
<pre>
$ swig -c++ -tcl example.i
-$ c++ -c example_wrap.cxx
+$ c++ -fPIC -c example_wrap.cxx
$ c++ example_wrap.o $(OBJS) -o example.so
</pre>
</div>
The <tt>-noproxy</tt> commandline option is recognised by many target languages and will generate just this
interface as in earlier versions.
-<H2><a name="SWIGPlus_nn38"></a>6.5 Proxy classes</H2>
+<H2><a name="SWIGPlus_nn38">6.5 Proxy classes</a></H2>
<p>
C++ class is wrapped by a Java proxy class.
</p>
-<H3><a name="SWIGPlus_nn39"></a>6.5.1 Construction of proxy classes</H3>
+<H3><a name="SWIGPlus_nn39">6.5.1 Construction of proxy classes</a></H3>
<p>
might include operator overloading, exception handling, and other features.
</p>
-<H3><a name="SWIGPlus_nn40"></a>6.5.2 Resource management in proxies</H3>
+<H3><a name="SWIGPlus_nn40">6.5.2 Resource management in proxies</a></H3>
<p>
can be used (if necessary) to address some of the more tricky memory management problems.
</p>
-<H3><a name="SWIGPlus_nn41"></a>6.5.3 Language specific details</H3>
+<H3><a name="SWIGPlus_nn41">6.5.3 Language specific details</a></H3>
<p>
chapter has merely introduced the topic in a very general way.
</p>
-<H2><a name="SWIGPlus_nn6"></a>6.6 Simple C++ wrapping</H2>
+<H2><a name="SWIGPlus_nn6">6.6 Simple C++ wrapping</a></H2>
<p>
accessor functions which are then used by the proxy classes.
</p>
-<H3><a name="SWIGPlus_nn7"></a>6.6.1 Constructors and destructors</H3>
+<H3><a name="SWIGPlus_nn7">6.6.1 Constructors and destructors</a></H3>
<p>
<div class="code"><pre>
List * new_List(void) {
- return new List;
+ return new List;
}
void delete_List(List *l) {
- delete l;
+ delete l;
}
</pre></div>
-<H3><a name="SWIGPlus_nn8"></a>6.6.2 Default constructors, copy constructors and implicit destructors</H3>
+<H3><a name="SWIGPlus_nn8">6.6.2 Default constructors, copy constructors and implicit destructors</a></H3>
<p>
</p>
-<H3><a name="SWIGPlus_nn9"></a>6.6.3 When constructor wrappers aren't created</H3>
+<H3><a name="SWIGPlus_nn9">6.6.3 When constructor wrappers aren't created</a></H3>
<p>
More information about <tt>%feature</tt> can be found in the <a href="Customization.html#Customization">Customization features</a> chapter.
</p>
-<H3><a name="SWIGPlus_nn10"></a>6.6.4 Copy constructors</H3>
+<H3><a name="SWIGPlus_nn10">6.6.4 Copy constructors</a></H3>
<p>
older versions.
</p>
-<H3><a name="SWIGPlus_nn11"></a>6.6.5 Member functions</H3>
+<H3><a name="SWIGPlus_nn11">6.6.5 Member functions</a></H3>
<p>
<div class="code"><pre>
int List_search(List *obj, char *value) {
- return obj->search(value);
+ return obj->search(value);
}
</pre></div>
low-level procedural wrappers match the accessor function prototype described above.
</p>
-<H3><a name="SWIGPlus_nn12"></a>6.6.6 Static members</H3>
+<H3><a name="SWIGPlus_nn12">6.6.6 Static members</a></H3>
<p>
in the generated wrapper code.
</p>
-<H3><a name="SWIGPlus_member_data"></a>6.6.7 Member data</H3>
+<H3><a name="SWIGPlus_member_data">6.6.7 Member data</a></H3>
<p>
<div class="code"><pre>
int List_length_get(List *obj) {
- return obj->length;
+ return obj->length;
}
int List_length_set(List *obj, int value) {
- obj->length = value;
- return value;
+ obj->length = value;
+ return value;
}
</pre></div>
public:
...
%immutable;
- int length;
+ int length;
%mutable;
...
};
</p>
<p>
+By default, SWIG uses the const reference typemaps for members that are primitive types.
There are some subtle issues when wrapping data members that are
-themselves classes. For instance, if you had another class like this,
+not primitive types, such as classes. For instance, if you had another class like this,
</p>
<div class="code">
</div>
<p>
-then the low-level accessor to the <tt>items</tt> member actually uses pointers. For example:
+then the low-level accessor to the <tt>items</tt> member actually uses pointers.
+For example:
</p>
<div class="code">
For example, a user would expect the STL std::string class member variables to be wrapped as a string in the target language,
rather than a pointer to this class.
The const reference typemaps offer this type of marshalling, so there is a feature to tell SWIG to use the const reference typemaps rather than the pointer typemaps.
-It is the <tt>%naturalvar</tt> directive and is used as follows:
+It is the naturalvar feature and can be used to effectively change the way accessors are generated to the following:
+</p>
+
+<div class="code">
+<pre>
+const List &Foo_items_get(Foo *self) {
+ return self->items;
+}
+void Foo_items_set(Foo *self, const List &value) {
+ self->items = value;
+}
+</pre>
+</div>
+
+<p>
+The <tt>%naturalvar</tt> directive is a macro for, and hence equivalent to, <tt>%feature("naturalvar")</tt>. It can be used as follows:
</p>
<div class="code">
List myList;
};
-// All variables will use const reference typemaps
+// All non-primitive types will use const reference typemaps
%naturalvar;
</pre>
</div>
<p>
The observant reader will notice that <tt>%naturalvar</tt> works like any other
-<a href="Customization.html#Customization_feature_flags">feature flag</a> directive,
-except it can also be attached to class types.
-The first of the example usages above show <tt>%naturalvar</tt> attaching to the <tt>List</tt> class.
-Effectively this feature changes the way accessors are generated to the following:
+<a href="Customization.html#Customization_feature_flags">feature flag</a> directive but with some extra flexibility.
+The first of the example usages above shows <tt>%naturalvar</tt> attaching to the <tt>myList</tt>'s variable type, that is the <tt>List</tt> class.
+The second usage shows <tt>%naturalvar</tt> attaching to the variable name.
+Hence the naturalvar feature can be used on either the variable's name or type.
+Note that using the naturalvar feature on a variable's name overrides any naturalvar feature attached to the variable's type.
</p>
-<div class="code">
-<pre>
-const List &Foo_items_get(Foo *self) {
- return self->items;
-}
-void Foo_items_set(Foo *self, const List &value) {
- self->items = value;
-}
-</pre>
-</div>
-
<p>
-In fact it is generally a good idea to use this feature globally as the reference typemaps have extra NULL checking compared to the pointer typemaps.
+It is generally a good idea to use this feature globally as the reference typemaps have extra NULL checking compared to the pointer typemaps.
A pointer can be NULL, whereas a reference cannot, so the extra checking ensures that the target language user does not pass in a value that translates
to a NULL pointer and thereby preventing any potential NULL pointer dereferences.
The <tt>%naturalvar</tt> feature will apply to global variables in addition to member variables in some language modules, eg C# and Java.
</p>
<p>
-Other alternatives for turning this feature on globally are to use the <tt>swig -naturalvar</tt> commandline option
-or the module mode option, <tt>%module(naturalvar=1)</tt>
+The naturalvar behavior can also be turned on as a global setting via the <tt>-naturalvar</tt> commandline option
+or the module mode option, <tt>%module(naturalvar=1)</tt>.
+However, any use of <tt>%feature("naturalvar")</tt> will override the global setting.
</p>
<p>
customization features.
</p>
-<H2><a name="SWIGPlus_default_args"></a>6.7 Default arguments</H2>
+<H2><a name="SWIGPlus_default_args">6.7 Default arguments</a></H2>
<p>
</div>
<p>
-This produces uncompileable wrapper code because default values in C++ are
+This produces uncompilable wrapper code because default values in C++ are
evaluated in the same scope as the member function whereas SWIG
evaluates them in the scope of a wrapper function (meaning that the
values have to be public).
</p>
<p>
-This feature is automatically turned on when wrapping <a href="SWIG.html#SWIG_default_args">C code with default arguments</a>
-and whenever keyword arguments (kwargs) are specified for either C or C++ code.
+The <tt>compactdefaultargs</tt> feature is automatically turned on when wrapping <a href="SWIG.html#SWIG_default_args">C code with default arguments</a>.
+Some target languages will also automatically turn on this feature
+if the keyword arguments feature (kwargs) is specified for either C or C++ functions, and the target language supports kwargs,
+the <tt>compactdefaultargs</tt> feature is also automatically turned on.
Keyword arguments are a language feature of some scripting languages, for example Ruby and Python.
SWIG is unable to support kwargs when wrapping overloaded methods, so the default approach cannot be used.
</p>
-<H2><a name="SWIGPlus_nn15"></a>6.8 Protection</H2>
+<H2><a name="SWIGPlus_nn15">6.8 Protection</a></H2>
<p>
SWIG wraps class members that are public following the C++
conventions, i.e., by explicit public declaration or by the use of
- the <tt> using</tt> directive. In general, anything specified in a
+ the <tt>using</tt> directive. In general, anything specified in a
private or protected section will be ignored, although the internal
code generator sometimes looks at the contents of the private and
protected sections so that it can properly generate code for default
the same convention used by C++).
</p>
-<H2><a name="SWIGPlus_nn16"></a>6.9 Enums and constants</H2>
+<H2><a name="SWIGPlus_nn16">6.9 Enums and constants</a></H2>
<p>
<div class="code"><pre>
class Swig {
public:
- enum {ALE, LAGER, PORTER, STOUT};
+ enum {ALE, LAGER, PORTER, STOUT};
};
</pre></div>
Members declared as <tt>const</tt> are wrapped as read-only members and do not create constants.
</p>
-<H2><a name="SWIGPlus_nn17"></a>6.10 Friends</H2>
+<H2><a name="SWIGPlus_nn17">6.10 Friends</a></H2>
<p>
and a wrapper for the method 'blah' will not be generated.
</p>
-<H2><a name="SWIGPlus_nn18"></a>6.11 References and pointers</H2>
+<H2><a name="SWIGPlus_nn18">6.11 References and pointers</a></H2>
<p>
<div class="code"><pre>
class Foo {
public:
- double bar(double &a);
+ double bar(double &a);
}
</pre></div>
<div class="code"><pre>
double Foo_bar(Foo *obj, double *a) {
- obj->bar(*a);
+ obj->bar(*a);
}
</pre></div>
</p>
-<H2><a name="SWIGPlus_nn19"></a>6.12 Pass and return by value</H2>
+<H2><a name="SWIGPlus_nn19">6.12 Pass and return by value</a></H2>
<p>
It is not used for C++ pointers or references.
</p>
-<H2><a name="SWIGPlus_nn20"></a>6.13 Inheritance</H2>
+<H2><a name="SWIGPlus_nn20">6.13 Inheritance</a></H2>
<p>
spirit, and target language capabilities, as possible. In most
cases, this means that SWIG will parse the non-public inheritance
declarations, but that will have no effect in the generated code,
-besides the implicit policies derived for constructor and
+besides the implicit policies derived for constructors and
destructors.
</p>
class Shape {
public:
- double x,y;
- virtual double area() = 0;
- virtual double perimeter() = 0;
- void set_location(double x, double y);
+ double x,y;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
+ void set_location(double x, double y);
};
class Circle : public Shape {
public:
- Circle(double radius);
- ~Circle();
- double area();
- double perimeter();
+ Circle(double radius);
+ ~Circle();
+ double area();
+ double perimeter();
};
class Square : public Shape {
public:
- Square(double size);
- ~Square();
- double area();
- double perimeter();
+ Square(double size);
+ ~Square();
+ double area();
+ double perimeter();
}
</pre></div>
class.
</p>
-<H2><a name="SWIGPlus_nn21"></a>6.14 A brief discussion of multiple inheritance, pointers, and type checking</H2>
+<H2><a name="SWIGPlus_nn21">6.14 A brief discussion of multiple inheritance, pointers, and type checking</a></H2>
<p>
In practice, the pointer is held as an integral number in the target language proxy class.
</p>
-<H2><a name="SWIGPlus_overloaded_methods"></a>6.15 Wrapping Overloaded Functions and Methods</H2>
+<H2><a name="SWIGPlus_overloaded_methods">6.15 Wrapping Overloaded Functions and Methods</a></H2>
<p>
</pre>
</div>
-<H3><a name="SWIGPlus_nn24"></a>6.15.1 Dispatch function generation</H3>
+<H3><a name="SWIGPlus_nn24">6.15.1 Dispatch function generation</a></H3>
<p>
If you're still confused, don't worry about it---SWIG is probably doing the right thing.
</p>
-<H3><a name="SWIGPlus_nn25"></a>6.15.2 Ambiguity in Overloading</H3>
+<H3><a name="SWIGPlus_nn25">6.15.2 Ambiguity in Overloading</a></H3>
<p>
</p>
<p>
-When wrapping an overloaded function, there is a chance that you will get an error message like this:
+When wrapping an overloaded function, there is a chance that you will get a warning message like this:
</p>
<div class="shell">
<pre>
-example.i:3: Warning 467: Overloaded foo(int) not supported (no type checking
-rule for 'int').
+example.i:3: Warning 467: Overloaded foo(int) not supported (incomplete type checking rule -
+no precedence level in typecheck typemap for 'int').
</pre>
</div>
but for some reason there is no type-checking rule that can be used to
generate a working dispatch function. The resulting behavior is then
undefined. You should report this as a bug to the
-<a href="http://www.swig.org/bugs.html">SWIG bug tracking database</a>.
+<a href="http://www.swig.org/bugs.html">SWIG bug tracking database</a>
+if this is due to one of the typemaps supplied with SWIG.
</p>
<p>
functions and methods. The only way to fix the problem is to read the next section.
</p>
-<H3><a name="SWIGPlus_ambiguity_resolution_renaming"></a>6.15.3 Ambiguity resolution and renaming</H3>
+<H3><a name="SWIGPlus_ambiguity_resolution_renaming">6.15.3 Ambiguity resolution and renaming</a></H3>
<p>
<li><p>
Currently no resolution is performed in order to match function parameters. This means function parameter types must match exactly.
For example, namespace qualifiers and typedefs will not work. The following usage of typedefs demonstrates this:
+</p>
<div class="code">
<pre>
</ul>
-<H3><a name="SWIGPlus_nn27"></a>6.15.4 Comments on overloading</H3>
+<H3><a name="SWIGPlus_nn27">6.15.4 Comments on overloading</a></H3>
<p>
than dynamically typed languages like Perl, Python, Ruby, and Tcl.
</p>
-<H2><a name="SWIGPlus_nn28"></a>6.16 Wrapping overloaded operators</H2>
+<H2><a name="SWIGPlus_nn28">6.16 Wrapping overloaded operators</a></H2>
<p>
}
Complex operator*(const Complex &c) const {
return Complex(rpart*c.rpart - ipart*c.ipart,
- rpart*c.ipart + c.rpart*ipart);
+ rpart*c.ipart + c.rpart*ipart);
}
Complex operator-() const {
return Complex(-rpart, -ipart);
</li>
</ul>
-<H2><a name="SWIGPlus_class_extension"></a>6.17 Class extension</H2>
+<H2><a name="SWIGPlus_class_extension">6.17 Class extension</a></H2>
<p>
class Vector {
public:
- double x,y,z;
- Vector();
- ~Vector();
- ... bunch of C++ methods ...
- %extend {
- char *__str__() {
- static char temp[256];
- sprintf(temp,"[ %g, %g, %g ]", $self->x,$self->y,$self->z);
- return &temp[0];
- }
- }
+ double x,y,z;
+ Vector();
+ ~Vector();
+ ... bunch of C++ methods ...
+ %extend {
+ char *__str__() {
+ static char temp[256];
+ sprintf(temp,"[ %g, %g, %g ]", $self->x,$self->y,$self->z);
+ return &temp[0];
+ }
+ }
};
</pre></div>
<p>
-This code adds a<tt> __str__</tt> method to our class for producing a
+This code adds a <tt>__str__</tt> method to our class for producing a
string representation of the object. In Python, such a method would
allow us to print the value of an object using the <tt>print</tt>
command.
<p>
The following special variables are expanded if used within a %extend block:
-$name, $symname, $overname, $decl, $fulldecl, $parentname and $parentsymname.
+$name, $symname, $overname, $decl, $fulldecl, $parentclassname and $parentclasssymname.
The <a href="Customization.html#Customization_exception_special_variables">Special variables</a> section provides more information each of these special variables.
</p>
<p>
-The<tt> %extend</tt> directive follows all of the same conventions
+The <tt>%extend</tt> directive follows all of the same conventions
as its use with C structures. Please refer to the <a href="SWIG.html#SWIG_adding_member_functions">Adding member functions to C structures</a>
section for further details.
</p>
directive name has been chosen.
</p>
-<H2><a name="SWIGPlus_nn30"></a>6.18 Templates</H2>
+<H2><a name="SWIGPlus_nn30">6.18 Templates</a></H2>
<p>
template<class T> class List {
...
public:
- List() { };
+ List() { }
T get(int index);
...
};
</p>
<p>
-Needless to say, SWIG's template support provides plenty of
-opportunities to break the universe. That said, an important final
-point is that <b>SWIG does not perform extensive error checking of
-templates!</b> Specifically, SWIG does not perform type checking nor
-does it check to see if the actual contents of the template
-declaration make any sense. Since the C++ compiler will hopefully
-check this when it compiles the resulting wrapper file, there is no
-practical reason for SWIG to duplicate this functionality (besides,
-none of the SWIG developers are masochistic enough to want to
-implement this right now).
+Needless to say, SWIG's template support provides plenty of opportunities to
+break the universe. That said, an important final point is that <b>SWIG does
+not perform extensive error checking of templates!</b> Specifically, SWIG does
+not perform type checking nor does it check to see if the actual contents of the
+template declaration make any sense. Since the C++ compiler checks this when it
+compiles the resulting wrapper file, there is no practical reason for SWIG to
+duplicate this functionality.
+</p>
+
+<a name="SWIGPlus_template_nested_class_example"></a>
+<p>
+As SWIG's template support does not perform type checking <tt>%template</tt>
+can be used as early as after a template declaration. You can, and rarely have
+to, use <tt>%template</tt> before the template parameters have been declared.
+For example:
</p>
+<div class="code">
+<pre>
+template <class T> class OuterTemplateClass {};
+
+// The nested class OuterClass::InnerClass inherits from the template class
+// OuterTemplateClass<OuterClass::InnerStruct> and thus the template needs
+// to be expanded with %template before the OuterClass declaration.
+%template(OuterTemplateClass_OuterClass__InnerStruct)
+ OuterTemplateClass<OuterClass::InnerStruct>
+
+
+// Don't forget to use %feature("flatnested") for OuterClass::InnerStruct and
+// OuterClass::InnerClass if the target language doesn't support nested classes.
+class OuterClass {
+ public:
+ // Forward declarations:
+ struct InnerStruct;
+ class InnerClass;
+};
+
+struct OuterClass::InnerStruct {};
+
+// Expanding the template at this point with %template is too late as the
+// OuterClass::InnerClass declaration is processed inside OuterClass.
+
+class OuterClass::InnerClass : public OuterTemplateClass<InnerStruct> {};
+</pre>
+</div>
+
<p>
<b>Compatibility Note</b>: The first implementation of template support relied heavily on
macro expansion in the preprocessor. Templates have been more tightly integrated into
Similar changes apply to typemaps and other customization features.
</p>
-<H2><a name="SWIGPlus_namespaces"></a>6.19 Namespaces</H2>
+<H2><a name="SWIGPlus_namespaces">6.19 Namespaces</a></H2>
<p>
more advanced namespace support.
</p>
-<H3><a name="SWIGPlus_nspace"></a>6.19.1 The nspace feature for namespaces</H3>
+<H3><a name="SWIGPlus_nspace">6.19.1 The nspace feature for namespaces</a></H3>
<p>
<b>Compatibility Note:</b> The nspace feature was first introduced in SWIG-2.0.0.
</p>
-<H2><a name="SWIGPlus_renaming_templated_types_namespaces"></a>6.20 Renaming templated types in namespaces</H2>
+<H2><a name="SWIGPlus_renaming_templated_types_namespaces">6.20 Renaming templated types in namespaces</a></H2>
<p>
</div>
-<H2><a name="SWIGPlus_exception_specifications"></a>6.21 Exception specifications</H2>
+<H2><a name="SWIGPlus_exception_specifications">6.21 Exception specifications</a></H2>
<p>
The next section details a way of simulating an exception specification or replacing an existing one.
</p>
-<H2><a name="SWIGPlus_catches"></a>6.22 Exception handling with %catches</H2>
+<H2><a name="SWIGPlus_catches">6.22 Exception handling with %catches</a></H2>
<p>
</p>
-<H2><a name="SWIGPlus_nn33"></a>6.23 Pointers to Members</H2>
+<H2><a name="SWIGPlus_nn33">6.23 Pointers to Members</a></H2>
<p>
for member pointers.
</p>
-<H2><a name="SWIGPlus_smart_pointers"></a>6.24 Smart pointers and operator->()</H2>
+<H2><a name="SWIGPlus_smart_pointers">6.24 Smart pointers and operator->()</a></H2>
<p>
<b>Note:</b> Smart pointer support was first added in SWIG-1.3.14.
</p>
-<H2><a name="SWIGPlus_ref_unref"></a>6.25 C++ reference counted objects - ref/unref feature</H2>
+<H2><a name="SWIGPlus_ref_unref">6.25 C++ reference counted objects - ref/unref feature</a></H2>
<p>
Another similar idiom in C++ is the use of reference counted objects. Consider for example:
+</p>
<div class="code">
<pre>
return add_ref();
}
- int unref() const {
+ int unref() const {
if (ref_count() == 0 || del_ref() == 0 ) {
- delete this;
- return 0;
- }
+ delete this;
+ return 0;
+ }
return ref_count();
}
};
-<H2><a name="SWIGPlus_nn35"></a>6.26 Using declarations and inheritance</H2>
+<H2><a name="SWIGPlus_nn35">6.26 Using declarations and inheritance</a></H2>
<p>
</div>
</ul>
-<H2><a name="SWIGPlus_nested_classes"></a>6.27 Nested classes</H2>
+<H2><a name="SWIGPlus_nested_classes">6.27 Nested classes</a></H2>
<p>
-There is some support for nested structs and unions when wrapping C code,
-see <a href="SWIG.html#SWIG_nested_structs">Nested structures</a> for further details.
-The added complexity of C++ compared to C means this approach does not work well for
-C++ code (when using the -c++ command line option).
-For C++, a nested class is treated much like an opaque pointer, so anything useful within the nested class, such as its
-methods and variables, are not accessible from the target language.
-True nested class support may be added to SWIG in the future, however,
-until then some of the following workarounds can be applied to improve the situation.
+If the target language supports the nested classes concept (like Java), the nested C++ classes
+are wrapped as nested target language proxy classes. (In case of Java - "static" nested classes.)
+Only public nested classes are wrapped. Otherwise there is little difference between nested and
+normal classes.
</p>
-
<p>
-It might be possible to use partial class information as often you can accept that the nested class is not needed,
-especially if it is not actually used in any methods you need from the target language.
-Imagine you are wrapping the following <tt>Outer</tt> class which contains a nested class <tt>Inner</tt>.
-The easiest thing to do is turn a blind eye to the warning that SWIG generates, or simply suppress it:
+If the target language doesn't support nested classes directly, or the support is not implemented in the
+language module (like for python currently), then the visible nested classes are moved to the same name
+space as the containing class (nesting hierarchy is "flattened"). The same behaviour may be turned on for
+C# and Java by the %feature ("flatnested"); If there is a class with the same name in the outer namespace
+the inner class (or the global one) may be renamed or ignored:
</p>
<div class="code">
<pre>
-%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) Outer::Inner;
-
-class Outer {
-public:
- class Inner {
- public:
- ...
- };
- Inner getInner();
- void useInner(const Inner& inner);
- ...
-};
-</pre>
-</div>
-
-<p>
-Note that if <tt>Inner</tt> can be used as an opaque type, the default wrapping approach suffices.
-For example, if the nested class does not need to be created from the target language, but can be obtained via a method
-call, such as the <tt>getInner()</tt> method above, the returned value can then be passed around, such as passed into the
-<tt>useInner()</tt> method.
-</p>
-
-<p>
-With some more effort the above situation can be improved somewhat and a nested class can be constructed and used
-from the target language much like any other non-nested class. Assuming we have the <tt>Outer</tt> class in a header file:
-</p>
-
-<div class="code">
-<pre>
-// File outer.h
-class Outer {
-public:
- class Inner {
- public:
- int var;
- Inner(int v = 0) : var(v) {}
- };
- Inner getInner();
- void useInner(const Inner& inner);
-};
-</pre>
-</div>
-
-<p>
-The following interface file works around the nested class limitations by redefining the nested class as a global class.
-A typedef for the compiler and the <tt>nestedworkaround</tt>
-<a href="Customization.html#Customization_feature_flags">feature flag</a> is also required in
-order for the generated wrappers to compile. This flag simply removes all the type information from SWIG, so SWIG treats
-the nested class as if it had not been parsed at all.
-</p>
-
-<div class="code">
-<pre>
-// File : example.i
-%module example
-
-// Redefine nested class in global scope in order for SWIG to generate
-// a proxy class. Only SWIG parses this definition.
-class Inner {
+%rename (Bar_Foo) Bar::Foo;
+class Foo {};
+class Bar {
public:
- int var;
- Inner(int v = 0) : var(v) {}
+ class Foo {};
};
-
-%nestedworkaround Outer::Inner;
-
-%{
-#include "outer.h"
-%}
-%include "outer.h"
-
-// We've fooled SWIG into thinking that Inner is a global class, so now we need
-// to trick the C++ compiler into understanding this apparent global type.
-%{
-typedef Outer::Inner Inner;
-%}
</pre>
</div>
<p>
-The downside to this approach is a more complex interface file and having to maintain two definitions of <tt>Inner</tt>,
-the real one and the one in the interface file that SWIG parses.
-However, the upside is that all the methods/variables in the nested class are available from the target language
-as a proxy class is generated instead of treating the nested class as an opaque type.
-The proxy class can be constructed from the target language and passed into any methods accepting the nested class.
-Also note that the original header file is parsed unmodified.
+If a nested class, within an outer class, has to be used as a template parameter within the outer class, then the template will
+have to be instantiated with <tt>%template</tt> before the beginning of the outer class.
+An example can be found in the
+<a href="#SWIGPlus_template_nested_class_example">Templates</a> section.
</p>
<p>
-Finally, conditional compilation can be used as a workaround to comment out nested class definitions in the actual headers,
-assuming you are able to modify them.
+<b>Compatibility Note:</b>
+Prior to SWIG-3.0.0, there was limited nested class support. Nested classes were treated as opaque pointers.
+However, there was a workaround for nested class support in these older versions requiring the user to replicate
+the nested class in the global scope, adding in a typedef for the nested class in the global scope and
+using the "nestedworkaround" feature on the nested class. This resulted in approximately the
+same behaviour as the "flatnested" feature. With proper nested class support now available in SWIG-3.0.0, this
+feature has been deprecated and no longer works requiring code changes. If you see the following warning:
</p>
-<div class="code">
+<div class="shell">
<pre>
-// File outer.h
-class Outer {
-public:
-#ifndef SWIG
- class Inner {
- public:
- ...
- };
-#endif
- ...
-};
+example.i:8: Warning 126: The nestedworkaround feature is deprecated
</pre>
</div>
<p>
-This workaround used to be common when SWIG could not deal with nested classes particulary well.
-This should just be a last resort for unusual corner cases now as SWIG can parse nested classes and even handle nested template classes fairly well.
+consider using the "flatnested" feature discussed above which generates a non-nested proxy class, like the
+"nestedworkaround" feature did. Alternatively, use the default nested class code generation, which may generate an
+equivalent to a nested proxy class in the target language, depending on the target language support.
</p>
<p>
-<b>Compatibility Note:</b> SWIG-1.3.40 and earlier versions did not have the <tt>nestedworkaround</tt> feature
+SWIG-1.3.40 and earlier versions did not have the <tt>nestedworkaround</tt> feature
and the generated code resulting from parsing nested classes did not always compile.
Nested class warnings could also not be suppressed using %warnfilter.
</p>
-<H2><a name="SWIGPlus_const"></a>6.28 A brief rant about const-correctness</H2>
+<H2><a name="SWIGPlus_const">6.28 A brief rant about const-correctness</a></H2>
<p>
of your project.
</p>
-<H2><a name="SWIGPlus_nn42"></a>6.29 Where to go for more information</H2>
+<H2><a name="SWIGPlus_nn42">6.29 Where to go for more information</a></H2>
<p>
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<title>SWIG and Scilab</title>
+<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
+</head>
+
+
+<body bgcolor="#ffffff">
+
+<H1><a name="Scilab">39 SWIG and Scilab</a></H1>
+<!-- INDEX -->
+<div class="sectiontoc">
+<ul>
+<li><a href="#Scilab_preliminaries">Preliminaries</a>
+<li><a href="#Scilab_running_swig">Running SWIG</a>
+<ul>
+<li><a href="#Scilab_running_swig_generating_module">Generating the module</a>
+<li><a href="#Scilab_running_swig_building_module">Building the module</a>
+<li><a href="#Scilab_running_swig_loading_module">Loading the module</a>
+<li><a href="#Scilab_running_swig_using_module">Using the module</a>
+<li><a href="#Scilab_running_swig_options">Scilab command line options</a>
+</ul>
+<li><a href="#Scilab_wrapping">A basic tour of C/C++ wrapping</a>
+<ul>
+<li><a href="#Scilab_wrapping_overview">Overview</a>
+<li><a href="#Scilab_wrapping_identifiers">Identifiers</a>
+<li><a href="#Scilab_wrapping_functions">Functions</a>
+<ul>
+<li><a href="#Scilab_nn13">Argument passing</a>
+<li><a href="#Scilab_nn14">Multiple output arguments</a>
+</ul>
+<li><a href="#Scilab_wrapping_global_variables">Global variables</a>
+<li><a href="#Scilab_wrapping_constants_and_enums">Constants and enumerations</a>
+<ul>
+<li><a href="#Scilab_wrapping_constants">Constants</a>
+<li><a href="#Scilab_wrapping_enums">Enumerations</a>
+</ul>
+<li><a href="#Scilab_wrapping_pointers">Pointers</a>
+<ul>
+<li><a href="#Scilab_wrapping_pointers_pointer_adresses">Utility functions</a>
+<li><a href="#Scilab_wrapping_pointers_null_pointers">Null pointers:</a>
+</ul>
+<li><a href="#Scilab_wrapping_structs">Structures</a>
+<li><a href="#Scilab_wrapping_cpp_classes">C++ classes</a>
+<li><a href="#Scilab_wrapping_cpp_inheritance">C++ inheritance</a>
+<li><a href="#Scilab_wrapping_cpp_overloading">C++ overloading</a>
+<li><a href="#Scilab_wrapping_pointers_references_values_arrays">Pointers, references, values, and arrays</a>
+<li><a href="#Scilab_wrapping_cpp_templates">C++ templates</a>
+<li><a href="#Scilab_wrapping_cpp_operators">C++ operators</a>
+<li><a href="#Scilab_wrapping_cpp_namespaces">C++ namespaces</a>
+<li><a href="#Scilab_wrapping_cpp_exceptions">C++ exceptions</a>
+<li><a href="#Scilab_wrapping_cpp_stl">C++ STL</a>
+</ul>
+<li><a href="#Scilab_typemaps">Type mappings and libraries</a>
+<ul>
+<li><a href="#Scilab_typemaps_primitive_types">Default primitive type mappings</a>
+<li><a href="#Scilab_typemaps_arrays">Arrays</a>
+<li><a href="#Scilab_typemaps_pointer-to-pointers">Pointer-to-pointers</a>
+<li><a href="#Scilab_typemaps_matrices">Matrices</a>
+<li><a href="#Scilab_typemaps_stl">STL</a>
+</ul>
+<li><a href="#Scilab_module_initialization">Module initialization</a>
+<li><a href="#Scilab_building_modes">Building modes</a>
+<ul>
+<li><a href="#Scilab_building_modes_nobuilder_mode">No-builder mode</a>
+<li><a href="#Scilab_building_modes_builder_mode">Builder mode</a>
+</ul>
+<li><a href="#Scilab_generated_scripts">Generated scripts</a>
+<ul>
+<li><a href="#Scilab_generated_scripts_builder_script">Builder script</a>
+<li><a href="#Scilab_generated_scripts_loader_script">Loader script</a>
+</ul>
+<li><a href="#Scilab_other_resources">Other resources</a>
+</ul>
+</div>
+<!-- INDEX -->
+
+
+
+<p>
+Scilab is a scientific software package for numerical computations providing a powerful open computing environment for engineering and scientific applications that is mostly compatible with MATLAB. More information can be found at <a href="http://www.scilab.org">www.scilab.org</a>.
+</p>
+
+<p>
+This chapter explains how to use SWIG for Scilab. After this introduction, you should be able to generate with SWIG a Scilab external module from a C/C++ library.
+</p>
+
+
+<H2><a name="Scilab_preliminaries">39.1 Preliminaries</a></H2>
+
+
+<p>
+SWIG for Scilab supports Linux. Other operating sytems haven't been tested.
+</p>
+
+<p>
+Scilab is supported from version 5.3.3 onwards.
+The forthcoming version 6, as of January 2015, is also supported.
+</p>
+
+<p>
+SWIG for Scilab supports C language. C++ is partially supported. See <a href="#Scilab_wrapping">A basic tour of C/C++ wrapping</a> for further details.
+</p>
+
+
+<H2><a name="Scilab_running_swig">39.2 Running SWIG</a></H2>
+
+
+<p>
+Let's see how to use SWIG for Scilab on a small example.
+<br>
+In this example we bind from C a function and a global variable into Scilab. The SWIG interface (stored in a file named <tt>example.i</tt>), is the following:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%inline %{
+double Foo = 3.0;
+
+int fact(int n) {
+ if (n < 0) {
+ return 0;
+ }
+ else if (n == 0) {
+ return 1;
+ }
+ else {
+ return n * fact(n-1);
+ }
+}
+%}
+</pre></div>
+
+<p>
+Note: a code in an <tt>%inline</tt> section is both parsed and wrapped by SWIG, and inserted as is in the wrapper source file.
+</p>
+
+
+<H3><a name="Scilab_running_swig_generating_module">39.2.1 Generating the module</a></H3>
+
+
+<p>
+The module is generated using the <tt>swig</tt> executable and its <tt>-scilab</tt> option.
+</p>
+
+<div class="shell"><pre>
+$ swig -scilab example.i
+</pre></div>
+
+<p>
+This command generates two files:
+</p>
+<ul>
+<li><tt>example_wrap.c</tt>: a C source file containing the wrapping code and also here the wrapped code (the <tt>fact()</tt> and <tt>Foo</tt> definitions)</li>
+<li><tt>loader.sce</tt>: a Scilab script used to load the module into Scilab
+</ul>
+
+<p>
+Note: if the following error is returned:
+</p>
+
+<div class="shell"><pre>
+:1: Error: Unable to find 'swig.swg'
+:3: Error: Unable to find 'scilab.swg'
+</pre></div>
+
+<p>
+it may be because the SWIG library is not found. Check the <tt>SWIG_LIB</tt> environment variable or your SWIG installation.
+</p>
+
+<p>
+Note: SWIG for Scilab can work in two modes related to the way the module is built, see the <a href="#Scilab_building_modes">Building modes</a> section for details.
+This example uses the <tt>builder</tt> mode.
+</p>
+
+
+<p>
+The <tt>swig</tt> executable has several other command line options you can use. See <a href="#Scilab_running_swig_options">Scilab command line options</a> for further details.
+</p>
+
+
+<H3><a name="Scilab_running_swig_building_module">39.2.2 Building the module</a></H3>
+
+
+<p>
+To be loaded in Scilab, the wrapper has to be built into a dynamic module (or shared library).
+</p>
+
+<p>
+The commands to compile and link the wrapper (with <tt>gcc</tt>) into the shared library <tt>libexample.so</tt> are:
+</p>
+
+<div class="shell"><pre>
+$ gcc -fPIC -c -I/usr/local/include/scilab example_wrap.c
+$ gcc -shared example_wrap.o -o libexample.so
+</pre></div>
+
+<p>
+Note: we supposed in this example that the path to the Scilab include directory is <tt>/usr/local/include/scilab</tt> (which is the case in a Debian environment), this should be changed for another environment.
+</p>
+
+<H3><a name="Scilab_running_swig_loading_module">39.2.3 Loading the module</a></H3>
+
+
+<p>
+Loading a module is done by running the loader script in Scilab:
+</p>
+
+<div class="targetlang"><pre>
+--> exec loader.sce
+</pre></div>
+
+<p>
+Scilab should output the following messages:
+</p>
+
+<div class="targetlang"><pre>
+Shared archive loaded.
+Link done.
+</pre></div>
+
+<p>
+which means that Scilab has successfully loaded the shared library. The module functions and other symbols are now available in Scilab.
+</p>
+
+<H3><a name="Scilab_running_swig_using_module">39.2.4 Using the module</a></H3>
+
+
+<p>
+In Scilab, the function <tt>fact()</tt> is simply called as following:
+</p>
+
+<div class="targetlang"><pre>
+--> fact(5)
+ans =
+
+ 120.
+</pre></div>
+
+<p>For the <tt>Foo</tt> global variable, the accessors need to be used:
+
+<div class="targetlang"><pre>
+--> Foo_get
+ans =
+
+ 3.
+
+--> Foo_set(4);
+
+--> Foo_get
+ans =
+
+ 4.
+</pre></div>
+
+<p>
+Note: for conciseness, we assume in the subsequent Scilab code examples that the modules have been beforehand built and loaded in Scilab.
+</p>
+
+<H3><a name="Scilab_running_swig_options">39.2.5 Scilab command line options</a></H3>
+
+
+<p>
+The following table lists the Scilab specific command line options in addition to the generic SWIG options:
+</p>
+
+<table summary="Scilab specific options">
+
+<tr>
+<td><tt>-builder</tt></td>
+<td>Generate the Scilab builder script</td>
+</tr>
+
+<tr>
+<td><tt>-buildercflags <cflags></tt></td>
+<td>Add <cflags> to the builder compiler flags</td>
+</tr>
+
+<tr>
+<td><tt>-builderldflags <ldflags></tt></td>
+<td>Add <ldlags> to the builder linker flags</td>
+</tr>
+
+<tr>
+<td><tt>-buildersources <files></tt></td>
+<td>Add the (comma separated) files <files> to the builder sources</td>
+</tr>
+
+<tr>
+<td><tt>-builderverbositylevel <level></tt></td>
+<td>Set the build verbosity level to <level> (default 0: off, 2: high)</td>
+</tr>
+
+<tr>
+<td><tt>-builderflagscript <file></tt></td>
+<td>Use the Scilab script <file> to configure the compiler and linker flags</td>
+</tr>
+
+<tr>
+<td><tt>-gatewayxml <gateway_id></tt></td>
+<td>Generate the gateway XML with the given <gateway_id></td>
+</tr>
+
+</table>
+
+<p>
+These options can be displayed with:
+</p>
+
+<div class="shell"><pre>
+$ swig -scilab -help
+</pre></div>
+
+
+<H2><a name="Scilab_wrapping">39.3 A basic tour of C/C++ wrapping</a></H2>
+
+
+<H3><a name="Scilab_wrapping_overview">39.3.1 Overview</a></H3>
+
+
+<p>
+SWIG for Scilab provides only a low-level C interface for Scilab (see <a href="Scripting.html#Scripting">Scripting Languages</a> for the general approach to wrapping).
+This means that functions, structs, classes, variables, etc... are interfaced through C functions. These C functions are mapped as Scilab functions.
+There are a few exceptions, such as constants and enumerations, which can be wrapped directly as Scilab variables.
+</p>
+
+<H3><a name="Scilab_wrapping_identifiers">39.3.2 Identifiers</a></H3>
+
+
+<p>
+In Scilab 5.x, identifier names are composed of 24 characters maximum (this limitation should disappear from Scilab 6.0 onwards).
+<br>Thus long function or variable names may be truncated and this can cause ambiguities.
+</p>
+<p>This happens especially when wrapping structs/classes, for which the wrapped function name is composed of the struct/class name and field names.
+In these cases, the <a href="SWIG.html#SWIG_rename_ignore">%rename directive</a> can be used to choose a different Scilab name.
+</p>
+
+<H3><a name="Scilab_wrapping_functions">39.3.3 Functions</a></H3>
+
+
+<p>
+Functions are wrapped as new Scilab built-in functions. For example:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%inline %{
+int fact(int n) {
+ if (n > 1)
+ return n * fact(n - 1);
+ else
+ return 1;
+}
+%}
+</pre></div>
+
+<p>
+creates a built-in function <tt>fact(n)</tt> in Scilab:
+</p>
+
+<div class="targetlang"><pre>
+--> fact(4)
+ans =
+
+ 24.
+</pre></div>
+
+<H4><a name="Scilab_nn13">39.3.3.1 Argument passing</a></H4>
+
+
+<p>
+In the above example, the function parameter is a primitive type and is marshalled by value.
+So this function is wrapped without any additional customization.
+Argument values are converted between C types and Scilab types through type mappings.
+There are several default type mappings for primitive and complex types, described later in the <a href="#Scilab_typemaps">Scilab typemaps</a> section.
+</p>
+
+<p>
+When a parameter is not passed by value, such as a pointer or reference, SWIG does not know if it is an input, output (or both) parameter.
+The INPUT, OUTPUT, INOUT typemaps defined in the <tt>typemaps.i</tt> library can be used to specify this.
+</p>
+
+<p>
+Let's see this on two simple functions: <tt>sub()</tt> which has an output parameter, and <tt>inc()</tt>, which as input/output parameter:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%include <typemaps.i>
+
+extern void sub(int *INPUT, int *INPUT, int *OUTPUT);
+extern void inc(int *INOUT, int *INPUT);
+
+%{
+void sub(int *x, int *y, int *result) {
+ *result = *x - *y;
+}
+void inc(int *x, int *delta) {
+ *x = *x + *delta;
+}
+%}
+</pre></div>
+
+<p>
+In Scilab, parameters are passed by value. The output (and inout) parameters are returned as the result of the functions:
+</p>
+
+<div class="targetlang"><pre>
+--> sub(5, 3)
+ ans =
+
+ 2.
+
+--> inc(4, 3)
+ ans =
+
+ 7.
+</pre></div>
+
+<H4><a name="Scilab_nn14">39.3.3.2 Multiple output arguments</a></H4>
+
+
+<p>
+A C function can have several output parameters. They can all be returned as results of the wrapped function as Scilab supports multiple return values from a function
+when using the <tt>typemaps.i</tt> library.
+If the C function itself returns a result, this is returned first before the parameter outputs.
+</p>
+
+<p>
+The example below shows this for a C function returning 2 values and a result:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%include <typemaps.i>
+
+int divide(int n, int d, int *OUTPUT, int *OUTPUT);
+
+%{
+int divide(int n, int d, int q*, int *r) {
+ if (d != 0) {
+ *q = n / d;
+ *r = n % d;
+ return 1;
+ }
+ else return 0;
+}
+%}
+</pre></div>
+
+<br/>
+
+<div class="targetlang"><pre>
+--> [ret, q, r] = divide(20, 6)
+ r =
+
+ 2.
+ q =
+
+ 3.
+ ret =
+
+ 1.
+</pre></div>
+
+
+<H3><a name="Scilab_wrapping_global_variables">39.3.4 Global variables</a></H3>
+
+
+<p>
+Global variables are manipulated through generated accessor functions.
+For example, for a given <tt>Foo</tt> global variable, SWIG actually generates two functions: <tt>Foo_get()</tt> to get the value of <tt>Foo</tt>, and <tt>Foo_set()</tt> to set the value.
+These functions are used as following:
+</p>
+
+<div class="targetlang"><pre>
+--> exec loader.sce;
+--> c = Foo_get();
+
+--> Foo_set(4);
+
+--> c
+c =
+
+ 3.
+
+--> Foo_get()
+ans =
+
+ 4.
+</pre></div>
+
+<p>
+It works for variables of primitive type, but also for non-primitive types: arrays, and structs/classes which are described later.
+For now, an example with two global primitive arrays x and y is shown:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%inline %{
+int x[10];
+double y[7];
+
+void initArrays()
+{
+ int i;
+ for (i = 0; i < 10; i++)
+ x[i] = 1;
+ for (i = 0; i < 7; i++)
+ y[i] = 1.0f;
+}
+%}
+</pre></div>
+
+<p>
+It works the same:</p>
+
+<div class="targetlang"><pre>
+--> exec loader.sce
+
+--> initArrays();
+--> x_get()
+ ans =
+
+ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.
+
+--> y_set([0:6] / 10);
+--> y_get()
+ ans =
+
+ 0. 0.1 0.2 0.3 0.4 0.5 0.6
+</pre></div>
+
+
+<H3><a name="Scilab_wrapping_constants_and_enums">39.3.5 Constants and enumerations</a></H3>
+
+
+<H4><a name="Scilab_wrapping_constants">39.3.5.1 Constants</a></H4>
+
+
+<p>
+There is not any constant in Scilab. By default, C/C++ constants are wrapped as getter functions. For example, for the following constants:
+</p>
+
+<div class="code"><pre>
+%module example
+#define ICONST 42
+#define FCONST 2.1828
+#define CCONST 'x'
+#define CCONST2 '\n'
+#define SCONST "Hello World"
+#define SCONST2 "\"Hello World\""
+</pre></div>
+
+<p>
+the following getter functions are generated:
+</p>
+
+<div class="targetlang"><pre>
+--> exec loader.sce;
+--> ICONST_get();
+ ans =
+
+ 42.
+
+--> FCONST_get();
+ ans =
+
+ 2.1828
+
+--> CCONST_get();
+ ans =
+
+ x
+
+--> CCONST2_get();
+ ans =
+
+--> SCONST_get();
+ ans =
+
+ Hello World
+
+--> SCONST2_get();
+ ans =
+
+ "Hello World"
+
+--> EXPR_get();
+ ans =
+
+ 48.5484
+
+--> iconst_get();
+ ans =
+
+ 37.
+
+--> fconst_get();
+ ans =
+
+ 3.14
+</pre></div>
+
+<p>
+There is another mode in which constants are wrapped as Scilab variables.
+The variables are easier to use than functions, but the drawback is that variables are not constant and so can be modified.
+</p>
+
+<p>
+This mode can be enabled/disabled at any time in the interface file with <tt>%scilabconst()</tt>, which
+works like all the other <a href="Customization.html#Customization_features">%feature directives</a>.
+Use the argument value "1" to enable and "0" to disable this mode.
+For example in this mode the previous constants:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%scilabconst(1);
+#define ICONST 42
+#define FCONST 2.1828
+#define CCONST 'x'
+#define CCONST2 '\n'
+#define SCONST "Hello World"
+#define SCONST2 "\"Hello World\""
+</pre></div>
+
+<p>
+are mapped to Scilab variables, with the same name:
+</p>
+
+<div class="targetlang"><pre>
+--> exec loader.sce;
+--> ICONST
+ ans =
+
+ 42
+
+--> FCONST
+ ans =
+
+ 2.1828
+
+--> CCONST
+ ans =
+
+ x
+
+--> CCONST2
+ ans =
+
+--> SCONST
+ ans =
+
+ Hello World
+
+--> SCONST2
+ ans =
+
+ "Hello World"
+
+--> EXPR
+ ans =
+
+ 48.5484
+
+--> iconst
+ ans =
+
+ 37
+
+--> fconst
+ ans =
+
+ 3.14
+</pre></div>
+
+<H4><a name="Scilab_wrapping_enums">39.3.5.2 Enumerations</a></H4>
+
+
+<p>
+The wrapping of enums is the same as for constants.
+By default, enums are wrapped as getter functions.
+For example, with the following enumeration:
+</p>
+
+<div class="code"><pre>%module example
+typedef enum { RED, BLUE, GREEN } color;
+</pre></div>
+
+<p>
+a getter function will be generated for each value of the enumeration:
+</p>
+
+<div class="targetlang"><pre>
+--> exec loader.sce;
+--> RED_get()
+ ans =
+
+ 0.
+
+--> BLUE_get()
+ ans =
+
+ 1.
+
+--> GREEN_get()
+ ans =
+
+ 2.
+</pre></div>
+
+<p>
+The <tt>%scilabconst()</tt> feature is also available for enumerations:
+</p>
+
+<div class="code"><pre>%module example
+%scilabconst(1) color;
+typedef enum { RED, BLUE, GREEN } color;
+</pre></div>
+
+<br/>
+
+<div class="targetlang"><pre>
+--> exec loader.sce;
+--> RED
+ ans =
+
+ 0.
+
+--> BLUE
+ ans =
+
+ 1.
+
+--> GREEN
+ ans =
+
+ 2.
+
+</pre></div>
+
+<H3><a name="Scilab_wrapping_pointers">39.3.6 Pointers</a></H3>
+
+
+<p>
+Pointers are supported by SWIG. A pointer can be returned from a wrapped C/C++ function, stored in a Scilab variable, and used in input argument of another C/C++ function.
+</p>
+<p>
+Also, thanks to the SWIG runtime which stores informations about types, pointer types are tracked between exchanges Scilab and the native code. Indeed pointer types are stored alongside the pointer adress.
+A pointer is mapped to a Scilab structure (<a href="https://help.scilab.org/docs/5.5.2/en_US/tlist.html">tlist</a>), which contains as fields the pointer address and the pointer type (in fact a pointer to the type information structure in the SWIG runtime).
+<br>
+Why a native pointer is not mapped to a Scilab pointer (type name: "pointer", type ID: 128) ? The big advantage of mapping to a <tt>tlist</tt> is that it exposes a new type for the pointer in Scilab, type which can be acessed in Scilab with the <a href="https://help.scilab.org/docs/5.5.2/en_US/typeof.html">typeof</a> function, and manipulated using the <a href="https://help.scilab.org/docs/5.5.2/en_US/overloading.html">overloading</a> mechanism.
+</p>
+
+<p>
+Notes:
+</p>
+<ul>
+<li>type tracking needs the SWIG runtime to be first initialized with the appropriate function (see the <a href="#Scilab_module_initialization">Module initialization</a> section).</li>
+<li>for any reason, if a wrapped pointer type is unknown (or if the SWIG runtime is not initialized), SWIG maps it to a Scilab pointer. Also, a Scilab pointer is always accepted as a pointer argument of a wrapped function. The drawaback is that pointer type is lost.</li>
+</ul>
+
+<p>
+Following is an example of the wrapping of the C <tt>FILE*</tt> pointer:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%{
+#include <stdio.h>
+%}
+
+FILE *fopen(const char *filename, const char *mode);
+int fputs(const char *, FILE *);
+int fclose(FILE *);
+</pre></div>
+
+<p>
+These functions can be used the same way as in C from Scilab:
+</p>
+
+<div class="targetlang"><pre>
+--> example_Init();
+
+--> f = fopen("junk", "w");
+--> typeof(f)
+ ans =
+
+ _p_FILE
+
+--> fputs("Hello World", f);
+--> fclose(f);
+</pre></div>
+
+<p>
+Note: the type name <tt>_p_FILE</tt> which means "pointer to FILE".
+</p>
+
+<p>
+The user of a pointer is responsible for freeing it or, like in the example, closing any resources associated with it (just as is required in a C program).
+</p>
+
+<H4><a name="Scilab_wrapping_pointers_pointer_adresses">39.3.6.1 Utility functions</a></H4>
+
+
+<p>
+As a scripting language, Scilab does not provide functions to manipulate pointers.
+However, in some cases it can be useful, such as for testing or debugging.
+</p>
+
+<p>
+SWIG comes with two pointer utility functions:
+</p>
+<ul>
+<li><tt>SWIG_this()</tt>: returns the address value of a pointer</li>
+<li><tt>SWIG_ptr()</tt>: creates a pointer from an address value</li>
+</ul>
+
+<p>
+Note: a pointer created by <tt>SWIG_ptr()</tt> does not have any type and is mapped as a Scilab pointer.
+</p>
+
+<p>Following we use the utility functions on the previous example:</p>
+
+<div class="targetlang"><pre>
+--> f = fopen("junk", "w");
+--> fputs("Hello", f);
+--> addr = SWIG_this(f)
+ ans =
+
+ 8219088.
+
+--> p = SWIG_ptr(addr);
+--> typeof(p)
+ans =
+
+ pointer
+
+--> fputs(" World", p);
+--> fclose(f);
+</pre></div>
+
+
+<H4><a name="Scilab_wrapping_pointers_null_pointers">39.3.6.2 Null pointers:</a></H4>
+
+
+<p>
+Using the previous <tt>SWIG_this()</tt> and <tt>SWIG_ptr()</tt>, it is possible to create and check null pointers:
+</p>
+
+<div class="targetlang"><pre>
+--> p = SWIG_ptr(0);
+--> SWIG_this(p) == 0
+ ans =
+
+ T
+</pre></div>
+
+
+<H3><a name="Scilab_wrapping_structs">39.3.7 Structures</a></H3>
+
+
+<p>
+Structs exist in Scilab, but C structs are not (at least in this version of SWIG) mapped to Scilab structs.
+A C structure is wrapped through low-level accessor functions, i.e. functions that give access to the member variables of this structure.
+In Scilab, a structure is manipulated through a pointer which is passed as an argument to the accessor functions.
+</p>
+
+<p>
+Let's see it on an example of a struct with two members:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%inline %{
+
+typedef struct {
+ int x;
+ int arr[4];
+} Foo;
+
+%}
+</pre></div>
+
+<p>
+Several functions are generated:
+</p>
+<ul>
+<li>a constructor function <tt>new_Foo()</tt> which returns a pointer to a newly created struct <tt>Foo</tt>.</li>
+<li>two member getter functions <tt>Foo_x_get()</tt>, <tt>Foo_arr_get()</tt>, to get the values of <tt>x</tt> and <tt>y</tt> for the struct pointer (provided as the first parameter to these functions)</li>
+<li>two member setter functions <tt>Foo_x_set()</tt>, <tt>Foo_arr_set()</tt>, to set the values of <tt>x</tt> and <tt>y</tt> for the struct pointer (provided as the first parameter to these functions).</li>
+<li>a destructor function <tt>delete_Foo()</tt> to release the struct pointer.</li>
+</ul>
+
+
+<p>
+Usage example:
+</p>
+
+<div class="targetlang"><pre>
+--> f = new_Foo();
+--> Foo_x_set(f, 100);
+--> Foo_x_get(f)
+ans =
+
+ 100.
+
+--> Foo_arr_set(f, [0:3]);
+--> Foo_arr_get(f)
+ans =
+
+ 0. 1. 2. 3.
+
+--> delete_Foo(f);
+</pre></div>
+
+
+<p>
+Members of a structure that are also structures are also accepted and wrapped as a pointer:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%inline %{
+
+typedef struct {
+ int x;
+} Bar;
+
+typedef struct {
+ Bar b;
+} Foo;
+
+%}
+</pre></div>
+
+<br/>
+
+<div class="targetlang"><pre>
+--> b = new_Bar();
+--> Bar_x_set(b, 20.);
+
+--> f = new_Foo();
+--> Foo_b_set(f, b);
+
+--> b2 = Foo_b_get(f);
+--> Bar_x_get(b2);
+ans =
+
+ 20.
+</pre></div>
+
+<p>
+Note: the pointer to the struct works as described in <a href="Scilab_wrapping_pointers">Pointers</a>. For example, the type of the struct pointer can be get with <tt>typeof</tt>, as following:
+</p>
+
+<div class="targetlang"><pre>
+--> example_Init();
+--> b = new_Bar();
+--> typeof(b)
+ ans =
+
+ _p_Bar
+--> delete_Bar(b);
+</pre></div>
+
+<H3><a name="Scilab_wrapping_cpp_classes">39.3.8 C++ classes</a></H3>
+
+
+<p>
+Classes do not exist in Scilab. The classes are wrapped the same way as structs.
+Low-level accessor functions are generated for class members.
+Also, constructor and destructor functions are generated to create and destroy an instance of the class.
+</p>
+
+<p>
+For example, the following class:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%inline %{
+
+class Point {
+public:
+ int x, y;
+ Point(int _x, int _y) : x(_x), y(_y) {}
+ double distance(const Point& rhs) {
+ return sqrt(pow(x-rhs.x, 2) + pow(y-rhs.y, 2));
+ }
+ void set(int _x, int _y) {
+ x=_x;
+ y=_y;
+ }
+};
+
+%}
+</pre></div>
+
+<p>
+can be used in Scilab like this:
+</p>
+
+<div class="targetlang"><pre>
+--> p1 = Point_new(3, 5);
+--> p2 = Point_new(1, 2);
+--> p1.distance(p2)
+ans =
+
+ 3.6056
+
+--> delete_Point(p1);
+--> delete_Point(p2);
+</pre></div>
+
+<p>
+Note: like structs, class pointers are mapped as described in <a href="Scilab_wrapping_pointers">Pointers</a>. Let's give an example which shows that each class pointer type is a new type in Scilab that can be used for example (through <a href="https://help.scilab.org/docs/5.5.2/en_US/overloading.html">overloading</a>) to implement a custom print for the <tt>Point</tt> class:
+</p>
+
+<div class="targetlang"><pre>
+--> function %_p_Point_p(p)
+--> mprintf('[%d, %d]\n', Point_x_get(p), Point_y_get(p));
+--> endfunction
+
+--> example_Init();
+--> p = new_Point(1, 2)
+ p =
+
+[1, 2]
+
+--> delete_Point(p);
+</pre></div>
+
+<H3><a name="Scilab_wrapping_cpp_inheritance">39.3.9 C++ inheritance</a></H3>
+
+
+<p>
+Inheritance is supported. SWIG knows the inheritance relationship between classes.
+</p>
+
+<p>
+A function is only generated for the class in which it is actually declared.
+But if one of its parameters is a class, any instance of a derived class is accepted as the argument.
+</p>
+
+<p>
+This mechanism also applies for accessor functions: they are generated only in the class in which they are defined.
+But any instance of a derived class can be used as the argument to these accessor functions.
+</p>
+
+<p>
+For example, let's take a base class <tt>Shape</tt> and two derived classes <tt>Circle</tt> and <tt>Square</tt>:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%inline %{
+
+class Shape {
+public:
+ double x, y;
+ void set_location(double _x, double _y) { x = _x; y = _y; }
+ virtual double get_perimeter() { return 0; };
+};
+
+class Circle : public Shape {
+public:
+ int radius;
+ Circle(int _radius): radius(_radius) {};
+ virtual double get_perimeter() { return 6.28 * radius; }
+};
+
+class Square : public Shape {
+public:
+ int size;
+ Square(int _size): size(_size) {};
+ virtual double get_perimeter() { return 4 * size; }
+};
+
+%}
+</pre></div>
+
+<p>
+To set the location of the <tt>Circle</tt>, we have to use the function <tt>set_location()</tt> of the parent <tt>Shape</tt>.
+But we can use either use the <tt>get_perimeter()</tt> function of the parent class or the derived class:
+</p>
+
+<div class="targetlang"><pre>
+--> c = new_Circle(3);
+
+--> Shape_set_location(c, 2, 3);
+--> Shape_x_get(c)
+ ans =
+
+ 2.
+
+--> Circle_get_perimeter(c)
+ ans =
+
+ 18.84
+
+--> Shape_get_perimeter(c)
+ ans =
+
+ 18.84
+</pre></div>
+
+<H3><a name="Scilab_wrapping_cpp_overloading">39.3.10 C++ overloading</a></H3>
+
+
+<p>
+As explained in <a href="http://www.swig.org/Doc3.0/SWIGPlus.html#SWIGPlus_overloaded_methods">6.15</a> SWIG provides support for overloaded functions and constructors.
+</p>
+
+<p>As SWIG knows pointer types, the overloading works also with pointer types, here is is an example with a function <tt>magnify</tt> overloaded for the previous classes <tt>Shape</tt> and <tt>Circle</tt>:
+</p>
+
+<div class="code"><pre>
+%module example
+
+void magnify(Square *square, double factor) {
+ square->size *= factor;
+};
+
+void magnify(Circle *circle, double factor) {
+ square->radius *= factor;
+};
+</pre></div>
+
+<div class="targetlang"><pre>
+--> example_Init();
+--> c = new_Circle(3);
+--> s = new_Square(2);
+
+--> magnify(c, 10);
+--> Circle_get_radius(c)
+ ans =
+
+ 30;
+--> magnify(s, 10);
+--> Square_get_size(s)
+ ans =
+
+ 20;
+</pre></div>
+
+
+<H3><a name="Scilab_wrapping_pointers_references_values_arrays">39.3.11 Pointers, references, values, and arrays</a></H3>
+
+
+<p>
+In C++ objects can be passed by value, pointer, reference, or by an array:
+</p>
+<div class="code"><pre>
+%module example
+
+%{
+#include <sciprint.h>
+%}
+
+%inline %{
+
+class Foo {
+public:
+ Foo(int _x) : x(_x) {}
+ int x;
+};
+
+void spam1(Foo *f) { sciprint("%d\n", f->x); } // Pass by pointer
+void spam2(Foo &f) { sciprint("%d\n", f.x); } // Pass by reference
+void spam3(Foo f) { sciprint("%d\n", f.x); } // Pass by value
+void spam4(Foo f[]) { sciprint("%d\n", f[0].x); } // Array of objects
+
+%}
+</pre></div>
+<p>
+
+In SWIG, there is no real distinction between these.
+So in Scilab, it is perfectly legal to do this:
+</p>
+<div class="targetlang"><pre>
+--> f = new_Foo()
+--> spam1(f)
+3
+--> spam2(f)
+3
+--> spam3(f)
+3
+--> spam4(f)
+3
+</pre></div>
+
+<p>
+Similar behaviour occurs for return values. For example, if you had functions like this:
+</p>
+<div class="code"><pre>
+Foo *spam5();
+Foo &spam6();
+Foo spam7();
+</pre></div>
+<p>
+All these functions will return a pointer to an instance of <tt>Foo</tt>.
+As the function <tt>spam7</tt> returns a value, new instance of <tt>Foo</tt> has to be allocated, and a pointer on this instance is returned.
+</p>
+
+<H3><a name="Scilab_wrapping_cpp_templates">39.3.12 C++ templates</a></H3>
+
+
+<p>
+As in other languages, function and class templates are supported in SWIG Scilab.
+</p>
+
+<p>
+You have to tell SWIG to create wrappers for a particular template instantiation. The <tt>%template</tt> directive is used for this purpose.
+For example:
+</p>
+
+<div class="code"><pre>
+%module example
+
+template<class T1, class T2, class T3>
+struct triplet {
+ T1 first;
+ T2 second;
+ T3 third;
+ triplet(const T1& a, const T2& b, const T3& c) {
+ third = a; second = b; third = c;
+ }
+};
+
+%template(IntTriplet) triplet<int,int,int>;
+</pre></div>
+
+<p>
+Then in Scilab:
+</p>
+
+<div class="targetlang">
+<pre>
+--> t = new_IntTriplet(3, 4, 1);
+
+--> IntTriplet_first_get(t)
+ ans =
+
+ 3.
+
+--> IntTriplet_second_get(t)
+ ans =
+
+ 4.
+
+--> IntTriplet_third_get(t)
+ ans =
+
+ 1.
+
+--> delete_IntTriplet(t);
+</pre>
+</div>
+
+<p>
+More details on template support can be found in the <a href="SWIGPlus.html#SWIGPlus_nn30">templates</a> documentation.
+</p>
+
+<H3><a name="Scilab_wrapping_cpp_operators">39.3.13 C++ operators</a></H3>
+
+
+<p>
+C++ operators are partially supported.
+Operator overloading exists in Scilab, but a C++ operator is not (in this version) wrapped by SWIG as a Scilab operator, but as a function.
+It is not automatic, you have to rename each operator (with the instruction <tt>%rename</tt>) with the suitable wrapper name.
+</p>
+
+<p>
+Let's see it with an example of class with two operators <tt>+</tt> and <tt>double()</tt>:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%rename(plus) operator +;
+%rename(toDouble) operator double();
+
+%inline %{
+
+class Complex {
+public:
+ Complex(double re, double im) : real(re), imag(im) {};
+
+ Complex operator+(const Complex& other) {
+ double result_real = real + other.real;
+ double result_imaginary = imag + other.imag;
+ return Complex(result_real, result_imaginary);
+ }
+ operator double() { return real; }
+private:
+ double real;
+ double imag;
+};
+
+%}
+</pre></div>
+
+<br/>
+
+<div class="targetlang"><pre>
+--> c1 = new_Complex(3, 7);
+
+--> c2 = Complex_plus(c, new_Complex(1,1));
+
+--> Complex_toDouble(c2)
+ ans =
+
+ 4.
+</pre></div>
+
+
+<H3><a name="Scilab_wrapping_cpp_namespaces">39.3.14 C++ namespaces</a></H3>
+
+
+<p>
+SWIG is aware of C++ namespaces, but does not use it for wrappers.
+The module is not broken into submodules, nor do namespace appear in functions names.
+All the namespaces are all flattened in the module.
+For example with one namespace <tt>Foo</tt>:
+</p>
+
+<div class="code">
+<pre>
+%module example
+
+%inline %{
+
+namespace foo {
+ int fact(int n) {
+ if (n > 1)
+ return n * fact(n-1);
+ else
+ return 1;
+ }
+
+ struct Vector {
+ double x,y,z;
+ };
+};
+
+%}
+
+</pre>
+</div>
+
+<p>
+In Scilab, there is no need to the specify the <tt>Foo</tt> namespace:
+</p>
+
+<div class="targetlang">
+<pre>
+--> fact(3)
+ ans =
+
+ 6.
+
+--> v = new_Vector();
+--> Vector_x_set(v, 3.4);
+--> Vector_y_get(v)
+ ans =
+
+ 0.
+</pre>
+</div>
+
+<p>
+If your program has more than one namespace, name conflicts can be resolved using <tt>%rename</tt>.
+For example:
+</p>
+
+<div class="code">
+<pre>
+%rename(Bar_spam) Bar::spam;
+
+namespace Foo {
+ int spam();
+}
+
+namespace Bar {
+ int spam();
+}
+</pre>
+</div>
+
+<p>
+Note: the <a href="SWIGPlus.html#SWIGPlus_nspace">nspace</a> feature is not supported.
+</p>
+
+
+<H3><a name="Scilab_wrapping_cpp_exceptions">39.3.15 C++ exceptions</a></H3>
+
+
+<p>
+Scilab does not natively support exceptions, but has errors.
+When an exception is thrown, SWIG catches it, and sets a Scilab error. An error message is displayed in Scilab.
+For example:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%inline %{
+void throw_exception() throw(char const *) {
+ throw "Bye world !";
+}
+%}
+</pre></div>
+
+<br/>
+
+<div class="targetlang"><pre>
+-->throw_exception()
+ !--error 999
+SWIG/Scilab: Exception (char const *) occured: Bye world !
+</pre></div>
+
+<p>
+Scilab has a <tt>try-catch</tt> mechanism (and a similar instruction <tt>execstr()</tt>) to handle exceptions.
+It can be used with the <tt>lasterror()</tt> function as following:
+</p>
+
+<div class="targetlang"><pre>
+--> execstr('throw_exception()', 'errcatch');
+ ans =
+
+ 999.
+
+--> lasterror()
+ ans =
+
+ SWIG/Scilab: Exception (char const *) occured: Bye world !
+</pre></div>
+
+<p>
+If the function has a <tt>throw</tt> exception specification, SWIG can automatically map the exception type and set an appropriate Scilab error message.
+It works for a few primitive types, and also for STL exceptions (the library <tt>std_except.i</tt> has to be included to get the STL exception support):
+</p>
+
+<div class="code"><pre>
+%module example
+
+%include <std_except.i>
+
+%inline %{
+void throw_int() throw(int) {
+ throw 12;
+}
+
+void throw_stl_invalid_arg(int i) throw(std::invalid_argument) {
+ if (i < 0)
+ throw std::invalid_argument("argument is negative.");
+}
+%}
+</pre></div>
+
+<br/>
+
+<div class="targetlang"><pre>
+--> throw_int();
+ !--error 999
+SWIG/Scilab: Exception (int) occured: 12
+
+-->throw_stl_invalid_arg(-1);
+ !--error 999
+SWIG/Scilab: ValueError: argument is negative.
+</pre></div>
+
+<p>
+More complex or custom exception types require specific exception typemaps to be implemented in order to specifically handle a thrown type.
+See the <a href="SWIGPlus.html#SWIGPlus">SWIG C++ documentation</a> for more details.
+</p>
+
+<H3><a name="Scilab_wrapping_cpp_stl">39.3.16 C++ STL</a></H3>
+
+
+<p>
+The Standard Template Library (STL) is partially supported. See <a href="#Scilab_typemaps_stl">STL</a> for more details.
+</p>
+
+<H2><a name="Scilab_typemaps">39.4 Type mappings and libraries</a></H2>
+
+
+<H3><a name="Scilab_typemaps_primitive_types">39.4.1 Default primitive type mappings</a></H3>
+
+
+<p>
+The following table provides the equivalent Scilab type for C/C++ primitive types.
+</p>
+
+<div class="table">
+<table border="1" summary="Scilab default primitive type mappings">
+<tr>
+ <td><b>C/C++ type</b></td>
+ <td><b>Scilab type</b></td>
+</tr>
+<tr><td>bool</td><td>boolean</td></tr>
+<tr><td>char</td><td>string</td></tr>
+<tr><td>signed char</td><td>double or int8</td></tr>
+<tr><td>unsigned char</td><td>double or uint8</td></tr>
+<tr><td>short</td><td>double or int16</td></tr>
+<tr><td>unsigned short</td><td>double or uint16</td></tr>
+<tr><td>int</td><td>double or int32</td></tr>
+<tr><td>unsigned int</td><td>double or uint32</td></tr>
+<tr><td>long</td><td>double or int32</td></tr>
+<tr><td>unsigned long</td><td>double or uint32</td></tr>
+<tr><td>signed long long</td><td>not supported in Scilab 5.x</td></tr>
+<tr><td>unsigned long long</td><td>not supported in Scilab 5.x</td></tr>
+<tr><td>float</td><td>double</td></tr>
+<tr><td>double</td><td>double</td></tr>
+<tr><td>char * or char[]</td><td>string</td></tr>
+</table>
+</div>
+
+<p>
+Notes:
+</p>
+<ul>
+<li>In Scilab the <tt>double</tt> type is far more used than any integer type.
+This is why integer values (<tt>int32</tt>, <tt>uint32</tt>, ...) are automatically converted to Scilab <tt>double</tt> values when marshalled from C into Scilab.
+Additionally on input to a C function, Scilab <tt>double</tt> values are converted into the related integer type.
+</li>
+<li>
+When an integer is expected, if the input is a double, the value must be an integer, i.e. it must not have any decimal part, otherwise a SWIG value error occurs.
+</li>
+<li>
+In SWIG for Scilab 5.x, the <tt>long long</tt> type is not supported, since Scilab 5.x does not have a 64-bit integer type.
+The default behaviour is for SWIG to generate code that will give a runtime error if <tt>long long</tt> type arguments are used from Scilab.
+</li>
+</ul>
+
+
+
+
+<H3><a name="Scilab_typemaps_arrays">39.4.2 Arrays</a></H3>
+
+
+<p>
+Typemaps are available by default for arrays. Primitive type arrays are automatically converted to/from Scilab matrices.
+Typemaps are also provided to handle members of a struct or class that are arrays.
+</p>
+
+<p>
+In input, the matrix is usually one-dimensional (it can be either a row or column vector). But it can also be a two-dimensional matrix.
+Warning: in Scilab, the values are column-major ordered, unlike in C, which is row-major ordered.
+</p>
+
+<p>
+The type mappings used for arrays is the same for primitive types, described <a href="#Scilab_typemaps_primitive_types">earlier</a>.
+This means that, if needed, a Scilab <tt>double</tt> vector is converted in input into the related C integer array
+and this C integer array is automatically converted on output into a Scilab <tt>double</tt> vector.
+Note that unlike scalars, no control is done for arrays when a <tt>double</tt> is converted into an integer.
+</p>
+
+<p>
+The following example illustrates all this:</p>
+
+<div class="code"><pre>
+%module example
+
+%#include <stdio.h>
+
+%inline %{
+
+void printArray(int values[], int len) {
+ int i = 0;
+ for (i = 0; i < len; i++) {
+ printf("%s %d %s", i==0?"[":"", values[i], i==len-1?"]\n":"");
+ }
+}
+%}
+</pre></div>
+
+<br/>
+
+<div class="targetlang"><pre>
+--> printArray([0 1 2 3], 4)
+[ 0 1 2 3 ]
+
+--> printArray([0.2; -1.8; 2; 3.7], 4)
+[ 0 -1 2 3 ]
+
+--> printArray([0 1; 2 3], 4)
+[ 0 2 1 3 ]
+
+--> printArray([0; 1; 2; 3], 4)
+[ 0 1 2 3 ]
+</pre></div>
+
+<H3><a name="Scilab_typemaps_pointer-to-pointers">39.4.3 Pointer-to-pointers</a></H3>
+
+
+<p>
+There are no specific typemaps for pointer-to-pointers, they are are mapped as pointers in Scilab.
+</p>
+
+<p>
+Pointer-to-pointers are sometimes used to implement matrices in C. The following is a an example of this:
+</p>
+
+
+<div class="code"><pre>
+%module example
+%inline %{
+
+// Returns the matrix [1 2; 3 4];
+double **create_matrix() {
+ double **M;
+ int i;
+ M = (double **) malloc(2 * sizeof(double *));
+ for (i = 0; i < 2; i++) {
+ M[i] = (double *) malloc(2 * sizeof(double));
+ M[i][0] = 2 * i + 1;
+ M[i][1] = 2 * i + 2;
+ }
+ return M;
+}
+
+// Gets the item M(i,j) value
+double get_matrix(double **M, int i, int j) {
+ return M[i][j];
+}
+
+// Sets the item M(i,j) value to be val
+void set_matrix(double **M, int i, int j, double val) {
+ M[i][j] = val;
+}
+
+// Prints a matrix (2,2) to console
+void print_matrix(double **M, int nbRows, int nbCols) {
+ int i, j;
+ for (i = 0; i < 2; i++) {
+ for (j = 0; j < 2; j++) {
+ printf("%3g ", M[i][j]);
+ }
+ printf("\n");
+ }
+}
+
+%}
+</pre></div>
+
+<p>
+ These functions are used like this in Scilab:
+</p>
+
+<div class="targetlang"><pre>
+--> m = create_matrix();
+
+--> print_matrix(m);
+ 1. 2.
+ 3. 4.
+
+--> set_matrix(m, 1, 1, 5.);
+
+--> get_matrix(m, 1, 1)
+ ans =
+
+ 5.
+</pre></div>
+
+
+<H3><a name="Scilab_typemaps_matrices">39.4.4 Matrices</a></H3>
+
+
+<p>
+The <tt>matrix.i</tt> library provides a set of typemaps which can be useful when working with one-dimensional and two-dimensional matrices.
+</p>
+
+<p>
+In order to use this library, just include it in the interface file:
+</p>
+
+<div class="code"><pre>
+ %include <matrix.i>
+</pre></div>
+
+
+<p>
+Several typemaps are available for the common Scilab matrix types:
+</p>
+<ul>
+<li><tt>double</tt></li>
+<li><tt>int</tt></li>
+<li><tt>char *</tt></li>
+<li><tt>bool</tt></li>
+</ul>
+
+<p>
+For example: for a matrix of <tt>int</tt>, we have the typemaps, for input:
+</p>
+<ul>
+<li><tt>(int *IN, int IN_ROWCOUNT, int IN_COLCOUNT)</tt></li>
+<li><tt>(int IN_ROWCOUNT, int IN_COLCOUNT, int *IN)</tt></li>
+<li><tt>(int *IN, int IN_SIZE)</tt></li>
+<li><tt>(int IN_SIZE, int *IN)</tt></li>
+</ul>
+
+<p>
+and output:
+</p>
+<ul>
+<li><tt>(int **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT)</tt></li>
+<li><tt>(int *OUT_ROWCOUNT, int *OUT_COLCOUNT, int **OUT)</tt></li>
+<li><tt>(int **OUT, int *OUT_SIZE)</tt></li>
+<li><tt>(int *OUT_SIZE, int **OUT)</tt></li>
+</ul>
+
+<p>
+They marshall a Scilab matrix type into the appropriate 2 or 3 C parameters.
+The following is an example using the typemaps in this library:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%include <matrix.i>
+
+%apply (int *IN, int IN_ROWCOUNT, int IN_COLCOUNT) { (int *matrix, int matrixNbRow, int matrixNbCol) };
+%apply (int **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT) { (int **outMatrix, int *outMatrixNbRow, int *outMatrixNbCol) };
+
+%inline %{
+
+void absolute(int *matrix, int matrixNbRow, int matrixNbCol,
+ int **outMatrix, int *outMatrixNbRow, int *outMatrixNbCol) {
+ int i, j;
+ *outMatrixNbRow = matrixNbRow;
+ *outMatrixNbCol = matrixNbCol;
+ *outMatrix = malloc(matrixNbRow * matrixNbCol * sizeof(int));
+ for (i=0; i < matrixNbRow * matrixNbCol; i++) {
+ (*outMatrix)[i] = matrix[i] > 0 ? matrix[i]:-matrix[i];
+ }
+}
+
+%}
+</pre></div>
+
+<br/>
+
+<div class="targetlang"><pre>
+--> absolute([-0 1 -2; 3 4 -5])
+ ans =
+
+ 0. 1. 2.
+ 3. 4. 5.
+</pre></div>
+
+<p>
+The remarks made earlier for arrays also apply here:
+</p>
+<ul>
+<li>The values of matrices in Scilab are column-major orderered,</li>
+<li>There is no control while converting <tt>double</tt> values to integers, <tt>double</tt> values are truncated without any checking or warning.</li>
+</ul>
+
+<H3><a name="Scilab_typemaps_stl">39.4.5 STL</a></H3>
+
+
+<p>
+The STL library wraps some containers defined in the STL (Standard Template Library), so that they can be manipulated in Scilab.
+This library also provides the appropriate typemaps to use the containers in functions and variables.
+</p>
+
+<p>
+The list of wrapped sequence containers are:
+</p>
+<ul>
+<li><tt>std::vector</tt></li>
+<li><tt>std::list</tt></li>
+<li><tt>std::deque</tt></li>
+</ul>
+
+<p>
+And associative containers are:
+</p>
+<ul>
+<li><tt>std::set</tt></li>
+<li><tt>std::multiset</tt></li>
+</ul>
+
+<p>
+Typemaps are available for the following container types:
+</p>
+
+<ul>
+<li><tt>double</tt></li>
+<li><tt>float</tt></li>
+<li><tt>int</tt></li>
+<li><tt>string</tt></li>
+<li><tt>bool</tt></li>
+<li><tt>pointer</tt></li>
+</ul>
+
+<p>
+Containers of other item types are not supported. Using them does not break compilation, but provokes a runtime error.
+Containers of enum are not supported yet.
+</p>
+
+<p>
+In order to use the STL, the library must first be included in the SWIG interface file:
+</p>
+
+<div class="code"><pre>
+%include <stl.i>
+</pre/></div>
+
+<p>Then for each container used, the appropriate template must be instantiated, in the <tt>std</tt> namespace:
+<div class="code"><pre>
+namespace std {
+ %template(IntVector) vector<int>;
+ %template(DoubleVector) vector<double>;
+}
+</pre></div>
+
+<p>
+Additionally, the module initialization function has to be executed first in Scilab, so that all the types are known to Scilab.
+See the <a href="#Scilab_module_initialization">Module initialization</a> section for more details.
+</p>
+
+
+<p>
+Because in Scilab matrices exist for basic types only, a sequence container of pointers is mapped to a Scilab list.
+For other item types (double, int, string...) the sequence container is mapped to a Scilab matrix.
+</p>
+
+<p>
+The first example below shows how to create a vector (of <tt>int</tt>) in Scilab, add some values to the vector and pass it as an argument of a function.
+It also shows, thanks to the typemaps, that we can also pass a Scilab matrix of values directly into the function:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%include <stl.i>
+
+namespace std {
+ %template(IntVector) vector<int>;
+}
+
+%{
+#include <numeric>
+%}
+
+%inline %{
+
+double average(std::vector<int> v) {
+ return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
+}
+
+%}
+</pre></div>
+
+<br/>
+
+<div class="targetlang"><pre>
+--> example_Init();
+
+--> v = new_IntVector();
+
+--> for i = 1:4
+--> IntVector_push_back(v, i);
+--> end;
+
+--> average(v)
+ ans =
+
+ 2.5
+
+--> average([0 1 2 3])
+ ans =
+
+ 2.5
+
+--> delete_IntVector();
+</pre></div>
+
+
+<p>
+In the second example, a set of struct (<tt>Person</tt>) is wrapped.
+A function performs a search in this set, and returns a subset. As one can see, the result in Scilab is a list of pointers:
+</p>
+
+<div class="code"><pre>
+%module example
+
+%include <stl.i>
+
+%{
+#include <string>
+%}
+
+%inline %{
+
+struct Person {
+ Person(std::string _name, int _age) : name(_name), age(_age) {};
+ std::string name;
+ int age;
+};
+typedef Person * PersonPtr;
+
+%}
+
+namespace std {
+ %template(PersonPtrSet) set<PersonPtr>;
+}
+
+%inline %{
+
+std::set<PersonPtr> findPersonsByAge(std::set<PersonPtr> persons, int minAge, int maxAge) {
+ std::set<PersonPtr> foundPersons;
+ for (std::set<PersonPtr>::iterator it = persons.begin(); it != persons.end(); it++) {
+ if (((*it)->age >= minAge) && ((*it)->age <= maxAge)) {
+ foundPersons.insert(*it);
+ }
+ }
+ return foundPersons;
+}
+
+%}
+</pre></div>
+
+<br/>
+
+<div class="targetlang"><pre>
+--> example_Init();
+
+--> joe = new_Person("Joe", 25);
+--> susan = new_Person("Susan", 32);
+--> bill = new_Person("Bill", 50);
+
+--> p = new_PersonPtrSet();
+--> PersonPtrSet_insert(p, susan);
+--> PersonPtrSet_insert(p, joe);
+--> PersonPtrSet_insert(p, bill);
+
+--> l = findPersonsByAge(p, 20, 40);
+
+--> size(l)
+ ans =
+
+ 2.
+
+--> Person_name_get(l(1))
+ans =
+
+ Susan
+
+--> Person_name_get(l(2))
+ ans =
+
+ Joe
+
+--> delete_PersonPtrSet(p);
+</pre></div>
+
+<H2><a name="Scilab_module_initialization">39.5 Module initialization</a></H2>
+
+
+<p>
+The wrapped module contains an initialization function to:
+</p>
+<ul>
+<li>initialize the SWIG runtime, needed for pointer type tracking or when working with the STL</li>
+<li>initialize the module constants and enumerations declared with <tt>%scilabconst()</tt></li>
+</ul>
+
+<p>
+This initialization function should be executed at the start of a script, before the wrapped library has to be used.
+</p>
+
+<p>
+The function has the name of the module suffixed by <tt>_Init</tt>.
+For example, to initialize the module <tt>example</tt>:
+</p>
+
+<div class="targetlang"><pre>
+--> example_Init();
+</pre></div>
+
+<H2><a name="Scilab_building_modes">39.6 Building modes</a></H2>
+
+
+<p>
+The mechanism to load an external module in Scilab is called <i>Dynamic Link</i> and works with dynamic modules (or shared libraries, <tt>.so</tt> files).
+</p>
+
+<p>
+To produce a dynamic module, when generating the wrapper, there are two possibilities, or build modes:
+</p>
+<ul>
+<li>the <tt>nobuilder</tt> mode, this is the default mode in SWIG. The user is responsible of the build.
+<li>the <tt>builder</tt> mode. In this mode, Scilab is responsible of building.
+</ul>
+
+<H3><a name="Scilab_building_modes_nobuilder_mode">39.6.1 No-builder mode</a></H3>
+
+
+<p>
+In this mode, used by default, SWIG generates the wrapper sources, which have to be manually compiled and linked.
+A loader script <tt>loader.sce</tt> is also produced, this one is executed further in Scilab to load the module.
+</p>
+
+<p>
+This mode is the best option to use when you have to integrate the module build into a larger build process.
+</p>
+
+
+<H3><a name="Scilab_building_modes_builder_mode">39.6.2 Builder mode</a></H3>
+
+
+<p>
+In this mode, in addition to the wrapper sources, SWIG produces a builder Scilab script (<tt>builder.sce</tt>), which is executed in Scilab to build the module.
+In a few words, the Scilab <tt>ilib_build()</tt> command is used, which produces the shared library file, and the loader script <tt>loader.sce</tt> (and also a cleaner script <tt>cleaner.sce</tt>).
+</p>
+
+<p>
+An advantage of this mode is that it hides all the complexity of the build and other platform issues.
+Also it allows the module to conform to a Scilab external module convention which is that an external module should be simply built by calling a builder script.
+</p>
+
+<p>
+The builder mode is activated with the <tt>-builder</tt> SWIG option.
+In this mode, the following SWIG options may be used to setup the build:
+</p>
+
+<ul>
+<li><tt><b>-buildersources</b></tt>: to add sources to the build (several files must be separated by a comma)</li>
+<li><tt><b>-buildercflags</b></tt>: to add flags to the builder compiler flags, for example to set library dependencies include paths</li>
+<li><tt><b>-builderldflags</b></tt>: to add flags to the linker flags, for example to set library dependency names and paths</li>
+</ul>
+
+<p>
+Let's give an example how to build a module <tt>example</tt>, composed of two sources, and using a library dependency:
+</p>
+<ul>
+<li>the sources are <tt>baa1.c</tt> and <tt>baa2.c</tt> (and are stored in in the current directory)</li>
+<li>the library is <tt>libfoo</tt> in <tt>/opt/foo</tt> (headers stored in <tt>/opt/foo/include</tt>, and shared library in <tt>/opt/foo/lib</tt>)</li>
+</ul>
+
+<p>
+The command is:
+</p>
+
+<div class="shell"><pre>
+$ swig -scilab -builder -buildercflags -I/opt/foo/include -builderldflags "-L/opt/foo/lib -lfoo" -buildersources baa1.cxx,baa2.cxx example.i
+</pre></div>
+
+<H2><a name="Scilab_generated_scripts">39.7 Generated scripts</a></H2>
+
+
+<p>
+In this part we give some details about the generated Scilab scripts.
+</p>
+
+<H3><a name="Scilab_generated_scripts_builder_script">39.7.1 Builder script</a></H3>
+
+
+<p>
+<tt>builder.sce</tt> is the name of the builder script generated by SWIG in <tt>builder</tt> mode. It contains code like this:
+</p>
+<div class="code"><pre>
+ilib_name = "examplelib";
+files = ["example_wrap.c"];
+libs = [];
+table = ["fact","_wrap_fact";"Foo_set","_wrap_Foo_set";"Foo_get","_wrap_Foo_get";];
+ilib_build(ilib_name,table,files,libs);
+</pre></div>
+
+<p>
+<tt>ilib_build(lib_name,table,files,libs)</tt> is used to create shared libraries, and to generate a loader file used to dynamically load the shared library into Scilab.
+</p>
+
+<ul>
+<li><tt><b>ilib_name</b></tt>: a character string, the generic name of the library without path and extension.</li>
+<li><tt><b>files</b></tt>: string matrix containing objects files needed for shared library creation.</li>
+<li><tt><b>libs</b></tt>: string matrix containing extra libraries needed for shared library creation.</li>
+<li><tt><b>table</b></tt>: two column string matrix containing a table of pairs of 'scilab function name', 'C function name'.</li>
+</ul>
+
+<H3><a name="Scilab_generated_scripts_loader_script">39.7.2 Loader script</a></H3>
+
+
+<p>
+The loader script is used to load in Scilab all the module functions. When loaded, these functions can be used as other Scilab functions.
+</p>
+
+<p>
+The loader script <tt>loader.sce</tt> contains code similar to:
+</p>
+
+<div class="code"><pre>
+// ------------------------------------------------------
+// generated by builder.sce: Please do not edit this file
+// ------------------------------------------------------
+
+libexamplelib_path = get_file_path('loader.sce');
+list_functions = [ 'fact';
+ 'Foo_set';
+ 'Foo_get';
+];
+addinter(libexamplelib_path+'/libexamplelib.so','libexamplelib',list_functions);
+// remove temp. variables on stack
+clear libexamplelib_path;
+clear list_functions;
+clear get_file_path;
+// ------------------------------------------------------
+</pre></div>
+
+<p>
+<tt>addinter(files,spname,fcts)</tt> performs dynamic linking of a compiled C interface function.
+</p>
+<ul>
+<li><tt><b>files</b></tt>: a character string or a vector of character strings defining the object files (containing the C interface functions) to link with.</li>
+<li><tt><b>spname</b></tt>: a character string. Name of interface routine entry point.</li>
+<li><tt><b>fcts</b></tt>: vector of character strings. The name of new Scilab function.</li>
+</ul>
+
+
+<H2><a name="Scilab_other_resources">39.8 Other resources</a></H2>
+
+
+<ul>
+<li>Example use cases can be found in the <tt>Examples/scilab</tt> directory.</li>
+<li>The test suite in the <tt>Examples/test-suite/scilab</tt> can be another source of useful use cases.</li>
+<li>The <a href="http://help.scilab.org/docs/5.5.0/en_US/api_scilab.html">Scilab API</a> is used in the generated code and is a useful reference when examining the output.</li>
+<li>This <a href="http://wiki.scilab.org/howto/Create%20a%20toolbox">guide</a> describes the Scilab external modules structure and files, in particular the files that are generated by SWIG for Scilab.</li>
+</ul>
+
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Scripting Languages</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Scripting"></a>4 Scripting Languages</H1>
+<H1><a name="Scripting">4 Scripting Languages</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
access C and C++ code.
</p>
-<H2><a name="Scripting_nn2"></a>4.1 The two language view of the world</H2>
+<H2><a name="Scripting_nn2">4.1 The two language view of the world</a></H2>
<p>
scripting, and access to high-level data structures such associative
arrays. </p>
-<H2><a name="Scripting_nn3"></a>4.2 How does a scripting language talk to C?</H2>
+<H2><a name="Scripting_nn3">4.2 How does a scripting language talk to C?</a></H2>
<p>
the process.
</p>
-<H3><a name="Scripting_nn4"></a>4.2.1 Wrapper functions</H3>
+<H3><a name="Scripting_nn4">4.2.1 Wrapper functions</a></H3>
<p>
<div class="code"><pre>
int fact(int n) {
- if (n <= 1) return 1;
- else return n*fact(n-1);
+ if (n <= 1)
+ return 1;
+ else
+ return n*fact(n-1);
}
</pre></div>
function above example might look like the following : </p>
<div class="code"><pre>
-int wrap_fact(ClientData clientData, Tcl_Interp *interp,
- int argc, char *argv[]) {
- int result;
- int arg0;
- if (argc != 2) {
- interp->result = "wrong # args";
- return TCL_ERROR;
- }
- arg0 = atoi(argv[1]);
- result = fact(arg0);
- sprintf(interp->result,"%d", result);
- return TCL_OK;
+int wrap_fact(ClientData clientData, Tcl_Interp *interp, int argc, char *argv[]) {
+ int result;
+ int arg0;
+ if (argc != 2) {
+ interp->result = "wrong # args";
+ return TCL_ERROR;
+ }
+ arg0 = atoi(argv[1]);
+ result = fact(arg0);
+ sprintf(interp->result,"%d", result);
+ return TCL_OK;
}
</pre></div>
<div class="code"><pre>
int Wrap_Init(Tcl_Interp *interp) {
- Tcl_CreateCommand(interp, "fact", wrap_fact, (ClientData) NULL,
- (Tcl_CmdDeleteProc *) NULL);
- return TCL_OK;
+ Tcl_CreateCommand(interp, "fact", wrap_fact, (ClientData) NULL,
+ (Tcl_CmdDeleteProc *) NULL);
+ return TCL_OK;
}
</pre></div>
additional initialization code. Only the specific details are
different.</p>
-<H3><a name="Scripting_nn5"></a>4.2.2 Variable linking</H3>
+<H3><a name="Scripting_nn5">4.2.2 Variable linking</a></H3>
<p>
the value.
</p>
-<H3><a name="Scripting_nn6"></a>4.2.3 Constants</H3>
+<H3><a name="Scripting_nn6">4.2.3 Constants</a></H3>
<p>
a trivial exercise.
</p>
-<H3><a name="Scripting_nn7"></a>4.2.4 Structures and classes</H3>
+<H3><a name="Scripting_nn7">4.2.4 Structures and classes</a></H3>
<p>
<div class="code"><pre>
struct Vector {
- Vector();
- ~Vector();
- double x,y,z;
+ Vector();
+ ~Vector();
+ double x,y,z;
};
</pre></div>
about the actual representation of a <tt>Vector</tt>.
</p>
-<H3><a name="Scripting_nn8"></a>4.2.5 Proxy classes</H3>
+<H3><a name="Scripting_nn8">4.2.5 Proxy classes</a></H3>
<p>
in a scripting language to access a C/C++ class (or struct) in a way
that looks like the original structure (that is, it proxies the real
C++ class). For example, if you
-have the following C definition :</p>
+have the following C++ definition :</p>
<div class="code"><pre>
class Vector {
public:
- Vector();
- ~Vector();
- double x,y,z;
+ Vector();
+ ~Vector();
+ double x,y,z;
};
</pre></div>
<div class="targetlang"><pre>
Vector v
-v configure -x 3 -y 4 -z 13
+v configure -x 3 -y 4 -z -13
</pre></div>
<p>
-When proxy classes are used, two objects are at really work--one in
+When proxy classes are used, two objects are really at work--one in
the scripting language, and an underlying C/C++ object. Operations
affect both objects equally and for all practical purposes, it appears
as if you are simply manipulating a C/C++ object.
</p>
-<H2><a name="Scripting_nn9"></a>4.3 Building scripting language extensions</H2>
+<H2><a name="Scripting_nn9">4.3 Building scripting language extensions</a></H2>
<p>
application is adding your extensions to the scripting language
itself. There are two primary approaches for doing
this. The preferred technique is to build a dynamically loadable
-extension in the form a shared library. Alternatively, you can
+extension in the form of a shared library. Alternatively, you can
recompile the scripting language interpreter with your extensions
added to it.
</p>
-<H3><a name="Scripting_nn10"></a>4.3.1 Shared libraries and dynamic loading</H3>
+<H3><a name="Scripting_nn10">4.3.1 Shared libraries and dynamic loading</a></H3>
<p>
To create a shared library or DLL, you often need to look at the
manual pages for your compiler and linker. However, the procedure
-for a few common machines is shown below:</p>
+for a few common platforms is shown below:</p>
<div class="shell"><pre>
# Build a shared library for Solaris
-gcc -c example.c example_wrap.c -I/usr/local/include
+gcc -fpic -c example.c example_wrap.c -I/usr/local/include
ld -G example.o example_wrap.o -o example.so
# Build a shared library for Linux
gcc -fpic -c example.c example_wrap.c -I/usr/local/include
gcc -shared example.o example_wrap.o -o example.so
-
-# Build a shared library for Irix
-gcc -c example.c example_wrap.c -I/usr/local/include
-ld -shared example.o example_wrap.o -o example.so
-
</pre></div>
<p>
c++ -shared example.o example_wrap.o -o example.so
</pre></div>
-<H3><a name="Scripting_nn11"></a>4.3.2 Linking with shared libraries</H3>
+<H3><a name="Scripting_nn11">4.3.2 Linking with shared libraries</a></H3>
<p>
</ul>
-<H3><a name="Scripting_nn12"></a>4.3.3 Static linking</H3>
+<H3><a name="Scripting_nn12">4.3.3 Static linking</a></H3>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
-<title>SWIG-2.0 Documentation</title>
+<title>SWIG-3.0 Documentation</title>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Sections"></a>SWIG-2.0 Documentation</H1>
+<H1><a name="Sections">SWIG-3.0 Documentation</a></H1>
-Last update : SWIG-2.0.12 (9 Feb 2014)
+<p>
+Last update : SWIG-3.0.10 (12 Jun 2016)
+</p>
-<H2>Sections</H2>
+<H2><a name="Sections_Sections">Sections</a></H2>
-<H3>SWIG Core Documentation</H3>
+<H3><a name="Sections_core_docs">SWIG Core Documentation</a></H3>
<ul>
<li><a href="Preface.html#Preface">Preface</a></li>
<li><a href="Introduction.html#Introduction">Introduction</a></li>
<li><a href="Scripting.html#Scripting">Scripting</a></li>
<li><a href="SWIG.html#SWIG">SWIG Basics</a> (Read this!)</li>
<li><a href="SWIGPlus.html#SWIGPlus">SWIG and C++</a></li>
+<li><a href="CPlusPlus11.html#CPlusPlus11">SWIG and C++11</a></li>
<li><a href="Preprocessor.html#Preprocessor">The SWIG preprocessor</a></li>
<li><a href="Library.html#Library">The SWIG library</a></li>
<li><a href="Arguments.html#Arguments">Argument handling</a></li>
<li><a href="CCache.html#CCache">Using SWIG with ccache</a></li>
</ul>
-<H3>Language Module Documentation</H3>
+<H3><a name="Sections_language_modules">Language Module Documentation</a></H3>
<ul>
<li><a href="Allegrocl.html#Allegrocl">Allegro Common Lisp support</a></li>
<li><a href="Go.html#Go">Go support</a></li>
<li><a href="Guile.html#Guile">Guile support</a></li>
<li><a href="Java.html#Java">Java support</a></li>
+<li><a href="Javascript.html#Javascript">Javascript support</a></li>
<li><a href="Lisp.html#Lisp">Common Lisp support</a></li>
<li><a href="Lua.html#Lua">Lua support</a></li>
<li><a href="Modula3.html#Modula3">Modula3 support</a></li>
<li><a href="Python.html#Python">Python support</a></li>
<li><a href="R.html#R">R support</a></li>
<li><a href="Ruby.html#Ruby">Ruby support</a></li>
+<li><a href="Scilab.html#Scilab">Scilab support</a></li>
<li><a href="Tcl.html#Tcl">Tcl support</a></li>
</ul>
-<H3>Developer Documentation</H3>
+<H3><a name="Sections_developers_docs">Developer Documentation</a></H3>
<ul>
<li><a href="Extending.html#Extending">Extending SWIG</a></li>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>SWIG and Tcl</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Tcl"></a>37 SWIG and Tcl</H1>
+<H1><a name="Tcl">40 SWIG and Tcl</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
this is no longer supported.
</p>
-<H2><a name="Tcl_nn2"></a>37.1 Preliminaries</H2>
+<H2><a name="Tcl_nn2">40.1 Preliminaries</a></H2>
<p>
need to compile this file and link it with the rest of your program.
</p>
-<H3><a name="Tcl_nn3"></a>37.1.1 Getting the right header files</H3>
+<H3><a name="Tcl_nn3">40.1.1 Getting the right header files</a></H3>
<p>
header file.
</p>
-<H3><a name="Tcl_nn4"></a>37.1.2 Compiling a dynamic module</H3>
+<H3><a name="Tcl_nn4">40.1.2 Compiling a dynamic module</a></H3>
<p>
<div class="code"><pre>
$ swig -tcl example.i
-$ gcc -c example.c
-$ gcc -c example_wrap.c -I/usr/local/include
+$ gcc -fPIC -c example.c
+$ gcc -fPIC -c example_wrap.c -I/usr/local/include
$ gcc -shared example.o example_wrap.o -o example.so
</pre></div>
name of the corresponding object file should be
"<tt>example.so</tt>".
The name of the module is specified using the <tt>%module</tt> directive or the
-<tt> -module</tt> command line option.
+ <tt>-module</tt> command line option.
</p>
-<H3><a name="Tcl_nn5"></a>37.1.3 Static linking</H3>
+<H3><a name="Tcl_nn5">40.1.3 Static linking</a></H3>
<p>
$ gcc example.c example_wrap.c \
-Xlinker -export-dynamic \
-DHAVE_CONFIG_H -I/usr/local/include/ \
- -L/usr/local/lib -ltcl -lm -ldl \
- -o mytclsh
+ -L/usr/local/lib -ltcl -lm -ldl \
+ -o mytclsh
</pre></div>
hassle in the opinion of this author).
</p>
-<H3><a name="Tcl_nn6"></a>37.1.4 Using your module</H3>
+<H3><a name="Tcl_nn6">40.1.4 Using your module</a></H3>
<p>
the man pages).
</p>
-<H3><a name="Tcl_nn7"></a>37.1.5 Compilation of C++ extensions</H3>
+<H3><a name="Tcl_nn7">40.1.5 Compilation of C++ extensions</a></H3>
<p>
<div class="code"><pre>
% swig -c++ -tcl example.i
-% g++ -c example.cxx
-% g++ -c example_wrap.cxx -I/usr/local/include
+% g++ -fPIC -c example.cxx
+% g++ -fPIC -c example_wrap.cxx -I/usr/local/include
% g++ -shared example.o example_wrap.o -o example.so
</pre></div>
<div class="code"><pre>
% swig -c++ -tcl example.i
-% CC -c example.cxx
-% CC -c example_wrap.cxx -I/usr/local/include
+% CC -KPIC -c example.cxx
+% CC -KPIC -c example_wrap.cxx -I/usr/local/include
% CC -G example.o example_wrap.o -L/opt/SUNWspro/lib -o example.so -lCrun
</pre></div>
might want to investigate using a more formal standard such as COM.
</p>
-<H3><a name="Tcl_nn8"></a>37.1.6 Compiling for 64-bit platforms</H3>
+<H3><a name="Tcl_nn8">40.1.6 Compiling for 64-bit platforms</a></H3>
<p>
linking standard (e.g., -o32 and -n32 on Irix).
</p>
-<H3><a name="Tcl_nn9"></a>37.1.7 Setting a package prefix</H3>
+<H3><a name="Tcl_nn9">40.1.7 Setting a package prefix</a></H3>
<p>
call it "<tt>Foo_bar</tt>".
</p>
-<H3><a name="Tcl_nn10"></a>37.1.8 Using namespaces</H3>
+<H3><a name="Tcl_nn10">40.1.8 Using namespaces</a></H3>
<p>
</p>
<p>
-When the<tt> -namespace</tt> option is used, objects in the module
+When the <tt>-namespace</tt> option is used, objects in the module
are always accessed with the namespace name such as <tt>Foo::bar</tt>.
</p>
-<H2><a name="Tcl_nn11"></a>37.2 Building Tcl/Tk Extensions under Windows 95/NT</H2>
+<H2><a name="Tcl_nn11">40.2 Building Tcl/Tk Extensions under Windows 95/NT</a></H2>
<p>
although the procedure may be similar with other compilers.
</p>
-<H3><a name="Tcl_nn12"></a>37.2.1 Running SWIG from Developer Studio</H3>
+<H3><a name="Tcl_nn12">40.2.1 Running SWIG from Developer Studio</a></H3>
<p>
%
</pre></div>
-<H3><a name="Tcl_nn13"></a>37.2.2 Using NMAKE</H3>
+<H3><a name="Tcl_nn13">40.2.2 Using NMAKE</a></H3>
<p>
TCL_INCLUDES = -Id:\tcl8.0a2\generic -Id:\tcl8.0a2\win
TCLLIB = d:\tcl8.0a2\win\tcl80.lib
-tcl::
- ..\..\swig -tcl -o $(WRAPFILE) $(INTERFACE)
- $(CC) $(CFLAGS) $(TCL_INCLUDES) $(SRCS) $(WRAPFILE)
- set LIB=$(TOOLS)\lib
- $(LINK) $(LOPT) -out:example.dll $(LIBS) $(TCLLIB) example.obj example_wrap.obj
+tcl:
+ ..\..\swig -tcl -o $(WRAPFILE) $(INTERFACE)
+ $(CC) $(CFLAGS) $(TCL_INCLUDES) $(SRCS) $(WRAPFILE)
+ set LIB=$(TOOLS)\lib
+ $(LINK) $(LOPT) -out:example.dll $(LIBS) $(TCLLIB) example.obj example_wrap.obj
</pre></div>
Tcl extensions.
</p>
-<H2><a name="Tcl_nn14"></a>37.3 A tour of basic C/C++ wrapping</H2>
+<H2><a name="Tcl_nn14">40.3 A tour of basic C/C++ wrapping</a></H2>
<p>
wrapping.
</p>
-<H3><a name="Tcl_nn15"></a>37.3.1 Modules</H3>
+<H3><a name="Tcl_nn15">40.3.1 Modules</a></H3>
<p>
</pre>
</div>
-<H3><a name="Tcl_nn16"></a>37.3.2 Functions</H3>
+<H3><a name="Tcl_nn16">40.3.2 Functions</a></H3>
<p>
%
</pre></div>
-<H3><a name="Tcl_nn17"></a>37.3.3 Global variables</H3>
+<H3><a name="Tcl_nn17">40.3.3 Global variables</a></H3>
<p>
</pre>
</div>
-<H3><a name="Tcl_nn18"></a>37.3.4 Constants and enums</H3>
+<H3><a name="Tcl_nn18">40.3.4 Constants and enums</a></H3>
<p>
conversion. This allows the <tt>global</tt> statement to be omitted.
</p>
-<H3><a name="Tcl_nn19"></a>37.3.5 Pointers</H3>
+<H3><a name="Tcl_nn19">40.3.5 Pointers</a></H3>
<p>
<tt>None</tt> if the conversion can't be performed.
</p>
-<H3><a name="Tcl_nn20"></a>37.3.6 Structures</H3>
+<H3><a name="Tcl_nn20">40.3.6 Structures</a></H3>
<p>
<div class="code"><pre>
struct Vector {
- double x,y,z;
+ double x,y,z;
};
</pre></div>
memory management section that appears shortly.
</p>
-<H3><a name="Tcl_nn21"></a>37.3.7 C++ classes</H3>
+<H3><a name="Tcl_nn21">40.3.7 C++ classes</a></H3>
<p>
% x insert Lager
% x get 1
Stout
-% puts [l cget -length]
+% puts [x cget -length]
3
%
</pre></div>
</pre>
</div>
-<H3><a name="Tcl_nn22"></a>37.3.8 C++ inheritance</H3>
+<H3><a name="Tcl_nn22">40.3.8 C++ inheritance</a></H3>
<p>
It is safe to use multiple inheritance with SWIG.
</p>
-<H3><a name="Tcl_nn23"></a>37.3.9 Pointers, references, values, and arrays</H3>
+<H3><a name="Tcl_nn23">40.3.9 Pointers, references, values, and arrays</a></H3>
<p>
when the return value is garbage collected).
</p>
-<H3><a name="Tcl_nn24"></a>37.3.10 C++ overloaded functions</H3>
+<H3><a name="Tcl_nn24">40.3.10 C++ overloaded functions</a></H3>
<p>
Please refer to the "SWIG and C++" chapter for more information about overloading.
</p>
-<H3><a name="Tcl_nn25"></a>37.3.11 C++ operators</H3>
+<H3><a name="Tcl_nn25">40.3.11 C++ operators</a></H3>
<p>
Keep reading.
</p>
-<H3><a name="Tcl_nn26"></a>37.3.12 C++ namespaces</H3>
+<H3><a name="Tcl_nn26">40.3.12 C++ namespaces</a></H3>
<p>
identical symbol names, well, then you get what you deserve.
</p>
-<H3><a name="Tcl_nn27"></a>37.3.13 C++ templates</H3>
+<H3><a name="Tcl_nn27">40.3.13 C++ templates</a></H3>
<p>
examples will appear later.
</p>
-<H3><a name="Tcl_nn28"></a>37.3.14 C++ Smart Pointers</H3>
+<H3><a name="Tcl_nn28">40.3.14 C++ Smart Pointers</a></H3>
<p>
</pre>
</div>
-<H2><a name="Tcl_nn29"></a>37.4 Further details on the Tcl class interface</H2>
+<H2><a name="Tcl_nn29">40.4 Further details on the Tcl class interface</a></H2>
<p>
of how the proxy classes work.
</p>
-<H3><a name="Tcl_nn30"></a>37.4.1 Proxy classes</H3>
+<H3><a name="Tcl_nn30">40.4.1 Proxy classes</a></H3>
<p>
as shown in the last section.
</p>
-<H3><a name="Tcl_nn31"></a>37.4.2 Memory management</H3>
+<H3><a name="Tcl_nn31">40.4.2 Memory management</a></H3>
<p>
</p>
-<H2><a name="Tcl_nn32"></a>37.5 Input and output parameters</H2>
+<H2><a name="Tcl_nn32">40.5 Input and output parameters</a></H2>
<p>
</pre>
</div>
-<H2><a name="Tcl_nn33"></a>37.6 Exception handling </H2>
+<H2><a name="Tcl_nn33">40.6 Exception handling </a></H2>
<p>
$action // Gets substituted by actual function call
}
catch (RangeError) {
- Tcl_SetStringObj(tcl_result,"Array index out-of-bounds");
+ Tcl_SetResult(interp, (char *)"Array index out-of-bounds", TCL_STATIC);
return TCL_ERROR;
}
}
$action
}
catch (RangeError) {
- Tcl_SetStringObj(tcl_result,"Array index out-of-bounds");
+ Tcl_SetResult(interp, (char *)"Array index out-of-bounds", TCL_STATIC);
return TCL_ERROR;
}
}
$action
}
catch (RangeError) {
- Tcl_SetStringObj(tcl_result,"Array index out-of-bounds");
+ Tcl_SetResult(interp, (char *)"Array index out-of-bounds", TCL_STATIC);
return TCL_ERROR;
}
}
$action
}
catch (RangeError) {
- Tcl_SetStringObj(tcl_result,"Array index out-of-bounds");
+ Tcl_SetResult(interp, (char *)"Array index out-of-bounds", TCL_STATIC);
return TCL_ERROR;
}
}
See the chapter on "<a href="Customization.html#Customization">Customization Features</a>" for more examples.
</p>
-<H2><a name="Tcl_nn34"></a>37.7 Typemaps</H2>
+<H2><a name="Tcl_nn34">40.7 Typemaps</a></H2>
<p>
C-Tcl interface.
</p>
-<H3><a name="Tcl_nn35"></a>37.7.1 What is a typemap?</H3>
+<H3><a name="Tcl_nn35">40.7.1 What is a typemap?</a></H3>
<p>
%module example
%typemap(in) int {
- if (Tcl_GetIntFromObj(interp,$input,&$1) == TCL_ERROR) return TCL_ERROR;
- printf("Received an integer : %d\n",$1);
+ if (Tcl_GetIntFromObj(interp,$input,&$1) == TCL_ERROR)
+ return TCL_ERROR;
+ printf("Received an integer : %d\n",$1);
}
%inline %{
extern int fact(int n);
%module example
%typemap(in) int n {
- if (Tcl_GetIntFromObj(interp,$input,&$1) == TCL_ERROR) return TCL_ERROR;
- printf("n = %d\n",$1);
+ if (Tcl_GetIntFromObj(interp,$input,&$1) == TCL_ERROR)
+ return TCL_ERROR;
+ printf("n = %d\n",$1);
}
%inline %{
extern int fact(int n);
<div class="code">
<pre>
%typemap(in) int n {
- if (Tcl_GetIntFromObj(interp,$input,&$1) == TCL_ERROR) return TCL_ERROR;
- printf("n = %d\n",$1);
+ if (Tcl_GetIntFromObj(interp,$input,&$1) == TCL_ERROR)
+ return TCL_ERROR;
+ printf("n = %d\n",$1);
}
%inline %{
typedef int Integer;
</pre>
</div>
-<H3><a name="Tcl_nn36"></a>37.7.2 Tcl typemaps</H3>
+<H3><a name="Tcl_nn36">40.7.2 Tcl typemaps</a></H3>
<p>
Examples of these methods will appear shortly.
</p>
-<H3><a name="Tcl_nn37"></a>37.7.3 Typemap variables</H3>
+<H3><a name="Tcl_nn37">40.7.3 Typemap variables</a></H3>
<p>
The Tcl name of the wrapper function being created.
</div>
-<H3><a name="Tcl_nn38"></a>37.7.4 Converting a Tcl list to a char ** </H3>
+<H3><a name="Tcl_nn38">40.7.4 Converting a Tcl list to a char ** </a></H3>
<p>
3
</pre></div>
-<H3><a name="Tcl_nn39"></a>37.7.5 Returning values in arguments</H3>
+<H3><a name="Tcl_nn39">40.7.5 Returning values in arguments</a></H3>
<p>
%
</pre></div>
-<H3><a name="Tcl_nn40"></a>37.7.6 Useful functions</H3>
+<H3><a name="Tcl_nn40">40.7.6 Useful functions</a></H3>
<p>
<div class="code">
<pre>
Tcl_Obj *Tcl_NewStringObj(char *str, int len);
-void Tcl_SetStringObj(Tcl_Obj *obj, char *str, int len);
char *Tcl_GetStringFromObj(Tcl_Obj *obj, int *len);
void Tcl_AppendToObj(Tcl_Obj *obj, char *str, int len);
</pre>
</pre>
</div>
-<H3><a name="Tcl_nn41"></a>37.7.7 Standard typemaps</H3>
+<H3><a name="Tcl_nn41">40.7.7 Standard typemaps</a></H3>
<p>
<div class="code">
<pre>
%typemap(in) int, short, long {
- int temp;
- if (Tcl_GetIntFromObj(interp, $input, &temp) == TCL_ERROR)
- return TCL_ERROR;
- $1 = ($1_ltype) temp;
+ int temp;
+ if (Tcl_GetIntFromObj(interp, $input, &temp) == TCL_ERROR)
+ return TCL_ERROR;
+ $1 = ($1_ltype) temp;
}
</pre>
</div>
<div class="code">
<pre>
-%typemap(out) char * {
- Tcl_SetStringObj($result,$1);
+%typemap(out,noblock=1,fragment="SWIG_FromCharPtr") char *, const char * {
+ Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)$1));
}
+
</pre>
</div>
-<H3><a name="Tcl_nn42"></a>37.7.8 Pointer handling</H3>
+<H3><a name="Tcl_nn42">40.7.8 Pointer handling</a></H3>
<p>
</pre>
</div>
-<H2><a name="Tcl_nn43"></a>37.8 Turning a SWIG module into a Tcl Package.</H2>
+<H2><a name="Tcl_nn43">40.8 Turning a SWIG module into a Tcl Package.</a></H2>
<p>
<div class="code"><pre>
./example/
- pkgIndex.tcl # The file created by pkg_mkIndex
- example.so # The SWIG generated module
+ pkgIndex.tcl # The file created by pkg_mkIndex
+ example.so # The SWIG generated module
</pre></div>
<p>
to use the <tt>load</tt> command instead.
</p>
-<H2><a name="Tcl_nn44"></a>37.9 Building new kinds of Tcl interfaces (in Tcl)</H2>
+<H2><a name="Tcl_nn44">40.9 Building new kinds of Tcl interfaces (in Tcl)</a></H2>
<p>
<div class="code"><pre>
set a [Array double 100] ;# Create a double [100]
for {set i 0} {$i < 100} {incr i 1} { ;# Clear the array
- $a set $i 0.0
+ $a set $i 0.0
}
$a set 3 3.1455 ;# Set an individual element
set b [$a get 10] ;# Retrieve an element
set ia [Array int 50] ;# Create an int[50]
for {set i 0} {$i < 50} {incr i 1} { ;# Clear it
- $ia set $i 0
+ $ia set $i 0
}
$ia set 3 7 ;# Set an individual element
set ib [$ia get 10] ;# Get an individual element
with an out of bounds array access).
</p>
-<H3><a name="Tcl_nn45"></a>37.9.1 Proxy classes</H3>
+<H3><a name="Tcl_nn45">40.9.1 Proxy classes</a></H3>
<p>
interesting things.
</p>
-<H2><a name="Tcl_nn46"></a>37.10 Tcl/Tk Stubs</H2>
+<H2><a name="Tcl_nn46">40.10 Tcl/Tk Stubs</a></H2>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Typemaps</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Typemaps"></a>10 Typemaps</H1>
+<H1><a name="Typemaps">11 Typemaps</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
<li><a href="#Typemaps_special_macro_descriptor">$descriptor(type)</a>
<li><a href="#Typemaps_special_macro_typemap">$typemap(method, typepattern)</a>
</ul>
+<li><a href="#Typemaps_special_variable_attributes">Special variables and typemap attributes</a>
+<li><a href="#Typemaps_special_variables_and_macros">Special variables combined with special variable macros</a>
</ul>
<li><a href="#Typemaps_nn25">Common typemap methods</a>
<ul>
<li><a href="#Typemaps_runtime_type_checker_usage">Usage</a>
</ul>
<li><a href="#Typemaps_overloading">Typemaps and overloading</a>
-<li><a href="#Typemaps_nn48">More about <tt>%apply</tt> and <tt>%clear</tt></a>
+<li><a href="#Typemaps_nn48">More about %apply and %clear</a>
<li><a href="#Typemaps_nn47">Passing data between typemaps</a>
<li><a href="#Typemaps_nn52">C++ "this" pointer</a>
<li><a href="#Typemaps_nn51">Where to go for more information?</a>
-<H2><a name="Typemaps_nn2"></a>10.1 Introduction</H2>
+<H2><a name="Typemaps_nn2">11.1 Introduction</a></H2>
<p>
chapter with only a vague idea of what SWIG already does by default.
</p>
-<H3><a name="Typemaps_nn3"></a>10.1.1 Type conversion</H3>
+<H3><a name="Typemaps_nn3">11.1.1 Type conversion</a></H3>
<p>
how it works (an exercise left to the reader).
</p>
-<H3><a name="Typemaps_nn4"></a>10.1.2 Typemaps</H3>
+<H3><a name="Typemaps_nn4">11.1.2 Typemaps</a></H3>
<p>
possible to completely change the way in which values are converted.
</p>
-<H3><a name="Typemaps_nn5"></a>10.1.3 Pattern matching</H3>
+<H3><a name="Typemaps_nn5">11.1.3 Pattern matching</a></H3>
<p>
provides a hint to the unusual variable naming scheme involving <tt>$1</tt>, <tt>$2</tt>, and so forth.
</p>
-<H3><a name="Typemaps_nn6"></a>10.1.4 Reusing typemaps</H3>
+<H3><a name="Typemaps_nn6">11.1.4 Reusing typemaps</a></H3>
<p>
then SWIG already knows that the <tt>int</tt> typemaps apply. You don't have to do anything.
</p>
-<H3><a name="Typemaps_nn7"></a>10.1.5 What can be done with typemaps?</H3>
+<H3><a name="Typemaps_nn7">11.1.5 What can be done with typemaps?</a></H3>
<p>
aspects of the Java bindings. Consult language specific documentation for further details.
</p>
-<H3><a name="Typemaps_nn8"></a>10.1.6 What can't be done with typemaps?</H3>
+<H3><a name="Typemaps_nn8">11.1.6 What can't be done with typemaps?</a></H3>
<p>
</pre>
</div>
-<H3><a name="Typemaps_aspects"></a>10.1.7 Similarities to Aspect Oriented Programming</H3>
+<H3><a name="Typemaps_aspects">11.1.7 Similarities to Aspect Oriented Programming</a></H3>
<p>
<li> <b>Aspect</b>: Aspects are the combination of the pointcut and the advice, hence each typemap is an aspect.
</ul>
<p>
-SWIG can also be viewed as has having a second set of aspects based around <a href="Customization.html">%feature</a>.
+SWIG can also be viewed as has having a second set of aspects based around <a href="Customization.html#Customization">%feature</a>.
Features such as <tt>%exception</tt> are also cross-cutting concerns as they encapsulate code that can be used to add logging or exception handling to any function.
</p>
-<H3><a name="Typemaps_nn9"></a>10.1.8 The rest of this chapter</H3>
+<H3><a name="Typemaps_nn9">11.1.8 The rest of this chapter</a></H3>
<p>
"The C++ Programming Language" by Stroustrup before going any further.
</p>
-<H2><a name="Typemaps_nn10"></a>10.2 Typemap specifications</H2>
+<H2><a name="Typemaps_nn10">11.2 Typemap specifications</a></H2>
<p>
This section describes the behavior of the <tt>%typemap</tt> directive itself.
</p>
-<H3><a name="Typemaps_defining"></a>10.2.1 Defining a typemap</H3>
+<H3><a name="Typemaps_defining">11.2.1 Defining a typemap</a></H3>
<p>
<p>
Note that the preprocessor will expand code within the {} delimiters, but not in the last two styles of delimiters,
-see <a href="Preprocessor.html#Preprocessor_typemap_delimiters">Preprocessor and Typemaps</a>.
+see <a href="Preprocessor.html#Preprocessor_delimiters">Preprocessor and Typemaps</a>.
Here are some examples of valid typemap specifications:
</p>
individual pieces will become clear.
</p>
-<H3><a name="Typemaps_nn12"></a>10.2.2 Typemap scope</H3>
+<H3><a name="Typemaps_nn12">11.2.2 Typemap scope</a></H3>
<p>
</pre>
</div>
-<H3><a name="Typemaps_nn13"></a>10.2.3 Copying a typemap</H3>
+<H3><a name="Typemaps_nn13">11.2.3 Copying a typemap</a></H3>
<p>
</pre>
</div>
-<H3><a name="Typemaps_nn14"></a>10.2.4 Deleting a typemap</H3>
+<H3><a name="Typemaps_nn14">11.2.4 Deleting a typemap</a></H3>
<p>
after the clear operation.
</p>
-<H3><a name="Typemaps_nn15"></a>10.2.5 Placement of typemaps</H3>
+<H3><a name="Typemaps_nn15">11.2.5 Placement of typemaps</a></H3>
<p>
within a particular namespace. In this example, this is done using the forward class declaration <tt>class string</tt>.
</p>
-<H2><a name="Typemaps_pattern_matching"></a>10.3 Pattern matching rules</H2>
+<H2><a name="Typemaps_pattern_matching">11.3 Pattern matching rules</a></H2>
<p>
The matching rules can be observed in practice by using the debugging options also described.
</p>
-<H3><a name="Typemaps_nn17"></a>10.3.1 Basic matching rules</H3>
+<H3><a name="Typemaps_nn17">11.3.1 Basic matching rules</a></H3>
<p>
stripped all qualifiers in one step.
</p>
-<H3><a name="Typemaps_typedef_reductions"></a>10.3.2 Typedef reductions matching</H3>
+<H3><a name="Typemaps_typedef_reductions">11.3.2 Typedef reductions matching</a></H3>
<p>
</pre>
</div>
-<H3><a name="Typemaps_nn19"></a>10.3.3 Default typemap matching rules</H3>
+<H3><a name="Typemaps_nn19">11.3.3 Default typemap matching rules</a></H3>
<p>
simpler scheme to match the current C++ class template partial specialization matching rules.
</p>
-<H3><a name="Typemaps_multi_argument_typemaps_patterns"></a>10.3.4 Multi-arguments typemaps</H3>
+<H3><a name="Typemaps_multi_argument_typemaps_patterns">11.3.4 Multi-arguments typemaps</a></H3>
<p>
</p>
-<H3><a name="Typemaps_matching_template_comparison"></a>10.3.5 Matching rules compared to C++ templates</H3>
+<H3><a name="Typemaps_matching_template_comparison">11.3.5 Matching rules compared to C++ templates</a></H3>
<p>
</p>
-<H3><a name="Typemaps_debugging_search"></a>10.3.6 Debugging typemap pattern matching</H3>
+<H3><a name="Typemaps_debugging_search">11.3.6 Debugging typemap pattern matching</a></H3>
<p>
</li>
</ul>
-<H2><a name="Typemaps_nn21"></a>10.4 Code generation rules</H2>
+<H2><a name="Typemaps_nn21">11.4 Code generation rules</a></H2>
<p>
the generated wrapper code.
</p>
-<H3><a name="Typemaps_nn22"></a>10.4.1 Scope</H3>
+<H3><a name="Typemaps_nn22">11.4.1 Scope</a></H3>
<p>
Note that only the third of the three typemaps have the typemap code passed through the SWIG preprocessor.
</p>
-<H3><a name="Typemaps_nn23"></a>10.4.2 Declaring new local variables</H3>
+<H3><a name="Typemaps_nn23">11.4.2 Declaring new local variables</a></H3>
<p>
</pre>
</div>
+<p>There is an exception: if the variable name starts with the <tt>_global_</tt> prefix,
+the argument number is not appended. Such variables can be used throughout the generated
+wrapper function. For example, the above typemap could be rewritten to use <tt>_global_temp</tt>
+instead of <tt>temp</tt> and the generated code would then contain a single <tt>_global_temp</tt> variable
+instead of <tt>temp1</tt>, <tt>temp2</tt> and <tt>temp3</tt>:
+</p>
+
+<div class="code">
+<pre>
+%typemap(in) std::string * <b>(std::string _global_temp)</b> {
+ ... as above ...
+}
+</pre>
+</div>
+
+
<p>
Some typemaps do not recognize local variables (or they may simply not
apply). At this time, only typemaps that apply to argument conversion support this (input typemaps such as the "in" typemap).
</div>
-<H3><a name="Typemaps_special_variables"></a>10.4.3 Special variables</H3>
+<H3><a name="Typemaps_special_variables">11.4.3 Special variables</a></H3>
<p>
</pre>
</div>
-<H3><a name="Typemaps_special_variable_macros"></a>10.4.4 Special variable macros</H3>
+<H3><a name="Typemaps_special_variable_macros">11.4.4 Special variable macros</a></H3>
<p>
The following special variable macros are available across all language modules.
</p>
-<H4><a name="Typemaps_special_macro_descriptor"></a>10.4.4.1 $descriptor(type)</H4>
+<H4><a name="Typemaps_special_macro_descriptor">11.4.4.1 $descriptor(type)</a></H4>
<p>
This macro is mostly used in the scripting target languages and is demonstrated later in the <a href="#Typemaps_runtime_type_checker_usage">Run-time type checker usage</a> section.
</p>
-<H4><a name="Typemaps_special_macro_typemap"></a>10.4.4.2 $typemap(method, typepattern)</H4>
+<H4><a name="Typemaps_special_macro_typemap">11.4.4.2 $typemap(method, typepattern)</a></H4>
<p>
</pre>
</div>
-<H2><a name="Typemaps_nn25"></a>10.5 Common typemap methods</H2>
+
+<H3><a name="Typemaps_special_variable_attributes">11.4.5 Special variables and typemap attributes</a></H3>
+
+
+<p>
+As of SWIG-3.0.7 typemap attributes will also expand special variables and special variable macros.
+</p>
+
+<p>
+Example usage showing the expansion in the 'out' attribute (C# specific) as well as the main typemap body:
+</p>
+
+<div class="code">
+<pre>
+%typemap(ctype, out="$*1_ltype") unsigned int& "$*1_ltype"
+</pre>
+</div>
+
+<p>
+is equivalent to the following as <tt>$*1_ltype</tt> expands to <tt>unsigned int</tt>:
+</p>
+
+<div class="code">
+<pre>
+%typemap(ctype, out="unsigned int") unsigned int& "unsigned int"
+</pre>
+</div>
+
+<H3><a name="Typemaps_special_variables_and_macros">11.4.6 Special variables combined with special variable macros</a></H3>
+
+
+<p>
+Special variables can also be used within special variable macros.
+The special variables are expanded before they are used in the special variable macros.
+</p>
+
+<p>
+Consider the following C# typemaps:
+</p>
+
+<div class="code">
+<pre>
+%typemap(cstype) unsigned int "uint"
+%typemap(cstype, out="$typemap(cstype, $*1_ltype)") unsigned int& "$typemap(cstype, $*1_ltype)"
+</pre>
+</div>
+
+<p>
+Special variables are expanded first and hence the above is equivalent to:
+</p>
+
+<div class="code">
+<pre>
+%typemap(cstype) unsigned int "uint"
+%typemap(cstype, out="$typemap(cstype, unsigned int)") unsigned int& "$typemap(cstype, unsigned int)"
+</pre>
+</div>
+
+<p>
+which then expands to:
+</p>
+
+<div class="code">
+<pre>
+%typemap(cstype) unsigned int "uint"
+%typemap(cstype, out="uint") unsigned int& "uint"
+</pre>
+</div>
+
+
+<H2><a name="Typemaps_nn25">11.5 Common typemap methods</a></H2>
<p>
the following typemap methods are nearly universal:
</p>
-<H3><a name="Typemaps_nn26"></a>10.5.1 "in" typemap</H3>
+<H3><a name="Typemaps_nn26">11.5.1 "in" typemap</a></H3>
<p>
is the same as the old "ignore" typemap.
</p>
-<H3><a name="Typemaps_nn27"></a>10.5.2 "typecheck" typemap</H3>
+<H3><a name="Typemaps_nn27">11.5.2 "typecheck" typemap</a></H3>
<p>
"typecheck" typemaps. More details about this follow in the <a href="#Typemaps_overloading">Typemaps and overloading</a> section.
</p>
-<H3><a name="Typemaps_nn28"></a>10.5.3 "out" typemap</H3>
+<H3><a name="Typemaps_nn28">11.5.3 "out" typemap</a></H3>
<p>
The "out" typemap supports an optional attribute flag called "optimal". This is for code optimisation and is detailed in the <a href="#Typemaps_optimal">Optimal code generation when returning by value</a> section.
</p>
-<H3><a name="Typemaps_nn29"></a>10.5.4 "arginit" typemap</H3>
+<H3><a name="Typemaps_nn29">11.5.4 "arginit" typemap</a></H3>
<p>
</pre>
</div>
-<H3><a name="Typemaps_nn30"></a>10.5.5 "default" typemap</H3>
+<H3><a name="Typemaps_nn30">11.5.5 "default" typemap</a></H3>
<p>
for further information on default argument wrapping.
</p>
-<H3><a name="Typemaps_nn31"></a>10.5.6 "check" typemap</H3>
+<H3><a name="Typemaps_nn31">11.5.6 "check" typemap</a></H3>
<p>
</pre>
</div>
-<H3><a name="Typemaps_nn32"></a>10.5.7 "argout" typemap</H3>
+<H3><a name="Typemaps_nn32">11.5.7 "argout" typemap</a></H3>
<p>
See the <tt>typemaps.i</tt> library file for examples.
</p>
-<H3><a name="Typemaps_nn33"></a>10.5.8 "freearg" typemap</H3>
+<H3><a name="Typemaps_nn33">11.5.8 "freearg" typemap</a></H3>
<p>
prematurely.
</p>
-<H3><a name="Typemaps_nn34"></a>10.5.9 "newfree" typemap</H3>
+<H3><a name="Typemaps_nn34">11.5.9 "newfree" typemap</a></H3>
<p>
See <a href="Customization.html#Customization_ownership">Object ownership and %newobject</a> for further details.
</p>
-<H3><a name="Typemaps_nn35"></a>10.5.10 "memberin" typemap</H3>
+<H3><a name="Typemaps_nn35">11.5.10 "memberin" typemap</a></H3>
<p>
a default implementation for arrays, strings, and other objects.
</p>
-<H3><a name="Typemaps_nn36"></a>10.5.11 "varin" typemap</H3>
+<H3><a name="Typemaps_nn36">11.5.11 "varin" typemap</a></H3>
<p>
purposes of assigning to a C/C++ global variable. This is implementation specific.
</p>
-<H3><a name="Typemaps_nn37"></a>10.5.12 "varout" typemap</H3>
+<H3><a name="Typemaps_nn37">11.5.12 "varout" typemap</a></H3>
<p>
language when reading a C/C++ global variable. This is implementation specific.
</p>
-<H3><a name="throws_typemap"></a>10.5.13 "throws" typemap</H3>
+<H3><a name="throws_typemap">11.5.13 "throws" typemap</a></H3>
<p>
For a neat way to handle these, see the <a href="Customization.html#Customization_exception">Exception handling with %exception</a> section.
</p>
-<H2><a name="Typemaps_nn39"></a>10.6 Some typemap examples</H2>
+<H2><a name="Typemaps_nn39">11.6 Some typemap examples</a></H2>
<p>
for more examples.
</p>
-<H3><a name="Typemaps_nn40"></a>10.6.1 Typemaps for arrays</H3>
+<H3><a name="Typemaps_nn40">11.6.1 Typemaps for arrays</a></H3>
<p>
<div class="code"><pre>
struct SomeObject {
- float value[4];
- ...
+ float value[4];
+ ...
};
</pre></div>
useless and has since been eliminated. To return structure members, simply use the "out" typemap.
</p>
-<H3><a name="Typemaps_nn41"></a>10.6.2 Implementing constraints with typemaps</H3>
+<H3><a name="Typemaps_nn41">11.6.2 Implementing constraints with typemaps</a></H3>
<p>
%module math
%typemap(check) double posdouble {
- if ($1 < 0) {
- croak("Expecting a positive number");
- }
+ if ($1 < 0) {
+ croak("Expecting a positive number");
+ }
}
...
segmentation faults or other run-time problems by raising an exception
rather than blindly passing values to the underlying C/C++ program.</p>
-<H2><a name="Typemaps_nn43"></a>10.7 Typemaps for multiple target languages</H2>
+<H2><a name="Typemaps_nn43">11.7 Typemaps for multiple target languages</a></H2>
<p>
<tt>%typemap(ruby,in) int "$1 = NUM2INT($input);"</tt>.
</p>
-<H2><a name="Typemaps_optimal"></a>10.8 Optimal code generation when returning by value</H2>
+<H2><a name="Typemaps_optimal">11.8 Optimal code generation when returning by value</a></H2>
<p>
However, it doesn't always get it right, for example when <tt>$1</tt> is within some commented out code.
</p>
-<H2><a name="Typemaps_multi_argument_typemaps"></a>10.9 Multi-argument typemaps</H2>
+<H2><a name="Typemaps_multi_argument_typemaps">11.9 Multi-argument typemaps</a></H2>
<p>
<div class="targetlang">
<pre>
->>> foo(["ale","lager","stout"])
+>>> foo(["ale", "lager", "stout"])
</pre>
</div>
<p>
-To do this, you not only need to map a list of strings to <tt> char *argv[]</tt>, but the
+To do this, you not only need to map a list of strings to <tt>char *argv[]</tt>, but the
value of <tt>int argc</tt> is implicitly determined by the length of the list. Using only simple
typemaps, this type of conversion is possible, but extremely painful.
Multi-argument typemaps help in this situation.
%typemap(freearg) (int argc, char *argv[]) {
if ($2) free($2);
}
+
+/* Required for C++ method overloading */
+%typecheck(SWIG_TYPECHECK_STRING_ARRAY) (int argc, char *argv[]) {
+ $1 = PyList_Check($input) ? 1 : 0;
+}
</pre>
</div>
</div>
<p>
+Don't forget to also provide a suitable <a href="#Typemaps_overloading">typemap for overloaded functions</a>, such as <tt>%typecheck</tt> shown for foo above.
+This is only required if the function is overloaded in C++.
+</p>
+
+<p>
Although multi-argument typemaps may seem like an exotic, little used feature, there
are several situations where they make sense. First, suppose you wanted to wrap
functions similar to the low-level <tt>read()</tt> and <tt>write()</tt> system calls.
the arguments to make them consecutive will need to be written.
</p>
-<H2><a name="Typemaps_warnings"></a>10.10 Typemap warnings</H2>
+<H2><a name="Typemaps_warnings">11.10 Typemap warnings</a></H2>
<p>
</p>
-<H2><a name="Typemaps_fragments"></a>10.11 Typemap fragments</H2>
+<H2><a name="Typemaps_fragments">11.11 Typemap fragments</a></H2>
<p>
with some powerful but tricky macro and fragment usage that is used in parts of the SWIG typemap library.
</p>
-<H3><a name="Typemaps_fragment_type_specialization"></a>10.11.1 Fragment type specialization</H3>
+<H3><a name="Typemaps_fragment_type_specialization">11.11.1 Fragment type specialization</a></H3>
<p>
</pre>
</div>
-<H3><a name="Typemaps_automatic_specialization"></a>10.11.2 Fragments and automatic typemap specialization</H3>
+<H3><a name="Typemaps_automatic_specialization">11.11.2 Fragments and automatic typemap specialization</a></H3>
<p>
</p>
-<H2><a name="Typemaps_runtime_type_checker"></a>10.12 The run-time type checker</H2>
+<H2><a name="Typemaps_runtime_type_checker">11.12 The run-time type checker</a></H2>
<p>
<li>Store inheritance and type equivalence information and be able to correctly
re-create the type pointer.</li>
<li>Share type information between modules.</li>
-<li>Modules can be loaded in any order, irregardless of actual type
+<li>Modules can be loaded in any order, regardless of actual type
dependency.</li>
<li>Avoid the use of dynamically allocated memory, and library/system calls in general.</li>
<li>Provide a reasonably fast implementation, minimizing the lookup time for all
<li>Modules can be unloaded from the type system.</li>
</ul>
-<H3><a name="Typemaps_nn45"></a>10.12.1 Implementation</H3>
+<H3><a name="Typemaps_nn45">11.12.1 Implementation</a></H3>
<p>
structures are chained together in a circularly linked list.
</p>
-<H3><a name="Typemaps_runtime_type_checker_usage"></a>10.12.2 Usage</H3>
+<H3><a name="Typemaps_runtime_type_checker_usage">11.12.2 Usage</a></H3>
<p>This section covers how to use these functions from typemaps. To learn how to
managed.
</p>
-<H2><a name="Typemaps_overloading"></a>10.13 Typemaps and overloading</H2>
+<H2><a name="Typemaps_overloading">11.13 Typemaps and overloading</a></H2>
<p>
<p>
Using the above table as a guide, each target language defines a collection of "typecheck" typemaps.
-The follow excerpt from the Python module illustrates this:
+The following excerpt from the Python module illustrates this:
</p>
<div class="code">
/* Note: %typecheck(X) is a macro for %typemap(typecheck,precedence=X) */
%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,
- bool, const bool &
+ 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,
+ bool, const bool &
{
$1 = (PyInt_Check($input) || PyLong_Check($input)) ? 1 : 0;
}
%typecheck(SWIG_TYPECHECK_DOUBLE)
- float, double,
- const float &, const double &
+ float, double,
+ const float &, const double &
{
$1 = (PyFloat_Check($input) || PyInt_Check($input) || PyLong_Check($input)) ? 1 : 0;
}
<p>
The bottom line: If you are writing new typemaps and you are using overloaded methods, you will probably
-have to write typecheck code or copy existing code. Since this is a relatively new SWIG feature, there are
-few examples to work with. However, you might look at some of the existing library files likes 'typemaps.i' for
-a guide.
+have to write new typecheck code or copy and modify existing typecheck code.
+</p>
+
+<p>
+If you write a typecheck typemap and omit the precedence level, for example commenting it out as shown below:
</p>
+<div class="code">
+<pre>
+%typemap(typecheck /*,precedence=SWIG_TYPECHECK_INTEGER*/) int {
+ $1 = PyInt_Check($input) ? 1 : 0;
+}
+</pre>
+</div>
+
+<p>
+then the type is given a precedence higher than any other known precedence level and a <a href="Warnings.html#Warnings">warning</a> is issued:
+</p>
+
+<div class="shell">
+<pre>
+example.i:18: Warning 467: Overloaded method foo(int) not supported (incomplete type checking rule - no precedence level in typecheck typemap for 'int').
+</pre>
+</div>
+
<p>
<b>Notes:</b>
</p>
</li>
</ul>
-<H2><a name="Typemaps_nn48"></a>10.14 More about <tt>%apply</tt> and <tt>%clear</tt></H2>
+<H2><a name="Typemaps_nn48">11.14 More about %apply and %clear</a></H2>
<p>
</div>
-<H2><a name="Typemaps_nn47"></a>10.15 Passing data between typemaps</H2>
+<H2><a name="Typemaps_nn47">11.15 Passing data between typemaps</a></H2>
<p>
</p>
-<H2><a name="Typemaps_nn52"></a>10.16 C++ "this" pointer</H2>
+<H2><a name="Typemaps_nn52">11.16 C++ "this" pointer</a></H2>
<p>
the method, but gives the argument a name other than <tt>self</tt>.
</p>
-<H2><a name="Typemaps_nn51"></a>10.17 Where to go for more information?</H2>
+<H2><a name="Typemaps_nn51">11.17 Where to go for more information?</a></H2>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Variable Length Arguments</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Varargs"></a>13 Variable Length Arguments</H1>
+<H1><a name="Varargs">14 Variable Length Arguments</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
wisely chosen to avoid this issue.
</p>
-<H2><a name="Varargs_nn2"></a>13.1 Introduction</H2>
+<H2><a name="Varargs_nn2">14.1 Introduction</a></H2>
<p>
</pre>
</div>
-<H2><a name="Varargs_nn3"></a>13.2 The Problem</H2>
+<H2><a name="Varargs_nn3">14.2 The Problem</a></H2>
<p>
are willing to get hands dirty. Keep reading.
</p>
-<H2><a name="Varargs_nn4"></a>13.3 Default varargs support</H2>
+<H2><a name="Varargs_nn4">14.3 Default varargs support</a></H2>
<p>
</p>
-<H2><a name="Varargs_nn5"></a>13.4 Argument replacement using %varargs</H2>
+<H2><a name="Varargs_nn5">14.4 Argument replacement using %varargs</a></H2>
<p>
wrappers to such functions presents special problems (covered shortly).
</p>
-<H2><a name="Varargs_nn6"></a>13.5 Varargs and typemaps</H2>
+<H2><a name="Varargs_nn6">14.5 Varargs and typemaps</a></H2>
<p>
security, continue to the next section.
</p>
-<H2><a name="Varargs_nn7"></a>13.6 Varargs wrapping with libffi</H2>
+<H2><a name="Varargs_nn7">14.6 Varargs wrapping with libffi</a></H2>
<p>
<p>
One way to do this is to use a special purpose library such as libffi
(<a
-href="http://sources.redhat.com/libffi/">http://sources.redhat.com/libffi</a>).
+href="http://www.sourceware.org/libffi/">http://www.sourceware.org/libffi/</a>).
libffi is a library that allows you to dynamically construct
call-stacks and invoke procedures in a relatively platform independent
manner. Details about the library can be found in the libffi
PyObject *o = PyTuple_GetItem(varargs,i);
if (!PyString_Check(o)) {
PyErr_SetString(PyExc_ValueError,"Expected a string");
- free(argv);
+ free(argv);
return NULL;
}
argv[i] = PyString_AsString(o);
values. Please consult the chapter on each language module for more details.
</p>
-<H2><a name="Varargs_nn8"></a>13.7 Wrapping of va_list</H2>
+<H2><a name="Varargs_nn8">14.7 Wrapping of va_list</a></H2>
<p>
</pre>
</div>
-<H2><a name="Varargs_nn9"></a>13.8 C++ Issues</H2>
+<H2><a name="Varargs_nn9">14.8 C++ Issues</a></H2>
<p>
fully general wrapper to a varargs C++ member function.
</p>
-<H2><a name="Varargs_nn10"></a>13.9 Discussion</H2>
+<H2><a name="Varargs_nn10">14.9 Discussion</a></H2>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Warning Messages</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Warnings"></a>14 Warning Messages</H1>
+<H1><a name="Warnings">15 Warning Messages</a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
-<H2><a name="Warnings_nn2"></a>14.1 Introduction</H2>
+<H2><a name="Warnings_nn2">15.1 Introduction</a></H2>
<p>
work like you expect.
</p>
-<H2><a name="Warnings_suppression"></a>14.2 Warning message suppression</H2>
+<H2><a name="Warnings_suppression">15.2 Warning message suppression</a></H2>
<p>
</p>
-<H2><a name="Warnings_nn4"></a>14.3 Enabling extra warnings</H2>
+<H2><a name="Warnings_nn4">15.3 Enabling extra warnings</a></H2>
<p>
or the <tt>-w</tt> option.
</p>
-<H2><a name="Warnings_nn5"></a>14.4 Issuing a warning message</H2>
+<H2><a name="Warnings_nn5">15.4 Issuing a warning message</a></H2>
<p>
</pre>
</div>
-<H2><a name="Warnings_symbolic_symbols"></a>14.5 Symbolic symbols</H2>
+<H2><a name="Warnings_symbolic_symbols">15.5 Symbolic symbols</a></H2>
<p>
</pre>
</div>
-<H2><a name="Warnings_nn6"></a>14.6 Commentary</H2>
+<H2><a name="Warnings_nn6">15.6 Commentary</a></H2>
<p>
messages.
</p>
-<H2><a name="Warnings_nn7"></a>14.7 Warnings as errors</H2>
+<H2><a name="Warnings_nn7">15.7 Warnings as errors</a></H2>
<p>
warning is encountered.
</p>
-<H2><a name="Warnings_nn8"></a>14.8 Message output format</H2>
+<H2><a name="Warnings_nn8">15.8 Message output format</a></H2>
<p>
<div class="shell"><pre>
$ swig -python -Fstandard example.i
-example.i:4: Syntax error in input.
+example.i:4: Syntax error in input(1).
$ swig -python -Fmicrosoft example.i
-example.i(4) : Syntax error in input.
+example.i(4) : Syntax error in input(1).
</pre></div>
-<H2><a name="Warnings_nn9"></a>14.9 Warning number reference</H2>
+<H2><a name="Warnings_nn9">15.9 Warning number reference</a></H2>
-<H3><a name="Warnings_nn10"></a>14.9.1 Deprecated features (100-199)</H3>
+<H3><a name="Warnings_nn10">15.9.1 Deprecated features (100-199)</a></H3>
<ul>
<li>119. Deprecated <tt>%typemap(ignore)</tt>.
<li>120. Deprecated command line option (-runtime, -noruntime).
<li>121. Deprecated <tt>%name</tt> directive.
+<li>126. The 'nestedworkaround' feature is deprecated.
</ul>
-<H3><a name="Warnings_nn11"></a>14.9.2 Preprocessor (200-299)</H3>
+<H3><a name="Warnings_nn11">15.9.2 Preprocessor (200-299)</a></H3>
<ul>
<li>206. Unexpected tokens after #<em>directive</em> directive.
</ul>
-<H3><a name="Warnings_nn12"></a>14.9.3 C/C++ Parser (300-399)</H3>
+<H3><a name="Warnings_nn12">15.9.3 C/C++ Parser (300-399)</a></H3>
<ul>
<li>395. operator delete[] ignored.
</ul>
-<H3><a name="Warnings_nn13"></a>14.9.4 Types and typemaps (400-499) </H3>
+<H3><a name="Warnings_nn13">15.9.4 Types and typemaps (400-499) </a></H3>
<ul>
<li>464. Unsupported constant value.
<li>465. Unable to handle type <em>type</em>.
<li>466. Unsupported variable type <em>type</em>.
-<li>467. Overloaded <em>declaration</em> not supported (no type checking rule for '<em>type</em>')
+<li>467. Overloaded <em>declaration</em> not supported (incomplete type checking rule - no precedence level in typecheck typemap for '<em>type</em>')
<li>468. No 'throw' typemap defined for exception type <em>type</em>
<li>469. No or improper directorin typemap defined for <em>type</em>
<li>470. Thread/reentrant unsafe wrapping, consider returning by value instead.
<li>471. Unable to use return type <em>type</em> in director method
<li>474. Method <em>method</em> usage of the optimal attribute ignored in the out typemap as the following cannot be used to generate optimal code: <em>code</em>
<li>475. Multiple calls to <em>method</em> might be generated due to optimal attribute usage in the out typemap.
+<li>476. Initialization using std::initializer_list.
+<li>477. No directorthrows typemap defined for <em>type</em>
</ul>
-<H3><a name="Warnings_nn14"></a>14.9.5 Code generation (500-599)</H3>
+<H3><a name="Warnings_nn14">15.9.5 Code generation (500-599)</a></H3>
<ul>
<li>523. Use of an illegal destructor name '<em>name</em>' in %extend is deprecated, the destructor name should be '<em>name</em>'.
</ul>
-<H3><a name="Warnings_nn15"></a>14.9.6 Language module specific (700-899) </H3>
+<H3><a name="Warnings_nn15">15.9.6 Language module specific (700-899) </a></H3>
<ul>
<li>810. No jni typemap defined for <em>type</em> (Java).
<li>811. No jtype typemap defined for <em>type</em> (Java).
<li>812. No jstype typemap defined for <em>type</em> (Java).
-<li>813. Warning for <em>classname</em>: Base <em>baseclass</em> ignored. Multiple inheritance is not supported in Java. (Java).
+<li>813. Warning for <em>classname</em>, base <em>baseclass</em> ignored. Multiple inheritance is not supported in Java. (Java).
<li>814.
<li>815. No javafinalize typemap defined for <em>type</em> (Java).
<li>816. No javabody typemap defined for <em>type</em> (Java).
<li>830. No ctype typemap defined for <em>type</em> (C#).
<li>831. No cstype typemap defined for <em>type</em> (C#).
<li>832. No cswtype typemap defined for <em>type</em> (C#).
-<li>833. Warning for <em>classname</em>: Base <em>baseclass</em> ignored. Multiple inheritance is not supported in C#. (C#).
+<li>833. Warning for <em>classname</em>, base <em>baseclass</em> ignored. Multiple inheritance is not supported in C#. (C#).
<li>834.
<li>835. No csfinalize typemap defined for <em>type</em> (C#).
<li>836. No csbody typemap defined for <em>type</em> (C#).
</ul>
<ul>
-<li>870. Warning for <em>classname</em>: Base <em>baseclass</em> ignored. Multiple inheritance is not supported in PHP.
+<li>870. Warning for <em>classname</em>: Base <em>baseclass</em> ignored. Multiple inheritance is not supported in PHP. (Php).
<li>871. Unrecognized pragma <em>pragma</em>. (Php).
</ul>
-<H3><a name="Warnings_nn16"></a>14.9.7 User defined (900-999)</H3>
+<H3><a name="Warnings_nn16">15.9.7 User defined (900-999)</a></H3>
<p>
These numbers can be used by your own application.
</p>
-<H2><a name="Warnings_nn17"></a>14.10 History</H2>
+<H2><a name="Warnings_nn17">15.10 History</a></H2>
<p>
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Getting started on Windows</title>
<link rel="stylesheet" type="text/css" href="style.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="Windows"></a>3 Getting started on Windows </H1>
+<H1><a name="Windows">3 Getting started on Windows </a></H1>
<!-- INDEX -->
<div class="sectiontoc">
<ul>
</p>
-<H2><a name="Windows_installation"></a>3.1 Installation on Windows</H2>
+<H2><a name="Windows_installation">3.1 Installation on Windows</a></H2>
<p>
<li>Set environment variables as described in the <a href="#Windows_examples">SWIG Windows Examples</a> section in order to run examples using Visual C++.
</ul>
-<H3><a name="Windows_executable"></a>3.1.1 Windows Executable</H3>
+<H3><a name="Windows_executable">3.1.1 Windows Executable</a></H3>
<p>
</p>
-<H2><a name="Windows_examples"></a>3.2 SWIG Windows Examples</H2>
+<H2><a name="Windows_examples">3.2 SWIG Windows Examples</a></H2>
<p>
Using Microsoft Visual C++ is the most common approach to compiling and linking SWIG's output.
The Examples directory has a few Visual C++ project files (.dsp files).
These were produced by Visual C++ 6.
-Later versions of Visual Studio should also be able to open and convert these project files.
-The C# examples come with .NET 2003 solution (.sln) and project files instead of Visual C++ 6 project files.
+Newer versions of Visual Studio should be able to open and convert these project files.
+Each C# example comes with a Visual Studio 2005 solution and associated project files instead of Visual C++ 6 project files.
The project files have been set up to execute SWIG in a custom build rule for the SWIG interface (.i) file.
Alternatively run the <a href="#Windows_examples_cygwin">examples using Cygwin</a>.
<p>
More information on each of the examples is available with the examples distributed with SWIG (Examples/index.html).
-<H3><a name="Windows_visual_studio"></a>3.2.1 Instructions for using the Examples with Visual Studio</H3>
+<H3><a name="Windows_visual_studio">3.2.1 Instructions for using the Examples with Visual Studio</a></H3>
<p>
If you are interested in how the project files are set up there is explanatory information in some of the language module's documentation.
</p>
-<H4><a name="Windows_csharp"></a>3.2.1.1 C#</H4>
+<H4><a name="Windows_csharp">3.2.1.1 C#</a></H4>
<p>
</p>
-<H4><a name="Windows_java"></a>3.2.1.2 Java</H4>
+<H4><a name="Windows_java">3.2.1.2 Java</a></H4>
<p>
</p>
-<H4><a name="Windows_perl"></a>3.2.1.3 Perl</H4>
+<H4><a name="Windows_perl">3.2.1.3 Perl</a></H4>
<p>
</p>
-<H4><a name="Windows_python"></a>3.2.1.4 Python</H4>
+<H4><a name="Windows_python">3.2.1.4 Python</a></H4>
<p>
</p>
-<H4><a name="Windows_tcl"></a>3.2.1.5 TCL</H4>
+<H4><a name="Windows_tcl">3.2.1.5 TCL</a></H4>
<p>
<b><tt>TCL_INCLUDE</tt></b> : Set this to the directory containing tcl.h<br>
<b><tt>TCL_LIB</tt></b> : Set this to the TCL library including path for linking<p>
-Example using ActiveTcl 8.3.3.3 <br>
+Example using ActiveTcl 8.3.3.3<br>
<tt>
TCL_INCLUDE: D:\tcl\include<br>
TCL_LIB: D:\tcl\lib\tcl83.lib<br>
</p>
-<H4><a name="Windows_r"></a>3.2.1.6 R</H4>
+<H4><a name="Windows_r">3.2.1.6 R</a></H4>
<p>
</p>
-<H4><a name="Windows_ruby"></a>3.2.1.7 Ruby</H4>
+<H4><a name="Windows_ruby">3.2.1.7 Ruby</a></H4>
<p>
</p>
-<H3><a name="Windows_other_compilers"></a>3.2.2 Instructions for using the Examples with other compilers</H3>
+<H3><a name="Windows_other_compilers">3.2.2 Instructions for using the Examples with other compilers</a></H3>
<p>
If you do not have access to Visual C++ you will have to set up project files / Makefiles for your chosen compiler. There is a section in each of the language modules detailing what needs setting up using Visual C++ which may be of some guidance. Alternatively you may want to use Cygwin as described in the following section.
</p>
-<H2><a name="Windows_cygwin_mingw"></a>3.3 SWIG on Cygwin and MinGW</H2>
+<H2><a name="Windows_cygwin_mingw">3.3 SWIG on Cygwin and MinGW</a></H2>
<p>
SWIG can also be compiled and run using <a href="http://www.cygwin.com">Cygwin</a> or <a href="http://www.mingw.org">MinGW</a> which provides a Unix like front end to Windows and comes free with gcc, an ANSI C/C++ compiler. However, this is not a recommended approach as the prebuilt executable is supplied.
</p>
-<H3><a name="Windows_swig_exe"></a>3.3.1 Building swig.exe on Windows</H3>
+<H3><a name="Windows_swig_exe">3.3.1 Building swig.exe on Windows</a></H3>
<p>
Normally this is not needed, so most people will want to ignore this section.
</p>
-<H4><a name="Windows_mingw_msys"></a>3.3.1.1 Building swig.exe using MinGW and MSYS</H4>
+<H4><a name="Windows_mingw_msys">3.3.1.1 Building swig.exe using MinGW and MSYS</a></H4>
<p>
Start the MSYS command prompt and execute:
<div class="shell"><pre>
cd /
-tar -jxf msys-automake-1.8.2.tar.bz2
+tar -jxf msys-automake-1.8.2.tar.bz2
tar -jxf msys-autoconf-2.59.tar.bz2
-tar -zxf bison-2.0-MSYS.tar.gz
+tar -zxf bison-2.0-MSYS.tar.gz
</pre></div>
</li>
</ol>
-<H4><a name="Windows_cygwin"></a>3.3.1.2 Building swig.exe using Cygwin</H4>
+<H4><a name="Windows_cygwin">3.3.1.2 Building swig.exe using Cygwin</a></H4>
<p>
These files are generated using the <tt>autogen.sh</tt> script and will only need regenerating in circumstances such as changing the build system.
</p>
-<H4><a name="Windows_building_alternatives"></a>3.3.1.3 Building swig.exe alternatives</H4>
+<H4><a name="Windows_building_alternatives">3.3.1.3 Building swig.exe alternatives</a></H4>
<p>
</p>
-<H3><a name="Windows_examples_cygwin"></a>3.3.2 Running the examples on Windows using Cygwin</H3>
+<H3><a name="Windows_examples_cygwin">3.3.2 Running the examples on Windows using Cygwin</a></H3>
<p>
Follow the Unix instructions in the README file in the SWIG root directory to build the examples.
</p>
-<H2><a name="Windows_interface_file"></a>3.4 Microsoft extensions and other Windows quirks</H2>
+<H2><a name="Windows_interface_file">3.4 Microsoft extensions and other Windows quirks</a></H2>
<p>
__declspec(dllexport) ULONG __stdcall foo(DWORD, __int32);
</pre></div>
+<p>Note that if you follow Microsoft's recommendation of wrapping the
+<tt>__declspec</tt> calls in a preprocessor definition, you will need to
+make sure that the definition is included by SWIG as well, by either defining it
+manually or via a header. For example, if you have specified the
+preprocessor definition in a header named <tt>export_lib.h</tt> and include
+other headers which depend on it, you should use the <tt>%include</tt> directive
+to include the definition explicitly. For example, if you had a header file,
+<tt>bar.h</tt>, which depended on <tt>export_lib.h</tt>, your SWIG definition
+file might look like:</p>
+
+<div class="code"><pre>
+// bar.i
+%module bar
+%include <windows.i>
+%include "export_lib.h"
+%include "bar.h"
+</pre></div>
+
+<p>
+where export_lib.h may contain:
+</p>
+
+<div class="code"><pre>
+// export_lib.h
+#define BAR_API __declspec(dllexport)
+</pre></div>
+
+<p>
+and bar.h may look like:
+</p>
+
+<div class="code"><pre>
+// bar.h
+#include "export_lib.h"
+BAR_API void bar_function(int, double);
+</pre></div>
+
+<p>
+Using the preprocessor to remove BAR_API is a popular simpler solution:
+</p>
+
+<div class="code"><pre>
+// bar.i
+%module bar
+#define BAR_API
+%include "bar.h"
+</pre></div>
</body>
</html>
Scripting.html
SWIG.html
SWIGPlus.html
+CPlusPlus11.html
Preprocessor.html
Library.html
Arguments.html
Go.html
Guile.html
Java.html
+Javascript.html
Lisp.html
Lua.html
Modula3.html
Python.html
R.html
Ruby.html
+Scilab.html
Tcl.html
Extending.html
#!/usr/bin/python
-# Adds the SWIG stylesheet to the generated documentation on a single page
+# Replace the inline htmldoc stylesheet with the SWIG stylesheet
import sys
import string
lines = data.splitlines()
result = [ ]
+skip = False
for s in lines:
- if s == "<STYLE TYPE=\"text/css\"><!--":
- result.append(s + swigstyle)
- else:
- result.append(s)
+ if not skip:
+ result.append(s)
+ if s == "<STYLE TYPE=\"text/css\"><!--":
+ result.append(swigstyle)
+ skip = True
+ elif s == "--></STYLE>":
+ result.append(s)
+ skip = False
data = "\n".join(result)
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
-<title>SWIG-2.0 Documentation</title>
+<title>SWIG-3.0 Documentation</title>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body bgcolor="#ffffff">
-<H1><a name="index"></a>SWIG-2.0 Documentation</h1>
+<H1><a name="index">SWIG-3.0 Documentation</a></H1>
The SWIG documentation is available in one of the following formats.
<ul>
-[checking]
-anchors=1
-
[filtering]
ignorewarnings=http-robots-denied
+ignorewarnings=https-certificate-error
###############################################################################
# Regexs for <a name="..."></a>
-alink = re.compile(r"<a *name *= *\"(.*)\"></a>", re.IGNORECASE)
+alink = re.compile(r"<a *name *= *\"(.*)\">.*</a>", re.IGNORECASE)
heading = re.compile(r"(_nn\d)", re.IGNORECASE)
def getheadingname(m):
headingname = "%s_nn%d" % (filenamebase, nameindex)
return headingname
+# Return heading - 1.1. Introduction in the examples below:
+# old style example: <H2><a name="Preface_nn2"></a>1.1 Introduction</H2>
+# new style example: <H2><a name="Preface_nn2">1.1 Introduction</a></H2>
+def getheadingtext(m, s):
+ prevheadingtext_newstyle = m.group(2)
+ prevheadingtext_oldstyle = m.group(3)
+ if len(prevheadingtext_oldstyle) == 0 and len(prevheadingtext_newstyle) == 0:
+ raise RuntimeError("No heading text in line:\n%s" % s)
+ if len(prevheadingtext_oldstyle) > 0 and len(prevheadingtext_newstyle) > 0:
+ raise RuntimeError("Two heading texts, only one should be specified in line:\n%s" % s)
+ prevheadingtext = prevheadingtext_oldstyle if len(prevheadingtext_oldstyle) > 0 else prevheadingtext_newstyle
+ return prevheadingtext
+
###############################################################################
# Main program
###############################################################################
# Regexs for <h1>,... <h5> sections
-h1 = re.compile(r".*?<H1>(<a.*a>)*[\d\.\s]*(.*?)</H1>", re.IGNORECASE)
-h2 = re.compile(r".*?<H2>(<a.*a>)*[\d\.\s]*(.*?)</H2>", re.IGNORECASE)
-h3 = re.compile(r".*?<H3>(<a.*a>)*[\d\.\s]*(.*?)</H3>", re.IGNORECASE)
-h4 = re.compile(r".*?<H4>(<a.*a>)*[\d\.\s]*(.*?)</H4>", re.IGNORECASE)
-h5 = re.compile(r".*?<H5>(<a.*a>)*[\d\.\s]*(.*?)</H5>", re.IGNORECASE)
+h1 = re.compile(r".*?<H1>(<a.*?>\s*[\d\s]*(.*?)</a>)*[\d\s]*(.*?)</H1>", re.IGNORECASE)
+h2 = re.compile(r".*?<H2>(<a.*?>\s*[\d\.\s]*(.*?)</a>)*[\d\.\s]*(.*?)</H2>", re.IGNORECASE)
+h3 = re.compile(r".*?<H3>(<a.*?>\s*[\d\.\s]*(.*?)</a>)*[\d\.\s]*(.*?)</H3>", re.IGNORECASE)
+h4 = re.compile(r".*?<H4>(<a.*?>\s*[\d\.\s]*(.*?)</a>)*[\d\.\s]*(.*?)</H4>", re.IGNORECASE)
+h5 = re.compile(r".*?<H5>(<a.*?>\s*[\d\.\s]*(.*?)</a>)*[\d\.\s]*(.*?)</H5>", re.IGNORECASE)
data = open(filename).read() # Read data
open(filename+".bak","w").write(data) # Make backup
m = h1.match(s)
if m:
- prevheadingtext = m.group(2)
+ prevheadingtext = getheadingtext(m, s)
nameindex += 1
headingname = getheadingname(m)
- result.append("""<H1><a name="%s"></a>%d %s</H1>""" % (headingname,num,prevheadingtext))
+ result.append("""<H1><a name="%s">%d %s</a></H1>""" % (headingname,num,prevheadingtext))
result.append("@INDEX@")
section = 0
subsection = 0
continue
m = h2.match(s)
if m:
- prevheadingtext = m.group(2)
+ prevheadingtext = getheadingtext(m, s)
nameindex += 1
section += 1
headingname = getheadingname(m)
- result.append("""<H2><a name="%s"></a>%d.%d %s</H2>""" % (headingname,num,section, prevheadingtext))
+ result.append("""<H2><a name="%s">%d.%d %s</a></H2>""" % (headingname,num,section, prevheadingtext))
if subsubsubsection:
index += "</ul>\n"
continue
m = h3.match(s)
if m:
- prevheadingtext = m.group(2)
+ prevheadingtext = getheadingtext(m, s)
nameindex += 1
subsection += 1
headingname = getheadingname(m)
- result.append("""<H3><a name="%s"></a>%d.%d.%d %s</H3>""" % (headingname,num,section, subsection, prevheadingtext))
+ result.append("""<H3><a name="%s">%d.%d.%d %s</a></H3>""" % (headingname,num,section, subsection, prevheadingtext))
if subsubsubsection:
index += "</ul>\n"
continue
m = h4.match(s)
if m:
- prevheadingtext = m.group(2)
+ prevheadingtext = getheadingtext(m, s)
nameindex += 1
subsubsection += 1
headingname = getheadingname(m)
- result.append("""<H4><a name="%s"></a>%d.%d.%d.%d %s</H4>""" % (headingname,num,section, subsection, subsubsection, prevheadingtext))
+ result.append("""<H4><a name="%s">%d.%d.%d.%d %s</a></H4>""" % (headingname,num,section, subsection, subsubsection, prevheadingtext))
if subsubsubsection:
index += "</ul>\n"
continue
m = h5.match(s)
if m:
- prevheadingtext = m.group(2)
+ prevheadingtext = getheadingtext(m, s)
nameindex += 1
subsubsubsection += 1
headingname = getheadingname(m)
- result.append("""<H5><a name="%s"></a>%d.%d.%d.%d.%d %s</H5>""" % (headingname,num,section, subsection, subsubsection, subsubsubsection, prevheadingtext))
+ result.append("""<H5><a name="%s">%d.%d.%d.%d.%d %s</a></H5>""" % (headingname,num,section, subsection, subsubsection, subsubsubsection, prevheadingtext))
if subsubsubsection == 1:
index += "<ul>\n"
f = open("Contents.html","w")
print >>f, """
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<HTML>
<HEAD>
<TITLE>SWIG Users Manual</TITLE>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</HEAD>
<BODY BGCOLOR="#ffffff">
+
<H1><a name="Contents"></a>SWIG Users Manual</H1>
<p>
+++ /dev/null
-# This patch is against htmldoc 1.8.27, and it hacks in support for
-# correctly indenting the <div class=""> sections in the SWIG manual.
-# This patch should only be used until the 1.9 branch of htmldoc
-# stabilizes, since the 1.9 branch includes true CSS1 support.
-#
-# This patch only affects the PDF generation, an unpatched htmldoc
-# creates the one-page html documentation just fine.
-#
-diff -Naur htmldoc-1.8.27/htmldoc/htmldoc.cxx htmldoc-1.8.27-margin-left/htmldoc/htmldoc.cxx
---- htmldoc-1.8.27/htmldoc/htmldoc.cxx 2006-03-30 14:01:20.000000000 +0100
-+++ htmldoc-1.8.27-margin-left/htmldoc/htmldoc.cxx 2013-05-11 10:11:47.428435647 +0100
-@@ -65,6 +65,8 @@
- const char *__XOS2RedirRoot(const char *);
- }
- #endif
-+
-+extern void parse_style(char *);
-
-
- /*
-@@ -1115,6 +1117,7 @@
- else if (compare_strings(argv[i], "--version", 6) == 0)
- {
- puts(SVERSION);
-+ puts("Patched with margin-left.patch");
- return (0);
- }
- else if (compare_strings(argv[i], "--webpage", 3) == 0)
-@@ -2403,6 +2406,10 @@
- }
- else if (strcmp(temp, "--cookies") == 0)
- file_cookies(temp2);
-+ else if (strcmp(temp, "--stylesheet") == 0)
-+ {
-+ parse_style(temp2);
-+ }
- }
- }
-
-diff -Naur htmldoc-1.8.27/htmldoc/Makefile htmldoc-1.8.27-margin-left/htmldoc/Makefile
---- htmldoc-1.8.27/htmldoc/Makefile 2005-10-28 21:32:59.000000000 +0100
-+++ htmldoc-1.8.27-margin-left/htmldoc/Makefile 2013-05-11 09:39:04.392367869 +0100
-@@ -36,7 +36,7 @@
- OBJS = gui.o file.o html.o htmldoc.o htmllib.o htmlsep.o \
- http.o http-addr.o http-addrlist.o http-support.o image.o \
- iso8859.o license.o md5.o progress.o ps-pdf.o rc4.o \
-- snprintf.o string.o toc.o util.o
-+ snprintf.o string.o toc.o util.o style.o
-
-
- #
-diff -Naur htmldoc-1.8.27/htmldoc/ps-pdf.cxx htmldoc-1.8.27-margin-left/htmldoc/ps-pdf.cxx
---- htmldoc-1.8.27/htmldoc/ps-pdf.cxx 2006-08-01 17:58:50.000000000 +0100
-+++ htmldoc-1.8.27-margin-left/htmldoc/ps-pdf.cxx 2013-05-11 09:37:40.096364957 +0100
-@@ -160,6 +160,7 @@
- # undef page_t
- #endif // __hpux
-
-+extern int lookup_div_class(uchar *);
-
- /*
- * Output options...
-@@ -4230,9 +4231,24 @@
- para->child = para->last_child = NULL;
- }
-
-- parse_doc(t->child, left, right, bottom, top, x, y, page, NULL,
-+ {
-+ int num_indent = 0;
-+ uchar *cname;
-+
-+ if (cname = htmlGetVariable(t, (uchar *)"class")) {
-+ num_indent = lookup_div_class(cname);
-+ *left += 5.0f * num_indent;
-+ *x = *left;
-+ }
-+
-+ parse_doc(t->child, left, right, bottom, top, x, y, page, NULL,
- needspace);
-
-+ if (num_indent > 0) {
-+ *left -= 5.0f * num_indent;
-+ }
-+ }
-+
- if (para->child != NULL)
- {
- parse_paragraph(para, *left, *right, *bottom, *top, x, y, page, *needspace);
-diff -Naur htmldoc-1.8.27/htmldoc/style.cxx htmldoc-1.8.27-margin-left/htmldoc/style.cxx
---- htmldoc-1.8.27/htmldoc/style.cxx 1970-01-01 01:00:00.000000000 +0100
-+++ htmldoc-1.8.27-margin-left/htmldoc/style.cxx 2013-05-11 09:37:40.096364957 +0100
-@@ -0,0 +1,185 @@
-+/* Extreamly simple parsing routines for CSS style sheets.
-+ * We only parse div.class { } sections, and only look
-+ * for margin-left: <num>em;
-+ *
-+ * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
-+ *
-+ * Released under GNU GPL v2 or above.
-+ */
-+
-+#include <stdio.h>
-+#include <stdlib.h>
-+#include <fcntl.h>
-+#include <string.h>
-+#include <ctype.h>
-+
-+#include "types.h"
-+
-+#define BUFF_SIZE 512
-+
-+struct div_entry {
-+ uchar class_name[BUFF_SIZE];
-+ int indent;
-+ struct div_entry *next;
-+};
-+
-+static struct div_entry *head = 0;
-+
-+/* These are the parsing states */
-+#define IGNORE_TILL_SEMI 0
-+#define IGNORE_TILL_CLOSE_BRACE 1
-+#define READING_DIV 2
-+#define READING_CLASS 3
-+#define READING_ATTRIBUTE 4
-+#define READING_NUM 5
-+#define CHECKING_ONLY_DIV 6
-+
-+static int at_eof = 0;
-+
-+static int strucmp(uchar *a, uchar *b) {
-+ int i;
-+ for (i = 0; a[i] && b[i]; i++) {
-+ if (a[i] < b[i]) return -1;
-+ if (a[i] > b[i]) return 1;
-+ }
-+ /* This isn't right, but who cares...*/
-+ if (a[i] || b[i]) return 1;
-+ return 0;
-+}
-+
-+static int read_word(FILE *f, const char *word) {
-+ char c;
-+ for (int idx = 0; word[idx]; idx++) {
-+ c = getc(f);
-+ if (c == EOF) {
-+ at_eof = 1;
-+ return 0;
-+ }
-+ if (c != word[idx])
-+ return 0;
-+ }
-+ return 1;
-+}
-+
-+int lookup_div_class(uchar *name) {
-+ struct div_entry *node = head;
-+
-+ while (node) {
-+ if (strucmp(node->class_name, name) == 0)
-+ return node->indent;
-+ node = node->next;
-+ }
-+
-+ return 0;
-+}
-+
-+void parse_style(char *fname) {
-+ FILE *f;
-+ char c;
-+ int state;
-+ struct div_entry *cur = 0;
-+ int class_idx = 0;
-+ char num[BUFF_SIZE];
-+ int num_idx = 0;
-+
-+ if (!fname) return;
-+
-+ f = fopen(fname, "r");
-+ if (!f) {
-+ fprintf(stderr, "Unable to parse style\n");
-+ return;
-+ }
-+
-+ state = READING_DIV;
-+ while (!at_eof && (c = getc(f)) != EOF) {
-+ switch (state) {
-+
-+ case IGNORE_TILL_SEMI:
-+ if (c == ';')
-+ state = READING_ATTRIBUTE;
-+ break;
-+
-+ case IGNORE_TILL_CLOSE_BRACE:
-+ if (c == '}')
-+ state = READING_DIV;
-+ break;
-+
-+ case READING_DIV:
-+ if (c != ' ' && c != '\t' && c != '\n') {
-+ if (c == 'd' && read_word(f, "iv.")) {
-+ state = READING_CLASS;
-+ cur = (struct div_entry *) malloc(sizeof(struct div_entry));
-+ memset(cur, 0, sizeof(struct div_entry));
-+ class_idx = 0;
-+ } else
-+ state = IGNORE_TILL_CLOSE_BRACE;
-+ }
-+ break;
-+
-+ case READING_CLASS:
-+ if (isalpha(c)) {
-+ if (class_idx >= BUFF_SIZE-1) {
-+ fprintf(stderr, "class size %s too long\n", cur->class_name);
-+ free(cur);
-+ state = IGNORE_TILL_CLOSE_BRACE;
-+ } else {
-+ cur->class_name[class_idx++] = c;
-+ }
-+ } else {
-+ if (c == '{') {
-+ cur->next = head;
-+ head = cur;
-+ state = READING_ATTRIBUTE;
-+ } else
-+ state = CHECKING_ONLY_DIV;
-+ }
-+ break;
-+
-+ case READING_ATTRIBUTE:
-+ if (c != ' ' && c != '\t' && c != '\n') {
-+ if (c == '}')
-+ state = READING_DIV;
-+ else {
-+ if (c == 'm' && read_word(f, "argin-left:")) {
-+ num_idx = 0;
-+ memset(num, 0, sizeof(num));
-+ state = READING_NUM;
-+ } else {
-+ state = IGNORE_TILL_SEMI;
-+ }
-+ }
-+ }
-+ break;
-+
-+ case READING_NUM:
-+ if (isdigit(c)) {
-+ if (num_idx >= BUFF_SIZE - 1) {
-+ fprintf(stderr, "Number too long\n");
-+ state = IGNORE_TILL_SEMI;
-+ } else {
-+ num[num_idx++] = c;
-+ }
-+ } else if (c != ' ' && c != '\t') {
-+ if (num_idx > 0 && c == 'e' && read_word(f, "m"))
-+ cur->indent = atoi(num);
-+ state = IGNORE_TILL_SEMI;
-+ }
-+ break;
-+
-+ case CHECKING_ONLY_DIV:
-+ if (c != ' ' && c != '\t' && c != '\n') {
-+ if (c == '{') {
-+ cur->next = head;
-+ head = cur;
-+ state = READING_ATTRIBUTE;
-+ } else {
-+ free(cur);
-+ state = IGNORE_TILL_CLOSE_BRACE;
-+ }
-+ }
-+ break;
-+ }
-+ }
-+
-+ fclose(f);
-+}
margin-left: 4em;
margin-right: 4em;
background-color: #F0FFFF;
+ font-family: "Courier New", Courier, "Courier 10 Pitch", monospace;
}
div.targetlang {
margin-left: 4em;
margin-right: 4em;
background-color: #d7f6bb;
+ font-family: "Courier New", Courier, "Courier 10 Pitch", monospace;
}
-
div.shell {
border-style: solid;
border-width: 1px;
margin-left: 4em;
margin-right: 4em;
background-color: #DCDCDC;
+ font-family: "Courier New", Courier, "Courier 10 Pitch", monospace;
}
div.diagram {
margin-left: 4em;
margin-right: 4em;
background-color: #FFEBCD;
+ font-family: "Courier New", Courier, "Courier 10 Pitch", monospace;
}
ul li p {
margin-right: 0;
}
+pre, code, tt {
+ font-family: "Courier New", Courier, "Courier 10 Pitch", monospace;
+}
+
+body { font-family: serif; }
Scripting.html
SWIG.html
SWIGPlus.html
+CPlusPlus11.html
Preprocessor.html
Library.html
Arguments.html
Go.html
Guile.html
Java.html
+Javascript.html
Lisp.html
Lua.html
Modula3.html
Python.html
R.html
Ruby.html
+Scilab.html
Tcl.html
Extending.html
+++ /dev/null
-#HTMLDOC 1.8.24
--t pdf13 -f SWIGDocumentation.pdf --book --toclevels 4 --no-numbered --toctitle "Table of Contents" --title --titleimage swig16.png --linkcolor #0000ff --linkstyle underline --size Universal --left 0.50in --right 0.50in --top 0.50in --bottom 0.50in --header .t. --footer h.1 --nup 1 --tocheader .t. --tocfooter ..i --portrait --color --no-pscommands --no-xrxcomments --compression=1 --jpeg=0 --fontsize 10.0 --fontspacing 1.2 --headingfont Helvetica --bodyfont Times --headfootsize 10.0 --headfootfont Helvetica --charset iso-8859-1 --links --no-embedfonts --pagemode outline --pagelayout single --firstpage c1 --pageeffect none --pageduration 10 --effectduration 1.0 --no-encryption --permissions all --owner-password "" --user-password "" --browserwidth 680 --stylesheet style.css
-Sections.html
-Preface.html
-Introduction.html
-Windows.html
-Scripting.html
-SWIG.html
-SWIGPlus.html
-Preprocessor.html
-Library.html
-Arguments.html
-Typemaps.html
-Customization.html
-Contract.html
-Varargs.html
-Warnings.html
-Modules.html
-CCache.html
-Allegrocl.html
-Android.html
-CSharp.html
-Chicken.html
-D.html
-Go.html
-Guile.html
-Java.html
-Lisp.html
-Lua.html
-Modula3.html
-Mzscheme.html
-Ocaml.html
-Octave.html
-Perl5.html
-Php.html
-Pike.html
-Python.html
-R.html
-Ruby.html
-Tcl.html
-Extending.html
#
# 2. To use this makefile, set required variables, eg SRCS, INTERFACE,
# INTERFACEDIR, INCLUDES, LIBS, TARGET, and do a
-# $(MAKE) -f Makefile.template.in SRCS='$(SRCS)' \
+# $(MAKE) -f Makefile.template.in SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
# INCLUDES='$(INCLUDES) LIBS='$(LIBS)' INTERFACE='$(INTERFACE)' \
# INTERFACEDIR='$(INTERFACEDIR)' TARGET='$(TARGET)' method
#
# 'method' describes what is being built.
#---------------------------------------------------------------
+# Regenerate Makefile if Makefile.in or config.status have changed.
+Makefile: @srcdir@/Makefile.in ../config.status
+ cd .. && $(SHELL) ./config.status Examples/Makefile
+
+# SRCDIR is the relative path to the current source directory
+# - For in-source-tree builds, SRCDIR with be either '' or './', but
+# '../' for the test suites that build in a subdir (e.g. C#, Java)
+# - For out-of-source-tree builds, SRCDIR will be a relative
+# path ending with a '/'
+
+# SRCDIR_SRCS, etc. are $(SRCS), etc. with $(SRCDIR) prepended
+SRCDIR_SRCS = $(addprefix $(SRCDIR),$(SRCS))
+SRCDIR_CSRCS = $(addprefix $(SRCDIR),$(CSRCS))
+SRCDIR_CXXSRCS = $(addprefix $(SRCDIR),$(CXXSRCS))
+
+ifeq (,$(SRCDIR))
+SRCDIR_INCLUDE = -I.
+else
+SRCDIR_INCLUDE = -I. -I$(SRCDIR)
+endif
+
TARGET =
CC = @CC@
CXX = @CXX@
-CFLAGS = @BOOST_CPPFLAGS@ @PLATFLAGS@
+CPPFLAGS = $(SRCDIR_INCLUDE)
+CFLAGS = @PLATCFLAGS@
+CXXFLAGS = @BOOST_CPPFLAGS@ @PLATCXXFLAGS@
+LDFLAGS =
prefix = @prefix@
exec_prefix= @exec_prefix@
SRCS =
LIBS =
INTERFACE =
INTERFACEDIR =
-INTERFACEPATH = $(INTERFACEDIR)$(INTERFACE)
+INTERFACEPATH = $(SRCDIR)$(INTERFACEDIR)$(INTERFACE)
SWIGOPT =
-SWIG = swig
+
+# SWIG_LIB_DIR and SWIGEXE must be explicitly set by Makefiles using this Makefile
+SWIG_LIB_DIR = ./Lib
+SWIGEXE = swig
+SWIG_LIB_SET = @SWIG_LIB_SET@
+SWIGTOOL =
+SWIG = $(SWIG_LIB_SET) $(SWIGTOOL) $(SWIGEXE)
LIBM = @LIBM@
LIBC = @LIBC@
RUNME = runme
-# X11 options
-
-XLIB = @XLIBSW@
-XINCLUDE = @XINCLUDES@
-
IWRAP = $(INTERFACE:.i=_wrap.i)
ISRCS = $(IWRAP:.i=.c)
ICXXSRCS = $(IWRAP:.i=.cxx)
##################################################################
CPP_DLLIBS = #-L/usr/local/lib/gcc-lib/sparc-sun-solaris2.5.1/2.7.2 \
- -L/usr/local/lib -lg++ -lstdc++ -lgcc
+ -L/usr/local/lib -lg++ -lstdc++ -lgcc
# Solaris workshop 5.0
# CPP_DLLIBS = -L/opt/SUNWspro/lib -lCrun
distclean:
rm -f Makefile
+ rm -f d/example.mk
rm -f xml/Makefile
##################################################################
+# Very generic invocation of swig
+##################################################################
+
+swiginvoke:
+ $(SWIG) $(SWIGOPT)
+
+##################################################################
##### Tcl/Tk ######
##################################################################
TCL_SO = @TCL_SO@
TCLLDSHARED = @TCLLDSHARED@
TCLCXXSHARED = @TCLCXXSHARED@
-TCL_SCRIPT = $(RUNME).tcl
+TCL_SCRIPT = $(SRCDIR)$(RUNME).tcl
# -----------------------------------------------------------
# Build a new version of the tclsh shell
# -----------------------------------------------------------
-
-tclsh: $(SRCS)
- $(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) -ltclsh.i $(INTERFACEPATH)
- $(CC) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE) \
+tclsh: $(SRCDIR_SRCS)
+ $(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) -ltclsh.i -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) $(SRCDIR_SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE) \
$(TCL_LIB) $(TCL_OPTS) $(LIBS) $(SYSLIBS) -o $(TARGET)
-tclsh_cpp: $(SRCS)
- $(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) -ltclsh.i $(INTERFACEPATH)
- $(CXX) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE) \
+tclsh_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) -ltclsh.i -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE) \
$(TCL_LIB) $(TCL_OPTS) $(LIBS) $(SYSLIBS) -o $(TARGET)
# -----------------------------------------------------------
-# Build a new copy of wish
-# -----------------------------------------------------------
-
-wish: $(SRCS)
- $(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) -lwish.i $(INTERFACEPATH)
- $(CC) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE) \
- $(XINCLUDE) $(TCL_LIB) $(TK_OPTS) $(XLIB) $(LIBS) $(SYSLIBS) -o $(TARGET)
-
-
-wish_cpp: $(SRCS)
- $(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) -lwish.i $(INTERFACEPATH)
- $(CXX) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE) \
- $(XINCLUDE) $(TCL_LIB) $(TK_OPTS) $(XLIB) $(LIBS) $(SYSLIBS) -o $(TARGET)
-
-# -----------------------------------------------------------
# Build a Tcl dynamic loadable module (you might need to tweak this)
# -----------------------------------------------------------
-tcl: $(SRCS)
- $(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) $(INTERFACEPATH)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE)
- $(TCLLDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO)
+tcl: $(SRCDIR_SRCS)
+ $(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(SRCDIR_SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE)
+ $(TCLLDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO)
# -----------------------------------------------------------
# Build a Tcl7.5 dynamic loadable module for C++
# -----------------------------------------------------------
-tcl_cpp: $(SRCS)
- $(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE)
- $(TCLCXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO)
+tcl_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE)
+ $(TCLCXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO)
# -----------------------------------------------------------------
# Run Tcl example
tcl_clean:
rm -f *_wrap* *~ .~* mytclsh@EXEEXT@
rm -f core @EXTRA_CLEAN@
- rm -f *.@OBJEXT@ *@SO@
+ rm -f *.@OBJEXT@ *$(TCL_SO)
##################################################################
##### PERL 5 ######
PERL5_LDFLAGS = @PERL5LDFLAGS@
PERL = @PERL@
PERL5_LIB = -L$(PERL5_INCLUDE) -l@PERL5LIB@ @LIBS@ $(SYSLIBS)
-PERL5_SCRIPT = $(RUNME).pl
+PERL5_SCRIPT = $(SRCDIR)$(RUNME).pl
# ----------------------------------------------------------------
# Build a Perl5 dynamically loadable module (C)
# ----------------------------------------------------------------
-perl5: $(SRCS)
- $(SWIG) -perl5 $(SWIGOPT) $(INTERFACEPATH)
- $(CC) -c -Dbool=char $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(PERL5_CCFLAGS) $(PERL5_CCCDLFLAGS) -I$(PERL5_INCLUDE)
- $(LDSHARED) $(CFLAGS) $(PERL5_CCDLFLAGS) $(OBJS) $(IOBJS) $(PERL5_LDFLAGS) $(PERL5_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+perl5: $(SRCDIR_SRCS)
+ $(SWIG) -perl5 $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -c -Dbool=char $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(SRCDIR_SRCS) $(ISRCS) $(INCLUDES) $(PERL5_CCFLAGS) $(PERL5_CCCDLFLAGS) -I$(PERL5_INCLUDE)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(PERL5_CCDLFLAGS) $(OBJS) $(IOBJS) $(PERL5_LDFLAGS) $(PERL5_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
# ----------------------------------------------------------------
# Build a Perl5 dynamically loadable module (C++)
# ----------------------------------------------------------------
-perl5_cpp: $(SRCS)
- $(SWIG) -perl5 -c++ $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(PERL5_CCFLAGS) $(PERL5_CCCDLFLAGS) -I$(PERL5_INCLUDE)
- $(CXXSHARED) $(CFLAGS) $(PERL5_CCDLFLAGS) $(OBJS) $(IOBJS) $(PERL5_LDFLAGS) $(PERL5_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+perl5_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -perl5 -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(PERL5_CCFLAGS) $(PERL5_CCCDLFLAGS) -I$(PERL5_INCLUDE)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(PERL5_CCDLFLAGS) $(OBJS) $(IOBJS) $(PERL5_LDFLAGS) $(PERL5_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
# ----------------------------------------------------------------
# Build a module from existing XS C source code. (ie. from xsubpp).
# ----------------------------------------------------------------
-perl5_xs: $(SRCS)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(INCLUDES) -I$(PERL5_INCLUDE)
- $(LDSHARED) $(CFLAGS) $(OBJS) $(LIBS) -o $(TARGET)$(SO)
+perl5_xs: $(SRCDIR_SRCS)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(SRCDIR_SRCS) $(INCLUDES) -I$(PERL5_INCLUDE)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(LIBS) -o $(TARGET)$(SO)
# ----------------------------------------------------------------
# Build a statically linked Perl5 executable
# ----------------------------------------------------------------
-perl5_static: $(SRCS)
- $(SWIG) -perl5 -static -lperlmain.i $(SWIGOPT) $(INTERFACEPATH)
- $(CC) $(CFLAGS) -Dbool=char $(SRCS) $(ISRCS) $(INCLUDES) -I$(PERL5_INCLUDE) $(PERL5_LIB) $(LIBS) -o $(TARGET)
+perl5_static: $(SRCDIR_SRCS)
+ $(SWIG) -perl5 -static -lperlmain.i $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -Dbool=char $(SRCDIR_SRCS) $(ISRCS) $(INCLUDES) -I$(PERL5_INCLUDE) $(PERL5_LIB) $(LIBS) -o $(TARGET)
-perl5_static_cpp: $(SRCS)
- $(SWIG) -perl5 -c++ -static -lperlmain.i $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) -I$(PERL5_INCLUDE) $(PERL5_LIB) $(LIBS) -o $(TARGET)
+perl5_static_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -perl5 -c++ -static -lperlmain.i $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(ICXXSRCS) $(INCLUDES) -I$(PERL5_INCLUDE) $(PERL5_LIB) $(LIBS) -o $(TARGET)
# -----------------------------------------------------------------
# Running a Perl5 example
##### PYTHON ######
##################################################################
+PYTHON_FLAGS =
+
# Make sure these locate your Python installation
ifeq (,$(PY3))
PYTHON_INCLUDE= $(DEFS) @PYINCLUDE@
PYTHON_LIB = @PYLIB@
- PYTHON = @PYTHON@
+ PYTHON = @PYTHON@ $(PYTHON_FLAGS)
else
PYTHON_INCLUDE= $(DEFS) @PY3INCLUDE@
PYTHON_LIB = @PY3LIB@
- PYTHON = @PYTHON3@
+ PYTHON = @PYTHON3@ $(PYTHON_FLAGS)
endif
# Extra Python specific linking options
endif
PYTHON_SO = @PYTHON_SO@
-# SWIG option for Python
+# SWIG option for Python3
ifeq (,$(PY3))
- SWIGPYTHON = $(SWIG) -python
+ SWIGOPTPY3 =
else
- SWIGPYTHON = $(SWIG) -python -py3
+ SWIGOPTPY3 = -py3
endif
+PEP8 = @PEP8@
+PEP8_FLAGS = --ignore=E402,E501,E30,W291,W391
+
# ----------------------------------------------------------------
# Build a C dynamically loadable module
# ----------------------------------------------------------------
-python: $(SRCS)
- $(SWIGPYTHON) $(SWIGOPT) $(INTERFACEPATH)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(PYTHON_INCLUDE)
- $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(PYTHON_DLNK) $(LIBS) -o $(LIBPREFIX)_$(TARGET)$(PYTHON_SO)
+python: $(SRCDIR_SRCS)
+ $(SWIG) -python $(SWIGOPTPY3) $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(ISRCS) $(SRCDIR_SRCS) $(INCLUDES) $(PYTHON_INCLUDE)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(PYTHON_DLNK) $(LIBS) -o $(LIBPREFIX)_$(TARGET)$(PYTHON_SO)
# -----------------------------------------------------------------
# Build a C++ dynamically loadable module
# -----------------------------------------------------------------
-python_cpp: $(SRCS)
- $(SWIGPYTHON) -c++ $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(PYTHON_INCLUDE)
- $(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(PYTHON_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)_$(TARGET)$(PYTHON_SO)
+python_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -python $(SWIGOPTPY3) -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) $(PYTHON_INCLUDE)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(PYTHON_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)_$(TARGET)$(PYTHON_SO)
# -----------------------------------------------------------------
# Build statically linked Python interpreter
TKINTER =
PYTHON_LIBOPTS = $(PYTHON_LINK) @LIBS@ $(TKINTER) $(SYSLIBS)
-python_static: $(SRCS)
- $(SWIGPYTHON) -lembed.i $(SWIGOPT) $(INTERFACEPATH)
- $(CC) $(CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCS) $(INCLUDES) \
+python_static: $(SRCDIR_SRCS)
+ $(SWIG) -python $(SWIGOPTPY3) -lembed.i $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCDIR_SRCS) $(INCLUDES) \
$(PYTHON_INCLUDE) $(LIBS) -L$(PYTHON_LIB) $(PYTHON_LIBOPTS) -o $(TARGET)
-python_static_cpp: $(SRCS)
- $(SWIGPYTHON) -c++ -lembed.i $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
+python_static_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -python $(SWIGOPTPY3) -c++ -lembed.i $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) \
$(PYTHON_INCLUDE) $(LIBS) -L$(PYTHON_LIB) $(PYTHON_LIBOPTS) -o $(TARGET)
# -----------------------------------------------------------------
PY2TO3 = 2to3 `2to3 -l | grep -v -E "Available|import$$" | awk '{print "-f "$$0}'`
python_run: $(PYSCRIPT)
- $(RUNTOOL) $(PYTHON) $(PYSCRIPT) $(RUNPIPE)
+ifneq (,$(PEP8))
+ $(COMPILETOOL) $(PEP8) $(PEP8_FLAGS) $(PYSCRIPT)
+endif
+ env PYTHONPATH=$$PWD $(RUNTOOL) $(PYTHON) $(PYSCRIPT) $(RUNPIPE)
+
+ifneq (,$(SRCDIR))
+$(RUNME).py: $(SRCDIR)$(RUNME).py
+ cp $< $@
+endif
-$(RUNME)3.py: $(RUNME).py
+$(RUNME)3.py: $(SRCDIR)$(RUNME).py
cp $< $@
$(PY2TO3) -w $@ >/dev/null 2>&1
rm -rf __pycache__
rm -f *_wrap* *~ .~* mypython@EXEEXT@ *.pyc
rm -f core @EXTRA_CLEAN@
- rm -f *.@OBJEXT@ *@SO@ *@PYTHON_SO@
+ rm -f *.@OBJEXT@ *@SO@ *$(PYTHON_SO)
rm -f $(TARGET).py
- if [ -f $(RUNME).py ]; then rm -f $(RUNME)3.py $(RUNME)3.py.bak; fi
+ if test -f $(SRCDIR)$(RUNME).py; then rm -f $(RUNME)3.py $(RUNME)3.py.bak; fi
+ case "x$(SRCDIR)" in x|x./);; *) rm -f $(RUNME).py;; esac
##################################################################
##################################################################
# Make sure these locate your Octave installation
-OCTAVE = OCTAVE_HISTFILE=/dev/null @OCTAVE@
+OCTAVE = @OCTAVE@
OCTAVE_CXX = $(DEFS) @OCTAVE_CPPFLAGS@ @OCTAVE_CXXFLAGS@
# Extra Octave specific dynamic linking options
OCTAVE_DLNK = @OCTAVE_LDFLAGS@
OCTAVE_SO = @OCTAVE_SO@
-OCTAVE_SCRIPT = $(RUNME).m
+OCTAVE_SCRIPT = $(SRCDIR)$(RUNME).m
# ----------------------------------------------------------------
# Build a C dynamically loadable module
# Note: Octave requires C++ compiler when compiling C wrappers
# ----------------------------------------------------------------
-octave: $(SRCS)
- $(SWIG) -octave $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -g -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(INCLUDES) $(OCTAVE_CXX)
- $(CC) -g -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CSRCS) $(INCLUDES)
- $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(OCTAVE_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(OCTAVE_SO)
+octave: $(SRCDIR_SRCS)
+ $(SWIG) -octave $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -g -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(ICXXSRCS) $(INCLUDES) $(OCTAVE_CXX)
+ $(CC) -g -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(SRCDIR_SRCS) $(SRCDIR_CSRCS) $(INCLUDES)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(OCTAVE_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(OCTAVE_SO)
# -----------------------------------------------------------------
# Build a C++ dynamically loadable module
# -----------------------------------------------------------------
-octave_cpp: $(SRCS)
- $(SWIG) -c++ -octave $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -g -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(OCTAVE_CXX)
- $(CXXSHARED) -g $(CFLAGS) $(OBJS) $(IOBJS) $(OCTAVE_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(OCTAVE_SO)
+octave_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -c++ -octave $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -g -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) $(OCTAVE_CXX)
+ $(CXXSHARED) -g $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(OCTAVE_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(OCTAVE_SO)
# -----------------------------------------------------------------
# Running an Octave example
# -----------------------------------------------------------------
octave_run:
- $(RUNTOOL) $(OCTAVE) $(OCTAVE_SCRIPT) $(RUNPIPE)
+ OCTAVE_HISTFILE=/dev/null $(RUNTOOL) $(OCTAVE) $(OCTAVE_SCRIPT) $(RUNPIPE)
# -----------------------------------------------------------------
# Version display
rm -rf __pycache__
rm -f *_wrap* *~ .~* myoctave@EXEEXT@ *.pyc
rm -f core @EXTRA_CLEAN@
- rm -f *.@OBJEXT@ *@SO@ *@OCTAVE_SO@
+ rm -f *.@OBJEXT@ *@SO@ *$(OCTAVE_SO)
##################################################################
##### GUILE ######
GUILE_LIBS = @GUILE_LIBS@
GUILE_LIBOPTS = @LIBS@ $(SYSLIBS)
GUILE_LIBPREFIX = lib
-GUILE_SCRIPT = $(RUNME).scm
+GUILE_SCRIPT = $(SRCDIR)$(RUNME).scm
#------------------------------------------------------------------
# Build a dynamically loaded module with passive linkage
#------------------------------------------------------------------
-guile: $(SRCS)
- $(SWIG) -guile -Linkage passive $(SWIGOPT) $(INTERFACEPATH)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_CFLAGS) $(ISRCS) $(SRCS)
- $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(GUILE_LIBS) $(LIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
+guile: $(SRCDIR_SRCS)
+ $(SWIG) -guile -Linkage passive $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(INCLUDES) $(GUILE_CFLAGS) $(ISRCS) $(SRCDIR_SRCS)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(GUILE_LIBS) $(LIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
-guile_cpp: $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
-$(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO): $(SRCS)
- $(SWIG) -c++ -guile -Linkage passive $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS)
- $(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(GUILE_LIBS) $(LIBS) $(CPP_DLLIBS) -o $@
+guile_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -c++ -guile -Linkage passive $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(INCLUDES) $(GUILE_CFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(GUILE_LIBS) $(LIBS) $(CPP_DLLIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
guile_externalhdr:
$(SWIG) -guile -external-runtime $(TARGET)
# Build Guile interpreter augmented with extra functions
# -----------------------------------------------------------------
-guile_augmented:
- $(SWIG) -guile $(SWIGOPT) $(INTERFACE)
- $(CC) $(CFLAGS) $(SRCS) $(ISRCS) $(GUILE_CFLAGS) $(GUILE_LIBS) $(LIBS) -o $(TARGET)
+guile_augmented: $(SRCDIR_SRCS)
+ $(SWIG) -guile $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) $(SRCDIR_SRCS) $(ISRCS) $(GUILE_CFLAGS) $(GUILE_LIBS) $(LIBS) -o $(TARGET)
# -----------------------------------------------------------------
# Build statically linked Guile interpreter
# -----------------------------------------------------------------
-guile_static: $(SRCS)
- $(SWIG) -guile -lguilemain.i -Linkage ltdlmod $(SWIGOPT) $(INTERFACEPATH)
- $(CC) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) \
+guile_static: $(SRCDIR_SRCS)
+ $(SWIG) -guile -lguilemain.i -Linkage ltdlmod $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) $(ISRCS) $(SRCDIR_SRCS) $(INCLUDES) \
-DSWIGINIT="SCM scm_init_$(TARGET)_module(void); scm_init_$(TARGET)_module();" \
$(GUILE_CFLAGS) $(GUILE_LIBS) $(LIBS) $(GUILE_LIBOPTS) -o $(TARGET)-guile
-guile_static_cpp: $(SRCS)
- $(SWIG) -c++ -guile -lguilemain.i -Linkage ltdlmod $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
+guile_static_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -c++ -guile -lguilemain.i -Linkage ltdlmod $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) \
-DSWIGINIT="SCM scm_init_$(TARGET)_module(void); scm_init_$(TARGET)_module();" \
$(GUILE_CFLAGS) $(GUILE_LIBS) $(LIBS) $(GUILE_LIBOPTS) -o $(TARGET)-guile
-guile_simple: $(SRCS)
- $(SWIG) -guile -lguilemain.i -Linkage simple $(SWIGOPT) $(INTERFACEPATH)
- $(CC) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) \
+guile_simple: $(SRCDIR_SRCS)
+ $(SWIG) -guile -lguilemain.i -Linkage simple $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) $(ISRCS) $(SRCDIR_SRCS) $(INCLUDES) \
$(GUILE_CFLAGS) $(GUILE_LIBS) $(LIBS) $(GUILE_LIBOPTS) -o $(TARGET)-guile
-guile_simple_cpp: $(SRCS)
- $(SWIG) -c++ -guile -lguilemain.i -Linkage simple $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
+guile_simple_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -c++ -guile -lguilemain.i -Linkage simple $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) \
$(GUILE_CFLAGS) $(GUILE_LIBS) $(LIBS) $(GUILE_LIBOPTS) -o $(TARGET)-guile
# -----------------------------------------------------------------
guile_clean:
rm -f *_wrap* *~ .~* my-guile@EXEEXT@ $(TARGET)@EXEEXT@
rm -f core @EXTRA_CLEAN@
- rm -f *.@OBJEXT@ *@GUILE_SO@
+ rm -f *.@OBJEXT@ *$(GUILE_SO)
##################################################################
##### JAVA ######
JAVALDSHARED = @JAVALDSHARED@
JAVACXXSHARED = @JAVACXXSHARED@
JAVACFLAGS = @JAVACFLAGS@
+JAVAFLAGS = @JAVAFLAGS@
JAVA = @JAVA@
-JAVAC = @JAVAC@
+JAVAC = @JAVAC@ -d .
# ----------------------------------------------------------------
# Build a java dynamically loadable module (C)
# ----------------------------------------------------------------
-java: $(SRCS)
- $(SWIG) -java $(SWIGOPT) $(INTERFACEPATH)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(JAVACFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(JAVA_INCLUDE)
- $(JAVALDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(JAVA_DLNK) $(LIBS) -o $(JAVA_LIBPREFIX)$(TARGET)$(JAVASO)
+java: $(SRCDIR_SRCS)
+ $(SWIG) -java $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(JAVACFLAGS) $(SRCDIR_SRCS) $(ISRCS) $(INCLUDES) $(JAVA_INCLUDE)
+ $(JAVALDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(JAVA_DLNK) $(LIBS) -o $(JAVA_LIBPREFIX)$(TARGET)$(JAVASO)
# ----------------------------------------------------------------
# Build a java dynamically loadable module (C++)
# ----------------------------------------------------------------
-java_cpp: $(SRCS)
- $(SWIG) -java -c++ $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(JAVACFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(JAVA_INCLUDE)
- $(JAVACXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(JAVA_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(JAVA_LIBPREFIX)$(TARGET)$(JAVASO)
+java_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -java -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(JAVACFLAGS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(JAVA_INCLUDE)
+ $(JAVACXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(JAVA_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(JAVA_LIBPREFIX)$(TARGET)$(JAVASO)
# ----------------------------------------------------------------
# Compile java files
# ----------------------------------------------------------------
-java_compile: $(SRCS)
- $(COMPILETOOL) $(JAVAC) $(JAVACFLAGS) $(JAVASRCS)
+java_compile: $(SRCDIR_SRCS)
+ $(COMPILETOOL) $(JAVAC) $(addprefix $(SRCDIR),$(JAVASRCS))
# -----------------------------------------------------------------
# Run java example
# -----------------------------------------------------------------
java_run:
- env LD_LIBRARY_PATH=. $(RUNTOOL) $(JAVA) $(RUNME) $(RUNPIPE)
+ env LD_LIBRARY_PATH=$$PWD $(RUNTOOL) $(JAVA) $(JAVAFLAGS) $(RUNME) $(RUNPIPE)
# -----------------------------------------------------------------
# Version display
rm -f *.@OBJEXT@ *@JAVASO@
##################################################################
+##### JAVASCRIPT ######
+##################################################################
+
+# Note: These targets are also from within Makefiles in the Example directories.
+# There is a common makefile, 'Examples/javascript/js_example.mk' to simplify
+# create a configuration for a new example.
+
+ROOT_DIR = @ROOT_DIR@
+JSINCLUDES = @JSCOREINC@ @JSV8INC@
+JSDYNAMICLINKING = @JSCOREDYNAMICLINKING@ @JSV8DYNAMICLINKING@
+NODEJS = @NODEJS@
+NODEGYP = @NODEGYP@
+
+# ----------------------------------------------------------------
+# Creating and building Javascript wrappers
+# ----------------------------------------------------------------
+
+javascript_wrapper:
+ $(SWIG) -javascript $(SWIGOPT) -o $(INTERFACEDIR)$(TARGET)_wrap.c $(INTERFACEPATH)
+
+javascript_wrapper_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -javascript -c++ $(SWIGOPT) -o $(INTERFACEDIR)$(TARGET)_wrap.cxx $(INTERFACEPATH)
+
+javascript_build: $(SRCDIR_SRCS)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(ISRCS) $(SRCDIR_SRCS) $(INCLUDES) $(JSINCLUDES)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(JSDYNAMICLINKING) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+
+javascript_build_cpp: $(SRCDIR_SRCS)
+ifeq (node,$(JSENGINE))
+ sed -e 's|$$srcdir|./$(SRCDIR)|g' $(SRCDIR)binding.gyp.in > binding.gyp
+ $(NODEGYP) --loglevel=silent configure build 1>>/dev/null
+else
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) $(JSINCLUDES)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(JSDYNAMICLINKING) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+
+endif
+
+# These targets are used by the test-suite:
+
+javascript: $(SRCDIR_SRCS) javascript_custom_interpreter
+ $(SWIG) -javascript $(SWIGOPT) $(INTERFACEPATH)
+ifeq (jsc, $(ENGINE))
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(ISRCS) $(SRCDIR_SRCS) $(INCLUDES) $(JSINCLUDES)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(JSDYNAMICLINKING) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+else # (v8 | node) # v8 and node must be compiled as c++
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(ISRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) $(JSINCLUDES)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(JSDYNAMICLINKING) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+endif
+
+javascript_cpp: $(SRCDIR_SRCS) javascript_custom_interpreter
+ $(SWIG) -javascript -c++ $(SWIGOPT) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) $(JSINCLUDES)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(JSDYNAMICLINKING) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+
+# -----------------------------------------------------------------
+# Running a Javascript example
+# -----------------------------------------------------------------
+
+javascript_custom_interpreter:
+ (cd $(ROOT_DIR)/Tools/javascript && $(MAKE) JSENGINE='$(JSENGINE)')
+
+ifeq (node,$(JSENGINE))
+javascript_run:
+ env NODE_PATH=$$PWD:$(SRCDIR) $(RUNTOOL) $(NODEJS) $(SRCDIR)$(RUNME).js $(RUNPIPE)
+else
+javascript_run: javascript_custom_interpreter
+ $(RUNTOOL) $(ROOT_DIR)/Tools/javascript/javascript -$(JSENGINE) -L $(TARGET) $(SRCDIR)$(RUNME).js $(RUNPIPE)
+endif
+
+# -----------------------------------------------------------------
+# Version display
+# -----------------------------------------------------------------
+
+javascript_version:
+ifeq (, $(ENGINE))
+ @if [ "$(NODEJS)" != "" ]; then \
+ echo "Node.js: `($(NODEJS) --version)`"; \
+ echo "node-gyp: `($(NODEGYP) --version)`"; \
+ else \
+ echo "Version depends on the interpreter"; \
+ fi
+endif
+ifeq (node, $(ENGINE))
+ echo "Node.js: `($(NODEJS) --version)`"
+ echo "node-gyp: `($(NODEGYP) --version)`"
+endif
+ifeq (jsc, $(ENGINE))
+ @if [ "@JSCOREVERSION@" != "" ]; then \
+ echo "@JSCOREVERSION@"; \
+ else \
+ echo "Unknown JavascriptCore version."; \
+ fi
+endif
+ifeq (v8, $(ENGINE))
+ echo "Unknown v8 version."
+endif
+
+# -----------------------------------------------------------------
+# Cleaning the Javascript examples
+# -----------------------------------------------------------------
+
+javascript_clean:
+ rm -rf build
+ rm -f *_wrap* $(RUNME)
+ rm -f core @EXTRA_CLEAN@
+ rm -f *.@OBJEXT@ *@SO@
+ rm -f binding.gyp example-gypcopy.cxx
+ cd $(ROOT_DIR)/Tools/javascript && $(MAKE) -s clean
+
+##################################################################
##### ANDROID ######
##################################################################
-ANDROID = android
-ANDROID_NDK_BUILD = ndk-build
-ANDROID_ADB = adb
-ANT = ant
+ANDROID = @ANDROID@
+ANDROID_NDK_BUILD = @NDKBUILD@
+ANDROID_ADB = @ADB@
+ANT = @ANT@
TARGETID = 1
# ----------------------------------------------------------------
# Build an Android dynamically loadable module (C)
# ----------------------------------------------------------------
-android: $(SRCS)
+android: $(SRCDIR_SRCS)
$(ANDROID) $(SILENT_OPTION) update project --target $(TARGETID) --name $(PROJECTNAME) --path .
$(SWIG) -java $(SWIGOPT) -o $(INTERFACEDIR)$(TARGET)_wrap.c $(INTERFACEPATH)
+$(ANDROID_NDK_BUILD) $(SILENT_PIPE)
# Build an Android dynamically loadable module (C++)
# ----------------------------------------------------------------
-android_cpp: $(SRCS)
+android_cpp: $(SRCDIR_SRCS)
$(ANDROID) $(SILENT_OPTION) update project --target $(TARGETID) --name $(PROJECTNAME) --path .
$(SWIG) -java -c++ $(SWIGOPT) -o $(INTERFACEDIR)$(TARGET)_wrap.cpp $(INTERFACEPATH)
+$(ANDROID_NDK_BUILD) $(SILENT_PIPE)
# -----------------------------------------------------------------
android_clean:
- ant -q -logfile /dev/null clean
+ test -n "$(SRCDIR)" && cd $(SRCDIR) ; $(ANT) -q -logfile /dev/null clean
rm -f $(INTERFACEDIR)$(TARGET)_wrap.*
rm -f `find $(PACKAGEDIR) -name \*.java | grep -v $(PROJECTNAME).java`
rm -rf obj
# Build a modula3 dynamically loadable module (C)
# ----------------------------------------------------------------
-modula3: $(SRCS)
- $(SWIG) -modula3 $(SWIGOPT) $(INTERFACEPATH)
-# $(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) \
-# $(OBJS) $(IOBJS) $(LIBS)
+modula3: $(SRCDIR_SRCS)
+ $(SWIG) -modula3 $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
-modula3_cpp: $(SRCS)
- $(SWIG) -modula3 -c++ $(SWIGOPT) $(INTERFACEPATH)
+modula3_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -modula3 -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
# -----------------------------------------------------------------
# Run modula3 example
# Build a C/C++ dynamically loadable module
# ----------------------------------------------------------------
-mzscheme: $(SRCS)
- $(SWIG) -mzscheme $(SWIGOPT) $(INTERFACEPATH)
- $(COMPILETOOL) $(MZC) `echo $(INCLUDES) | sed 's/-I/++ccf -I/g'` --cc $(ISRCS) $(SRCS)
+mzscheme: $(SRCDIR_SRCS)
+ $(SWIG) -mzscheme $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(COMPILETOOL) $(MZC) `echo $(INCLUDES) | sed 's/-I/++ccf -I/g'` --cc $(ISRCS) $(SRCDIR_SRCS)
$(COMPILETOOL) $(MZC) --ld $(TARGET)$(MZSCHEME_SO) $(OBJS) $(IOBJS)
-mzscheme_cpp: $(SRCS)
- $(SWIG) -mzscheme -c++ $(SWIGOPT) $(INTERFACEPATH)
- $(COMPILETOOL) $(MZC) `echo $(INCLUDES) | sed 's/-I/++ccf -I/g'` --cc $(ICXXSRCS) $(SRCS) $(CXXSRCS)
- $(CXXSHARED) $(CFLAGS) -o $(LIBPREFIX)$(TARGET)$(MZSCHEME_SO) $(OBJS) $(IOBJS) $(MZDYNOBJ) $(CPP_DLLIBS)
+mzscheme_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -mzscheme -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(COMPILETOOL) $(MZC) `echo $(INCLUDES) | sed 's/-I/++ccf -I/g'` --cc $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS)
+ $(CXXSHARED) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) -o $(LIBPREFIX)$(TARGET)$(MZSCHEME_SO) $(OBJS) $(IOBJS) $(MZDYNOBJ) $(CPP_DLLIBS)
# -----------------------------------------------------------------
# Run mzscheme example
# -----------------------------------------------------------------
mzscheme_run:
- env LD_LIBRARY_PATH=. $(RUNTOOL) $(MZSCHEME) -r $(MZSCHEME_SCRIPT) $(RUNPIPE)
+ env LD_LIBRARY_PATH=$$PWD $(RUNTOOL) $(MZSCHEME) -r $(MZSCHEME_SCRIPT) $(RUNPIPE)
# -----------------------------------------------------------------
# Version display
mzscheme_clean:
rm -f *_wrap* *~ .~*
rm -f core @EXTRA_CLEAN@
- rm -f *.@OBJEXT@ *@SO@
+ rm -f *.@OBJEXT@ *$(MZSCHEME_SO)
##################################################################
##### Ocaml #####
OCAMLMKTOP=@OCAMLMKTOP@ $(SWIGWHERE)
NOLINK ?= false
OCAMLPP= -pp "camlp4o ./swigp4.cmo"
-OCAMLP4WHERE=`$(COMPILETOOL) camlp4 -where`
+OCAMLP4WHERE=`$(COMPILETOOL) @CAMLP4@ -where`
OCAMLCORE=\
rm -rf swig.mli swig.ml swigp4.ml && \
$(SWIG) -ocaml -co swig.mli 2>/dev/null && \
$(OCC) -I $(OCAMLP4WHERE) -pp "camlp4o pa_extend.cmo q_MLast.cmo" \
-c swigp4.ml
-ocaml_static: $(SRCS)
+ocaml_static: $(SRCDIR_SRCS)
$(OCAMLCORE)
- $(SWIG) -ocaml $(SWIGOPT) $(INTERFACEPATH)
- $(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCS)
+ $(SWIG) -ocaml $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCDIR_SRCS)
$(OCC) -g -c $(INTERFACE:%.i=%.mli)
$(OCC) -g -c $(INTERFACE:%.i=%.ml)
test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
$(PROGFILE:%.ml=%.cmo) \
$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) -cclib "$(LIBS)"
-ocaml_dynamic: $(SRCS)
+ocaml_dynamic: $(SRCDIR_SRCS)
$(OCAMLCORE)
- $(SWIG) -ocaml $(SWIGOPT) $(INTERFACEPATH)
- $(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCS)
- $(CXXSHARED) $(CFLAGS) $(CCSHARED) $(CFLAGS) -o $(INTERFACE:%.i=%@SO@) \
+ $(SWIG) -ocaml $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCDIR_SRCS)
+ $(CXXSHARED) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(CCSHARED) -o $(INTERFACE:%.i=%@SO@) \
$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) $(LIBS)
$(OCAMLDLGEN) $(INTERFACE:%.i=%.ml) $(INTERFACE:%.i=%@SO@) > \
$(INTERFACE:%.i=%_dynamic.ml)
-package dl -linkpkg \
$(INTERFACE:%.i=%.cmo) $(PROGFILE:%.ml=%.cmo)
-ocaml_static_toplevel: $(SRCS)
+ocaml_static_toplevel: $(SRCDIR_SRCS)
$(OCAMLCORE)
- $(SWIG) -ocaml $(SWIGOPT) $(INTERFACEPATH)
- $(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCS)
+ $(SWIG) -ocaml $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCDIR_SRCS)
$(OCC) -g -c $(INTERFACE:%.i=%.mli)
$(OCC) -g -c $(INTERFACE:%.i=%.ml)
test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
$(INTERFACE:%.i=%.cmo) \
$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) -cclib "$(LIBS)"
-ocaml_static_cpp: $(SRCS)
+ocaml_static_cpp: $(SRCDIR_SRCS)
$(OCAMLCORE)
- $(SWIG) -ocaml -c++ $(SWIGOPT) $(INTERFACEPATH)
+ $(SWIG) -ocaml -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
cp $(ICXXSRCS) $(ICXXSRCS:%.cxx=%.c)
$(OCC) -cc '$(CXX) -Wno-write-strings' -g -c -ccopt -g -ccopt "-xc++ $(INCLUDES)" \
- $(ICXXSRCS:%.cxx=%.c) $(SRCS) $(CXXSRCS)
+ $(ICXXSRCS:%.cxx=%.c) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS)
$(OCC) -g -c $(INTERFACE:%.i=%.mli)
$(OCC) -g -c $(INTERFACE:%.i=%.ml)
test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) \
-cclib "$(LIBS)" -cc '$(CXX) -Wno-write-strings'
-ocaml_static_cpp_toplevel: $(SRCS)
+ocaml_static_cpp_toplevel: $(SRCDIR_SRCS)
$(OCAMLCORE)
- $(SWIG) -ocaml -c++ $(SWIGOPT) $(INTERFACEPATH)
+ $(SWIG) -ocaml -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
cp $(ICXXSRCS) $(ICXXSRCS:%.cxx=%.c)
$(OCC) -cc '$(CXX) -Wno-write-strings' -g -c -ccopt -g -ccopt "-xc++ $(INCLUDES)" \
- $(ICXXSRCS:%.cxx=%.c) $(SRCS) $(CXXSRCS)
+ $(ICXXSRCS:%.cxx=%.c) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS)
$(OCC) -g -c $(INTERFACE:%.i=%.mli)
$(OCC) -g -c $(INTERFACE:%.i=%.ml)
test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) \
-cclib "$(LIBS)" -cc '$(CXX) -Wno-write-strings'
-ocaml_dynamic_cpp: $(SRCS)
+ocaml_dynamic_cpp: $(SRCDIR_SRCS)
$(OCAMLCORE)
- $(SWIG) -ocaml -c++ $(SWIGOPT) $(INTERFACEPATH)
+ $(SWIG) -ocaml -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
cp $(ICXXSRCS) $(ICXXSRCS:%.cxx=%.c)
$(OCC) -cc '$(CXX) -Wno-write-strings' -g -c -ccopt -g -ccopt "-xc++ $(INCLUDES)" \
- $(ICXXSRCS:%.cxx=%.c) $(SRCS) $(CXXSRCS) -ccopt -fPIC
- $(CXXSHARED) $(CFLAGS) -o $(INTERFACE:%.i=%@SO@) \
+ $(ICXXSRCS:%.cxx=%.c) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) -ccopt -fPIC
+ $(CXXSHARED) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) -o $(INTERFACE:%.i=%@SO@) \
$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) \
$(CPP_DLLIBS) $(LIBS)
$(OCAMLDLGEN) $(INTERFACE:%.i=%.ml) $(INTERFACE:%.i=%@SO@) > \
RUBY_LIBOPTS = @RUBYLINK@ @LIBS@ $(SYSLIBS)
RUBY_SO = @RUBYSO@
RUBY = @RUBY@
-RUBY_SCRIPT = $(RUNME).rb
+RUBY_SCRIPT = $(SRCDIR)$(RUNME).rb
# ----------------------------------------------------------------
# Build a C dynamically loadable module
# ----------------------------------------------------------------
-ruby: $(SRCS)
- $(SWIG) -ruby $(SWIGOPT) $(INTERFACEPATH)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(RUBY_CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(RUBY_INCLUDE)
- $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(RUBY_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(RUBY_SO)
+ruby: $(SRCDIR_SRCS)
+ $(SWIG) -ruby $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(RUBY_CFLAGS) $(ISRCS) $(SRCDIR_SRCS) $(INCLUDES) $(RUBY_INCLUDE)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(RUBY_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(RUBY_SO)
# -----------------------------------------------------------------
# Build a C++ dynamically loadable module
# -----------------------------------------------------------------
-ruby_cpp: $(SRCS)
- $(SWIG) -c++ -ruby $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(RUBY_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(RUBY_INCLUDE)
- $(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(RUBY_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(RUBY_SO)
+ruby_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -c++ -ruby $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(RUBY_CFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) $(RUBY_INCLUDE)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(RUBY_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(RUBY_SO)
# -----------------------------------------------------------------
# Build statically linked Ruby interpreter
# library file
# -----------------------------------------------------------------
-ruby_static: $(SRCS)
- $(SWIG) -ruby -lembed.i $(SWIGOPT) $(INTERFACEPATH)
- $(CC) $(CFLAGS) $(RUBY_CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCS) $(INCLUDES) \
+ruby_static: $(SRCDIR_SRCS)
+ $(SWIG) -ruby -lembed.i $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) $(RUBY_CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCDIR_SRCS) $(INCLUDES) \
$(RUBY_INCLUDE) $(LIBS) -L$(RUBY_LIB) $(RUBY_LIBOPTS) -o $(TARGET)
-ruby_cpp_static: $(SRCS)
- $(SWIG) -c++ -ruby -lembed.i $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) $(CFLAGS) $(RUBY_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
+ruby_cpp_static: $(SRCDIR_SRCS)
+ $(SWIG) -c++ -ruby -lembed.i $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(RUBY_CFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) \
$(RUBY_INCLUDE) $(LIBS) -L$(RUBY_LIB) $(RUBY_LIBOPTS) -o $(TARGET)
# -----------------------------------------------------------------
# -----------------------------------------------------------------
ruby_run:
- $(RUNTOOL) $(RUBY) -I. $(RUBY_SCRIPT) $(RUNPIPE)
+ $(RUNTOOL) $(RUBY) $(RUBYFLAGS) -I. $(RUBY_SCRIPT) $(RUNPIPE)
# -----------------------------------------------------------------
# Version display
# -----------------------------------------------------------------
ruby_clean:
- rm -f *_wrap* *~ .~* myruby@EXEEXT@ *.pm
+ rm -f *_wrap* *~ .~* myruby@EXEEXT@
rm -f core @EXTRA_CLEAN@
- rm -f *.@OBJEXT@ *@SO@
+ rm -f *.@OBJEXT@ *$(RUBY_SO)
##################################################################
##### PHP ######
PHP = @PHP@
PHP_INCLUDE = @PHPINC@
PHP_SO = @PHP_SO@
-PHP_SCRIPT = $(RUNME).php
+PHP_SCRIPT = $(SRCDIR)$(RUNME).php
# -------------------------------------------------------------------
# Build a PHP dynamically loadable module (C)
# -------------------------------------------------------------------
-php: $(SRCS)
- $(SWIG) -php $(SWIGOPT) $(INTERFACEPATH)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(PHP_INCLUDE)
- $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(PHP_SO)
+php: $(SRCDIR_SRCS)
+ $(SWIG) -php $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(SRCDIR_SRCS) $(ISRCS) $(INCLUDES) $(PHP_INCLUDE)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(PHP_SO)
# --------------------------------------------------------------------
# Build a PHP dynamically loadable module (C++)
# --------------------------------------------------------------------
-php_cpp: $(SRCS)
- $(SWIG) -php -cppext cxx -c++ $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(PHP_INCLUDE)
- $(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(PHP_SO)
+php_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -php -cppext cxx -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(PHP_INCLUDE)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(PHP_SO)
# -----------------------------------------------------------------
# Running a PHP example
php_clean:
rm -f *_wrap* *~ .~* example.php php_example.h
rm -f core @EXTRA_CLEAN@
- rm -f *.@OBJEXT@ *@SO@
+ rm -f *.@OBJEXT@ *$(PHP_SO)
##################################################################
##### Pike ######
# Build a C dynamically loadable module
# ----------------------------------------------------------------
-pike: $(SRCS)
- $(SWIG) -pike $(SWIGOPT) $(INTERFACEPATH)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(PIKE_CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(PIKE_INCLUDE)
- $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(PIKE_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+pike: $(SRCDIR_SRCS)
+ $(SWIG) -pike $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(PIKE_CFLAGS) $(ISRCS) $(SRCDIR_SRCS) $(INCLUDES) $(PIKE_INCLUDE)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(PIKE_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
# -----------------------------------------------------------------
# Build a C++ dynamically loadable module
# -----------------------------------------------------------------
-pike_cpp: $(SRCS)
- $(SWIG) -c++ -pike $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(PIKE_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(PIKE_INCLUDE)
- $(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(PIKE_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+pike_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -c++ -pike $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(PIKE_CFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) $(PIKE_INCLUDE)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(PIKE_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
# -----------------------------------------------------------------
# Build statically linked Pike interpreter
# library file
# -----------------------------------------------------------------
-pike_static: $(SRCS)
- $(SWIG) -pike -lembed.i $(SWIGOPT) $(INTERFACEPATH)
- $(CC) $(CFLAGS) $(PIKE_CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCS) $(INCLUDES) \
+pike_static: $(SRCDIR_SRCS)
+ $(SWIG) -pike -lembed.i $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) $(PIKE_CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCDIR_SRCS) $(INCLUDES) \
$(PIKE_INCLUDE) $(LIBS) -L$(PIKE_LIB) $(PIKE_LIBOPTS) -o $(TARGET)
-pike_cpp_static: $(SRCS)
- $(SWIG) -c++ -pike -lembed.i $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) $(CFLAGS) $(PIKE_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
+pike_cpp_static: $(SRCDIR_SRCS)
+ $(SWIG) -c++ -pike -lembed.i $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(PIKE_CFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) \
$(PIKE_INCLUDE) $(LIBS) -L$(PIKE_LIB) $(PIKE_LIBOPTS) -o $(TARGET)
# -----------------------------------------------------------------
CHICKEN_COMPILED_SCHEME = $(INTERFACE:.i=_chicken.c)
CHICKEN_COMPILED_OBJECT = $(CHICKEN_COMPILED_SCHEME:.c=.@OBJEXT@)
-# flags for the main chicken sources (only used when compiling staticly)
+# flags for the main chicken sources (only used when compiling statically)
CHICKEN_COMPILED_MAIN = $(CHICKEN_MAIN:.scm=_chicken.c)
CHICKEN_COMPILED_MAIN_OBJECT = $(CHICKEN_COMPILED_MAIN:.c=.@OBJEXT@)
# -----------------------------------------------------------------
# This is the old way to build chicken, but it does not work correctly with exceptions
-chicken_direct: $(SRCS)
+chicken_direct: $(SRCDIR_SRCS)
$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
-dynamic -feature chicken-compile-shared \
-output-file $(CHICKEN_COMPILED_SCHEME)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
- $(INCLUDES) $(CHICKEN_INCLUDE) $(ISRCS) $(SRCS) $(CHICKEN_COMPILED_SCHEME)
- $(LDSHARED) $(CFLAGS) $(CHICKEN_COMPILED_OBJECT) $(OBJS) $(IOBJS) \
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(CHICKEN_CFLAGS) \
+ $(INCLUDES) $(CHICKEN_INCLUDE) $(ISRCS) $(SRCDIR_SRCS) $(CHICKEN_COMPILED_SCHEME)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(CHICKEN_COMPILED_OBJECT) $(OBJS) $(IOBJS) \
$(LIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(LIBPREFIX)$(TARGET)$(SO)
-chicken_direct_cpp: $(CXXSRCS) $(CHICKSRCS)
+chicken_direct_cpp: $(SRCDIR_CXXSRCS) $(CHICKSRCS)
$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
-dynamic -feature chicken-compile-shared \
-output-file $(CHICKEN_COMPILED_SCHEME)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
- $(INCLUDES) $(CHICKEN_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(CHICKEN_COMPILED_SCHEME)
- $(CXXSHARED) $(CFLAGS) $(CHICKEN_COMPILED_OBJECT) $(OBJS) $(IOBJS) \
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(CHICKEN_CFLAGS) \
+ $(INCLUDES) $(CHICKEN_INCLUDE) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(CHICKEN_COMPILED_SCHEME)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(CHICKEN_COMPILED_OBJECT) $(OBJS) $(IOBJS) \
$(LIBS) $(CPP_DLLIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(LIBPREFIX)$(TARGET)$(SO)
# -----------------------------------------------------------------
# -----------------------------------------------------------------
# The following two targets are also used by the test suite
-chicken_static: $(SRCS) $(CHICKSRCS)
+chicken_static: $(SRCDIR_SRCS) $(CHICKSRCS)
$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
-output-file $(CHICKEN_COMPILED_SCHEME)
$(CHICKEN) $(CHICKEN_MAIN) $(CHICKENOPTS) \
-output-file $(CHICKEN_MAIN:.scm=_chicken.c)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
- $(INCLUDES) $(CHICKEN_INCLUDE) $(ISRCS) $(SRCS) \
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(CHICKEN_CFLAGS) \
+ $(INCLUDES) $(CHICKEN_INCLUDE) $(ISRCS) $(SRCDIR_SRCS) \
$(CHICKEN_COMPILED_SCHEME) $(CHICKEN_COMPILED_MAIN)
- $(CC) $(CHICKEN_COMPILED_OBJECT) $(CHICKEN_COMPILED_MAIN_OBJECT) \
+ $(CC) $(CFLAGS) $(LDFLAGS) $(CHICKEN_COMPILED_OBJECT) $(CHICKEN_COMPILED_MAIN_OBJECT) \
$(OBJS) $(IOBJS) $(LIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(TARGET)
-chicken_static_cpp: $(CXXSRCS) $(CHICKSRCS)
+chicken_static_cpp: $(SRCDIR_CXXSRCS) $(CHICKSRCS)
$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
-output-file $(CHICKEN_COMPILED_SCHEME)
$(CHICKEN) $(CHICKEN_MAIN) $(CHICKENOPTS) \
-output-file $(CHICKEN_MAIN:.scm=_chicken.c)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
- $(INCLUDES) $(CHICKEN_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS) \
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(CHICKEN_CFLAGS) \
+ $(INCLUDES) $(CHICKEN_INCLUDE) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) \
$(CHICKEN_COMPILED_SCHEME) $(CHICKEN_COMPILED_MAIN)
- $(CXX) $(CHICKEN_COMPILED_OBJECT) $(CHICKEN_COMPILED_MAIN_OBJECT) \
+ $(CXX) $(CXXFLAGS) $(LDFLAGS) $(CHICKEN_COMPILED_OBJECT) $(CHICKEN_COMPILED_MAIN_OBJECT) \
$(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(TARGET)
# ----------------------------------------------------------------
chicken:
$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
- $(COMPILETOOL) $(CHICKEN_CSC) -s `echo $(INCLUDES) | sed 's/-I/-C -I/g'` $(CHICKEN_GENERATED_SCHEME) $(SRCS) $(ISRCS) -o $(TARGET)$(SO)
+ $(COMPILETOOL) $(CHICKEN_CSC) -s `echo $(INCLUDES) | sed 's/-I/-C -I/g'` $(CHICKEN_GENERATED_SCHEME) $(SRCDIR_SRCS) $(ISRCS) -o $(TARGET)$(SO)
chicken_cpp:
$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
- $(COMPILETOOL) $(CHICKEN_CSC) -s `echo $(INCLUDES) | sed 's/-I/-C -I/g'` $(CHICKEN_GENERATED_SCHEME) $(SRCS) $(ICXXSRCS) $(CXXSRCS) -o $(TARGET)$(SO)
+ $(COMPILETOOL) $(CHICKEN_CSC) -s `echo $(INCLUDES) | sed 's/-I/-C -I/g'` $(CHICKEN_GENERATED_SCHEME) $(SRCDIR_SRCS) $(ICXXSRCS) $(SRCDIR_CXXSRCS) -o $(TARGET)$(SO)
chicken_externalhdr:
$(SWIG) -chicken -external-runtime $(TARGET)
# -----------------------------------------------------------------
chicken_run:
- env LD_LIBRARY_PATH=. $(RUNTOOL) $(CHICKEN_CSI) $(CHICKEN_SCRIPT) $(RUNPIPE)
+ env LD_LIBRARY_PATH=$$PWD $(RUNTOOL) $(CHICKEN_CSI) $(CHICKEN_SCRIPT) $(RUNPIPE)
# -----------------------------------------------------------------
# Version display
CSHARP_LIBPREFIX = @CSHARPLIBRARYPREFIX@
CSHARPCOMPILER = @CSHARPCOMPILER@
CSHARPCILINTERPRETER = @CSHARPCILINTERPRETER@
+CSHARPCILINTERPRETER_FLAGS = @CSHARPCILINTERPRETER_FLAGS@
CSHARPCFLAGS = @CSHARPCFLAGS@
+CSHARPFLAGS =
+CSHARPOPTIONS =
CSHARPSO = @CSHARPSO@
-CSHARP_RUNME = ./$(RUNME).exe
+CSHARP_RUNME = $(CSHARPCILINTERPRETER) $(CSHARPCILINTERPRETER_FLAGS) ./$(RUNME).exe
# ----------------------------------------------------------------
# Build a CSharp dynamically loadable module (C)
# ----------------------------------------------------------------
-csharp: $(SRCS)
- $(SWIG) -csharp $(SWIGOPT) $(INTERFACEPATH)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(CSHARPCFLAGS) $(SRCS) $(ISRCS) $(INCLUDES)
- $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(CSHARP_DLNK) $(LIBS) -o $(CSHARP_LIBPREFIX)$(TARGET)$(CSHARPSO)
+csharp: $(SRCDIR_SRCS)
+ $(SWIG) -csharp $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(CSHARPCFLAGS) $(SRCDIR_SRCS) $(ISRCS) $(INCLUDES)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(CSHARP_DLNK) $(LIBS) -o $(CSHARP_LIBPREFIX)$(TARGET)$(CSHARPSO)
# ----------------------------------------------------------------
# Build a CSharp dynamically loadable module (C++)
# ----------------------------------------------------------------
-csharp_cpp: $(SRCS)
- $(SWIG) -csharp -c++ $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(CSHARPCFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES)
- $(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(CSHARP_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(CSHARP_LIBPREFIX)$(TARGET)$(CSHARPSO)
+csharp_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -csharp -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(CSHARPCFLAGS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(ICXXSRCS) $(INCLUDES)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(CSHARP_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(CSHARP_LIBPREFIX)$(TARGET)$(CSHARPSO)
# ----------------------------------------------------------------
# Compile CSharp files
# ----------------------------------------------------------------
-csharp_compile: $(SRCS)
- $(COMPILETOOL) $(CSHARPCOMPILER) $(CSHARPFLAGS) $(CSHARPSRCS)
+ifneq (,$(SRCDIR))
+SRCDIR_CSHARPSRCS = $(addprefix $(SRCDIR),$(CSHARPSRCS))
+else
+SRCDIR_CSHARPSRCS =
+endif
+
+csharp_compile: $(SRCDIR_SRCS)
+ $(COMPILETOOL) $(CSHARPCOMPILER) $(CSHARPFLAGS) $(CSHARPOPTIONS) $(CSHARPSRCS) $(SRCDIR_CSHARPSRCS)
# -----------------------------------------------------------------
# Run CSharp example
# -----------------------------------------------------------------
csharp_run:
- env LD_LIBRARY_PATH=. $(RUNTOOL) $(CSHARP_RUNME) $(RUNPIPE)
+ env LD_LIBRARY_PATH=$$PWD $(RUNTOOL) $(CSHARP_RUNME) $(RUNPIPE)
# -----------------------------------------------------------------
# Version display
# Version check below also works with MS csc.exe which does not understand --version
csharp_version:
$(CSHARPCOMPILER) --version | head -n 1
+ if test -n "$(CSHARPCILINTERPRETER)" ; then "$(CSHARPCILINTERPRETER)" --version ; fi
# -----------------------------------------------------------------
# Cleaning the CSharp examples
# -----------------------------------------------------------------
csharp_clean:
- rm -f *_wrap* *~ .~* runme runme.exe *.exe.mdb gc.log `find . -name \*.cs | grep -v runme.cs`
+ rm -f *_wrap* *~ .~* $(RUNME) $(RUNME).exe *.exe.mdb gc.log `find . -name \*.cs | grep -v $(RUNME).cs`
rm -f core @EXTRA_CLEAN@
rm -f *.@OBJEXT@ *@CSHARPSO@
LUA_SO = @LUA_SO@
LUA = @LUABIN@
-LUA_SCRIPT = $(RUNME).lua
+LUA_SCRIPT = $(SRCDIR)$(RUNME).lua
# Extra code for lua static link
LUA_INTERP = ../lua.c
# Build a C dynamically loadable module
# ----------------------------------------------------------------
-lua: $(SRCS)
- $(SWIG) -lua $(SWIGOPT) $(INTERFACEPATH)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(LUA_INCLUDE)
- $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(LUA_LIB) -o $(LIBPREFIX)$(TARGET)$(LUA_SO)
+lua: $(SRCDIR_SRCS)
+ $(SWIG) -lua $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(ISRCS) $(SRCDIR_SRCS) $(INCLUDES) $(LUA_INCLUDE)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(LUA_LIB) -o $(LIBPREFIX)$(TARGET)$(LUA_SO)
# -----------------------------------------------------------------
# Build a C++ dynamically loadable module
# -----------------------------------------------------------------
-lua_cpp: $(SRCS)
- $(SWIG) -c++ -lua $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(LUA_INCLUDE)
- $(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(LUA_LIB) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(LUA_SO)
+lua_cpp: $(SRCDIR_SRCS) $(GENCXXSRCS)
+ $(SWIG) -c++ -lua $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(GENCXXSRCS) $(INCLUDES) $(LUA_INCLUDE)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(LUA_LIB) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(LUA_SO)
+
+lua_externalhdr:
+ $(SWIG) -lua -external-runtime $(TARGET)
+
+lua_swig_cpp:
+ $(SWIG) -c++ -lua $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
# -----------------------------------------------------------------
# Build statically linked Lua interpreter
# -----------------------------------------------------------------
-lua_static: $(SRCS)
- $(SWIG) -lua -module example $(SWIGOPT) $(INTERFACEPATH)
- $(CC) $(CFLAGS) $(ISRCS) $(SRCS) $(LUA_INTERP) $(INCLUDES) \
+lua_static: $(SRCDIR_SRCS)
+ $(SWIG) -lua -module example $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) $(ISRCS) $(SRCDIR_SRCS) $(SRCDIR)$(LUA_INTERP) $(INCLUDES) \
$(LUA_INCLUDE) $(LIBS) $(LUA_LIB) -o $(TARGET)
-lua_static_cpp: $(SRCS)
- $(SWIG) -c++ -lua -module example $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(LUA_INTERP) $(INCLUDES) \
+lua_static_cpp: $(SRCDIR_SRCS) $(GENCXXSRCS)
+ $(SWIG) -c++ -lua -module example $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(GENCXXSRCS) $(SRCDIR)$(LUA_INTERP) $(INCLUDES) \
$(LUA_INCLUDE) $(LIBS) $(LUA_LIB) -o $(TARGET)
# -----------------------------------------------------------------
$(RUNTOOL) $(LUA) $(LUA_SCRIPT) $(RUNPIPE)
lua_embed_run:
- $(RUNTOOL) ./$(TARGET) $(RUNPIPE)
+ $(RUNTOOL) ./$(TARGET) $(LUA_SCRIPT) $(RUNPIPE)
# -----------------------------------------------------------------
# Version display
lua_clean:
rm -f *_wrap* *~ .~* mylua@EXEEXT@
rm -f core @EXTRA_CLEAN@
- rm -f *.@OBJEXT@ *@SO@
+ rm -f *.@OBJEXT@ *$(LUA_SO)
##################################################################
##### ALLEGRO CL ######
ALLEGROCL = @ALLEGROCLBIN@
ALLEGROCL_SCRIPT=$(RUNME).lisp
-allegrocl: $(SRCS)
- $(SWIG) -allegrocl -cwrap $(SWIGOPT) $(INTERFACEPATH)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCS)
- $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+allegrocl: $(SRCDIR_SRCS)
+ $(SWIG) -allegrocl -cwrap $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCDIR_SRCS)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
-allegrocl_cpp: $(SRCS)
- $(SWIG) -c++ -allegrocl $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES)
- $(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+allegrocl_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -c++ -allegrocl $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
# -----------------------------------------------------------------
# Run ALLEGRO CL example
CLISP = @CLISPBIN@
CLISP_SCRIPT=$(RUNME).lisp
-clisp: $(SRCS)
- $(SWIG) -clisp $(SWIGOPT) $(INTERFACEPATH)
+clisp: $(SRCDIR_SRCS)
+ $(SWIG) -clisp $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
-clisp_cpp: $(SRCS)
- $(SWIG) -c++ -clisp $(SWIGOPT) $(INTERFACEPATH)
+clisp_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -c++ -clisp $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
# -----------------------------------------------------------------
# Run CLISP example
CFFI = @CFFIBIN@
CFFI_SCRIPT=$(RUNME).lisp
-cffi: $(SRCS)
- $(SWIG) -cffi $(SWIGOPT) $(INTERFACEPATH)
-# $(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCS)
-# $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+cffi: $(SRCDIR_SRCS)
+ $(SWIG) -cffi $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+# $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCDIR_SRCS)
+# $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
-cffi_cpp: $(SRCS)
- $(SWIG) -c++ -cffi $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES)
- $(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+cffi_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -c++ -cffi $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
# -----------------------------------------------------------------
# Run CFFI example
UFFI = @UFFIBIN@
UFFI_SCRIPT=$(RUNME).lisp
-uffi: $(SRCS)
- $(SWIG) -uffi $(SWIGOPT) $(INTERFACEPATH)
-# $(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCS)
-# $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+uffi: $(SRCDIR_SRCS)
+ $(SWIG) -uffi $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+# $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCDIR_SRCS)
+# $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
-uffi_cpp: $(SRCS)
- $(SWIG) -c++ -uffi $(SWIGOPT) $(INTERFACEPATH)
-# $(CXX) -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES)
-# $(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
+uffi_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -c++ -uffi $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+# $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES)
+# $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
# -----------------------------------------------------------------
# Run UFFI example
RCXXSRCS = $(INTERFACE:.i=_wrap.cpp) #Need to use _wrap.cpp for R build system as it does not understand _wrap.cxx
RRSRC = $(INTERFACE:.i=.R)
R_CFLAGS=-fPIC
-R_SCRIPT=$(RUNME).R
+R_OPT = --slave --quiet --no-save --no-restore
+R_SCRIPT=$(SRCDIR)$(RUNME).R
# need to compile .cxx files outside of R build system to make sure that
# we get -fPIC
# Build a R dynamically loadable module (C)
# ----------------------------------------------------------------
-r: $(SRCS)
- $(SWIG) -r $(SWIGOPT) $(INTERFACEPATH)
-ifneq ($(SRCS),)
- $(CC) -g -c $(CFLAGS) $(R_CFLAGS) $(SRCS) $(INCLUDES)
+r: $(SRCDIR_SRCS)
+ $(SWIG) -r $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ifneq ($(SRCDIR_SRCS),)
+ $(CC) -g -c $(CPPFLAGS) $(CFLAGS) $(R_CFLAGS) $(SRCDIR_SRCS) $(INCLUDES)
endif
- +( PKG_CPPFLAGS="$(INCLUDES)" $(COMPILETOOL) $(R) CMD SHLIB -o $(LIBPREFIX)$(TARGET)$(SO) $(ISRCS) $(OBJS) > /dev/null )
+ +( PKG_CPPFLAGS="$(CPPFLAGS) $(INCLUDES)" $(COMPILETOOL) $(R) CMD SHLIB -o $(LIBPREFIX)$(TARGET)$(SO) $(ISRCS) $(OBJS) > /dev/null )
# ----------------------------------------------------------------
# Build a R dynamically loadable module (C++)
# ----------------------------------------------------------------
-
-r_cpp: $(CXXSRCS)
+r_cpp: $(SRCDIR_CXXSRCS)
$(SWIG) -c++ -r $(SWIGOPT) -o $(RCXXSRCS) $(INTERFACEPATH)
-ifneq ($(CXXSRCS),)
- $(CXX) -g -c $(CFLAGS) $(R_CFLAGS) $(CXXSRCS) $(INCLUDES)
+ifneq ($(SRCDIR_CXXSRCS),)
+ $(CXX) -g -c $(CPPFLAGS) $(CXXFLAGS) $(R_CFLAGS) $(SRCDIR_CXXSRCS) $(INCLUDES)
endif
- +( PKG_CPPFLAGS="$(INCLUDES)" $(COMPILETOOL) $(R) CMD SHLIB -o $(LIBPREFIX)$(TARGET)$(SO) $(RCXXSRCS) $(OBJS) > /dev/null )
+ +( PKG_CPPFLAGS="$(CPPFLAGS) $(INCLUDES)" $(COMPILETOOL) $(R) CMD SHLIB -o $(LIBPREFIX)$(TARGET)$(SO) $(RCXXSRCS) $(OBJS) > /dev/null )
# -----------------------------------------------------------------
# Run R example
# -----------------------------------------------------------------
r_run:
- $(RUNTOOL) $(R) CMD BATCH $(R_SCRIPT) $(RUNPIPE)
+ $(RUNTOOL) $(R) $(R_OPT) -f $(R_SCRIPT) $(RUNPIPE)
# -----------------------------------------------------------------
# Version display
rm -f $(RRSRC) $(RUNME).Rout .RData
##################################################################
+##### SCILAB ######
+##################################################################
+
+SCILAB = @SCILAB@
+SCILAB_INC= @SCILABINCLUDE@
+SCILAB_OPT = @SCILABOPT@
+SCILAB_LIBPREFIX = lib
+
+# ----------------------------------------------------------------
+# Build a C dynamically loadable module
+# ----------------------------------------------------------------
+
+scilab:
+ $(SWIG) -scilab $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -g -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(SCILAB_INC) $(INCLUDES) $(ISRCS) $(SRCDIR_SRCS) $(SRCDIR_CSRCS)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(IOBJS) $(OBJS) $(LIBS) -o $(SCILAB_LIBPREFIX)$(TARGET)$(SO)
+
+# ----------------------------------------------------------------
+# Build a C++ dynamically loadable module
+# ----------------------------------------------------------------
+
+scilab_cpp:
+ $(SWIG) -c++ -scilab $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -g -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(SCILAB_INC) $(INCLUDES) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(IOBJS) $(OBJS) $(LIBS) $(CPP_DLLIBS) -o $(SCILAB_LIBPREFIX)$(TARGET)$(SO)
+
+# -----------------------------------------------------------------
+# Running a Scilab example
+# -----------------------------------------------------------------
+
+scilab_run:
+ env LD_LIBRARY_PATH=$$PWD $(RUNTOOL) $(SCILAB) $(SCILAB_OPT) -f $(SRCDIR)$(RUNME).sci $(RUNPIPE)
+
+# -----------------------------------------------------------------
+# Scilab version
+# -----------------------------------------------------------------
+
+scilab_version:
+ echo `$(SCILAB) -version | head -1`
+
+# -----------------------------------------------------------------
+# Cleaning the scilab examples
+# -----------------------------------------------------------------
+
+scilab_clean:
+ rm -f *_wrap* *~ .~*
+ rm -f core @EXTRA_CLEAN@
+ rm -f *.@OBJEXT@ *@SO@
+ rm -f *.sce
+
+##################################################################
##### Go ######
##################################################################
+# TODO: The Go make targets need simplifying to use configure time
+# configuration or to use Make's ifeq rather than using lots of
+# runtime shell code. The output will then be a lot less verbose.
+
GO = @GO@
GOGCC = @GOGCC@
+GCCGO = @GCCGO@
GO1 = @GO1@
+GO12 = @GO12@
+GO13 = @GO13@
+GO15 = @GO15@
GOC = @GOC@
GOOPT = @GOOPT@
+GCCGOOPT = @GCCGOOPT@
GOVERSIONOPTION = @GOVERSIONOPTION@
GOSWIGARG = `if $(GOGCC) ; then echo -gccgo; fi`
-GOCOMPILEARG = `if $(GOGCC) ; then echo -c -g; elif $(GO1) ; then echo tool $(GOC:c=g) ; fi`
+GOCOMPILEARG = `if $(GO15); then echo tool compile; elif $(GO1) ; then echo tool $(GOC:c=g) ; fi` `if $(GO13) || $(GO15); then echo -pack ; fi`
GOSRCS = $(INTERFACE:.i=.go)
GOCSRCS = $(INTERFACE:.i=_gc.c)
-GOLD = $(GOC:c=l)
+GOLD = `if $(GO15); then echo link; else echo $(GOC:c=l); fi`
GOTOOL = `if $(GO1) ; then echo go tool; fi`
GOPACK = `if $(GO1) ; then echo go tool pack; else echo gopack; fi`
-GOPACKAGE = $(INTERFACE:.i=.a)
+GOPACKAGE = $(notdir $(INTERFACE:.i=.a))
-GOOBJEXT = $(GOC:c=)
+GOPATHDIR = gopath/src/$(INTERFACE:.i=)
+
+GOOBJEXT = `if $(GO15); then echo o; else echo $(GOC:c=); fi`
GOGCOBJS = $(GOSRCS:.go=.$(GOOBJEXT))
GOGCCOBJS = $(GOSRCS:.go=.@OBJEXT@)
# ----------------------------------------------------------------
-# Build a Go dynamically loadable module (C)
+# Build a Go module (C)
# ----------------------------------------------------------------
-go: $(SRCS)
- $(SWIG) -go $(GOOPT) $(GOSWIGARG) $(SWIGOPT) $(INTERFACEPATH)
- $(CC) -g -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES)
- $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
- $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(GOSRCS)
- if ! $(GOGCC) ; then \
- $(COMPILETOOL) $(GOTOOL) $(GOC) -I $${GOROOT}/pkg/$${GOOS}_$${GOARCH} $(GOCSRCS) && \
- $(COMPILETOOL) $(GOPACK) grc $(GOPACKAGE) $(GOGCOBJS) $(GOCSRCS:.c=.$(GOOBJEXT)); \
+go_nocgo: $(SRCDIR_SRCS)
+ $(SWIG) -go $(GOOPT) $(GOSWIGARG) $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ if $(GO12) || $(GO13) || $(GO15) || $(GOGCC); then \
+ $(CC) -g -c $(CPPFLAGS) $(CFLAGS) $(SRCDIR_SRCS) $(ISRCS) $(INCLUDES); \
+ else \
+ $(CC) -g -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(SRCDIR_SRCS) $(ISRCS) $(INCLUDES); \
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO); \
+ fi
+ if $(GOGCC) ; then \
+ $(COMPILETOOL) $(GCCGO) -g -c -I . $(GOSRCS); \
+ else \
+ $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(GOSRCS); \
+ $(COMPILETOOL) $(GOTOOL) $(GOC) -I $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`} $(GOCSRCS); \
+ rm -f $(GOPACKAGE); \
+ if $(GO13) || $(GO15); then \
+ cp $(GOGCOBJS) $(GOPACKAGE); \
+ $(COMPILETOOL) $(GOPACK) r $(GOPACKAGE) $(GOCSRCS:.c=.$(GOOBJEXT)) $(OBJS) $(IOBJS); \
+ elif $(GO12); then \
+ $(COMPILETOOL) $(GOPACK) grc $(GOPACKAGE) $(GOGCOBJS) $(GOCSRCS:.c=.$(GOOBJEXT)) $(OBJS) $(IOBJS); \
+ else \
+ $(COMPILETOOL) $(GOPACK) grc $(GOPACKAGE) $(GOGCOBJS) $(GOCSRCS:.c=.$(GOOBJEXT)); \
+ fi; \
+ fi
+ if test -f $(SRCDIR)$(RUNME).go; then \
+ if $(GOGCC) ; then \
+ $(COMPILETOOL) $(GCCGO) -g -c $(SRCDIR)$(RUNME).go; \
+ $(COMPILETOOL) $(GCCGO) -o $(RUNME) $(RUNME).@OBJEXT@ $(GOGCCOBJS) $(OBJS) $(IOBJS); \
+ elif $(GO12) || $(GO13) || $(GO15); then \
+ $(GO) $(GOCOMPILEARG) $(SRCDIR)$(RUNME).go; \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -linkmode external -extld "$(CC)" -extldflags "$(CFLAGS) $(LDFLAGS)" -o $(RUNME) $(RUNME).$(GOOBJEXT); \
+ else \
+ $(GO) $(GOCOMPILEARG) $(SRCDIR)$(RUNME).go; \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -r $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`}:. -o $(RUNME) $(RUNME).$(GOOBJEXT); \
+ fi; \
+ fi
+
+go: $(SRCDIR_SRCS)
+ $(SWIG) -go -cgo $(GOOPT) $(GOSWIGARG) $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ @mkdir gopath 2>/dev/null || true
+ @mkdir gopath/src 2>/dev/null || true
+ @mkdir gopath/src/$(INTERFACE:.i=) 2>/dev/null || true
+ rm -f $(GOPATHDIR)/*
+ cp $(ISRCS) $(GOPATHDIR)/
+ if test -f $(IWRAP:.i=.h); then \
+ cp $(IWRAP:.i=.h) $(GOPATHDIR)/; \
+ fi
+ if test -n "$(SRCDIR_SRCS)"; then \
+ cp $(SRCDIR_SRCS) $(GOPATHDIR)/; \
+ fi
+ cp $(GOSRCS) $(GOPATHDIR)/
+ GOPATH=`pwd`/gopath; \
+ export GOPATH; \
+ CGO_CPPFLAGS="$(CPPFLAGS) $(INCLUDES) -I `cd $(SRCDIR) && pwd` -I `pwd`"; \
+ export CGO_CPPFLAGS; \
+ CGO_CFLAGS="$(CFLAGS)"; \
+ export CGO_CFLAGS; \
+ CGO_LDFLAGS="$(LDFLAGS) -lm"; \
+ export CGO_LDFLAGS; \
+ (cd $(GOPATHDIR)/ && $(COMPILETOOL) $(GO) build `if $(GOGCC); then echo -compiler=gccgo; fi` -o $(GOPACKAGE))
+ cp $(GOPATHDIR)/$(GOPACKAGE) $(dir $(INTERFACE))/$(GOPACKAGE)
+ if $(GOGCC); then \
+ cp $(dir $(INTERFACE))/$(GOPACKAGE) $(dir $(INTERFACE))/$(GOPACKAGE:.a=.gox); \
+ fi
+ if test -f $(SRCDIR)$(RUNME).go; then \
+ if $(GOGCC) ; then \
+ $(COMPILETOOL) $(GCCGO) -c -g $(SRCDIR)$(RUNME).go; \
+ $(COMPILETOOL) $(GCCGO) -o $(RUNME) $(RUNME).@OBJEXT@ $(dir $(INTERFACE))/$(GOPACKAGE); \
+ elif $(GO12) || $(GO13) || $(GO15); then \
+ $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -o $(RUNME).$(GOOBJEXT) $(SRCDIR)$(RUNME).go; \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -linkmode external -extld "$(CC)" -extldflags "$(CFLAGS) $(LDFLAGS)" -o $(RUNME) $(RUNME).$(GOOBJEXT); \
+ else \
+ $(COMPILETOOL) $(GO) $(GOCOMPILEARG) $(SRCDIR)$(RUNME).go; \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -r $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`}:. -o $(RUNME) $(RUNME).$(GOOBJEXT); \
+ fi; \
fi
# ----------------------------------------------------------------
-# Build a Go dynamically loadable module (C++)
+# Build a Go module (C++)
# ----------------------------------------------------------------
-go_cpp: $(SRCS)
- $(SWIG) -go -c++ $(GOOPT) $(GOSWIGARG) $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -g -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES)
- $(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
- $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(GOSRCS)
+go_cpp_nocgo: $(SRCDIR_SRCS)
+ $(SWIG) -go -c++ $(GOOPT) $(GOSWIGARG) $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ if $(GO12) || $(GO13) || $(GO15) || $(GOGCC); then \
+ if test -n "$(SRCDIR_CXXSRCS)$(SRCDIR_SRCS)"; then \
+ $(CXX) -g -c $(CPPFLAGS) $(CXXFLAGS) $(SRCDIR_CXXSRCS) $(SRCDIR_SRCS) $(INCLUDES); \
+ fi; \
+ $(foreach f,$(ICXXSRCS), \
+ $(CXX) -g -c $(CPPFLAGS) $(CXXFLAGS) -o $(addsuffix .@OBJEXT@,$(basename $f)) $f $(INCLUDES); \
+ ) \
+ else \
+ $(CXX) -g -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(ICXXSRCS) $(INCLUDES); \
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO); \
+ fi
if ! $(GOGCC) ; then \
- $(COMPILETOOL) $(GOTOOL) $(GOC) -I $${GOROOT}/pkg/$${GOOS}_$${GOARCH} $(GOCSRCS) && \
- $(COMPILETOOL) $(GOPACK) grc $(GOPACKAGE) $(GOGCOBJS) $(GOCSRCS:.c=.$(GOOBJEXT)); \
+ $(foreach f,$(GOSRCS), \
+ $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . -o $(addsuffix .$(GOOBJEXT),$(basename $f)) $f \
+ ); \
+ $(foreach f,$(GOCSRCS), \
+ $(COMPILETOOL) $(GOTOOL) $(GOC) -I $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`} \
+ -o $(addsuffix .$(GOOBJEXT),$(basename $f)) $f; \
+ ) \
+ rm -f $(GOPACKAGE); \
+ if $(GO13) || $(GO15); then \
+ cp $(GOGCOBJS) $(GOPACKAGE); \
+ $(COMPILETOOL) $(GOPACK) r $(GOPACKAGE) $(GOCSRCS:.c=.$(GOOBJEXT)) $(OBJS) $(IOBJS); \
+ elif $(GO12); then \
+ $(COMPILETOOL) $(GOPACK) grc $(GOPACKAGE) $(GOGCOBJS) $(GOCSRCS:.c=.$(GOOBJEXT)) $(OBJS) $(IOBJS); \
+ else \
+ $(COMPILETOOL) $(GOPACK) grc $(GOPACKAGE) $(GOGCOBJS) $(GOCSRCS:.c=.$(GOOBJEXT)); \
+ fi; \
+ else \
+ $(foreach f,$(GOSRCS), \
+ $(COMPILETOOL) $(GCCGO) -g -c -I . -o $(addsuffix .@OBJEXT@,$(basename $f)) $f \
+ ); \
+ fi
+ if test -f $(SRCDIR)$(RUNME).go; then \
+ if $(GOGCC) ; then \
+ $(COMPILETOOL) $(GCCGO) -g -c $(SRCDIR)$(RUNME).go; \
+ $(COMPILETOOL) $(GCCGO) -o $(RUNME) $(RUNME).@OBJEXT@ $(GOGCCOBJS) $(OBJS) $(IOBJS) -lstdc++; \
+ elif $(GO12) || $(GO13) || $(GO15); then \
+ $(GO) $(GOCOMPILEARG) $(SRCDIR)$(RUNME).go; \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -linkmode external -extld "$(CXX)" -extldflags "$(CXXFLAGS) $(LDFLAGS)" -o $(RUNME) $(RUNME).$(GOOBJEXT); \
+ else \
+ $(GO) $(GOCOMPILEARG) $(SRCDIR)$(RUNME).go; \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -r $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`}:. -o $(RUNME) $(RUNME).$(GOOBJEXT); \
+ fi; \
+ fi
+
+go_cpp: $(SRCDIR_SRCS)
+ $(SWIG) -go -c++ -cgo $(GOOPT) $(GOSWIGARG) $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ @mkdir gopath 2>/dev/null || true
+ @mkdir gopath/src 2>/dev/null || true
+ @mkdir gopath/src/$(INTERFACE:.i=) 2>/dev/null || true
+ rm -f $(GOPATHDIR)/*
+ cp $(ICXXSRCS) $(GOPATHDIR)/
+ if test -f $(IWRAP:.i=.h); then \
+ cp $(IWRAP:.i=.h) $(GOPATHDIR)/; \
+ fi
+ if test -n "$(SRCDIR_CXXSRCS)"; then \
+ cp $(SRCDIR_CXXSRCS) $(GOPATHDIR)/; \
+ fi
+ if test -n "$(SRCDIR_SRCS)"; then \
+ cp $(SRCDIR_SRCS) $(GOPATHDIR)/; \
+ fi
+ cp $(GOSRCS) $(GOPATHDIR)/
+ GOPATH=`pwd`/gopath; \
+ export GOPATH; \
+ CGO_CPPFLAGS="$(CPPFLAGS) $(INCLUDES) -I `cd $(SRCDIR) && pwd` -I `pwd`"; \
+ export CGO_CPPFLAGS; \
+ CGO_CFLAGS="$(CFLAGS)"; \
+ export CGO_CFLAGS; \
+ CGO_CXXFLAGS="$(CXXFLAGS)"; \
+ export CGO_CXXFLAGS; \
+ CGO_LDFLAGS="$(LDFLAGS) -lm"; \
+ export CGO_LDFLAGS; \
+ (cd $(GOPATHDIR) && $(COMPILETOOL) $(GO) build `if $(GOGCC); then echo -compiler=gccgo; fi` -o $(GOPACKAGE))
+ cp $(GOPATHDIR)/$(GOPACKAGE) $(dir $(INTERFACE))/$(GOPACKAGE)
+ if $(GOGCC); then \
+ cp $(dir $(INTERFACE))/$(GOPACKAGE) $(dir $(INTERFACE))/$(GOPACKAGE:.a=.gox); \
+ fi
+ if test -f $(SRCDIR)$(RUNME).go; then \
+ if $(GOGCC) ; then \
+ $(COMPILETOOL) $(GCCGO) -g -c $(SRCDIR)$(RUNME).go; \
+ $(COMPILETOOL) $(GCCGO) -o $(RUNME) $(RUNME).@OBJEXT@ $(dir $(INTERFACE))/$(GOPACKAGE) -lstdc++; \
+ elif $(GO12) || $(GO13) || $(GO15); then \
+ $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -o $(RUNME).$(GOOBJEXT) $(SRCDIR)$(RUNME).go; \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -linkmode external -extld "$(CXX)" -extldflags "$(CXXFLAGS) $(LDFLAGS)" -o $(RUNME) $(RUNME).$(GOOBJEXT); \
+ else \
+ $(COMPILETOOL) $(GO) $(GOCOMPILEARG) $(SRCDIR)$(RUNME).go; \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -r $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`}:. -o $(RUNME) $(RUNME).$(GOOBJEXT); \
+ fi; \
fi
# -----------------------------------------------------------------
-# Running a Go example
+# Running Go example
# -----------------------------------------------------------------
-go_run: runme.go
- $(GO) $(GOCOMPILEARG) runme.go
- if $(GOGCC) ; then \
- $(COMPILETOOL) $(GO) -o runme runme.@OBJEXT@ $(GOGCCOBJS) $(LIBPREFIX)$(TARGET)$(SO); \
- else \
- $(COMPILETOOL) $(GOTOOL) $(GOLD) -r $${GOROOT}/pkg/$${GOOS}_$${GOARCH}:. -o runme runme.$(GOOBJEXT); \
- fi
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) ./runme $(RUNPIPE)
+go_run:
+ env $(RUNTOOL) ./$(RUNME) $(RUNPIPE)
# -----------------------------------------------------------------
# Version display
# -----------------------------------------------------------------
go_clean:
- rm -f *_wrap* *_gc* .~* runme $(GOSRCS)
+ rm -f *_wrap* *_gc* *.gox .~* $(RUNME) $(GOSRCS)
+ rm -rf gopath
rm -f core @EXTRA_CLEAN@
rm -f *.@OBJEXT@ *.[568] *.a *@SO@
# Build a dynamically loadable D wrapper for a C module
# ----------------------------------------------------------------
-d: $(SRCS)
- $(SWIGD) $(SWIGOPT) $(INTERFACEPATH)
- $(CC) -c $(CCSHARED) $(CFLAGS) $(DCFLAGS) $(EXTRA_CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES)
- $(LDSHARED) $(CFLAGS) $(DCFLAGS) $(EXTRA_LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(DLIBPREFIX)$(TARGET)$(SO)
+d: $(SRCDIR_SRCS)
+ $(SWIGD) $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH)
+ $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(DCFLAGS) $(EXTRA_CFLAGS) $(SRCDIR_SRCS) $(ISRCS) $(INCLUDES)
+ $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(DCFLAGS) $(EXTRA_LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(DLIBPREFIX)$(TARGET)$(SO)
# ----------------------------------------------------------------
# Build a dynamically loadable D wrapper for a C++ module
# ----------------------------------------------------------------
-d_cpp: $(SRCS)
- $(SWIGD) -c++ $(SWIGOPT) $(INTERFACEPATH)
- $(CXX) -c $(CCSHARED) $(CFLAGS) $(DCFLAGS) $(EXTRA_CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES)
- $(CXXSHARED) $(CFLAGS) $(DCFLAGS) $(EXTRA_LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(DLIBPREFIX)$(TARGET)$(SO)
+d_cpp: $(SRCDIR_SRCS)
+ $(SWIGD) -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH)
+ $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(DCFLAGS) $(EXTRA_CFLAGS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(ICXXSRCS) $(INCLUDES)
+ $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(DCFLAGS) $(EXTRA_LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(DLIBPREFIX)$(TARGET)$(SO)
# ----------------------------------------------------------------
# Compile D files
# Clear the DFLAGS environment variable for the compiler call itself
# to work around a discrepancy in argument handling between DMD and LDC.
-d_compile: $(SRCS)
+d_compile: $(SRCDIR_SRCS)
DFLAGS="" $(COMPILETOOL) $(DCOMPILER) $(DFLAGS) $(DSRCS)
# -----------------------------------------------------------------
# -----------------------------------------------------------------
d_run:
- $(RUNTOOL) $(D_RUNME) $(RUNPIPE)
+ env LD_LIBRARY_PATH=$$PWD $(RUNTOOL) $(D_RUNME) $(RUNPIPE)
# -----------------------------------------------------------------
# Version display
# -----------------------------------------------------------------
d_clean:
- rm -f *_wrap* *~ .~* runme runme.exe `find . -name \*.d | grep -v runme.d`
+ rm -f *_wrap* *~ .~* $(RUNME) $(RUNME).exe `find . -name \*.d | grep -v $(RUNME).d`
rm -f core @EXTRA_CLEAN@
rm -f *.@OBJEXT@ *@SO@
SWIG Examples
-The "perl5", "python", "tcl", "guile", "java", "mzscheme", "ruby", and
-"chicken" directories contain a number of simple examples that are
-primarily used for testing.
+The subdirectories of "Examples" named after SWIG's language backends
+contain a number of simple examples that are primarily used for testing.
The file 'index.html' is the top of a hyperlinked document that
contains information about all of the examples along with various
notes related to each example.
-The Examples directory is currently quite incomplete because it
-is being reorganized. A more complete set of examples can be found
-in the SWIG1.1p5 distribution (most of which should still work with
-SWIG1.3).
-
Note: All of the examples rely upon the Makefile in this directory.
You may need to edit it to reflect the configuration of your machine
in case the configure script guesses incorrect settings.
-*** Special note concering C++ ***
+*** Special note concerning C++ ***
The configure script is currently unable to handle all of the possible
options for producing dynamically loadable C++ extensions. Here are
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
TARGET = example
INTERFACE = example.i
INTERFACEDIR = jni/
-PACKAGEDIR = src/org/swig
+PACKAGEDIR = $(SRCDIR)src/org/swig
PACKAGENAME= org.swig.classexample
-SWIGOPT = -package $(PACKAGENAME) -outdir $(PACKAGEDIR)/classexample
+SWIGOPT = -package $(PACKAGENAME) -outdir $(PACKAGEDIR)/classexample
PROJECTNAME= SwigClass
TARGETID = 1
#INSTALLOPTIONS = -s # To install on SD Card
check: build
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' INTERFACEDIR='$(INTERFACEDIR)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' INTERFACEDIR='$(INTERFACEDIR)' \
PROJECTNAME='$(PROJECTNAME)' TARGETID='$(TARGETID)' android_cpp
install:
- $(MAKE) -f $(TOP)/Makefile INSTALLOPTIONS='$(INSTALLOPTIONS)' PROJECTNAME='$(PROJECTNAME)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INSTALLOPTIONS='$(INSTALLOPTIONS)' PROJECTNAME='$(PROJECTNAME)' \
PACKAGEDIR='$(PACKAGEDIR)' PACKAGENAME='$(PACKAGENAME)' android_install
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' PROJECTNAME='$(PROJECTNAME)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' PROJECTNAME='$(PROJECTNAME)' \
PACKAGEDIR='$(PACKAGEDIR)' INTERFACEDIR='$(INTERFACEDIR)' android_clean
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
TARGET = example
INTERFACE = example.i
INTERFACEDIR = jni/
-PACKAGEDIR = src/org/swig
+PACKAGEDIR = $(SRCDIR)src/org/swig
PACKAGENAME= org.swig.extendexample
-SWIGOPT = -package $(PACKAGENAME) -outdir $(PACKAGEDIR)/extendexample
+SWIGOPT = -package $(PACKAGENAME) -outdir $(PACKAGEDIR)/extendexample
PROJECTNAME= SwigExtend
TARGETID = 1
#INSTALLOPTIONS = -s # To install on SD Card
check: build
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' INTERFACEDIR='$(INTERFACEDIR)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' INTERFACEDIR='$(INTERFACEDIR)' \
PROJECTNAME='$(PROJECTNAME)' TARGETID='$(TARGETID)' android_cpp
install:
- $(MAKE) -f $(TOP)/Makefile INSTALLOPTIONS='$(INSTALLOPTIONS)' PROJECTNAME='$(PROJECTNAME)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INSTALLOPTIONS='$(INSTALLOPTIONS)' PROJECTNAME='$(PROJECTNAME)' \
PACKAGEDIR='$(PACKAGEDIR)' PACKAGENAME='$(PACKAGENAME)' android_install
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' PROJECTNAME='$(PROJECTNAME)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' PROJECTNAME='$(PROJECTNAME)' \
PACKAGEDIR='$(PACKAGEDIR)' INTERFACEDIR='$(INTERFACEDIR)' android_clean
// methods of all these instances are treated the same. For items 0, 1, and
// 2, all methods resolve in C++. For item 3, our CEO, getTitle calls
// getPosition which resolves in Java. The call to getPosition is
- // slightly different, however, because of the overidden getPosition() call, since
+ // slightly different, however, because of the overridden getPosition() call, since
// now the object reference has been "laundered" by passing through
// EmployeeList as an Employee*. Previously, Java resolved the call
// immediately in CEO, but now Java thinks the object is an instance of
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
TARGET = example
INTERFACE = example.i
INTERFACEDIR = jni/
-PACKAGEDIR = src/org/swig
+PACKAGEDIR = $(SRCDIR)src/org/swig
PACKAGENAME= org.swig.simple
SWIGOPT = -package $(PACKAGENAME) -outdir $(PACKAGEDIR)/simple
PROJECTNAME= SwigSimple
check: build
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' INTERFACEDIR='$(INTERFACEDIR)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' INTERFACEDIR='$(INTERFACEDIR)' \
PROJECTNAME='$(PROJECTNAME)' TARGETID='$(TARGETID)' android
install:
- $(MAKE) -f $(TOP)/Makefile INSTALLOPTIONS='$(INSTALLOPTIONS)' PROJECTNAME='$(PROJECTNAME)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INSTALLOPTIONS='$(INSTALLOPTIONS)' PROJECTNAME='$(PROJECTNAME)' \
PACKAGEDIR='$(PACKAGEDIR)' PACKAGENAME='$(PACKAGENAME)' android_install
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' PROJECTNAME='$(PROJECTNAME)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' PROJECTNAME='$(PROJECTNAME)' \
PACKAGEDIR='$(PACKAGEDIR)' INTERFACEDIR='$(INTERFACEDIR)' android_clean
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-INTERFACE = example.i
-SRCS =
-CXXSRCS = example.cxx
-TARGET = class
-INCLUDE =
-SWIGOPT =
-CFLAGS =
-VARIANT =
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+INTERFACE = example.i
+SRCS =
+CXXSRCS = example.cxx
+TARGET = class
+INCLUDE =
+SWIGOPT =
+VARIANT =
# uncomment the following lines to build a static exe (only pick one of the CHICKEN_MAIN lines)
#CHICKEN_MAIN = runme-lowlevel.scm
#CHICKEN_MAIN = runme-tinyclos.scm
-#VARIANT = _static
+#VARIANT = _static
check: build
- $(MAKE) -f $(TOP)/Makefile CHICKEN_SCRIPT='runme-lowlevel.scm' chicken_run
- $(MAKE) -f $(TOP)/Makefile CHICKEN_SCRIPT='runme-tinyclos.scm' chicken_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CHICKEN_SCRIPT='runme-lowlevel.scm' chicken_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CHICKEN_SCRIPT='runme-tinyclos.scm' chicken_run
build: $(TARGET) $(TARGET)_proxy
$(TARGET): $(INTERFACE) $(SRCS)
- $(MAKE) -f $(TOP)/Makefile \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' \
- SWIG='$(SWIG)' INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)_cpp
+ INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)_cpp
$(TARGET)_proxy: $(INTERFACE) $(SRCS)
- $(MAKE) -f $(TOP)/Makefile \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT) -proxy' TARGET='$(TARGET)_proxy' \
- SWIG='$(SWIG)' INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)_cpp
+ INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile chicken_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_clean
rm -f example.scm
rm -f $(TARGET)
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
enum SomeEnum {
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
-
-
-
-
-
/* Let's just grab the original header file here */
%include "example.h"
-
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-INTERFACE = example.i
-SRCS =
-CXXSRCS =
-TARGET = constants
-INCLUDE =
-SWIGOPT =
-CFLAGS =
-VARIANT =
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+INTERFACE = example.i
+SRCS =
+CXXSRCS =
+TARGET = constants
+INCLUDE =
+SWIGOPT =
+VARIANT =
# uncomment the following two lines to build a static exe
#CHICKEN_MAIN = runme.scm
#VARIANT = _static
check: build
- $(MAKE) -f $(TOP)/Makefile chicken_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_run
build: $(TARGET)
$(TARGET): $(INTERFACE) $(SRCS)
- $(MAKE) -f $(TOP)/Makefile \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' \
- SWIG='$(SWIG)' INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)
+ INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)
clean:
- $(MAKE) -f $(TOP)/Makefile chicken_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_clean
rm -f example.scm
rm -f $(TARGET)
-SWIG = ../../../preinst-swig
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
check: build
cd eggs/install && csi ../../test.scm
# compile the single module with -nounit
single_wrap.cxx: single.i
- $(SWIG) -chicken -c++ -proxy -nounit single.i
+ $(SWIGEXE) -chicken -c++ -proxy -nounit single.i
# Now build both mod1 and mod2 into a single egg
multi: mod1_wrap.cxx mod2_wrap.cxx
rm -f mod1.scm mod1_wrap.cxx mod2.scm mod2_wrap.cxx
mod1_wrap.cxx: mod1.i
- $(SWIG) -chicken -c++ -proxy mod1.i
+ $(SWIGEXE) -chicken -c++ -proxy mod1.i
mod2_wrap.cxx: mod2.i
- $(SWIG) -chicken -c++ -proxy mod2.i
+ $(SWIGEXE) -chicken -c++ -proxy mod2.i
clean:
rm -rf eggs
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-INTERFACE = example.i
-SRCS = example.c
-CXXSRCS =
-TARGET = multimap
-INCLUDE =
-SWIGOPT =
-CFLAGS =
-VARIANT =
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+INTERFACE = example.i
+SRCS = example.c
+CXXSRCS =
+TARGET = multimap
+INCLUDE =
+SWIGOPT =
+VARIANT =
# uncomment the following two lines to build a static exe
#CHICKEN_MAIN = runme.scm
-#VARIANT = _static
+#VARIANT = _static
check: build
- $(MAKE) -f $(TOP)/Makefile chicken_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_run
build: $(TARGET)
$(TARGET): $(INTERFACE) $(SRCS)
- $(MAKE) -f $(TOP)/Makefile \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' \
- SWIG='$(SWIG)' INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)
+ INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)
clean:
- $(MAKE) -f $(TOP)/Makefile chicken_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_clean
rm -f example.scm
rm -f $(TARGET)
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-INTERFACE = example.i
-SRCS =
-CXXSRCS = example.cxx
-TARGET = overload
-INCLUDE =
-SWIGOPT = -proxy -unhideprimitive
-CFLAGS =
-VARIANT =
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+INTERFACE = example.i
+SRCS =
+CXXSRCS = example.cxx
+TARGET = overload
+INCLUDE =
+SWIGOPT = -proxy -unhideprimitive
+VARIANT =
# uncomment the following lines to build a static exe
#CHICKEN_MAIN = runme.scm
-#VARIANT = _static
+#VARIANT = _static
check: build
- $(MAKE) -f $(TOP)/Makefile chicken_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_run
build: $(TARGET)
$(TARGET): $(INTERFACE) $(SRCS)
- $(MAKE) -f $(TOP)/Makefile \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' \
- SWIG='$(SWIG)' INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)_cpp
+ INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile chicken_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_clean
rm -f example.scm
rm -f $(TARGET)
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-INTERFACE = example.i
-SRCS = example.c
-CXXSRCS =
-TARGET = simple
-INCLUDE =
-SWIGOPT =
-CFLAGS =
-VARIANT =
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+INTERFACE = example.i
+SRCS = example.c
+CXXSRCS =
+TARGET = simple
+INCLUDE =
+SWIGOPT =
+VARIANT =
# uncomment the following two lines to build a static exe
#CHICKEN_MAIN = runme.scm
-#VARIANT = _static
+#VARIANT = _static
check: build
- $(MAKE) -f $(TOP)/Makefile chicken_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_run
build: $(TARGET)
$(TARGET): $(INTERFACE) $(SRCS)
- $(MAKE) -f $(TOP)/Makefile \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' \
- SWIG='$(SWIG)' INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)
+ INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)
clean:
- $(MAKE) -f $(TOP)/Makefile chicken_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_clean
rm -f example.scm example-generic.scm example-clos.scm
rm -f $(TARGET)
}
virtual ~Shape() {
nshapes--;
- };
+ }
double x, y;
void move(double dx, double dy);
virtual double area(void) = 0;
private:
double radius;
public:
- Circle(double r) : radius(r) { };
+ Circle(double r) : radius(r) { }
virtual double area(void);
virtual double perimeter(void);
};
private:
double width;
public:
- Square(double w) : width(w) { };
+ Square(double w) : width(w) { }
virtual double area(void);
virtual double perimeter(void);
};
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
CSHARPSRCS = *.cs
-CSHARPFLAGS= -nologo -unsafe -out:runme.exe
+CSHARPFLAGS= -nologo -debug+ -unsafe -out:runme.exe
check: build
- $(MAKE) -f $(TOP)/Makefile csharp_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' csharp
- $(MAKE) -f $(TOP)/Makefile CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
clean:
- $(MAKE) -f $(TOP)/Makefile csharp_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_clean
--- /dev/null
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <ProjectType>Local</ProjectType>\r
+ <ProductVersion>8.0.50727</ProductVersion>\r
+ <SchemaVersion>2.0</SchemaVersion>\r
+ <ProjectGuid>{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}</ProjectGuid>\r
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>\r
+ <Platform Condition=" '$(Platform)' == '' ">x86</Platform>\r
+ <ApplicationIcon>\r
+ </ApplicationIcon>\r
+ <AssemblyKeyContainerName>\r
+ </AssemblyKeyContainerName>\r
+ <AssemblyName>runme</AssemblyName>\r
+ <AssemblyOriginatorKeyFile>\r
+ </AssemblyOriginatorKeyFile>\r
+ <DefaultClientScript>JScript</DefaultClientScript>\r
+ <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>\r
+ <DefaultTargetSchema>IE50</DefaultTargetSchema>\r
+ <DelaySign>false</DelaySign>\r
+ <OutputType>Exe</OutputType>\r
+ <RootNamespace>runme</RootNamespace>\r
+ <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>\r
+ <StartupObject>\r
+ </StartupObject>\r
+ <FileUpgradeFlags>\r
+ </FileUpgradeFlags>\r
+ <UpgradeBackupLocation>\r
+ </UpgradeBackupLocation>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x86\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">\r
+ <OutputPath>bin\x86\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x64\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">\r
+ <OutputPath>bin\x64\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <Compile Include="example.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="examplePINVOKE.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="runme.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ </ItemGroup>\r
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />\r
+ <PropertyGroup>\r
+ <PreBuildEvent>\r
+ </PreBuildEvent>\r
+ <PostBuildEvent>copy runme.exe "$(SolutionDir)runme.exe"\r
+echo Run the example from the root directory $(SolutionDir) and ensure example.dll is also in this directory</PostBuildEvent>\r
+ </PropertyGroup>\r
+</Project>\r
--- /dev/null
+<?xml version="1.0" encoding="Windows-1252"?>\r
+<VisualStudioProject\r
+ ProjectType="Visual C++"\r
+ Version="8.00"\r
+ Name="example"\r
+ ProjectGUID="{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
+ Keyword="Win32Proj"\r
+ >\r
+ <Platforms>\r
+ <Platform\r
+ Name="Win32"\r
+ />\r
+ <Platform\r
+ Name="x64"\r
+ />\r
+ </Platforms>\r
+ <ToolFiles>\r
+ </ToolFiles>\r
+ <Configurations>\r
+ <Configuration\r
+ Name="Debug|Win32"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="4"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Debug|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|Win32"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ </Configurations>\r
+ <References>\r
+ </References>\r
+ <Files>\r
+ <Filter\r
+ Name="Source Files"\r
+ Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
+ >\r
+ <File\r
+ RelativePath="example.c"\r
+ >\r
+ </File>\r
+ <File\r
+ RelativePath="example_wrap.c"\r
+ >\r
+ </File>\r
+ </Filter>\r
+ <Filter\r
+ Name="Header Files"\r
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"\r
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"\r
+ >\r
+ <File\r
+ RelativePath="example.h"\r
+ >\r
+ </File>\r
+ </Filter>\r
+ <File\r
+ RelativePath=".\example.i"\r
+ >\r
+ <FileConfiguration\r
+ Name="Debug|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Debug|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Release|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Release|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
+ </FileConfiguration>\r
+ </File>\r
+ </Files>\r
+ <Globals>\r
+ </Globals>\r
+</VisualStudioProject>\r
--- /dev/null
+Microsoft Visual Studio Solution File, Format Version 9.00\r
+# Visual Studio 2005\r
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "example-cs", "example-cs.csproj", "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
+ ProjectSection(ProjectDependencies) = postProject\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6} = {C2302635-D489-4678-96B4-70F5309DCBE6}\r
+ EndProjectSection\r
+EndProject\r
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example-vc", "example-vc.vcproj", "{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
+EndProject\r
+Global\r
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
+ Debug|Win32 = Debug|Win32\r
+ Debug|x64 = Debug|x64\r
+ Release|Win32 = Release|Win32\r
+ Release|x64 = Release|x64\r
+ EndGlobalSection\r
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.ActiveCfg = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.Build.0 = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.Build.0 = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.ActiveCfg = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.Build.0 = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.ActiveCfg = Release|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.Build.0 = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.ActiveCfg = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.Build.0 = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.Build.0 = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.ActiveCfg = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.Build.0 = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.ActiveCfg = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.Build.0 = Release|x64\r
+ EndGlobalSection\r
+ GlobalSection(SolutionProperties) = preSolution\r
+ HideSolutionNode = FALSE\r
+ EndGlobalSection\r
+EndGlobal\r
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
CSHARPSRCS = *.cs
-CSHARPFLAGS= -debug -nologo -out:runme.exe
+CSHARPFLAGS= -nologo -debug+ -out:runme.exe
check: build
- $(MAKE) -f $(TOP)/Makefile csharp_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' csharp_cpp
- $(MAKE) -f $(TOP)/Makefile CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
clean:
- $(MAKE) -f $(TOP)/Makefile csharp_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_clean
-<VisualStudioProject>\r
- <CSHARP\r
- ProjectType = "Local"\r
- ProductVersion = "7.10.3077"\r
- SchemaVersion = "2.0"\r
- ProjectGuid = "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
- >\r
- <Build>\r
- <Settings\r
- ApplicationIcon = ""\r
- AssemblyKeyContainerName = ""\r
- AssemblyName = "runme"\r
- AssemblyOriginatorKeyFile = ""\r
- DefaultClientScript = "JScript"\r
- DefaultHTMLPageLayout = "Grid"\r
- DefaultTargetSchema = "IE50"\r
- DelaySign = "false"\r
- OutputType = "Exe"\r
- PreBuildEvent = ""\r
- PostBuildEvent = ""\r
- RootNamespace = "runme"\r
- RunPostBuildEvent = "OnBuildSuccess"\r
- StartupObject = ""\r
- >\r
- <Config\r
- Name = "Debug"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "DEBUG;TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "true"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "false"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- <Config\r
- Name = "Release"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "false"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "true"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- </Settings>\r
- <References/>\r
- </Build>\r
- <Files>\r
- <Include>\r
- <File\r
- RelPath = "Callback.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "Caller.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "example.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "examplePINVOKE.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "runme.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- </Include>\r
- </Files>\r
- </CSHARP>\r
-</VisualStudioProject>\r
-\r
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <ProjectType>Local</ProjectType>\r
+ <ProductVersion>8.0.50727</ProductVersion>\r
+ <SchemaVersion>2.0</SchemaVersion>\r
+ <ProjectGuid>{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}</ProjectGuid>\r
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>\r
+ <Platform Condition=" '$(Platform)' == '' ">x86</Platform>\r
+ <ApplicationIcon>\r
+ </ApplicationIcon>\r
+ <AssemblyKeyContainerName>\r
+ </AssemblyKeyContainerName>\r
+ <AssemblyName>runme</AssemblyName>\r
+ <AssemblyOriginatorKeyFile>\r
+ </AssemblyOriginatorKeyFile>\r
+ <DefaultClientScript>JScript</DefaultClientScript>\r
+ <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>\r
+ <DefaultTargetSchema>IE50</DefaultTargetSchema>\r
+ <DelaySign>false</DelaySign>\r
+ <OutputType>Exe</OutputType>\r
+ <RootNamespace>runme</RootNamespace>\r
+ <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>\r
+ <StartupObject>\r
+ </StartupObject>\r
+ <FileUpgradeFlags>\r
+ </FileUpgradeFlags>\r
+ <UpgradeBackupLocation>\r
+ </UpgradeBackupLocation>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x86\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">\r
+ <OutputPath>bin\x86\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x64\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">\r
+ <OutputPath>bin\x64\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <Compile Include="Callback.cs" />\r
+ <Compile Include="Caller.cs" />\r
+ <Compile Include="example.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="examplePINVOKE.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="runme.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ </ItemGroup>\r
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />\r
+ <PropertyGroup>\r
+ <PreBuildEvent>\r
+ </PreBuildEvent>\r
+ <PostBuildEvent>copy runme.exe "$(SolutionDir)runme.exe"\r
+echo Run the example from the root directory $(SolutionDir) and ensure example.dll is also in this directory</PostBuildEvent>\r
+ </PropertyGroup>\r
+</Project>\r
<?xml version="1.0" encoding="Windows-1252"?>\r
<VisualStudioProject\r
ProjectType="Visual C++"\r
- Version="7.10"\r
+ Version="8.00"\r
Name="example"\r
ProjectGUID="{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- Keyword="Win32Proj">\r
+ Keyword="Win32Proj"\r
+ >\r
<Platforms>\r
<Platform\r
- Name="Win32"/>\r
+ Name="Win32"\r
+ />\r
+ <Platform\r
+ Name="x64"\r
+ />\r
</Platforms>\r
+ <ToolFiles>\r
+ </ToolFiles>\r
<Configurations>\r
<Configuration\r
Name="Debug|Win32"\r
- OutputDirectory="Debug"\r
- IntermediateDirectory="Debug"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
Optimization="0"\r
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
- MinimalRebuild="TRUE"\r
+ MinimalRebuild="true"\r
BasicRuntimeChecks="3"\r
RuntimeLibrary="1"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="4"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="4"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="2"\r
- GenerateDebugInformation="TRUE"\r
- ProgramDatabaseFile="$(OutDir)/example.pdb"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Debug|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
<Configuration\r
Name="Release|Win32"\r
- OutputDirectory="Release"\r
- IntermediateDirectory="Release"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
RuntimeLibrary="0"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="3"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="1"\r
- GenerateDebugInformation="TRUE"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
OptimizeReferences="2"\r
EnableCOMDATFolding="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCPreBuildEventTool"\r
+ />\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCCustomBuildTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
</Configurations>\r
<References>\r
<Filter\r
Name="Source Files"\r
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">\r
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
+ >\r
<File\r
- RelativePath="example.cxx">\r
+ RelativePath="example.cxx"\r
+ >\r
</File>\r
<File\r
- RelativePath="example_wrap.cxx">\r
+ RelativePath="example_wrap.cxx"\r
+ >\r
</File>\r
</Filter>\r
<Filter\r
Name="Header Files"\r
Filter="h;hpp;hxx;hm;inl;inc;xsd"\r
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">\r
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"\r
+ >\r
<File\r
- RelativePath="example.h">\r
+ RelativePath="example.h"\r
+ >\r
+ </File>\r
+ <File\r
+ RelativePath="example_wrap.h"\r
+ >\r
</File>\r
</Filter>\r
<File\r
- RelativePath=".\example.i">\r
+ RelativePath=".\example.i"\r
+ >\r
+ <FileConfiguration\r
+ Name="Debug|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Debug|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
<FileConfiguration\r
- Name="Debug|Win32">\r
+ Name="Release|Win32"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -c++ -csharp "$(InputPath)"\r
-@echo off"\r
- Outputs="$(InputName)_wrap.cxx"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
</FileConfiguration>\r
<FileConfiguration\r
- Name="Release|Win32">\r
+ Name="Release|x64"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -c++ -csharp "$(InputPath)"\r
-@echo off"\r
- Outputs="$(InputName)_wrap.cxx"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
</FileConfiguration>\r
</File>\r
</Files>\r
#include "example.h"
%}
-%include "std_string.i"
-
/* turn on director wrapping Callback */
%feature("director") Callback;
-Microsoft Visual Studio Solution File, Format Version 8.00\r
+Microsoft Visual Studio Solution File, Format Version 9.00\r
+# Visual Studio 2005\r
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "example-cs", "example-cs.csproj", "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
ProjectSection(ProjectDependencies) = postProject\r
{C2302635-D489-4678-96B4-70F5309DCBE6} = {C2302635-D489-4678-96B4-70F5309DCBE6}\r
EndProjectSection\r
EndProject\r
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example-vc", "example-vc.vcproj", "{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- ProjectSection(ProjectDependencies) = postProject\r
- EndProjectSection\r
EndProject\r
Global\r
- GlobalSection(SolutionConfiguration) = preSolution\r
- Debug = Debug\r
- Release = Release\r
- EndGlobalSection\r
- GlobalSection(ProjectConfiguration) = postSolution\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.ActiveCfg = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.Build.0 = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.ActiveCfg = Release|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.Build.0 = Release|.NET\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.ActiveCfg = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.Build.0 = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.ActiveCfg = Release|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.Build.0 = Release|Win32\r
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
+ Debug|Win32 = Debug|Win32\r
+ Debug|x64 = Debug|x64\r
+ Release|Win32 = Release|Win32\r
+ Release|x64 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityGlobals) = postSolution\r
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.ActiveCfg = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.Build.0 = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.Build.0 = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.ActiveCfg = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.Build.0 = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.ActiveCfg = Release|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.Build.0 = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.ActiveCfg = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.Build.0 = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.Build.0 = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.ActiveCfg = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.Build.0 = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.ActiveCfg = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.Build.0 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityAddIns) = postSolution\r
+ GlobalSection(SolutionProperties) = preSolution\r
+ HideSolutionNode = FALSE\r
EndGlobalSection\r
EndGlobal\r
enum
extend
funcptr
+nested
reference
simple
template
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
CSHARPSRCS = *.cs
-CSHARPFLAGS= -nologo -out:runme.exe
+CSHARPFLAGS= -nologo -debug+ -out:runme.exe
check: build
- $(MAKE) -f $(TOP)/Makefile csharp_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' csharp_cpp
- $(MAKE) -f $(TOP)/Makefile CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
clean:
- $(MAKE) -f $(TOP)/Makefile csharp_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_clean
-<VisualStudioProject>\r
- <CSHARP\r
- ProjectType = "Local"\r
- ProductVersion = "7.10.3077"\r
- SchemaVersion = "2.0"\r
- ProjectGuid = "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
- >\r
- <Build>\r
- <Settings\r
- ApplicationIcon = ""\r
- AssemblyKeyContainerName = ""\r
- AssemblyName = "runme"\r
- AssemblyOriginatorKeyFile = ""\r
- DefaultClientScript = "JScript"\r
- DefaultHTMLPageLayout = "Grid"\r
- DefaultTargetSchema = "IE50"\r
- DelaySign = "false"\r
- OutputType = "Exe"\r
- PreBuildEvent = ""\r
- PostBuildEvent = ""\r
- RootNamespace = "runme"\r
- RunPostBuildEvent = "OnBuildSuccess"\r
- StartupObject = ""\r
- >\r
- <Config\r
- Name = "Debug"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "DEBUG;TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "true"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "false"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- <Config\r
- Name = "Release"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "false"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "true"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- </Settings>\r
- <References/>\r
- </Build>\r
- <Files>\r
- <Include>\r
- <File\r
- RelPath = "Circle.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "example.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "examplePINVOKE.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "runme.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "Shape.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "Square.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- </Include>\r
- </Files>\r
- </CSHARP>\r
-</VisualStudioProject>\r
-\r
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <ProjectType>Local</ProjectType>\r
+ <ProductVersion>8.0.50727</ProductVersion>\r
+ <SchemaVersion>2.0</SchemaVersion>\r
+ <ProjectGuid>{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}</ProjectGuid>\r
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>\r
+ <Platform Condition=" '$(Platform)' == '' ">x86</Platform>\r
+ <ApplicationIcon>\r
+ </ApplicationIcon>\r
+ <AssemblyKeyContainerName>\r
+ </AssemblyKeyContainerName>\r
+ <AssemblyName>runme</AssemblyName>\r
+ <AssemblyOriginatorKeyFile>\r
+ </AssemblyOriginatorKeyFile>\r
+ <DefaultClientScript>JScript</DefaultClientScript>\r
+ <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>\r
+ <DefaultTargetSchema>IE50</DefaultTargetSchema>\r
+ <DelaySign>false</DelaySign>\r
+ <OutputType>Exe</OutputType>\r
+ <RootNamespace>runme</RootNamespace>\r
+ <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>\r
+ <StartupObject>\r
+ </StartupObject>\r
+ <FileUpgradeFlags>\r
+ </FileUpgradeFlags>\r
+ <UpgradeBackupLocation>\r
+ </UpgradeBackupLocation>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x86\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">\r
+ <OutputPath>bin\x86\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x64\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">\r
+ <OutputPath>bin\x64\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <Compile Include="Circle.cs" />\r
+ <Compile Include="example.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="examplePINVOKE.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="runme.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="Shape.cs" />\r
+ <Compile Include="Square.cs" />\r
+ </ItemGroup>\r
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />\r
+ <PropertyGroup>\r
+ <PreBuildEvent>\r
+ </PreBuildEvent>\r
+ <PostBuildEvent>copy runme.exe "$(SolutionDir)runme.exe"\r
+echo Run the example from the root directory $(SolutionDir) and ensure example.dll is also in this directory</PostBuildEvent>\r
+ </PropertyGroup>\r
+</Project>\r
<?xml version="1.0" encoding="Windows-1252"?>\r
<VisualStudioProject\r
ProjectType="Visual C++"\r
- Version="7.10"\r
+ Version="8.00"\r
Name="example"\r
ProjectGUID="{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- Keyword="Win32Proj">\r
+ Keyword="Win32Proj"\r
+ >\r
<Platforms>\r
<Platform\r
- Name="Win32"/>\r
+ Name="Win32"\r
+ />\r
+ <Platform\r
+ Name="x64"\r
+ />\r
</Platforms>\r
+ <ToolFiles>\r
+ </ToolFiles>\r
<Configurations>\r
<Configuration\r
Name="Debug|Win32"\r
- OutputDirectory="Debug"\r
- IntermediateDirectory="Debug"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
Optimization="0"\r
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
- MinimalRebuild="TRUE"\r
+ MinimalRebuild="true"\r
BasicRuntimeChecks="3"\r
RuntimeLibrary="1"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="4"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="4"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="2"\r
- GenerateDebugInformation="TRUE"\r
- ProgramDatabaseFile="$(OutDir)/example.pdb"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Debug|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCPreBuildEventTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
<Configuration\r
Name="Release|Win32"\r
- OutputDirectory="Release"\r
- IntermediateDirectory="Release"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
RuntimeLibrary="0"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="3"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="1"\r
- GenerateDebugInformation="TRUE"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
OptimizeReferences="2"\r
EnableCOMDATFolding="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
</Configurations>\r
<References>\r
<Filter\r
Name="Source Files"\r
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">\r
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
+ >\r
<File\r
- RelativePath="example.cxx">\r
+ RelativePath="example.cxx"\r
+ >\r
</File>\r
<File\r
- RelativePath="example_wrap.cxx">\r
+ RelativePath="example_wrap.cxx"\r
+ >\r
</File>\r
</Filter>\r
<Filter\r
Name="Header Files"\r
Filter="h;hpp;hxx;hm;inl;inc;xsd"\r
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">\r
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"\r
+ >\r
<File\r
- RelativePath="example.h">\r
+ RelativePath="example.h"\r
+ >\r
</File>\r
</Filter>\r
<File\r
- RelativePath=".\example.i">\r
+ RelativePath=".\example.i"\r
+ >\r
+ <FileConfiguration\r
+ Name="Debug|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Debug|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
<FileConfiguration\r
- Name="Debug|Win32">\r
+ Name="Release|Win32"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -c++ -csharp "$(InputPath)"\r
-@echo off"\r
- Outputs="$(InputName)_wrap.cxx"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
</FileConfiguration>\r
<FileConfiguration\r
- Name="Release|Win32">\r
+ Name="Release|x64"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -c++ -csharp "$(InputPath)"\r
-@echo off"\r
- Outputs="$(InputName)_wrap.cxx"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
</FileConfiguration>\r
</File>\r
</Files>\r
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
-
-
-
-
-
/* Let's just grab the original header file here */
%include "example.h"
-
-Microsoft Visual Studio Solution File, Format Version 8.00\r
+Microsoft Visual Studio Solution File, Format Version 9.00\r
+# Visual Studio 2005\r
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "example-cs", "example-cs.csproj", "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
ProjectSection(ProjectDependencies) = postProject\r
{C2302635-D489-4678-96B4-70F5309DCBE6} = {C2302635-D489-4678-96B4-70F5309DCBE6}\r
EndProjectSection\r
EndProject\r
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example-vc", "example-vc.vcproj", "{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- ProjectSection(ProjectDependencies) = postProject\r
- EndProjectSection\r
EndProject\r
Global\r
- GlobalSection(SolutionConfiguration) = preSolution\r
- Debug = Debug\r
- Release = Release\r
- EndGlobalSection\r
- GlobalSection(ProjectConfiguration) = postSolution\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.ActiveCfg = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.Build.0 = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.ActiveCfg = Release|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.Build.0 = Release|.NET\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.ActiveCfg = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.Build.0 = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.ActiveCfg = Release|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.Build.0 = Release|Win32\r
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
+ Debug|Win32 = Debug|Win32\r
+ Debug|x64 = Debug|x64\r
+ Release|Win32 = Release|Win32\r
+ Release|x64 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityGlobals) = postSolution\r
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.ActiveCfg = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.Build.0 = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.Build.0 = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.ActiveCfg = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.Build.0 = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.ActiveCfg = Release|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.Build.0 = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.ActiveCfg = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.Build.0 = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.Build.0 = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.ActiveCfg = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.Build.0 = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.ActiveCfg = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.Build.0 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityAddIns) = postSolution\r
+ GlobalSection(SolutionProperties) = preSolution\r
+ HideSolutionNode = FALSE\r
EndGlobalSection\r
EndGlobal\r
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
CSHARPSRCS = *.cs
-CSHARPFLAGS= -nologo -out:runme.exe
+CSHARPFLAGS= -nologo -debug+ -out:runme.exe
check: build
- $(MAKE) -f $(TOP)/Makefile csharp_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' csharp_cpp
- $(MAKE) -f $(TOP)/Makefile CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
clean:
- $(MAKE) -f $(TOP)/Makefile csharp_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_clean
-<VisualStudioProject>\r
- <CSHARP\r
- ProjectType = "Local"\r
- ProductVersion = "7.10.3077"\r
- SchemaVersion = "2.0"\r
- ProjectGuid = "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
- >\r
- <Build>\r
- <Settings\r
- ApplicationIcon = ""\r
- AssemblyKeyContainerName = ""\r
- AssemblyName = "runme"\r
- AssemblyOriginatorKeyFile = ""\r
- DefaultClientScript = "JScript"\r
- DefaultHTMLPageLayout = "Grid"\r
- DefaultTargetSchema = "IE50"\r
- DelaySign = "false"\r
- OutputType = "Exe"\r
- PreBuildEvent = ""\r
- PostBuildEvent = ""\r
- RootNamespace = "runme"\r
- RunPostBuildEvent = "OnBuildSuccess"\r
- StartupObject = ""\r
- >\r
- <Config\r
- Name = "Debug"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "DEBUG;TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "true"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "false"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- <Config\r
- Name = "Release"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "false"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "true"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- </Settings>\r
- <References/>\r
- </Build>\r
- <Files>\r
- <Include>\r
- <File\r
- RelPath = "color.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "example.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "examplePINVOKE.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "Foo.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "runme.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- </Include>\r
- </Files>\r
- </CSHARP>\r
-</VisualStudioProject>\r
-\r
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <ProjectType>Local</ProjectType>\r
+ <ProductVersion>8.0.50727</ProductVersion>\r
+ <SchemaVersion>2.0</SchemaVersion>\r
+ <ProjectGuid>{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}</ProjectGuid>\r
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>\r
+ <Platform Condition=" '$(Platform)' == '' ">x86</Platform>\r
+ <ApplicationIcon>\r
+ </ApplicationIcon>\r
+ <AssemblyKeyContainerName>\r
+ </AssemblyKeyContainerName>\r
+ <AssemblyName>runme</AssemblyName>\r
+ <AssemblyOriginatorKeyFile>\r
+ </AssemblyOriginatorKeyFile>\r
+ <DefaultClientScript>JScript</DefaultClientScript>\r
+ <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>\r
+ <DefaultTargetSchema>IE50</DefaultTargetSchema>\r
+ <DelaySign>false</DelaySign>\r
+ <OutputType>Exe</OutputType>\r
+ <RootNamespace>runme</RootNamespace>\r
+ <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>\r
+ <StartupObject>\r
+ </StartupObject>\r
+ <FileUpgradeFlags>\r
+ </FileUpgradeFlags>\r
+ <UpgradeBackupLocation>\r
+ </UpgradeBackupLocation>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x86\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">\r
+ <OutputPath>bin\x86\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x64\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">\r
+ <OutputPath>bin\x64\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <Compile Include="color.cs" />\r
+ <Compile Include="example.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="examplePINVOKE.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="Foo.cs" />\r
+ <Compile Include="runme.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ </ItemGroup>\r
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />\r
+ <PropertyGroup>\r
+ <PreBuildEvent>\r
+ </PreBuildEvent>\r
+ <PostBuildEvent>copy runme.exe "$(SolutionDir)runme.exe"\r
+echo Run the example from the root directory $(SolutionDir) and ensure example.dll is also in this directory</PostBuildEvent>\r
+ </PropertyGroup>\r
+</Project>\r
<?xml version="1.0" encoding="Windows-1252"?>\r
<VisualStudioProject\r
ProjectType="Visual C++"\r
- Version="7.10"\r
+ Version="8.00"\r
Name="example"\r
ProjectGUID="{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- Keyword="Win32Proj">\r
+ Keyword="Win32Proj"\r
+ >\r
<Platforms>\r
<Platform\r
- Name="Win32"/>\r
+ Name="Win32"\r
+ />\r
+ <Platform\r
+ Name="x64"\r
+ />\r
</Platforms>\r
+ <ToolFiles>\r
+ </ToolFiles>\r
<Configurations>\r
<Configuration\r
Name="Debug|Win32"\r
- OutputDirectory="Debug"\r
- IntermediateDirectory="Debug"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
Optimization="0"\r
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
- MinimalRebuild="TRUE"\r
+ MinimalRebuild="true"\r
BasicRuntimeChecks="3"\r
RuntimeLibrary="1"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="4"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="4"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="2"\r
- GenerateDebugInformation="TRUE"\r
- ProgramDatabaseFile="$(OutDir)/example.pdb"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Debug|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCPreBuildEventTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
<Configuration\r
Name="Release|Win32"\r
- OutputDirectory="Release"\r
- IntermediateDirectory="Release"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
RuntimeLibrary="0"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="3"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="1"\r
- GenerateDebugInformation="TRUE"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
OptimizeReferences="2"\r
EnableCOMDATFolding="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
</Configurations>\r
<References>\r
<Filter\r
Name="Source Files"\r
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">\r
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
+ >\r
<File\r
- RelativePath="example.cxx">\r
+ RelativePath="example.cxx"\r
+ >\r
</File>\r
<File\r
- RelativePath="example_wrap.cxx">\r
+ RelativePath="example_wrap.cxx"\r
+ >\r
</File>\r
</Filter>\r
<Filter\r
Name="Header Files"\r
Filter="h;hpp;hxx;hm;inl;inc;xsd"\r
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">\r
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"\r
+ >\r
<File\r
- RelativePath="example.h">\r
+ RelativePath="example.h"\r
+ >\r
</File>\r
</Filter>\r
<File\r
- RelativePath=".\example.i">\r
+ RelativePath=".\example.i"\r
+ >\r
+ <FileConfiguration\r
+ Name="Debug|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Debug|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
<FileConfiguration\r
- Name="Debug|Win32">\r
+ Name="Release|Win32"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -c++ -csharp "$(InputPath)"\r
-@echo off"\r
- Outputs="$(InputName)_wrap.cxx"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
</FileConfiguration>\r
<FileConfiguration\r
- Name="Release|Win32">\r
+ Name="Release|x64"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -c++ -csharp "$(InputPath)"\r
-@echo off"\r
- Outputs="$(InputName)_wrap.cxx"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
</FileConfiguration>\r
</File>\r
</Files>\r
-Microsoft Visual Studio Solution File, Format Version 8.00\r
+Microsoft Visual Studio Solution File, Format Version 9.00\r
+# Visual Studio 2005\r
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "example-cs", "example-cs.csproj", "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
ProjectSection(ProjectDependencies) = postProject\r
{C2302635-D489-4678-96B4-70F5309DCBE6} = {C2302635-D489-4678-96B4-70F5309DCBE6}\r
EndProjectSection\r
EndProject\r
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example-vc", "example-vc.vcproj", "{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- ProjectSection(ProjectDependencies) = postProject\r
- EndProjectSection\r
EndProject\r
Global\r
- GlobalSection(SolutionConfiguration) = preSolution\r
- Debug = Debug\r
- Release = Release\r
- EndGlobalSection\r
- GlobalSection(ProjectConfiguration) = postSolution\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.ActiveCfg = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.Build.0 = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.ActiveCfg = Release|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.Build.0 = Release|.NET\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.ActiveCfg = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.Build.0 = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.ActiveCfg = Release|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.Build.0 = Release|Win32\r
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
+ Debug|Win32 = Debug|Win32\r
+ Debug|x64 = Debug|x64\r
+ Release|Win32 = Release|Win32\r
+ Release|x64 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityGlobals) = postSolution\r
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.ActiveCfg = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.Build.0 = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.Build.0 = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.ActiveCfg = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.Build.0 = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.ActiveCfg = Release|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.Build.0 = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.ActiveCfg = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.Build.0 = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.Build.0 = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.ActiveCfg = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.Build.0 = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.ActiveCfg = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.Build.0 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityAddIns) = postSolution\r
+ GlobalSection(SolutionProperties) = preSolution\r
+ HideSolutionNode = FALSE\r
EndGlobalSection\r
EndGlobal\r
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
CSHARPSRCS = *.cs
-CSHARPFLAGS= -nologo -out:runme.exe
+CSHARPFLAGS= -nologo -debug+ -out:runme.exe
check: build
- $(MAKE) -f $(TOP)/Makefile csharp_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' csharp_cpp
- $(MAKE) -f $(TOP)/Makefile CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
clean:
- $(MAKE) -f $(TOP)/Makefile csharp_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_clean
-<VisualStudioProject>\r
- <CSHARP\r
- ProjectType = "Local"\r
- ProductVersion = "7.10.3077"\r
- SchemaVersion = "2.0"\r
- ProjectGuid = "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
- >\r
- <Build>\r
- <Settings\r
- ApplicationIcon = ""\r
- AssemblyKeyContainerName = ""\r
- AssemblyName = "runme"\r
- AssemblyOriginatorKeyFile = ""\r
- DefaultClientScript = "JScript"\r
- DefaultHTMLPageLayout = "Grid"\r
- DefaultTargetSchema = "IE50"\r
- DelaySign = "false"\r
- OutputType = "Exe"\r
- PreBuildEvent = ""\r
- PostBuildEvent = ""\r
- RootNamespace = "runme"\r
- RunPostBuildEvent = "OnBuildSuccess"\r
- StartupObject = ""\r
- >\r
- <Config\r
- Name = "Debug"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "DEBUG;TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "true"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "false"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- <Config\r
- Name = "Release"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "false"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "true"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- </Settings>\r
- <References/>\r
- </Build>\r
- <Files>\r
- <Include>\r
- <File\r
- RelPath = "Employee.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "EmployeeList.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "Manager.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "example.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "examplePINVOKE.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "runme.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- </Include>\r
- </Files>\r
- </CSHARP>\r
-</VisualStudioProject>\r
-\r
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <ProjectType>Local</ProjectType>\r
+ <ProductVersion>8.0.50727</ProductVersion>\r
+ <SchemaVersion>2.0</SchemaVersion>\r
+ <ProjectGuid>{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}</ProjectGuid>\r
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>\r
+ <Platform Condition=" '$(Platform)' == '' ">x86</Platform>\r
+ <ApplicationIcon>\r
+ </ApplicationIcon>\r
+ <AssemblyKeyContainerName>\r
+ </AssemblyKeyContainerName>\r
+ <AssemblyName>runme</AssemblyName>\r
+ <AssemblyOriginatorKeyFile>\r
+ </AssemblyOriginatorKeyFile>\r
+ <DefaultClientScript>JScript</DefaultClientScript>\r
+ <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>\r
+ <DefaultTargetSchema>IE50</DefaultTargetSchema>\r
+ <DelaySign>false</DelaySign>\r
+ <OutputType>Exe</OutputType>\r
+ <RootNamespace>runme</RootNamespace>\r
+ <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>\r
+ <StartupObject>\r
+ </StartupObject>\r
+ <FileUpgradeFlags>\r
+ </FileUpgradeFlags>\r
+ <UpgradeBackupLocation>\r
+ </UpgradeBackupLocation>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x86\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">\r
+ <OutputPath>bin\x86\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x64\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">\r
+ <OutputPath>bin\x64\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <Compile Include="Employee.cs" />\r
+ <Compile Include="EmployeeList.cs" />\r
+ <Compile Include="example.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="examplePINVOKE.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="Manager.cs" />\r
+ <Compile Include="runme.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ </ItemGroup>\r
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />\r
+ <PropertyGroup>\r
+ <PreBuildEvent>\r
+ </PreBuildEvent>\r
+ <PostBuildEvent>copy runme.exe "$(SolutionDir)runme.exe"\r
+echo Run the example from the root directory $(SolutionDir) and ensure example.dll is also in this directory</PostBuildEvent>\r
+ </PropertyGroup>\r
+</Project>\r
<?xml version="1.0" encoding="Windows-1252"?>\r
<VisualStudioProject\r
ProjectType="Visual C++"\r
- Version="7.10"\r
+ Version="8.00"\r
Name="example"\r
ProjectGUID="{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- Keyword="Win32Proj">\r
+ Keyword="Win32Proj"\r
+ >\r
<Platforms>\r
<Platform\r
- Name="Win32"/>\r
+ Name="Win32"\r
+ />\r
+ <Platform\r
+ Name="x64"\r
+ />\r
</Platforms>\r
+ <ToolFiles>\r
+ </ToolFiles>\r
<Configurations>\r
<Configuration\r
Name="Debug|Win32"\r
- OutputDirectory="Debug"\r
- IntermediateDirectory="Debug"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
Optimization="0"\r
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
- MinimalRebuild="TRUE"\r
+ MinimalRebuild="true"\r
BasicRuntimeChecks="3"\r
RuntimeLibrary="1"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="4"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="4"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="2"\r
- GenerateDebugInformation="TRUE"\r
- ProgramDatabaseFile="$(OutDir)/example.pdb"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Debug|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
<Configuration\r
Name="Release|Win32"\r
- OutputDirectory="Release"\r
- IntermediateDirectory="Release"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
RuntimeLibrary="0"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="3"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="1"\r
- GenerateDebugInformation="TRUE"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
OptimizeReferences="2"\r
EnableCOMDATFolding="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCPreBuildEventTool"\r
+ />\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCCustomBuildTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
</Configurations>\r
<References>\r
<Filter\r
Name="Source Files"\r
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">\r
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
+ >\r
<File\r
- RelativePath="example.cxx">\r
+ RelativePath="example.cxx"\r
+ >\r
</File>\r
<File\r
- RelativePath="example_wrap.cxx">\r
+ RelativePath="example_wrap.cxx"\r
+ >\r
</File>\r
</Filter>\r
<Filter\r
Name="Header Files"\r
Filter="h;hpp;hxx;hm;inl;inc;xsd"\r
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">\r
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"\r
+ >\r
<File\r
- RelativePath="example.h">\r
+ RelativePath="example.h"\r
+ >\r
+ </File>\r
+ <File\r
+ RelativePath="example_wrap.h"\r
+ >\r
</File>\r
</Filter>\r
<File\r
- RelativePath=".\example.i">\r
+ RelativePath=".\example.i"\r
+ >\r
+ <FileConfiguration\r
+ Name="Debug|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Debug|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
<FileConfiguration\r
- Name="Debug|Win32">\r
+ Name="Release|Win32"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -c++ -csharp "$(InputPath)"\r
-@echo off"\r
- Outputs="$(InputName)_wrap.cxx"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
</FileConfiguration>\r
<FileConfiguration\r
- Name="Release|Win32">\r
+ Name="Release|x64"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -c++ -csharp "$(InputPath)"\r
-@echo off"\r
- Outputs="$(InputName)_wrap.cxx"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
</FileConfiguration>\r
</File>\r
</Files>\r
virtual std::string getTitle() { return getPosition() + " " + getName(); }
virtual std::string getName() { return name; }
virtual std::string getPosition() const { return "Employee"; }
- virtual ~Employee() { printf("~Employee() @ %p\n", this); }
+ virtual ~Employee() { printf("~Employee() @ %p\n", (void *)this); }
};
-Microsoft Visual Studio Solution File, Format Version 8.00\r
+Microsoft Visual Studio Solution File, Format Version 9.00\r
+# Visual Studio 2005\r
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "example-cs", "example-cs.csproj", "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
ProjectSection(ProjectDependencies) = postProject\r
{C2302635-D489-4678-96B4-70F5309DCBE6} = {C2302635-D489-4678-96B4-70F5309DCBE6}\r
EndProjectSection\r
EndProject\r
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example-vc", "example-vc.vcproj", "{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- ProjectSection(ProjectDependencies) = postProject\r
- EndProjectSection\r
EndProject\r
Global\r
- GlobalSection(SolutionConfiguration) = preSolution\r
- Debug = Debug\r
- Release = Release\r
- EndGlobalSection\r
- GlobalSection(ProjectConfiguration) = postSolution\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.ActiveCfg = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.Build.0 = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.ActiveCfg = Release|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.Build.0 = Release|.NET\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.ActiveCfg = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.Build.0 = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.ActiveCfg = Release|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.Build.0 = Release|Win32\r
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
+ Debug|Win32 = Debug|Win32\r
+ Debug|x64 = Debug|x64\r
+ Release|Win32 = Release|Win32\r
+ Release|x64 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityGlobals) = postSolution\r
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.ActiveCfg = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.Build.0 = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.Build.0 = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.ActiveCfg = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.Build.0 = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.ActiveCfg = Release|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.Build.0 = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.ActiveCfg = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.Build.0 = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.Build.0 = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.ActiveCfg = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.Build.0 = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.ActiveCfg = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.Build.0 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityAddIns) = postSolution\r
+ GlobalSection(SolutionProperties) = preSolution\r
+ HideSolutionNode = FALSE\r
EndGlobalSection\r
EndGlobal\r
// methods of all these instances are treated the same. For items 0, 1, and
// 2, all methods resolve in C++. For item 3, our CEO, getTitle calls
// getPosition which resolves in C#. The call to getPosition is
- // slightly different, however, because of the overidden getPosition() call, since
+ // slightly different, however, because of the overridden getPosition() call, since
// now the object reference has been "laundered" by passing through
// EmployeeList as an Employee*. Previously, C# resolved the call
// immediately in CEO, but now C# thinks the object is an instance of
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
CSHARPSRCS = *.cs
-CSHARPFLAGS= -nologo -out:runme.exe
+CSHARPFLAGS= -nologo -debug+ -out:runme.exe
check: build
- $(MAKE) -f $(TOP)/Makefile csharp_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' csharp
- $(MAKE) -f $(TOP)/Makefile CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
clean:
- $(MAKE) -f $(TOP)/Makefile csharp_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_clean
-<VisualStudioProject>\r
- <CSHARP\r
- ProjectType = "Local"\r
- ProductVersion = "7.10.3077"\r
- SchemaVersion = "2.0"\r
- ProjectGuid = "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
- >\r
- <Build>\r
- <Settings\r
- ApplicationIcon = ""\r
- AssemblyKeyContainerName = ""\r
- AssemblyName = "runme"\r
- AssemblyOriginatorKeyFile = ""\r
- DefaultClientScript = "JScript"\r
- DefaultHTMLPageLayout = "Grid"\r
- DefaultTargetSchema = "IE50"\r
- DelaySign = "false"\r
- OutputType = "Exe"\r
- PreBuildEvent = ""\r
- PostBuildEvent = ""\r
- RootNamespace = "runme"\r
- RunPostBuildEvent = "OnBuildSuccess"\r
- StartupObject = ""\r
- >\r
- <Config\r
- Name = "Debug"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "DEBUG;TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "true"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "false"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- <Config\r
- Name = "Release"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "false"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "true"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- </Settings>\r
- <References/>\r
- </Build>\r
- <Files>\r
- <Include>\r
- <File\r
- RelPath = "example.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "examplePINVOKE.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "runme.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "SWIGTYPE_p_f_int_int__int.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- </Include>\r
- </Files>\r
- </CSHARP>\r
-</VisualStudioProject>\r
-\r
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <ProjectType>Local</ProjectType>\r
+ <ProductVersion>8.0.50727</ProductVersion>\r
+ <SchemaVersion>2.0</SchemaVersion>\r
+ <ProjectGuid>{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}</ProjectGuid>\r
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>\r
+ <Platform Condition=" '$(Platform)' == '' ">x86</Platform>\r
+ <ApplicationIcon>\r
+ </ApplicationIcon>\r
+ <AssemblyKeyContainerName>\r
+ </AssemblyKeyContainerName>\r
+ <AssemblyName>runme</AssemblyName>\r
+ <AssemblyOriginatorKeyFile>\r
+ </AssemblyOriginatorKeyFile>\r
+ <DefaultClientScript>JScript</DefaultClientScript>\r
+ <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>\r
+ <DefaultTargetSchema>IE50</DefaultTargetSchema>\r
+ <DelaySign>false</DelaySign>\r
+ <OutputType>Exe</OutputType>\r
+ <RootNamespace>runme</RootNamespace>\r
+ <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>\r
+ <StartupObject>\r
+ </StartupObject>\r
+ <FileUpgradeFlags>\r
+ </FileUpgradeFlags>\r
+ <UpgradeBackupLocation>\r
+ </UpgradeBackupLocation>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x86\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">\r
+ <OutputPath>bin\x86\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x64\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">\r
+ <OutputPath>bin\x64\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <Compile Include="example.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="examplePINVOKE.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="runme.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="SWIGTYPE_p_f_int_int__int.cs" />\r
+ </ItemGroup>\r
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />\r
+ <PropertyGroup>\r
+ <PreBuildEvent>\r
+ </PreBuildEvent>\r
+ <PostBuildEvent>copy runme.exe "$(SolutionDir)runme.exe"\r
+echo Run the example from the root directory $(SolutionDir) and ensure example.dll is also in this directory</PostBuildEvent>\r
+ </PropertyGroup>\r
+</Project>\r
<?xml version="1.0" encoding="Windows-1252"?>\r
<VisualStudioProject\r
ProjectType="Visual C++"\r
- Version="7.10"\r
+ Version="8.00"\r
Name="example"\r
ProjectGUID="{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- Keyword="Win32Proj">\r
+ Keyword="Win32Proj"\r
+ >\r
<Platforms>\r
<Platform\r
- Name="Win32"/>\r
+ Name="Win32"\r
+ />\r
+ <Platform\r
+ Name="x64"\r
+ />\r
</Platforms>\r
+ <ToolFiles>\r
+ </ToolFiles>\r
<Configurations>\r
<Configuration\r
Name="Debug|Win32"\r
- OutputDirectory="Debug"\r
- IntermediateDirectory="Debug"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
Optimization="0"\r
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
- MinimalRebuild="TRUE"\r
+ MinimalRebuild="true"\r
BasicRuntimeChecks="3"\r
RuntimeLibrary="1"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="4"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="4"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="2"\r
- GenerateDebugInformation="TRUE"\r
- ProgramDatabaseFile="$(OutDir)/example.pdb"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Debug|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCPreBuildEventTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
<Configuration\r
Name="Release|Win32"\r
- OutputDirectory="Release"\r
- IntermediateDirectory="Release"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
RuntimeLibrary="0"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="3"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="1"\r
- GenerateDebugInformation="TRUE"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
OptimizeReferences="2"\r
EnableCOMDATFolding="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
</Configurations>\r
<References>\r
<Filter\r
Name="Source Files"\r
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">\r
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
+ >\r
<File\r
- RelativePath=".\example.c">\r
+ RelativePath="example.c"\r
+ >\r
</File>\r
<File\r
- RelativePath=".\example_wrap.c">\r
+ RelativePath="example_wrap.c"\r
+ >\r
</File>\r
</Filter>\r
<Filter\r
Name="Header Files"\r
Filter="h;hpp;hxx;hm;inl;inc;xsd"\r
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">\r
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"\r
+ >\r
<File\r
- RelativePath=".\example.h">\r
+ RelativePath="example.h"\r
+ >\r
</File>\r
</Filter>\r
<File\r
- RelativePath=".\example.i">\r
+ RelativePath=".\example.i"\r
+ >\r
+ <FileConfiguration\r
+ Name="Debug|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Debug|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
+ </FileConfiguration>\r
<FileConfiguration\r
- Name="Debug|Win32">\r
+ Name="Release|Win32"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -csharp "$(InputPath)"\r
-@echo off\r
-"\r
- Outputs="$(InputName)_wrap.c"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
</FileConfiguration>\r
<FileConfiguration\r
- Name="Release|Win32">\r
+ Name="Release|x64"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -csharp "$(InputPath)"\r
-@echo off\r
-"\r
- Outputs="$(InputName)_wrap.c"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
</FileConfiguration>\r
</File>\r
</Files>\r
-Microsoft Visual Studio Solution File, Format Version 8.00\r
+Microsoft Visual Studio Solution File, Format Version 9.00\r
+# Visual Studio 2005\r
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "example-cs", "example-cs.csproj", "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
ProjectSection(ProjectDependencies) = postProject\r
{C2302635-D489-4678-96B4-70F5309DCBE6} = {C2302635-D489-4678-96B4-70F5309DCBE6}\r
EndProjectSection\r
EndProject\r
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example-vc", "example-vc.vcproj", "{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- ProjectSection(ProjectDependencies) = postProject\r
- EndProjectSection\r
EndProject\r
Global\r
- GlobalSection(SolutionConfiguration) = preSolution\r
- Debug = Debug\r
- Release = Release\r
- EndGlobalSection\r
- GlobalSection(ProjectConfiguration) = postSolution\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.ActiveCfg = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.Build.0 = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.ActiveCfg = Release|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.Build.0 = Release|.NET\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.ActiveCfg = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.Build.0 = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.ActiveCfg = Release|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.Build.0 = Release|Win32\r
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
+ Debug|Win32 = Debug|Win32\r
+ Debug|x64 = Debug|x64\r
+ Release|Win32 = Release|Win32\r
+ Release|x64 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityGlobals) = postSolution\r
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.ActiveCfg = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.Build.0 = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.Build.0 = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.ActiveCfg = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.Build.0 = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.ActiveCfg = Release|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.Build.0 = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.ActiveCfg = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.Build.0 = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.Build.0 = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.ActiveCfg = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.Build.0 = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.ActiveCfg = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.Build.0 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityAddIns) = postSolution\r
+ GlobalSection(SolutionProperties) = preSolution\r
+ HideSolutionNode = FALSE\r
EndGlobalSection\r
EndGlobal\r
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS = example.cxx
+TARGET = example
+INTERFACE = example.i
+SWIGOPT =
+CSHARPSRCS = *.cs
+CSHARPFLAGS= -nologo -debug+ -out:runme.exe
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' csharp_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_clean
--- /dev/null
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <ProjectType>Local</ProjectType>\r
+ <ProductVersion>8.0.50727</ProductVersion>\r
+ <SchemaVersion>2.0</SchemaVersion>\r
+ <ProjectGuid>{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}</ProjectGuid>\r
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>\r
+ <Platform Condition=" '$(Platform)' == '' ">x86</Platform>\r
+ <ApplicationIcon>\r
+ </ApplicationIcon>\r
+ <AssemblyKeyContainerName>\r
+ </AssemblyKeyContainerName>\r
+ <AssemblyName>runme</AssemblyName>\r
+ <AssemblyOriginatorKeyFile>\r
+ </AssemblyOriginatorKeyFile>\r
+ <DefaultClientScript>JScript</DefaultClientScript>\r
+ <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>\r
+ <DefaultTargetSchema>IE50</DefaultTargetSchema>\r
+ <DelaySign>false</DelaySign>\r
+ <OutputType>Exe</OutputType>\r
+ <RootNamespace>runme</RootNamespace>\r
+ <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>\r
+ <StartupObject>\r
+ </StartupObject>\r
+ <FileUpgradeFlags>\r
+ </FileUpgradeFlags>\r
+ <UpgradeBackupLocation>\r
+ </UpgradeBackupLocation>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x86\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">\r
+ <OutputPath>bin\x86\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x64\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">\r
+ <OutputPath>bin\x64\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <Compile Include="example.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="examplePINVOKE.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="runme.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="MotorCar.cs" />\r
+ </ItemGroup>\r
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />\r
+ <PropertyGroup>\r
+ <PreBuildEvent>\r
+ </PreBuildEvent>\r
+ <PostBuildEvent>copy runme.exe "$(SolutionDir)runme.exe"\r
+echo Run the example from the root directory $(SolutionDir) and ensure example.dll is also in this directory</PostBuildEvent>\r
+ </PropertyGroup>\r
+</Project>\r
--- /dev/null
+<?xml version="1.0" encoding="Windows-1252"?>\r
+<VisualStudioProject\r
+ ProjectType="Visual C++"\r
+ Version="8.00"\r
+ Name="example"\r
+ ProjectGUID="{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
+ Keyword="Win32Proj"\r
+ >\r
+ <Platforms>\r
+ <Platform\r
+ Name="Win32"\r
+ />\r
+ <Platform\r
+ Name="x64"\r
+ />\r
+ </Platforms>\r
+ <ToolFiles>\r
+ </ToolFiles>\r
+ <Configurations>\r
+ <Configuration\r
+ Name="Debug|Win32"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="4"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Debug|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|Win32"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ </Configurations>\r
+ <References>\r
+ </References>\r
+ <Files>\r
+ <Filter\r
+ Name="Source Files"\r
+ Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
+ >\r
+ <File\r
+ RelativePath="example.cxx"\r
+ >\r
+ </File>\r
+ <File\r
+ RelativePath="example_wrap.cxx"\r
+ >\r
+ </File>\r
+ </Filter>\r
+ <Filter\r
+ Name="Header Files"\r
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"\r
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"\r
+ >\r
+ <File\r
+ RelativePath="example.h"\r
+ >\r
+ </File>\r
+ </Filter>\r
+ <File\r
+ RelativePath=".\example.i"\r
+ >\r
+ <FileConfiguration\r
+ Name="Debug|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Debug|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Release|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Release|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
+ </File>\r
+ </Files>\r
+ <Globals>\r
+ </Globals>\r
+</VisualStudioProject>\r
--- /dev/null
+#include "example.h"
+
+int MotorCar::DesignOpinion::AceDesignCount = 0;
+int MotorCar::DesignOpinion::TotalDesignCount = 0;
+
+int MotorCar::DesignOpinion::PercentScore() {
+ return AceDesignCount*100/TotalDesignCount;
+}
+
+MotorCar::Wheels::Wheels(Shape shape, size_t count) : shape(shape), count(count) {}
+
+MotorCar::WindScreen::WindScreen(bool opaque) : opaque(opaque) {}
+
+MotorCar::MotorCar(const std::string &name, const Wheels &wheels, const WindScreen &windscreen) : name(name), wheels(wheels), windscreen(windscreen) {}
+
+MotorCar MotorCar::DesignFromComponents(const std::string &name, const Wheels &wheels, const WindScreen &windscreen) {
+ MotorCar car = MotorCar(name, wheels, windscreen);
+ DesignOpinion::TotalDesignCount++;
+ if (car.wheels.Opinion().itrocks && car.windscreen.Opinion().itrocks)
+ DesignOpinion::AceDesignCount++;
+ return car;
+}
+
+MotorCar::DesignOpinion MotorCar::Wheels::Opinion() {
+ DesignOpinion opinion;
+ opinion.itrocks = true;
+ if (shape == Square) {
+ opinion.itrocks = false;
+ opinion.reason = "you'll have a few issues with wheel rotation";
+ }
+ if (count <= 2) {
+ opinion.reason += opinion.itrocks ? "" : " and ";
+ opinion.itrocks = false;
+ opinion.reason += "a few more wheels are needed for stability";
+ }
+ if (opinion.itrocks)
+ opinion.reason = "your choice of wheels was top notch";
+
+ return opinion;
+}
+
+MotorCar::DesignOpinion MotorCar::WindScreen::Opinion() {
+ DesignOpinion opinion;
+ opinion.itrocks = !opaque;
+ opinion.reason = opinion.itrocks ? "the driver will have a commanding view out the window" : "you can't see out the windscreen";
+ return opinion;
+}
+
+std::string MotorCar::WillItWork() {
+ DesignOpinion wh = wheels.Opinion();
+ DesignOpinion ws = windscreen.Opinion();
+ std::string willit;
+ if (wh.itrocks && ws.itrocks) {
+ willit = "Great car design because " + wh.reason + " and " + ws.reason;
+ } else {
+ willit = "You need a rethink because ";
+ willit += wh.itrocks ? "" : wh.reason;
+ willit += (!wh.itrocks && !ws.itrocks) ? " and " : "";
+ willit += ws.itrocks ? "" : ws.reason;
+ }
+ return willit;
+}
--- /dev/null
+#include <string>
+
+/** Design a motor car from various components */
+struct MotorCar {
+
+ /** Information about an opinion of the design of a car component */
+ struct DesignOpinion {
+ bool itrocks;
+ std::string reason;
+ static int AceDesignCount;
+ static int TotalDesignCount;
+ static int PercentScore();
+ };
+
+ /** Wheels component */
+ struct Wheels {
+ enum Shape { Round, Square };
+ Wheels(Shape shape, size_t count);
+ DesignOpinion Opinion();
+ private:
+ Shape shape;
+ size_t count;
+ };
+
+ /** Windscreen component */
+ struct WindScreen {
+ WindScreen(bool opaque);
+ DesignOpinion Opinion();
+ private:
+ bool opaque;
+ };
+
+ /** Factory method for creating a car */
+ static MotorCar DesignFromComponents(const std::string &name, const Wheels &wheels, const WindScreen &windscreen);
+
+ std::string Name() {
+ return name;
+ }
+
+ /** Get an overall opinion on the car design */
+ std::string WillItWork();
+
+private:
+ MotorCar(const std::string &name, const Wheels &wheels, const WindScreen &windscreen);
+ std::string name;
+ Wheels wheels;
+ WindScreen windscreen;
+};
--- /dev/null
+%module example
+
+// This example shows how wrappers for numerous aspects of C++ nested classes work:
+// Nested static and instance variables and methods and nested enums
+
+%include <std_string.i>
+
+%{
+#include "example.h"
+%}
+
+%include "example.h"
+
--- /dev/null
+Microsoft Visual Studio Solution File, Format Version 9.00\r
+# Visual Studio 2005\r
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "example-cs", "example-cs.csproj", "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
+ ProjectSection(ProjectDependencies) = postProject\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6} = {C2302635-D489-4678-96B4-70F5309DCBE6}\r
+ EndProjectSection\r
+EndProject\r
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example-vc", "example-vc.vcproj", "{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
+EndProject\r
+Global\r
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
+ Debug|Win32 = Debug|Win32\r
+ Debug|x64 = Debug|x64\r
+ Release|Win32 = Release|Win32\r
+ Release|x64 = Release|x64\r
+ EndGlobalSection\r
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.ActiveCfg = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.Build.0 = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.Build.0 = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.ActiveCfg = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.Build.0 = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.ActiveCfg = Release|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.Build.0 = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.ActiveCfg = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.Build.0 = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.Build.0 = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.ActiveCfg = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.Build.0 = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.ActiveCfg = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.Build.0 = Release|x64\r
+ EndGlobalSection\r
+ GlobalSection(SolutionProperties) = preSolution\r
+ HideSolutionNode = FALSE\r
+ EndGlobalSection\r
+EndGlobal\r
--- /dev/null
+// This example illustrates how C++ classes can be used from C# using SWIG.
+// The C# class gets mapped onto the C++ class and behaves as if it is a C# class.
+
+using System;
+
+public class runme
+{
+ static void Main()
+ {
+ MotorCar car1 = MotorCar.DesignFromComponents("Bumpy", new MotorCar.Wheels(MotorCar.Wheels.Shape.Square, 4), new MotorCar.WindScreen(false));
+ MotorCar car2 = MotorCar.DesignFromComponents("Wobbly", new MotorCar.Wheels(MotorCar.Wheels.Shape.Round, 2), new MotorCar.WindScreen(false));
+ MotorCar car3 = MotorCar.DesignFromComponents("Batty", new MotorCar.Wheels(MotorCar.Wheels.Shape.Round, 4), new MotorCar.WindScreen(true));
+ MotorCar car4 = MotorCar.DesignFromComponents("Spiffing", new MotorCar.Wheels(MotorCar.Wheels.Shape.Round, 4), new MotorCar.WindScreen(false));
+
+ Console.WriteLine("Expert opinion on " + car1.Name() + " : \n " + car1.WillItWork());
+ Console.WriteLine("Expert opinion on " + car2.Name() + " : \n " + car2.WillItWork());
+ Console.WriteLine("Expert opinion on " + car3.Name() + " : \n " + car3.WillItWork());
+ Console.WriteLine("Expert opinion on " + car4.Name() + " : \n " + car4.WillItWork());
+
+ int count = MotorCar.DesignOpinion.AceDesignCount;
+ int total = MotorCar.DesignOpinion.TotalDesignCount;
+ int percent = MotorCar.DesignOpinion.PercentScore();
+ Console.WriteLine("Overall opinion rating on car design is " + count + "/" + total + " = " + percent + "%");
+
+ Console.WriteLine("Single square wheel thoughts: " + new MotorCar.Wheels(MotorCar.Wheels.Shape.Square, 1).Opinion().reason);
+ }
+}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
CSHARPSRCS = *.cs
-CSHARPFLAGS= -nologo -out:runme.exe
+CSHARPFLAGS= -nologo -debug+ -out:runme.exe
check: build
- $(MAKE) -f $(TOP)/Makefile csharp_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' csharp_cpp
- $(MAKE) -f $(TOP)/Makefile CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
clean:
- $(MAKE) -f $(TOP)/Makefile csharp_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_clean
-<VisualStudioProject>\r
- <CSHARP\r
- ProjectType = "Local"\r
- ProductVersion = "7.10.3077"\r
- SchemaVersion = "2.0"\r
- ProjectGuid = "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
- >\r
- <Build>\r
- <Settings\r
- ApplicationIcon = ""\r
- AssemblyKeyContainerName = ""\r
- AssemblyName = "runme"\r
- AssemblyOriginatorKeyFile = ""\r
- DefaultClientScript = "JScript"\r
- DefaultHTMLPageLayout = "Grid"\r
- DefaultTargetSchema = "IE50"\r
- DelaySign = "false"\r
- OutputType = "Exe"\r
- PreBuildEvent = ""\r
- PostBuildEvent = ""\r
- RootNamespace = "runme"\r
- RunPostBuildEvent = "OnBuildSuccess"\r
- StartupObject = ""\r
- >\r
- <Config\r
- Name = "Debug"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "DEBUG;TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "true"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "false"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- <Config\r
- Name = "Release"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "false"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "true"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- </Settings>\r
- <References/>\r
- </Build>\r
- <Files>\r
- <Include>\r
- <File\r
- RelPath = "example.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "examplePINVOKE.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "runme.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "Vector.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "VectorArray.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- </Include>\r
- </Files>\r
- </CSHARP>\r
-</VisualStudioProject>\r
-\r
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <ProjectType>Local</ProjectType>\r
+ <ProductVersion>8.0.50727</ProductVersion>\r
+ <SchemaVersion>2.0</SchemaVersion>\r
+ <ProjectGuid>{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}</ProjectGuid>\r
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>\r
+ <Platform Condition=" '$(Platform)' == '' ">x86</Platform>\r
+ <ApplicationIcon>\r
+ </ApplicationIcon>\r
+ <AssemblyKeyContainerName>\r
+ </AssemblyKeyContainerName>\r
+ <AssemblyName>runme</AssemblyName>\r
+ <AssemblyOriginatorKeyFile>\r
+ </AssemblyOriginatorKeyFile>\r
+ <DefaultClientScript>JScript</DefaultClientScript>\r
+ <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>\r
+ <DefaultTargetSchema>IE50</DefaultTargetSchema>\r
+ <DelaySign>false</DelaySign>\r
+ <OutputType>Exe</OutputType>\r
+ <RootNamespace>runme</RootNamespace>\r
+ <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>\r
+ <StartupObject>\r
+ </StartupObject>\r
+ <FileUpgradeFlags>\r
+ </FileUpgradeFlags>\r
+ <UpgradeBackupLocation>\r
+ </UpgradeBackupLocation>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x86\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">\r
+ <OutputPath>bin\x86\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x64\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">\r
+ <OutputPath>bin\x64\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <Compile Include="example.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="examplePINVOKE.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="runme.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="Vector.cs" />\r
+ <Compile Include="VectorArray.cs" />\r
+ </ItemGroup>\r
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />\r
+ <PropertyGroup>\r
+ <PreBuildEvent>\r
+ </PreBuildEvent>\r
+ <PostBuildEvent>copy runme.exe "$(SolutionDir)runme.exe"\r
+echo Run the example from the root directory $(SolutionDir) and ensure example.dll is also in this directory</PostBuildEvent>\r
+ </PropertyGroup>\r
+</Project>\r
<?xml version="1.0" encoding="Windows-1252"?>\r
<VisualStudioProject\r
ProjectType="Visual C++"\r
- Version="7.10"\r
+ Version="8.00"\r
Name="example"\r
ProjectGUID="{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- Keyword="Win32Proj">\r
+ Keyword="Win32Proj"\r
+ >\r
<Platforms>\r
<Platform\r
- Name="Win32"/>\r
+ Name="Win32"\r
+ />\r
+ <Platform\r
+ Name="x64"\r
+ />\r
</Platforms>\r
+ <ToolFiles>\r
+ </ToolFiles>\r
<Configurations>\r
<Configuration\r
Name="Debug|Win32"\r
- OutputDirectory="Debug"\r
- IntermediateDirectory="Debug"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
Optimization="0"\r
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
- MinimalRebuild="TRUE"\r
+ MinimalRebuild="true"\r
BasicRuntimeChecks="3"\r
RuntimeLibrary="1"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="4"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="4"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="2"\r
- GenerateDebugInformation="TRUE"\r
- ProgramDatabaseFile="$(OutDir)/example.pdb"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Debug|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCPreBuildEventTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
<Configuration\r
Name="Release|Win32"\r
- OutputDirectory="Release"\r
- IntermediateDirectory="Release"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
RuntimeLibrary="0"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="3"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="1"\r
- GenerateDebugInformation="TRUE"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
OptimizeReferences="2"\r
EnableCOMDATFolding="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
</Configurations>\r
<References>\r
<Filter\r
Name="Source Files"\r
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">\r
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
+ >\r
<File\r
- RelativePath="example.cxx">\r
+ RelativePath="example.cxx"\r
+ >\r
</File>\r
<File\r
- RelativePath="example_wrap.cxx">\r
+ RelativePath="example_wrap.cxx"\r
+ >\r
</File>\r
</Filter>\r
<Filter\r
Name="Header Files"\r
Filter="h;hpp;hxx;hm;inl;inc;xsd"\r
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">\r
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"\r
+ >\r
<File\r
- RelativePath="example.h">\r
+ RelativePath="example.h"\r
+ >\r
</File>\r
</Filter>\r
<File\r
- RelativePath=".\example.i">\r
+ RelativePath=".\example.i"\r
+ >\r
+ <FileConfiguration\r
+ Name="Debug|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Debug|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
<FileConfiguration\r
- Name="Debug|Win32">\r
+ Name="Release|Win32"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -c++ -csharp "$(InputPath)"\r
-@echo off"\r
- Outputs="$(InputName)_wrap.cxx"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
</FileConfiguration>\r
<FileConfiguration\r
- Name="Release|Win32">\r
+ Name="Release|x64"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -c++ -csharp "$(InputPath)"\r
-@echo off"\r
- Outputs="$(InputName)_wrap.cxx"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
</FileConfiguration>\r
</File>\r
</Files>\r
char *Vector::print() {
static char temp[512];
- sprintf(temp,"Vector %p (%g,%g,%g)", this, x,y,z);
+ sprintf(temp,"Vector %p (%g,%g,%g)", (void *)this, x,y,z);
return temp;
}
private:
double x,y,z;
public:
- Vector() : x(0), y(0), z(0) { };
- Vector(double x, double y, double z) : x(x), y(y), z(z) { };
+ Vector() : x(0), y(0), z(0) { }
+ Vector(double x, double y, double z) : x(x), y(y), z(z) { }
friend Vector operator+(const Vector &a, const Vector &b);
char *print();
};
Vector &operator[](int);
int size();
};
-
-
-
-
VectorArray(int maxsize);
~VectorArray();
int size();
-
+
/* This wrapper provides an alternative to the [] operator */
%extend {
Vector &get(int index) {
}
}
};
-
-
-
-
-Microsoft Visual Studio Solution File, Format Version 8.00\r
+Microsoft Visual Studio Solution File, Format Version 9.00\r
+# Visual Studio 2005\r
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "example-cs", "example-cs.csproj", "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
ProjectSection(ProjectDependencies) = postProject\r
{C2302635-D489-4678-96B4-70F5309DCBE6} = {C2302635-D489-4678-96B4-70F5309DCBE6}\r
EndProjectSection\r
EndProject\r
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example-vc", "example-vc.vcproj", "{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- ProjectSection(ProjectDependencies) = postProject\r
- EndProjectSection\r
EndProject\r
Global\r
- GlobalSection(SolutionConfiguration) = preSolution\r
- Debug = Debug\r
- Release = Release\r
- EndGlobalSection\r
- GlobalSection(ProjectConfiguration) = postSolution\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.ActiveCfg = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.Build.0 = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.ActiveCfg = Release|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.Build.0 = Release|.NET\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.ActiveCfg = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.Build.0 = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.ActiveCfg = Release|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.Build.0 = Release|Win32\r
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
+ Debug|Win32 = Debug|Win32\r
+ Debug|x64 = Debug|x64\r
+ Release|Win32 = Release|Win32\r
+ Release|x64 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityGlobals) = postSolution\r
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.ActiveCfg = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.Build.0 = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.Build.0 = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.ActiveCfg = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.Build.0 = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.ActiveCfg = Release|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.Build.0 = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.ActiveCfg = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.Build.0 = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.Build.0 = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.ActiveCfg = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.Build.0 = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.ActiveCfg = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.Build.0 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityAddIns) = postSolution\r
+ GlobalSection(SolutionProperties) = preSolution\r
+ HideSolutionNode = FALSE\r
EndGlobalSection\r
EndGlobal\r
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
CSHARPSRCS = *.cs
-CSHARPFLAGS= -nologo -out:runme.exe
+CSHARPFLAGS= -nologo -debug+ -out:runme.exe
check: build
- $(MAKE) -f $(TOP)/Makefile csharp_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' csharp
- $(MAKE) -f $(TOP)/Makefile CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
clean:
- $(MAKE) -f $(TOP)/Makefile csharp_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_clean
-<VisualStudioProject>\r
- <CSHARP\r
- ProjectType = "Local"\r
- ProductVersion = "7.10.3077"\r
- SchemaVersion = "2.0"\r
- ProjectGuid = "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
- >\r
- <Build>\r
- <Settings\r
- ApplicationIcon = ""\r
- AssemblyKeyContainerName = ""\r
- AssemblyName = "runme"\r
- AssemblyOriginatorKeyFile = ""\r
- DefaultClientScript = "JScript"\r
- DefaultHTMLPageLayout = "Grid"\r
- DefaultTargetSchema = "IE50"\r
- DelaySign = "false"\r
- OutputType = "Exe"\r
- PreBuildEvent = ""\r
- PostBuildEvent = ""\r
- RootNamespace = "runme"\r
- RunPostBuildEvent = "OnBuildSuccess"\r
- StartupObject = ""\r
- >\r
- <Config\r
- Name = "Debug"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "DEBUG;TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "true"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "false"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- <Config\r
- Name = "Release"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "false"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "true"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- </Settings>\r
- <References/>\r
- </Build>\r
- <Files>\r
- <Include>\r
- <File\r
- RelPath = "example.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "examplePINVOKE.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "runme.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- </Include>\r
- </Files>\r
- </CSHARP>\r
-</VisualStudioProject>\r
-\r
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <ProjectType>Local</ProjectType>\r
+ <ProductVersion>8.0.50727</ProductVersion>\r
+ <SchemaVersion>2.0</SchemaVersion>\r
+ <ProjectGuid>{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}</ProjectGuid>\r
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>\r
+ <Platform Condition=" '$(Platform)' == '' ">x86</Platform>\r
+ <ApplicationIcon>\r
+ </ApplicationIcon>\r
+ <AssemblyKeyContainerName>\r
+ </AssemblyKeyContainerName>\r
+ <AssemblyName>runme</AssemblyName>\r
+ <AssemblyOriginatorKeyFile>\r
+ </AssemblyOriginatorKeyFile>\r
+ <DefaultClientScript>JScript</DefaultClientScript>\r
+ <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>\r
+ <DefaultTargetSchema>IE50</DefaultTargetSchema>\r
+ <DelaySign>false</DelaySign>\r
+ <OutputType>Exe</OutputType>\r
+ <RootNamespace>runme</RootNamespace>\r
+ <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>\r
+ <StartupObject>\r
+ </StartupObject>\r
+ <FileUpgradeFlags>\r
+ </FileUpgradeFlags>\r
+ <UpgradeBackupLocation>\r
+ </UpgradeBackupLocation>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x86\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">\r
+ <OutputPath>bin\x86\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x64\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">\r
+ <OutputPath>bin\x64\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <Compile Include="example.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="examplePINVOKE.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="runme.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ </ItemGroup>\r
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />\r
+ <PropertyGroup>\r
+ <PreBuildEvent>\r
+ </PreBuildEvent>\r
+ <PostBuildEvent>copy runme.exe "$(SolutionDir)runme.exe"\r
+echo Run the example from the root directory $(SolutionDir) and ensure example.dll is also in this directory</PostBuildEvent>\r
+ </PropertyGroup>\r
+</Project>\r
<Platform\r
Name="Win32"\r
/>\r
+ <Platform\r
+ Name="x64"\r
+ />\r
</Platforms>\r
<ToolFiles>\r
</ToolFiles>\r
<Configurations>\r
<Configuration\r
Name="Debug|Win32"\r
- OutputDirectory="Debug"\r
- IntermediateDirectory="Debug"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
CharacterSet="2"\r
/>\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="2"\r
GenerateDebugInformation="true"\r
- ProgramDatabaseFile="$(OutDir)/example.pdb"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
TargetMachine="1"\r
/>\r
<Tool\r
/>\r
<Tool\r
Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Debug|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
/>\r
</Configuration>\r
<Configuration\r
Name="Release|Win32"\r
- OutputDirectory="Release"\r
- IntermediateDirectory="Release"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
CharacterSet="2"\r
/>\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="1"\r
GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
OptimizeReferences="2"\r
EnableCOMDATFolding="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
TargetMachine="1"\r
/>\r
<Tool\r
/>\r
<Tool\r
Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
/>\r
</Configuration>\r
</Configurations>\r
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
>\r
<File\r
- RelativePath=".\example.c"\r
+ RelativePath="example.c"\r
>\r
</File>\r
<File\r
- RelativePath=".\example_wrap.c"\r
+ RelativePath="example_wrap.c"\r
>\r
</File>\r
</Filter>\r
/>\r
</FileConfiguration>\r
<FileConfiguration\r
+ Name="Debug|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
Name="Release|Win32"\r
>\r
<Tool\r
Outputs="$(InputName)_wrap.c"\r
/>\r
</FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Release|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
+ </FileConfiguration>\r
</File>\r
</Files>\r
<Globals>\r
Microsoft Visual Studio Solution File, Format Version 9.00\r
-# Visual C++ Express 2005\r
+# Visual Studio 2005\r
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "example-cs", "example-cs.csproj", "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
ProjectSection(ProjectDependencies) = postProject\r
{C2302635-D489-4678-96B4-70F5309DCBE6} = {C2302635-D489-4678-96B4-70F5309DCBE6}\r
Global\r
GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
Debug|Win32 = Debug|Win32\r
+ Debug|x64 = Debug|x64\r
Release|Win32 = Release|Win32\r
+ Release|x64 = Release|x64\r
EndGlobalSection\r
GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.ActiveCfg = Debug|Any CPU\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.ActiveCfg = Release|Any CPU\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.ActiveCfg = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.Build.0 = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.Build.0 = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.ActiveCfg = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.Build.0 = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.ActiveCfg = Release|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.Build.0 = Release|x64\r
{C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.ActiveCfg = Debug|Win32\r
{C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.Build.0 = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.Build.0 = Debug|x64\r
{C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.ActiveCfg = Release|Win32\r
{C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.Build.0 = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.ActiveCfg = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.Build.0 = Release|x64\r
EndGlobalSection\r
GlobalSection(SolutionProperties) = preSolution\r
HideSolutionNode = FALSE\r
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT =
CSHARPSRCS = *.cs
-CSHARPFLAGS= -nologo -out:runme.exe
+CSHARPFLAGS= -nologo -debug+ -out:runme.exe
check: build
- $(MAKE) -f $(TOP)/Makefile csharp_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' csharp_cpp
- $(MAKE) -f $(TOP)/Makefile CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
clean:
- $(MAKE) -f $(TOP)/Makefile csharp_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_clean
-<VisualStudioProject>\r
- <CSHARP\r
- ProjectType = "Local"\r
- ProductVersion = "7.10.3077"\r
- SchemaVersion = "2.0"\r
- ProjectGuid = "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
- >\r
- <Build>\r
- <Settings\r
- ApplicationIcon = ""\r
- AssemblyKeyContainerName = ""\r
- AssemblyName = "runme"\r
- AssemblyOriginatorKeyFile = ""\r
- DefaultClientScript = "JScript"\r
- DefaultHTMLPageLayout = "Grid"\r
- DefaultTargetSchema = "IE50"\r
- DelaySign = "false"\r
- OutputType = "Exe"\r
- PreBuildEvent = ""\r
- PostBuildEvent = ""\r
- RootNamespace = "runme"\r
- RunPostBuildEvent = "OnBuildSuccess"\r
- StartupObject = ""\r
- >\r
- <Config\r
- Name = "Debug"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "DEBUG;TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "true"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "false"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- <Config\r
- Name = "Release"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "false"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "true"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- </Settings>\r
- <References/>\r
- </Build>\r
- <Files>\r
- <Include>\r
- <File\r
- RelPath = "example.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "examplePINVOKE.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "runme.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "SWIGTYPE_p_double.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "SWIGTYPE_p_int.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "vecdouble.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "vecint.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- </Include>\r
- </Files>\r
- </CSHARP>\r
-</VisualStudioProject>\r
-\r
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <ProjectType>Local</ProjectType>\r
+ <ProductVersion>8.0.50727</ProductVersion>\r
+ <SchemaVersion>2.0</SchemaVersion>\r
+ <ProjectGuid>{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}</ProjectGuid>\r
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>\r
+ <Platform Condition=" '$(Platform)' == '' ">x86</Platform>\r
+ <ApplicationIcon>\r
+ </ApplicationIcon>\r
+ <AssemblyKeyContainerName>\r
+ </AssemblyKeyContainerName>\r
+ <AssemblyName>runme</AssemblyName>\r
+ <AssemblyOriginatorKeyFile>\r
+ </AssemblyOriginatorKeyFile>\r
+ <DefaultClientScript>JScript</DefaultClientScript>\r
+ <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>\r
+ <DefaultTargetSchema>IE50</DefaultTargetSchema>\r
+ <DelaySign>false</DelaySign>\r
+ <OutputType>Exe</OutputType>\r
+ <RootNamespace>runme</RootNamespace>\r
+ <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>\r
+ <StartupObject>\r
+ </StartupObject>\r
+ <FileUpgradeFlags>\r
+ </FileUpgradeFlags>\r
+ <UpgradeBackupLocation>\r
+ </UpgradeBackupLocation>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x86\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">\r
+ <OutputPath>bin\x86\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x64\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">\r
+ <OutputPath>bin\x64\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <Compile Include="example.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="examplePINVOKE.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="runme.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="SWIGTYPE_p_double.cs" />\r
+ <Compile Include="SWIGTYPE_p_int.cs" />\r
+ <Compile Include="vecdouble.cs" />\r
+ <Compile Include="vecint.cs" />\r
+ </ItemGroup>\r
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />\r
+ <PropertyGroup>\r
+ <PreBuildEvent>\r
+ </PreBuildEvent>\r
+ <PostBuildEvent>copy runme.exe "$(SolutionDir)runme.exe"\r
+echo Run the example from the root directory $(SolutionDir) and ensure example.dll is also in this directory</PostBuildEvent>\r
+ </PropertyGroup>\r
+</Project>\r
<?xml version="1.0" encoding="Windows-1252"?>\r
<VisualStudioProject\r
ProjectType="Visual C++"\r
- Version="7.10"\r
+ Version="8.00"\r
Name="example"\r
ProjectGUID="{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- Keyword="Win32Proj">\r
+ Keyword="Win32Proj"\r
+ >\r
<Platforms>\r
<Platform\r
- Name="Win32"/>\r
+ Name="Win32"\r
+ />\r
+ <Platform\r
+ Name="x64"\r
+ />\r
</Platforms>\r
+ <ToolFiles>\r
+ </ToolFiles>\r
<Configurations>\r
<Configuration\r
Name="Debug|Win32"\r
- OutputDirectory="Debug"\r
- IntermediateDirectory="Debug"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
Optimization="0"\r
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
- MinimalRebuild="TRUE"\r
+ MinimalRebuild="true"\r
BasicRuntimeChecks="3"\r
RuntimeLibrary="1"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="4"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="4"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="2"\r
- GenerateDebugInformation="TRUE"\r
- ProgramDatabaseFile="$(OutDir)/example.pdb"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Debug|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCPreBuildEventTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
<Configuration\r
Name="Release|Win32"\r
- OutputDirectory="Release"\r
- IntermediateDirectory="Release"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
RuntimeLibrary="0"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="3"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="1"\r
- GenerateDebugInformation="TRUE"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
OptimizeReferences="2"\r
EnableCOMDATFolding="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
</Configurations>\r
<References>\r
<Filter\r
Name="Source Files"\r
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">\r
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
+ >\r
<File\r
- RelativePath="example_wrap.cxx">\r
+ RelativePath="example_wrap.cxx"\r
+ >\r
</File>\r
</Filter>\r
<Filter\r
Name="Header Files"\r
Filter="h;hpp;hxx;hm;inl;inc;xsd"\r
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">\r
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"\r
+ >\r
<File\r
- RelativePath="example.h">\r
+ RelativePath="example.h"\r
+ >\r
</File>\r
</Filter>\r
<File\r
- RelativePath=".\example.i">\r
+ RelativePath=".\example.i"\r
+ >\r
+ <FileConfiguration\r
+ Name="Debug|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Debug|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
+ </FileConfiguration>\r
<FileConfiguration\r
- Name="Debug|Win32">\r
+ Name="Release|Win32"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -c++ -csharp "$(InputPath)"\r
-@echo off\r
-"\r
- Outputs="$(InputName)_wrap.cxx"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
</FileConfiguration>\r
<FileConfiguration\r
- Name="Release|Win32">\r
+ Name="Release|x64"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -c++ -csharp "$(InputPath)"\r
-@echo off\r
-"\r
- Outputs="$(InputName)_wrap.cxx"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -c++ -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.cxx"\r
+ />\r
</FileConfiguration>\r
</File>\r
</Files>\r
-Microsoft Visual Studio Solution File, Format Version 8.00\r
+Microsoft Visual Studio Solution File, Format Version 9.00\r
+# Visual Studio 2005\r
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "example-cs", "example-cs.csproj", "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
ProjectSection(ProjectDependencies) = postProject\r
{C2302635-D489-4678-96B4-70F5309DCBE6} = {C2302635-D489-4678-96B4-70F5309DCBE6}\r
EndProjectSection\r
EndProject\r
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example-vc", "example-vc.vcproj", "{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- ProjectSection(ProjectDependencies) = postProject\r
- EndProjectSection\r
EndProject\r
Global\r
- GlobalSection(SolutionConfiguration) = preSolution\r
- Debug = Debug\r
- Release = Release\r
- EndGlobalSection\r
- GlobalSection(ProjectConfiguration) = postSolution\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.ActiveCfg = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.Build.0 = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.ActiveCfg = Release|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.Build.0 = Release|.NET\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.ActiveCfg = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.Build.0 = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.ActiveCfg = Release|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.Build.0 = Release|Win32\r
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
+ Debug|Win32 = Debug|Win32\r
+ Debug|x64 = Debug|x64\r
+ Release|Win32 = Release|Win32\r
+ Release|x64 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityGlobals) = postSolution\r
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.ActiveCfg = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.Build.0 = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.Build.0 = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.ActiveCfg = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.Build.0 = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.ActiveCfg = Release|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.Build.0 = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.ActiveCfg = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.Build.0 = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.Build.0 = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.ActiveCfg = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.Build.0 = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.ActiveCfg = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.Build.0 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityAddIns) = postSolution\r
+ GlobalSection(SolutionProperties) = preSolution\r
+ HideSolutionNode = FALSE\r
EndGlobalSection\r
EndGlobal\r
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
CSHARPSRCS = *.cs
-CSHARPFLAGS= -nologo -out:runme.exe
+CSHARPFLAGS= -nologo -debug+ -out:runme.exe
check: build
- $(MAKE) -f $(TOP)/Makefile csharp_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' csharp
- $(MAKE) -f $(TOP)/Makefile CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CSHARPSRCS='$(CSHARPSRCS)' CSHARPFLAGS='$(CSHARPFLAGS)' csharp_compile
clean:
- $(MAKE) -f $(TOP)/Makefile csharp_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' csharp_clean
-<VisualStudioProject>\r
- <CSHARP\r
- ProjectType = "Local"\r
- ProductVersion = "7.10.3077"\r
- SchemaVersion = "2.0"\r
- ProjectGuid = "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
- >\r
- <Build>\r
- <Settings\r
- ApplicationIcon = ""\r
- AssemblyKeyContainerName = ""\r
- AssemblyName = "runme"\r
- AssemblyOriginatorKeyFile = ""\r
- DefaultClientScript = "JScript"\r
- DefaultHTMLPageLayout = "Grid"\r
- DefaultTargetSchema = "IE50"\r
- DelaySign = "false"\r
- OutputType = "Exe"\r
- PreBuildEvent = ""\r
- PostBuildEvent = ""\r
- RootNamespace = "runme"\r
- RunPostBuildEvent = "OnBuildSuccess"\r
- StartupObject = ""\r
- >\r
- <Config\r
- Name = "Debug"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "DEBUG;TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "true"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "false"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- <Config\r
- Name = "Release"\r
- AllowUnsafeBlocks = "false"\r
- BaseAddress = "285212672"\r
- CheckForOverflowUnderflow = "false"\r
- ConfigurationOverrideFile = ""\r
- DefineConstants = "TRACE"\r
- DocumentationFile = ""\r
- DebugSymbols = "false"\r
- FileAlignment = "4096"\r
- IncrementalBuild = "false"\r
- NoStdLib = "false"\r
- NoWarn = ""\r
- Optimize = "true"\r
- OutputPath = ".\"\r
- RegisterForComInterop = "false"\r
- RemoveIntegerChecks = "false"\r
- TreatWarningsAsErrors = "false"\r
- WarningLevel = "4"\r
- />\r
- </Settings>\r
- <References/>\r
- </Build>\r
- <Files>\r
- <Include>\r
- <File\r
- RelPath = "example.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "examplePINVOKE.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "runme.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "SWIGTYPE_p_int.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- <File\r
- RelPath = "SWIGTYPE_p_Point.cs"\r
- SubType = "Code"\r
- BuildAction = "Compile"\r
- />\r
- </Include>\r
- </Files>\r
- </CSHARP>\r
-</VisualStudioProject>\r
-\r
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <PropertyGroup>\r
+ <ProjectType>Local</ProjectType>\r
+ <ProductVersion>8.0.50727</ProductVersion>\r
+ <SchemaVersion>2.0</SchemaVersion>\r
+ <ProjectGuid>{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}</ProjectGuid>\r
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>\r
+ <Platform Condition=" '$(Platform)' == '' ">x86</Platform>\r
+ <ApplicationIcon>\r
+ </ApplicationIcon>\r
+ <AssemblyKeyContainerName>\r
+ </AssemblyKeyContainerName>\r
+ <AssemblyName>runme</AssemblyName>\r
+ <AssemblyOriginatorKeyFile>\r
+ </AssemblyOriginatorKeyFile>\r
+ <DefaultClientScript>JScript</DefaultClientScript>\r
+ <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>\r
+ <DefaultTargetSchema>IE50</DefaultTargetSchema>\r
+ <DelaySign>false</DelaySign>\r
+ <OutputType>Exe</OutputType>\r
+ <RootNamespace>runme</RootNamespace>\r
+ <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>\r
+ <StartupObject>\r
+ </StartupObject>\r
+ <FileUpgradeFlags>\r
+ </FileUpgradeFlags>\r
+ <UpgradeBackupLocation>\r
+ </UpgradeBackupLocation>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x86\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">\r
+ <OutputPath>bin\x86\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x86</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">\r
+ <DebugSymbols>true</DebugSymbols>\r
+ <OutputPath>bin\x64\Debug\</OutputPath>\r
+ <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <DebugType>full</DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">\r
+ <OutputPath>bin\x64\Release\</OutputPath>\r
+ <DefineConstants>TRACE</DefineConstants>\r
+ <BaseAddress>285212672</BaseAddress>\r
+ <Optimize>true</Optimize>\r
+ <DebugType>\r
+ </DebugType>\r
+ <PlatformTarget>x64</PlatformTarget>\r
+ <ErrorReport>prompt</ErrorReport>\r
+ </PropertyGroup>\r
+ <ItemGroup>\r
+ <Compile Include="example.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="examplePINVOKE.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="runme.cs">\r
+ <SubType>Code</SubType>\r
+ </Compile>\r
+ <Compile Include="SWIGTYPE_p_int.cs" />\r
+ <Compile Include="SWIGTYPE_p_Point.cs" />\r
+ </ItemGroup>\r
+ <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />\r
+ <PropertyGroup>\r
+ <PreBuildEvent>\r
+ </PreBuildEvent>\r
+ <PostBuildEvent>copy runme.exe "$(SolutionDir)runme.exe"\r
+echo Run the example from the root directory $(SolutionDir) and ensure example.dll is also in this directory</PostBuildEvent>\r
+ </PropertyGroup>\r
+</Project>\r
<?xml version="1.0" encoding="Windows-1252"?>\r
<VisualStudioProject\r
ProjectType="Visual C++"\r
- Version="7.10"\r
+ Version="8.00"\r
Name="example"\r
ProjectGUID="{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- Keyword="Win32Proj">\r
+ Keyword="Win32Proj"\r
+ >\r
<Platforms>\r
<Platform\r
- Name="Win32"/>\r
+ Name="Win32"\r
+ />\r
+ <Platform\r
+ Name="x64"\r
+ />\r
</Platforms>\r
+ <ToolFiles>\r
+ </ToolFiles>\r
<Configurations>\r
<Configuration\r
Name="Debug|Win32"\r
- OutputDirectory="Debug"\r
- IntermediateDirectory="Debug"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
Optimization="0"\r
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
- MinimalRebuild="TRUE"\r
+ MinimalRebuild="true"\r
BasicRuntimeChecks="3"\r
RuntimeLibrary="1"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="4"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="4"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="2"\r
- GenerateDebugInformation="TRUE"\r
- ProgramDatabaseFile="$(OutDir)/example.pdb"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Debug|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCCLCompilerTool"\r
+ Optimization="0"\r
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ MinimalRebuild="true"\r
+ BasicRuntimeChecks="3"\r
+ RuntimeLibrary="1"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCResourceCompilerTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="2"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
<Configuration\r
Name="Release|Win32"\r
- OutputDirectory="Release"\r
- IntermediateDirectory="Release"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
ConfigurationType="2"\r
- CharacterSet="2">\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
+ <Tool\r
+ Name="VCPreBuildEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ />\r
+ <Tool\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ />\r
<Tool\r
Name="VCCLCompilerTool"\r
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
RuntimeLibrary="0"\r
UsePrecompiledHeader="0"\r
WarningLevel="3"\r
- Detect64BitPortabilityProblems="TRUE"\r
- DebugInformationFormat="3"/>\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
<Tool\r
- Name="VCCustomBuildTool"/>\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
<Tool\r
Name="VCLinkerTool"\r
- OutputFile="example.dll"\r
+ OutputFile="$(OutDir)\example.dll"\r
LinkIncremental="1"\r
- GenerateDebugInformation="TRUE"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
SubSystem="2"\r
OptimizeReferences="2"\r
EnableCOMDATFolding="2"\r
- ImportLibrary="$(OutDir)/example.lib"\r
- TargetMachine="1"/>\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="1"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
<Tool\r
- Name="VCMIDLTool"/>\r
+ Name="VCManifestTool"\r
+ />\r
<Tool\r
- Name="VCPostBuildEventTool"/>\r
+ Name="VCXDCMakeTool"\r
+ />\r
<Tool\r
- Name="VCPreBuildEventTool"/>\r
+ Name="VCBscMakeTool"\r
+ />\r
<Tool\r
- Name="VCPreLinkEventTool"/>\r
+ Name="VCFxCopTool"\r
+ />\r
<Tool\r
- Name="VCResourceCompilerTool"/>\r
+ Name="VCAppVerifierTool"\r
+ />\r
<Tool\r
- Name="VCWebServiceProxyGeneratorTool"/>\r
+ Name="VCWebDeploymentTool"\r
+ />\r
<Tool\r
- Name="VCXMLDataGeneratorTool"/>\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
+ </Configuration>\r
+ <Configuration\r
+ Name="Release|x64"\r
+ OutputDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"\r
+ ConfigurationType="2"\r
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"\r
+ CharacterSet="2"\r
+ >\r
<Tool\r
- Name="VCWebDeploymentTool"/>\r
+ Name="VCPreBuildEventTool"\r
+ />\r
<Tool\r
- Name="VCManagedWrapperGeneratorTool"/>\r
+ Name="VCCustomBuildTool"\r
+ />\r
<Tool\r
- Name="VCAuxiliaryManagedWrapperGeneratorTool"/>\r
+ Name="VCXMLDataGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebServiceProxyGeneratorTool"\r
+ />\r
+ <Tool\r
+ Name="VCMIDLTool"\r
+ TargetEnvironment="3"\r
+ />\r
+ <Tool\r
+ Name="VCCLCompilerTool"\r
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;EXAMPLEVC_EXPORTS"\r
+ RuntimeLibrary="0"\r
+ UsePrecompiledHeader="0"\r
+ WarningLevel="3"\r
+ Detect64BitPortabilityProblems="true"\r
+ DebugInformationFormat="3"\r
+ />\r
+ <Tool\r
+ Name="VCManagedResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCResourceCompilerTool"\r
+ />\r
+ <Tool\r
+ Name="VCPreLinkEventTool"\r
+ />\r
+ <Tool\r
+ Name="VCLinkerTool"\r
+ OutputFile="$(OutDir)\example.dll"\r
+ LinkIncremental="1"\r
+ GenerateDebugInformation="true"\r
+ ProgramDatabaseFile="$(OutDir)\example.pdb"\r
+ SubSystem="2"\r
+ OptimizeReferences="2"\r
+ EnableCOMDATFolding="2"\r
+ ImportLibrary="$(OutDir)\example.lib"\r
+ TargetMachine="17"\r
+ />\r
+ <Tool\r
+ Name="VCALinkTool"\r
+ />\r
+ <Tool\r
+ Name="VCManifestTool"\r
+ />\r
+ <Tool\r
+ Name="VCXDCMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCBscMakeTool"\r
+ />\r
+ <Tool\r
+ Name="VCFxCopTool"\r
+ />\r
+ <Tool\r
+ Name="VCAppVerifierTool"\r
+ />\r
+ <Tool\r
+ Name="VCWebDeploymentTool"\r
+ />\r
+ <Tool\r
+ Name="VCPostBuildEventTool"\r
+ Description="Copy unmanaged dll to root directory..."\r
+ CommandLine="echo on
copy "$(OutDir)\example.dll" "$(SolutionDir)"
@echo off
"\r
+ />\r
</Configuration>\r
</Configurations>\r
<References>\r
<Filter\r
Name="Source Files"\r
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
- UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">\r
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
+ >\r
<File\r
- RelativePath=".\example.c">\r
+ RelativePath="example.c"\r
+ >\r
</File>\r
<File\r
- RelativePath=".\example_wrap.c">\r
+ RelativePath="example_wrap.c"\r
+ >\r
</File>\r
</Filter>\r
<Filter\r
Name="Header Files"\r
Filter="h;hpp;hxx;hm;inl;inc;xsd"\r
- UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">\r
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"\r
+ >\r
+ <File\r
+ RelativePath="example.h"\r
+ >\r
+ </File>\r
</Filter>\r
<File\r
- RelativePath=".\example.i">\r
+ RelativePath=".\example.i"\r
+ >\r
+ <FileConfiguration\r
+ Name="Debug|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Debug|x64"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
+ </FileConfiguration>\r
<FileConfiguration\r
- Name="Debug|Win32">\r
+ Name="Release|Win32"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -csharp "$(InputPath)"\r
-@echo off\r
-"\r
- Outputs="$(InputName)_wrap.c"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
</FileConfiguration>\r
<FileConfiguration\r
- Name="Release|Win32">\r
+ Name="Release|x64"\r
+ >\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="echo Invoking SWIG...\r
-echo on\r
-..\..\..\swig.exe -csharp "$(InputPath)"\r
-@echo off\r
-"\r
- Outputs="$(InputName)_wrap.c"/>\r
+ CommandLine="echo Invoking SWIG...
echo on
..\..\..\swig.exe -csharp "$(InputPath)"
@echo off
"\r
+ Outputs="$(InputName)_wrap.c"\r
+ />\r
</FileConfiguration>\r
</File>\r
</Files>\r
printf("dvar = %g\n", dvar);
printf("cvar = %c\n", cvar);
printf("strvar = %s\n", strvar ? strvar : "(null)");
- printf("cstrvar = %s\n", cstrvar ? cstrvar : "(null)");
- printf("iptrvar = %p\n", iptrvar);
+ printf("cstrvar = %s\n", cstrvar);
+ printf("iptrvar = %p\n", (void *)iptrvar);
printf("name = %s\n", name);
- printf("ptptr = %p (%d, %d)\n", ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
+ printf("ptptr = %p (%d, %d)\n", (void *)ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
printf("pt = (%d, %d)\n", pt.x, pt.y);
printf("status = %d\n", status);
}
-Microsoft Visual Studio Solution File, Format Version 8.00\r
+Microsoft Visual Studio Solution File, Format Version 9.00\r
+# Visual Studio 2005\r
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "example-cs", "example-cs.csproj", "{C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}"\r
ProjectSection(ProjectDependencies) = postProject\r
{C2302635-D489-4678-96B4-70F5309DCBE6} = {C2302635-D489-4678-96B4-70F5309DCBE6}\r
EndProjectSection\r
EndProject\r
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example-vc", "example-vc.vcproj", "{C2302635-D489-4678-96B4-70F5309DCBE6}"\r
- ProjectSection(ProjectDependencies) = postProject\r
- EndProjectSection\r
EndProject\r
Global\r
- GlobalSection(SolutionConfiguration) = preSolution\r
- Debug = Debug\r
- Release = Release\r
- EndGlobalSection\r
- GlobalSection(ProjectConfiguration) = postSolution\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.ActiveCfg = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug.Build.0 = Debug|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.ActiveCfg = Release|.NET\r
- {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release.Build.0 = Release|.NET\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.ActiveCfg = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug.Build.0 = Debug|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.ActiveCfg = Release|Win32\r
- {C2302635-D489-4678-96B4-70F5309DCBE6}.Release.Build.0 = Release|Win32\r
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
+ Debug|Win32 = Debug|Win32\r
+ Debug|x64 = Debug|x64\r
+ Release|Win32 = Release|Win32\r
+ Release|x64 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityGlobals) = postSolution\r
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.ActiveCfg = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|Win32.Build.0 = Debug|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Debug|x64.Build.0 = Debug|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.ActiveCfg = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|Win32.Build.0 = Release|x86\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.ActiveCfg = Release|x64\r
+ {C17D27DF-4C57-4625-AEE0-A40C4F48FF1A}.Release|x64.Build.0 = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.ActiveCfg = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|Win32.Build.0 = Debug|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Debug|x64.Build.0 = Debug|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.ActiveCfg = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|Win32.Build.0 = Release|Win32\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.ActiveCfg = Release|x64\r
+ {C2302635-D489-4678-96B4-70F5309DCBE6}.Release|x64.Build.0 = Release|x64\r
EndGlobalSection\r
- GlobalSection(ExtensibilityAddIns) = postSolution\r
+ GlobalSection(SolutionProperties) = preSolution\r
+ HideSolutionNode = FALSE\r
EndGlobalSection\r
EndGlobal\r
-ifeq (2,$(D_VERSION))
- WORKING_DIR = d2/
-else
- WORKING_DIR = d1/
-endif
-
-TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
-EXTRA_CFLAGS = -I../ ../example.cxx example_wrap.cxx
-EXTRA_LDFLAGS = example.o example_wrap.o
-TARGET = example_wrap
-SWIGOPT =
-DSRCS = *.d
-DFLAGS = -ofrunme
-
-check: build
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_run
-
-build:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile EXTRA_CFLAGS='$(EXTRA_CFLAGS)' EXTRA_LDFLAGS='$(EXTRA_LDFLAGS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT) -outcurrentdir ../example.i' TARGET='$(TARGET)' d_cpp; \
- $(MAKE) -f $(TOP)/Makefile DSRCS='$(DSRCS)' DFLAGS='$(DFLAGS)' d_compile
-
-clean:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_clean
+include ../example.mk
#include "example.h"
%}
-%include "std_string.i"
-
/* turn on director wrapping Callback */
%feature("director") Callback;
-ifeq (2,$(D_VERSION))
- WORKING_DIR = d2/
-else
- WORKING_DIR = d1/
-endif
-
-TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
-EXTRA_CFLAGS = -I../ ../example.cxx example_wrap.cxx
-EXTRA_LDFLAGS = example.o example_wrap.o
-TARGET = example_wrap
-SWIGOPT =
-DSRCS = *.d
-DFLAGS = -ofrunme
-
-check: build
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_run
-
-build:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile EXTRA_CFLAGS='$(EXTRA_CFLAGS)' EXTRA_LDFLAGS='$(EXTRA_LDFLAGS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT) -outcurrentdir ../example.i' TARGET='$(TARGET)' d_cpp; \
- $(MAKE) -f $(TOP)/Makefile DSRCS='$(DSRCS)' DFLAGS='$(DFLAGS)' d_compile
-
-clean:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_clean
+include ../example.mk
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
+ }
double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
/* Let's just grab the original header file here */
%include "example.h"
-
-ifeq (2,$(D_VERSION))
- WORKING_DIR = d2/
-else
- WORKING_DIR = d1/
-endif
-
-TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
-EXTRA_CFLAGS = -I../ example_wrap.c
-EXTRA_LDFLAGS = example_wrap.o
-TARGET = example_wrap
-SWIGOPT =
-DSRCS = *.d
-DFLAGS = -ofrunme
-
-check: build
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_run
-
-build:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile EXTRA_CFLAGS='$(EXTRA_CFLAGS)' EXTRA_LDFLAGS='$(EXTRA_LDFLAGS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT) -outcurrentdir ../example.i' TARGET='$(TARGET)' d; \
- $(MAKE) -f $(TOP)/Makefile DSRCS='$(DSRCS)' DFLAGS='$(DFLAGS)' d_compile
-
-clean:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_clean
+include ../example.mk
+++ /dev/null
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.41
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-module example;
-
-static import example_wrap;
-
-static import tango.stdc.stringz;
-
-public const int ICONST = 42;
-public const double FCONST = 2.1828;
-public const char CCONST = 'x';
-public const char CCONST2 = '\n';
-public const char[] SCONST = "Hello World";
-public const char[] SCONST2 = "\"Hello World\"";
-public const double EXPR = 42+3*(2.1828);
-public const int iconst = 37;
-public const double fconst = 3.14;
-ifeq (2,$(D_VERSION))
- WORKING_DIR = d2/
-else
- WORKING_DIR = d1/
-endif
-
-TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
-EXTRA_CFLAGS = -I../ ../example.cxx example_wrap.cxx
-EXTRA_LDFLAGS = example.o example_wrap.o
-TARGET = example_wrap
-SWIGOPT =
-DSRCS = *.d
-DFLAGS = -ofrunme
-
-check: build
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_run
-
-build:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile EXTRA_CFLAGS='$(EXTRA_CFLAGS)' EXTRA_LDFLAGS='$(EXTRA_LDFLAGS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT) -outcurrentdir ../example.i' TARGET='$(TARGET)' d_cpp; \
- $(MAKE) -f $(TOP)/Makefile DSRCS='$(DSRCS)' DFLAGS='$(DFLAGS)' d_compile
-
-clean:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_clean
+include ../example.mk
--- /dev/null
+#
+# Common Makefile code for building D examples.
+#
+# We actually need to configure this to gain access to the default D version to
+# use when D_VERSION is not set. Using Examples/Makefile.in is not enough, as
+# the location of the source files (d1/ or d2/) depends on it. The alternative
+# would be to add the functionality specific to Examples/d (as opposed to the
+# test suite) directly to Examples/Makefile.in.
+#
+# This file is supposed to be included from a Makefile in the subdirectory
+# corresponding to a specific example.
+#
+
+ifeq (,$(D_VERSION))
+ D_VERSION = @DDEFAULTVERSION@
+endif
+
+ifeq (1,$(D_VERSION))
+ VERSION_DIR = d1/
+else
+ VERSION_DIR = d2/
+endif
+
+EXAMPLES_TOP = ../../..
+SWIG_TOP = ../../../..
+SWIGEXE = $(SWIG_TOP)/swig
+SWIG_LIB_DIR = $(SWIG_TOP)/$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+EXTRA_CFLAGS =
+EXTRA_CXXFLAGS =
+EXTRA_LDFLAGS =
+TARGET = example_wrap
+SWIGOPT = -outcurrentdir
+DFLAGS = -ofrunme
+
+ifeq (,$(SRCDIR))
+DSRCS = *.d
+else
+DSRCS = *.d $(addprefix ../$(SRCDIR)$(VERSION_DIR),runme.d)
+endif
+
+
+check: build
+ $(MAKE) -C $(VERSION_DIR) -f $(EXAMPLES_TOP)/Makefile SRCDIR='../$(SRCDIR)' d_run
+
+build:
+ mkdir -p $(VERSION_DIR)
+ if [ -f $(SRCDIR)example.cxx ]; then \
+ $(MAKE) -C $(VERSION_DIR) -f $(EXAMPLES_TOP)/Makefile SRCDIR='../$(SRCDIR)' EXTRA_CXXFLAGS='$(EXTRA_CXXFLAGS)' EXTRA_LDFLAGS='$(EXTRA_LDFLAGS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='example.i' CXXSRCS='example.cxx' d_cpp; \
+ elif [ -f $(SRCDIR)example.c ]; then \
+ $(MAKE) -C $(VERSION_DIR) -f $(EXAMPLES_TOP)/Makefile SRCDIR='../$(SRCDIR)' EXTRA_CFLAGS='$(EXTRA_CFLAGS)' EXTRA_LDFLAGS='$(EXTRA_LDFLAGS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='example.i' SRCS='example.c' d; \
+ else \
+ $(MAKE) -C $(VERSION_DIR) -f $(EXAMPLES_TOP)/Makefile SRCDIR='../$(SRCDIR)' EXTRA_CFLAGS='$(EXTRA_CFLAGS)' EXTRA_LDFLAGS='$(EXTRA_LDFLAGS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='example.i' SRCS='' d; \
+ fi
+ $(MAKE) -C $(VERSION_DIR) -f $(EXAMPLES_TOP)/Makefile SRCDIR='../$(SRCDIR)' DSRCS='$(DSRCS)' DFLAGS='$(DFLAGS)' d_compile
+
+clean:
+ if [ -d $(VERSION_DIR) ]; then \
+ $(MAKE) -C $(VERSION_DIR) -f $(EXAMPLES_TOP)/Makefile SRCDIR='../$(SRCDIR)' d_clean; \
+ fi
+ test -f $(VERSION_DIR)runme.d || rm -rf $(VERSION_DIR) # Only delete dir if out of source
-ifeq (2,$(D_VERSION))
- WORKING_DIR = d2/
-else
- WORKING_DIR = d1/
-endif
-
-TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
-EXTRA_CFLAGS = -I../ ../example.cxx example_wrap.cxx
-EXTRA_LDFLAGS = example.o example_wrap.o
-TARGET = example_wrap
-SWIGOPT =
-DSRCS = *.d
-DFLAGS = -ofrunme
-
-check: build
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_run
-
-build:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile EXTRA_CFLAGS='$(EXTRA_CFLAGS)' EXTRA_LDFLAGS='$(EXTRA_LDFLAGS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT) -outcurrentdir ../example.i' TARGET='$(TARGET)' d_cpp; \
- $(MAKE) -f $(TOP)/Makefile DSRCS='$(DSRCS)' DFLAGS='$(DFLAGS)' d_compile
-
-clean:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_clean
+include ../example.mk
// methods of all these instances are treated the same. For items 0, 1, and
// 2, all methods resolve in C++. For item 3, our CEO, getTitle calls
// getPosition which resolves in D. The call to getPosition is
- // slightly different, however, because of the overidden getPosition() call, since
+ // slightly different, however, because of the overridden getPosition() call, since
// now the object reference has been "laundered" by passing through
// EmployeeList as an Employee*. Previously, D resolved the call
// immediately in CEO, but now D thinks the object is an instance of
// methods of all these instances are treated the same. For items 0, 1, and
// 2, all methods resolve in C++. For item 3, our CEO, getTitle calls
// getPosition which resolves in D. The call to getPosition is
- // slightly different, however, because of the overidden getPosition() call, since
+ // slightly different, however, because of the overridden getPosition() call, since
// now the object reference has been "laundered" by passing through
// EmployeeList as an Employee*. Previously, D resolved the call
// immediately in CEO, but now D thinks the object is an instance of
virtual std::string getTitle() { return getPosition() + " " + getName(); }
virtual std::string getName() { return name; }
virtual std::string getPosition() const { return "Employee"; }
- virtual ~Employee() { printf("~Employee() @ %p\n", this); }
+ virtual ~Employee() { printf("~Employee() @ %p\n", (void *)this); }
};
-ifeq (2,$(D_VERSION))
- WORKING_DIR = d2/
-else
- WORKING_DIR = d1/
-endif
-
-TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
-EXTRA_CFLAGS = -I../ ../example.c example_wrap.c
-EXTRA_LDFLAGS = example.o example_wrap.o
-TARGET = example_wrap
-SWIGOPT =
-DSRCS = *.d
-DFLAGS = -ofrunme
-
-check: build
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_run
-
-build:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile EXTRA_CFLAGS='$(EXTRA_CFLAGS)' EXTRA_LDFLAGS='$(EXTRA_LDFLAGS)' EXTRA_LDFLAGS='$(EXTRA_LDFLAGS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT) -outcurrentdir ../example.i' TARGET='$(TARGET)' d; \
- $(MAKE) -f $(TOP)/Makefile DSRCS='$(DSRCS)' DFLAGS='$(DFLAGS)' d_compile
-
-clean:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_clean
+include ../example.mk
-ifeq (2,$(D_VERSION))
- WORKING_DIR = d2/
-else
- WORKING_DIR = d1/
-endif
-
-TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
-EXTRA_CFLAGS = -I../ ../example.c example_wrap.c
-EXTRA_LDFLAGS = example.o example_wrap.o
-TARGET = example_wrap
-SWIGOPT =
-DSRCS = *.d
-DFLAGS = -ofrunme
-
-check: build
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_run
-
-build:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile EXTRA_CFLAGS='$(EXTRA_CFLAGS)' EXTRA_LDFLAGS='$(EXTRA_LDFLAGS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT) -outcurrentdir ../example.i' TARGET='$(TARGET)' d; \
- $(MAKE) -f $(TOP)/Makefile DSRCS='$(DSRCS)' DFLAGS='$(DFLAGS)' d_compile
-
-clean:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_clean
+include ../example.mk
-ifeq (2,$(D_VERSION))
- WORKING_DIR = d2/
-else
- WORKING_DIR = d1/
-endif
-
-TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
-EXTRA_CFLAGS = -I../ ../example.c example_wrap.c
-EXTRA_LDFLAGS = example.o example_wrap.o
-TARGET = example_wrap
-SWIGOPT =
-DSRCS = *.d
-DFLAGS = -ofrunme
-
-check: build
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_run
-
-build:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile EXTRA_CFLAGS='$(EXTRA_CFLAGS)' EXTRA_LDFLAGS='$(EXTRA_LDFLAGS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT) -outcurrentdir ../example.i' TARGET='$(TARGET)' d; \
- $(MAKE) -f $(TOP)/Makefile DSRCS='$(DSRCS)' DFLAGS='$(DFLAGS)' d_compile
-
-clean:
- cd $(WORKING_DIR); \
- $(MAKE) -f $(TOP)/Makefile d_clean
+include ../example.mk
printf("dvar = %g\n", dvar);
printf("cvar = %c\n", cvar);
printf("strvar = %s\n", strvar ? strvar : "(null)");
- printf("cstrvar = %s\n", cstrvar ? cstrvar : "(null)");
- printf("iptrvar = %p\n", iptrvar);
+ printf("cstrvar = %s\n", cstrvar);
+ printf("iptrvar = %p\n", (void *)iptrvar);
printf("name = %s\n", name);
- printf("ptptr = %p (%d, %d)\n", ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
+ printf("ptptr = %p (%d, %d)\n", (void *)ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
printf("pt = (%d, %d)\n", pt.x, pt.y);
printf("status = %d\n", status);
}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS = example.cxx
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS = callback.cxx
+GOSRCS = gocallback.go
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ if [ -n '$(SRCDIR)' ]; then \
+ cp $(GOSRCS:%=$(SRCDIR)/%) .; \
+ fi
+ @# Note: example.go gets generated by SWIG
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' GOSRCS='example.go $(GOSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' go_clean
+ if [ -n '$(SRCDIR)' ]; then \
+ rm -f $(GOSRCS); \
+ fi
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
void setCallback(Callback *cb) { delCallback(); _callback = cb; }
void call() { if (_callback) _callback->run(); }
};
-
#include "example.h"
%}
-%include "std_string.i"
-
/* turn on director wrapping Callback */
%feature("director") Callback;
--- /dev/null
+package example
+
+import (
+ "fmt"
+)
+
+type GoCallback interface {
+ Callback
+ deleteCallback()
+ IsGoCallback()
+}
+
+type goCallback struct {
+ Callback
+}
+
+func (p *goCallback) deleteCallback() {
+ DeleteDirectorCallback(p.Callback)
+}
+
+func (p *goCallback) IsGoCallback() {}
+
+type overwrittenMethodsOnCallback struct {
+ p Callback
+}
+
+func NewGoCallback() GoCallback {
+ om := &overwrittenMethodsOnCallback{}
+ p := NewDirectorCallback(om)
+ om.p = p
+
+ return &goCallback{Callback: p}
+}
+
+func DeleteGoCallback(p GoCallback) {
+ p.deleteCallback()
+}
+
+func (p *goCallback) Run() {
+ fmt.Println("GoCallback.Run")
+}
<H2>Implementing C++ callbacks in Go</H2>
<p>
-This example illustrates how to use directors to implement C++
-callbacks in Go.
-</p>
-
-<p>
-Because Go and C++ use inheritance differently, you must call a
-different function to create a class which uses callbacks. Instead of
-calling the usual constructor function whose name is <tt>New</tt>
-followed by the capitalized name of the class, you call a function
-named <tt>NewDirector</tt> followed by the capitalized name of the
-class.
-</p>
-
-<p>
-The first argument to the <tt>NewDirector</tt> function is an instance
-of a type. The <tt>NewDirector</tt> function will return an interface
-value as usual. However, when calling any method on the returned
-value, the program will first check whether the value passed
-to <tt>NewDirector</tt> implements that method. If it does, the
-method will be called in Go. This is true whether the method is
-called from Go code or C++ code.
-</p>
-
-<p>
-Note that the Go code will be called with just the Go value, not the
-C++ value. If the Go code needs to call a C++ method on itself, you
-need to get a copy of the C++ object. This is typically done as
-follows:
-
-<blockquote>
-<pre>
-type Child struct { abi Parent }
-func (p *Child) ChildMethod() {
- p.abi.ParentMethod()
-}
-func f() {
- p := &Child{nil}
- d := NewDirectorParent(p)
- p.abi = d
- ...
-}
-</pre>
-</blockquote>
-
-In other words, we first create the Go value. We pass that to
-the <tt>NewDirector</tt> function to create the C++ value; this C++
-value will be created with an association to the Go value. We then
-store the C++ value in the Go value, giving us the reverse
-association. That permits us to call parent methods from the child.
-
-</p>
-
-<p>
-To delete a director object, use the function <tt>DeleteDirector</tt>
-followed by the capitalized name of the class.
+This example illustrates how to use directors to implement C++ callbacks in Go.
+See the <a href="../../../Doc/Manual/Go.html#Go_director_classes">Go Director
+Classes</a> documentation subsection for an in-depth explanation how to use the
+director feature.
</p>
<p>
<ul>
-<li><a href="example.h">example.h</a>. Header file containing some enums.
-<li><a href="example.i">example.i</a>. Interface file.
+<li><a href="example.h">example.h</a>. Header with the definition of the Caller and Callback classes.
+<li><a href="example.i">example.i</a>. SWIG interface file.
+<li><a href="gocallback.go">gocallback.go</a>. Go source with the definition of the GoCallback class.
<li><a href="runme.go">runme.go</a>. Sample Go program.
</ul>
caller.Call()
caller.DelCallback()
- callback = NewDirectorCallback(new(GoCallback))
+ go_callback := NewGoCallback()
fmt.Println()
fmt.Println("Adding and calling a Go callback")
- fmt.Println("------------------------------------")
+ fmt.Println("--------------------------------")
- caller.SetCallback(callback)
+ caller.SetCallback(go_callback)
caller.Call()
caller.DelCallback()
- // Test that a double delete does not occur as the object has
- // already been deleted from the C++ layer.
- DeleteDirectorCallback(callback)
+ DeleteGoCallback(go_callback)
fmt.Println()
fmt.Println("Go exit")
}
-
-type GoCallback struct{}
-
-func (p *GoCallback) Run() {
- fmt.Println("GoCallback.Run")
-}
callback
class
constants
+director
enum
extend
funcptr
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS = example.cxx
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS = class.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' go_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
--- /dev/null
+/* File : class.cxx */
+
+#include "example.h"
+#define M_PI 3.14159265358979323846
+
+/* Move the shape to a new location */
+void Shape::move(double dx, double dy) {
+ x += dx;
+ y += dy;
+}
+
+int Shape::nshapes = 0;
+
+double Circle::area() {
+ return M_PI*radius*radius;
+}
+
+double Circle::perimeter() {
+ return 2*M_PI*radius;
+}
+
+double Square::area() {
+ return width*width;
+}
+
+double Square::perimeter() {
+ return 4*width;
+}
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
-
-
-
-
-
/* Let's just grab the original header file here */
%include "example.h"
-
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
virtual double area() = 0;
virtual double perimeter() = 0;
private:
double radius;
public:
- Circle(double r) : radius(r) { };
+ Circle(double r) : radius(r) { }
virtual double area();
virtual double perimeter();
};
private:
double width;
public:
- Square(double w) : width(w) { };
+ Square(double w) : width(w) { }
virtual double area();
virtual double perimeter();
};
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' go_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
+GOSRCS = director.go
+TARGET = example
+INTERFACE = example.i
+SWIGOPT =
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+
+build:
+ if [ -n '$(SRCDIR)' ]; then \
+ cp $(GOSRCS:%=$(SRCDIR)/%) .; \
+ fi
+ @# Note: example.go gets generated by SWIG
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' GOSRCS='example.go $(GOSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_cpp
+
+clean:
+ if [ -n '$(SRCDIR)' ]; then \
+ rm -f $(GOSRCS); \
+ fi
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
--- /dev/null
+package example
+
+// FooBarGo is a superset of FooBarAbstract and hence FooBarGo can be used as a
+// drop in replacement for FooBarAbstract but the reverse causes a compile time
+// error.
+type FooBarGo interface {
+ FooBarAbstract
+ deleteFooBarAbstract()
+ IsFooBarGo()
+}
+
+// Via embedding fooBarGo "inherits" all methods of FooBarAbstract.
+type fooBarGo struct {
+ FooBarAbstract
+}
+
+func (fbgs *fooBarGo) deleteFooBarAbstract() {
+ DeleteDirectorFooBarAbstract(fbgs.FooBarAbstract)
+}
+
+// The IsFooBarGo method ensures that FooBarGo is a superset of FooBarAbstract.
+// This is also how the class hierarchy gets represented by the SWIG generated
+// wrapper code. For an instance FooBarCpp has the IsFooBarAbstract and
+// IsFooBarCpp methods.
+func (fbgs *fooBarGo) IsFooBarGo() {}
+
+// Go type that defines the DirectorInterface. It contains the Foo and Bar
+// methods that overwrite the respective virtual C++ methods on FooBarAbstract.
+type overwrittenMethodsOnFooBarAbstract struct {
+ // Backlink to FooBarAbstract so that the rest of the class can be used by
+ // the overridden methods.
+ fb FooBarAbstract
+
+ // If additional constructor arguments have been given they are typically
+ // stored here so that the overriden methods can use them.
+}
+
+func (om *overwrittenMethodsOnFooBarAbstract) Foo() string {
+ // DirectorFooBarAbstractFoo calls the base method FooBarAbstract::Foo.
+ return "Go " + DirectorFooBarAbstractFoo(om.fb)
+}
+
+func (om *overwrittenMethodsOnFooBarAbstract) Bar() string {
+ return "Go Bar"
+}
+
+func NewFooBarGo() FooBarGo {
+ // Instantiate FooBarAbstract with selected methods overridden. The methods
+ // that will be overwritten are defined on
+ // overwrittenMethodsOnFooBarAbstract and have a compatible signature to the
+ // respective virtual C++ methods. Furthermore additional constructor
+ // arguments will be typically stored in the
+ // overwrittenMethodsOnFooBarAbstract struct.
+ om := &overwrittenMethodsOnFooBarAbstract{}
+ fb := NewDirectorFooBarAbstract(om)
+ om.fb = fb // Backlink causes cycle as fb.v = om!
+
+ fbgs := &fooBarGo{FooBarAbstract: fb}
+ // The memory of the FooBarAbstract director object instance can be
+ // automatically freed once the FooBarGo instance is garbage collected by
+ // uncommenting the following line. Please make sure to understand the
+ // runtime.SetFinalizer specific gotchas before doing this. Furthemore
+ // DeleteFooBarGo should be deleted if a finalizer is in use or the fooBarGo
+ // struct needs additional data to prevent double deletion.
+ // runtime.SetFinalizer(fbgs, FooBarGo.deleteFooBarAbstract)
+ return fbgs
+}
+
+// Recommended to be removed if runtime.SetFinalizer is in use.
+func DeleteFooBarGo(fbg FooBarGo) {
+ fbg.deleteFooBarAbstract()
+}
--- /dev/null
+#ifndef DIRECTOR_H
+#define DIRECTOR_H
+
+
+#include <stdio.h>
+#include <string>
+
+
+class FooBarAbstract
+{
+public:
+ FooBarAbstract() {};
+ virtual ~FooBarAbstract() {};
+
+ std::string FooBar() {
+ return this->Foo() + ", " + this->Bar();
+ };
+
+protected:
+ virtual std::string Foo() {
+ return "Foo";
+ };
+
+ virtual std::string Bar() = 0;
+};
+
+
+class FooBarCpp : public FooBarAbstract
+{
+protected:
+ virtual std::string Foo() {
+ return "C++ " + FooBarAbstract::Foo();
+ }
+
+ virtual std::string Bar() {
+ return "C++ Bar";
+ }
+};
+
+
+#endif
--- /dev/null
+/* File : example.i */
+%module(directors="1") example
+
+%include "std_string.i"
+
+%header %{
+#include "director.h"
+%}
+
+%feature("director") FooBarAbstract;
+%include "director.h"
--- /dev/null
+<html>
+<head>
+<title>SWIG:Examples:go:director</title>
+</head>
+
+<body bgcolor="#ffffff">
+
+<tt>SWIG/Examples/go/director/</tt>
+<hr>
+
+<H2>How to subclass a C++ class with a Go type</H2>
+
+<p>
+See the <a href="../../../Doc/Manual/Go.html#Go_director_classes">Go Director
+Classes</a> documentation subsection for an explanation of this example.
+</p>
+
+<p>
+<ul>
+<li><a href="director.go">director.go</a>. Go source with the definition of the FooBarGo class.
+<li><a href="director.h">director.h</a>. Header with the definition of the FooBarAbstract and FooBarCpp classes.
+<li><a href="example.i">example.i</a>. SWIG interface file.
+<li><a href="runme.go">runme.go</a>. Sample Go program.
+</ul>
+
+<hr>
+</body>
+</html>
--- /dev/null
+package main
+
+import (
+ "./example"
+ "fmt"
+ "os"
+)
+
+func Compare(name string, got string, exp string) error {
+ fmt.Printf("%s; Got: '%s'; Expected: '%s'\n", name, got, exp)
+ if got != exp {
+ return fmt.Errorf("%s returned unexpected string! Got: '%s'; Expected: '%s'\n", name, got, exp)
+ }
+ return nil
+}
+
+func TestFooBarCpp() error {
+ fb := example.NewFooBarCpp()
+ defer example.DeleteFooBarCpp(fb)
+ return Compare("FooBarCpp.FooBar()", fb.FooBar(), "C++ Foo, C++ Bar")
+}
+
+func TestFooBarGo() error {
+ fb := example.NewFooBarGo()
+ defer example.DeleteFooBarGo(fb)
+ return Compare("FooBarGo.FooBar()", fb.FooBar(), "Go Foo, Go Bar")
+}
+
+func main() {
+ fmt.Println("Test output:")
+ fmt.Println("------------")
+ err := TestFooBarCpp()
+ err = TestFooBarGo()
+ fmt.Println("------------")
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "Tests failed! Last error: %s\n", err.Error())
+ os.Exit(1)
+ }
+}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS = example.cxx
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS = enum.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' go_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS = example.cxx
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS = extend.cxx
+GOSRCS = ceo.go
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ if [ -n '$(SRCDIR)' ]; then \
+ cp $(GOSRCS:%=$(SRCDIR)/%) .; \
+ fi
+ @# Note: example.go gets generated by SWIG
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' GOSRCS='example.go $(GOSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' go_clean
+ if [ -n '$(SRCDIR)' ]; then \
+ rm -f $(GOSRCS); \
+ fi
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
--- /dev/null
+package example
+
+type CEO interface {
+ Manager
+ deleteManager()
+ IsCEO()
+}
+
+type ceo struct {
+ Manager
+}
+
+func (p *ceo) deleteManager() {
+ DeleteDirectorManager(p.Manager)
+}
+
+func (p *ceo) IsCEO() {}
+
+type overwrittenMethodsOnManager struct {
+ p Manager
+}
+
+func NewCEO(name string) CEO {
+ om := &overwrittenMethodsOnManager{}
+ p := NewDirectorManager(om, name)
+ om.p = p
+
+ return &ceo{Manager: p}
+}
+
+func DeleteCEO(p CEO) {
+ p.deleteManager()
+}
+
+func (p *ceo) GetPosition() string {
+ return "CEO"
+}
virtual std::string getTitle() { return getPosition() + " " + getName(); }
virtual std::string getName() { return name; }
virtual std::string getPosition() const { return "Employee"; }
- virtual ~Employee() { printf("~Employee() @ %p\n", this); }
+ virtual ~Employee() { printf("~Employee() @ %p\n", (void *)this); }
};
const Employee *get_item(int i) {
return list[i];
}
- ~EmployeeList() {
+ ~EmployeeList() {
std::vector<Employee*>::iterator i;
std::cout << "~EmployeeList, deleting " << list.size() << " employees." << std::endl;
for (i=list.begin(); i!=list.end(); i++) {
<H2>Extending a simple C++ class in Go</H2>
<p>
-This example illustrates the extending of a C++ class with cross
-language polymorphism.
-
+This example illustrates how to inherit from a C++ class in Go.
+See the <a href="../../../Doc/Manual/Go.html#Go_director_classes">Go Director
+Classes</a> documentation subsection for an in-depth explanation how to use the
+director feature.
<p>
+
<ul>
-<li><a href="example.h">example.h</a>. Header file containing some enums.
-<li><a href="example.i">example.i</a>. Interface file.
+<li><a href="ceo.go">ceo.go</a>. Go source with the definition of the CEO class.
+<li><a href="example.h">example.h</a>. Header with the definition of the Employee, Manager and EmployeeList classes.
+<li><a href="example.i">example.i</a>. SWIG interface file.
<li><a href="runme.go">runme.go</a>. Sample Go program.
</ul>
"fmt"
)
-type CEO struct{}
-
-func (p *CEO) GetPosition() string {
- return "CEO"
-}
-
func main() {
// Create an instance of CEO, a class derived from the Go
// proxy of the underlying C++ class. The calls to getName()
// and getPosition() are standard, the call to getTitle() uses
// the director wrappers to call CEO.getPosition().
-
- e := NewDirectorManager(new(CEO), "Alice")
+ e := NewCEO("Alice")
fmt.Println(e.GetName(), " is a ", e.GetPosition())
fmt.Println("Just call her \"", e.GetTitle(), "\"")
fmt.Println("----------------------")
// Create a new EmployeeList instance. This class does not
// have a C++ director wrapper, but can be used freely with
// other classes that do.
-
list := NewEmployeeList()
// EmployeeList owns its items, so we must surrender ownership
// treated the same. For items 0, 1, and 2, all methods
// resolve in C++. For item 3, our CEO, GetTitle calls
// GetPosition which resolves in Go. The call to GetPosition
- // is slightly different, however, because of the overidden
+ // is slightly different, however, because of the overridden
// GetPosition() call, since now the object reference has been
// "laundered" by passing through EmployeeList as an
// Employee*. Previously, Go resolved the call immediately in
// CEO, but now Go thinks the object is an instance of class
// Employee. So the call passes through the Employee proxy
// class and on to the C wrappers and C++ director, eventually
- // ending up back at the Java CEO implementation of
+ // ending up back at the Go CEO implementation of
// getPosition(). The call to GetTitle() for item 3 runs the
// C++ Employee::getTitle() method, which in turn calls
// GetPosition(). This virtual method call passes down
- // through the C++ director class to the Java implementation
+ // through the C++ director class to the Go implementation
// in CEO. All this routing takes place transparently.
-
fmt.Println("(position, title) for items 0-3:")
-
fmt.Println(" ", list.Get_item(0).GetPosition(), ", \"", list.Get_item(0).GetTitle(), "\"")
fmt.Println(" ", list.Get_item(1).GetPosition(), ", \"", list.Get_item(1).GetTitle(), "\"")
fmt.Println(" ", list.Get_item(2).GetPosition(), ", \"", list.Get_item(2).GetTitle(), "\"")
// Time to delete the EmployeeList, which will delete all the
// Employee* items it contains. The last item is our CEO,
- // which gets destroyed as well.
+ // which gets destroyed as well and hence there is no need to
+ // call DeleteCEO.
DeleteEmployeeList(list)
fmt.Println("----------------------")
// All done.
-
fmt.Println("Go exit")
}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS = example.c
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS = funcptr.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' go_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
<li><a href="template/index.html">template</a>. C++ templates.
<li><a href="callback/index.html">callback</a>. C++ callbacks using directors.
<li><a href="extend/index.html">extend</a>. Polymorphism using directors.
+<li><a href="director/index.html">director</a>. Example how to utilize the director feature.
</ul>
<h2>Compilation Issues</h2>
</blockquote>
<li>On Unix the compilation of examples is done using the
-file <tt>Example/Makefile</tt>. This makefile performs a manual
-module compilation which is platform specific. When using
-the <tt>6g</tt> or <tt>8g</tt> compiler, the steps look like this
+file <tt>Example/Makefile</tt>. Normally builds are done simply
+using <tt>go build</tt>. For testing purposes this makefile performs
+a manual module compilation that is platform specific. When using
+the <tt>gc</tt> compiler, the steps look approximately like this
(GNU/Linux):
<blockquote>
<pre>
-% swig -go interface.i
-% gcc -fpic -c interface_wrap.c
-% gcc -shared interface_wrap.o $(OBJS) -o interfacemodule.so
-% 6g interface.go
-% 6c interface_gc.c
-% gopack grc interface.a interface.6 interface_gc.6
-% 6l program.6
+% swig -go -cgo interface.i
+% mkdir -p gopath/src/interface
+% cp interface_wrap.c interface_wrap.h interface.go gopath/src/interface
+% GOPATH=`pwd`/gopath
+% export GOPATH
+% cd gopath/src/interface
+% go build
+% go tool compile $(SRCDIR)/runme.go
+% go tool link -o runme runme.o
</pre>
</blockquote>
<blockquote>
<pre>
-% swig -go interface.i
-% gcc -c interface_wrap.c
-% gccgo -c interface.go
-% gccgo program.o interface.o interface_wrap.o
+% swig -go -cgo interface.i
+% mkdir -p gopath/src/interface
+% cp interface_wrap.c interface_wrap.h interface.go gopath/src/interface
+% GOPATH=`pwd`/gopath
+% export GOPATH
+% cd gopath/src/interface
+% go build
+% gccgo -c $(SRCDIR)/runme.go
+% gccgo -o runme runme.o interface.a
</pre>
</blockquote
</ul>
All of the examples were last tested with the following configuration
-(10 May 2010):
+(5 August 2015):
<ul>
-<li>Ubuntu Hardy
-<li>gcc-4.2.4
+<li>Ubuntu Trusty
+<li>gcc-4.8.4
</ul>
-Your mileage may vary. If you experience a problem, please let us know by
+Your mileage may vary. If you experience a problem, please let us know by
contacting us on the <a href="http://www.swig.org/mail.html">mailing lists</a>.
</body>
</html>
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS = example.c
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS = multimap.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' go_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
%}
/* Return the mutated string as a modified element in the array. */
-%typemap(argout) (char *str, int len)
+%typemap(argout,fragment="AllocateString") (char *str, int len)
%{
{
_gostring_ *a;
a = (_gostring_*) $input.array;
- a[0] = _swig_makegostring($1, $2);
+ a[0] = Swig_AllocateString($1, $2);
}
%}
+%typemap(goargout,fragment="CopyString") (char *str, int len)
+%{
+ $input[0] = swigCopyString($input[0])
+%}
+
%typemap(freearg) (char *str, int len)
%{
free($1);
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS = example.c
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS = pointer.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' go_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS = example.cxx
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS = reference.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' go_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
private:
double x,y,z;
public:
- Vector() : x(0), y(0), z(0) { };
- Vector(double x, double y, double z) : x(x), y(y), z(z) { };
+ Vector() : x(0), y(0), z(0) { }
+ Vector(double x, double y, double z) : x(x), y(y), z(z) { }
friend Vector operator+(const Vector &a, const Vector &b);
char *print();
};
Vector &operator[](int);
int size();
};
-
-
-
-
VectorArray(int maxsize);
~VectorArray();
int size();
-
+
/* This wrapper provides an alternative to the [] operator */
%extend {
Vector &get(int index) {
--- /dev/null
+/* File : example.cxx */
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+#include "example.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+Vector operator+(const Vector &a, const Vector &b) {
+ Vector r;
+ r.x = a.x + b.x;
+ r.y = a.y + b.y;
+ r.z = a.z + b.z;
+ return r;
+}
+
+char *Vector::print() {
+ static char temp[512];
+ sprintf(temp,"Vector %p (%g,%g,%g)", (void *)this, x,y,z);
+ return temp;
+}
+
+VectorArray::VectorArray(int size) {
+ items = new Vector[size];
+ maxsize = size;
+}
+
+VectorArray::~VectorArray() {
+ delete [] items;
+}
+
+Vector &VectorArray::operator[](int index) {
+ if ((index < 0) || (index >= maxsize)) {
+ printf("Panic! Array index out of bounds.\n");
+ exit(1);
+ }
+ return items[index];
+}
+
+int VectorArray::size() {
+ return maxsize;
+}
+
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS = example.c
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS = simple.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' go_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' go_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
<h2>The C++ Code</h2>
-Lets take a templated function and a templated class as follows:
+Let's take a templated function and a templated class as follows:
<blockquote>
<pre>
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS = example.c
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS = variables.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' go
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' go_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' go_clean
printf("dvar = %g\n", dvar);
printf("cvar = %c\n", cvar);
printf("strvar = %s\n", strvar ? strvar : "(null)");
- printf("cstrvar = %s\n", cstrvar ? cstrvar : "(null)");
+ printf("cstrvar = %s\n", cstrvar);
printf("iptrvar = %p\n", iptrvar);
printf("name = %s\n", name);
printf("ptptr = %p (%d, %d)\n", ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile guile_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' guile_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' guile_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='my-guile' INTERFACE='$(INTERFACE)' guile_static_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' guile_clean
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
+ }
double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = my-guile
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_augmented_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' guile_augmented_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' guile_augmented
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' guile_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = matrix.c vector.c
-TARGET = matrix
+TARGET = my-guile
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' GUILE_RUNOPTIONS='-e do-test' guile_augmented_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' GUILE_RUNOPTIONS='-e do-test' guile_augmented_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' LIBS='-lm' guile_augmented
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' guile_clean
Alternatively, use the command-line:
- ./matrix -e do-test -s runme.scm
+ ./my-guile -e do-test -s runme.scm
Or, if your operating system is spiffy enough:
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile guile_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' guile_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' guile
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='my-guile' INTERFACE='$(INTERFACE)' guile_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' guile_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile guile_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' guile_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' guile
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='my-guile' INTERFACE='$(INTERFACE)' guile_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' guile_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
-TARGET = port
+TARGET = my-guile
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_augmented_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' guile_augmented_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' guile_augmented
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' guile_clean
rm -f test.out
This example illustrates the translation from Scheme file ports to
-temporary FILE streams. Read the source and run ./port -s runme.scm
+temporary FILE streams. Read the source and run ./my-guile -s runme.scm
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = my-guile
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_augmented_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' guile_augmented_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' guile_augmented
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' guile_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS =
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile guile_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' guile_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' guile_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='my-guile' INTERFACE='$(INTERFACE)' guile_static_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' guile_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' guile_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java_cpp
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
#include "example.h"
%}
-%include "std_string.i"
-
/* turn on director wrapping Callback */
%feature("director") Callback;
funcptr
multimap
native
+nested
pointer
reference
simple
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java_cpp
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
-
-
-
-
-
/* Let's just grab the original header file here */
%include "example.h"
-
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
virtual double area() = 0;
virtual double perimeter() = 0;
private:
double radius;
public:
- Circle(double r) : radius(r) { };
+ Circle(double r) : radius(r) { }
virtual double area();
virtual double perimeter();
};
private:
double width;
public:
- Square(double w) : width(w) { };
+ Square(double w) : width(w) { }
virtual double area();
virtual double perimeter();
};
<ul>
<li>This high-level interface using proxy classes is not the only way to handle C++ code.
-A low level interface using c functions to access member variables and member functions is the alternative SWIG
-approach. This entails passing around the c pointer or c++ 'this' pointer and as such it is not difficult to crash the JVM.
+A low level interface using C functions to access member variables and member functions is the alternative SWIG
+approach. This entails passing around the C pointer or C++ 'this' pointer and as such it is not difficult to crash the JVM.
The abstraction of the underlying pointer by the java proxy classes far better fits the java programming paradigm.
<p>
-<li>SWIG *does* know how to properly perform upcasting of objects in an inheritance
+<li>SWIG <b>does</b> know how to properly perform upcasting of objects in an inheritance
hierarchy (including multiple inheritance). However Java classes can only derive from one base class so multiple inheritance
is not implemented. Java classes can implement more than one interface so there is scope for improvement in the future.
-<p>
-<li>A wide variety of C++ features are not currently supported by SWIG. Here is the
-short and incomplete list:
-
-<p>
-<ul>
-<li>Overloaded methods and functions. SWIG wrappers don't know how to resolve name
-conflicts so you must give an alternative name to any overloaded method name using the
-%name directive like this:
-
-<blockquote>
-<pre>
-void foo(int a);
-%name(foo2) void foo(double a, double b);
-</pre>
-</blockquote>
-
-<p>
-<li>Overloaded operators. Not supported at all. The only workaround for this is
-to write a helper function. For example:
-
-<blockquote>
-<pre>
-%inline %{
- Vector *vector_add(Vector *a, Vector *b) {
- ... whatever ...
- }
-%}
-</pre>
-</blockquote>
-
-<p>
-<li>Namespaces. Not supported at all. Won't be supported until SWIG2.0 (if at all).
-
-</ul>
</ul>
<hr>
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT =
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java_cpp
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java_cpp
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java_cpp
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
virtual std::string getTitle() { return getPosition() + " " + getName(); }
virtual std::string getName() { return name; }
virtual std::string getPosition() const { return "Employee"; }
- virtual ~Employee() { printf("~Employee() @ %p\n", this); }
+ virtual ~Employee() { printf("~Employee() @ %p\n", (void *)this); }
};
// methods of all these instances are treated the same. For items 0, 1, and
// 2, all methods resolve in C++. For item 3, our CEO, getTitle calls
// getPosition which resolves in Java. The call to getPosition is
- // slightly different, however, because of the overidden getPosition() call, since
+ // slightly different, however, because of the overridden getPosition() call, since
// now the object reference has been "laundered" by passing through
// EmployeeList as an Employee*. Previously, Java resolved the call
// immediately in CEO, but now Java thinks the object is an instance of
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT =
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS = example.cxx
+TARGET = example
+INTERFACE = example.i
+SWIGOPT =
+JAVASRCS = *.java
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
--- /dev/null
+#include "example.h"
+
+int MotorCar::DesignOpinion::AceDesignCount = 0;
+int MotorCar::DesignOpinion::TotalDesignCount = 0;
+
+int MotorCar::DesignOpinion::PercentScore() {
+ return AceDesignCount*100/TotalDesignCount;
+}
+
+MotorCar::Wheels::Wheels(Shape shape, size_t count) : shape(shape), count(count) {}
+
+MotorCar::WindScreen::WindScreen(bool opaque) : opaque(opaque) {}
+
+MotorCar::MotorCar(const std::string &name, const Wheels &wheels, const WindScreen &windscreen) : name(name), wheels(wheels), windscreen(windscreen) {}
+
+MotorCar MotorCar::DesignFromComponents(const std::string &name, const Wheels &wheels, const WindScreen &windscreen) {
+ MotorCar car = MotorCar(name, wheels, windscreen);
+ DesignOpinion::TotalDesignCount++;
+ if (car.wheels.Opinion().itrocks && car.windscreen.Opinion().itrocks)
+ DesignOpinion::AceDesignCount++;
+ return car;
+}
+
+MotorCar::DesignOpinion MotorCar::Wheels::Opinion() {
+ DesignOpinion opinion;
+ opinion.itrocks = true;
+ if (shape == Square) {
+ opinion.itrocks = false;
+ opinion.reason = "you'll have a few issues with wheel rotation";
+ }
+ if (count <= 2) {
+ opinion.reason += opinion.itrocks ? "" : " and ";
+ opinion.itrocks = false;
+ opinion.reason += "a few more wheels are needed for stability";
+ }
+ if (opinion.itrocks)
+ opinion.reason = "your choice of wheels was top notch";
+
+ return opinion;
+}
+
+MotorCar::DesignOpinion MotorCar::WindScreen::Opinion() {
+ DesignOpinion opinion;
+ opinion.itrocks = !opaque;
+ opinion.reason = opinion.itrocks ? "the driver will have a commanding view out the window" : "you can't see out the windscreen";
+ return opinion;
+}
+
+std::string MotorCar::WillItWork() {
+ DesignOpinion wh = wheels.Opinion();
+ DesignOpinion ws = windscreen.Opinion();
+ std::string willit;
+ if (wh.itrocks && ws.itrocks) {
+ willit = "Great car design because " + wh.reason + " and " + ws.reason;
+ } else {
+ willit = "You need a rethink because ";
+ willit += wh.itrocks ? "" : wh.reason;
+ willit += (!wh.itrocks && !ws.itrocks) ? " and " : "";
+ willit += ws.itrocks ? "" : ws.reason;
+ }
+ return willit;
+}
--- /dev/null
+# Microsoft Developer Studio Project File - Name="example" - Package Owner=<4>\r
+# Microsoft Developer Studio Generated Build File, Format Version 6.00\r
+# ** DO NOT EDIT **\r
+\r
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102\r
+\r
+CFG=example - Win32 Release\r
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,\r
+!MESSAGE use the Export Makefile command and run\r
+!MESSAGE \r
+!MESSAGE NMAKE /f "example.mak".\r
+!MESSAGE \r
+!MESSAGE You can specify a configuration when running NMAKE\r
+!MESSAGE by defining the macro CFG on the command line. For example:\r
+!MESSAGE \r
+!MESSAGE NMAKE /f "example.mak" CFG="example - Win32 Release"\r
+!MESSAGE \r
+!MESSAGE Possible choices for configuration are:\r
+!MESSAGE \r
+!MESSAGE "example - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")\r
+!MESSAGE "example - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")\r
+!MESSAGE \r
+\r
+# Begin Project\r
+# PROP AllowPerConfigDependencies 0\r
+# PROP Scc_ProjName ""\r
+# PROP Scc_LocalPath ""\r
+CPP=cl.exe\r
+MTL=midl.exe\r
+RSC=rc.exe\r
+\r
+!IF "$(CFG)" == "example - Win32 Debug"\r
+\r
+# PROP BASE Use_MFC 0\r
+# PROP BASE Use_Debug_Libraries 1\r
+# PROP BASE Output_Dir "Debug"\r
+# PROP BASE Intermediate_Dir "Debug"\r
+# PROP BASE Target_Dir ""\r
+# PROP Use_MFC 0\r
+# PROP Use_Debug_Libraries 1\r
+# PROP Output_Dir "Debug"\r
+# PROP Intermediate_Dir "Debug"\r
+# PROP Ignore_Export_Lib 0\r
+# PROP Target_Dir ""\r
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE_EXPORTS" /YX /FD /GZ /c\r
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "$(JAVA_INCLUDE)" /I "$(JAVA_INCLUDE)\win32" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE_EXPORTS" /YX /FD /GZ /c\r
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32\r
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32\r
+# ADD BASE RSC /l 0x809 /d "_DEBUG"\r
+# ADD RSC /l 0x809 /d "_DEBUG"\r
+BSC32=bscmake.exe\r
+# ADD BASE BSC32 /nologo\r
+# ADD BSC32 /nologo\r
+LINK32=link.exe\r
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /dll /debug /machine:I386 /pdbtype:sept\r
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /dll /debug /machine:I386 /out:"example.dll" /pdbtype:sept\r
+# Begin Special Build Tool\r
+SOURCE="$(InputPath)"\r
+PostBuild_Desc=Java compile post-build step\r
+PostBuild_Cmds=echo on "%JAVA_BIN%\javac" *.java\r
+# End Special Build Tool\r
+\r
+!ELSEIF "$(CFG)" == "example - Win32 Release"\r
+\r
+# PROP BASE Use_MFC 0\r
+# PROP BASE Use_Debug_Libraries 0\r
+# PROP BASE Output_Dir "Release"\r
+# PROP BASE Intermediate_Dir "Release"\r
+# PROP BASE Target_Dir ""\r
+# PROP Use_MFC 0\r
+# PROP Use_Debug_Libraries 0\r
+# PROP Output_Dir "Release"\r
+# PROP Intermediate_Dir "Release"\r
+# PROP Ignore_Export_Lib 0\r
+# PROP Target_Dir ""\r
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE_EXPORTS" /YX /FD /c\r
+# ADD CPP /nologo /MT /W3 /GX /O2 /I "$(JAVA_INCLUDE)" /I "$(JAVA_INCLUDE)\win32" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE_EXPORTS" /YX /FD /c\r
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32\r
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32\r
+# ADD BASE RSC /l 0x809 /d "NDEBUG"\r
+# ADD RSC /l 0x809 /d "NDEBUG"\r
+BSC32=bscmake.exe\r
+# ADD BASE BSC32 /nologo\r
+# ADD BSC32 /nologo\r
+LINK32=link.exe\r
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /dll /machine:I386\r
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /dll /machine:I386 /out:"example.dll"\r
+# Begin Special Build Tool\r
+SOURCE="$(InputPath)"\r
+PostBuild_Desc=Java compile post-build step\r
+PostBuild_Cmds=echo on "%JAVA_BIN%\javac" *.java\r
+# End Special Build Tool\r
+\r
+!ENDIF \r
+\r
+# Begin Target\r
+\r
+# Name "example - Win32 Debug"\r
+# Name "example - Win32 Release"\r
+# Begin Group "Source Files"\r
+\r
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"\r
+# Begin Source File\r
+\r
+SOURCE=.\example.cxx\r
+# End Source File\r
+# Begin Source File\r
+\r
+SOURCE=.\example_wrap.cxx\r
+# End Source File\r
+# End Group\r
+# Begin Group "Header Files"\r
+\r
+# PROP Default_Filter "h;hpp;hxx;hm;inl"\r
+# Begin Source File\r
+\r
+SOURCE=.\example.h\r
+# End Source File\r
+# End Group\r
+# Begin Group "Resource Files"\r
+\r
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"\r
+# End Group\r
+# Begin Source File\r
+\r
+SOURCE=.\example.i\r
+\r
+!IF "$(CFG)" == "example - Win32 Debug"\r
+\r
+# Begin Custom Build\r
+InputPath=.\example.i\r
+InputName=example\r
+\r
+"$(InputName)_wrap.cxx" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\r
+ echo In order to function correctly, please ensure the following environment variables are correctly set: \r
+ echo JAVA_INCLUDE: %JAVA_INCLUDE% \r
+ echo JAVA_BIN: %JAVA_BIN% \r
+ echo on \r
+ ..\..\..\swig.exe -c++ -java "$(InputPath)" \r
+ \r
+# End Custom Build\r
+\r
+!ELSEIF "$(CFG)" == "example - Win32 Release"\r
+\r
+# Begin Custom Build\r
+InputPath=.\example.i\r
+InputName=example\r
+\r
+"$(InputName)_wrap.cxx" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\r
+ echo In order to function correctly, please ensure the following environment variables are correctly set: \r
+ echo JAVA_INCLUDE: %JAVA_INCLUDE% \r
+ echo JAVA_BIN: %JAVA_BIN% \r
+ echo on \r
+ ..\..\..\swig.exe -c++ -java "$(InputPath)" \r
+ \r
+# End Custom Build\r
+\r
+!ENDIF \r
+\r
+# End Source File\r
+# End Target\r
+# End Project\r
--- /dev/null
+#include <string>
+
+/** Design a motor car from various components */
+struct MotorCar {
+
+ /** Information about an opinion of the design of a car component */
+ struct DesignOpinion {
+ bool itrocks;
+ std::string reason;
+ static int AceDesignCount;
+ static int TotalDesignCount;
+ static int PercentScore();
+ };
+
+ /** Wheels component */
+ struct Wheels {
+ enum Shape { Round, Square };
+ Wheels(Shape shape, size_t count);
+ DesignOpinion Opinion();
+ private:
+ Shape shape;
+ size_t count;
+ };
+
+ /** Windscreen component */
+ struct WindScreen {
+ WindScreen(bool opaque);
+ DesignOpinion Opinion();
+ private:
+ bool opaque;
+ };
+
+ /** Factory method for creating a car */
+ static MotorCar DesignFromComponents(const std::string &name, const Wheels &wheels, const WindScreen &windscreen);
+
+ std::string Name() {
+ return name;
+ }
+
+ /** Get an overall opinion on the car design */
+ std::string WillItWork();
+
+private:
+ MotorCar(const std::string &name, const Wheels &wheels, const WindScreen &windscreen);
+ std::string name;
+ Wheels wheels;
+ WindScreen windscreen;
+};
--- /dev/null
+%module example
+
+// This example shows how wrappers for numerous aspects of C++ nested classes work:
+// Nested static and instance variables and methods and nested enums
+
+%include <std_string.i>
+
+%{
+#include "example.h"
+%}
+
+%include "example.h"
+
--- /dev/null
+// This example illustrates wrapping of nested C++ classes
+
+public class runme {
+ static {
+ try {
+ System.loadLibrary("example");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[])
+ {
+ MotorCar car1 = MotorCar.DesignFromComponents("Bumpy", new MotorCar.Wheels(MotorCar.Wheels.Shape.Square, 4), new MotorCar.WindScreen(false));
+ MotorCar car2 = MotorCar.DesignFromComponents("Wobbly", new MotorCar.Wheels(MotorCar.Wheels.Shape.Round, 2), new MotorCar.WindScreen(false));
+ MotorCar car3 = MotorCar.DesignFromComponents("Batty", new MotorCar.Wheels(MotorCar.Wheels.Shape.Round, 4), new MotorCar.WindScreen(true));
+ MotorCar car4 = MotorCar.DesignFromComponents("Spiffing", new MotorCar.Wheels(MotorCar.Wheels.Shape.Round, 4), new MotorCar.WindScreen(false));
+
+ System.out.println("Expert opinion on " + car1.Name() + " : \n " + car1.WillItWork());
+ System.out.println("Expert opinion on " + car2.Name() + " : \n " + car2.WillItWork());
+ System.out.println("Expert opinion on " + car3.Name() + " : \n " + car3.WillItWork());
+ System.out.println("Expert opinion on " + car4.Name() + " : \n " + car4.WillItWork());
+
+ int count = MotorCar.DesignOpinion.getAceDesignCount();
+ int total = MotorCar.DesignOpinion.getTotalDesignCount();
+ int percent = MotorCar.DesignOpinion.PercentScore();
+ System.out.println("Overall opinion rating on car design is " + count + "/" + total + " = " + percent + "%");
+
+ System.out.println("Single square wheel thoughts: " + new MotorCar.Wheels(MotorCar.Wheels.Shape.Square, 1).Opinion().getReason());
+ }
+}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
%apply int *OUTPUT { int *r };
extern int divide(int n, int d, int *r);
-
-
-
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java_cpp
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
char *Vector::print() {
static char temp[512];
- sprintf(temp,"Vector %p (%g,%g,%g)", this, x,y,z);
+ sprintf(temp,"Vector %p (%g,%g,%g)", (void *)this, x,y,z);
return temp;
}
private:
double x,y,z;
public:
- Vector() : x(0), y(0), z(0) { };
- Vector(double x, double y, double z) : x(x), y(y), z(z) { };
+ Vector() : x(0), y(0), z(0) { }
+ Vector(double x, double y, double z) : x(x), y(y), z(z) { }
friend Vector operator+(const Vector &a, const Vector &b);
char *print();
};
Vector &operator[](int);
int size();
};
-
-
-
-
VectorArray(int maxsize);
~VectorArray();
int size();
-
+
/* This wrapper provides an alternative to the [] operator */
%extend {
Vector &get(int index) {
}
}
};
-
-
-
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT =
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java_cpp
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
<h2>The C++ Code</h2>
-Lets take a templated function and a templated class as follows:
+Let's take a templated function and a templated class as follows:
<blockquote>
<pre>
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT =
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
JAVASRCS = *.java
check: build
- $(MAKE) -f $(TOP)/Makefile java_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' java
- $(MAKE) -f $(TOP)/Makefile JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' JAVASRCS='$(JAVASRCS)' JAVAFLAGS='$(JAVAFLAGS)' java_compile
clean:
- $(MAKE) -f $(TOP)/Makefile java_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' java_clean
printf("dvar = %g\n", dvar);
printf("cvar = %c\n", cvar);
printf("strvar = %s\n", strvar ? strvar : "(null)");
- printf("cstrvar = %s\n", cstrvar ? cstrvar : "(null)");
- printf("iptrvar = %p\n", iptrvar);
+ printf("cstrvar = %s\n", cstrvar);
+ printf("iptrvar = %p\n", (void *)iptrvar);
printf("name = %s\n", name);
- printf("ptptr = %p (%d, %d)\n", ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
+ printf("ptptr = %p (%d, %d)\n", (void *)ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
printf("pt = (%d, %d)\n", pt.x, pt.y);
printf("status = %d\n", status);
}
--- /dev/null
+class
+constant
+enum
+exception
+functor
+nspace
+operator
+overload
+pointer
+#reference
+simple
+template
+variables
--- /dev/null
+SRCS = example.cxx
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "<!(cp $srcdir/example.cxx example-gypcopy.cxx && echo example-gypcopy.cxx)", "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"]
+ }
+ ]
+}
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
--- /dev/null
+/* File : example.h */
+
+class Shape {
+public:
+ Shape() {
+ nshapes++;
+ }
+ virtual ~Shape() {
+ nshapes--;
+ }
+ double x, y;
+ void move(double dx, double dy);
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
+ static int nshapes;
+};
+
+class Circle : public Shape {
+private:
+ double radius;
+public:
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
+};
+
+class Square : public Shape {
+private:
+ double width;
+public:
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
+};
--- /dev/null
+/* File : example.i */
+%module example
+
+%{
+#include "example.h"
+%}
+
+/* Let's just grab the original header file here */
+%include "example.h"
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+var example = require("example");
+
+// ----- Object creation -----
+
+console.log("Creating some objects:");
+c = new example.Circle(10);
+console.log("Created circle " + c);
+s = new example.Square(10);
+console.log("Created square " + s);
+
+// ----- Access a static member -----
+console.log("\nA total of " + example.Shape.nshapes + " shapes were created"); // access static member as properties of the class object
+
+// ----- Member data access -----
+// Set the location of the object.
+// Note: methods in the base class Shape are used since
+// x and y are defined there.
+
+c.x = 20;
+c.y = 30;
+s.x = -10;
+s.y = 5;
+
+console.log("\nHere is their new position:");
+console.log("Circle = (" + c.x + "," + c.y + ")");
+console.log("Square = (" + s.x + "," + s.y + ")");
+
+// ----- Call some methods -----
+console.log("\nHere are some properties of the shapes:");
+console.log("Circle:");
+console.log("area = " + c.area() + "");
+console.log("perimeter = " + c.perimeter() + "");
+console.log("\n");
+console.log("Square:");
+console.log("area = " + s.area() + "");
+console.log("perimeter = " + s.perimeter() + "");
+
+// ----- Delete everything -----
+console.log("\nGuess I'll clean up now");
+// Note: this invokes the virtual destructor
+delete c;
+delete s;
+
+console.log(example.Shape.nshapes + " shapes remain");
+
+console.log("Goodbye");
--- /dev/null
+SRCS =
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"]
+ }
+ ]
+}
--- /dev/null
+#define ICONST 42
+#define FCONST 2.1828
+#define CCONST 'x'
+#define CCONST2 '\n'
+#define SCONST "Hello World"
+#define SCONST2 "\"Hello World\""
+#define EXTERN extern
+#define FOO (ICONST + BAR)
--- /dev/null
+/* File : example.i */
+%module example
+
+/* A few preprocessor macros */
+
+#define ICONST 42
+#define FCONST 2.1828
+#define CCONST 'x'
+#define CCONST2 '\n'
+#define SCONST "Hello World"
+#define SCONST2 "\"Hello World\""
+
+/* This should work just fine */
+#define EXPR ICONST + 3*(FCONST)
+
+/* This shouldn't do anything */
+#define EXTERN extern
+
+/* Neither should this (BAR isn't defined) */
+#define FOO (ICONST + BAR)
+
+/* The following directives also produce constants */
+%constant int iconst = 37;
+%constant double fconst = 3.14;
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+var example = require("example");
+
+console.log("ICONST = " + example.ICONST + " (should be 42)");
+console.log("FCONST = " + example.FCONST + " (should be 2.1828)");
+console.log("CCONST = " + example.CCONST + " (should be 'x')");
+console.log("CCONST2 = " + example.CCONST2 + " (this should be on a new line)");
+console.log("SCONST = " + example.SCONST + " (should be 'Hello World')");
+console.log("SCONST2 = " + example.SCONST2 + " (should be '\"Hello World\"')");
+console.log("EXPR = " + example.EXPR + " (should be 48.5484)");
+console.log("iconst = " + example.iconst + " (should be 37)");
+console.log("fconst = " + example.fconst + " (should be 3.14)");
+
+console.log("EXTERN = " + example.EXTERN + " (should be undefined)");
+console.log("FOO = " + example.FOO + " (should be undefined)");
--- /dev/null
+SRCS = example.cxx
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "<!(cp $srcdir/example.cxx example-gypcopy.cxx && echo example-gypcopy.cxx)", "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"]
+ }
+ ]
+}
--- /dev/null
+/* File : example.c */
+
+#include "example.h"
+#include <stdio.h>
+
+void Foo::enum_test(speed s) {
+ if (s == IMPULSE) {
+ printf("IMPULSE speed\n");
+ } else if (s == WARP) {
+ printf("WARP speed\n");
+ } else if (s == LUDICROUS) {
+ printf("LUDICROUS speed\n");
+ } else {
+ printf("Unknown speed\n");
+ }
+}
+
+void enum_test(color c, Foo::speed s) {
+ if (c == RED) {
+ printf("color = RED, ");
+ } else if (c == BLUE) {
+ printf("color = BLUE, ");
+ } else if (c == GREEN) {
+ printf("color = GREEN, ");
+ } else {
+ printf("color = Unknown color!, ");
+ }
+ if (s == Foo::IMPULSE) {
+ printf("speed = IMPULSE speed\n");
+ } else if (s == Foo::WARP) {
+ printf("speed = WARP speed\n");
+ } else if (s == Foo::LUDICROUS) {
+ printf("speed = LUDICROUS speed\n");
+ } else {
+ printf("speed = Unknown speed!\n");
+ }
+}
--- /dev/null
+/* File : example.h */
+
+enum color { RED, BLUE, GREEN };
+
+class Foo {
+ public:
+ Foo() { }
+ enum speed { IMPULSE=10, WARP=20, LUDICROUS=30 };
+ void enum_test(speed s);
+};
+
+void enum_test(color c, Foo::speed s);
+
--- /dev/null
+/* File : example.i */
+%module example
+
+%{
+#include "example.h"
+%}
+
+/* Let's just grab the original header file here */
+
+%include "example.h"
+
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+var example = require("example");
+
+// ----- Object creation -----
+
+// Print out the value of some enums
+console.log("*** color ***");
+console.log(" RED =" + example.RED);
+console.log(" BLUE =" + example.BLUE);
+console.log(" GREEN =" + example.GREEN);
+
+console.log("\n*** Foo::speed ***");
+console.log(" Foo_IMPULSE =" + example.Foo.IMPULSE);
+console.log(" Foo_WARP =" + example.Foo.WARP);
+console.log(" Foo_LUDICROUS =" + example.Foo.LUDICROUS);
+
+console.log("\nTesting use of enums with functions\n");
+
+example.enum_test(example.RED, example.Foo.IMPULSE);
+example.enum_test(example.BLUE, example.Foo.WARP);
+example.enum_test(example.GREEN, example.Foo.LUDICROUS);
+example.enum_test(1234,5678);
+
+console.log("\nTesting use of enum with class method");
+f = new example.Foo();
+
+f.enum_test(example.Foo.IMPULSE);
+f.enum_test(example.Foo.WARP);
+f.enum_test(example.Foo.LUDICROUS);
+
+// enum value BLUE of enum color is accessed as property of cconst
+console.log("example.BLUE= " + example.BLUE);
+
+// enum value LUDICROUS of enum Foo::speed is accessed as as property of cconst
+console.log("example.speed.LUDICROUS= " + example.Foo.LUDICROUS);
--- /dev/null
+# Note: as a convention an example must be in a child directory of this.
+# These paths are relative to such an example directory
+
+ifneq (, $(ENGINE))
+ JSENGINE=$(ENGINE)
+else
+ JSENGINE=node
+endif
+
+ifneq (, $(V8_VERSION))
+ JSV8_VERSION=$(V8_VERSION)
+else
+ JSV8_VERSION=0x031110
+endif
+
+EXAMPLES_TOP = ../..
+SWIG_TOP = ../../..
+SWIGEXE = $(SWIG_TOP)/swig
+SWIG_LIB_DIR = $(SWIG_TOP)/$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+TARGET = example
+INTERFACE = example.i
+SWIGOPT = -$(JSENGINE) -DV8_VERSION=$(JSV8_VERSION)
+
+check: build
+ $(MAKE) -f $(EXAMPLES_TOP)/Makefile SRCDIR='$(SRCDIR)' JSENGINE='$(JSENGINE)' TARGET='$(TARGET)' javascript_run
+
+build:
+ $(MAKE) -f $(EXAMPLES_TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' javascript_wrapper_cpp
+ $(MAKE) -f $(EXAMPLES_TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' JSENGINE='$(JSENGINE)' javascript_build_cpp
+
+clean:
+ $(MAKE) -f $(EXAMPLES_TOP)/Makefile SRCDIR='$(SRCDIR)' javascript_clean
--- /dev/null
+SRCS = example.cxx
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "<!(cp $srcdir/example.cxx example-gypcopy.cxx && echo example-gypcopy.cxx)", "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"],
+ 'defines': [
+ 'BUILDING_NODE_EXTENSION=1',
+ ],
+ 'conditions': [
+ ['OS=="mac"',
+ {
+ 'xcode_settings': {
+ 'GCC_ENABLE_CPP_RTTI': 'YES',
+ 'GCC_ENABLE_CPP_EXCEPTIONS' : 'YES'
+ }
+ }
+ ],
+ ['OS=="linux" or OS=="freebsd" or OS=="openbsd" or OS=="solaris"',
+ {
+ 'cflags': [ "-Wno-unused-variable", "-Wno-unused-but-set-variable", "-Wno-unused-but-set-parameter"],
+ 'cflags_cc': [ "-Wno-unused-variable", "-Wno-unused-but-set-variable", "-Wno-unused-but-set-parameter"],
+ 'cflags!': [ '-fno-exceptions' ],
+ 'cflags_cc!': [ '-fno-exceptions', '-fno-rtti' ]
+ }
+ ]
+ ]
+ }
+ ]
+}
--- /dev/null
+/* File : example.h */
+
+#include <string.h>
+#ifndef SWIG
+struct A {
+};
+#endif
+
+class Exc {
+public:
+ Exc(int c, const char *m) {
+ code = c;
+ strncpy(msg,m,256);
+ }
+ int code;
+ char msg[256];
+};
+
+#if defined(_MSC_VER)
+ #pragma warning(disable: 4290) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
+#endif
+
+class Test {
+public:
+ int simple() throw(int) {
+ throw(37);
+ return 1;
+ }
+ int message() throw(const char *) {
+ throw("I died.");
+ return 1;
+ }
+ int hosed() throw(Exc) {
+ throw(Exc(42,"Hosed"));
+ return 1;
+ }
+ int unknown() throw(A*) {
+ static A a;
+ throw &a;
+ return 1;
+ }
+ int multi(int x) throw(int, const char *, Exc) {
+ if (x == 1) throw(37);
+ if (x == 2) throw("Bleah!");
+ if (x == 3) throw(Exc(42,"No-go-diggy-die"));
+ return 1;
+ }
+};
+
+#if defined(_MSC_VER)
+ #pragma warning(default: 4290) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
+#endif
+
--- /dev/null
+/* File : example.i */
+%module example
+
+%{
+#include "example.h"
+%}
+
+%include "std_string.i"
+
+/* Let's just grab the original header file here */
+%include "example.h"
+
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+var example = require("example");
+
+console.log("Trying to catch some exceptions.");
+t = new example.Test();
+try{
+ t.unknown();
+ throw -1;
+} catch(error)
+{
+ if(error == -1) {
+ console.log("t.unknown() didn't throw");
+ } else {
+ console.log("successfully catched throw in Test::unknown().");
+ }
+}
+
+try{
+ t.simple();
+ throw -1;
+}
+catch(error){
+ if(error == -1) {
+ console.log("t.simple() did not throw");
+ } else {
+ console.log("successfully catched throw in Test::simple().");
+ }
+}
+
+try{
+ t.message();
+ throw -1;
+} catch(error){
+ if(error == -1) {
+ console.log("t.message() did not throw");
+ } else {
+ console.log("successfully catched throw in Test::message().");
+ }
+}
+
+try{
+ t.hosed();
+ throw -1;
+}
+catch(error){
+ if(error == -1) {
+ console.log("t.hosed() did not throw");
+ } else {
+ console.log("successfully catched throw in Test::hosed().");
+ }
+}
+
+for (var i=1; i<4; i++) {
+ try{
+ t.multi(i);
+ throw -1;
+ }
+ catch(error){
+ if(error == -1) {
+ console.log("t.multi(" + i + ") did not throw");
+ } else {
+ console.log("successfully catched throw in Test::multi().");
+ }
+ }
+}
--- /dev/null
+SRCS =
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"]
+ }
+ ]
+}
--- /dev/null
+/* File : example.i */
+%module example
+
+
+%inline %{
+// From B. Strousjoup, "The C++ Programming Language, Third Edition", p. 514
+template<class T> class Sum {
+ T res;
+public:
+ Sum(T i = 0) : res(i) { }
+ void operator() (T x) { res += x; }
+ T result() const { return res; }
+};
+
+%}
+
+%rename(call) *::operator(); // the fn call operator
+
+// Instantiate a few versions
+%template(intSum) Sum<int>;
+%template(doubleSum) Sum<double>;
+
+
+
+
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+var example = require("example");
+
+a = new example.intSum(0);
+b = new example.doubleSum(100.0);
+
+// Use the objects. They should be callable just like a normal
+// javascript function.
+
+for (i=1;i<=100;i++)
+ a.call(i); // Note: function call
+ b.call(Math.sqrt(i)); // Note: function call
+
+console.log(a.result());
+console.log(b.result());
+
--- /dev/null
+SRCS =
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"]
+ }
+ ]
+}
--- /dev/null
+#ifndef _example_guardian_
+#define _example_guardian_
+
+int module_function() { return 7; }
+int module_variable = 9;
+
+namespace MyWorld {
+ class World {
+ public:
+ World() : world_max_count(9) {}
+ int create_world() { return 17; }
+ const int world_max_count; // = 9
+ };
+ namespace Nested {
+ class Dweller {
+ public:
+ enum Gender { MALE = 0, FEMALE = 1 };
+ static int count() { return 19; }
+ };
+ }
+}
+
+#endif
--- /dev/null
+%module example
+
+%{
+#include "example.h"
+%}
+
+%nspace MyWorld::Nested::Dweller;
+%nspace MyWorld::World;
+
+%include "example.h"
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+// File: runme.js
+
+// This file illustrates class C++ interface generated
+// by SWIG.
+
+var example = require("example");
+
+// Calling a module function ( aka global function )
+if (example.module_function() !== 7) {
+ throw new Error("example.module_function() should equal 7");
+}
+console.log("example.module_function(): " + example.module_function());
+
+// Accessing a module (aka global) variable
+if (example.module_variable !== 9) {
+ throw new Error("example.module_variable should equal 9");
+}
+console.log("example.module_variable: " + example.module_variable);
+
+// Creating an instance of the class
+var w1 = new example.MyWorld.World();
+console.log("Creating class instance: w1 = new example.MyWorld.World(): " + w1);
+
+// Accessing class members
+if (w1.create_world() !== 17) {
+ throw new Error("w1.create_world() should equal 17");
+}
+console.log("w1.create_world() = " + w1.create_world());
+
+if (w1.world_max_count !== 9) {
+ throw new Error("w1.world_max_count should equal 9");
+}
+console.log("w1.world_max_count = " + w1.world_max_count);
+
+// Accessing enums from class within namespace
+if (example.MyWorld.Nested.Dweller.MALE !== 0) {
+ throw new Error("example.MyWorld.Nested.Dweller.MALE should equal 0");
+}
+console.log("Accessing enums: ex.MyWorld.Nested.Dweller.MALE = " + example.MyWorld.Nested.Dweller.MALE);
+
+if (example.MyWorld.Nested.Dweller.FEMALE !== 1) {
+ throw new Error("example.MyWorld.Nested.Dweller.FEMALE should equal 1");
+}
+console.log("Accessing enums: ex.MyWorld.Nested.Dweller.FEMALE = " + example.MyWorld.Nested.Dweller.FEMALE);
+
+// Accessing static member function
+if (example.MyWorld.Nested.Dweller.count() !== 19) {
+ throw new Error("example.MyWorld.Nested.Dweller.count() should equal 19");
+}
+console.log("Accessing static member function: ex.MyWorld.Nested.Dweller.count() = " + example.MyWorld.Nested.Dweller.count());
--- /dev/null
+SRCS =
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"]
+ }
+ ]
+}
--- /dev/null
+/* File : example.h */
+#include <math.h>
+
+class Complex {
+private:
+ double rpart, ipart;
+public:
+ Complex(double r = 0, double i = 0) : rpart(r), ipart(i) { }
+ Complex(const Complex &c) : rpart(c.rpart), ipart(c.ipart) { }
+ Complex &operator=(const Complex &c) {
+ rpart = c.rpart;
+ ipart = c.ipart;
+ return *this;
+ }
+ Complex operator+(const Complex &c) const {
+ return Complex(rpart+c.rpart, ipart+c.ipart);
+ }
+ Complex operator-(const Complex &c) const {
+ return Complex(rpart-c.rpart, ipart-c.ipart);
+ }
+ Complex operator*(const Complex &c) const {
+ return Complex(rpart*c.rpart - ipart*c.ipart,
+ rpart*c.ipart + c.rpart*ipart);
+ }
+ Complex operator-() const {
+ return Complex(-rpart, -ipart);
+ }
+
+ double re() const { return rpart; }
+ double im() const { return ipart; }
+};
+
+
+
+
+
--- /dev/null
+/* File : example.i */
+%module example
+#pragma SWIG nowarn=SWIGWARN_IGNORE_OPERATOR_EQ
+%{
+#include "example.h"
+%}
+
+/* This header file is a little tough to handle because it has overloaded
+ operators and constructors. We're going to try and deal with that here */
+
+/* This turns the copy constructor in a function ComplexCopy() that can
+ be called */
+
+%rename(assign) Complex::operator=;
+%rename(plus) Complex::operator+;
+%rename(minus) Complex::operator-(const Complex &) const;
+%rename(uminus) Complex::operator-() const;
+%rename(times) Complex::operator*;
+
+/* Now grab the original header file */
+%include "example.h"
+
+/* An output method that turns a complex into a short string */
+%extend Complex {
+ char *toString() {
+ static char temp[512];
+ sprintf(temp,"(%g,%g)", $self->re(), $self->im());
+ return temp;
+ }
+ static Complex* copy(const Complex& c) {
+ return new Complex(c);
+ }
+};
+
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+var example = require("example");
+
+a = new example.Complex(2,3);
+b = new example.Complex(-5,10);
+
+console.log ("a =" + a);
+console.log ("b =" + b);
+
+c = a.plus(b);
+
+console.log("c =" + c);
+console.log("a*b =" + a.times(b));
+console.log("a-c =" + a.minus(c));
+
+e = example.Complex.copy(a.minus(c));
+console.log("e =" + e);
+
+// Big expression
+f = a.plus(b).times(c.plus(b.times(e))).plus(a.uminus());
+console.log("f =" + f);
+
+
+
+
+
--- /dev/null
+SRCS =
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"]
+ }
+ ]
+}
--- /dev/null
+#include <iostream>
+
+void f() {
+ std::cout << "Called f()." << std::endl;
+}
+
+void f(int val) {
+ std::cout << "Called f(int)." << std::endl;
+}
+void f(int val1, int val2) {
+ std::cout << "Called f(int, int)." << std::endl;
+}
+
+void f(const char* s) {
+ std::cout << "Called f(const char*)." << std::endl;
+}
+
+void f(bool val) {
+ std::cout << "Called f(bool)." << std::endl;
+}
+
+void f(long val) {
+ std::cout << "Called f(long)." << std::endl;
+}
+
+void f(double val) {
+ std::cout << "Called f(double)." << std::endl;
+}
--- /dev/null
+/* File : example.i */
+%module example
+
+%{
+#include "example.h"
+%}
+
+/*
+ Note: overloading is implemented in a sloppy way currently
+ i.e., only the number of arguments is taken into conideration
+ for dispatching.
+ To solve the problem one has to rename such conflicting methods.
+*/
+%rename(f_double) f(double val);
+
+%include "example.h"
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+var example = require("example");
+
+example.f();
+example.f(1);
+example.f(1, 2);
+example.f("bla");
+example.f(false);
+example.f(11111111111);
+example.f_double(1.0);
--- /dev/null
+SRCS = example.cxx
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "<!(cp $srcdir/example.cxx example-gypcopy.cxx && echo example-gypcopy.cxx)", "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"]
+ }
+ ]
+}
--- /dev/null
+/* File : example.c */
+
+void add(int *x, int *y, int *result) {
+ *result = *x + *y;
+}
+
+void subtract(int *x, int *y, int *result) {
+ *result = *x - *y;
+}
+
+int divide(int n, int d, int *r) {
+ int q;
+ q = n/d;
+ *r = n - q*d;
+ return q;
+}
--- /dev/null
+/* File : example.i */
+%module example
+
+%{
+extern void add(int *, int *, int *);
+extern void subtract(int *, int *, int *);
+extern int divide(int, int, int *);
+%}
+
+/* This example illustrates a couple of different techniques
+ for manipulating C pointers */
+
+/* First we'll use the pointer library */
+extern void add(int *x, int *y, int *result);
+%include cpointer.i
+%pointer_functions(int, intp);
+
+/* Next we'll use some typemaps */
+
+%include typemaps.i
+extern void subtract(int *INPUT, int *INPUT, int *OUTPUT);
+
+/* Next we'll use typemaps and the %apply directive */
+
+%apply int *OUTPUT { int *r };
+extern int divide(int n, int d, int *r);
+
+
+
+
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+var example = require("example");
+
+// First create some objects using the pointer library.
+console.log("Testing the pointer library");
+a = example.new_intp();
+b = example.new_intp();
+c = example.new_intp();
+
+example.intp_assign(a,37);
+example.intp_assign(b,42);
+
+console.log(" a = " + example.intp_value(a));
+console.log(" b = " + example.intp_value(b));
+console.log(" c = " + example.intp_value(c));
+
+//// Call the add() function with some pointers
+example.add(a, b, c);
+
+//
+//// Now get the result
+r = example.intp_value(c);
+console.log(" 37 + 42 = " + r);
+
+// Clean up the pointers
+example.delete_intp(a);
+example.delete_intp(b);
+example.delete_intp(c);
+
+//// Now try the typemap library
+//// This should be much easier. Now how it is no longer
+//// necessary to manufacture pointers.
+//"OUTPUT" Mapping is not supported
+//console.log("Trying the typemap library");
+//r = example.subtract(37,42);
+//console.log("37 - 42 =" + r);
--- /dev/null
+SRCS = example.cxx
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "<!(cp $srcdir/example.cxx example-gypcopy.cxx && echo example-gypcopy.cxx)", "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"]
+ }
+ ]
+}
char *Vector::print() {
static char temp[512];
- sprintf(temp,"Vector %p (%g,%g,%g)", this, x,y,z);
+ sprintf(temp,"Vector %p (%g,%g,%g)", (void *)this, x,y,z);
return temp;
}
--- /dev/null
+/* File : example.h */
+
+class Vector {
+private:
+ double x,y,z;
+public:
+ Vector() : x(0), y(0), z(0) { }
+ Vector(double x, double y, double z) : x(x), y(y), z(z) { }
+ friend Vector operator+(const Vector &a, const Vector &b);
+ char *print();
+};
+
+class VectorArray {
+private:
+ Vector *items;
+ int maxsize;
+public:
+ VectorArray(int maxsize);
+ ~VectorArray();
+ Vector &operator[](int);
+ int size();
+};
--- /dev/null
+/* File : example.i */
+
+/* This file has a few "typical" uses of C++ references. */
+
+%module example
+
+%{
+#include "example.h"
+%}
+
+class Vector {
+public:
+ Vector(double x, double y, double z);
+ ~Vector();
+ char *print();
+};
+
+/* This helper function calls an overloaded operator */
+%inline %{
+Vector addv(Vector &a, Vector &b) {
+ return a+b;
+}
+%}
+
+/* Wrapper around an array of vectors class */
+
+class VectorArray {
+public:
+ VectorArray(int maxsize);
+ ~VectorArray();
+ int size();
+
+ /* This wrapper provides an alternative to the [] operator */
+ %extend {
+ Vector &get(int index) {
+ return (*$self)[index];
+ }
+ void set(int index, Vector &a) {
+ (*$self)[index] = a;
+ }
+ }
+};
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+// This file illustrates the manipulation of C++ references in Javascript.
+var example = require("example");
+
+// ----- Object creation -----
+
+console.log("Creating some objects:");
+a = new example.Vector(3,4,5);
+b = new example.Vector(10,11,12);
+
+console.log(" created" + a.print());
+console.log(" created" + b.print());
+
+// ----- Call an overloaded operator -----
+
+// This calls the wrapper we placed around operator+(const Vector &a, const Vector &)
+// It returns a new allocated object.
+
+console.log("Adding a+b");
+c = example.addv(a, b);
+console.log("a+b = " + c.print());
+
+
+// TODO: Note: Unless we free the result, a memory leak will occur
+//delete_Vector(c);
+
+// ----- Create a vector array -----
+
+// Note: Using the high-level interface here
+console.log("Creating an array of vectors");
+va = new example.VectorArray(10);
+console.log("va = " + va);
+
+// ----- Set some values in the array -----
+
+// These operators copy the value of a and b to the vector array
+va.set(0,a);
+va.set(1,b);
+
+// This will work, but it will cause a memory leak!
+va.set(2,example.addv(a,b));
+
+// The non-leaky way to do it
+//c = addv(a,b);
+//va.set(3,c);
+//delete_Vector(c);
+
+// Get some values from the array
+
+console.log("Getting some array values");
+for (i = 0; i < 5; i++) {
+ temp = va.get(i);
+ console.log(i,temp.print());
+}
+
+// Watch under resource meter to check on this
+console.log("Making sure we don't leak memory.");
+for (i = 0; i < 1000000; i++) {
+ c = va.get(i % 10);
+}
+//---------TODO---------
+//----- Clean up -----
+//console.log("Cleaning up");
+
+//example.delete_VectorArray(va);
+//example.delete_Vector(a);
+//example.delete_Vector(b);
+
--- /dev/null
+SRCS = example.cxx
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "<!(cp $srcdir/example.cxx example-gypcopy.cxx && echo example-gypcopy.cxx)", "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"]
+ }
+ ]
+}
--- /dev/null
+/* File : example.c */
+
+/* A global variable */
+double Foo = 3.0;
+
+/* Compute the greatest common divisor of positive integers */
+int gcd(int x, int y) {
+ int g;
+ g = y;
+ while (x > 0) {
+ g = x;
+ x = y % x;
+ y = g;
+ }
+ return g;
+}
+
+
--- /dev/null
+/* File : example.i */
+%module example
+
+%inline %{
+extern int gcd(int x, int y);
+extern double Foo;
+%}
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+var example = require("example");
+
+/* Call our gcd() function */
+
+x = 42;
+y = 105;
+g = example.gcd(x,y);
+console.log("GCD of x and y is=" + g);
+
+/* Manipulate the Foo global variable */
+
+/* Output its current value */
+console.log("Global variable Foo=" + example.Foo);
+
+/* Change its value */
+example.Foo = 3.1415926;
+
+/* See if the change took effect */
+console.log("Variable Foo changed to=" + example.Foo);
+
+
+
+
+
+
+
--- /dev/null
+SRCS =
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"]
+ }
+ ]
+}
--- /dev/null
+/* File : example.h */
+
+// Some template definitions
+
+template<class T> T max(T a, T b) { return a>b ? a : b; }
+
+template<class T> class vector {
+ T *v;
+ int sz;
+ public:
+ vector(int _sz) {
+ v = new T[_sz];
+ sz = _sz;
+ }
+ T &get(int index) {
+ return v[index];
+ }
+ void set(int index, T &val) {
+ v[index] = val;
+ }
+#ifdef SWIG
+ %extend {
+ T getitem(int index) {
+ return $self->get(index);
+ }
+ void setitem(int index, T val) {
+ $self->set(index,val);
+ }
+ }
+#endif
+};
+
--- /dev/null
+/* File : example.i */
+%module example
+
+%{
+#include "example.h"
+%}
+
+/* Let's just grab the original header file here */
+%include "example.h"
+
+/* Now instantiate some specific template declarations */
+
+%template(maxint) max<int>;
+%template(maxdouble) max<double>;
+%template(vecint) vector<int>;
+%template(vecdouble) vector<double>;
+
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+var example = require("example");
+
+//Call some templated functions
+console.log(example.maxint(3,7));
+console.log(example.maxdouble(3.14,2.18));
+
+// Create some class
+
+iv = new example.vecint(100);
+dv = new example.vecdouble(1000);
+
+for(i=0;i<100;i++)
+ iv.setitem(i,2*i);
+
+for(i=0;i<1000;i++)
+ dv.setitem(i, 1.0/(i+1));
+
+sum = 0;
+for(i=0;i<100;i++)
+ sum = sum + iv.getitem(i);
+
+console.log(sum);
+
+sum = 0.0;
+for(i=0;i<1000;i++)
+ sum = sum + dv.getitem(i);
+console.log(sum);
+
+delete iv;
+delete dv;
--- /dev/null
+SRCS = example.cxx
+
+include $(SRCDIR)../example.mk
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "example",
+ "sources": [ "<!(cp $srcdir/example.cxx example-gypcopy.cxx && echo example-gypcopy.cxx)", "example_wrap.cxx" ],
+ "include_dirs": ["$srcdir"]
+ }
+ ]
+}
--- /dev/null
+/* File : example.c */
+
+/* I'm a file containing some C global variables */
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "example.h"
+
+int ivar = 0;
+short svar = 0;
+long lvar = 0;
+unsigned int uivar = 0;
+unsigned short usvar = 0;
+unsigned long ulvar = 0;
+signed char scvar = 0;
+unsigned char ucvar = 0;
+char cvar = 0;
+float fvar = 0;
+double dvar = 0;
+char *strvar = 0;
+#ifdef __cplusplus // Note: for v8 this must be linkable with g++, without extern cstrvar is mangled
+extern const char cstrvar[] = "Goodbye";
+#else
+const char cstrvar[] = "Goodbye";
+#endif
+const
+int *iptrvar = 0;
+char name[256] = "Dave";
+char path[256] = "/home/beazley";
+
+
+/* Global variables involving a structure */
+Point *ptptr = 0;
+Point pt = { 10, 20 };
+
+/* A variable that we will make read-only in the interface */
+int status = 1;
+
+/* A debugging function to print out their values */
+
+void print_vars() {
+ printf("ivar = %d\n", ivar);
+ printf("svar = %d\n", svar);
+ printf("lvar = %ld\n", lvar);
+ printf("uivar = %u\n", uivar);
+ printf("usvar = %u\n", usvar);
+ printf("ulvar = %lu\n", ulvar);
+ printf("scvar = %d\n", scvar);
+ printf("ucvar = %u\n", ucvar);
+ printf("fvar = %g\n", fvar);
+ printf("dvar = %g\n", dvar);
+ printf("cvar = %c\n", cvar);
+ printf("strvar = %s\n", strvar ? strvar : "(null)");
+ printf("cstrvar = %s\n", cstrvar);
+ printf("iptrvar = %p\n", (void *)iptrvar);
+ printf("name = %s\n", name);
+ printf("ptptr = %p (%d, %d)\n", (void *)ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
+ printf("pt = (%d, %d)\n", pt.x, pt.y);
+ printf("status = %d\n", status);
+}
+
+/* A function to create an integer (to test iptrvar) */
+
+int *new_int(int value) {
+ int *ip = (int *) malloc(sizeof(int));
+ *ip = value;
+ return ip;
+}
+
+/* A function to create a point */
+
+Point *new_Point(int x, int y) {
+ Point *p = (Point *) malloc(sizeof(Point));
+ p->x = x;
+ p->y = y;
+ return p;
+}
+
+char * Point_print(Point *p) {
+ static char buffer[256];
+ if (p) {
+ sprintf(buffer,"(%d,%d)", p->x,p->y);
+ } else {
+ sprintf(buffer,"null");
+ }
+ return buffer;
+}
+
+void pt_print() {
+ printf("(%d, %d)\n", pt.x, pt.y);
+}
--- /dev/null
+/* File: example.h */
+
+typedef struct {
+ int x,y;
+} Point;
+
--- /dev/null
+/* File : example.i */
+%module example
+%{
+#include "example.h"
+%}
+
+/* Some global variable declarations */
+%inline %{
+extern int ivar;
+extern short svar;
+extern long lvar;
+extern unsigned int uivar;
+extern unsigned short usvar;
+extern unsigned long ulvar;
+extern signed char scvar;
+extern unsigned char ucvar;
+extern char cvar;
+extern float fvar;
+extern double dvar;
+extern char *strvar;
+extern const char cstrvar[];
+extern int *iptrvar;
+extern char name[256];
+
+extern Point *ptptr;
+extern Point pt;
+%}
+
+
+/* Some read-only variables */
+
+%immutable;
+
+%inline %{
+extern int status;
+extern char path[256];
+%}
+
+%mutable;
+
+/* Some helper functions to make it easier to test */
+%inline %{
+extern void print_vars();
+extern int *new_int(int value);
+extern Point *new_Point(int x, int y);
+extern char *Point_print(Point *p);
+extern void pt_print();
+%}
+
--- /dev/null
+module.exports = require("build/Release/example");
--- /dev/null
+var example = require("example");
+
+// Try to set the values of some global variables
+example.ivar = 42;
+example.svar = -31000;
+example.lvar = 65537;
+example.uivar = 123456;
+example.usvar = 61000;
+example.ulvar = 654321;
+example.scvar = -13;
+example.ucvar = 251;
+example.cvar = "S";
+example.fvar = 3.14159;
+example.dvar = 2.1828;
+example.strvar = "Hello World";
+example.iptrvar= example.new_int(37);
+example.ptptr = example.new_Point(37,42);
+example.name = "Bill";
+
+// Now console.log out the values of the variables
+console.log("Variables (values printed from Javascript)");
+console.log("ivar = " + example.ivar);
+console.log("svar = " + example.svar);
+console.log("lvar = " + example.lvar);
+console.log("uivar = " + example.uivar);
+console.log("usvar = " + example.usvar);
+console.log("ulvar = " + example.ulvar);
+console.log("scvar = " + example.scvar);
+console.log("ucvar = " + example.ucvar);
+console.log("fvar = " + example.fvar);
+console.log("dvar = " + example.dvar);
+console.log("cvar = " + example.cvar);
+console.log("strvar = " + example.strvar);
+console.log("cstrvar = " + example.cstrvar);
+console.log("iptrvar = " + example.iptrvar);
+console.log("name = " + example.name);
+console.log("ptptr = " + example.ptptr + ": " + example.Point_print(example.ptptr));
+console.log("pt = " + example.pt + ": " + example.Point_print(example.pt));
+
+
+console.log("\nVariables (values printed from C)");
+
+example.print_vars();
+
+console.log("\nNow I'm going to try and modify some read only variables");
+
+console.log("Tring to set 'path'");
+try{
+ example.path = "Whoa!";
+ console.log("Hey, what's going on?!?! This shouldn't work");
+}
+catch(e){
+ console.log("Good.");
+}
+
+console.log("Trying to set 'status'");
+try{
+ example.status = 0;
+ console.log("Hey, what's going on?!?! This shouldn't work");
+} catch(e){
+ console.log("Good.");
+}
+
+console.log("\nI'm going to try and update a structure variable.");
+example.pt = example.ptptr;
+console.log("The new value is: ");
+example.pt_print();
+console.log("You should see the value: " + example.Point_print(example.ptptr));
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile lua_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' lua
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mylua' INTERFACE='$(INTERFACE)' lua_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
qsort(arr, len, sizeof(int), compare_int);
}
-// ditto doubles
+/* ditto doubles */
int compare_double(const void * a, const void * b)
{
return (int)( *(double*)a - *(double*)b );
// this adds some lua code directly into the module
// warning: you need the example. prefix if you want it added into the module
-// addmittedly this code is a bit tedious, but its a one off effort
+// admittedly this code is a bit tedious, but its a one off effort
%luacode {
function example.sort_int2(t)
- local len=table.maxn(t) -- the len
+-- local len=table.maxn(t) -- the len - maxn deprecated in 5.3
+ local len=0; for _ in pairs(t) do len=len+1 end
local arr=example.new_int(len)
for i=1,len do
- example.int_setitem(arr,i-1,t[i]) -- note: C index is one less then lua indea
+ example.int_setitem(arr,i-1,t[i]) -- note: C index is one less then lua index
end
example.sort_int(arr,len) -- call the fn
-- copy back
for i=1,len do
- t[i]=example.int_getitem(arr,i-1) -- note: C index is one less then lua indea
+ t[i]=example.int_getitem(arr,i-1) -- note: C index is one less then lua index
end
example.delete_int(arr) -- must delete it
end
--[[ version 1: passing a C array to the code
-lets test call sort_int()
+let's test call sort_int()
this requires a C array, so is the hardest to use]]
ARRAY_SIZE=10
arr=example.new_int(ARRAY_SIZE)
functest
functor
import
+nspace
owner
pointer
simple
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile lua_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' lua_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mylua' INTERFACE='$(INTERFACE)' lua_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
-
-
-
-
-
/* Let's just grab the original header file here */
%include "example.h"
-
-- Note: this invokes the virtual destructor
c=nil
s=nil
-s = 3
-- call gc to make sure they are collected
collectgarbage()
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
-LIBS =
+LIBS =
check: build
- $(MAKE) -f $(TOP)/Makefile lua_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' lua
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mylua' INTERFACE='$(INTERFACE)' lua_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
TARGET = dual
-CXXSRCS = example2_wrap.cxx
+GENCXXSRCS = example2_wrap.cxx
INTERFACE = dual.i
LUA_INTERP = dual.cpp
# This is a little different to normal as we need to static link two modules and a custom interpreter
# We need the external runtime, then swig examples2, and build the module as normal
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' lua_embed_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' lua_embed_run
build:
- $(SWIG) -lua -external-runtime
- $(SWIG) -c++ -lua $(SWIGOPT) example2.i
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ lua_externalhdr
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-c++' INTERFACE='example2.i' lua_swig_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' $(SWIGLIB) GENCXXSRCS='$(GENCXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='example.i' LUA_INTERP='$(LUA_INTERP)' lua_static_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
rm -f swigluarun.h $(TARGET)
/*
-dual.cpp a test for multiple modules and multiple intrepreters staticly linked together.
+dual.cpp a test for multiple modules and multiple interpreters statically linked together.
-Earlier version of lua bindings for SWIG would fail if staticly linked.
+Earlier version of lua bindings for SWIG would fail if statically linked.
What is happening is as follows:
example.i declares a type Foo
#include <stdio.h>
#include <stdlib.h>
-// the 2 libraries which are wrappered via SWIG
+// the 2 libraries which are wrapped via SWIG
extern "C" int luaopen_example(lua_State*L);
extern "C" int luaopen_example2(lua_State*L);
#define DEBUG2(X,Y) {printf(X,Y);fflush(stdout);}
#define DEBUG3(X,Y,Z) {printf(X,Y,Z);fflush(stdout);}
+#if LUA_VERSION_NUM > 501
+#define lua_open luaL_newstate
+#endif
+
void testModule(lua_State *L)
{
swig_type_info *pTypeInfo=0,*pTypeInfo2=0;
swig_module_info *pModule=0;
pModule=SWIG_GetModule(L);
- DEBUG2(" SWIG_GetModule() returns %p\n",pModule)
+ DEBUG2(" SWIG_GetModule() returns %p\n", (void *)pModule)
if(pModule==0) return;
pTypeInfo = SWIG_TypeQuery(L,"Foo *");
DEBUG2(" Type (Foo*) is %s\n",pTypeInfo==0?"unknown":"known");
- DEBUG3(" Module %p typeinfo(Foo*) %p\n",pModule,pTypeInfo);
+ DEBUG3(" Module %p typeinfo(Foo*) %p\n", (void *)pModule, (void *)pTypeInfo);
pTypeInfo2 = SWIG_TypeQuery(L,"Bar *");
DEBUG2(" Type (Bar*) is %s\n",pTypeInfo2==0?"unknown":"known");
- DEBUG3(" Module %p typeinfo(Bar*) %p\n",pModule,pTypeInfo2);
+ DEBUG3(" Module %p typeinfo(Bar*) %p\n", (void *)pModule, (void *)pTypeInfo2);
}
int main(int argc,char* argv[])
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
TARGET = embed
SRCS = example.c
INTERFACE = example.i
LUA_INTERP = embed.c
+LIBS = -lm
# this is a little different to normal as we have our own special interpreter
# which we want to static link
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' lua_embed_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' lua_embed_run
build:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) SRCS='$(SRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='example.i' LUA_INTERP='$(LUA_INTERP)' lua_static
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' $(SWIGLIB) SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' LIBS='$(LIBS)' INTERFACE='example.i' LUA_INTERP='$(LUA_INTERP)' lua_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
rm -f $(TARGET)
-/* embed.c a simple test for an embeded interpreter
+/* embed.c a simple test for an embedded interpreter
The idea is that we wrapper a few simple function (example.c)
and write our own app to call it.
-What it will do is load the wrappered lib, load runme.lua and then call some functions.
+What it will do is load the wrapped lib, load runme.lua and then call some functions.
To make life easier, all the printf's have either [C] or [Lua] at the start
so you can see where they are coming from.
#include <stdlib.h>
#include <stdio.h>
+#include <string.h>
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
+#if LUA_VERSION_NUM > 501
+#define lua_open luaL_newstate
+#endif
+
/* the SWIG wrappered library */
extern int luaopen_example(lua_State*L);
/* a really simple way of calling lua from C
just give it a lua state & a string to execute
Unfortunately lua keeps changing its API's.
-In lua 5.0.X its lua_dostring()
-In lua 5.1.X its luaL_dostring()
+In lua 5.0.X it's lua_dostring()
+In lua 5.1.X it's luaL_dostring()
so we have a few extra compiles
*/
int dostring(lua_State *L, char* str) {
luaopen_base(L);
luaopen_string(L);
luaopen_math(L);
- printf("[C] now loading the SWIG wrappered library\n");
+ printf("[C] now loading the SWIG wrapped library\n");
luaopen_example(L);
printf("[C] all looks ok\n");
printf("\n");
- printf("[C] lets load the file 'runme.lua'\n");
+ if (argc != 2 || argv[1] == NULL || strlen(argv[1]) == 0) {
+ printf("[C] ERROR: no lua file given on command line\n");
+ exit(3);
+ }
+ printf("[C] let's load the file '%s'\n", argv[1]);
printf("[C] any lua code in this file will be executed\n");
- if (luaL_loadfile(L, "runme.lua") || lua_pcall(L, 0, 0, 0)) {
+ if (luaL_loadfile(L, argv[1]) || lua_pcall(L, 0, 0, 0)) {
printf("[C] ERROR: cannot run lua file: %s",lua_tostring(L, -1));
exit(3);
}
printf("[C] We are now back in C, all looks ok\n");
printf("\n");
- printf("[C] lets call the function 'do_tests()'\n");
+ printf("[C] let's call the function 'do_tests()'\n");
ok=dostring(L,"do_tests()");
printf("[C] We are back in C, the dostring() function returned %d\n",ok);
printf("\n");
- printf("[C] Lets call lua again, but create an error\n");
+ printf("[C] Let's call lua again, but create an error\n");
ok=dostring(L,"no_such_function()");
printf("[C] We are back in C, the dostring() function returned %d\n",ok);
printf("[C] it should also have returned 1 and printed an error message\n");
printf("\n");
- printf("[C] Lets call lua again, calling the greeting function\n");
+ printf("[C] Let's call lua again, calling the greeting function\n");
ok=dostring(L,"call_greeting()");
printf("[C] This was C=>Lua=>C (getting a bit complex)\n");
printf("\n");
print "[lua] This is runme.lua"
--- test program for embeded lua
--- we do not need to load the library, as it was already in the intrepreter
--- but lets check anyway
+-- test program for embedded lua
+-- we do not need to load the library, as it was already in the interpreter
+-- but let's check anyway
assert(type(example)=='table',"Don't appear to have loaded the example module")
-- a test function to run the tests
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
TARGET = embed2
SRCS = example.c
INTERFACE = example.i
LUA_INTERP = embed2.c
+LIBS = -lm
# this is a little different to normal as we have our own special interpreter
# which we want to static link
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' lua_embed_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' lua_embed_run
build:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) SRCS='$(SRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='example.i' LUA_INTERP='$(LUA_INTERP)' lua_static
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' $(SWIGLIB) SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' LIBS='$(LIBS)' INTERFACE='example.i' LUA_INTERP='$(LUA_INTERP)' lua_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
rm -f $(TARGET)
-/* embed2.c some more test for an embeded interpreter
+/* embed2.c some more tests for an embedded interpreter
This will go a bit further as it will pass values to and from the lua code.
It uses less of the SWIG code, and more of the raw lua API's
-What it will do is load the wrappered lib, load runme.lua and then call some functions.
+What it will do is load the wrapped lib, load runme.lua and then call some functions.
To make life easier, all the printf's have either [C] or [Lua] at the start
so you can see where they are coming from.
#include <stdlib.h>
#include <stdio.h>
+#include <string.h>
#include <lua.h>
#include <lauxlib.h>
#include <stdarg.h>
#include <string.h>
+#if LUA_VERSION_NUM > 501
+#define lua_open luaL_newstate
+#endif
-/* the SWIG wrappered library */
+/* the SWIG wrapped library */
extern int luaopen_example(lua_State*L);
/* This is an example of how to call the Lua function
int add(int,int)
- its very tedious, but gives you an idea of the issues involded.
+ its very tedious, but gives you an idea of the issues involved.
(look below for a better idea)
*/
int call_add(lua_State *L,int a,int b,int* res) {
push a, push b, call 'add' check & return res
*/
top=lua_gettop(L); /* for later */
- lua_pushstring(L, "add"); /* function name */
- lua_gettable(L, LUA_GLOBALSINDEX); /* function to be called */
+ lua_getglobal(L, "add"); /* function to be called */
if (!lua_isfunction(L,-1)) {
printf("[C] error: cannot find function 'add'\n");
- lua_settop(L,top); // reset
+ lua_settop(L,top);
return 0;
}
lua_pushnumber(L,a);
if (lua_pcall(L, 2, 1, 0) != 0) /* call function with 2 arguments and 1 result */
{
printf("[C] error running function `add': %s\n",lua_tostring(L, -1));
- lua_settop(L,top); // reset
+ lua_settop(L,top);
return 0;
}
- // check results
+ /* check results */
if (!lua_isnumber(L,-1)) {
printf("[C] error: returned value is not a number\n");
- lua_settop(L,top); // reset
+ lua_settop(L,top);
return 0;
}
*res=(int)lua_tonumber(L,-1);
lua_settop(L,top); /* reset stack */
- return 1; // ok
+ return 1;
}
/* This is a variargs call function for calling from C into Lua.
Original Code from Programming in Lua (PIL) by Roberto Ierusalimschy
ISBN 85-903798-1-7
http://www.lua.org/pil/25.3.html
-This has been modified slightly to make it compile, and its still a bit rough.
+This has been modified slightly to make it compile, and it's still a bit rough.
But it gives the idea of how to make it work.
*/
int call_va (lua_State *L,const char *func, const char *sig, ...) {
luaopen_example(L);
printf("[C] all looks ok\n");
printf("\n");
- printf("[C] lets load the file 'runme.lua'\n");
+ if (argc != 2 || argv[1] == NULL || strlen(argv[1]) == 0) {
+ printf("[C] ERROR: no lua file given on command line\n");
+ exit(3);
+ }
+ printf("[C] let's load the file '%s'\n", argv[1]);
printf("[C] any lua code in this file will be executed\n");
- if (luaL_loadfile(L, "runme.lua") || lua_pcall(L, 0, 0, 0)) {
+ if (luaL_loadfile(L, argv[1]) || lua_pcall(L, 0, 0, 0)) {
printf("[C] ERROR: cannot run lua file: %s",lua_tostring(L, -1));
exit(3);
}
printf("[C] We are now back in C, all looks ok\n");
printf("\n");
- printf("[C] lets call the Lua function 'add(1,1)'\n");
+ printf("[C] let's call the Lua function 'add(1,1)'\n");
printf("[C] using the C function 'call_add'\n");
ok=call_add(L,1,1,&res);
printf("[C] the function returned %d with value %d\n",ok,res);
printf("\n");
- printf("[C] lets do this rather easier\n");
+ printf("[C] let's do this rather easier\n");
printf("[C] we will call the same Lua function using a generic C function 'call_va'\n");
ok=call_va(L,"add","ii>i",1,1,&res);
printf("[C] the function returned %d with value %d\n",ok,res);
print "[lua] This is runme.lua"
--- test program for embeded lua
--- we do not need to load the library, as it was already in the intrepreter
--- but lets check anyway
+-- test program for embedded lua
+-- we do not need to load the library, as it was already in the interpreter
+-- but let's check anyway
assert(type(example)=='table',"Don't appear to have loaded the example module")
-\r
--- note: we will copy the functions from example table into global\r
--- this will help us later\r
-for k,v in pairs(example) do _G[k]=v end\r
--- our add function\r
+-- note: we will copy the functions from example table into global
+-- this will help us later
+for k,v in pairs(example) do _G[k]=v end
+
+-- our add function
-- we will be calling this from C
-function add(a,b)\r
- print("[lua] this is function add(",a,b,")")\r
- c=a+b\r
- print("[lua] returning",c)\r
- return c\r
+function add(a,b)
+ print("[lua] this is function add(",a,b,")")
+ c=a+b
+ print("[lua] returning",c)
+ return c
end
-function append(a,b)\r
- print("[lua] this is function append(",a,b,")")\r
- c=a..b\r
- print("[lua] returning",c)\r
- return c\r
+function append(a,b)
+ print("[lua] this is function append(",a,b,")")
+ c=a..b
+ print("[lua] returning",c)
+ return c
end
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
TARGET = embed3
SRCS = example.cpp
INTERFACE = example.i
# which we want to static link
# we also need the external runtime, so we can get access to certain internals of SWIG
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' lua_embed_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' lua_embed_run
build:
- $(SWIG) -c++ -lua $(SWIGOPT) -external-runtime swigluarun.h
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ lua_externalhdr
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='example.i' LUA_INTERP='$(LUA_INTERP)' lua_static_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
rm -f swigluarun.h $(TARGET)
-/* embed3.cpp A C++ embeded interpreter
+/* embed3.cpp A C++ embedded interpreter
This will register a C++ class with Lua, and then call a Lua function
passing C++ objects to this function.
#include <lauxlib.h>
#include <lualib.h>
}
-\r
-/* The SWIG external runtime is generated by using.\r
-swig -lua -externalruntime swigluarun.h\r
-It contains useful function used by SWIG in its wrappering\r
-SWIG_TypeQuery() SWIG_NewPointerObj()\r
+
+#if LUA_VERSION_NUM > 501
+#define lua_open luaL_newstate
+#endif
+
+/* The SWIG external runtime is generated by using.
+swig -lua -externalruntime swigluarun.h
+It contains useful function used by SWIG in its wrapper
+SWIG_TypeQuery() SWIG_NewPointerObj()
*/
#include "swigluarun.h" // the SWIG external runtime
-/* the SWIG wrappered library */
+/* the SWIG wrapped library */
extern "C" int luaopen_example(lua_State*L);
// the code itself
push a, push b, call 'add' check & return res
*/
top = lua_gettop(L); /* for later */
- lua_pushstring(L, "onEvent"); /* function name */
- lua_gettable(L, LUA_GLOBALSINDEX); /* function to be called */
+ lua_getglobal(L, "onEvent"); /* function to be called */
if (!lua_isfunction(L, -1)) {
printf("[C++] error: cannot find function 'OnEvent'\n");
lua_settop(L, top); // reset
luaopen_example(L);
printf("[C++] all looks ok\n");
printf("\n");
- printf("[C++] lets create an Engine and pass a pointer to Lua\n");
+ printf("[C++] let's create an Engine and pass a pointer to Lua\n");
Engine engine;
/* this code will pass a pointer into lua, but C++ still owns the object
- this is a little tedious, to do, but lets do it
+ this is a little tedious, to do, but let's do it
we need to pass the pointer (obviously), the type name
and a flag which states if Lua should delete the pointer once its finished with it
The type name is a class name string which is registered with SWIG
push_pointer(L,&engine,"Engine *",0);
lua_setglobal(L, "pEngine"); // set as global variable
- printf("[C++] now lets load the file 'runme.lua'\n");
+ if (argc != 2 || argv[1] == NULL || strlen(argv[1]) == 0) {
+ printf("[C++] ERROR: no lua file given on command line\n");
+ exit(3);
+ }
+ printf("[C++] now let's load the file '%s'\n", argv[1]);
printf("[C++] any lua code in this file will be executed\n");
- if (luaL_loadfile(L, "runme.lua") || lua_pcall(L, 0, 0, 0)) {
- printf("[C++] ERROR: cannot run lua file: %s", lua_tostring(L, -1));
+ if (luaL_loadfile(L, argv[1]) || lua_pcall(L, 0, 0, 0)) {
+ printf("[C++] ERROR: cannot run lua file: %s",lua_tostring(L, -1));
exit(3);
}
printf("[C++] We are now back in C++, all looks ok\n");
printf("\n");
- printf("[C++] Lets call the Lua function onEvent(e)\n");
+ printf("[C++] Let's call the Lua function onEvent(e)\n");
printf("[C++] We will give it different events, as we wish\n");
printf("[C++] Starting with STARTUP\n");
Event ev;
};
-/* We also want to pass some events to Lua, so lets have a few classes
+/* We also want to pass some events to Lua, so let's have a few classes
to do this.
*/
class Event
print "[lua] This is runme.lua"
--- test program for embeded lua
--- we do not need to load the library, as it was already in the intrepreter
--- but lets check anyway
+-- test program for embedded lua
+-- we do not need to load the library, as it was already in the interpreter
+-- but let's check anyway
assert(type(example)=='table',"Don't appear to have loaded the example module. Do not run this file directly, run the embed3 executable")
end
--- the embed program expects a function void onEvent(Event)
+-- the embedded program expects a function void onEvent(Event)
-- this is it
function onEvent(e)
print("[Lua] onEvent with event",e.mType)
- -- lets do something with the Engine
+ -- let's do something with the Engine
-- nothing clever, but ...
if e.mType==example.Event_STARTUP then
pEngine:start()
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile lua_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' lua_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mylua' INTERFACE='$(INTERFACE)' lua_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
t:message()
end
print [[
-Now lets call function a()
+Now let's call function a()
which calls b()
which calls into C++
which will throw an exception!]]
else
print(" call failed with error:",res)
end
-print "Now lets do the same using xpcall(a,debug.traceback)"
+print "Now let's do the same using xpcall(a,debug.traceback)"
ok,res=xpcall(a,debug.traceback)
if ok then
print " that worked! Funny"
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
-LIBS =
+LIBS =
check: build
- $(MAKE) -f $(TOP)/Makefile lua_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' lua
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mylua' INTERFACE='$(INTERFACE)' lua_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
-LIBS =
+LIBS =
check: build
- $(MAKE) -f $(TOP)/Makefile lua_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' lua
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mylua' INTERFACE='$(INTERFACE)' lua_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
/* File : example.i */
%module example
-%include "typemaps.i" // you must have this for the typemaps for ptrs
-// basic function testing
-//
+%include "typemaps.i"
+
%inline %{
-extern int add1(int x, int y); // return x+y -- basic function test
-extern void add2(int x, int *INPUT, int *OUTPUT); // *z = x+*y -- argin and argout test
-extern int add3(int x, int y, int *OUTPUT); // return x+y, *z=x-y -- returning 2 values
-extern void add4(int x, int *INOUT); // *y += x -- INOUT dual purpose variable
+extern int add1(int x, int y); /* return x+y -- basic function test */
+extern void add2(int x, int *INPUT, int *OUTPUT); /* *z = x+*y -- argin and argout test */
+extern int add3(int x, int y, int *OUTPUT); /* return x+y, *z=x-y -- returning 2 values */
+extern void add4(int x, int *INOUT); /* *y += x -- INOUT dual purpose variable */
%}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile lua_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' lua_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mylua' INTERFACE='$(INTERFACE)' lua_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
-- import
-- the lua 5.0 loading mechanism is rather poor & relies upon the loadlib() fn
-- the lua 5.1 loading mechanism is simplicity itself
--- for now we need a bridge which will use the correct verion
+-- for now we need a bridge which will use the correct version
function import_5_0(module)
-- imports the file into the program
-- and look for the fn 'Example_Init()' (note the capitalisation)
if rawget(_G,module)~=nil then return end -- module appears to be loaded
- -- capitialising the first letter
+ -- capitalising the first letter
local c=string.upper(string.sub(module,1,1))
local fnname=c..string.sub(module,2).."_Init"
end
assert(lib,"error loading module:"..module)
- lib() -- execute the function: initalising the lib
+ lib() -- execute the function: initialising the lib
local m=rawget(_G,module) -- gets the module object
assert(m~=nil,"no module table found")
end
import=import_5_0
else
import=import_5_1
-end
\ No newline at end of file
+end
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SWIGOPT =
LIBS =
-
+
check: build
- $(MAKE) -f $(TOP)/Makefile lua_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
build:
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='base' INTERFACE='base.i' lua_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' lua_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' lua_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' lua_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='base' INTERFACE='base.i' lua_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' lua_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' lua_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' lua_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
-This example tests the %import directive and working with multiple modules.\r
-\r
-Use 'lua runme.lua' to run a test.\r
-\r
-Overview:\r
----------\r
-\r
-The example defines 4 different extension modules--each wrapping\r
-a separate C++ class.\r
-\r
- base.i - Base class\r
- foo.i - Foo class derived from Base\r
- bar.i - Bar class derived from Base\r
- spam.i - Spam class derived from Bar\r
-\r
-Each module uses %import to refer to another module. For\r
-example, the 'foo.i' module uses '%import base.i' to get\r
-definitions for its base class.\r
-\r
-If everything is okay, all of the modules will load properly and\r
-type checking will work correctly. Caveat: Some compilers, for example\r
-gcc-3.2.x, generate broken vtables with the inline methods in this test.\r
-This is not a SWIG problem and can usually be solved with non-inlined\r
-destructors compiled into separate shared objects/DLLs.\r
-\r
-Unix:\r
------\r
-- Run make\r
-- Run the test as described above\r
-\r
-Windows:\r
+This example tests the %import directive and working with multiple modules.
+
+Use 'lua runme.lua' to run a test.
+
+Overview:
+---------
+
+The example defines 4 different extension modules--each wrapping
+a separate C++ class.
+
+ base.i - Base class
+ foo.i - Foo class derived from Base
+ bar.i - Bar class derived from Base
+ spam.i - Spam class derived from Bar
+
+Each module uses %import to refer to another module. For
+example, the 'foo.i' module uses '%import base.i' to get
+definitions for its base class.
+
+If everything is okay, all of the modules will load properly and
+type checking will work correctly. Caveat: Some compilers, for example
+gcc-3.2.x, generate broken vtables with the inline methods in this test.
+This is not a SWIG problem and can usually be solved with non-inlined
+destructors compiled into separate shared objects/DLLs.
+
+Unix:
+-----
+- Run make
+- Run the test as described above
+
+Windows:
--------
Sorry, no files here.
-If you know how, you could copy the python or ruby example dsw & dsp and try editing that\r
+If you know how, you could copy the python or ruby example dsw & dsp and try editing that
+
-\r
class Base {
public:
- Base() { };
- virtual ~Base() { };
+ Base() { }
+ virtual ~Base() { }
virtual const char * A() const {
return "Base::A";
}
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' lua_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='mylua' INTERFACE='$(INTERFACE)' lua_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
--- /dev/null
+#ifndef _example_guardian_
+#define _example_guardian_
+
+int module_function() { return 7; }
+int module_variable = 9;
+
+namespace MyWorld {
+ class World {
+ public:
+ World() : world_max_count(9) {}
+ int create_world() { return 17; }
+ const int world_max_count; // = 9
+ };
+ namespace Nested {
+ class Dweller {
+ public:
+ enum Gender { MALE = 0, FEMALE = 1 };
+ static int count() { return 19; }
+ };
+ }
+}
+
+#endif
--- /dev/null
+%module example
+
+%{
+#include "example.h"
+%}
+
+%nspace MyWorld::Nested::Dweller;
+%nspace MyWorld::World;
+
+%include "example.h"
--- /dev/null
+-- file: runme.lua
+
+-- This file illustrates class C++ interface generated
+-- by SWIG.
+
+---- importing ----
+if string.sub(_VERSION,1,7)=='Lua 5.0' then
+ -- lua5.0 doesnt have a nice way to do this
+ lib=loadlib('example.dll','luaopen_example') or loadlib('example.so','luaopen_example')
+ assert(lib)()
+else
+ -- lua 5.1 does
+ require('example')
+end
+
+ex = example
+
+-- Calling a module function ( aka global function )
+assert( ex.module_function() == 7 )
+print("example.module_function(): ", ex.module_function())
+
+-- Accessing a module (aka global) variable
+assert( ex.module_variable == 9 )
+print("example.module_variable: ", ex.module_variable)
+
+-- Creating an instance of the class
+w1 = ex.MyWorld.World()
+print("Creating class instance: w1 = ex.MyWorld.World(): ", w1)
+
+-- Accessing class members
+assert( ex.MyWorld.World():create_world() == 17 )
+print( "w1:create_world() = ", w1:create_world() )
+assert( w1:create_world() == 17 )
+print( "w1:world_max_count = ", w1.world_max_count )
+assert( w1.world_max_count == 9 )
+
+-- Accessing enums from class within namespace
+print( "Accessing enums: ex.MyWorld.Nested.Dweller.MALE = ", ex.MyWorld.Nested.Dweller.MALE )
+assert( ex.MyWorld.Nested.Dweller.MALE == 0 )
+print( "Accessing enums: ex.MyWorld.Nested.Dweller.FEMALE = ", ex.MyWorld.Nested.Dweller.FEMALE )
+assert( ex.MyWorld.Nested.Dweller.FEMALE == 1 )
+
+-- Accessing static member function
+print( "Accessing static member function: ex.MyWorld.Nested.Dweller.count() = ", ex.MyWorld.Nested.Dweller.count() )
+assert( ex.MyWorld.Nested.Dweller.count() == 19 )
+
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile lua_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' lua_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mylua' INTERFACE='$(INTERFACE)' lua_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
return new Square(w);
}
-ShapeOwner::ShapeOwner() {printf(" ShapeOwner(%p)\n",this);}
+ShapeOwner::ShapeOwner() {
+ printf(" ShapeOwner(%p)\n", (void *)this);
+}
+
ShapeOwner::~ShapeOwner()
{
- printf(" ~ShapeOwner(%p)\n",this);
- for(unsigned i=0;i<shapes.size();i++)
- delete shapes[i];
+ printf(" ~ShapeOwner(%p)\n", (void *)this);
+ for(unsigned i=0;i<shapes.size();i++)
+ delete shapes[i];
}
void ShapeOwner::add(Shape* ptr) // this method takes ownership of the object
}
virtual ~Shape() {
nshapes--;
- };
+ }
double x, y;
void move(double dx, double dy);
virtual double area(void) = 0;
private:
double radius;
public:
- Circle(double r) : radius(r) { };
+ Circle(double r) : radius(r) { }
virtual double area(void);
virtual double perimeter(void);
};
private:
double width;
public:
- Square(double w) : width(w) { };
+ Square(double w) : width(w) { }
virtual double area(void);
virtual double perimeter(void);
};
require('example')
end
-print "ok, lets test Lua's ownership of C++ objects"
+print "ok, let's test Lua's ownership of C++ objects"
print("Currently there are",example.Shape_nshapes,"shapes (there should be 0)")
-print "\nLets make a couple"
+print "\nLet's make a couple"
a=example.Square(10)
b=example.Circle(1)
print("Currently there are",example.Shape_nshapes,"shapes (there should be 2)")
-print "\nNote lets use the createX functions"
+print "\nNote let's use the createX functions"
c=example.createCircle(5)
d=example.createSquare(3)
print("Currently there are",example.Shape_nshapes,"shapes (there should be 4)")
collectgarbage()
print("Currently there are",example.Shape_nshapes,"shapes (there should be 4)")
-print "\nLets get rid of them all, collect garbage & see if they are till here"
+print "\nLet's get rid of them all, collect garbage & see if they are till here"
a,b,c,d=nil,nil,nil,nil
collectgarbage()
print("Currently there are",example.Shape_nshapes,"shapes (there should be 0)")
-print "\nLets start putting stuff into the ShapeOwner"
+print "\nLet's start putting stuff into the ShapeOwner"
print "The ShapeOwner now owns the shapes, but Lua still has pointers to them"
o=example.ShapeOwner()
a=example.Square(10)
o:add(example.createSquare(5))
print("Currently there are",example.Shape_nshapes,"shapes (there should be 3)")
-print "\nWe will nil our references,run the garbage collector & see if they are till here"
+print "\nWe will nil our references,run the garbage collector & see if they are still here"
print "they should be, as the ShapeOwner owns them"
a,b=nil,nil
collectgarbage()
o,sh=nil,nil
collectgarbage()
print("Currently there are",example.Shape_nshapes,"shapes (there should be 0)")
-print "thats all folks!"
+print "that's all folks!"
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
-LIBS =
+LIBS =
check: build
- $(MAKE) -f $(TOP)/Makefile lua_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' lua
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mylua' INTERFACE='$(INTERFACE)' lua_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile lua_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' lua
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mylua' INTERFACE='$(INTERFACE)' lua_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile lua_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' lua
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mylua' INTERFACE='$(INTERFACE)' lua_static
clean:
- $(MAKE) -f $(TOP)/Makefile lua_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' lua_clean
printf("dvar = %g\n", dvar);
printf("cvar = %c\n", cvar);
printf("strvar = %s\n", strvar ? strvar : "(null)");
- printf("cstrvar = %s\n", cstrvar ? cstrvar : "(null)");
- printf("iptrvar = %p\n", iptrvar);
+ printf("cstrvar = %s\n", cstrvar);
+ printf("iptrvar = %p\n", (void *)iptrvar);
printf("name = %s\n", name);
- printf("ptptr = %p (%d, %d)\n", ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
+ printf("ptptr = %p (%d, %d)\n", (void *)ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
printf("pt = (%d, %d)\n", pt.x, pt.y);
printf("status = %d\n", status);
}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
PLATFORM = LINUXLIBC6
INTERFACE = example.i
MODULA3SRCS = *.[im]3
check: build
- $(MAKE) -f $(TOP)/Makefile modula3_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' modula3
m3ppinplace $(MODULA3SRCS)
# compilation of example_wrap.cxx is started by cm3
cm3
clean:
- $(MAKE) -f $(TOP)/Makefile modula3_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_clean
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
/* File : example.h */
-class Shape
-{
+class Shape {
public:
- Shape ()
- {
+ Shape() {
nshapes++;
}
- virtual ~ Shape ()
- {
+ virtual ~Shape() {
nshapes--;
- };
- double x, y;
- void move (double dx, double dy);
- virtual double area (void) const = 0;
- virtual double perimeter (void) const = 0;
-protected:
- static int nshapes;
+ }
+ double x, y;
+ void move(double dx, double dy);
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
+ static int nshapes;
};
-class Circle:public Shape
-{
+class Circle : public Shape {
private:
double radius;
public:
- Circle (double r):radius (r)
- {
- };
- virtual double area (void) const;
- virtual double perimeter (void) const;
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
-class Square:public Shape
-{
+class Square : public Shape {
private:
double width;
public:
- Square (double w):width (w)
- {
- };
- virtual double area (void) const;
- virtual double perimeter (void) const;
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
CONSTNUMERIC = example_const
MODULA3SRCS = *.[im]3
check: build
- $(MAKE) -f $(TOP)/Makefile modula3_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_run
build:
- $(SWIG) -modula3 $(SWIGOPT) -module Example -generateconst $(CONSTNUMERIC) $(TARGET).h
+ $(SWIGEXE) -modula3 $(SWIGOPT) -module Example -generateconst $(CONSTNUMERIC) $(TARGET).h
$(CXX) -Wall $(CONSTNUMERIC).c -o $(CONSTNUMERIC)
$(CONSTNUMERIC) >$(CONSTNUMERIC).i
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' modula3
m3ppinplace $(MODULA3SRCS)
mv m3makefile $(MODULA3SRCS) src/
cm3
clean:
- $(MAKE) -f $(TOP)/Makefile modula3_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
MODULA3FLAGS= -o runme
check: build
- $(MAKE) -f $(TOP)/Makefile modula3_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' modula3_cpp
-# $(MAKE) -f $(TOP)/Makefile MODULA3SRCS='$(MODULA3SRCS)' MODULA3FLAGS='$(MODULA3FLAGS)' modula3_compile
+# $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' MODULA3SRCS='$(MODULA3SRCS)' MODULA3FLAGS='$(MODULA3FLAGS)' modula3_compile
m3ppinplace $(MODULA3SRCS)
mv m3makefile $(MODULA3SRCS) src/
cm3
clean:
- $(MAKE) -f $(TOP)/Makefile modula3_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT = -c++
MODULA3SRCS = *.[im]3
check: build
- $(MAKE) -f $(TOP)/Makefile modula3_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' modula3
m3ppinplace $(MODULA3SRCS)
mv m3makefile $(MODULA3SRCS) src/
cm3
clean:
- $(MAKE) -f $(TOP)/Makefile modula3_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_clean
char *Vector::print() {
static char temp[512];
- sprintf(temp,"Vector %x (%g,%g,%g)", (int)this, x,y,z);
+ sprintf(temp,"Vector %p (%g,%g,%g)", (void *)this, x,y,z);
return temp;
}
private:
double x,y,z;
public:
- Vector() : x(0), y(0), z(0) { };
- Vector(double x, double y, double z) : x(x), y(y), z(z) { };
+ Vector() : x(0), y(0), z(0) { }
+ Vector(double x, double y, double z) : x(x), y(y), z(z) { }
Vector operator+(const Vector &b) const;
char *print();
};
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT =
MODULA3SRCS = *.[im]3
check: build
- $(MAKE) -f $(TOP)/Makefile modula3_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' modula3
m3ppinplace $(MODULA3SRCS)
mv m3makefile $(MODULA3SRCS) src/
cm3
clean:
- $(MAKE) -f $(TOP)/Makefile modula3_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT =
MODULA3SRCS = *.[im]3
check: build
- $(MAKE) -f $(TOP)/Makefile modula3_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' modula3
m3ppinplace $(MODULA3SRCS)
mv m3makefile $(MODULA3SRCS) src/
cm3
clean:
- $(MAKE) -f $(TOP)/Makefile modula3_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile mzscheme_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' mzscheme_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' mzscheme
clean:
- $(MAKE) -f $(TOP)/Makefile mzscheme_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' mzscheme_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile mzscheme_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' mzscheme_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' mzscheme
clean:
- $(MAKE) -f $(TOP)/Makefile mzscheme_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' mzscheme_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
-SWIGOPT =
+SWIGOPT =
GPP = `which g++`
MZC = test -n "/usr/bin/mzc" && /usr/bin/mzc
check: build
- $(MAKE) -f $(TOP)/Makefile mzscheme_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' mzscheme_run
build:
- $(SWIG) -mzscheme -c++ $(SWIGOPT) $(INTERFACE)
+ $(SWIGEXE) -mzscheme -c++ $(SWIGOPT) $(INTERFACE)
$(MZC) --compiler $(GPP) ++ccf "-I." --cc example_wrap.cxx
- $(MZC) --linker $(GPP) --ld $(TARGET).so example_wrap.o
-
+ $(MZC) --linker $(GPP) --ld $(TARGET).so example_wrap.o
+
clean:
- $(MAKE) -f $(TOP)/Makefile mzscheme_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' mzscheme_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
OBJS = example.o
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_run
build: static
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' MLFILE='$(MLFILE)' \
PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_static_cpp
dynamic:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' MLFILE='$(MLFILE)' \
PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_dynamic_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile MLFILE='$(MLFILE)' ocaml_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' MLFILE='$(MLFILE)' ocaml_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
MLFILE = example.ml
PROGFILE = example_prog.ml
-OBJS =
+OBJS =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_run
build: static
dynamic:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' MLFILE='$(MLFILE)' \
PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_dynamic
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' MLFILE='$(MLFILE)' \
PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_static
toplevel:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' MLFILE='$(MLFILE)' \
PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_static_toplevel
clean:
- $(MAKE) -f $(TOP)/Makefile MLFILE='$(MLFILE)' ocaml_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' MLFILE='$(MLFILE)' ocaml_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
MLFILE = example.ml
PROGFILE = example_prog.ml
-OBJS =
+OBJS =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_run
build: static
dynamic:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' MLFILE='$(MLFILE)' \
PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_dynamic_cpp
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' MLFILE='$(MLFILE)' \
PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_static_cpp
toplevel:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' MLFILE='$(MLFILE)' \
PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_static_cpp_toplevel
clean:
- $(MAKE) -f $(TOP)/Makefile MLFILE='$(MLFILE)' ocaml_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' MLFILE='$(MLFILE)' ocaml_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SWIGOPT =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
SRCS = example.c
TARGET = example
INTERFACE = example.i
OBJS = example.o
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_run
build: static static_top
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
MLFILE='$(MLFILE)' PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_static_cpp
static_top:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
MLFILE='$(MLFILE)' PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_static_cpp_toplevel
dynamic:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)'
MLFILE='$(MLFILE)' PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_dynamic_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile MLFILE='$(MLFILE)' ocaml_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' MLFILE='$(MLFILE)' ocaml_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
OBJS = example.o
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_run
build: static
dynamic:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' MLFILE='$(MLFILE)' \
PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_dynamic
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' MLFILE='$(MLFILE)' \
PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_static
toplevel:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' MLFILE='$(MLFILE)' \
PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_static_toplevel
clean:
- $(MAKE) -f $(TOP)/Makefile MLFILE='$(MLFILE)' ocaml_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' MLFILE='$(MLFILE)' ocaml_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
PROGFILE = runme.ml
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_run
build: static
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
PROGFILE='$(PROGFILE)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
ocaml_static_cpp
dynamic:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
PROGFILE='$(PROGFILE)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
ocaml_dynamic_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
PROGFILE = runme.ml
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_run
build: static
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
PROGFILE='$(PROGFILE)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
ocaml_static_cpp
dynamic:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
PROGFILE='$(PROGFILE)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
ocaml_dynamic_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
PROGFILE = runme.ml
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_run
build: static
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
PROGFILE='$(PROGFILE)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
ocaml_static_cpp
director:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
PROGFILE='$(PROGFILE)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
ocaml_static_cpp_director
dynamic:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
PROGFILE='$(PROGFILE)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
ocaml_static_cpp
toplevel:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
PROGFILE='$(PROGFILE)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
ocaml_static_cpp_toplevel
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SWIGOPT = -c++
-SRCS =
+SRCS =
TARGET = example
INTERFACE = foolib.i
MLFILE = foolib.ml
PROGFILE = example_prog.ml
-OBJS =
+OBJS =
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_run
build: static static_top
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
MLFILE='$(MLFILE)' PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_static_cpp
static_top:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
MLFILE='$(MLFILE)' PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_static_cpp_toplevel
dynamic:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)'
MLFILE='$(MLFILE)' PROGFILE='$(PROGFILE)' OBJS='$(OBJS)' \
ocaml_dynamic_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile MLFILE='$(MLFILE)' ocaml_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' MLFILE='$(MLFILE)' ocaml_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
PROGFILE = runme.ml
check: build
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_run
build: static top
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
PROGFILE='$(PROGFILE)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
ocaml_static_cpp
dynamic:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
PROGFILE='$(PROGFILE)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
ocaml_static_cpp
top:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
PROGFILE='$(PROGFILE)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
ocaml_static_cpp_toplevel
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' ocaml_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' ocaml_clean
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS = example.cxx
-TARGET = swigexample
-INTERFACE = example.i
-LIBS = -lm
-SWIGOPT =
+CXXSRCS = example.cxx
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave_cpp
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
/* File : example.i */
%module(directors="1") swigexample
+
+%feature("autodoc", 1);
+
%{
#include "example.h"
%}
-%include "std_string.i"
-
/* turn on director wrapping Callback */
%feature("director") Callback;
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS = example.cxx
-TARGET = swigexample
-INTERFACE = example.i
-LIBS = -lm
-SWIGOPT =
+CXXSRCS = example.cxx
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave_cpp
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
+ }
double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
/* File : example.i */
%module swigexample
+%feature("autodoc", 1);
+
%{
#include "example.h"
%}
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
-TARGET = swigexample
-INTERFACE = example.i
-LIBS = -lm
-SWIGOPT =
+CXXSRCS =
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave_cpp
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
/* File : example.i */
%module swigexample
+%feature("autodoc", 1);
+
/* A few preprocessor macros */
#define ICONST 42
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS = example.c
-TARGET = swigexample
-INTERFACE = example.i
+SRCS = example.c
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
/* File : example.i */
%module swigexample
+%feature("autodoc", 1);
+
%contract gcd(int x, int y) {
require:
x >= 0;
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS = example.cxx
-TARGET = swigexample
-INTERFACE = example.i
-LIBS = -lm
-SWIGOPT =
+CXXSRCS = example.cxx
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave_cpp
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
/* File : example.i */
%module swigexample
+%feature("autodoc", 1);
+
%{
#include "example.h"
%}
--- /dev/null
+# Note: as a convention an example must be in a child directory of this.
+# These paths are relative to such an example directory
+
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+TARGET = swigexample
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' octave_run
+
+build:
+ifneq (,$(SRCS))
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave
+else
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave_cpp
+endif
+ifneq (,$(TARGET2)$(SWIGOPT2))
+ifneq (,$(SRCS))
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT2)' TARGET='$(TARGET2)' INTERFACE='$(INTERFACE)' octave
+else
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT2)' TARGET='$(TARGET2)' INTERFACE='$(INTERFACE)' octave_cpp
+endif
+endif
+
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' octave_clean
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS = example.cxx
-TARGET = swigexample
-INTERFACE = example.i
-LIBS = -lm
-SWIGOPT =
+CXXSRCS = example.cxx
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave_cpp
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
virtual std::string getTitle() { return getPosition() + " " + getName(); }
virtual std::string getName() { return name; }
virtual std::string getPosition() const { return "Employee"; }
- virtual ~Employee() { printf("~Employee() @ %p\n", this); }
+ virtual ~Employee() { printf("~Employee() @ %p\n", (void *)this); }
};
/* File : example.i */
%module(directors="1") swigexample
+
+%feature("autodoc", 1);
+
%{
#include "example.h"
%}
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS = example.c
-TARGET = swigexample
-INTERFACE = example.i
+SRCS = example.c
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
/* File : example.i */
%module swigexample
+
+%feature("autodoc", 1);
+
%{
#include "example.h"
%}
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS = example.c
-TARGET = swigexample
-INTERFACE = example.i
+SRCS = example.c
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
/* File : example.i */
%module swigexample
+
+%feature("autodoc", 1);
+
%{
#include "example.h"
%}
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
-TARGET = swigexample
-INTERFACE = example.i
-LIBS = -lm
-SWIGOPT =
+CXXSRCS =
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave_cpp
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
/* File : example.i */
%module swigexample
+%feature("autodoc", 1);
%inline %{
// From B. Strousjoup, "The C++ Programming Language, Third Edition", p. 514
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS = example.c
-TARGET = swigexample
-INTERFACE = example.i
+SRCS = example.c
+TARGET = swigexample
+SWIGOPT = -module swigexample
+TARGET2 = swigexample2
+SWIGOPT2 = -module swigexample2 -globals .
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
- TARGET='$(TARGET)' SWIGOPT='-module $$(TARGET)' INTERFACE='$(INTERFACE)' octave
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
- TARGET='$(TARGET)2' SWIGOPT='-module $$(TARGET) -globals .' INTERFACE='$(INTERFACE)' octave
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
- rm -f $(TARGET).m
+include $(SRCDIR)../example.mk
/* File : example.i */
/* module name given on cmdline */
+
+%feature("autodoc", 1);
+
%{
#include "example.h"
%}
testme
clear all
-# octave 3.0.5 randomly crashes on the remaining tests, so skip them
-api_version = sscanf(octave_config_info("api_version"), "api-v%i");
-if api_version < 37
+# octave 3.0.5 randomly crashes on the remaining tests
+if !swig_octave_prereq(3,2,0)
exit
endif
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
-TARGET = swigexample
-INTERFACE = example.i
-LIBS = -lm
-SWIGOPT =
+CXXSRCS =
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave_cpp
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
/* File : example.i */
%module swigexample
+
+%feature("autodoc", 1);
+
#pragma SWIG nowarn=SWIGWARN_IGNORE_OPERATOR_EQ
+
%{
#include "example.h"
%}
ComplexVal __paren__(int j) {
return ComplexVal($self->re()*j,$self->im()*j);
}
+
+ double __float__() {
+ return (double) $self->re();
+ }
+
+ double __real__() {
+ return $self->re();
+ }
+ double __imag__() {
+ return $self->im();
+ }
+ double __abs__() {
+ return sqrt($self->re()*$self->re() + $self->im()*$self->im());
+ }
+ ComplexVal __conj__() {
+ return ComplexVal($self->re(), -$self->im());
+ }
+ ComplexVal __exp__() {
+ return exp($self->re()) * ComplexVal(cos($self->im()), sin($self->im()));
+ }
+
};
# friend operator
printf("2*a = %s\n",disp(2*a));
+
+# conversions
+printf("single(a) = %g\n", single(a));
+printf("double(a) = %g\n", double(a));
+
+# unary functions
+if swig_octave_prereq(3,8,0)
+ printf("real(a) = %g\n", real(a));
+ printf("imag(a) = %g\n", imag(a));
+ printf("abs(a) = %g\n", abs(a));
+ printf("conj(a) = %s\n", disp(conj(a)));
+ printf("exp(a) = %s\n", disp(exp(a)));
+endif
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS = example.c
-TARGET = swigexample
-INTERFACE = example.i
+SRCS = example.c
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
/* File : example.i */
%module swigexample
+%feature("autodoc", 1);
+
%{
extern void add(int *, int *, int *);
extern void sub(int *, int *, int *);
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS = example.cxx
-TARGET = swigexample
-INTERFACE = example.i
-LIBS = -lm
-SWIGOPT =
+CXXSRCS = example.cxx
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave_cpp
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
char *Vector::print() {
static char temp[512];
- sprintf(temp,"Vector %p (%g,%g,%g)", this, x,y,z);
+ sprintf(temp,"Vector %p (%g,%g,%g)", (void *)this, x,y,z);
return temp;
}
private:
double x,y,z;
public:
- Vector() : x(0), y(0), z(0) { };
- Vector(double x, double y, double z) : x(x), y(y), z(z) { };
+ Vector() : x(0), y(0), z(0) { }
+ Vector(double x, double y, double z) : x(x), y(y), z(z) { }
friend Vector operator+(const Vector &a, const Vector &b);
char *print();
};
%module swigexample
+%feature("autodoc", 1);
+
%{
#include "example.h"
%}
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS = example.c
-TARGET = swigexample
-INTERFACE = example.i
+SRCS = example.c
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
/* File : example.i */
%module swigexample
+%feature("autodoc", 1);
+
%inline %{
extern int gcd(int x, int y);
extern double Foo;
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
-TARGET = swigexample
-INTERFACE = example.i
-LIBS = -lm
-SWIGOPT =
+CXXSRCS =
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave_cpp
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
/* File : example.i */
%module swigexample
+%feature("autodoc", 1);
+
%{
#include "example.h"
%}
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS = example.c
-TARGET = swigexample
-INTERFACE = example.i
+SRCS = example.c
-check: build
- $(MAKE) -f $(TOP)/Makefile octave_run
-
-build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' octave
-
-clean:
- $(MAKE) -f $(TOP)/Makefile octave_clean
+include $(SRCDIR)../example.mk
printf("dvar = %g\n", dvar);
printf("cvar = %c\n", cvar);
printf("strvar = %s\n", strvar ? strvar : "(null)");
- printf("cstrvar = %s\n", cstrvar ? cstrvar : "(null)");
- printf("iptrvar = %p\n", iptrvar);
+ printf("cstrvar = %s\n", cstrvar);
+ printf("iptrvar = %p\n", (void *)iptrvar);
printf("name = %s\n", name);
- printf("ptptr = %p (%d, %d)\n", ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
+ printf("ptptr = %p (%d, %d)\n", (void *)ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
printf("pt = (%d, %d)\n", pt.x, pt.y);
printf("status = %d\n", status);
}
/* File : example.i */
%module swigexample
+
+%feature("autodoc", 1);
+
%{
#include "example.h"
%}
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS = example.cxx
+TARGET = example
+INTERFACE = example.i
+LIBS = -lm
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
--- /dev/null
+/* File : example.cxx */
+
+#include "example.h"
+
--- /dev/null
+/* File : example.h */
+
+#include <cstdio>
+#include <iostream>
+
+class Callback {
+public:
+ virtual ~Callback() { std::cout << "Callback::~Callback()" << std:: endl; }
+ virtual void run() { std::cout << "Callback::run()" << std::endl; }
+};
+
+
+class Caller {
+private:
+ Callback *_callback;
+public:
+ Caller(): _callback(0) {}
+ ~Caller() { delCallback(); }
+ void delCallback() { delete _callback; _callback = 0; }
+ void setCallback(Callback *cb) { delCallback(); _callback = cb; }
+ void call() { if (_callback) _callback->run(); }
+};
+
--- /dev/null
+/* File : example.i */
+%module(directors="1") example
+%{
+#include "example.h"
+%}
+
+/* turn on director wrapping Callback */
+%feature("director") Callback;
+
+/* Caller::setCallback(Callback *cb) gives ownership of the cb to the
+ * Caller object. The wrapper code should understand this. */
+%apply SWIGTYPE *DISOWN { Callback *cb };
+
+%include "example.h"
+
--- /dev/null
+<html>
+<head>
+<title>SWIG:Examples:perl5:callback</title>
+</head>
+
+<body bgcolor="#ffffff">
+
+
+<tt>SWIG/Examples/perl/callback/</tt>
+<hr>
+
+<H2>Implementing C++ callbacks in Perl</H2>
+
+<p>
+This example illustrates how to use directors to implement C++ callbacks.
+</p>
+
+<hr>
+</body>
+</html>
--- /dev/null
+# file: runme.pl
+
+# This file illustrates the cross language polymorphism using directors.
+
+use example;
+
+
+{
+ package PlCallback;
+ use base 'example::Callback';
+ sub run {
+ print "PlCallback->run()\n";
+ }
+}
+
+# Create an Caller instance
+
+$caller = example::Caller->new();
+
+# Add a simple C++ callback (caller owns the callback, so
+# we disown it first by clearing the .thisown flag).
+
+print "Adding and calling a normal C++ callback\n";
+print "----------------------------------------\n";
+
+$callback = example::Callback->new();
+$callback->DISOWN();
+$caller->setCallback($callback);
+$caller->call();
+$caller->delCallback();
+
+print "\n";
+print "Adding and calling a Perl callback\n";
+print "----------------------------------\n";
+
+# Add a Perl callback (caller owns the callback, so we
+# disown it first by calling DISOWN).
+
+$callback = PlCallback->new();
+$callback->DISOWN();
+$caller->setCallback($callback);
+$caller->call();
+$caller->delCallback();
+
+# All done.
+
+print "\n";
+print "perl exit\n";
# see top-level Makefile.in
+callback
class
constants
constants2
+extend
funcptr
import
java
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
typedef Square TSquare;
class CFoo
{
public:
- static Square MakeSquare(void) {return Square(4.0);};
- static TSquare MakeTSquare(void) {return Square(4.0);};
+ static Square MakeSquare(void) {return Square(4.0);}
+ static TSquare MakeTSquare(void) {return Square(4.0);}
};
-
-
-
-
-
%}
/* Let's just grab the original header file here */
-
%include "example.h"
-
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
virtual double area() = 0;
virtual double perimeter() = 0;
private:
double radius;
public:
- Circle(double r) : radius(r) { };
+ Circle(double r) : radius(r) { }
virtual double area();
virtual double perimeter();
};
private:
double width;
public:
- Square(double w) : width(w) { };
+ Square(double w) : width(w) { }
virtual double area();
virtual double perimeter();
};
Note: when creating a C++ extension, you must run SWIG with the <tt>-c++</tt> option like this:
<blockquote>
<pre>
-% swig -c++ -python example.i
+% swig -c++ -perl example.i
</pre>
</blockquote>
<blockquote>
<pre>
-$c = example::new_Circle(10.0);
+$c = new example::Circle(10.0);
</pre>
</blockquote>
<p>
-<li>To access member data, a pair of accessor functions are used.
-For example:
+<li>You can access member data like so:
<blockquote>
<pre>
-example::Shape_x_set($c,15); # Set member data
-$x = example::Shape_x_get($c); # Get member data
+$c->{x} = 15; # Set member data
+$x = $c->{x}; # Get member data
</pre>
</blockquote>
-Note: when accessing member data, the name of the class in which
-the data member is defined is used. For example <tt>Shape_x_get()</tt>.
-
<p>
-<li>To invoke a member function, you simply do this
+<li>To invoke a member function, you simply do this:
<blockquote>
<pre>
-print "The area is ", example::Shape_area($c);
+print "The area is ", $c->area();
</pre>
</blockquote>
<p>
-<li>Type checking knows about the inheritance structure of C++. For example:
+<li>To invoke a destructor, simply do this:
<blockquote>
<pre>
-example::Shape_area($c); # Works (c is a Shape)
-example::Circle_area($c); # Works (c is a Circle)
-example::Square_area($c); # Fails (c is definitely not a Square)
+$c->DESTROY(); # Deletes a shape
</pre>
</blockquote>
<p>
-<li>To invoke a destructor, simply do this
+<li>Static member variables are wrapped like so:
<blockquote>
<pre>
-example::delete_Shape($c); # Deletes a shape
-</pre>
-</blockquote>
-
-<p>
-<li>Static member variables are wrapped as C global variables. For example:
-
-<blockquote>
-<pre>
-$n = $example::Shape_nshapes; # Get a static data member
-$example::Shapes_nshapes = 13; # Set a static data member
+$n = $example::Shape::nshapes; # Get a static data member
+$example::Shapes::nshapes = 13; # Set a static data member
</pre>
</blockquote>
<h2>General Comments</h2>
<ul>
-<li>This low-level interface is not the only way to handle C++ code. Proxy classes
-provide a much higher-level interface.
-
-<p>
-<li>SWIG *does* know how to properly perform upcasting of objects in an inheritance
+<li>SWIG <b>does</b> know how to properly perform upcasting of objects in an inheritance
hierarchy (including multiple inheritance). Therefore it is perfectly safe to pass
an object of a derived class to any function involving a base class.
-<p>
-<li>A wide variety of C++ features are not currently supported by SWIG. Here is the
-short and incomplete list:
-
-<p>
-<ul>
-<li>Overloaded methods and functions. SWIG wrappers don't know how to resolve name
-conflicts so you must give an alternative name to any overloaded method name using the
-%name directive like this:
-
-<blockquote>
-<pre>
-void foo(int a);
-%name(foo2) void foo(double a, double b);
-</pre>
-</blockquote>
-
-<p>
-<li>Overloaded operators. Not supported at all. The only workaround for this is
-to write a helper function. For example:
-
-<blockquote>
-<pre>
-%inline %{
- Vector *vector_add(Vector *a, Vector *b) {
- ... whatever ...
- }
-%}
-</pre>
-</blockquote>
-
-<p>
-<li>Namespaces. Not supported at all. Won't be supported until SWIG2.0 (if at all).
+<li>C++ Namespaces - %nspace isn't yet supported for Perl.
</ul>
print " $o\n";
print " area = ", $o->area(), "\n";
print " perimeter = ", $o->perimeter(), "\n";
- }
+}
# ----- Delete everything -----
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_static
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT = -const
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_static
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS = example.cxx
+TARGET = example
+INTERFACE = example.i
+LIBS = -lm
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
--- /dev/null
+/* File : example.cxx */
+
+#include "example.h"
+
virtual std::string getTitle() { return getPosition() + " " + getName(); }
virtual std::string getName() { return name; }
virtual std::string getPosition() const { return "Employee"; }
- virtual ~Employee() { printf("~Employee() @ %p\n", this); }
+ virtual ~Employee() { printf("~Employee() @ %p\n", (void *)this); }
};
}
};
-Manager* convert_to_Manager(PyObject *obj);
-
%feature("director") Employee;
%feature("director") Manager;
+/* EmployeeList::addEmployee(Employee *p) gives ownership of the
+ * employee to the EmployeeList object. The wrapper code should
+ * understand this. */
+%apply SWIGTYPE *DISOWN { Employee *p };
+
%include "example.h"
--- /dev/null
+<html>
+<head>
+<title>SWIG:Examples:perl5:extend</title>
+</head>
+
+<body bgcolor="#ffffff">
+
+
+<tt>SWIG/Examples/perl5/extend/</tt>
+<hr>
+
+<H2>Extending a simple C++ class</H2>
+
+<p>
+This example illustrates the extending of a C++ class with cross language polymorphism.
+
+<hr>
+</body>
+</html>
--- /dev/null
+# file: runme.pl
+
+# This file illustrates the cross language polymorphism using directors.
+
+use example;
+
+
+# CEO class, which overrides Employee::getPosition().
+
+{
+ package CEO;
+ use base 'example::Manager';
+ sub getPosition {
+ return "CEO";
+ }
+}
+
+
+# Create an instance of our employee extension class, CEO. The calls to
+# getName() and getPosition() are standard, the call to getTitle() uses
+# the director wrappers to call CEO->getPosition. $e = CEO->new("Alice")
+
+$e = CEO->new("Alice");
+print $e->getName(), " is a ", $e->getPosition(), "\n";
+printf "Just call her \"%s\"\n", $e->getTitle();
+print "----------------------\n";
+
+
+# Create a new EmployeeList instance. This class does not have a C++
+# director wrapper, but can be used freely with other classes that do.
+
+$list = example::EmployeeList->new();
+
+# EmployeeList owns its items, so we must surrender ownership of objects
+# we add. This involves calling the DISOWN method to tell the
+# C++ director to start reference counting.
+
+$e->DISOWN();
+$list->addEmployee($e);
+print "----------------------\n";
+
+# Now we access the first four items in list (three are C++ objects that
+# EmployeeList's constructor adds, the last is our CEO). The virtual
+# methods of all these instances are treated the same. For items 0, 1, and
+# 2, both all methods resolve in C++. For item 3, our CEO, getTitle calls
+# getPosition which resolves in Perl. The call to getPosition is
+# slightly different, however, from the $e->getPosition() call above, since
+# now the object reference has been "laundered" by passing through
+# EmployeeList as an Employee*. Previously, Perl resolved the call
+# immediately in CEO, but now Perl thinks the object is an instance of
+# class Employee (actually EmployeePtr). So the call passes through the
+# Employee proxy class and on to the C wrappers and C++ director,
+# eventually ending up back at the CEO implementation of getPosition().
+# The call to getTitle() for item 3 runs the C++ Employee::getTitle()
+# method, which in turn calls getPosition(). This virtual method call
+# passes down through the C++ director class to the Perl implementation
+# in CEO. All this routing takes place transparently.
+
+print "(position, title) for items 0-3:\n";
+
+printf " %s, \"%s\"\n", $list->get_item(0)->getPosition(), $list->get_item(0)->getTitle();
+printf " %s, \"%s\"\n", $list->get_item(1)->getPosition(), $list->get_item(1)->getTitle();
+printf " %s, \"%s\"\n", $list->get_item(2)->getPosition(), $list->get_item(2)->getTitle();
+printf " %s, \"%s\"\n", $list->get_item(3)->getPosition(), $list->get_item(3)->getTitle();
+print "----------------------\n";
+
+# Time to delete the EmployeeList, which will delete all the Employee*
+# items it contains. The last item is our CEO, which gets destroyed as its
+# reference count goes to zero. The Perl destructor runs, and is still
+# able to call self.getName() since the underlying C++ object still
+# exists. After this destructor runs the remaining C++ destructors run as
+# usual to destroy the object.
+
+undef $list;
+print "----------------------\n";
+
+# All done.
+
+print "perl exit\n";
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_static
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SWIGOPT =
LIBS =
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='baseclass' INTERFACE='base.i' perl5_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' perl5_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' perl5_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' perl5_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='baseclass' INTERFACE='base.i' perl5_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' perl5_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' perl5_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' perl5_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
class Base {
public:
- Base() { };
- virtual ~Base() { };
+ Base() { }
+ virtual ~Base() { }
virtual void A() {
printf("I'm Base::A\n");
}
<li><a href="reference/index.html">reference</a>. C++ references.
<li><a href="pointer/index.html">pointer</a>. Simple pointer handling.
<li><a href="funcptr/index.html">funcptr</a>. Pointers to functions.
+<li><a href="callback/index.html">callback</a>. C++ callbacks using directors.
+<li><a href="extend/index.html">extend</a>. Extending a simple C++ class.
</ul>
<h2>Compilation Issues</h2>
run:
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
rm -rf _Inline
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
-build: Example.class
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' CXX="gcj" \
+build: Example.class Example.h
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
CXXSHARED="gcj -fpic -shared Example.class" PERL5_CCFLAGS='' PERL5_EXP='' LIBS="-lstdc++" perl5_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
- rm -f *.class Example.h
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
+ rm -f *.class Example.h
-Example.class: Example.java
- gcj -fPIC -C -c -g Example.java
- gcjh Example
+Example.class Example.h: $(SRCDIR)Example.java
+ gcj -d . -fPIC -C -c -g $(SRCDIR)Example.java
+ gcjh Example.class
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_static
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
-LIBS =
+LIBS =
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_static
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT = -noproxy
+SWIGOPT = -noproxy
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' SWIGOPT='$(SWIGOPT)' perl5_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myperl' INTERFACE='$(INTERFACE)' SWIGOPT='$(SWIGOPT)' perl5_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
char *Vector::print() {
static char temp[512];
- sprintf(temp,"Vector %p (%g,%g,%g)", this, x,y,z);
+ sprintf(temp,"Vector %p (%g,%g,%g)", (void *)this, x,y,z);
return temp;
}
private:
double x,y,z;
public:
- Vector() : x(0), y(0), z(0) { };
- Vector(double x, double y, double z) : x(x), y(y), z(z) { };
+ Vector() : x(0), y(0), z(0) { }
+ Vector(double x, double y, double z) : x(x), y(y), z(z) { }
friend Vector operator+(const Vector &a, const Vector &b);
char *print();
};
Vector &operator[](int);
int size();
};
-
-
-
-
VectorArray(int maxsize);
~VectorArray();
int size();
-
+
/* This wrapper provides an alternative to the [] operator */
%extend {
Vector &get(int index) {
}
}
};
-
-
-
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_static
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_static
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
}
void vector_print(Vector *v) {
- printf("Vector %p = (%g, %g, %g)\n", v, v->x, v->y, v->z);
+ printf("Vector %p = (%g, %g, %g)\n", (void *)v, v->x, v->y, v->z);
}
%}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' perl5
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_static
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
printf("dvar = %g\n", dvar);
printf("cvar = %c\n", cvar);
printf("strvar = %s\n", strvar ? strvar : "(null)");
- printf("cstrvar = %s\n", cstrvar ? cstrvar : "(null)");
- printf("iptrvar = %p\n", iptrvar);
+ printf("cstrvar = %s\n", cstrvar);
+ printf("iptrvar = %p\n", (void *)iptrvar);
printf("name = %s\n", name);
- printf("ptptr = %p (%d, %d)\n", ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
+ printf("ptptr = %p (%d, %d)\n", (void *)ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
printf("pt = (%d, %d)\n", pt.x, pt.y);
printf("status = %d\n", status);
}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lxerces-c -lxerces-depdom -lm
check: build
- $(MAKE) -f $(TOP)/Makefile perl5_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' LIBS=$(LIBS) CXX="g++ -g3" perl5_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myperl' INTERFACE='$(INTERFACE)' perl5_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile perl5_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
}
}
+%fragment("SWIG_XMLStringNLen","header") {
+size_t
+SWIG_XMLStringNLen(const XMLCh* s, size_t maxlen)
+{
+ const XMLCh *p;
+ for (p = s; maxlen-- && *p; p++)
+ ;
+ return p - s;
+}
+}
+
%init {
if (!SWIG_UTF8Transcoder()) {
croak("ERROR: XML::Xerces: INIT: Could not create UTF-8 transcoder");
SWIG_AsXMLChPtrAndSize,
SWIG_FromXMLChPtrAndSize,
XERCES_CPP_NAMESPACE::XMLString::stringLen,
+ SWIG_XMLStringNLen,
"<XMLCh.h>", INT_MIN, INT_MAX);
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' $(SWIGLIB) CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' php_cpp
static:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' $(SWIGLIB) CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' php_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
#include "example.h"
%}
-%include "std_string.i"
-
/* turn on director wrapping Callback */
%feature("director") Callback;
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
-#include <math.h>
-#ifndef M_PI
-# define M_PI 3.14159265358979323846
-#endif
-
-int Shape::get_nshapes() {
- return nshapes;
-}
+#define M_PI 3.14159265358979323846
/* Move the shape to a new location */
void Shape::move(double dx, double dy) {
int Shape::nshapes = 0;
-void Circle::set_radius( double r ) {
- radius = r;
-}
-
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
- static int get_nshapes();
};
class Circle : public Shape {
double radius;
public:
Circle(double r) : radius(r) { }
- ~Circle() { }
- void set_radius( double r );
- virtual double area(void);
- virtual double perimeter(void);
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
double width;
public:
Square(double w) : width(w) { }
- ~Square() { }
- virtual double area(void);
- virtual double perimeter(void);
+ virtual double area();
+ virtual double perimeter();
};
/* Let's just grab the original header file here */
%include "example.h"
-
# ----- Access a static member -----
-print "\nA total of " . Shape::get_nshapes() . " shapes were created\n";
+print "\nA total of " . Shape::nshapes() . " shapes were created\n";
# ----- Member data access -----
# the square.
$o = NULL;
-print Shape::get_nshapes() . " shapes remain\n";
+print Shape::nshapes() . " shapes remain\n";
print "Goodbye\n";
?>
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
/* File : example.c */
-void add(double *x, double *y, double *result) {
+void add(int *x, int *y, int *result) {
*result = *x + *y;
}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
}
virtual ~Shape() {
nshapes--;
- };
+ }
double x, y;
void move(double dx, double dy);
virtual double area(void) = 0;
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- ~Circle() { };
+ Circle(double r) : radius(r) { }
+ ~Circle() { }
void set_radius( double r );
virtual double area(void);
virtual double perimeter(void);
private:
double width;
public:
- Square(double w) : width(w) { };
+ Square(double w) : width(w) { }
~Square() { }
virtual double area(void);
virtual double perimeter(void);
typedef std::vector<Shape*>::iterator iterator;
std::vector<Shape*> shapes;
public:
- ShapeContainer() : shapes() {};
+ ShapeContainer() : shapes() {}
~ShapeContainer();
void addShape( Shape *s );
};
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT = -noproxy
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' $(SWIGLIB) CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' php_cpp
static:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' $(SWIGLIB) CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' php_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
virtual std::string getTitle() { return getPosition() + " " + getName(); }
virtual std::string getName() { return name; }
virtual std::string getPosition() const { return "Employee"; }
- virtual ~Employee() { printf("~Employee() @ %p\n", this); }
+ virtual ~Employee() { printf("~Employee() @ %p\n", (void *)this); }
};
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
print " c = $c\n";
# Call the add() function wuth some pointers
- add(&$a,&$b,&$c);
+ add($a,$b,$c);
print " $a + $b = $c\n";
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS =
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
}
virtual ~Shape() {
nshapes--;
- };
+ }
double x, y;
void move(double dx, double dy);
virtual double area(void) = 0;
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- ~Circle() { };
+ Circle(double r) : radius(r) { }
+ ~Circle() { }
void set_radius( double r );
virtual double area(void);
virtual double perimeter(void);
private:
double width;
public:
- Square(double w) : width(w) { };
+ Square(double w) : width(w) { }
~Square() { }
virtual double area(void);
virtual double perimeter(void);
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
char *Vector::as_string() {
static char temp[512];
- sprintf(temp,"Vector %p (%g,%g,%g)", this, x,y,z);
+ sprintf(temp,"Vector %p (%g,%g,%g)", (void *)this, x,y,z);
return temp;
}
VectorArray::VectorArray(int size) {
items = new Vector[size];
maxsize = size;
- printf("VectorArray new: self=%p\n",this);
+ printf("VectorArray new: self=%p\n", (void *)this);
}
VectorArray::~VectorArray() {
- printf("VectorArray delete: self=%p\n",this);
+ printf("VectorArray delete: self=%p\n", (void *)this);
delete [] items;
}
Vector &VectorArray::operator[](int index) {
- printf("VectorArray: read[%d] self=%p\n",index,this);
+ printf("VectorArray: read[%d] self=%p\n", index, (void *)this);
if ((index < 0) || (index >= maxsize)) {
printf("Panic! Array index out of bounds.\n");
exit(1);
}
int VectorArray::size() {
- printf("VectorArray: size %d self=%p\n",maxsize,this);
+ printf("VectorArray: size %d self=%p\n", maxsize, (void *)this);
return maxsize;
}
private:
double x,y,z;
public:
- Vector() : x(0), y(0), z(0) { };
- Vector(double x, double y, double z) : x(x), y(y), z(z) { };
+ Vector() : x(0), y(0), z(0) { }
+ Vector(double x, double y, double z) : x(x), y(y), z(z) { }
friend Vector operator+(const Vector &a, const Vector &b);
char *as_string();
};
Vector &operator[](int);
int size();
};
-
-
-
-
/* File : example.i */
-/* This example has nothing to do with references but the name is used by all
- * the other languages so it's hard to rename to something more meaningful.
- *
- * Mostly it shows how to use %extend.
- */
+/* This file has a few "typical" uses of C++ references. */
%module example
VectorArray(int maxsize);
~VectorArray();
int size();
-
- /* This wrapper provides an alternative to the [] operator */
+
+ /* This wrapper provides an alternative to the [] operator */
%extend {
Vector &get(int index) {
- printf("VectorArray extended get: %p %d\n",$self,index);
+ printf("VectorArray extended get: %p %d\n", (void *)$self, index);
return (*$self)[index];
}
void set(int index, Vector &a) {
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
printf("The value of global x is %d\n", x);
printf("The value of class s is %s\n", s);
printf("The value of class x is %d\n", x);
-};
+}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
SWIGOPT = -noproxy
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
%inline %{
void vector_print(Vector *v) {
- printf("Vector %p = (%g, %g, %g)\n", v, v->x, v->y, v->z);
+ printf("Vector %p = (%g, %g, %g)\n", (void *)v, v->x, v->y, v->z);
}
%}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile php_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
php
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myphp' INTERFACE='$(INTERFACE)' \
php_static
clean:
- $(MAKE) -f $(TOP)/Makefile php_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' php_clean
printf("dvar = %g\n", dvar);
printf("cvar = %c\n", cvar);
printf("strvar = %s\n", strvar ? strvar : "(null)");
- printf("cstrvar = %s\n", cstrvar ? cstrvar : "(null)");
- printf("iptrvar = %p\n", iptrvar);
+ printf("cstrvar = %s\n", cstrvar);
+ printf("iptrvar = %p\n", (void *)iptrvar);
printf("name = %c%c%c%c%c\n", name[0],name[1],name[2],name[3],name[4]);
- printf("ptptr = %p %s\n", ptptr, Point_print( ptptr ) );
+ printf("ptptr = %p %s\n", (void *)ptptr, Point_print( ptptr ) );
printf("pt = (%d, %d)\n", pt.x, pt.y);
printf("status = %d\n", status);
}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile pike_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypike' INTERFACE='$(INTERFACE)' pike_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile pike_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_clean
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
-
-#include <stdio.h>
-
#define M_PI 3.14159265358979323846
-// Static member initializer
-int Shape::nshapes = 0;
-
-// Constructor
-Shape::Shape() {
- nshapes++;
-}
-
-// Move the shape to a new location
+/* Move the shape to a new location */
void Shape::move(double dx, double dy) {
x += dx;
y += dy;
}
-// Destructor
-Shape::~Shape() {
- nshapes--;
-}
+int Shape::nshapes = 0;
-// Circle area
-double Circle::area() const {
+double Circle::area() {
return M_PI*radius*radius;
}
-// Circle perimeter
-double Circle::perimeter() const {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-// Square area
-double Square::area() const {
+double Square::area() {
return width*width;
}
-// Square perimeter
-double Square::perimeter() const {
+double Square::perimeter() {
return 4*width;
}
class Shape {
public:
- Shape();
- virtual ~Shape();
- double x, y;
+ Shape() {
+ nshapes++;
+ }
+ virtual ~Shape() {
+ nshapes--;
+ }
+ double x, y;
void move(double dx, double dy);
- virtual double area() const = 0;
- virtual double perimeter() const = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area() const;
- virtual double perimeter() const;
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area() const;
- virtual double perimeter() const;
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
-
-
-
-
-
/* Let's just grab the original header file here */
%include "example.h"
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile pike_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypike' INTERFACE='$(INTERFACE)' pike_static
clean:
- $(MAKE) -f $(TOP)/Makefile pike_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile pike_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypike' INTERFACE='$(INTERFACE)' pike_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile pike_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lstdc++ -lm
check: build
- $(MAKE) -f $(TOP)/Makefile pike_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypike' INTERFACE='$(INTERFACE)' pike_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile pike_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile pike_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypike' INTERFACE='$(INTERFACE)' pike_static
clean:
- $(MAKE) -f $(TOP)/Makefile pike_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile pike_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='mypike' INTERFACE='$(INTERFACE)' pike_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile pike_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' $(SWIGLIB) CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' $(SWIGLIB) CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
#include "example.h"
%}
-%include "std_string.i"
-
/* turn on director wrapping Callback */
%feature("director") Callback;
# This file illustrates the cross language polymorphism using directors.
-import example
+import example
class PyCallback(example.Callback):
- def __init__(self):
- example.Callback.__init__(self)
- def run(self):
- print "PyCallback.run()"
+
+ def __init__(self):
+ example.Callback.__init__(self)
+
+ def run(self):
+ print "PyCallback.run()"
# Create an Caller instance
callback.thisown = 0
caller.setCallback(callback)
caller.call()
-caller.delCallback();
+caller.delCallback()
print
print "Adding and calling a Python callback"
print "Adding and calling another Python callback"
print "------------------------------------------"
-# Lets do the same but use the weak reference this time.
+# Let's do the same but use the weak reference this time.
callback = PyCallback().__disown__()
caller.setCallback(callback)
print
print "python exit"
-
functor
import
import_template
+import_packages
java
#libffi
multimap
smartptr
std_vector
std_map
-swigrun
template
varargs
variables
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
-
-
-
-
-
/* Let's just grab the original header file here */
%include "example.h"
-
<H2>Wrapping a simple C++ class</H2>
<p>
-This example illustrates the most primitive form of C++ class wrapping performed
-by SWIG. In this case, C++ classes are simply transformed into a collection of
-C-style functions that provide access to class members.
+This example illustrates wrapping a simple C++ class to give a Python class.
<h2>The C++ Code</h2>
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
virtual double area() = 0;
virtual double perimeter() = 0;
private:
double radius;
public:
- Circle(double r) : radius(r) { };
+ Circle(double r) : radius(r) { }
virtual double area();
virtual double perimeter();
};
private:
double width;
public:
- Square(double w) : width(w) { };
+ Square(double w) : width(w) { }
virtual double area();
virtual double perimeter();
};
</blockquote>
<p>
-<li>To access member data, a pair of accessor functions are used.
+<li>Member variables of the C++ class are wrapped as attributes of the Python class.
For example:
<blockquote>
<pre>
-example.Shape_x_set(c,15) # Set member data
-x = example.Shape_x_get(c) # Get member data
+c.x = 15 # Set member data
+x = c.x # Get member data
</pre>
</blockquote>
-Note: when accessing member data, the name of the class in which
-the member data was must be used. In this case, <tt>Shape_x_get()</tt>
-and <tt>Shape_x_set()</tt> are used since 'x' was defined in Shape.
-
<p>
-<li>To invoke a member function, you simply do this
+<li>Member function are invoked as you would expect:
<blockquote>
<pre>
-print "The area is ", example.Shape_area(c)
+print "The area is ", c.area()
</pre>
</blockquote>
<p>
-<li>Type checking knows about the inheritance structure of C++. For example:
+<li>To invoke a destructor, simply call <code>del</code> on the object:
<blockquote>
<pre>
-example.Shape_area(c) # Works (c is a Shape)
-example.Circle_area(c) # Works (c is a Circle)
-example.Square_area(c) # Fails (c is definitely not a Square)
+del c # Deletes a shape
</pre>
</blockquote>
<p>
-<li>To invoke a destructor, simply do this
-
-<blockquote>
-<pre>
-example.delete_Shape(c) # Deletes a shape
-</pre>
-</blockquote>
-
-(Note: destructors are currently not inherited. This might change later).
-
-<p>
<li>Static member variables are wrapped as C global variables. For example:
<blockquote>
<h2>General Comments</h2>
<ul>
-<li>This low-level interface is not the only way to handle C++ code.
-Proxy classes provide a much higher-level interface.
-
-<p>
-<li>SWIG *does* know how to properly perform upcasting of objects in
+<li>SWIG <b>does</b> know how to properly perform upcasting of objects in
an inheritance hierarchy (including multiple inheritance). Therefore
it is perfectly safe to pass an object of a derived class to any
function involving a base class.
-<p>
-<li>A wide variety of C++ features are not currently supported by SWIG. Here is the
-short and incomplete list:
-
-<p>
-<ul>
-<li>Overloaded methods and functions. SWIG wrappers don't know how to resolve name
-conflicts so you must give an alternative name to any overloaded method name using the
-%name directive like this:
-
-<blockquote>
-<pre>
-void foo(int a);
-%name(foo2) void foo(double a, double b);
-</pre>
-</blockquote>
-
-<p>
-<li>Overloaded operators. Not supported at all. The only workaround for this is
-to write a helper function. For example:
-
-<blockquote>
-<pre>
-%inline %{
- Vector *vector_add(Vector *a, Vector *b) {
- ... whatever ...
- }
-%}
-</pre>
-</blockquote>
-
-<p>
-<li>Namespaces. Not supported at all. Won't be supported until SWIG2.0 (if at all).
-
-<p>
-<li>Dave's snide remark: Like a large bottle of strong Tequilla, it's better to
-use C++ in moderation.
+<li>C++ Namespaces - %nspace isn't yet supported for Python.
</ul>
# This file illustrates the proxy class C++ interface generated
# by SWIG.
-import example
+import example
# ----- Object creation -----
# ----- Access a static member -----
-print "\nA total of", example.cvar.Shape_nshapes,"shapes were created"
+print "\nA total of", example.cvar.Shape_nshapes, "shapes were created"
# ----- Member data access -----
s.y = 5
print "\nHere is their current position:"
-print " Circle = (%f, %f)" % (c.x,c.y)
-print " Square = (%f, %f)" % (s.x,s.y)
+print " Circle = (%f, %f)" % (c.x, c.y)
+print " Square = (%f, %f)" % (s.x, s.y)
# ----- Call some methods -----
print "\nHere are some properties of the shapes:"
-for o in [c,s]:
- print " ", o
- print " area = ", o.area()
- print " perimeter = ", o.perimeter()
+for o in [c, s]:
+ print " ", o
+ print " area = ", o.area()
+ print " perimeter = ", o.perimeter()
+# prevent o from holding a reference to the last object looked at
+o = None
print "\nGuess I'll clean up now"
del c
del s
-s = 3
-print example.cvar.Shape_nshapes,"shapes remain"
+print example.cvar.Shape_nshapes, "shapes remain"
print "Goodbye"
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
# file: runme.py
-import example
+import example
print "ICONST =", example.ICONST, "(should be 42)"
print "FCONST =", example.FCONST, "(should be 2.1828)"
print "CCONST2 =", example.CCONST2, "(this should be on a new line)"
print "SCONST =", example.SCONST, "(should be 'Hello World')"
print "SCONST2 =", example.SCONST2, "(should be '\"Hello World\"')"
-print "EXPR =", example.EXPR, "(should be 48.5484)"
+print "EXPR =", example.EXPR, "(should be 48.5484)"
print "iconst =", example.iconst, "(should be 37)"
print "fconst =", example.fconst, "(should be 3.14)"
print "FOO = ", example.FOO, "(Arg! This shouldn't print anything)"
except AttributeError:
print "FOO isn't defined (good)"
-
-
-
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
# file: runme.py
-import example
+import example
# Call our gcd() function
x = 42
y = 105
-g = example.gcd(x,y)
-print "The gcd of %d and %d is %d" % (x,y,g)
+g = example.gcd(x, y)
+print "The gcd of %d and %d is %d" % (x, y, g)
# Manipulate the Foo global variable
# See if the change took effect
print "Foo = ", example.cvar.Foo
-
-
-
-
-
-
-
-
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
SWIGOPT = -O
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
# file: runme.py
-import example
+import example
print "example.Foo.bar.__doc__ =", repr(example.Foo.bar.__doc__), "(Should be 'No comment')"
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
print "\nTesting use of enums with functions\n"
example.enum_test(example.RED, example.Foo.IMPULSE)
-example.enum_test(example.BLUE, example.Foo.WARP)
+example.enum_test(example.BLUE, example.Foo.WARP)
example.enum_test(example.GREEN, example.Foo.LUDICROUS)
-example.enum_test(1234,5678)
+example.enum_test(1234, 5678)
print "\nTesting use of enum with class method"
f = example.Foo()
f.enum_test(example.Foo.IMPULSE)
f.enum_test(example.Foo.WARP)
f.enum_test(example.Foo.LUDICROUS)
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
/* Let's just grab the original header file here */
%include "example.h"
+%inline %{
+// The -builtin SWIG option results in SWIGPYTHON_BUILTIN being defined
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
+%}
+
t = example.Test()
try:
- t.unknown()
-except RuntimeError,e:
- print "incomplete type", e.args[0]
+ t.unknown()
+except RuntimeError, e:
+ print "incomplete type", e.args[0]
try:
- t.simple()
-except RuntimeError,e:
- print e.args[0]
+ t.simple()
+except RuntimeError, e:
+ print e.args[0]
try:
- t.message()
-except RuntimeError,e:
- print e.args[0]
-
-try:
- t.hosed()
-except example.Exc,e:
- print e.code, e.msg
-
-for i in range(1,4):
- try:
- t.multi(i)
- except RuntimeError,e:
- print e.args[0]
- except example.Exc,e:
- print e.code, e.msg
-
-
+ t.message()
+except RuntimeError, e:
+ print e.args[0]
+
+if not example.is_python_builtin():
+ try:
+ t.hosed()
+ except example.Exc, e:
+ print e.code, e.msg
+else:
+ try:
+ t.hosed()
+ except BaseException, e:
+ # Throwing builtin classes as exceptions not supported (-builtin
+ # option)
+ print e
+
+for i in range(1, 4):
+ try:
+ t.multi(i)
+ except RuntimeError, e:
+ print e.args[0]
+ except example.Exc, e:
+ print e.code, e.msg
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
%template(doubleQueue) Queue<double>;
-
-
+%inline %{
+// The -builtin SWIG option results in SWIGPYTHON_BUILTIN being defined
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
+%}
# file: runme.py
import example
+if example.is_python_builtin():
+ print "Skipping example: -builtin option does not support %exceptionclass"
+ exit(0)
+
q = example.intQueue(10)
print "Inserting items into intQueue"
+print type(example.FullError)
+
try:
- for i in range(0,100):
- q.enqueue(i)
-except example.FullError,e:
- print "Maxsize is", e.maxsize
+ for i in range(0, 100):
+ q.enqueue(i)
+except example.FullError, e:
+ print "Maxsize is", e.maxsize
print "Removing items"
try:
- while 1:
- q.dequeue()
-except example.EmptyError,e:
- pass
+ while 1:
+ q.dequeue()
+except example.EmptyError, e:
+ pass
q = example.doubleQueue(1000)
print "Inserting items into doubleQueue"
try:
- for i in range(0,10000):
- q.enqueue(i*1.5)
-except example.FullError,e:
- print "Maxsize is", e.maxsize
+ for i in range(0, 10000):
+ q.enqueue(i * 1.5)
+except example.FullError, e:
+ print "Maxsize is", e.maxsize
print "Removing items"
try:
- while 1:
- q.dequeue()
-except example.EmptyError,e:
- pass
-
-
-
-
-
-
+ while 1:
+ q.dequeue()
+except example.EmptyError, e:
+ pass
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' $(SWIGLIB) CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' $(SWIGLIB) CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
virtual std::string getTitle() { return getPosition() + " " + getName(); }
virtual std::string getName() { return name; }
virtual std::string getPosition() const { return "Employee"; }
- virtual ~Employee() { printf("~Employee() @ %p\n", this); }
+ virtual ~Employee() { printf("~Employee() @ %p\n", (void *)this); }
};
# This file illustrates the cross language polymorphism using directors.
-import example
+import example
# CEO class, which overrides Employee::getPosition().
class CEO(example.Manager):
- def __init__(self, name):
- example.Manager.__init__(self, name)
- def getPosition(self):
- return "CEO"
+
+ def __init__(self, name):
+ example.Manager.__init__(self, name)
+
+ def getPosition(self):
+ return "CEO"
# Create an instance of our employee extension class, CEO. The calls to
# All done.
print "python exit"
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
# file: runme.py
-import example
+import example
a = 37
b = 42
print "Trying some C callback functions"
print " a =", a
print " b =", b
-print " ADD(a,b) =", example.do_op(a,b,example.ADD)
-print " SUB(a,b) =", example.do_op(a,b,example.SUB)
-print " MUL(a,b) =", example.do_op(a,b,example.MUL)
+print " ADD(a,b) =", example.do_op(a, b, example.ADD)
+print " SUB(a,b) =", example.do_op(a, b, example.SUB)
+print " MUL(a,b) =", example.do_op(a, b, example.MUL)
print "Here is what the C callback function objects look like in Python"
print " ADD =", example.ADD
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
# file: runme.py
-import example
+import example
a = 37
b = 42
print "Trying some C callback functions"
print " a =", a
print " b =", b
-print " ADD(a,b) =", example.do_op(a,b,example.ADD)
-print " SUB(a,b) =", example.do_op(a,b,example.SUB)
-print " MUL(a,b) =", example.do_op(a,b,example.MUL)
+print " ADD(a,b) =", example.do_op(a, b, example.ADD)
+print " SUB(a,b) =", example.do_op(a, b, example.SUB)
+print " MUL(a,b) =", example.do_op(a, b, example.MUL)
print "Here is what the C callback function objects look like in Python"
print " ADD =", example.ADD
print " MUL =", example.MUL
print "Call the functions directly..."
-print " add(a,b) =", example.add(a,b)
-print " sub(a,b) =", example.sub(a,b)
+print " add(a,b) =", example.add(a, b)
+print " sub(a,b) =", example.sub(a, b)
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
# Use the objects. They should be callable just like a normal
# python function.
-for i in range(0,100):
+for i in range(0, 100):
a(i) # Note: function call
b(math.sqrt(i)) # Note: function call
print a.result()
print b.result()
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SWIGOPT =
LIBS =
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='base' INTERFACE='base.i' python_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='base' INTERFACE='base.i' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' python_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
rm -f foo.py bar.py spam.py base.py
class Base {
public:
- Base() { };
- virtual ~Base() { };
+ Base() { }
+ virtual ~Base() { }
virtual void A() {
printf("I'm Base::A\n");
}
print " Spam -> Base -> Foo : ",
y = foo.Foo_fromBase(x)
if y:
- print "bad swig"
+ print "bad swig"
else:
- print "good swig"
+ print "good swig"
print " Spam -> Base -> Bar : ",
y = bar.Bar_fromBase(x)
if y:
- print "good swig"
+ print "good swig"
else:
- print "bad swig"
-
+ print "bad swig"
+
print " Spam -> Base -> Spam : ",
y = spam.Spam_fromBase(x)
if y:
- print "good swig"
+ print "good swig"
else:
- print "bad swig"
+ print "bad swig"
print " Foo -> Spam : ",
y = spam.Spam_fromBase(b)
if y:
- print "bad swig"
+ print "bad swig"
else:
- print "good swig"
-
-
-
-
+ print "good swig"
--- /dev/null
+TOP = ../..
+SWIGOPT =
+LIBS =
+
+import_packages_subdirs = \
+ same_modnames1 \
+ same_modnames2 \
+ from_init1 \
+ from_init2 \
+ from_init3 \
+ relativeimport1 \
+ relativeimport2 \
+ relativeimport3 \
+ split_modules \
+ namespace_pkg
+
+
+check: build
+ if test "x$(SRCDIR)" != x; then \
+ for file in `cd $(SRCDIR) && find . -type f -name "*.py"`; do \
+ mkdir -p `dirname $$file`; \
+ cp "${SRCDIR}$$file" "$$file" || exit 1; \
+ done; \
+ fi; \
+ for s in $(import_packages_subdirs); do \
+ (cd $$s && $(MAKE) check); \
+ done
+
+build:
+ for s in $(import_packages_subdirs); do \
+ (cd $$s && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build); \
+ done
+
+static:
+ for s in $(import_packages_subdirs); do \
+ (cd $$s && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static); \
+ done
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ if test "x$(SRCDIR)" != x; then \
+ for file in `cd $(SRCDIR) && find . -type f -name "*.py"`; do \
+ rm -f "$$file" || exit 1; \
+ done; \
+ fi; \
+ for s in $(import_packages_subdirs); do \
+ (cd $$s && $(MAKE) clean); \
+ done
--- /dev/null
+These are actually regression tests for SF bug #1297 (GH issue #7).
+The namespace_pkg is an example of python3's namespace packages.
+
+See individual READMEs in subdirectories.
\ No newline at end of file
--- /dev/null
+TOP = ../../..
+LIBS =
+
+ifeq (,$(PY3))
+ PKG1DIR = "py2"
+else
+ PKG1DIR = "py3"
+endif
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
+
+build:
+ cd $(PKG1DIR) && $(MAKE) SWIGOPT='$(SWIGOPT) -relativeimport' LIBS='$(LIBS)' build
+
+static:
+ cd $(PKG1DIR) && $(MAKE) SWIGOPT='$(SWIGOPT) -relativeimport' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd py2 && $(MAKE) clean
+ cd py3 && $(MAKE) clean
--- /dev/null
+This example tests the %import directive and python import from __init__.py.
+
+This case is not correctly handled by swig 2.
+
+The issue was reported as Source Forge bug #1297 and later as GitHub issue #7.
+
+Use 'python runme.py' to run a test.
+
+
+Overview:
+---------
+
+The example defines 2 different extension modules--each wrapping a separate C++
+class.
+
+ pyX/pkg2/foo.i - Pkg2_Foo class
+ pyX/pkg2/bar.i - Pkg2_Bar class derived from Pkg2_Foo
+
+and the package pyX.pkg2 has:
+
+ pyX/pkg2/__init__.py - which imports something from "bar" module (we
+ import Pkg2_Bar class, but it is not the clue,
+ the clue is the 'from' keyword)
+
+For example with python2.x the py2/pkg2/__init__.py imports Pkg2_Bar class
+as follows
+
+ from bar import Pkg2_Bar # [1]
+
+Such cases doesn't work when fully qualified python module names are used by
+swig (swig 2.0.10, e.g.) to generate python import directives (SF bug #1297).
+The generated file "py2/pkg2/bar.py" has following lines:
+
+ import py2.pkg2.foo # [2]
+ class Pkg2_Bar(py2.pkg2.foo.Pkg2_Foo): # [3]
+
+but it's not possible to import anything from py2.pkg2 subpackage, e.g.
+
+ import py2.pkg2
+
+fails with the following exception:
+
+Traceback (most recent call last):
+ File "runme.py", line 3, in <module>
+ import py2.pkg2
+ File "py2/pkg2/__init__.py", line 7, in <module>
+ from .bar import Pkg2_Bar
+ File "py2/pkg2/bar.py", line 71, in <module>
+ class Pkg2_Bar(py2.pkg2.foo.Pkg2_Foo):
+ AttributeError: 'module' object has no attribute 'pkg2'
+
+
+It seems like during the import [1], the sub-package pkg2 is not yet fully
+initialized, so py2.pkg2 is not known. The above exception is raised at
+line [3]. The problem disappears, for example, if we force swig to use relative
+package names.
+
+If everything works well, the package py2.pkg2 shall load properly.
+
+Unix:
+-----
+- Run make
+- Run the test as described above
--- /dev/null
+TOP = ../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp_static
+
+clean::
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='bar' python_clean
--- /dev/null
+from bar import Pkg2_Bar
--- /dev/null
+#ifndef PY2_PKG2_BAR_HPP
+#define PY2_PKG2_BAR_HPP
+#include "../../py2/pkg2/foo.hpp"
+struct Pkg2_Bar : Pkg2_Foo {};
+#endif /* PY2_PKG2_BAR_HPP */
--- /dev/null
+%module(package="py2.pkg2") bar
+%{
+#include "../../py2/pkg2/bar.hpp"
+%}
+%import "../../py2/pkg2/foo.i"
+%include "../../py2/pkg2/bar.hpp"
--- /dev/null
+#ifndef PY2_PKG2_FOO_HPP
+#define PY2_PKG2_FOO_HPP
+struct Pkg2_Foo {};
+#endif /* PY2_PKG2_FOO_HPP */
--- /dev/null
+%module(package="py2.pkg2") foo
+%{
+#include "../../py2/pkg2/foo.hpp"
+%}
+%include "../../py2/pkg2/foo.hpp"
--- /dev/null
+TOP = ../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp_static
+
+clean::
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='bar' python_clean
--- /dev/null
+from .bar import Pkg2_Bar
--- /dev/null
+#ifndef PY3_PKG2_BAR_HPP
+#define PY3_PKG2_BAR_HPP
+#include "../../py3/pkg2/foo.hpp"
+struct Pkg2_Bar : Pkg2_Foo {};
+#endif /* PY3_PKG2_BAR_HPP */
--- /dev/null
+%module(package="py3.pkg2") bar
+%{
+#include "../../py3/pkg2/bar.hpp"
+%}
+%import "../../py3/pkg2/foo.i"
+%include "../../py3/pkg2/bar.hpp"
--- /dev/null
+#ifndef PY3_PKG2_FOO_HPP
+#define PY3_PKG2_FOO_HPP
+struct Pkg2_Foo {};
+#endif /* PY3_PKG2_FOO_HPP */
--- /dev/null
+%module(package="py3.pkg2") foo
+%{
+#include "../../py3/pkg2/foo.hpp"
+%}
+%include "../../py3/pkg2/foo.hpp"
--- /dev/null
+import sys
+import os.path
+
+# Test import of modules content from within __init__.py
+testname = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+print "Testing " + testname + " - %module(package=...) + python 'import' in __init__.py"
+
+if sys.version_info < (3, 0):
+ import py2.pkg2
+ print " Finished importing py2.pkg2"
+else:
+ import py3.pkg2
+ print " Finished importing py3.pkg2"
--- /dev/null
+TOP = ../../..
+LIBS =
+
+ifeq (,$(PY3))
+ PKG1DIR = "py2"
+else
+ PKG1DIR = "py3"
+endif
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
+
+build:
+ cd $(PKG1DIR) && $(MAKE) SWIGOPT='$(SWIGOPT) -relativeimport' LIBS='$(LIBS)' build
+
+static:
+ cd $(PKG1DIR) && $(MAKE) SWIGOPT='$(SWIGOPT) -relativeimport' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd py2 && $(MAKE) clean
+ cd py3 && $(MAKE) clean
--- /dev/null
+This example tests the %import directive and python import from __init__.py.
+
+This case is not correctly handled by swig 2.
+
+The issue was reported as Source Forge bug #1297 and later as GitHub issue #7.
+
+Use 'python runme.py' to run a test.
+
+Overview:
+---------
+
+The example defines 2 different extension modules--each wrapping a separate C++
+class.
+
+ pyX/pkg2/pkg3/foo.i - Pkg3_Foo class
+ pyX/pkg2/bar.i - Pkg2_Bar class derived from Pkg3_Foo
+
+and the package pyX.pkg2 has:
+
+ pyX/pkg2/__init__.py - which imports something from "bar" module
+
+For example with python 2.x the py2/pkg2/__init__.py imports Pkg2_Bar class as
+follows
+
+ from bar import Pkg2_Bar # [1]
+
+Such cases doesn't work when fully qualified python module names are used by
+swig to generate python import directives (SF bug #1297). The generated file
+"py2/pkg2/bar.py" has following lines:
+
+ import py2.pkg2.pkg3.foo # [2]
+ class Pkg2_Bar(py2.pkg2.pkg3.foo.Pkg3_Foo): # [3]
+
+and it's not possible to import anything from py2.pkg2 subpackage, e.g.
+
+ import py2.pkg2
+
+fails with the following exception:
+
+Traceback (most recent call last):
+ File "runme.py", line 3, in <module>
+ import py2.pkg2
+ File "py2/pkg2/__init__.py", line 4, in <module>
+ from bar import Pkg2_Bar
+ File "py2/pkg2/bar.py", line 71, in <module>
+ class Pkg2_Bar(py2.pkg2.pkg3.foo.Pkg3_Foo):
+AttributeError: 'module' object has no attribute 'pkg2'
+
+It seems like during the import [1], the subpackage pkg2 is not yet fully
+initialized, so pyX.pkg2 is not known. The above exception is raised at line [3].
+The problem disappears, for example, if we force swig to use relative package
+names.
+
+The difference between this ('from_init2') case and the case
+'from_init1' is that here it's not sufficient to import relative module
+by just ignoring the package part of the fully qualified module name. IOW
+it is not correct to force swig to put:
+
+ import foo
+ class Pkg2_Bar(foo.Pkg3_Foo)
+
+into pyX/pkg2/bar.py (note, that this would work for 'from_init1' case).
+The import directive shall be rather:
+
+ import pkg3.foo
+
+for python 2.x and:
+
+ from . import pkg3
+ import pkg3.foo
+
+for python 3, and the class definition shall begin with:
+
+ class Pkg2_Bar(pkg3.foo.Pkg3_Foo)
+
+If everything works well, the package pyX.pkg2 shall load properly.
+
+Unix:
+-----
+- Run make
+- Run the test as described above
--- /dev/null
+TOP = ../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='bar' python_clean
+ cd pkg3 && $(MAKE) clean
--- /dev/null
+from bar import Pkg2_Bar
--- /dev/null
+#ifndef PY2_PKG2_BAR_HPP
+#define PY2_PKG2_BAR_HPP
+#include "../../py2/pkg2/pkg3/foo.hpp"
+struct Pkg2_Bar : Pkg3_Foo {};
+#endif /* PY2_PKG2_BAR_HPP */
--- /dev/null
+%module(package="py2.pkg2") bar
+%{
+#include "../../py2/pkg2/bar.hpp"
+%}
+%import "../../py2/pkg2/pkg3/foo.i"
+%include "../../py2/pkg2/bar.hpp"
--- /dev/null
+TOP = ../../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PY2_PKG2_PKG3_FOO_HPP
+#define PY2_PKG2_PKG3_FOO_HPP
+struct Pkg3_Foo {};
+#endif /* PY2_PKG2_PKG3_FOO_HPP */
--- /dev/null
+%module(package="py2.pkg2.pkg3") foo
+%{
+#include "../../../py2/pkg2/pkg3/foo.hpp"
+%}
+%include "../../../py2/pkg2/pkg3/foo.hpp"
--- /dev/null
+TOP = ../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='bar' python_clean
+ cd pkg3 && $(MAKE) clean
--- /dev/null
+from .bar import Pkg2_Bar
--- /dev/null
+#ifndef PY3_PKG2_BAR_HPP
+#define PY3_PKG2_BAR_HPP
+#include "../../py3/pkg2/pkg3/foo.hpp"
+struct Pkg2_Bar : Pkg3_Foo {};
+#endif /* PY3_PKG2_BAR_HPP */
--- /dev/null
+%module(package="py3.pkg2") bar
+%{
+#include "../../py3/pkg2/bar.hpp"
+%}
+%import "../../py3/pkg2/pkg3/foo.i"
+%include "../../py3/pkg2/bar.hpp"
--- /dev/null
+TOP = ../../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PY3_PKG2_PKG3_FOO_HPP
+#define PY3_PKG2_PKG3_FOO_HPP
+struct Pkg3_Foo {};
+#endif /* PY3_PKG2_PKG3_FOO_HPP */
--- /dev/null
+%module(package="py3.pkg2.pkg3") foo
+%{
+#include "../../../py3/pkg2/pkg3/foo.hpp"
+%}
+%include "../../../py3/pkg2/pkg3/foo.hpp"
--- /dev/null
+import sys
+import os.path
+
+# Test import of modules content from within __init__.py
+testname = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+print "Testing " + testname + " - %module(package=...) + python 'import' in __init__.py"
+
+if sys.version_info < (3, 0):
+ import py2.pkg2
+ print " Finished importing py2.pkg2"
+else:
+ import py3.pkg2
+ print " Finished importing py3.pkg2"
--- /dev/null
+TOP = ../../..
+LIBS =
+
+ifeq (,$(PY3))
+ PKG1DIR = "py2"
+else
+ PKG1DIR = "py3"
+endif
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
+
+build:
+ cd $(PKG1DIR) && $(MAKE) SWIGOPT='$(SWIGOPT) -relativeimport' LIBS='$(LIBS)' build
+
+static:
+ cd $(PKG1DIR) && $(MAKE) SWIGOPT='$(SWIGOPT) -relativeimport' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd py2 && $(MAKE) clean
+ cd py3 && $(MAKE) clean
--- /dev/null
+This example tests the %import directive and python import from __init__.py.
+
+This case is not correctly handled by swig 2.
+
+The issue was reported as Source Forge bug #1297 and later as GitHub issue #7.
+
+Use 'python runme.py' to run a test.
+
+Overview:
+---------
+
+The example defines 2 different extension modules--each wrapping a separate C++
+class.
+
+ pyX/pkg2/pkg3/pkg4/foo.i - Pkg4_Foo class
+ pyX/pkg2/bar.i - Pkg2_Bar class derived from Pkg4_Foo
+
+and the package pyX.pkg2 has:
+
+ pyX/pkg2/__init__.py - which imports something from "bar" module
+
+For example with python 2.x the py2/pkg2/__init__.py imports Pkg2_Bar class as
+follows
+
+ from bar import Pkg2_Bar # [1]
+
+Such cases doesn't work when fully qualified python module names are used by
+swig to generate python import directives (SF bug 1297). The generated file
+"py2/pkg2/bar.py" has following lines:
+
+ import py2.pkg2.pkg3.pkg4.foo # [2]
+ class Pkg2_Bar(py2.pkg2.pkg3.pkg4.foo.P1_S1_S2_Foo): # [3]
+
+and it's not possible to import anything from py2.pkg2 subpackage, e.g.
+
+ import py2.pkg2
+
+fails with the following exception:
+
+ Traceback (most recent call last):
+ File "runme.py", line 3, in <module>
+ import py2.pkg2
+ File "py2/pkg2/__init__.py", line 4, in <module>
+ from bar import Pkg2_Bar
+ File "py2/pkg2/bar.py", line 71, in <module>
+ class Pkg2_Bar(py2.pkg2.pkg3.pkg4.foo.Pkg4_Foo):
+ AttributeError: 'module' object has no attribute 'pkg2'
+
+It seems like during the import [1], the subpackage pkg2 is not yet fully
+initialized, so py2.pkg2 can't be used. The above exception is raised at
+line [3]. The problem disappears, for example, if we force swig to use relative
+package names.
+
+The difference between this ('from_init3') case and the case
+'from_init2' is that here we import base class from module
+pyX.pkg2.pkg3.pkg4.foo, which is nested deeper than it was in
+'from_init2'. This is just to ensure, that two (and more) levels of
+subpackages get imported correctly by generated python code, i.e, not only
+'pkg3.foo' is handled properly (one-level subpackage) but the code works also
+for 'pkg3.pkg4.foo', and so on.
+
+If everything works well, the package pyX.pkg2 shall load properly.
+
+Unix:
+-----
+- Run make
+- Run the test as described above
--- /dev/null
+TOP = ../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='bar' python_clean
+ cd pkg3 && $(MAKE) clean
--- /dev/null
+from bar import Pkg2_Bar
--- /dev/null
+#ifndef PY2_PKG2_HPP
+#define PY2_PKG2_HPP
+#include "../../py2/pkg2/pkg3/pkg4/foo.hpp"
+struct Pkg2_Bar : Pkg4_Foo {};
+#endif /* PY2_PKG2_HPP */
--- /dev/null
+%module(package="py2.pkg2") bar
+%{
+#include "../../py2/pkg2/bar.hpp"
+%}
+%import "../../py2/pkg2/pkg3/pkg4/foo.i"
+%include "../../py2/pkg2/bar.hpp"
--- /dev/null
+TOP = ../../../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg4 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg4 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg4 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PY2_PKG2_PKG3_PKG4
+#define PY2_PKG2_PKG3_PKG4
+struct Pkg4_Foo {};
+#endif /* PY2_PKG2_PKG3_PKG4 */
--- /dev/null
+%module(package="py2.pkg2.pkg3.pkg4") foo
+%{
+#include "../../../../py2/pkg2/pkg3/pkg4/foo.hpp"
+%}
+%include "../../../../py2/pkg2/pkg3/pkg4/foo.hpp"
--- /dev/null
+TOP = ../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='bar' python_clean
+ cd pkg3 && $(MAKE) clean
--- /dev/null
+from .bar import Pkg2_Bar
--- /dev/null
+#ifndef PY3_PKG2_HPP
+#define PY3_PKG2_HPP
+#include "../../py3/pkg2/pkg3/pkg4/foo.hpp"
+struct Pkg2_Bar : Pkg4_Foo {};
+#endif /* PY3_PKG2_HPP */
--- /dev/null
+%module(package="py3.pkg2") bar
+%{
+#include "../../py3/pkg2/bar.hpp"
+%}
+%import "../../py3/pkg2/pkg3/pkg4/foo.i"
+%include "../../py3/pkg2/bar.hpp"
--- /dev/null
+TOP = ../../../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg4 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg4 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg4 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PY3_PKG2_PKG3_PKG4
+#define PY3_PKG2_PKG3_PKG4
+struct Pkg4_Foo {};
+#endif /* PY3_PKG2_PKG3_PKG4 */
--- /dev/null
+%module(package="py3.pkg2.pkg3.pkg4") foo
+%{
+#include "../../../../py3/pkg2/pkg3/pkg4/foo.hpp"
+%}
+%include "../../../../py3/pkg2/pkg3/pkg4/foo.hpp"
--- /dev/null
+import sys
+import os.path
+
+# Test import of modules content from within __init__.py
+testname = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+print "Testing " + testname + " - %module(package=...) + python 'import' in __init__.py"
+
+if sys.version_info < (3, 0):
+ import py2.pkg2
+ print " Finished importing py2.pkg2"
+else:
+ import py3.pkg2
+ print " Finished importing py3.pkg2"
--- /dev/null
+TOP = ../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+TARGET = robin
+INTERFACE = robin.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
+ rm -rf path1 path2 path3 path4.zip
--- /dev/null
+ This is an example (and test) of using swig generated modules in the context
+of python3's namespace packages:
+
+https://www.python.org/dev/peps/pep-0420/
+
+ Consequently, this example requires python (3.3 or newer) to build and run.
+
+ This example creates a simple swig module named robin. The robin.py module
+has a companion C module named _robin.so. The robin module is tested in four
+ways:
+
+ 1) As a non-package module (tested by nonpkg.py)
+
+ 2) With robin.py and _robin.so in the brave package under the path1
+ subdirectory. (tested by normal.py)
+
+ 3) With robin.py in path2/brave and _robin.so in path3/brave
+ (tested by split.py)
+
+ 4) With robin.py contained in a zip file (path4.zip) as brave/robin.py and
+ _robin.so found on the filesystem under path3/brave (tested by zipsplit.py)
+
+Note: Using namespace packages with subpackages (such as brave.sir.robin) where
+ robin.py is located in a zipfile requires python-3.5.1 or newer as
+ python's zipimporter only worked with packages of depth 1 until then.
\ No newline at end of file
--- /dev/null
+# import robin as a module in the global namespace
+
+import robin
+
+assert(robin.run() == "AWAY!")
--- /dev/null
+import sys
+# Package brave found under one path
+sys.path.insert(0, 'path1')
+
+from brave import robin
+
+assert(robin.run() == "AWAY!")
--- /dev/null
+import sys
+import os
+import shutil
+import zipfile
+
+
+def copyMods():
+ dirs = ['path1', 'path2', 'path3']
+
+ # Clean out any old package paths
+ for d in dirs:
+ if os.path.isdir(d):
+ shutil.rmtree(d)
+
+ for d in dirs:
+ os.mkdir(d)
+ os.mkdir(os.path.join(d, 'brave'))
+
+ shutil.copy('robin.py', os.path.join('path1', 'brave'))
+ os.system('cp _robin.* ' + os.path.join('path1', 'brave'))
+
+ shutil.copy('robin.py', os.path.join('path2', 'brave'))
+ os.system('cp _robin.* ' + os.path.join('path3', 'brave'))
+
+ mkzip()
+
+def mkzip():
+ zf = zipfile.ZipFile("path4.zip", "w")
+ zf.writestr("brave/", b'')
+ zf.write('robin.py', 'brave/robin.py')
+ zf.close()
+
+
+def main():
+ copyMods()
+
+ # Run each test with a separate interpreter
+ os.system(sys.executable + " nonpkg.py")
+ os.system(sys.executable + " normal.py")
+ os.system(sys.executable + " split.py")
+ os.system(sys.executable + " zipsplit.py")
+
+
+if __name__ == "__main__":
+ main()
--- /dev/null
+%module robin
+
+%inline %{
+const char *run(void) {
+ return "AWAY!";
+}
+%}
--- /dev/null
+# These examples rely on namespace packages. Don't
+# run them for old python interpreters.
+import sys
+import os.path
+
+testname = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+print "Testing " + testname + " - namespace packages"
+
+if sys.version_info < (3, 3, 0):
+ print " Not importing nstest as Python version is < 3.3"
+ sys.exit(0)
+
+import nstest
+
+print " Finished importing nstest"
+
+nstest.main()
--- /dev/null
+import sys
+# Package brave split into two paths.
+# path2/brave/robin.py and path3/brave/_robin.so
+sys.path.insert(0, 'path2')
+sys.path.insert(0, 'path3')
+
+from brave import robin
+
+assert(robin.run() == "AWAY!")
--- /dev/null
+import sys
+# Package brave split into two paths.
+# brave/robin.py (in path4.zip) and path3/brave/_robin.so
+sys.path.insert(0, 'path4.zip')
+sys.path.insert(0, 'path3')
+
+from brave import robin
+
+assert(robin.run() == "AWAY!")
--- /dev/null
+TOP = ../../..
+LIBS =
+
+ifeq (,$(PY3))
+ PKG1DIR = "py2"
+else
+ PKG1DIR = "py3"
+endif
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
+
+build:
+ cd $(PKG1DIR) && $(MAKE) SWIGOPT='$(SWIGOPT) -relativeimport' LIBS='$(LIBS)' build
+
+static:
+ cd $(PKG1DIR) && $(MAKE) SWIGOPT='$(SWIGOPT) -relativeimport' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd py2 && $(MAKE) clean
+ cd py3 && $(MAKE) clean
--- /dev/null
+This example tests the %import directive and -relativeimport swig option.
+
+Use 'python runme.py' to run a test.
+
+Overview:
+---------
+
+The example defines 2 different extension modules--each wrapping a separate C++
+class.
+
+ pyX/pkg2/pkg3/foo.i - Pkg3_Foo class
+ pyX/pkg2/bar.i - Pkg2_Bar class derived from Pkg3_Foo
+
+The code is processed by swig with -relativeimport flag. The runtime test
+imports pyX.pkg2.bar module.
+
+If everything works well, the module pyX.pkg2.bar shall load properly.
+
+Unix:
+-----
+- Run make
+- Run the test as described above
--- /dev/null
+TOP = ../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='bar' python_clean
+ cd pkg3 && $(MAKE) clean
--- /dev/null
+#ifndef PY2_PKG2_BAR_HPP
+#define PY2_PKG2_BAR_HPP
+#include "../../py2/pkg2/pkg3/foo.hpp"
+struct Pkg2_Bar : Pkg3_Foo {};
+#endif /* PY2_PKG2_BAR_HPP */
--- /dev/null
+%module(package="py2.pkg2") bar
+%{
+#include "../../py2/pkg2/bar.hpp"
+%}
+%import "../../py2/pkg2/pkg3/foo.i"
+%include "../../py2/pkg2/bar.hpp"
--- /dev/null
+TOP = ../../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PY2_PKG2_PKG3_FOO_HPP
+#define PY2_PKG2_PKG3_FOO_HPP
+struct Pkg3_Foo {};
+#endif /* PY2_PKG2_PKG3_FOO_HPP */
--- /dev/null
+%module(package="py2.pkg2.pkg3") foo
+%{
+#include "../../../py2/pkg2/pkg3/foo.hpp"
+%}
+%include "../../../py2/pkg2/pkg3/foo.hpp"
--- /dev/null
+TOP = ../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='bar' python_clean
+ cd pkg3 && $(MAKE) clean
--- /dev/null
+#ifndef PY3_PKG2_BAR_HPP
+#define PY3_PKG2_BAR_HPP
+#include "../../py3/pkg2/pkg3/foo.hpp"
+struct Pkg2_Bar : Pkg3_Foo {};
+#endif /* PY3_PKG2_BAR_HPP */
--- /dev/null
+%module(package="py3.pkg2") bar
+%{
+#include "../../py3/pkg2/bar.hpp"
+%}
+%import "../../py3/pkg2/pkg3/foo.i"
+%include "../../py3/pkg2/bar.hpp"
--- /dev/null
+TOP = ../../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PY3_PKG2_PKG3_FOO_HPP
+#define PY3_PKG2_PKG3_FOO_HPP
+struct Pkg3_Foo {};
+#endif /* PY3_PKG2_PKG3_FOO_HPP */
--- /dev/null
+%module(package="py3.pkg2.pkg3") foo
+%{
+#include "../../../py3/pkg2/pkg3/foo.hpp"
+%}
+%include "../../../py3/pkg2/pkg3/foo.hpp"
--- /dev/null
+import sys
+import os.path
+
+# Test import of modules content from within __init__.py
+testname = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+print "Testing " + testname + " - %module(package=...) with -relativeimport"
+
+if sys.version_info < (3, 0):
+ import py2.pkg2.bar
+ print " Finished importing py2.pkg2.bar"
+else:
+ import py3.pkg2.bar
+ print " Finished importing py3.pkg2.bar"
--- /dev/null
+TOP = ../../..
+LIBS =
+
+ifeq (,$(PY3))
+ PKG1DIR = "py2"
+else
+ PKG1DIR = "py3"
+endif
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
+
+build:
+ cd $(PKG1DIR) && $(MAKE) SWIGOPT='$(SWIGOPT) -relativeimport' LIBS='$(LIBS)' build
+
+static:
+ cd $(PKG1DIR) && $(MAKE) SWIGOPT='$(SWIGOPT) -relativeimport' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd py2 && $(MAKE) clean
+ cd py3 && $(MAKE) clean
--- /dev/null
+This example tests the %import directive and -relativeimport option.
+
+Use 'python runme.py' to run a test.
+
+Overview:
+---------
+
+The example defines 2 different extension modules--each wrapping a separate C++
+class.
+
+ pyX/pkg2/pkg3/pkg4/foo.i - Pkg4_Foo class
+ pyX/pkg2/bar.i - Pkg2_Bar class derived from Pkg4_Foo
+
+The difference between this ('relativeimport2') case and the case
+'relativeimport1' is the "distance" between importer and importee.
+
+If everything works well, the package pyX.pkg2 shall load properly.
+
+Unix:
+-----
+- Run make
+- Run the test as described above
--- /dev/null
+TOP = ../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='bar' python_clean
+ cd pkg3 && $(MAKE) clean
--- /dev/null
+#ifndef PY2_PKG2_HPP
+#define PY2_PKG2_HPP
+#include "../../py2/pkg2/pkg3/pkg4/foo.hpp"
+struct Pkg2_Bar : Pkg4_Foo {};
+#endif /* PY2_PKG2_HPP */
--- /dev/null
+%module(package="py2.pkg2") bar
+%{
+#include "../../py2/pkg2/bar.hpp"
+%}
+%import "../../py2/pkg2/pkg3/pkg4/foo.i"
+%include "../../py2/pkg2/bar.hpp"
--- /dev/null
+TOP = ../../../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg4 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg4 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg4 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PY2_PKG2_PKG3_PKG4
+#define PY2_PKG2_PKG3_PKG4
+struct Pkg4_Foo {};
+#endif /* PY2_PKG2_PKG3_PKG4 */
--- /dev/null
+%module(package="py2.pkg2.pkg3.pkg4") foo
+%{
+#include "../../../../py2/pkg2/pkg3/pkg4/foo.hpp"
+%}
+%include "../../../../py2/pkg2/pkg3/pkg4/foo.hpp"
--- /dev/null
+TOP = ../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='bar' python_clean
+ cd pkg3 && $(MAKE) clean
--- /dev/null
+#ifndef PY3_PKG2_HPP
+#define PY3_PKG2_HPP
+#include "../../py3/pkg2/pkg3/pkg4/foo.hpp"
+struct Pkg2_Bar : Pkg4_Foo {};
+#endif /* PY3_PKG2_HPP */
--- /dev/null
+%module(package="py3.pkg2") bar
+%{
+#include "../../py3/pkg2/bar.hpp"
+%}
+%import "../../py3/pkg2/pkg3/pkg4/foo.i"
+%include "../../py3/pkg2/bar.hpp"
--- /dev/null
+TOP = ../../../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg4 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg4 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg4 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PY3_PKG2_PKG3_PKG4
+#define PY3_PKG2_PKG3_PKG4
+struct Pkg4_Foo {};
+#endif /* PY3_PKG2_PKG3_PKG4 */
--- /dev/null
+%module(package="py3.pkg2.pkg3.pkg4") foo
+%{
+#include "../../../../py3/pkg2/pkg3/pkg4/foo.hpp"
+%}
+%include "../../../../py3/pkg2/pkg3/pkg4/foo.hpp"
--- /dev/null
+import sys
+import os.path
+
+# Test import of modules content from within __init__.py
+testname = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+print "Testing " + testname + " - %module(package=...) + python 'import' in __init__.py"
+
+if sys.version_info < (3, 0):
+ import py2.pkg2.bar
+ print " Finished importing py2.pkg2.bar"
+else:
+ import py3.pkg2.bar
+ print " Finished importing py3.pkg2.bar"
--- /dev/null
+TOP = ../../..
+LIBS =
+
+ifeq (,$(PY3))
+ PKG1DIR = "py2"
+else
+ PKG1DIR = "py3"
+endif
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
+
+build:
+ cd $(PKG1DIR) && $(MAKE) SWIGOPT='$(SWIGOPT) -relativeimport' LIBS='$(LIBS)' build
+
+static:
+ cd $(PKG1DIR) && $(MAKE) SWIGOPT='$(SWIGOPT) -relativeimport' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd py2 && $(MAKE) clean
+ cd py3 && $(MAKE) clean
--- /dev/null
+This example tests the %import directive and -relativeimport swig option.
+
+Use 'python runme.py' to run a test.
+
+Overview:
+---------
+
+The example defines 2 different extension modules--each wrapping a separate C++
+class.
+
+ pyX/pkg2/pkg3/foo.i - Pkg3_Foo class
+ pyX/pkg2/bar.i - Pkg2_Bar class derived from Pkg3_Foo
+
+The code is processed by swig with -relativeimport flag. The runtime test
+imports pyX.pkg2.bar module.
+
+If everything works well, the module pyX.pkg2.bar shall load properly.
+
+Unix:
+-----
+- Run make
+- Run the test as described above
--- /dev/null
+TOP = ../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='bar' python_clean
+ cd pkg3 && $(MAKE) clean
--- /dev/null
+#ifndef PY2_PKG2_BAR_HPP
+#define PY2_PKG2_BAR_HPP
+#include "../../py2/pkg2/pkg3/foo.hpp"
+struct Pkg2_Bar : Pkg3_Foo {};
+#endif /* PY2_PKG2_BAR_HPP */
--- /dev/null
+%module(package="py2.pkg2") bar
+%{
+#include "../../py2/pkg2/bar.hpp"
+%}
+%import (module="foo", package="py2.pkg2.pkg3") "../../py2/pkg2/pkg3/foo.hpp"
+%include "../../py2/pkg2/bar.hpp"
--- /dev/null
+TOP = ../../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PY2_PKG2_PKG3_FOO_HPP
+#define PY2_PKG2_PKG3_FOO_HPP
+struct Pkg3_Foo {};
+#endif /* PY2_PKG2_PKG3_FOO_HPP */
--- /dev/null
+%module(package="py2.pkg2.pkg3") foo
+%{
+#include "../../../py2/pkg2/pkg3/foo.hpp"
+%}
+%include "../../../py2/pkg2/pkg3/foo.hpp"
--- /dev/null
+TOP = ../../../..
+SWIGOPT =
+LIBS =
+
+build:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ cd pkg3 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='bar' python_clean
+ cd pkg3 && $(MAKE) clean
--- /dev/null
+#ifndef PY3_PKG2_BAR_HPP
+#define PY3_PKG2_BAR_HPP
+#include "../../py3/pkg2/pkg3/foo.hpp"
+struct Pkg2_Bar : Pkg3_Foo {};
+#endif /* PY3_PKG2_BAR_HPP */
--- /dev/null
+%module(package="py3.pkg2") bar
+%{
+#include "../../py3/pkg2/bar.hpp"
+%}
+%import (module="foo", package="py3.pkg2.pkg3") "../../py3/pkg2/pkg3/foo.hpp"
+%include "../../py3/pkg2/bar.hpp"
--- /dev/null
+TOP = ../../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PY3_PKG2_PKG3_FOO_HPP
+#define PY3_PKG2_PKG3_FOO_HPP
+struct Pkg3_Foo {};
+#endif /* PY3_PKG2_PKG3_FOO_HPP */
--- /dev/null
+%module(package="py3.pkg2.pkg3") foo
+%{
+#include "../../../py3/pkg2/pkg3/foo.hpp"
+%}
+%include "../../../py3/pkg2/pkg3/foo.hpp"
--- /dev/null
+import sys
+import os.path
+
+# Test import of modules content from within __init__.py
+testname = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+print "Testing " + testname + " - %module(package=...) with -relativeimport"
+
+if sys.version_info < (3, 0):
+ import py2.pkg2.bar
+ print " Finished importing py2.pkg2.bar"
+else:
+ import py3.pkg2.bar
+ print " Finished importing py3.pkg2.bar"
--- /dev/null
+TOP = ../../..
+LIBS =
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
+
+build:
+ cd pkg1 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg1 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+ cd pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg1 && $(MAKE) clean
+ cd pkg2 && $(MAKE) clean
--- /dev/null
+This example tests the %import directive and working with multiple modules.
+
+There are two modules having same name but belonging to different packages.
+This case is not correctly handled by swig 2.
+
+The issue was reported as Source Forge bug #1297 and later as GitHub issue #7.
+
+Use 'python runme.py' to run a test.
+
+Overview:
+---------
+
+The example defines 2 different extension modules--each wrapping a separate C++
+class.
+
+ pkg1/foo.i - Pkg1_Foo class.
+ pkg2/foo.i - Pkg2_Foo class (derived from Pkg1_Foo).
+
+The pkg2/foo.i module uses %import to refer to pkg1/foo.i.
+
+If everything works well, the module pkg2.foo shall load properly.
+
+Unix:
+-----
+- Run make
+- Run the test as described above.
--- /dev/null
+TOP = ../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PKG1_FOO_HPP
+#define PKG1_FOO_HPP
+struct Pkg1_Foo{};
+#endif /* PKG1_FOO_HPP */
--- /dev/null
+%module(package="pkg1") foo
+%{
+#include "../pkg1/foo.hpp"
+%}
+%include "../pkg1/foo.hpp"
--- /dev/null
+TOP = ../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PKG2_FOO_HPP
+#define PKG2_FOO_HPP
+#include "../pkg1/foo.hpp"
+struct Pkg2_Foo : public Pkg1_Foo{};
+#endif /* PKG2_FOO_HPP */
--- /dev/null
+%module(package="pkg2") foo
+%{
+#include "../pkg2/foo.hpp"
+%}
+%import "../pkg1/foo.i"
+%include "../pkg2/foo.hpp"
--- /dev/null
+import os.path
+
+# Test import of same modules from different packages
+testname = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+print "Testing " + testname + " - %module(package=...) + python 'import' in __init__.py"
+
+import pkg2.foo
+print " Finished importing pkg2.foo"
+
+var2 = pkg2.foo.Pkg2_Foo()
+
+classname = str(type(var2))
+# Check for an old-style class if swig was run in -classic mode
+if classname == "<type 'instance'>":
+ classname = str(var2.__class__)
+
+if classname.find("pkg2.foo.Pkg2_Foo") == -1:
+ raise RuntimeError("failed type checking: " + classname)
+print " Successfully created object pkg2.foo.Pkg2_Foo"
--- /dev/null
+TOP = ../../..
+LIBS =
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
+
+build:
+ cd pkg1 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+ cd pkg1/pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build
+
+static:
+ cd pkg1 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+ cd pkg1/pkg2 && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ cd pkg1 && $(MAKE) clean
+ cd pkg1/pkg2 && $(MAKE) clean
--- /dev/null
+This example tests the %import directive and working with multiple modules.
+
+There are two modules having same name but belonging to different packages.
+This case is not correctly handled by swig 2.
+
+The issue was reported as Source Forge bug #1297 and later as GitHub issue #7.
+
+Use 'python runme.py' to run a test.
+
+Overview:
+---------
+
+The example defines 2 different extension modules--each wrapping a separate C++
+class.
+
+ pkg1/foo.i - Pkg1_Foo class
+ pkg1/pkg2/foo.i - Pkg2_Foo class derived from Pkg1_Foo
+
+The pkg1/pkg2/foo module uses %import to refer to pkg1/foo.
+
+If everything works well, the module pkg1.pkg2.foo shall load properly.
+
+Unix:
+-----
+- Run make
+- Run the test as described above
--- /dev/null
+TOP = ../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PKG1_FOO_HPP
+#define PKG1_FOO_HPP
+struct Pkg1_Foo{};
+#endif /* PKG1_FOO_HPP */
--- /dev/null
+%module(package="pkg1") foo
+%{
+#include "../pkg1/foo.hpp"
+%}
+%include "../pkg1/foo.hpp"
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+#ifndef PKG1_PKG2_FOO_HPP
+#define PKG1_PKG2_FOO_HPP
+#include "../../pkg1/foo.hpp"
+struct Pkg2_Foo : public Pkg1_Foo{};
+#endif /* PKG1_PKG2_FOO_HPP */
--- /dev/null
+%module(package="pkg1.pkg2") foo
+%{
+#include "../../pkg1/pkg2/foo.hpp"
+%}
+%import "../../pkg1/foo.i"
+%include "../../pkg1/pkg2/foo.hpp"
--- /dev/null
+import os.path
+
+testname = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+print "Testing " + testname + " - %module(package=...) + python 'import' in __init__.py"
+
+import pkg1.pkg2.foo
+print " Finished importing pkg1.pkg2.foo"
+
+var2 = pkg1.pkg2.foo.Pkg2_Foo()
+
+classname = str(type(var2))
+# Check for an old-style class if swig was run in -classic mode
+if classname == "<type 'instance'>":
+ classname = str(var2.__class__)
+
+if classname.find("pkg1.pkg2.foo.Pkg2_Foo") == -1:
+ raise RuntimeError("failed type checking: " + classname)
+print " Successfully created object pkg1.pkg2.foo.Pkg2_Foo"
--- /dev/null
+TOP = ../../..
+LIBS =
+
+subdirs = vanilla vanilla_split
+
+
+check: build
+ for s in $(subdirs); do \
+ (cd $$s && $(MAKE) check); \
+ done
+
+build:
+ for s in $(subdirs); do \
+ (cd $$s && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' build); \
+ done
+
+static:
+ for s in $(subdirs); do \
+ (cd $$s && $(MAKE) SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' static); \
+ done
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ for s in $(subdirs); do \
+ (cd $$s && $(MAKE) clean); \
+ done
--- /dev/null
+ These examples/tests are for when the SWIG generated wrapper module is split
+between two packages. Specifically the pure python part is part of a package
+and the C/C++ part is not in any package at all. Historically SWIG has
+supported this sort of thing.
+
+vanilla # "plane Jane" module both halves in pkg1
+vanilla_split # python 1/2 in pkg1 C 1/2 in global namespace
--- /dev/null
+TOP = ../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
+
+build:
+ cd pkg1 && $(MAKE) build
+
+static:
+ cd pkg1 && $(MAKE) static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
+ cd pkg1 && $(MAKE) -f $(TOP)/../Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+TOP = ../../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT =
+LIBS =
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+# killroy was here
--- /dev/null
+%module(package="pkg1") foo
+%{
+static unsigned count(void)
+{
+ return 3;
+}
+%}
+
+unsigned count(void);
+
--- /dev/null
+import os.path
+
+testname = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+print "Testing " + testname + " - split modules"
+
+import pkg1.foo
+
+print " Finished importing pkg1.foo"
+
+assert(pkg1.foo.count() == 3)
--- /dev/null
+TOP = ../../../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SWIGOPT = -outdir pkg1
+LIBS =
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+
+static:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp_static
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
+ cd pkg1 && $(MAKE) -f $(TOP)/../Makefile SRCDIR='$(SRCDIR)' TARGET='foo' python_clean
--- /dev/null
+%module(package="pkg1") foo
+%{
+static unsigned count(void)
+{
+ return 3;
+}
+%}
+
+unsigned count(void);
+
--- /dev/null
+# killroy was here
--- /dev/null
+import os.path
+
+testname = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+print "Testing " + testname + " - split modules"
+
+import pkg1.foo
+
+print " Finished importing pkg1.foo"
+
+assert(pkg1.foo.count() == 3)
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SWIGOPT =
LIBS =
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='base' INTERFACE='base.i' python_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='base' INTERFACE='base.i' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' python_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
rm -f foo.py bar.py spam.py base.py
template<class T> class Base {
public:
- Base() { };
- virtual ~Base() { };
+ Base() { }
+ virtual ~Base() { }
virtual void A() {
printf("I'm Base::A\n");
}
print " Spam -> Base -> Foo : ",
y = foo.intFoo_fromBase(x)
if y:
- print "bad swig"
+ print "bad swig"
else:
- print "good swig"
+ print "good swig"
print " Spam -> Base -> Bar : ",
y = bar.intBar_fromBase(x)
if y:
- print "good swig"
+ print "good swig"
else:
- print "bad swig"
-
+ print "bad swig"
+
print " Spam -> Base -> Spam : ",
y = spam.intSpam_fromBase(x)
if y:
- print "good swig"
+ print "good swig"
else:
- print "bad swig"
+ print "bad swig"
print " Foo -> Spam : ",
y = spam.intSpam_fromBase(b)
if y:
- print "bad swig"
+ print "bad swig"
else:
- print "good swig"
-
-
-
-
+ print "good swig"
</blockquote>
<li>The politically "correct" way to compile a Python extension is to follow the steps
-described at <a href="http://www.python.org/doc/current/ext/building-on-unix.html">www.python.org</a>
-or in the most excellent (and shamelessly plugged) <a href="http://islab.cs.uchicago.edu/python">Python Essential Reference</a>:
+described at <a href="http://docs.python.org/2.0/ext/building-on-unix.html">www.python.org</a>:
<p>
<ol>
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
-build: Example.class
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' CXX="gcj" \
+build: Example.class Example.h
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
CXXSHARED="gcj -fpic -shared Example.class" DEFS='' LIBS="-lstdc++" python_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_clean
rm -f $(TARGET).py
rm -f *.class Example.h
-Example.class: Example.java
- gcj -fPIC -C -c -g Example.java
- gcjh Example
-
+Example.class Example.h: $(SRCDIR)Example.java
+ gcj -d . -fPIC -C -c -g $(SRCDIR)Example.java
+ gcjh Example.class
%include Example.h
+
+%extend Example {
+ ~Example() {}
+}
e1 = Example(1)
e2 = Example(2)
-print e1.Add(1,2)
-print e1.Add(1.0,2.0)
-e3 = e1.Add(e1,e2)
+print e1.Add(1, 2)
+print e1.Add(1.0, 2.0)
+e3 = e1.Add(e1, e2)
print e3.mPublicInt
-print e1.Add("1","2")
+print e1.Add("1", "2")
JvDetachCurrentThread()
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' LIBS='-L/usr/local/lib -lffi' python
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
if (!PyList_Check($input)) {
SWIG_exception(SWIG_ValueError, "Expecting a list");
}
- $1 = PyList_Size($input);
+ $1 = (int)PyList_Size($input);
if ($1 == 0) {
SWIG_exception(SWIG_ValueError, "List must contain at least 1 element");
}
}
utf8str = PyUnicode_AsUTF8String($input);
PyBytes_AsStringAndSize(utf8str, &cstr, &len);
- $1 = strndup(cstr, (size_t)len);
+ $1 = strncpy((char *)malloc(len+1), cstr, (size_t)len);
$2 = (int)len;
Py_DECREF(utf8str);
%#else
return NULL;
}
$1 = PyString_AsString($input);
- $2 = PyString_Size($input);
+ $2 = (int)PyString_Size($input);
%#endif
}
/* This example shows how to wrap a function that mutates a string */
/* Since str is modified, we make a copy of the Python object
- so that we don't violate it's mutability */
+ so that we don't violate its mutability */
%typemap(in) (char *str, int len) {
%#if PY_VERSION_HEX >= 0x03000000
Py_ssize_t len;
PyObject *utf8str = PyUnicode_AsUTF8String($input);
PyBytes_AsStringAndSize(utf8str, &cstr, &len);
- $1 = strndup(cstr, (size_t)len);
+ $1 = strncpy((char *)malloc(len+1), cstr, (size_t)len);
$2 = (int)len;
Py_DECREF(utf8str);
%#else
- $2 = PyString_Size($input);
+ $2 = (int)PyString_Size($input);
$1 = (char *) malloc($2+1);
memmove($1,PyString_AsString($input),$2);
%#endif
# file: runme.py
-import example
+import example
# Call our gcd() function
x = 42
y = 105
-g = example.gcd(x,y)
-print "The gcd of %d and %d is %d" % (x,y,g)
+g = example.gcd(x, y)
+print "The gcd of %d and %d is %d" % (x, y, g)
# Call the gcdmain() function
-example.gcdmain(["gcdmain","42","105"])
+example.gcdmain(["gcdmain", "42", "105"])
# Call the count function
print example.count("Hello World", "l")
# Call the capitalize function
print example.capitalize("hello world")
-
-
-
-
-
-
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
# Operator overloading example
import example
-a = example.Complex(2,3)
-b = example.Complex(-5,10)
+a = example.Complex(2, 3)
+b = example.Complex(-5, 10)
-print "a =",a
-print "b =",b
+print "a =", a
+print "b =", b
c = a + b
-print "c =",c
-print "a*b =",a*b
-print "a-c =",a-c
+print "c =", c
+print "a*b =", a * b
+print "a-c =", a - c
-e = example.ComplexCopy(a-c)
-print "e =",e
+e = example.ComplexCopy(a - c)
+print "e =", e
# Big expression
-f = ((a+b)*(c+b*e)) + (-a)
-print "f =",f
-
+f = ((a + b) * (c + b * e)) + (-a)
+print "f =", f
TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS =
TARGET = Simple
INTERFACE = Simple.i
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -module Simple_baseline' \
- TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -O -module Simple_optimized' \
- TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -builtin -O -module Simple_builtin' \
- TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-module Simple_baseline' TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-O -module Simple_optimized' TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-builtin -O -module Simple_builtin' TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
rm -f $(TARGET)_*.py
-#!/usr/bin/env
-
import sys
sys.path.append('..')
import harness
-def proc (mod) :
- for i in range(1000000) :
+
+def proc(mod):
+ for i in range(1000000):
x = mod.MyClass()
harness.run(proc)
TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS =
TARGET = Simple
INTERFACE = Simple.i
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -module Simple_baseline' \
- TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -O -module Simple_optimized' \
- TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -builtin -O -module Simple_builtin' \
- TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-module Simple_baseline' TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-O -module Simple_optimized' TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-builtin -O -module Simple_builtin' TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
rm -f $(TARGET)_*.py
-#!/usr/bin/env
-
import sys
sys.path.append('..')
import harness
-def proc (mod) :
+
+def proc(mod):
x = mod.MyClass()
- for i in range(10000000) :
+ for i in range(10000000):
x.func()
harness.run(proc)
-#!/usr/bin/env
-
import sys
import time
import imp
from subprocess import *
-def run (proc) :
- try :
+def run(proc):
+
+ try:
mod = imp.find_module(sys.argv[1])
mod = imp.load_module(sys.argv[1], *mod)
t2 = time.clock()
print "%s took %f seconds" % (mod.__name__, t2 - t1)
- except IndexError :
- proc = Popen([sys.executable, 'runme.py', 'Simple_baseline'], stdout=PIPE)
+ except IndexError:
+ proc = Popen(
+ [sys.executable, 'runme.py', 'Simple_baseline'], stdout=PIPE)
(stdout, stderr) = proc.communicate()
print stdout
- proc = Popen([sys.executable, 'runme.py', 'Simple_optimized'], stdout=PIPE)
+ proc = Popen(
+ [sys.executable, 'runme.py', 'Simple_optimized'], stdout=PIPE)
(stdout, stderr) = proc.communicate()
print stdout
- proc = Popen([sys.executable, 'runme.py', 'Simple_builtin'], stdout=PIPE)
+ proc = Popen(
+ [sys.executable, 'runme.py', 'Simple_builtin'], stdout=PIPE)
(stdout, stderr) = proc.communicate()
print stdout
TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS =
TARGET = Simple
INTERFACE = Simple.i
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -module Simple_baseline' \
- TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -O -module Simple_optimized' \
- TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -builtin -O -module Simple_builtin' \
- TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-module Simple_baseline' TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-O -module Simple_optimized' TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-builtin -O -module Simple_builtin' TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
rm -f $(TARGET)_*.py
-#!/usr/bin/env
-
import sys
sys.path.append('..')
import harness
-def proc (mod) :
+
+def proc(mod):
x = mod.H()
- for i in range(10000000) :
+ for i in range(10000000):
x.func()
harness.run(proc)
TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS =
TARGET = Simple
INTERFACE = Simple.i
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -module Simple_baseline' \
- TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -O -module Simple_optimized' \
- TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -builtin -O -module Simple_builtin' \
- TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-module Simple_baseline' TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-O -module Simple_optimized' TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-builtin -O -module Simple_builtin' TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
rm -f $(TARGET)_*.py
-#!/usr/bin/env
-
import sys
sys.path.append('..')
import harness
-def proc (mod) :
+
+def proc(mod):
x = mod.H()
- for i in range(10000000) :
+ for i in range(10000000):
x += i
harness.run(proc)
TOP = ../../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS =
TARGET = Simple
INTERFACE = Simple.i
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -module Simple_baseline' \
- TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -O -module Simple_optimized' \
- TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -builtin -O -module Simple_builtin' \
- TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-module Simple_baseline' TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-O -module Simple_optimized' TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-builtin -O -module Simple_builtin' TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
rm -f $(TARGET)_*.py
-#!/usr/bin/env
-
import sys
sys.path.append('..')
import harness
-def proc (mod) :
+
+def proc(mod):
x = mod.MyClass()
- for i in range(10000000) :
+ for i in range(10000000):
x = x + i
harness.run(proc)
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
# file: runme.py
-import example;
+import example
# First create some objects using the pointer library.
-print "Testing the pointer library";
-a = example.new_intp();
-b = example.new_intp();
-c = example.new_intp();
-example.intp_assign(a,37);
-example.intp_assign(b,42);
+print "Testing the pointer library"
+a = example.new_intp()
+b = example.new_intp()
+c = example.new_intp()
+example.intp_assign(a, 37)
+example.intp_assign(b, 42)
-print " a =",a
-print " b =",b
-print " c =",c
+print " a =", a
+print " b =", b
+print " c =", c
# Call the add() function with some pointers
-example.add(a,b,c)
+example.add(a, b, c)
# Now get the result
r = example.intp_value(c)
-print " 37 + 42 =",r
+print " 37 + 42 =", r
# Clean up the pointers
example.delete_intp(a)
# This should be much easier. Now how it is no longer
# necessary to manufacture pointers.
-print "Trying the typemap library";
-r = example.sub(37,42)
-print " 37 - 42 =",r
+print "Trying the typemap library"
+r = example.sub(37, 42)
+print " 37 - 42 =", r
# Now try the version with multiple return values
-print "Testing multiple return values";
-q,r = example.divide(42,37)
-print " 42/37 = %d remainder %d" % (q,r)
-
-
-
+print "Testing multiple return values"
+q, r = example.divide(42, 37)
+print " 42/37 = %d remainder %d" % (q, r)
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
char *Vector::print() {
static char temp[512];
- sprintf(temp,"Vector %p (%g,%g,%g)", this, x,y,z);
+ sprintf(temp,"Vector %p (%g,%g,%g)", (void *)this, x,y,z);
return temp;
}
private:
double x,y,z;
public:
- Vector() : x(0), y(0), z(0) { };
- Vector(double x, double y, double z) : x(x), y(y), z(z) { };
+ Vector() : x(0), y(0), z(0) { }
+ Vector(double x, double y, double z) : x(x), y(y), z(z) { }
friend Vector operator+(const Vector &a, const Vector &b);
char *print();
};
Vector &operator[](int);
int size();
};
-
-
-
-
VectorArray(int maxsize);
~VectorArray();
int size();
-
+
/* This wrapper provides an alternative to the [] operator */
%extend {
Vector &get(int index) {
}
}
};
-
-
-
-
# ----- Object creation -----
print "Creating some objects:"
-a = example.Vector(3,4,5)
-b = example.Vector(10,11,12)
+a = example.Vector(3, 4, 5)
+b = example.Vector(10, 11, 12)
-print " Created",a.cprint()
-print " Created",b.cprint()
+print " Created", a.cprint()
+print " Created", b.cprint()
# ----- Call an overloaded operator -----
# This calls the wrapper we placed around
#
-# operator+(const Vector &a, const Vector &)
+# operator+(const Vector &a, const Vector &)
#
# It returns a new allocated object.
print "Adding a+b"
-c = example.addv(a,b)
+c = example.addv(a, b)
print " a+b =", c.cprint()
# Note: Unless we free the result, a memory leak will occur
# Note: Using the high-level interface here
print "Creating an array of vectors"
va = example.VectorArray(10)
-print " va = ",va
+print " va = ", va
# ----- Set some values in the array -----
# These operators copy the value of $a and $b to the vector array
-va.set(0,a)
-va.set(1,b)
+va.set(0, a)
+va.set(1, b)
-va.set(2,example.addv(a,b))
+va.set(2, example.addv(a, b))
# Get some values from the array
print "Getting some array values"
-for i in range(0,5):
+for i in range(0, 5):
print " va(%d) = %s" % (i, va.get(i).cprint())
# Watch under resource meter to check on this
print "Making sure we don't leak memory."
-for i in xrange(0,1000000):
+for i in xrange(0, 1000000):
c = va.get(i % 10)
# ----- Clean up -----
del va
del a
del b
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
# file: runme.py
-import example
+import example
# Call our gcd() function
x = 42
y = 105
-g = example.gcd(x,y)
-print "The gcd of %d and %d is %d" % (x,y,g)
+g = example.gcd(x, y)
+print "The gcd of %d and %d is %d" % (x, y, g)
# Manipulate the Foo global variable
# See if the change took effect
print "Foo = ", example.cvar.Foo
-
-
-
-
-
-
-
-
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
}
virtual ~Shape() {
nshapes--;
- };
+ }
double x, y;
void move(double dx, double dy);
virtual double area() = 0;
private:
double radius;
public:
- Circle(double r) : radius(r) { };
+ Circle(double r) : radius(r) { }
virtual double area();
virtual double perimeter();
};
# This file illustrates the proxy class C++ interface generated
# by SWIG.
-import example
+import example
# ----- Object creation -----
# ----- Access a static member -----
-print "\nA total of", example.cvar.Shape_nshapes,"shapes were created"
+print "\nA total of", example.cvar.Shape_nshapes, "shapes were created"
# ----- Member data access -----
s.y = 5
print "\nHere is their current position:"
-print " Circle = (%f, %f)" % (c.x,c.y)
-print " Square = (%f, %f)" % (s.x,s.y)
+print " Circle = (%f, %f)" % (c.x, c.y)
+print " Square = (%f, %f)" % (s.x, s.y)
# ----- Call some methods -----
print "\nHere are some properties of the shapes:"
-for o in [c,s]:
- print " ", o
- print " area = ", o.area()
- print " perimeter = ", o.perimeter()
+for o in [c, s]:
+ print " ", o
+ print " area = ", o.area()
+ print " perimeter = ", o.perimeter()
print "\nGuess I'll clean up now"
del ss
s = 3
-print example.cvar.Shape_nshapes,"shapes remain"
+print example.cvar.Shape_nshapes, "shapes remain"
print "Goodbye"
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
pmap["hello"] = 2
-
-
dmap = {}
dmap["hello"] = 1.0
dmap["hi"] = 2.0
for i in dmap.itervalues():
print "val", i
-for k,v in dmap.iteritems():
- print "item", k,v
+for k, v in dmap.iteritems():
+ print "item", k, v
dmap = example.DoubleMap()
dmap["hello"] = 1.0
for i in dmap.itervalues():
print "val", i
-for k,v in dmap.iteritems():
- print "item", k,v
+for k, v in dmap.iteritems():
+ print "item", k, v
print dmap.items()
print hmap.values()
-
dmap = {}
dmap["hello"] = 2
dmap["hi"] = 4
for i in dmap.iteritems():
print "item", i
-for k,v in dmap.iteritems():
- print "item", k,v
+for k, v in dmap.iteritems():
+ print "item", k, v
print dmap
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
# Call average with a Python list...
-print example.average([1,2,3,4])
+print example.average([1, 2, 3, 4])
# ... or a wrapped std::vector<int>
v = example.IntVector(4)
for i in range(len(v)):
- v[i] = i+1
+ v[i] = i + 1
print example.average(v)
# ... or a wrapped std::vector<double>
v = example.DoubleVector()
-for i in [1,2,3,4]:
- v.append(i)
+for i in [1, 2, 3, 4]:
+ v.append(i)
print example.half(v)
example.halve_in_place(v)
for i in range(len(v)):
- print v[i], "; ",
+ print v[i], "; ",
print
-
+++ /dev/null
-TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS = example.cxx
-TARGET = example
-INTERFACE = example.i
-LIBS = -lm
-SWIGOPT =
-
-check: build
- $(MAKE) -f $(TOP)/Makefile python_run
-
-build:
- $(SWIG) -python -external-runtime
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
-
-static:
- $(MAKE) -f $(TOP)/Makefile $(SWIGLIB) CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- SWIGOPT='$(SWIGOPT)' TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
-
-clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
- rm -f swigpyrun.h
+++ /dev/null
-/* File : example.cxx */
-
-#include <Python.h>
-#include "swigpyrun.h"
-#include "example.h"
-
-
-Manager* convert_to_Manager(PyObject *py_obj)
-{
- Manager* c_ptr;
- swig_type_info *ty = SWIG_TypeQuery("Manager *");
- printf("manager ty %p \n", ty);
- if (SWIG_ConvertPtr(py_obj, (void **) &c_ptr, ty, 0) == -1) {
- c_ptr = 0;
- } else {
- Py_XINCREF(py_obj);
- }
- return c_ptr;
-}
-
+++ /dev/null
-# file: runme.py
-
-# This file illustrates the cross language polymorphism using directors.
-
-import example
-
-
-# CEO class, which overrides Employee::getPosition().
-
-class CEO(example.Manager):
- def __init__(self, name):
- example.Manager.__init__(self, name)
- def getPosition(self):
- return "CEO"
- def __del__(self):
- print "CEO.__del__(),", self.getName()
- # for proxy class extensions that are not "disowned" and
- # define a __del__ method, it is very important to call the
- # base class __del__. otherwise the c++ objects will never
- # be deleted.
- example.Manager.__del__(self)
-
-
-
-
-e = CEO("Alice")
-m = example.convert_to_Manager(e)
-print m
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
import example
# Call some templated functions
-print example.maxint(3,7)
-print example.maxdouble(3.14,2.18)
+print example.maxint(3, 7)
+print example.maxdouble(3.14, 2.18)
# Create some class
iv = example.vecint(100)
dv = example.vecdouble(1000)
-for i in range(0,100):
- iv.setitem(i,2*i)
+for i in range(0, 100):
+ iv.setitem(i, 2 * i)
-for i in range(0,1000):
- dv.setitem(i, 1.0/(i+1))
+for i in range(0, 1000):
+ dv.setitem(i, 1.0 / (i + 1))
sum = 0
-for i in range(0,100):
- sum = sum + iv.getitem(i)
+for i in range(0, 100):
+ sum = sum + iv.getitem(i)
print sum
sum = 0.0
-for i in range(0,1000):
- sum = sum + dv.getitem(i)
+for i in range(0, 1000):
+ sum = sum + dv.getitem(i)
print sum
del iv
del dv
-
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
# file: runme.py
import sys
-import example
+import example
# Call printf
example.printf("Hello World. I'm printf\n")
# Note: We call printf, but use *python* string formatting
-for i in range(0,10):
+for i in range(0, 10):
example.printf("i is %d\n" % i)
# This will probably be garbled because %d is interpreted by C
stdout = example.stdout_stream()
# Call fprintf
-example.fprintf(stdout,"Hello World. I'm fprintf\n")
-for i in range(0,10):
- example.fprintf(stdout,"i is %d\n" % i)
+example.fprintf(stdout, "Hello World. I'm fprintf\n")
+for i in range(0, 10):
+ example.fprintf(stdout, "i is %d\n" % i)
# This won't be garbled since %d is not interpreted
-example.fprintf(stdout,"The value is %d\n")
+example.fprintf(stdout, "The value is %d\n")
# This function calls our NULL-terminated function
-example.printv("Hello","World","this","is","a","test.")
-
-
-
-
-
-
-
-
+example.printv("Hello", "World", "this", "is", "a", "test.")
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile python_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' python_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' python
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mypython' INTERFACE='$(INTERFACE)' python_static
clean:
- $(MAKE) -f $(TOP)/Makefile TARGET='$(TARGET)' python_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' TARGET='$(TARGET)' python_clean
printf("dvar = %g\n", dvar);
printf("cvar = %c\n", cvar);
printf("strvar = %s\n", strvar ? strvar : "(null)");
- printf("cstrvar = %s\n", cstrvar ? cstrvar : "(null)");
- printf("iptrvar = %p\n", iptrvar);
+ printf("cstrvar = %s\n", cstrvar);
+ printf("iptrvar = %p\n", (void *)iptrvar);
printf("name = %s\n", name);
- printf("ptptr = %p (%d, %d)\n", ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
+ printf("ptptr = %p (%d, %d)\n", (void *)ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
printf("pt = (%d, %d)\n", pt.x, pt.y);
printf("status = %d\n", status);
}
# Try to set the values of some global variables
-example.cvar.ivar = 42
-example.cvar.svar = -31000
-example.cvar.lvar = 65537
-example.cvar.uivar = 123456
-example.cvar.usvar = 61000
-example.cvar.ulvar = 654321
-example.cvar.scvar = -13
-example.cvar.ucvar = 251
-example.cvar.cvar = "S"
-example.cvar.fvar = 3.14159
-example.cvar.dvar = 2.1828
-example.cvar.strvar = "Hello World"
-example.cvar.iptrvar= example.new_int(37)
-example.cvar.ptptr = example.new_Point(37,42)
-example.cvar.name = "Bill"
+example.cvar.ivar = 42
+example.cvar.svar = -31000
+example.cvar.lvar = 65537
+example.cvar.uivar = 123456
+example.cvar.usvar = 61000
+example.cvar.ulvar = 654321
+example.cvar.scvar = -13
+example.cvar.ucvar = 251
+example.cvar.cvar = "S"
+example.cvar.fvar = 3.14159
+example.cvar.dvar = 2.1828
+example.cvar.strvar = "Hello World"
+example.cvar.iptrvar = example.new_int(37)
+example.cvar.ptptr = example.new_Point(37, 42)
+example.cvar.name = "Bill"
# Now print out the values of the variables
example.print_vars()
-print "\nNow I'm going to try and modify some read only variables";
+print "\nNow I'm going to try and modify some read only variables"
-print " Tring to set 'path'";
+print " Tring to set 'path'"
try:
example.cvar.path = "Whoa!"
print "Hey, what's going on?!?! This shouldn't work"
except:
print "Good."
-print " Trying to set 'status'";
+print " Trying to set 'status'"
try:
example.cvar.status = 0
print "Hey, what's going on?!?! This shouldn't work"
print "The new value is"
example.pt_print()
print "You should see the value", example.Point_print(example.cvar.ptptr)
-
-
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile r_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' r_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' r_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' r_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' r_clean
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
-
-
-
-
-
/* File : example.i */
%module example
-%inline %{
+%{
#include "example.h"
%}
-%include "example.h"
-
+/* Let's just grab the original header file here */
+%include "example.h"
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile r_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' r_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' r
clean:
- $(MAKE) -f $(TOP)/Makefile INTERFACE='$(INTERFACE)' r_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' INTERFACE='$(INTERFACE)' r_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
-
-
-
-
-
/* Let's just grab the original header file here */
%include "example.h"
-
<H2>Wrapping a simple C++ class</H2>
<p>
-This example illustrates C++ class wrapping performed by SWIG.
-C++ classes are simply transformed into Ruby classes that provide methods to
-access class members.
+This example illustrates wrapping a simple C++ class to give a Ruby class.
<h2>The C++ Code</h2>
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
virtual double area() = 0;
virtual double perimeter() = 0;
private:
double radius;
public:
- Circle(double r) : radius(r) { };
+ Circle(double r) : radius(r) { }
virtual double area();
virtual double perimeter();
};
private:
double width;
public:
- Square(double w) : width(w) { };
+ Square(double w) : width(w) { }
virtual double area();
virtual double perimeter();
};
</blockquote>
<p>
-<li>When a instance of Ruby level wrapper class is garbage collected by
+<li>When a instance of Ruby level wrapper class is garbage collected by the
Ruby interpreter, the corresponding C++ destructor is automatically invoked.
-(Note: destructors are currently not inherited. This might change later.
-Until then, use <tt>-make_default</tt>).
<p>
<li>Static member variables are wrapped as Ruby class accessor methods.
<ul>
<li>Ruby module of SWIG differs from other language modules in wrapping C++
-interfaces. They provides lower-level interfaces and optional higher-level
+interfaces. They provide lower-level interfaces and optional higher-level
interfaces know as proxy classes. Ruby module needs no such redundancy
due to Ruby's sophisticated extension API.
-<p>
-<li>SWIG *does* know how to properly perform upcasting of objects in
+<li>SWIG <b>does</b> know how to properly perform upcasting of objects in
an inheritance hierarchy except for multiple inheritance.
-<p>
-<li>A wide variety of C++ features are not currently supported by SWIG. Here is the
-short and incomplete list:
-
-<p>
-<ul>
-<li>Overloaded methods and functions. SWIG wrappers don't know how to resolve name
-conflicts so you must give an alternative name to any overloaded method name using the
-%name directive like this:
-
-<blockquote>
-<pre>
-void foo(int a);
-%name(foo2) void foo(double a, double b);
-</pre>
-</blockquote>
-
-<p>
-<li>Overloaded operators. Not supported at all. The only workaround for this is
-to write a helper function. For example:
-
-<blockquote>
-<pre>
-%inline %{
- Vector *vector_add(Vector *a, Vector *b) {
- ... whatever ...
- }
-%}
-</pre>
-</blockquote>
-
-<p>
-<li>Namespaces. Not supported at all. Won't be supported until SWIG2.0 (if at all).
-
-</ul>
-<p>
-
-<li>Dave's snide remark: Like a large bottle of strong Tequilla, it's better to
-use C++ in moderation.
+<li>C++ Namespaces - %nspace isn't yet supported for Ruby.
</ul>
# Notice how the Shape#area() and Shape#perimeter() functions really
# invoke the appropriate virtual method on each object.
+# Remove references to the object and force a garbage collection run.
+c = s = o = nil
+GC.start()
+
print "\n", Example::Shape.nshapes," shapes remain\n"
print "Goodbye\n"
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-SRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SWIGOPT =
LIBS =
-
+
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='base' INTERFACE='base.i' ruby_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' ruby_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' ruby_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' ruby_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='base' INTERFACE='base.i' ruby_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' ruby_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' ruby_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' ruby_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SWIGOPT =
LIBS =
-
+
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='base' INTERFACE='base.i' ruby_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' ruby_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' ruby_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' ruby_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='base' INTERFACE='base.i' ruby_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' ruby_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' ruby_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' ruby_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
-
+<html>
<head>
<title>SWIG:Examples:ruby</title>
</head>
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
-build: Example.class
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' CXX="gcj" \
+build: Example.class Example.h
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
CXXSHARED="gcj -fpic -shared Example.class" LIBS="-lstdc++" DEFS='' ruby_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
rm -f *.class Example.h
-Example.class: Example.java
- gcj -fPIC -C -c -g Example.java
- gcjh Example
-
+Example.class Example.h: $(SRCDIR)Example.java
+ gcj -d . -fPIC -C -c -g $(SRCDIR)Example.java
+ gcjh Example.class
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
zoo.add_animal(tiger1)
# unset variables to force gc
- tiger = nil
+ tiger1 = nil
end
GC.start
# Call a method to verify the animal is still valid and not gc'ed
if tiger2.get_name != "tiger1"
raise RuntimeError, "Wrong animal name"
-end
+end
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
char *Vector::print() {
static char temp[512];
- sprintf(temp,"Vector %p (%g,%g,%g)", this, x,y,z);
+ sprintf(temp,"Vector %p (%g,%g,%g)", (void *)this, x,y,z);
return temp;
}
private:
double x,y,z;
public:
- Vector() : x(0), y(0), z(0) { };
- Vector(double x, double y, double z) : x(x), y(y), z(z) { };
+ Vector() : x(0), y(0), z(0) { }
+ Vector(double x, double y, double z) : x(x), y(y), z(z) { }
friend Vector operator+(const Vector &a, const Vector &b);
char *print();
};
Vector &operator[](int);
int size();
};
-
-
-
-
VectorArray(int maxsize);
~VectorArray();
int size();
-
+
/* This wrapper provides an alternative to the [] operator */
%extend {
Vector &get(int index) {
}
}
};
-
-
-
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
-SWIGOPT =
+SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
SWIGOPT='$(SWIGOPT)' TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
}
void vector_print(Vector *v) {
- printf("Vector %p = (%g, %g, %g)\n", v, v->x, v->y, v->z);
+ printf("Vector %p = (%g, %g, %g)\n", (void *)v, v->x, v->y, v->z);
}
%}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile ruby_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' ruby
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='myruby' INTERFACE='$(INTERFACE)' ruby_static
clean:
- $(MAKE) -f $(TOP)/Makefile ruby_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
printf("dvar = %g\n", dvar);
printf("cvar = %c\n", cvar);
printf("strvar = %s\n", strvar ? strvar : "(null)");
- printf("cstrvar = %s\n", cstrvar ? cstrvar : "(null)");
- printf("iptrvar = %p\n", iptrvar);
+ printf("cstrvar = %s\n", cstrvar);
+ printf("iptrvar = %p\n", (void *)iptrvar);
printf("name = %s\n", name);
- printf("ptptr = %p (%d, %d)\n", ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
+ printf("ptptr = %p (%d, %d)\n", (void *)ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
printf("pt = (%d, %d)\n", pt.x, pt.y);
printf("status = %d\n", status);
}
(defvar *swig-source-directory* #p"/home/mkoeppe/s/swig1.3/")
-(defvar *swig-program* (merge-pathnames "preinst-swig" *swig-source-directory*))
+(defvar *swig-program* (merge-pathnames "swig" *swig-source-directory*))
(defun run-swig (swig-interface-file-name &key directory-search-list module
ignore-errors c++)
--- /dev/null
+# see top-level Makefile.in
+class
+constants
+contract
+enum
+funcptr
+matrix
+matrix2
+pointer
+simple
+std_list
+std_vector
+struct
+template
+variables
+
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS = example.cxx
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab_cpp
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+/* File : example.cxx */
+
+#include "example.h"
+#define M_PI 3.14159265358979323846
+
+/* Move the shape to a new location */
+void Shape::move(double dx, double dy) {
+ x += dx;
+ y += dy;
+}
+
+int Shape::nshapes = 0;
+
+double Circle::area() {
+ return M_PI*radius*radius;
+}
+
+double Circle::perimeter() {
+ return 2*M_PI*radius;
+}
+
+double Square::area() {
+ return width*width;
+}
+
+double Square::perimeter() {
+ return 4*width;
+}
--- /dev/null
+/* File : example.h */
+
+class Shape {
+public:
+ Shape() {
+ nshapes++;
+ }
+ virtual ~Shape() {
+ nshapes--;
+ }
+ double x, y;
+ void move(double dx, double dy);
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
+ static int nshapes;
+};
+
+class Circle : public Shape {
+private:
+ double radius;
+public:
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
+};
+
+class Square : public Shape {
+private:
+ double width;
+public:
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
+};
--- /dev/null
+/* File : example.i */
+%module example
+
+%{
+#include "example.h"
+%}
+
+/* Let's just grab the original header file here */
+%include "example.h"
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+
+// ----- Object creation -----
+
+printf("Creating some objects:\n");
+c = new_Circle(10)
+s = new_Square(10)
+
+// ----- Access a static member -----
+
+printf("\nA total of %i shapes were created\n", Shape_nshapes_get());
+
+// ----- Member data access -----
+
+// Set the location of the object
+
+Shape_x_set(c, 20);
+Shape_y_set(c, 30);
+
+Shape_x_set(s, -10);
+Shape_y_set(s, 5);
+
+printf("\nHere is their current position:\n");
+printf(" Circle = (%f, %f)\n", Shape_x_get(c), Shape_y_get(c));
+printf(" Square = (%f, %f)\n", Shape_x_get(s), Shape_y_get(s));
+
+// ----- Call some methods -----
+
+printf("\nHere are some properties of the shapes:\n");
+function print_shape(o)
+ printf(" area = %f\n", Shape_area(o));
+ printf(" perimeter = %f\n", Shape_perimeter(o));
+endfunction
+print_shape(c);
+print_shape(s);
+
+printf("\nGuess I will clean up now\n");
+
+// Note: this invokes the virtual destructor
+delete_Circle(c);
+delete_Square(s);
+
+printf("%i shapes remain\n", Shape_nshapes_get());
+printf("Goodbye\n");
+
+exit
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+/* File : example.i */
+%module example
+
+/* Wraps enums and constants as Scilab variables (instead of functions) */
+%scilabconst(1);
+
+/* A few preprocessor macros */
+
+#define ICONST 42
+#define FCONST 2.1828
+#define CCONST 'x'
+#define CCONST2 '\n'
+#define SCONST "Hello World"
+#define SCONST2 "\"Hello World\""
+
+/* This should work just fine */
+#define EXPR ICONST + 3*(FCONST)
+
+/* This shouldn't do anything */
+#define EXTERN extern
+
+/* Neither should this (BAR isn't defined) */
+#define FOO (ICONST + BAR)
+
+/* The following directives also produce constants */
+
+%constant int iconst = 37;
+%constant double fconst = 3.14;
+
+
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+example_Init();
+
+printf("\nTest constants\n");
+printf("ICONST = %i (should be 42)\n", ICONST);
+printf("FCONST = %5.4f (should be 2.1828)\n", FCONST);
+printf("SCONST = ''%s'' (should be ''Hello World'')\n", SCONST);
+printf("EXPR = %5.4f (should be 48.5484)\n", EXPR);
+printf("iconst = %i (should be 37)\n", iconst);
+printf("fconst = %3.2f (should be 3.14)\n", fconst);
+
+exit
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS = example.c
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+/* File : example.c */
+
+/* A global variable */
+double Foo = 3.0;
+
+/* Compute the greatest common divisor of positive integers */
+int gcd(int x, int y) {
+ int g;
+ g = y;
+ while (x > 0) {
+ g = x;
+ x = y % x;
+ y = g;
+ }
+ return g;
+}
+
+int fact(int n) {
+ if (n <= 0) return 1;
+ return n*fact(n-1);
+}
+
+
--- /dev/null
+/* File : example.i */
+%module example
+
+%contract gcd(int x, int y) {
+require:
+ x >= 0;
+ y >= 0;
+}
+
+%contract fact(int n) {
+require:
+ n >= 0;
+ensure:
+ fact >= 1;
+}
+
+%inline %{
+extern int gcd(int x, int y);
+extern int fact(int n);
+extern double Foo;
+%}
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+
+
+// Call our gcd() function
+x = 42;
+y = 105;
+g = gcd(x, y);
+printf("The gcd of %d and %d is %d\n", x, y, g);
+
+// Call our fact() function
+x = 5;
+g = fact(x);
+printf("The fact of %d is %d\n", x, g);
+
+// Manipulate the Foo global variable
+
+// Output its current value
+printf("Foo = %f\n", Foo_get());
+
+// Change its value
+Foo_set(3.1415926);
+
+// See if the change took effect
+printf("Foo = %f\n", Foo_get());
+
+// Check error messages when violating contract
+ierr = execstr('gcd(-42, 105)', 'errcatch');
+if ierr <> 20003 then
+ error("gcd(-42, 105) must provoke a RunTimeError")
+end
+
+ierr = execstr('fact(-4)', 'errcatch');
+if ierr <> 20003 then
+ error("fact(-4) must provoke a RunTimeError")
+end
+
+exit
+
+
+
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS = example.cxx
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab_cpp
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+/* File : example.c */
+
+#include "example.h"
+#include <stdio.h>
+
+void Foo::enum_test(speed s) {
+ if (s == IMPULSE) {
+ printf("IMPULSE speed\n");
+ } else if (s == WARP) {
+ printf("WARP speed\n");
+ } else if (s == LUDICROUS) {
+ printf("LUDICROUS speed\n");
+ } else {
+ printf("Unknown speed\n");
+ }
+}
+
+void enum_test(color c, Foo::speed s) {
+ if (c == RED) {
+ printf("color = RED, ");
+ } else if (c == BLUE) {
+ printf("color = BLUE, ");
+ } else if (c == GREEN) {
+ printf("color = GREEN, ");
+ } else {
+ printf("color = Unknown color!, ");
+ }
+ if (s == Foo::IMPULSE) {
+ printf("speed = IMPULSE speed\n");
+ } else if (s == Foo::WARP) {
+ printf("speed = WARP speed\n");
+ } else if (s == Foo::LUDICROUS) {
+ printf("speed = LUDICROUS speed\n");
+ } else {
+ printf("speed = Unknown speed!\n");
+ }
+}
--- /dev/null
+/* File : example.h */
+
+enum color { RED, BLUE, GREEN };
+
+class Foo {
+ public:
+ Foo() { }
+ enum speed { IMPULSE, WARP, LUDICROUS };
+ void enum_test(speed s);
+};
+
+void enum_test(color c, Foo::speed s);
+
--- /dev/null
+/* File : example.i */
+%module example
+
+%{
+#include "example.h"
+%}
+
+%include "example.h"
+
+
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+example_Init();
+
+printf("\nTest enums\n");
+printf("*** color ***\n");
+printf(" RED_get() = %i\n", RED_get());
+printf(" BLUE_get() = %i\n", BLUE_get());
+printf(" GREEN_get() = %i\n", GREEN_get());
+
+printf("\n*** Foo::speed ***\n")
+printf(" Foo_IMPULSE = %i\n", Foo_IMPULSE_get());
+printf(" Foo_WARP = %i\n", Foo_WARP_get());
+printf(" Foo_LUDICROUS = %i\n", Foo_LUDICROUS_get());
+
+printf("\nTest enums as argument of functions\n");
+
+enum_test(RED_get(), Foo_IMPULSE_get());
+enum_test(BLUE_get(), Foo_WARP_get());
+enum_test(GREEN_get(), Foo_LUDICROUS_get());
+enum_test(1234, 5678);
+
+printf("\nTest enums as argument of class methods\n");
+
+f = new_Foo();
+Foo_enum_test(f, Foo_IMPULSE_get());
+Foo_enum_test(f, Foo_WARP_get());
+Foo_enum_test(f, Foo_LUDICROUS_get());
+delete_Foo(f);
+
+exit
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS = example.c
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+/* File : example.c */
+
+int do_op(int a, int b, int (*op)(int,int)) {
+ return (*op)(a,b);
+}
+
+int add(int a, int b) {
+ return a+b;
+}
+
+int sub(int a, int b) {
+ return a-b;
+}
+
+int mul(int a, int b) {
+ return a*b;
+}
+
+int (*funcvar)(int,int) = add;
--- /dev/null
+/* file: example.h */
+
+extern int do_op(int,int, int (*op)(int,int));
+extern int add(int,int);
+extern int sub(int,int);
+extern int mul(int,int);
+
+extern int (*funcvar)(int,int);
+
--- /dev/null
+/* File : example.i */
+%module example
+%{
+#include "example.h"
+%}
+
+/* Wrap a function taking a pointer to a function */
+extern int do_op(int a, int b, int (*op)(int, int));
+
+extern int (*funcvar)(int,int);
+
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+
+a = 37
+b = 42
+
+// Now call our C function with a bunch of callbacks
+
+printf("Trying some C callback functions\n");
+printf(" a = %i\n", a);
+printf(" b = %i\n", b);
+printf(" ADD(a,b) = %i\n", do_op(a,b,funcvar_get()));
+
+exit
+
+
+
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS = example.c
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+/* FILE : matrix.c : some simple 4x4 matrix operations */
+#include <stdlib.h>
+#include <stdio.h>
+
+double **new_matrix() {
+
+ int i;
+ double **M;
+
+ M = (double **) malloc(4*sizeof(double *));
+ M[0] = (double *) malloc(16*sizeof(double));
+
+ for (i = 0; i < 4; i++) {
+ M[i] = M[0] + 4*i;
+ }
+ return M;
+}
+
+void destroy_matrix(double **M) {
+
+ free(M[0]);
+ free(M);
+
+}
+
+void print_matrix(double **M) {
+
+ int i,j;
+
+ for (i = 0; i < 4; i++) {
+ for (j = 0; j < 4; j++) {
+ printf("%10g ", M[i][j]);
+ }
+ printf("\n");
+ }
+
+}
+
+void mat_mult(double **m1, double **m2, double **m3) {
+
+ int i,j,k;
+ double temp[4][4];
+
+ for (i = 0; i < 4; i++)
+ for (j = 0; j < 4; j++) {
+ temp[i][j] = 0;
+ for (k = 0; k < 4; k++)
+ temp[i][j] += m1[i][k]*m2[k][j];
+ }
+
+ for (i = 0; i < 4; i++)
+ for (j = 0; j < 4; j++)
+ m3[i][j] = temp[i][j];
+}
+
+
+
+
+
+
+
--- /dev/null
+%module example
+// FILE : matrix.i
+
+%{
+
+void set_m(double **M, int i, int j, double val) {
+ M[i][j] = val;
+}
+
+double get_m(double **M, int i, int j) {
+ return M[i][j];
+}
+%}
+
+%inline {
+/*** Matrix Operations ***/
+
+extern double **new_matrix();
+/* Creates a new matrix and returns a pointer to it */
+
+extern void destroy_matrix(double **M);
+/* Destroys the matrix M */
+
+extern void print_matrix(double **M);
+/* Prints out the matrix M */
+
+extern void set_m(double **M, int i, int j, double val);
+/* Sets M[i][j] = val*/
+
+extern double get_m(double **M, int i, int j);
+/* Returns M[i][j] */
+
+extern void mat_mult(double **a, double **b, double **c);
+/* Multiplies matrix a by b and places the result in c*/
+
+}
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+
+// create a new matrix
+x = new_matrix();
+for i = 0 : 3;
+ for j = 0 : 3;
+ set_m(x, i, j, i+j);
+ end;
+end;
+
+// print the matrix
+print_matrix(x);
+
+// another matrix
+y = new_matrix();
+ for i = 0 : 3;
+ for j = 0 : 3;
+ set_m(y, i, j, i-j);
+ end;
+ end;
+
+// print the matrix
+print_matrix(y);
+
+// mat_mult the two matrix, and the result is stored in a new matrix
+z = new_matrix();
+
+mat_mult(x, y, z);
+
+print_matrix(z);
+
+//destroy the matrix
+destroy_matrix(x);
+destroy_matrix(y);
+destroy_matrix(z);
+
+exit
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS = example.c
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+
+// Double matrix functions
+
+double sumDoubleMatrix(double *inputMatrix, int nbRow, int nbCol)
+{
+ int i;
+ double total = 0.0;
+ for (i=0; i<nbRow*nbCol; i++)
+ {
+ total += inputMatrix[i];
+ }
+ return total;
+}
+
+void squareDoubleMatrix(double *inputMatrix, int nbRow, int nbCol, double** resultMatrix, int* nbRowRes, int* nbColRes)
+{
+ int i;
+ int size = nbRow * nbCol;
+ *nbRowRes = nbRow;
+ *nbColRes = nbCol;
+ *resultMatrix = (double*) malloc(size * sizeof(double));
+ for (i=0; i<size; i++)
+ {
+ (*resultMatrix)[i] = inputMatrix[i] * inputMatrix[i];
+ }
+}
+
+void getDoubleMatrix(double **resultMatrix, int *nbRowRes, int *nbColRes)
+{
+ int i;
+ int size;
+ *nbRowRes = 5;
+ *nbColRes = 3;
+ size = (*nbRowRes) * (*nbColRes);
+ *resultMatrix = (double*) malloc(size * sizeof(double));
+ for (i=0; i<size; i++)
+ {
+ (*resultMatrix)[i] = i*2;
+ }
+}
+
+// Integer matrix functions
+
+int sumIntegerMatrix(int *inputMatrix, int nbRow, int nbCol)
+{
+ int i;
+ int total = 0;
+ for (i=0; i<nbRow*nbCol; i++)
+ {
+ total += inputMatrix[i];
+ }
+ return total;
+}
+
+void squareIntegerMatrix(int *inputMatrix, int nbRow, int nbCol, int** resultMatrix, int* nbRowRes, int* nbColRes)
+{
+ int i;
+ int size = nbRow * nbCol;
+ *nbRowRes = nbRow;
+ *nbColRes = nbCol;
+ *resultMatrix = (int*) malloc(size * sizeof(int));
+ for (i=0; i<size; i++)
+ {
+ (*resultMatrix)[i] = inputMatrix[i] * inputMatrix[i];
+ }
+}
+
+void getIntegerMatrix(int **resultMatrix, int *nbRowRes, int *nbColRes)
+{
+ int i;
+ int size;
+ *nbRowRes = 5;
+ *nbColRes = 3;
+ size = (*nbRowRes) * (*nbColRes);
+ *resultMatrix = (int*) malloc(size * sizeof(int));
+ for (i=0; i<size; i++)
+ {
+ (*resultMatrix)[i] = i*2;
+ }
+}
+
+// String matrix functions
+
+char* concatStringVector(char **inputVector, int size)
+{
+ int i;
+ int resultSize;
+ char *result;
+ resultSize = 3 * size + 1;
+ result = calloc(resultSize, sizeof(char));
+ strcpy(result, inputVector[0]);
+ for (i=1; i<size; i++)
+ {
+ strcat(result, " ");
+ strcat(result, (const char*) inputVector[i]);
+ }
+ return result;
+}
+
+void getStringVector(char ***resultVector, int *sizeRes)
+{
+ int i;
+ *sizeRes = 12;
+ *resultVector = (char**) malloc((*sizeRes) * sizeof(char*));
+ for (i=0; i<*sizeRes; i++)
+ {
+ char* pc = (char*) calloc(3, sizeof(char));
+ sprintf(pc, "%d", i);
+ (*resultVector)[i] = pc;
+ }
+}
+
+
+
--- /dev/null
+%module example
+
+%include matrix.i
+
+%apply (double *IN, int IN_ROWCOUNT, int IN_COLCOUNT) { (double *inputMatrix, int nbRow, int nbCol) }
+%apply (double **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT) { (double **resultMatrix, int *nbRowRes, int *nbColRes) }
+
+%apply (int *IN, int IN_ROWCOUNT, int IN_COLCOUNT) { (int *inputMatrix, int nbRow, int nbCol) }
+%apply (int **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT) { (int **resultMatrix, int *nbRowRes, int *nbColRes) }
+
+%apply (char **IN, int IN_SIZE) { (char **inputVector, int size) }
+%apply (char ***OUT, int *OUT_SIZE) { (char ***resultVector, int *sizeRes) }
+
+%inline %{
+ extern double sumDoubleMatrix(double *inputMatrix, int nbRow, int nbCol);
+ extern void squareDoubleMatrix(double *inputMatrix, int nbRow, int nbCol, double **resultMatrix, int *nbRowRes, int *nbColRes);
+ extern void getDoubleMatrix(double **resultMatrix, int *nbRowRes, int *nbColRes);
+
+ extern int sumIntegerMatrix(int *inputMatrix, int nbRow, int nbCol);
+ extern void squareIntegerMatrix(int *inputMatrix, int nbRow, int nbCol, int **resultMatrix, int *nbRowRes, int *nbColRes);
+ extern void getIntegerMatrix(int **resultMatrix, int *nbRowRes, int *nbColRes);
+
+ extern char* concatStringVector(char **inputVector, int size);
+ extern void getStringVector(char ***resultVector, int *sizeRes);
+%}
+
--- /dev/null
+double sumitems(double *first, int nbRow, int nbCol);
+void main(){
+/**
+ * --> myMatrix=[ 103 3 1 12;0 0 2043 1];
+ * --> sumitems(myMatrix);
+ * 32
+ */
+ double B[] = {1,3,4,9,2,8,3,2}; /* Declare the matrix */
+ int rowB = 2, colB = 4;
+ printf("sumitems: %6.2f\n",sumitems(B, rowB, colB));
+
+
+/**
+ * --> myOtherMatrix=generateValues();
+ * --> size(myOtherMatrix);
+ */
+ int numberRow, numberCol, i;
+ double * matrix=getValues(&numberRow, &numberCol);
+ printf("Matrix of size [%d,%d]",numberRow, numberCol);
+ for(i=0; i < numberRow*numberCol; i++)
+ {
+ printf("A[%d] = %5.2f\n",i,matrix[i]);
+ }
+}
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+
+// Test lib double matrix functions
+disp("Call lib function getDoubleMatrix()");
+doubleMatrix = getDoubleMatrix();
+disp(doubleMatrix);
+
+disp("Call lib function sumDoubleMatrix()");
+s = sumDoubleMatrix(doubleMatrix);
+disp(s);
+
+disp("Call lib function squareDoubleMatrix()");
+sqrd = squareDoubleMatrix(doubleMatrix);
+disp(sqrd);
+
+
+// Test lib integer matrix functions
+
+disp("Call lib function getIntegerMatrix()");
+integerMatrix = getIntegerMatrix();
+disp(integerMatrix);
+
+disp("Call lib function sumIntegerMatrix()");
+s = sumIntegerMatrix(integerMatrix);
+disp(s);
+
+disp("Call lib function squareIntegerMatrix()");
+sqri = squareIntegerMatrix(integerMatrix);
+disp(sqri);
+
+
+// Test lib string matrix functions
+
+disp("Call lib function getStringVector()");
+stringVector = getStringVector();
+disp(stringVector);
+
+disp("Call lib function concatStringVector()");
+stringVector2 = concatStringVector(stringVector);
+disp(stringVector2);
+
+exit
+
+
+
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS = example.c
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+/* File : example.c */
+
+void add(int *x, int *y, int *result) {
+ *result = *x + *y;
+}
+
+void sub(int *x, int *y, int *result) {
+ *result = *x - *y;
+}
+
+int divide(int n, int d, int *r) {
+ int q;
+ q = n/d;
+ *r = n - q*d;
+ return q;
+}
--- /dev/null
+/* File : example.i */
+%module example
+
+%{
+extern void add(int *, int *, int *);
+extern void sub(int *, int *, int *);
+extern int divide(int, int, int *);
+%}
+
+/* This example illustrates a couple of different techniques
+ for manipulating C pointers */
+
+/* First we'll use the pointer library */
+extern void add(int *x, int *y, int *result);
+%include cpointer.i
+%pointer_functions(int, intp);
+
+/* Next we'll use some typemaps */
+
+%include typemaps.i
+extern void sub(int *INPUT, int *INPUT, int *OUTPUT);
+
+/* Next we'll use typemaps and the %apply directive */
+
+%apply int *OUTPUT { int *r };
+extern int divide(int n, int d, int *r);
+
+
+
+
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+
+// First create some objects using the pointer library.
+printf("Testing the pointer library\n")
+a = new_intp();
+b = new_intp();
+c = new_intp(); // Memory for result
+
+intp_assign(a, 37);
+intp_assign(b, 42);
+
+printf(" a = %d\n", intp_value(a));
+printf(" b = %d\n", intp_value(b));
+printf(" c = %d\n", intp_value(c));
+
+// Call the add() function with some pointers
+add(a, b, c);
+
+// Now get the result
+r = intp_value(c);
+printf(" 37 + 42 = %d\n", r);
+
+// Clean up the pointers
+delete_intp(a);
+delete_intp(b);
+delete_intp(c);
+
+// Now try the typemap library
+// This should be much easier. Now how it is no longer
+// necessary to manufacture pointers.
+printf("Trying the typemap library\n");
+r = sub(37, 42);
+printf(" 37 - 42 = %d\n", r);
+
+// Now try the version with multiple return values
+printf("Testing multiple return values\n");
+[q, r] = divide(42, 37);
+printf(" 42/37 = %d remainder %d\n", q, r);
+
+exit
+
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS = example.c
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+/* File : example.c */
+
+/* A global variable */
+double Foo = 3.0;
+
+/* Compute the greatest common divisor of positive integers */
+int gcd(int x, int y) {
+ int g;
+ g = y;
+ while (x > 0) {
+ g = x;
+ x = y % x;
+ y = g;
+ }
+ return g;
+}
+
+
--- /dev/null
+/* File : example.i */
+%module example
+
+%inline %{
+extern int gcd(int x, int y);
+extern double Foo;
+%}
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+
+// Call our gcd() function
+
+x = 42;
+y = 105;
+g = gcd(x,y);
+printf("The gcd of %d and %d is %d\n",x,y,g);
+
+// Manipulate the Foo global variable
+
+// Get its default value (see in example.c)
+defaultValue = Foo_get()
+if defaultValue <> 3 then pause; end
+
+// Change its value
+Foo_set(3.1415926)
+
+// See if the change took effect
+if Foo_get() <> 3.1415926 then pause,end
+
+exit
+
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS = example.cxx
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab_cpp
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+/* File : example.cpp */
+
+#include "example.h"
+
+#include <iostream>
+#include <iterator>
+#include <algorithm>
+#include <numeric>
+#include <sstream>
+
+
+template <typename T>
+std::list<T> concat_list(const std::list<T> list, const std::list<T> other_list)
+{
+ std::list<T> out_list(list);
+ out_list.insert(out_list.end(), other_list.begin(), other_list.end());
+ return out_list;
+}
+
+// int lists
+
+std::list<int> create_integer_list(const int rangemin, const int rangemax)
+{
+ std::list<int> out_list;
+ for (int i = rangemin; i <= rangemax; i++)
+ {
+ out_list.push_back(i);
+ }
+ return out_list;
+}
+
+int sum_integer_list(const std::list<int>& list)
+{
+ return std::accumulate(list.begin(), list.end(), 0);
+}
+
+std::list<int> concat_integer_list(const std::list<int> list, const std::list<int> other_list)
+{
+ return concat_list<int>(list, other_list);
+}
+
+// string lists
+
+std::list<std::string> create_string_list(const char* svalue)
+{
+ std::list<std::string> out_list;
+ std::string str(svalue);
+
+ std::istringstream iss(str);
+ std::copy(std::istream_iterator<std::string>(iss),
+ std::istream_iterator<std::string>(),
+ std::inserter<std::list<std::string> >(out_list, out_list.begin()));
+
+ return out_list;
+}
+
+std::list<std::string> concat_string_list(const std::list<std::string> list, const std::list<std::string> other_list)
+{
+ return concat_list<std::string>(list, other_list);
+}
+
--- /dev/null
+/* File : example.h */
+
+#include <list>
+#include <string>
+
+
+// integer lists
+std::list<int> create_integer_list(const int size, const int value);
+int sum_integer_list(const std::list<int>& list);
+std::list<int> concat_integer_list(const std::list<int> list, const std::list<int> other_list);
+
+// string lists
+std::list<std::string> create_string_list(const char* value);
+std::list<std::string> concat_string_list(const std::list<std::string> list, const std::list<std::string> other_list);
--- /dev/null
+/* File : example.i */
+
+%module example
+
+%{
+#include "example.h"
+%}
+
+%include stl.i
+%include std_list.i
+
+/* instantiate the required template specializations */
+namespace std
+{
+ %template(IntList) list<int>;
+ %template(StringList) list<std::string>;
+}
+
+%include "example.h"
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+example_Init();
+
+// This example shows how to use C++ fonctions with STL lists arguments
+// Here, STL lists are converted from/to Scilab matrices (SWIG_SCILAB_EXTRA_NATIVE_CONTAINERS is not defined)
+
+// integer lists
+
+disp("Example of passing matrices of int as list arguments of C++ functions.");
+disp("get a list of int {1...4} from create_integer_list():");
+is = create_integer_list(1, 4);
+disp(is);
+disp("get the sum of this list elements with sum_integer_list():")
+sum = sum_integer_list(is);
+disp(is);
+is2 = create_integer_list(3, 6);
+disp("concat this list with the list of int {3...6} with concat_integer_list():");
+is3 = concat_integer_list(is, is2);
+disp(is3);
+
+// string lists
+
+disp("Example of passing matrices of string as list arguments of C++ functions.");
+disp("get a list of string {''aa'', ''bb'', ''cc'', ''dd''} with create_string_list():");
+ss = create_string_list("aa bb cc dd");
+disp(ss);
+ss2 = create_string_list("cc dd ee ff");
+disp("concat this list with the list of string {''cc'', ''dd'', ''ee'', ''ff''} with concat_string_list():");
+ss3 = concat_string_list(ss, ss2);
+disp(ss3);
+
+exit
+
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab_cpp
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+/* File : example.h */
+
+#include <vector>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+
+double average(std::vector<int> v) {
+ return std::accumulate(v.begin(),v.end(),0.0)/v.size();
+}
+
+std::vector<double> half(const std::vector<double>& v) {
+ std::vector<double> w(v);
+ for (unsigned int i=0; i<w.size(); i++)
+ w[i] /= 2.0;
+ return w;
+}
+
+void halve_in_place(std::vector<double>& v) {
+ // would you believe this is the same as the above?
+ std::transform(v.begin(),v.end(),v.begin(),
+ std::bind2nd(std::divides<double>(),2.0));
+}
+
+
--- /dev/null
+/* File : example.i */
+%module example
+
+%warnfilter(SWIGWARN_SCILAB_TRUNCATED_NAME) std::vector::get_allocator;
+
+%{
+#include "example.h"
+%}
+
+%include stl.i
+/* instantiate the required template specializations */
+namespace std {
+ %template(IntVector) vector<int>;
+ %template(DoubleVector) vector<double>;
+}
+
+/* Let's just grab the original header file here */
+%include "example.h"
+
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+example_Init();
+
+
+disp(mean([1,2,3,4]));
+
+// ... or a wrapped std::vector<int>
+
+v = new_IntVector();
+for i = 1:4
+ IntVector_push_back(v, i);
+end;
+disp(average(v));
+
+
+// half will return a Scilab matrix.
+// Call it with a Scilab matrix...
+
+disp(half([1.0, 1.5, 2.0, 2.5, 3.0]));
+
+
+// ... or a wrapped std::vector<double>
+
+v = new_DoubleVector();
+for i = 1:4
+ DoubleVector_push_back(v, i);
+end;
+disp(half(v));
+
+exit
+
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS =
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+%module example
+
+%rename(Bar) Foo;
+
+%inline %{
+typedef struct {
+ int x;
+} Foo;
+
+%}
+
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+
+// Test use of a struct (Bar)
+
+a = new_Bar();
+
+Bar_x_set(a, 100);
+printf("a.x = %d (Should be 100)\n", Bar_x_get(a));
+
+delete_Bar(a);
+
+exit
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab_cpp
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+/* File : example.h */
+
+// Some template definitions
+
+template<class T> T max(T a, T b) { return a>b ? a : b; }
+
+template<class T> class vector {
+ T *v;
+ int sz;
+ public:
+ vector(int _sz) {
+ v = new T[_sz];
+ sz = _sz;
+ }
+ T &get(int index) {
+ return v[index];
+ }
+ void set(int index, T &val) {
+ v[index] = val;
+ }
+#ifdef SWIG
+ %extend {
+ T getitem(int index) {
+ return $self->get(index);
+ }
+ void setitem(int index, T val) {
+ $self->set(index,val);
+ }
+ }
+#endif
+};
+
--- /dev/null
+/* File : example.i */
+%module example
+
+%{
+#include "example.h"
+%}
+
+/* Let's just grab the original header file here */
+%include "example.h"
+
+/* Now instantiate some specific template declarations */
+
+%template(maxint) max<int>;
+%template(maxdouble) max<double>;
+%template(vecint) vector<int>;
+%template(vecdouble) vector<double>;
+
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+example_Init();
+
+// Call some templated functions
+printf("maxint(3, 7) = %i\n", maxint(3, 7));
+printf("maxdouble(3.14, 2.18) = %3.2f\n", maxdouble(3.14, 2.18));
+
+// Create some class
+
+iv = new_vecint(100);
+dv = new_vecdouble(1000);
+
+for i = 0:100
+ vecint_setitem(iv, i, 2*i);
+end
+
+for i = 0:100
+ vecdouble_setitem(dv, i, 1.0/(i+1));
+end
+
+isum = 0
+for i = 0:100
+ isum = isum + vecint_getitem(iv, i);
+end
+
+printf("isum = %i\n", isum);
+
+dsum = 0
+for i = 0:100
+ dsum = dsum + vecdouble_getitem(dv, i);
+end
+
+printf("dsum = %3.2f\n", dsum);
+
+delete_vecint(iv);
+delete_vecdouble(dv);
+
+exit
+
--- /dev/null
+TOP = ../..
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+SRCS = example.c
+TARGET = example
+INTERFACE = example.i
+
+check: build
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_run
+
+build:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' scilab
+
+clean:
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' scilab_clean
--- /dev/null
+/* File : example.c */
+
+/* I'm a file containing some C global variables */
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "example.h"
+
+int ivar = 0;
+short svar = 0;
+long lvar = 0;
+unsigned int uivar = 0;
+unsigned short usvar = 0;
+unsigned long ulvar = 0;
+signed char scvar = 0;
+unsigned char ucvar = 0;
+char cvar = 0;
+float fvar = 0;
+double dvar = 0;
+char *strvar = 0;
+const char cstrvar[] = "Goodbye";
+int *iptrvar = 0;
+char name[256] = "Dave";
+char path[256] = "/home/beazley";
+
+
+/* Global variables involving a structure */
+Point *ptptr = 0;
+Point pt = { 10, 20 };
+
+/* A variable that we will make read-only in the interface */
+int status = 1;
+
+/* A debugging function to print out their values */
+
+void print_vars() {
+ printf("ivar = %d\n", ivar);
+ printf("svar = %d\n", svar);
+ printf("lvar = %ld\n", lvar);
+ printf("uivar = %u\n", uivar);
+ printf("usvar = %u\n", usvar);
+ printf("ulvar = %lu\n", ulvar);
+ printf("scvar = %d\n", scvar);
+ printf("ucvar = %u\n", ucvar);
+ printf("fvar = %g\n", fvar);
+ printf("dvar = %g\n", dvar);
+ printf("cvar = %c\n", cvar);
+ printf("strvar = %s\n", strvar ? strvar : "(null)");
+ printf("cstrvar = %s\n", cstrvar);
+ printf("iptrvar = %p\n", (void *)iptrvar);
+ printf("name = %s\n", name);
+ printf("ptptr = %p (%d, %d)\n", (void *)ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
+ printf("pt = (%d, %d)\n", pt.x, pt.y);
+ printf("status = %d\n", status);
+}
+
+/* A function to create an integer (to test iptrvar) */
+
+int *new_int(int value) {
+ int *ip = (int *) malloc(sizeof(int));
+ *ip = value;
+ return ip;
+}
+
+int value_int(int *value) {
+ return *value;
+}
+
+/* A function to create a point */
+
+Point *new_Point(int x, int y) {
+ Point *p = (Point *) malloc(sizeof(Point));
+ p->x = x;
+ p->y = y;
+ return p;
+}
+
+char * Point_print(Point *p) {
+ static char buffer[256];
+ if (p) {
+ sprintf(buffer,"(%d,%d)", p->x,p->y);
+ } else {
+ sprintf(buffer,"null");
+ }
+ return buffer;
+}
+
+void pt_print() {
+ printf("(%d, %d)\n", pt.x, pt.y);
+}
--- /dev/null
+/* File: example.h */
+
+typedef struct {
+ int x,y;
+} Point;
+
--- /dev/null
+/* File : example.i */
+%module example
+%{
+#include "example.h"
+%}
+
+#pragma SWIG nowarn=SWIGWARN_TYPEMAP_SWIGTYPELEAK
+
+/* Some global variable declarations */
+%inline %{
+extern int ivar;
+extern short svar;
+extern long lvar;
+extern unsigned int uivar;
+extern unsigned short usvar;
+extern unsigned long ulvar;
+extern signed char scvar;
+extern unsigned char ucvar;
+extern char cvar;
+extern float fvar;
+extern double dvar;
+extern char *strvar;
+extern const char cstrvar[];
+extern int *iptrvar;
+extern char name[256];
+
+extern Point *ptptr;
+extern Point pt;
+%}
+
+
+/* Some read-only variables */
+
+%immutable;
+
+%inline %{
+extern int status;
+extern char path[256];
+%}
+
+%mutable;
+
+/* Some helper functions to make it easier to test */
+%inline %{
+extern void print_vars();
+extern int *new_int(int value);
+extern int value_int(int *value);
+extern Point *new_Point(int x, int y);
+extern char *Point_print(Point *p);
+extern void pt_print();
+%}
+
--- /dev/null
+lines(0);
+ilib_verbose(0);
+ierr = exec('loader.sce', 'errcatch');
+if ierr <> 0 then
+ disp(lasterror());
+ exit(ierr);
+end
+
+// Try to set the values of some global variables
+ivar_set(42);
+svar_set(-31000);
+lvar_set(65537);
+uivar_set(uint32(123456));
+usvar_set(uint16(61000));
+ulvar_set(654321);
+scvar_set(int8(-13));
+ucvar_set(uint8(251));
+cvar_set("S");
+fvar_set(3.14159);
+dvar_set(2.1828);
+strvar_set("Hello World");
+iptrvar_set(new_int(37));
+ptptr_set(new_Point(37,42));
+name_set("Bill");
+
+// Now print out the values of the variables
+printf("Variables (values printed from Scilab)\n");
+printf("ivar = %i\n", ivar_get());
+printf("svar = %i\n", svar_get());
+printf("lvar = %i\n", lvar_get());
+printf("uivar = %i\n", uivar_get());
+printf("usvar = %i\n", usvar_get());
+printf("ulvar = %i\n", ulvar_get());
+printf("scvar = %i\n", scvar_get());
+printf("ucvar = %i\n", ucvar_get());
+printf("fvar = %f\n", fvar_get());
+printf("dvar = %f\n", dvar_get());
+printf("cvar = %s\n", cvar_get());
+printf("strvar = %s\n", strvar_get());
+printf("cstrvar = %s\n", cstrvar_get());
+printf("iptrvar = %i\n", value_int(iptrvar_get()));
+printf("name = %s\n", name_get());
+printf("ptptr = %s\n", Point_print(ptptr_get()));
+printf("pt = %s\n", Point_print(pt_get()));
+printf("status = %d\n", status_get());
+
+printf("\nVariables (values printed from C)\n");
+print_vars()
+
+// Immutable variables
+printf("\nNow I''m going to try and modify some read only variables\n");
+printf(" Tring to set ''path''\n");
+try
+ path_set("Whoa!");
+ printf("Hey, what''s going on?!?! This shouldn''t work\n");
+catch
+ printf("Good.\n");
+end
+printf(" Trying to set ''status''\n");
+try
+ status_set(0);
+ printf("Hey, what''s going on?!?! This shouldn''t work\n");
+catch
+ printf("Good.\n");
+end
+
+// Structure
+printf("\nI''m going to try and update a structure variable.\n");
+pt_set(ptptr_get());
+printf("The new value is %s\n", Point_print(pt_get()));
+
+exit
+
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tcl_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mytclsh' INTERFACE='$(INTERFACE)' tclsh_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
-/* File : example.c */
+/* File : example.cxx */
#include "example.h"
#define M_PI 3.14159265358979323846
int Shape::nshapes = 0;
-double Circle::area(void) {
+double Circle::area() {
return M_PI*radius*radius;
}
-double Circle::perimeter(void) {
+double Circle::perimeter() {
return 2*M_PI*radius;
}
-double Square::area(void) {
+double Square::area() {
return width*width;
}
-double Square::perimeter(void) {
+double Square::perimeter() {
return 4*width;
}
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
- virtual double area(void) = 0;
- virtual double perimeter(void) = 0;
+ virtual double area() = 0;
+ virtual double perimeter() = 0;
static int nshapes;
};
private:
double radius;
public:
- Circle(double r) : radius(r) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Circle(double r) : radius(r) { }
+ virtual double area();
+ virtual double perimeter();
};
class Square : public Shape {
private:
double width;
public:
- Square(double w) : width(w) { };
- virtual double area(void);
- virtual double perimeter(void);
+ Square(double w) : width(w) { }
+ virtual double area();
+ virtual double perimeter();
};
-
-
-
-
-
%}
/* Let's just grab the original header file here */
-
%include "example.h"
-
}
virtual ~Shape() {
nshapes--;
- };
- double x, y;
+ }
+ double x, y;
void move(double dx, double dy);
virtual double area() = 0;
virtual double perimeter() = 0;
private:
double radius;
public:
- Circle(double r) : radius(r) { };
+ Circle(double r) : radius(r) { }
virtual double area();
virtual double perimeter();
};
private:
double width;
public:
- Square(double w) : width(w) { };
+ Square(double w) : width(w) { }
virtual double area();
virtual double perimeter();
};
SWIG performs two forms of C++ wrapping-- a low level interface and a high level widget-like interface.
<ul>
<li>
-Click <a href="example1.tcl">here</a> to see a script that calls the C++ functions using the
+Click <a href="runme.tcl">here</a> to see a script that calls the C++ functions using the
low-level interface.
<li>
-Click <a href="example2.tcl">here</a> to see a the same script written with the high-level
+Click <a href="runme2.tcl">here</a> to see the same script written with the high-level
interface.
</ul>
<h2>General Comments</h2>
<ul>
+
<li>The low-level function interface is much faster than the high-level interface.
In fact, all the higher level interface does is call functions in the low-level interface.
-<p>
-<li>SWIG *does* know how to properly perform upcasting of objects in an inheritance
+<li>SWIG <b>does</b> know how to properly perform upcasting of objects in an inheritance
hierarchy (including multiple inheritance). Therefore it is perfectly safe to pass
an object of a derived class to any function involving a base class.
-<p>
-<li>A wide variety of C++ features are not currently supported by SWIG. Here is the
-short and incomplete list:
-
-<p>
-<ul>
-<li>Overloaded methods and functions. SWIG wrappers don't know how to resolve name
-conflicts so you must give an alternative name to any overloaded method name using the
-%name directive like this:
-
-<blockquote>
-<pre>
-void foo(int a);
-%name(foo2) void foo(double a, double b);
-</pre>
-</blockquote>
-
-<p>
-<li>Overloaded operators. Not supported at all. The only workaround for this is
-to write a helper function. For example:
-
-<blockquote>
-<pre>
-%inline %{
- Vector *vector_add(Vector *a, Vector *b) {
- ... whatever ...
- }
-%}
-</pre>
-</blockquote>
-
-<p>
-<li>Namespaces. Not supported at all. Won't be supported until SWIG2.0 (if at all).
+<li>C++ Namespaces - %nspace isn't yet supported for Tcl.
</ul>
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS =
TARGET = my_tclsh
DLTARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(DLTARGET)' INTERFACE='$(INTERFACE)' tcl
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tclsh
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = my_tclsh
DLTARGET = example
SWIGOPT =
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- TARGET='$(DLTARGET)' INTERFACE='$(INTERFACE)' tcl
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(DLTARGET)' INTERFACE='$(INTERFACE)' tcl
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tclsh
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tclsh
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tcl_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mytclsh' INTERFACE='$(INTERFACE)' tclsh_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = my_tclsh
DLTARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(DLTARGET)' INTERFACE='$(INTERFACE)' tcl
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tclsh
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SWIGOPT =
LIBS =
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='base' INTERFACE='base.i' tcl_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' tcl_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' tcl_cpp
- $(MAKE) -f $(TOP)/Makefile SWIG='$(SWIG)' SWIGOPT='$(SWIGOPT)' \
- LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' tcl_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='base' INTERFACE='base.i' tcl_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='foo' INTERFACE='foo.i' tcl_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='bar' INTERFACE='bar.i' tcl_cpp
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='$(SWIGOPT)' LIBS='$(LIBS)' TARGET='spam' INTERFACE='spam.i' tcl_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
-build: Example.class
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
- TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' CXX="gcj" \
- TCL_CXXSHARED="gcj -fpic -shared Example.class " LIBS="-lstdc++" DEFS='' tcl_cpp
+build: Example.class Example.h
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' \
+ TCLCXXSHARED="gcj -fpic -shared Example.class " LIBS="-lstdc++" DEFS='' tcl_cpp
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
rm -f *.class Example.h
-run:
- tclsh runme.tcl
-
-Example.class: Example.java
- gcj -fPIC -C -c -g Example.java
- gcjh Example
-
+Example.class Example.h: $(SRCDIR)Example.java
+ gcj -d . -fPIC -C -c -g $(SRCDIR)Example.java
+ gcjh Example.class
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = my_tclsh
DLTARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(DLTARGET)' INTERFACE='$(INTERFACE)' tcl
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tclsh
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tcl_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mytclsh' INTERFACE='$(INTERFACE)' tclsh_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = my_tclsh
DLTARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(DLTARGET)' INTERFACE='$(INTERFACE)' tcl
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tclsh
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
CXXSRCS = example.cxx
TARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tcl_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='mytclsh' INTERFACE='$(INTERFACE)' tclsh_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
char *Vector::print() {
static char temp[512];
- sprintf(temp,"Vector %p (%g,%g,%g)", this, x,y,z);
+ sprintf(temp,"Vector %p (%g,%g,%g)", (void *)this, x,y,z);
return temp;
}
private:
double x,y,z;
public:
- Vector() : x(0), y(0), z(0) { };
- Vector(double x, double y, double z) : x(x), y(y), z(z) { };
+ Vector() : x(0), y(0), z(0) { }
+ Vector(double x, double y, double z) : x(x), y(y), z(z) { }
friend Vector operator+(const Vector &a, const Vector &b);
char *print();
};
Vector &operator[](int);
int size();
};
-
-
-
-
VectorArray(int maxsize);
~VectorArray();
int size();
-
+
/* This wrapper provides an alternative to the [] operator */
%extend {
Vector &get(int index) {
}
}
};
-
-
-
-
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = my_tclsh
DLTARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(DLTARGET)' INTERFACE='$(INTERFACE)' tcl
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tclsh
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
-CXXSRCS =
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
+CXXSRCS =
TARGET = my_tclsh
DLTARGET = example
INTERFACE = example.i
LIBS = -lm
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(DLTARGET)' INTERFACE='$(INTERFACE)' tcl_cpp
static:
- $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tclsh_cpp_static
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = my_tclsh
DLTARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(DLTARGET)' INTERFACE='$(INTERFACE)' tcl
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tclsh
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
}
void vector_print(Vector *v) {
- printf("Vector %p = (%g, %g, %g)\n", v, v->x, v->y, v->z);
+ printf("Vector %p = (%g, %g, %g)\n", (void *)v, v->x, v->y, v->z);
}
%}
TOP = ../..
-SWIG = $(TOP)/../preinst-swig
+SWIGEXE = $(TOP)/../swig
+SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib
SRCS = example.c
TARGET = my_tclsh
DLTARGET = example
INTERFACE = example.i
check: build
- $(MAKE) -f $(TOP)/Makefile tcl_run
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_run
build:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(DLTARGET)' INTERFACE='$(INTERFACE)' tcl
static:
- $(MAKE) -f $(TOP)/Makefile SRCS='$(SRCS)' SWIG='$(SWIG)' \
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' tclsh
clean:
- $(MAKE) -f $(TOP)/Makefile tcl_clean
+ $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
printf("dvar = %g\n", dvar);
printf("cvar = %c\n", cvar);
printf("strvar = %s\n", strvar ? strvar : "(null)");
- printf("cstrvar = %s\n", cstrvar ? cstrvar : "(null)");
- printf("iptrvar = %p\n", iptrvar);
+ printf("cstrvar = %s\n", cstrvar);
+ printf("iptrvar = %p\n", (void *)iptrvar);
printf("name = %s\n", name);
- printf("ptptr = %p (%d, %d)\n", ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
+ printf("ptptr = %p (%d, %d)\n", (void *)ptptr, ptptr ? ptptr->x : 0, ptptr ? ptptr->y : 0);
printf("pt = (%d, %d)\n", pt.x, pt.y);
printf("status = %d\n", status);
}
LANGUAGE = allegrocl
ALLEGROCL = @ALLEGROCLBIN@
SCRIPTSUFFIX = _runme.lisp
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
# these cpp tests generate warnings/errors when compiling
# the wrapper .cxx file.
-CPP_TEST_BROKEN_CXX =
+CPP_TEST_BROKEN_CXX =
# the error is wrap:action code generated by swig. \
# error: can't convert [std::string] 'b' to 'bool' \
# might just need a bool overload op for std::string. \
dynamic_cast \
extend_variable \
# cdata.i support needed \
- li_cdata \
+ li_cdata_cpp \
# warning generated. otherwise all good. \
operator_overload \
# std_common.i support \
extern_throws \
throw_exception \
using_pointers \
-
+
C_TEST_CASES_ACL_BROKEN = \
# 'cdate.i' module support \
li_cdata \
# none!
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.lisp appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(ALLEGROCLBIN) -batch -s $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(ALLEGROCLBIN) -batch -s $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
%.clean:
@rm -f $*.cl
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile allegrocl_clean
-
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR="$(SRCDIR)" allegrocl_clean
%}
-// Now test the allowexcept feature by making the usual $action uncompileable and ensuring the %exception is picked up
+// Now test the allowexcept feature by making the usual $action uncompilable and ensuring the %exception is picked up
struct XYZ {
};
%include "std_string.i"
+#ifdef SWIGSCILAB
+%rename(ProcBase) ProtectedBase;
+%rename(PubBase) PublicBase;
+#endif
+
%feature("director") PublicBase;
%feature("director") ProtectedBase;
%warnfilter(SWIGWARN_TYPEMAP_THREAD_UNSAFE,SWIGWARN_TYPEMAP_DIRECTOROUT_PTR) DirectorTest;
+#if defined(SWIGSCILAB)
+%rename(DirTest) DirectorTest;
+#endif
+
%apply signed char {char, const char};
%apply const signed char & {const char &};
-/* Test %apply for char *, signed char *, unsigned char *
- This won't work in all situations, so does not necessarily have to be implemented. See
+/* Test %apply for char *, signed char *, unsigned char *
+ This won't work in all situations, so does not necessarily have to be implemented. See
http://groups.google.com.ai/group/comp.lang.c++.moderated/browse_thread/thread/ad5873ce25d49324/0ae94552452366be?lnk=raot */
%module(directors="1") apply_strings
%warnfilter(SWIGWARN_TYPEMAP_VARIN_UNDEF) DigitsGlobalB;
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK) DigitsGlobalC;
+#if defined(SWIGSCILAB)
+%rename(TNum) TNumber;
+%rename(DirTest) DirectorTest;
+#endif
+
%apply char * {UCharPtr};
%apply char * {SCharPtr};
%apply const char * {CUCharPtr};
TAscii DigitsMemberA[20];
TAscii *DigitsMemberB;
} TNumber;
-
+
TAscii DigitsGlobalA[20];
TAscii DigitsGlobalB[] = {(unsigned char)'A', (unsigned char)'B', 0};
TAscii *DigitsGlobalC;
-%}
+%}
// Director test
%feature("director");
+#if defined(SWIGGO)
+%typemap(godirectorout) CharPtr, CCharPtr ""
+#endif
+
%inline %{
struct DirectorTest {
virtual UCharPtr UCharFunction(UCharPtr str) { return str; }
%module array_member
+#if defined(SWIGSCILAB)
+%rename(RayPkt) RayPacketData;
+#endif
+
%inline %{
typedef struct Foo {
%module array_typedef_memberin
+
+#if defined(SWIGSCILAB)
+%rename(ExDetail) ExampleDetail;
+#endif
+
%inline %{
+#if defined(_MSC_VER)
+ #pragma warning(disable: 4351) // new behavior: elements of array 'xyz' will be default initialized
+#endif
+
typedef short Eight[8];
typedef const short ConstEight[8];
namespace ArrayExample
{
public:
Eight node_list;
-#ifndef _MSC_VER
const Eight node_list2;
ConstEight node_list3;
-#else
- Eight node_list2;
- Eight node_list3;
-#endif
void fn1(Eight a) {}
void fn2(const Eight a) {}
void fn7(Eight*& a) {}
void fn8(ConstEight*& a) {}
void fn9(const ConstEight*& a) {}
+
+ ExampleDetail() : node_list(), node_list2(), node_list3() {}
};
}
#include <stdlib.h>
%}
+#if defined(SWIGSCILAB)
+%rename(ArrSt) ArrayStruct;
+#endif
+
%inline %{
#define ARRAY_LEN 2
-%module(docstring="hello") autodoc
+%module(docstring="hello.") autodoc
%feature("autodoc");
%feature("autodoc","2") A::variable_c; // extended
%feature("autodoc","3") A::variable_d; // extended + types
-%feature("autodoc","just a string") A::funk; // names
+%feature("autodoc","just a string.") A::funk; // names
%inline {
void banana(S *a, const struct tagS *b, int c, Integer d) {}
%}
+%inline %{
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
+%}
+
%warnfilter(SWIGWARN_RUBY_WRONG_NAME) kMaxIOCTLSpaceParmsSize;
-#define kMaxIOCTLSpaceParmsSize 128
+#ifdef SWIGSCILAB
+%rename(Parms) sm_channel_ix_dump_parms;
+#endif
+
+#define kMaxIOCTLSpaceParmsSize 128
%{
-#define kMaxIOCTLSpaceParmsSize 128
+#define kMaxIOCTLSpaceParmsSize 128
%}
%inline %{
-typedef struct sm_channel_ix_dump_parms {
- unsigned data[(kMaxIOCTLSpaceParmsSize - ((4*sizeof(int)) + (2*sizeof(unsigned))))/sizeof(unsigned)];
-} SM_CHANNEL_IX_DUMP_PARMS;
+typedef struct sm_channel_ix_dump_parms {
+ unsigned data[(kMaxIOCTLSpaceParmsSize - ((4*sizeof(int)) + (2*sizeof(unsigned))))/sizeof(unsigned)];
+} SM_CHANNEL_IX_DUMP_PARMS;
%}
// bool typemaps check
%module bools
+
+#if defined(SWIGSCILAB)
+%rename(BoolSt) BoolStructure;
+#endif
+
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK); /* memory leak when setting a ptr/ref variable */
%warnfilter(SWIGWARN_RUBY_WRONG_NAME) constbool; /* Ruby, wrong class name */
--- /dev/null
+%module c_delete
+
+/* check C++ delete keyword is okay in C wrappers */
+
+%warnfilter(SWIGWARN_PARSE_KEYWORD) delete;
+
+#if !defined(SWIGOCTAVE) && !defined(SWIG_JAVASCRIPT_V8) /* Octave and Javascript/v8 compiles wrappers as C++ */
+
+%inline %{
+struct delete {
+ int delete;
+};
+%}
+
+%rename(DeleteGlobalVariable) delete;
+%inline %{
+int delete = 0;
+%}
+
+#endif
--- /dev/null
+%module c_delete_function
+
+/* check C++ delete keyword is okay in C wrappers */
+
+%warnfilter(SWIGWARN_PARSE_KEYWORD) delete;
+
+#if !defined(SWIGOCTAVE) && !defined(SWIG_JAVASCRIPT_V8) /* Octave and Javascript/v8 compiles wrappers as C++ */
+
+%inline %{
+double delete(double d) { return d; }
+%}
+
+#endif
%module callback
+// Not specifying the callback name is only possible in Python.
+#ifdef SWIGPYTHON
%callback(1) foo;
%callback(1) foof;
%callback(1) A::bar;
%callback(1) A::foom;
-%callback("%s_Cb_Ptr") foo_T; // old style, still works.
+#else
+%callback("%s") foo;
+%callback("%s") foof;
+%callback("%s") A::bar;
+%callback("%s") A::foom;
+#endif
+%callback("%(uppercase)s_Cb_Ptr") foo_T; // this works in Python too
%inline %{
return pf(a);
}
+#if defined(__SUNPRO_CC)
+// workaround for: Error: Could not find a match for foobar_T<T>(int, extern "C" int(*)(int)).
+ extern "C" {
+ typedef int (*foobar_int_int)(int a);
+ typedef double (*foobar_double_double)(double a);
+ };
+ template <class T>
+ int foobar_T(int a, foobar_int_int pf) {
+ return pf(a);
+ }
+ template <class T>
+ double foobar_T(double a, foobar_double_double pf) {
+ return pf(a);
+ }
+#endif
+
template <class T>
const T& ident(const T& x) {
return x;
LANGUAGE = cffi
CFFI = @CFFIBIN@
SCRIPTSUFFIX = _runme.lisp
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
# Overridden variables here
# no C++ tests for now
CPP_TEST_CASES =
-#C_TEST_CASES +=
+#C_TEST_CASES +=
# Custom tests - tests with additional commandline options
# none!
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.lisp appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(CFFI) -batch -s $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(CFFI) -batch -s $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
# Clean: (does nothing, we dont generate extra cffi code)
%.clean:
-
+ @exit 0
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile cffi_clean
-
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' cffi_clean
%module char_binary
%apply (char *STRING, size_t LENGTH) { (const char *str, size_t len) }
+%apply (char *STRING, size_t LENGTH) { (const unsigned char *str, size_t len) }
%inline %{
struct Test {
size_t strlen(const char *str, size_t len) {
return len;
}
+ size_t ustrlen(const unsigned char *str, size_t len) {
+ return len;
+ }
};
typedef char namet[5];
#define ESC_CONST '\1'
#define NULL_CONST '\0'
#define SPECIALCHAR 'á'
+#define SPECIALCHAR2 '\n'
+#define SPECIALCHARA 'A'
+#define SPECIALCHARB '\102' // B
+#define SPECIALCHARC '\x43' // C
+#define SPECIALCHARD 0x44 // D
+#define SPECIALCHARE 69 // E
+#define SPECIALCHARAE1 'Æ' // AE (latin1 encoded)
+#define SPECIALCHARAE2 '\306' // AE (latin1 encoded)
+#define SPECIALCHARAE3 '\xC6' // AE (latin1 encoded)
+
+#if defined(SWIGJAVA)
+%javaconst(1);
+#elif SWIGCSHARP
+%csconst(1);
+#elif SWIGD
+%dmanifestconst;
+#endif
+
+#define X_ESC_CONST '\1'
+#define X_NULL_CONST '\0'
+#define X_SPECIALCHAR 'á'
+#define X_SPECIALCHAR2 '\n'
+#define X_SPECIALCHARA 'A'
+#define X_SPECIALCHARB '\102' // B
+#define X_SPECIALCHARC '\x43' // C
+#define X_SPECIALCHARD 0x44 // D
+#define X_SPECIALCHARE 69 // E
+#define X_SPECIALCHARAE1 'Æ' // AE (latin1 encoded)
+#define X_SPECIALCHARAE2 '\306' // AE (latin1 encoded)
+#define X_SPECIALCHARAE3 '\xC6' // AE (latin1 encoded)
%inline
{
%warnfilter(SWIGWARN_TYPEMAP_VARIN_UNDEF) global_char_array1; // Unable to set variable of type char[]
%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK_MSG) global_const_char; // Setting a const char * variable may leak memory.
-#ifdef SWIG_ALLEGRO_CL
%{
#include <stdio.h>
-%}
-#endif
-%{
#define OTHERLAND_MSG "Little message from the safe world."
#define CPLUSPLUS_MSG "A message from the deep dark world of C++, where anything is possible."
static char *global_str = NULL;
--- /dev/null
+%module chartest
+
+%inline %{
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Suppress: illegal character encoding in character literal
+#pragma clang diagnostic ignored "-Winvalid-source-encoding"
+#endif
+char printable_global_char = 'a';
+char unprintable_global_char = 0x7F;
+
+char GetPrintableChar() {
+ return 'a';
+}
+
+char GetUnprintableChar() {
+ return 0x7F;
+}
+
+static const char globchar0 = '\0';
+static const char globchar1 = '\1';
+static const char globchar2 = '\n';
+static const char globcharA = 'A';
+static const char globcharB = '\102'; // B
+static const char globcharC = '\x43'; // C
+static const char globcharD = 0x44; // D
+static const char globcharE = 69; // E
+static const char globcharAE1 = 'Æ'; // AE (latin1 encoded)
+static const char globcharAE2 = '\306'; // AE (latin1 encoded)
+static const char globcharAE3 = '\xC6'; // AE (latin1 encoded)
+
+struct CharTestClass {
+ static const char memberchar0 = '\0';
+ static const char memberchar1 = '\1';
+ static const char memberchar2 = '\n';
+ static const char membercharA = 'A';
+ static const char membercharB = '\102'; // B
+ static const char membercharC = '\x43'; // C
+ static const char membercharD = 0x44; // D
+ static const char membercharE = 69; // E
+ static const char membercharAE1 = 'Æ'; // AE (latin1 encoded)
+ static const char membercharAE2 = '\306'; // AE (latin1 encoded)
+ static const char membercharAE3 = '\xC6'; // AE (latin1 encoded)
+};
+%}
+
+#if defined(SWIGJAVA)
+%javaconst(1);
+#elif SWIGCSHARP
+%csconst(1);
+#elif SWIGD
+%dmanifestconst;
+#endif
+
+%inline %{
+static const char x_globchar0 = '\0';
+static const char x_globchar1 = '\1';
+static const char x_globchar2 = '\n';
+static const char x_globcharA = 'A';
+static const char x_globcharB = '\102'; // B
+static const char x_globcharC = '\x43'; // C
+static const char x_globcharD = 0x44; // D
+static const char x_globcharE = 69; // E
+static const char x_globcharAE1 = 'Æ'; // AE (latin1 encoded)
+static const char x_globcharAE2 = '\306'; // AE (latin1 encoded)
+static const char x_globcharAE3 = '\xC6'; // AE (latin1 encoded)
+
+struct X_CharTestClass {
+ static const char memberchar0 = '\0';
+ static const char memberchar1 = '\1';
+ static const char memberchar2 = '\n';
+ static const char membercharA = 'A';
+ static const char membercharB = '\102'; // B
+ static const char membercharC = '\x43'; // C
+ static const char membercharD = 0x44; // D
+ static const char membercharE = 69; // E
+ static const char membercharAE1 = 'Æ'; // AE (latin1 encoded)
+ static const char membercharAE2 = '\306'; // AE (latin1 encoded)
+ static const char membercharAE3 = '\xC6'; // AE (latin1 encoded)
+};
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+%}
#######################################################################
LANGUAGE = chicken
-VARIANT =
+VARIANT =
SCRIPTSUFFIX = _runme.ss
PROXYSUFFIX = _runme_proxy.ss
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
+
CHICKEN_CSI = @CHICKEN_CSI@ -quiet -batch -no-init
SO = @SO@
# Skip the STD cases for now, except for li_std_string.i
SKIP_CPP_STD_CASES = Yes
-CPP_TEST_CASES += li_std_string
+CPP_TEST_CASES += li_std_string
EXTRA_TEST_CASES += chicken_ext_test.externaltest
%.multiproxy: SCRIPTSUFFIX = $(PROXYSUFFIX)
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(PROXYSUFFIX) ]; then \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(PROXYSUFFIX) ]; then \
$(MAKE) $*.cppproxy; \
fi
$(setup)
+$(swig_and_compile_c)
$(run_testcase)
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(PROXYSUFFIX) ]; then \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(PROXYSUFFIX) ]; then \
$(MAKE) $*.cproxy; \
fi
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(PROXYSUFFIX) ]; then \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(PROXYSUFFIX) ]; then \
$(MAKE) $*.multiproxy; \
fi
$(run_testcase)
%.cppproxy:
- echo "$(ACTION)ing testcase $* (with run test) under chicken with -proxy"
+ echo "$(ACTION)ing $(LANGUAGE) testcase $* (with run test) with -proxy"
+$(swig_and_compile_cpp)
$(run_testcase)
%.cproxy:
- echo "$(ACTION)ing testcase $* (with run test) under chicken with -proxy"
+ echo "$(ACTION)ing $(LANGUAGE) testcase $* (with run test) with -proxy"
+$(swig_and_compile_c)
$(run_testcase)
%.multiproxy:
- echo "$(ACTION)ing testcase $* (with run test) under chicken with -proxy"
+ echo "$(ACTION)ing $(LANGUAGE) testcase $* (with run test) with -proxy"
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.scm appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(CHICKEN_CSI) $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(CHICKEN_CSI) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
# Clean
%.clean:
-
+ @exit 0
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile chicken_clean
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' chicken_clean
rm -f *.scm
--- /dev/null
+(load "overload_extend_c.so")
+(include "../schemerunme/overload_extend_c.scm")
LANGUAGE = clisp
CLISP = @CLISPBIN@
SCRIPTSUFFIX = _runme.lisp
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
# Overridden variables here
# no C++ tests for now
CPP_TEST_CASES =
-#C_TEST_CASES +=
+#C_TEST_CASES +=
# Custom tests - tests with additional commandline options
# none!
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.lisp appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(CLISP) -batch -s $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(CLISP) -batch -s $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
# Clean: (does nothing, we dont generate extra clisp code)
%.clean:
-
+ @exit 0
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile clisp_clean
-
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' clisp_clean
# can be used for memory checking of the runtime tests using:
# make RUNTOOL="valgrind --leak-check=full"
# and valgrind can be used when invoking SWIG using:
-# make SWIGTOOL="valgrind --tool=memcheck --trace-children=yes"
-# Note: trace-children needed because of preinst-swig shell wrapper
-# to the swig executable.
+# make SWIGTOOL="valgrind --tool=memcheck"
#
# An individual test run can be debugged easily:
# make director_string.cpptest RUNTOOL="gdb --args"
COMPILETOOL=
SWIGTOOL =
-SWIG = $(SWIGTOOL) $(top_builddir)/preinst-swig
-SWIG_LIB = $(top_srcdir)/Lib
+SWIGEXE = $(top_builddir)/swig
+SWIG_LIB_DIR = $(top_srcdir)/Lib
TEST_SUITE = test-suite
EXAMPLES = Examples
CXXSRCS =
LIBS = -L.
LIBPREFIX = lib
ACTION = check
-INTERFACEDIR = $(top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)/
+INTERFACEDIR = ../
+SRCDIR = $(srcdir)/
+SCRIPTDIR = $(srcdir)
+
+# Regenerate Makefile if Makefile.in or config.status have changed.
+Makefile: $(srcdir)/Makefile.in ../../../config.status
+ cd ../../../ && $(SHELL) ./config.status $(EXAMPLES)/$(TEST_SUITE)/$(LANGUAGE)/Makefile
#
# Please keep test cases in alphabetical order.
CPP_TEST_BROKEN += \
constants \
cpp_broken \
+ director_nested_class \
exception_partial_info \
extend_variable \
li_std_vector_ptr \
li_boost_shared_ptr_template \
+ nested_private \
overload_complicated \
+ rename_camel \
template_default_pointer \
- template_expr
+ template_private_assignment \
+ template_expr \
+ $(CPP11_TEST_BROKEN)
# Broken C test cases. (Can be run individually using: make testcase.ctest)
C_TEST_BROKEN += \
tag_no_clash_with_variable
-
# C++ test cases. (Can be run individually using: make testcase.cpptest)
CPP_TEST_CASES += \
abstract_access \
casts \
char_binary \
char_strings \
+ chartest \
class_forward \
class_ignore \
class_scope_weird \
compactdefaultargs \
const_const_2 \
+ constant_directive \
constant_pointers \
constover \
constructor_copy \
conversion \
conversion_namespace \
conversion_ns_template \
+ conversion_operators \
cplusplus_throw \
cpp_basic \
cpp_enum \
director_ignore \
director_keywords \
director_namespace_clash \
+ director_nested \
director_nspace \
director_nspace_director_name_collision \
- director_nested \
director_overload \
director_overload2 \
+ director_pass_by_value \
director_primitives \
+ director_property \
director_protected \
director_protected_overloaded \
director_redefined \
+ director_ref \
director_smartptr \
director_thread \
director_unroll \
disown \
dynamic_cast \
empty \
+ enum_ignore \
+ enum_plus \
enum_rename \
enum_scope_template \
enum_template \
enum_thorough \
enum_var \
+ equality \
evil_diamond \
evil_diamond_ns \
evil_diamond_prop \
+ exception_classname \
exception_order \
extend \
extend_constructor_destructor \
features \
fragments \
friends \
+ friends_template \
funcptr_cpp \
fvirtual \
global_namespace \
ignore_parameter \
import_nomodule \
inherit \
+ inherit_member \
inherit_missing \
inherit_same_name \
inherit_target_language \
insert_directive \
keyword_rename \
kind \
+ kwargs_feature \
langobj \
li_attribute \
li_attribute_template \
+ li_boost_array \
li_boost_shared_ptr \
li_boost_shared_ptr_bits \
li_boost_shared_ptr_template \
- li_carrays \
- li_cdata \
- li_cpointer \
+ li_boost_shared_ptr_attribute \
+ li_carrays_cpp \
+ li_cdata_cpp \
+ li_cpointer_cpp \
+ li_std_auto_ptr \
li_stdint \
+ li_swigtype_inout \
li_typemaps \
li_typemaps_apply \
li_windows \
minherit2 \
mixed_types \
multiple_inheritance \
+ multiple_inheritance_abstract \
+ multiple_inheritance_interfaces \
+ multiple_inheritance_nspace \
+ multiple_inheritance_shared_ptr \
name_cxx \
name_warnings \
namespace_class \
nspace \
nspace_extend \
naturalvar \
+ naturalvar_more \
+ naturalvar_onoff \
nested_class \
+ nested_directors \
nested_comment \
+ nested_scope \
+ nested_template_base \
nested_workaround \
newobject1 \
null_pointer \
operator_pointer_ref \
operbool \
ordering \
+ overload_arrays \
+ overload_bool \
overload_copy \
overload_extend \
overload_method \
overload_numeric \
+ overload_polymorphic \
overload_rename \
overload_return_type \
overload_simple \
rename2 \
rename3 \
rename4 \
+ rename_rstrip_encoder \
rename_scope \
rename_simple \
rename_strip_encoder \
rename_pcre_encoder \
rename_pcre_enum \
+ rename_predicates \
restrict_cplusplus \
return_const_value \
return_value_scope \
smart_pointer_const2 \
smart_pointer_const_overload \
smart_pointer_extend \
+ smart_pointer_ignore \
smart_pointer_member \
smart_pointer_multi \
smart_pointer_multi_typedef \
smart_pointer_simple \
smart_pointer_static \
smart_pointer_template_const_overload \
+ smart_pointer_template_defaults_overload \
smart_pointer_templatemethods \
smart_pointer_templatevariables \
smart_pointer_typedef \
special_variables \
+ special_variable_attributes \
special_variable_macros \
static_array_member \
static_const_member \
static_const_member_2 \
+ string_constants \
struct_initialization_cpp \
struct_value \
symbol_clash \
template_classes \
template_const_ref \
template_construct \
+ template_templated_constructors \
template_default \
template_default2 \
template_default_arg \
+ template_default_arg_overloaded \
+ template_default_arg_overloaded_extend \
template_default_arg_virtual_destructor \
template_default_class_parms \
template_default_class_parms_typedef \
template_inherit \
template_inherit_abstract \
template_int_const \
+ template_keyword_in_type \
template_methods \
template_namespace_forward_declaration \
template_using_directive_and_declaration_forward \
template_partial_specialization \
template_partial_specialization_typedef \
template_qualifier \
- template_qualifier \
template_ref_type \
template_rename \
template_retvalue \
template_typedef_ns \
template_typedef_ptr \
template_typedef_rec \
+ template_typedef_typedef \
template_typemaps \
template_typemaps_typedef \
template_typemaps_typedef2 \
typedef_reference \
typedef_scope \
typedef_sizet \
- typedef_struct \
+ typedef_struct_cpp \
+ typedef_typedef \
typemap_arrays \
typemap_array_qualifiers \
typemap_delete \
typemap_various \
typename \
types_directive \
+ unicode_strings \
union_scope \
using1 \
using2 \
wallkw \
wrapmacro
+# C++11 test cases.
+CPP11_TEST_CASES = \
+ cpp11_alignment \
+ cpp11_alternate_function_syntax \
+ cpp11_constexpr \
+ cpp11_decltype \
+ cpp11_default_delete \
+ cpp11_delegating_constructors \
+ cpp11_director_enums \
+ cpp11_explicit_conversion_operators \
+ cpp11_final_override \
+ cpp11_function_objects \
+ cpp11_inheriting_constructors \
+ cpp11_initializer_list \
+ cpp11_initializer_list_extend \
+ cpp11_lambda_functions \
+ cpp11_li_std_array \
+ cpp11_noexcept \
+ cpp11_null_pointer_constant \
+ cpp11_raw_string_literals \
+ cpp11_result_of \
+ cpp11_rvalue_reference \
+ cpp11_rvalue_reference2 \
+ cpp11_rvalue_reference3 \
+ cpp11_sizeof_object \
+ cpp11_static_assert \
+ cpp11_strongly_typed_enumerations \
+ cpp11_thread_local \
+ cpp11_template_double_brackets \
+ cpp11_template_explicit \
+ cpp11_template_typedefs \
+ cpp11_type_traits \
+ cpp11_type_aliasing \
+ cpp11_uniform_initialization \
+ cpp11_unrestricted_unions \
+ cpp11_userdefined_literals \
+
+# Broken C++11 test cases.
+CPP11_TEST_BROKEN = \
+# cpp11_hash_tables \ # not fully implemented yet
+# cpp11_variadic_templates \ # Broken for some languages (such as Java)
+# cpp11_reference_wrapper \ # No typemaps
+
+
#
# Put all the heavy STD/STL cases here, where they can be skipped if needed
#
li_std_vector \
li_std_vector_enum \
li_std_vector_member_var\
- naturalvar \
smart_pointer_inherit \
template_typedef_fnc \
template_type_namespace \
CPP_TEST_CASES += ${CPP_STD_TEST_CASES}
endif
+ifneq (,$(HAVE_CXX11_COMPILER))
+CPP_TEST_CASES += $(CPP11_TEST_CASES)
+endif
# C test cases. (Can be run individually using: make testcase.ctest)
C_TEST_CASES += \
arrays \
bom_utf8 \
+ c_delete \
+ c_delete_function \
char_constant \
const_const \
constant_expr \
- empty \
+ empty_c \
enums \
enum_forward \
enum_macro \
+ enum_missing \
extern_declaration \
funcptr \
function_typedef \
+ global_functions \
immutable_values \
inctest \
+ infinity \
integers \
- keyword_rename \
+ keyword_rename_c \
lextype \
li_carrays \
li_cdata \
memberin_extend_c \
name \
nested \
+ nested_extend_c \
nested_structs \
newobject2 \
- overload_extend \
- overload_extendc \
+ overload_extend_c \
+ overload_extend2 \
preproc \
preproc_constants_c \
preproc_defined \
simple_array \
sizeof_pointer \
sneaky1 \
+ string_simple \
struct_rename \
struct_initialization \
typedef_struct \
wallkw.cpptest: SWIGOPT += -Wallkw
preproc_include.ctest: SWIGOPT += -includeall
+# Allow modules to define temporarily failing tests.
+C_TEST_CASES := $(filter-out $(FAILING_C_TESTS),$(C_TEST_CASES))
+CPP_TEST_CASES := $(filter-out $(FAILING_CPP_TESTS),$(CPP_TEST_CASES))
+MULTI_CPP_TEST_CASES := $(filter-out $(FAILING_MULTI_CPP_TESTS),$(MULTI_CPP_TEST_CASES))
+
NOT_BROKEN_TEST_CASES = $(CPP_TEST_CASES:=.cpptest) \
$(C_TEST_CASES:=.ctest) \
$(C_TEST_BROKEN:=.clean)
#######################################################################
+# Error test suite has its own set of test cases
+#######################################################################
+ifneq (,$(ERROR_TEST_CASES))
+check: $(ERROR_TEST_CASES)
+else
+
+#######################################################################
# The following applies for all module languages
#######################################################################
-all: $(BROKEN_TEST_CASES) $(NOT_BROKEN_TEST_CASES)
+all: $(NOT_BROKEN_TEST_CASES) $(BROKEN_TEST_CASES)
+
+broken: $(BROKEN_TEST_CASES)
+
+check: $(NOT_BROKEN_TEST_CASES)
+ @echo $(words $^) $(LANGUAGE) tests passed
-check: $(NOT_BROKEN_TEST_CASES)
+check-c: $(C_TEST_CASES:=.ctest)
+
+check-cpp: $(CPP_TEST_CASES:=.cpptest)
+
+check-cpp11: $(CPP11_TEST_CASES:=.cpptest)
+
+check-failing-test = \
+ $(MAKE) -s $1.$2 >/dev/null 2>/dev/null && echo "Failing test $1 passed."
+
+check-failing:
+ +-$(foreach t,$(FAILING_C_TESTS),$(call check-failing-test,$t,ctest);)
+ +-$(foreach t,$(FAILING_CPP_TESTS),$(call check-failing-test,$t,cpptest);)
+ +-$(foreach t,$(FAILING_MULTI_CPP_TESTS),$(call check-failing-test,$t,multicpptest);)
+endif
# partialcheck target runs SWIG only, ie no compilation or running of tests (for a subset of languages)
partialcheck:
$(MAKE) check CC=true CXX=true LDSHARED=true CXXSHARED=true RUNTOOL=true COMPILETOOL=true
-broken: $(BROKEN_TEST_CASES)
-
swig_and_compile_cpp = \
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile CXXSRCS="$(CXXSRCS)" \
- SWIG_LIB="$(SWIG_LIB)" SWIG="$(SWIG)" \
- INCLUDES="$(INCLUDES)" SWIGOPT="$(SWIGOPT)" NOLINK=true \
- TARGET="$(TARGETPREFIX)$*$(TARGETSUFFIX)" INTERFACEDIR="$(INTERFACEDIR)" INTERFACE="$*.i" \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ INCLUDES='$(INCLUDES)' SWIGOPT='$(SWIGOPT)' NOLINK=true \
+ TARGET='$(TARGETPREFIX)$*$(TARGETSUFFIX)' INTERFACEDIR='$(INTERFACEDIR)' INTERFACE='$*.i' \
$(LANGUAGE)$(VARIANT)_cpp
swig_and_compile_c = \
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile CSRCS="$(CSRCS)" \
- SWIG_LIB="$(SWIG_LIB)" SWIG="$(SWIG)" \
- INCLUDES="$(INCLUDES)" SWIGOPT="$(SWIGOPT)" NOLINK=true \
- TARGET="$(TARGETPREFIX)$*$(TARGETSUFFIX)" INTERFACEDIR="$(INTERFACEDIR)" INTERFACE="$*.i" \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' CSRCS='$(CSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ INCLUDES='$(INCLUDES)' SWIGOPT='$(SWIGOPT)' NOLINK=true \
+ TARGET='$(TARGETPREFIX)$*$(TARGETSUFFIX)' INTERFACEDIR='$(INTERFACEDIR)' INTERFACE='$*.i' \
$(LANGUAGE)$(VARIANT)
swig_and_compile_multi_cpp = \
for f in `cat $(top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)/$*.list` ; do \
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile CXXSRCS="$(CXXSRCS)" \
- SWIG_LIB="$(SWIG_LIB)" SWIG="$(SWIG)" LIBS='$(LIBS)' \
- INCLUDES="$(INCLUDES)" SWIGOPT="$(SWIGOPT)" NOLINK=true \
- TARGET="$(TARGETPREFIX)$${f}$(TARGETSUFFIX)" INTERFACEDIR="$(INTERFACEDIR)" INTERFACE="$$f.i" \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ LIBS='$(LIBS)' INCLUDES='$(INCLUDES)' SWIGOPT='$(SWIGOPT)' NOLINK=true \
+ TARGET="$(TARGETPREFIX)$${f}$(TARGETSUFFIX)" INTERFACEDIR='$(INTERFACEDIR)' INTERFACE="$$f.i" \
$(LANGUAGE)$(VARIANT)_cpp; \
done
swig_and_compile_external = \
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile \
- SWIG_LIB="$(SWIG_LIB)" SWIG="$(SWIG)" \
- TARGET="$*_wrap_hdr.h" \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ TARGET='$*_wrap_hdr.h' \
$(LANGUAGE)$(VARIANT)_externalhdr; \
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile CXXSRCS="$(CXXSRCS) $*_external.cxx" \
- SWIG_LIB="$(SWIG_LIB)" SWIG="$(SWIG)" \
- INCLUDES="$(INCLUDES)" SWIGOPT="$(SWIGOPT)" NOLINK=true \
- TARGET="$(TARGETPREFIX)$*$(TARGETSUFFIX)" INTERFACEDIR="$(INTERFACEDIR)" INTERFACE="$*.i" \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS) $*_external.cxx' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ INCLUDES='$(INCLUDES)' SWIGOPT='$(SWIGOPT)' NOLINK=true \
+ TARGET='$(TARGETPREFIX)$*$(TARGETSUFFIX)' INTERFACEDIR='$(INTERFACEDIR)' INTERFACE='$*.i' \
$(LANGUAGE)$(VARIANT)_cpp
swig_and_compile_runtime = \
setup = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- echo "$(ACTION)ing testcase $* (with run test) under $(LANGUAGE)" ; \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ echo "$(ACTION)ing $(LANGUAGE) testcase $* (with run test)" ; \
else \
- echo "$(ACTION)ing testcase $* under $(LANGUAGE)" ; \
+ echo "$(ACTION)ing $(LANGUAGE) testcase $*" ; \
fi;
static const double PUBLIC_DEFAULT;
Defaults2(int a = PRIVATE_DEFAULT) {}
double ret(double d = PUBLIC_DEFAULT) { return d; }
+ double nodefault(int x) { return x; }
};
%}
--- /dev/null
+%module constant_directive
+
+// %constant and struct
+
+%inline %{
+#if defined(_MSC_VER)
+ #pragma warning(disable : 4190) // warning C4190: 'result' has C-linkage specified, but returns UDT 'Type1' which is incompatible with C
+#endif
+struct Type1 {
+ Type1(int val = 0) : val(val) {}
+ int val;
+};
+/* Typedefs for const Type and its pointer */
+typedef const Type1 Type1Const;
+typedef const Type1* Type1Cptr;
+
+/* Typedefs for function pointers returning Type1 */
+typedef Type1 (*Type1Fptr)();
+typedef Type1 (* const Type1Cfptr)();
+
+/* Function returning an instance of Type1 */
+Type1 getType1Instance() { return Type1(111); }
+%}
+
+%{
+ static Type1 TYPE1_CONSTANT1(1);
+ static Type1 TYPE1_CONST2(2);
+ static Type1 TYPE1_CONST3(3);
+%}
+
+%constant Type1 TYPE1_CONSTANT1;
+%constant Type1 TYPE1_CONSTANT2 = TYPE1_CONST2;
+%constant Type1 *TYPE1_CONSTANT3 = &TYPE1_CONST3;
+/* Typedef'ed types */
+%constant Type1Const* TYPE1CONST_CONSTANT1 = &TYPE1_CONSTANT1;
+%constant Type1Cptr TYPE1CPTR_CONSTANT1 = &TYPE1_CONSTANT1;
+/* Function pointers */
+%constant Type1 (*TYPE1FPTR1_CONSTANT1)() = getType1Instance;
+%constant Type1 (* const TYPE1CFPTR1_CONSTANT1)() = getType1Instance;
+/* Typedef'ed function pointers */
+%constant Type1Fptr TYPE1FPTR1DEF_CONSTANT1 = getType1Instance;
+%constant Type1Cfptr TYPE1CFPTR1DEF_CONSTANT1 = getType1Instance;
+/* Regular constant */
+%constant int TYPE_INT = 0;
%module constant_pointers
+#if defined(SWIGSCILAB)
+%rename(MbrVar) MemberVariablesTest;
+%rename(RetVal) ReturnValuesTest;
+#endif
+
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK); /* memory leak when setting a ptr/ref variable */
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG); /* Setting a pointer/reference variable may leak memory. */
%nocopyctor Bar<double>;
%inline %{
-
+
struct Foo1 {
int x;
Foo1(int _x = 2) : x(_x)
{
- }
+ }
};
struct Foo2 {
struct Foo4 {
Foo4() { }
-
+
protected:
Foo4(const Foo4& ) { }
};
struct Foo4a {
Foo4a() { }
-
+
private:
Foo4a(const Foo4a& ) { }
};
};
template <class T>
-class Bar
+class Bar
{
public:
int x;
%include "std_vector.i"
-#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGR) || defined(SWIGOCTAVE) || defined(SWIGRUBY)
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGR) || defined(SWIGOCTAVE) || defined(SWIGRUBY) || defined(SWIGJAVASCRIPT) || defined(SWIGSCILAB)
#define SWIG_GOOD_VECTOR
%ignore std::vector<Space::Flow>::vector(size_type);
%ignore std::vector<Space::Flow>::resize(size_type);
namespace Space {
class Flow {
+int x;
public:
- Flow(int i) {}
+ Flow(int i) : x(i) {}
};
class FlowFlow {
+int x;
public:
- FlowFlow(int i) {}
+ FlowFlow(int i) : x(i) {}
};
}
template <class T>
struct ModelUtils_T {};
- }
+ }
}
%}
class TotalReturnSwap {
public:
TotalReturnSwap() {}
- };
+ };
template <class T>
class TotalReturnSwap_T {
public:
TotalReturnSwap_T() {}
- };
+ };
}
}
%module constructor_exception
%inline %{
-class Error {
+class MyError {
};
class SomeClass {
public:
SomeClass(int x) {
if (x < 0) {
- throw Error();
+ throw MyError();
}
}
};
SomeClass o;
public:
Test(int x) try : o(x) { }
- catch (Error &) {
+ catch (MyError &) {
}
catch (int) {
}
Bar(){ }
Bar(int){ }
+#if !defined(__SUNPRO_CC)
operator int() { return 0; }
+#endif
operator int&() { static int num = 0; return num; }
+#if !defined(__SUNPRO_CC)
operator Foo<T>() { return Foo<T>(); }
+#endif
operator Foo<T>&() { return *(new Foo<T>()); }
};
}
--- /dev/null
+%module conversion_operators
+
+// Test bug #401 where the conversion operator name incorrectly included the newline character
+// Also test comments around conversion operators due to special handling in the scanner for conversion operators
+
+// These one line ignores should match the conversion operator names to suppress Warning 503 - SWIGWARN_LANG_IDENTIFIER
+%ignore operator const EcReal;
+%ignore operator EcImaginary const;
+%ignore operator EcComplex const;
+
+%inline %{
+
+struct EcReal {};
+struct EcImaginary {};
+struct EcComplex {};
+
+struct EcAngle {
+ operator const EcReal
+ (
+ ) const;
+ operator EcImaginary
+const (
+ ) const;
+ operator
+EcComplex
+ const (
+ ) const;
+};
+
+struct EcAngle2 {
+ operator const EcReal/* C comment */
+ (
+ ) const;
+ operator EcImaginary/* C comment */
+const (
+ ) const;
+ operator/* C comment */
+EcComplex
+ const (
+ ) const;
+};
+
+struct EcAngle3 {
+ operator const EcReal // C++ comment
+ (
+ ) const;
+ operator EcImaginary // C++ comment
+const (
+ ) const;
+ operator // C++ comment
+EcComplex
+ const (
+ ) const;
+};
+%}
--- /dev/null
+%module cpp11_alignment
+
+%inline %{
+struct A {
+ int member;
+};
+const int align1 = alignof(A::member);
+%}
+
+%{
+// alignas - not yet working
+struct alignas(16) S {
+ int num;
+};
+alignas(double) unsigned char c[sizeof(double)];
+%}
--- /dev/null
+/* This testcase checks whether SWIG correctly uses the new alternate functions
+ declarations and definitions introduced in C++11. */
+%module cpp11_alternate_function_syntax
+
+%inline %{
+struct SomeStruct {
+ int addNormal(int x, int y);
+ auto addAlternate(int x, int y) -> int;
+};
+
+auto SomeStruct::addAlternate(int x, int y) -> int {
+ return x + y;
+}
+
+int SomeStruct::addNormal(int x, int y) {
+ return x + y;
+}
+%}
--- /dev/null
+/* This interface tests whether SWIG supports the new "constexpr" keyword
+ introduced by C++11.
+*/
+%module cpp11_constexpr
+
+%inline %{
+constexpr int AAA = 10;
+constexpr const int BBB = 20;
+constexpr int CCC() { return 30; }
+constexpr const int DDD() { return 40; }
+
+constexpr int XXX() { return 10; }
+constexpr int YYY = XXX() + 100;
+
+struct ConstExpressions {
+ static constexpr const int JJJ = 100;
+ static constexpr int KKK = 200;
+ static const int LLL = 300;
+ constexpr int MMM() { return 400; }
+ constexpr const int NNN() { return 500; }
+ // Regression tests for support added in SWIG 3.0.4:
+ static constexpr const int JJJ1 = 101;
+ constexpr static int KKK1 = 201;
+ // Regression tests for https://github.com/swig/swig/issues/284 :
+ explicit constexpr ConstExpressions(int) { }
+ constexpr explicit ConstExpressions(double) { }
+};
+%}
+
+%{
+int Array10[AAA];
+int Array20[BBB];
+int Array30[CCC()];
+int Array40[DDD()];
+int Array100[ConstExpressions::JJJ];
+int Array200[ConstExpressions::KKK];
+int Array300[ConstExpressions::LLL];
+//int Array400[ConstExpressions::MMM()];
+//int Array500[ConstExpressions::NNN()];
+%}
--- /dev/null
+/* This testcase checks whether SWIG correctly uses the new 'decltype()'
+ introduced in C++11.
+*/
+%module cpp11_decltype
+
+%inline %{
+ class A {
+ public:
+ int i;
+ decltype(i) j;
+
+ auto foo( decltype(i) a ) -> decltype(i) {
+ if (a==5)
+ return 10;
+ else
+ return 0;
+ }
+ };
+ %}
--- /dev/null
+/* This testcase checks whether SWIG correctly parses C++11 explicitly defaulted functions and deleted functions */
+%module cpp11_default_delete
+
+%warnfilter(SWIGWARN_LANG_OVERLOAD_IGNORED, SWIGWARN_LANG_OVERLOAD_SHADOW) trivial::trivial(trivial&&);
+%warnfilter(SWIGWARN_LANG_OVERLOAD_IGNORED, SWIGWARN_LANG_OVERLOAD_SHADOW) trivial::operator =(trivial&&);
+
+%rename(Assignment) *::operator=;
+
+%inline %{
+
+class NonCopyable {
+public:
+ NonCopyable& operator=(const NonCopyable&) = delete; /* Removes operator= */
+ NonCopyable(const NonCopyable&) = delete; /* Removed copy constructor */
+ NonCopyable() = default; /* Explicitly allows the empty constructor */
+ void *operator new(size_t) = delete; /* Removes new NonCopyable */
+};
+
+struct A1 {
+ void func(int i) {}
+ A1() = default;
+ ~A1() = default;
+ void func(double i) = delete; /* Don't cast double to int. Compiler returns an error */
+private:
+ A1(const A1&);
+};
+A1::A1(const A1&) = default;
+
+struct A2 {
+ void func(int i) {}
+ virtual void fff(int) = delete;
+ virtual ~A2() = default;
+ template<class T> void func(T) = delete;
+};
+
+struct trivial {
+ trivial() = default;
+ trivial(const trivial&) = default;
+ trivial(trivial&&) = default;
+ trivial& operator=(const trivial&) = default;
+ trivial& operator=(trivial&&) = default;
+ ~trivial() = default;
+};
+
+struct nontrivial1 {
+ nontrivial1();
+};
+nontrivial1::nontrivial1() = default;
+
+struct sometype {
+ sometype() = delete;
+ sometype(int) = delete;
+ sometype(double);
+};
+sometype::sometype(double) {}
+
+/* Not working with prerelease of gcc-4.8
+struct nonew {
+ void *operator new(std::size_t) = delete;
+ void *operator new[](std::size_t) = delete;
+};
+*/
+
+struct moveonly {
+ moveonly() = default;
+ moveonly(const moveonly&) = delete;
+ moveonly(moveonly&&) = default;
+ moveonly& operator=(const moveonly&) = delete;
+ moveonly& operator=(moveonly&&) = default;
+ ~moveonly() = default;
+};
+
+struct ConstructorThrow {
+ ConstructorThrow() throw() = default;
+ ConstructorThrow(const ConstructorThrow&) throw() = delete;
+ ConstructorThrow(ConstructorThrow&&) throw() = delete;
+ ConstructorThrow& operator=(const ConstructorThrow&) throw() = delete;
+ ~ConstructorThrow() throw() = default;
+};
+
+%}
--- /dev/null
+/* This test checks whether SWIG correctly parses the new delegating
+ constructors.
+*/
+%module cpp11_delegating_constructors
+
+%inline %{
+class A {
+public:
+ int a;
+ int b;
+ int c;
+
+ A() : A( 10 ) {}
+ A(int aa) : A(aa, 20) {}
+ A(int aa, int bb) : A(aa, bb, 30) {}
+ A(int aa, int bb, int cc) { a=aa; b=bb; c=cc; }
+};
+%}
--- /dev/null
+%module(directors="1") cpp11_director_enums
+
+%warnfilter(SWIGWARN_TYPEMAP_THREAD_UNSAFE,SWIGWARN_TYPEMAP_DIRECTOROUT_PTR) Cpp11DirectorEnumsCallback::g;
+
+%director Cpp11DirectorEnumsCallback;
+
+%inline %{
+enum class Color { Red, Green, Blue=10 };
+struct Cpp11DirectorEnumsCallback {
+ virtual Color f(Color c) = 0;
+ virtual const Color & g(const Color &c) = 0;
+ virtual ~Cpp11DirectorEnumsCallback() {}
+};
+%}
--- /dev/null
+/* This interface checks whether SWIG correctly compiles the new
+ explicit conversion operators feature introduced in C++11.
+*/
+%module cpp11_explicit_conversion_operators
+
+%warnfilter(SWIGWARN_LANG_IDENTIFIER) Testable::operator bool;
+%rename(AsInteger) Testable::operator int;
+
+%inline %{
+
+class U {
+public:
+ int u;
+};
+
+class V {
+public:
+ int v;
+};
+
+class TestClass {
+public:
+ //implicit converting constructor
+ TestClass( U const &val ) { t=val.u; }
+ // explicit constructor
+ explicit TestClass( V const &val ) { t=val.v; }
+
+ int t;
+};
+
+struct Testable {
+ // explicit conversion operator
+ explicit operator bool() const {
+ return false;
+ }
+ explicit operator int() {
+ return 42;
+ }
+};
+%}
+
--- /dev/null
+// Test C++11 virtual specifier sequences (final and/or override on methods)
+// Also check final/override - the two 'identifiers with special meaning' work as normal identifiers
+
+%module cpp11_final_override
+
+%warnfilter(SWIGWARN_PARSE_KEYWORD) final; // 'final' is a java keyword, renaming to '_final'
+%warnfilter(SWIGWARN_PARSE_KEYWORD) override; // 'override' is a C# keyword, renaming to '_override'
+
+%inline %{
+
+struct Base {
+ virtual void stuff() const {}
+ virtual void override1() const {}
+ virtual void override2() const {}
+ virtual void finaloverride1() {}
+ virtual void finaloverride2() {}
+ virtual void finaloverride3() {}
+ virtual void finaloverride4() const {}
+ virtual ~Base() {}
+};
+
+struct Derived /*final*/ : Base {
+ virtual void stuff() const noexcept override final {}
+ virtual void override1() const noexcept override;
+ virtual void override2() const noexcept override;
+ virtual void final1() final {}
+ virtual void final2() noexcept final {}
+ virtual void final4() const final {}
+ virtual void final5() const noexcept final {}
+ virtual void finaloverride1() final override {}
+ virtual void finaloverride2() override final {}
+ virtual void finaloverride3() noexcept override final {}
+ virtual void finaloverride4() const noexcept override final {}
+ virtual ~Derived() override final {}
+};
+void Derived::override2() const noexcept {}
+
+// Pure virtual methods
+struct PureBase {
+ virtual void pure1(int) const = 0;
+ virtual void pure2(int) const = 0;
+ virtual void pure3(int) const = 0;
+ virtual void pure4(int) const = 0;
+ virtual void pure5(int) const = 0;
+ virtual ~PureBase() {}
+};
+
+struct PureDerived : PureBase {
+ virtual void pure1(int) const override = 0;
+ virtual void pure2(int) const final = 0;
+ virtual void pure3(int) const override final = 0;
+ virtual void pure4(int) const final override = 0;
+ virtual void pure5(int) const noexcept final override = 0;
+ virtual ~PureDerived() override final;
+};
+void PureDerived::pure1(int) const {}
+void PureDerived::pure2(int) const {}
+void PureDerived::pure3(int) const {}
+void PureDerived::pure4(int) const {}
+void PureDerived::pure5(int) const noexcept {}
+PureDerived::~PureDerived() {}
+
+// Destructors and virtual specifier sequences (final/override)
+struct Destructors1 : Base {
+ virtual ~Destructors1() override {}
+};
+struct Destructors2 : Base {
+ virtual ~Destructors2() final {}
+};
+struct Destructors3 : Base {
+ virtual ~Destructors3() noexcept final override {}
+};
+struct Destructors4 : Base {
+ virtual ~Destructors4() noexcept override final {}
+};
+
+// Check the two 'identifiers with special meaning' work as normal identifiers
+struct FinalOverrideMethods {
+ virtual void final() {}
+ virtual void override(int) {}
+};
+struct FinalOverrideVariables {
+ int final;
+ double override;
+};
+void final(int) {}
+void override() {}
+%}
+
+%{
+void Derived::override1() const noexcept {}
+%}
+
+// Example in documentation ... declarations only
+%inline %{
+struct BaseStruct {
+ virtual void ab() const = 0;
+ virtual void cd();
+ virtual void ef();
+ virtual ~BaseStruct();
+};
+struct DerivedStruct : BaseStruct {
+ virtual void ab() const override;
+ virtual void cd() final;
+ virtual void ef() final override;
+ virtual ~DerivedStruct() override;
+};
+struct DerivedNoVirtualStruct : BaseStruct {
+ void ab() const override;
+ void cd() final;
+ void ef() final override;
+ ~DerivedNoVirtualStruct() override;
+};
+%}
+
+%{
+void BaseStruct::cd() {}
+void BaseStruct::ef() {}
+BaseStruct::~BaseStruct() {}
+void DerivedStruct::ab() const {}
+void DerivedStruct::cd() {}
+void DerivedStruct::ef() {}
+DerivedStruct::~DerivedStruct() {}
+void DerivedNoVirtualStruct::ab() const {}
+void DerivedNoVirtualStruct::cd() {}
+void DerivedNoVirtualStruct::ef() {}
+DerivedNoVirtualStruct::~DerivedNoVirtualStruct() {}
+%}
--- /dev/null
+/* This testcase checks whether SWIG correctly parses function objects
+ and the templates for the functions (signature).
+ Function objects are objects which overload the operator() function.
+ The std::function does not provide any seamless support in the target languages yet.
+*/
+%module(directors="1") cpp11_function_objects
+
+%rename(__call__) Test::operator();
+
+%feature("director") Test;
+
+%inline %{
+class Test {
+public:
+ int value;
+
+ virtual void operator()(int x, int y) {
+ value=x+y;
+ }
+ Test() : value(0) {}
+ virtual ~Test() {}
+};
+
+Test test;
+
+#include <functional>
+std::function<void ( int, int )> pF = test;
+
+int testit1(Test &new_test, int a, int b) {
+ pF = std::ref(new_test);
+ pF(a, b);
+ return new_test.value;
+}
+
+int testit2(int a, int b) {
+ test(a, b);
+ return test.value;
+}
+
+%}
+
--- /dev/null
+/* This testcase checks the new wrappers for the new unordered_ STL types
+ introduced in C++11. */
+%module cpp11_hash_tables
+
+%inline %{
+#include <set>
+//#include <map>
+#include <unordered_set>
+//#include <unordered_map>
+%}
+
+%include "std_set.i"
+//%include "std_map.i"
+%include "std_unordered_set.i"
+//%include "std_unordered_map.i"
+%template (SetInt) std::set<int>;
+//%template (MapIntInt) std::map<int, int>;
+%template (UnorderedSetInt) std::unordered_set<int>;
+//%template (UnorderedMapIntInt) std::unordered_map<int, int>;
+
+%inline %{
+using namespace std;
+
+class MyClass {
+public:
+ set<int> getSet() { return _set; }
+ void addSet(int elt) { _set.insert(_set.begin(), elt); }
+// map<int, int> getMap() { return _map; }
+// void addMap(int elt1, int elt2) { _map.insert(make_pair(elt1, elt2)); }
+
+ unordered_set<int> getUnorderedSet() { return _unordered_set; }
+ void addUnorderedSet(int elt) { _unordered_set.insert(_unordered_set.begin(), elt); }
+// unordered_map<int, int> getUnorderedMap() { return _unordered_map; }
+// void addUnorderedMap(int elt1, int elt2) { _unordered_map.insert(make_pair(elt1, elt2)); }
+private:
+ set<int> _set;
+// map<int, int> _map;
+
+ unordered_set<int> _unordered_set;
+// unordered_map<int, int> _unordered_map;
+};
+%}
+
--- /dev/null
+/* This test checks whether SWIG correctly parses the new constructor
+ inheritance.
+*/
+%module cpp11_inheriting_constructors
+
+%inline %{
+// Delegating constructors
+class BaseClass {
+private:
+ int _val;
+public:
+ BaseClass(int iValue) { _val = iValue; }
+};
+
+// Constructor inheritance via using declaration
+class DerivedClass: public BaseClass {
+public:
+ using BaseClass::BaseClass; // Adds DerivedClass(int) constructor
+};
+
+// Member initialization at the site of the declaration
+class SomeClass {
+public:
+ SomeClass() {}
+ explicit SomeClass(int new_value) : value(new_value) {}
+
+ int value = 5;
+};
+%}
--- /dev/null
+/* This testcase shows a few simple ways to deal with the new initializer_list
+ introduced in C++11. */
+%module cpp11_initializer_list
+
+%warnfilter(SWIGWARN_TYPEMAP_INITIALIZER_LIST) B::B;
+%ignore A::A(std::initializer_list<int>);
+%ignore B::method;
+
+%typemap(in) std::initializer_list<const char *> {
+ $1 = {"Ab", "Fab"};
+}
+
+%inline %{
+#include <initializer_list>
+
+class A {
+public:
+ A(std::initializer_list<int>) {}
+ A() {}
+ A(double d) {}
+};
+class B {
+public:
+ B(std::initializer_list<int>, std::initializer_list<double>) {}
+ B() {}
+ void method(std::initializer_list<int> init) {}
+};
+class C {
+public:
+ C(std::initializer_list<const char *>) {}
+ C() {}
+};
+%}
+
--- /dev/null
+/* This testcase shows how to replace std_initializer_list with std_vector. */
+
+%module cpp11_initializer_list_extend
+
+%ignore Container::Container(std::initializer_list<int>);
+%include <std_vector.i>
+%template(VectorInt) std::vector<int>;
+
+%extend Container {
+ Container(const std::vector<int> &elements) {
+ Container *c = new Container();
+ for (int element : elements)
+ c->push_back(element);
+ return c;
+ }
+}
+
+
+%inline %{
+#include <initializer_list>
+
+class Container {
+public:
+ Container(std::initializer_list<int>) {}
+ Container() {}
+ void push_back(const int&) {}
+};
+%}
+
--- /dev/null
+/* This testcase checks whether SWIG correctly parses the lambda expressions
+ and closure syntax introduced in C++11.
+ SWIG supports only lambda syntax and doesn't produce any wrapper code for
+ this.
+*/
+%module cpp11_lambda_functions
+
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda1;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda2;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda3;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda4;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda5;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda6;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda7;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda8;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda9;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda10;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda11;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda12;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda13;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda14;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda15;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda16;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda17;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) lambda18;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) Space1::lambda19;
+%warnfilter(SWIGWARN_CPP11_LAMBDA) Space1::Space2::lambda20;
+
+%inline %{
+/* Defined lambda function with return value. */
+auto lambda1 = [](int x, int y) -> int { return x+y; };
+
+/* Defined lambda function without return value.
+ Return value is calculated by compiler, if the function contains a
+ single statement "return expr;". */
+auto lambda2 = [](int x, int y) { return x+y; };
+
+auto lambda3 = [&](int x, int y) { return x+y; };
+auto lambda4 = [=](int x, int y) { return x+y; };
+int thing = 0;
+#ifdef SWIG
+// Not strictly correct as captured variables should have non-automatic storage duration, ie shouldn't capture globals. gcc-4.7 warns about this, but we check that SWIG can parse this anyway.
+auto lambda5 = [=,&thing]() { return thing; };
+#else
+auto lambda5 = [=]() { return thing; };
+#endif
+
+void fn() {
+ int stuff = 0;
+ auto lambdaxxxx = [=,&stuff]() { return thing; };
+}
+auto lambda6 = [] (int a, int b) mutable { return a + b; };
+auto lambda7 = [] (int x, int y) -> int { return x+y; };
+auto lambda8 = [] (int x, int y) throw() -> int { return x+y; };
+auto lambda9 = [] (int x, int y) mutable throw() -> int { return x+y; };
+auto lambda10 = [] (int x, int y) throw(int) { return x+y; };
+auto lambda11 = [] (int x, int y) mutable throw(int) { return x+y; };
+auto lambda12 = [] (int a, int b) { return a + b; }(1, 2);
+auto lambda13 = [] (int a, int b) mutable { return a + b; }(1, 2);
+auto lambda14 = [] () throw () {};
+auto lambda15 = [] () mutable throw () {};
+auto lambda16 = [] { return thing; };
+auto lambda17 = [] { return thing; }();
+constexpr auto lambda18 = [] (int x, int y) mutable throw(int) { return x+y; };
+
+namespace Space1 {
+ constexpr auto lambda19 = [] (int x, int y) mutable throw(int) { return x+y; };
+ namespace Space2 {
+ constexpr auto lambda20 = [] (int x, int y) mutable throw(int) { return x+y; };
+ }
+}
+
+int runLambda1() {
+ return lambda1(5,6);
+}
+
+int runLambda2() {
+ return lambda2(5,6);
+}
+
+int runLambda3() {
+ return lambda3(5,6);
+}
+
+int runLambda4() {
+ return lambda4(5,6);
+}
+
+int runLambda5() {
+ thing++;
+ return lambda5();
+}
+
+/* Inline defined lambda function. */
+int runLambdaInline() {
+ auto myLambda = [](int x, int y) { return x+y; };
+ return myLambda(5,6);
+}
+%}
+
+%{
+// TODO
+int(*lambda101notauto)(int, int) = [] (int a, int b) { return a + b; };
+int lambda102 = [] (int a, int b) mutable { return a + b; }(1, 2);
+void lambda_init(int = ([=]{ return 0; })());
+%}
+
--- /dev/null
+%module cpp11_li_std_array
+
+#if defined(SWIGPYTHON) || defined(SWIGRUBY) || defined(SWIGJAVA)
+
+%{
+#include <array>
+%}
+
+%include <std_array.i>
+
+%template(ArrayInt6) std::array<int, 6>;
+
+%inline %{
+std::array<int, 6> arrayOutVal() {
+ return { -2, -1, 0, 0, 1, 2 };
+}
+
+std::array<int, 6> & arrayOutRef() {
+ static std::array<int, 6> a = { -2, -1, 0, 0, 1, 2 };
+ return a;
+}
+
+const std::array<int, 6> & arrayOutConstRef() {
+ static std::array<int, 6> a = { -2, -1, 0, 0, 1, 2 };
+ return a;
+}
+
+std::array<int, 6> * arrayOutPtr() {
+ static std::array<int, 6> a = { -2, -1, 0, 0, 1, 2 };
+ return &a;
+}
+
+std::array<int, 6> arrayInVal(std::array<int, 6> myarray) {
+ std::array<int, 6> a = myarray;
+ for (auto& val : a) {
+ val *= 10;
+ }
+ return a;
+}
+
+const std::array<int, 6> & arrayInConstRef(const std::array<int, 6> & myarray) {
+ static std::array<int, 6> a = myarray;
+ for (auto& val : a) {
+ val *= 10;
+ }
+ return a;
+}
+
+void arrayInRef(std::array<int, 6> & myarray) {
+ for (auto& val : myarray) {
+ val *= 10;
+ }
+}
+
+void arrayInPtr(std::array<int, 6> * myarray) {
+ for (auto& val : *myarray) {
+ val *= 10;
+ }
+}
+%}
+
+#endif
--- /dev/null
+%module cpp11_noexcept
+
+%ignore NoExceptClass(NoExceptClass&&);
+%rename(Assignment) NoExceptClass::operator=;
+
+%inline %{
+
+extern "C" void global_noexcept(int, bool) noexcept;
+
+struct NoExceptClass {
+ static const bool VeryTrue = true;
+
+ NoExceptClass() noexcept {}
+ NoExceptClass(const NoExceptClass&) noexcept {}
+ NoExceptClass(NoExceptClass&&) noexcept {}
+ NoExceptClass& operator=(const NoExceptClass&) noexcept { return *this; }
+ ~NoExceptClass() noexcept {}
+
+ void noex0() noexcept {}
+ void noex1() noexcept(sizeof(int) == 4) {}
+ void noex2() noexcept(true) {}
+ void noex3() noexcept(false) {}
+ void noex4() noexcept(VeryTrue) {}
+
+ template<typename T> void template_noexcept(T) noexcept {}
+
+ void noo1() const noexcept {}
+ static void noo2() noexcept {}
+ virtual void noo3() const noexcept {}
+ virtual void noo4() const noexcept = delete;
+ virtual void noo5() const throw() = delete;
+};
+
+struct NoExceptAbstract {
+ virtual void noo4() const noexcept = 0;
+ virtual ~NoExceptAbstract() noexcept = 0;
+};
+
+struct NoExceptDefaultDelete {
+ template<typename T> NoExceptDefaultDelete(T) noexcept = delete;
+ NoExceptDefaultDelete() noexcept = default;
+ NoExceptDefaultDelete(const NoExceptDefaultDelete&) noexcept = delete;
+ NoExceptDefaultDelete(NoExceptDefaultDelete&&) = delete;
+ NoExceptDefaultDelete& operator=(const NoExceptDefaultDelete&) = delete;
+ ~NoExceptDefaultDelete() noexcept = default;
+};
+
+%}
+
--- /dev/null
+/* This testcase checks whether SWIG correctly treats the new nullptr_t
+ constant introduced in C++11.
+*/
+
+%module cpp11_null_pointer_constant
+
+%feature("autodoc") A::NullPtrMethod; // Triggers conversion of nullptr to None, nil etc in target language
+%feature("compactdefaultargs") A::NullPtrMethod;
+
+%inline %{
+
+const int *const MyIntegerPtr = nullptr;
+
+class A {
+public:
+ A() : _myA(nullptr) { }
+
+ A *_myA;
+
+ void NullPtrMethod(double *ptr = nullptr) {}
+};
+%}
--- /dev/null
+/* This module tests whether SWIG correctly parses:
+ - ordinary strings (char_t)
+ - L wide strings (wchar_t)
+ - u8 unicode8 strings (char_t)
+ - u unicode16 strings (char16_t)
+ - U unicode32 strings (char32_t)
+
+ This module also tests whether SWIG correctly parses custom string delimiters.
+*/
+%module cpp11_raw_string_literals
+%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK_MSG) bb;
+%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK_MSG) ee;
+%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK_MSG) gg;
+%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK_MSG) xx;
+%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) cc;
+%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) dd;
+%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) hh;
+%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) ii;
+
+%include <std_wstring.i>
+
+%inline %{
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+int L = 100;
+int u8 = 100;
+int u = 100;
+struct UStruct {
+ static const int U = 100;
+};
+
+int R = 100;
+int LR = 100;
+int u8R = 100;
+int uR = 100;
+struct URStruct {
+ static const int UR = 100;
+};
+
+// New string literals
+wstring aa = L"Wide string";
+const char *bb = u8"UTF-8 string";
+const char16_t *cc = u"UTF-16 string";
+const char32_t *dd = U"UTF-32 string";
+%}
+
+/* Raw string literals */
+%inline %{
+const char *xx = ")I'm an \"ascii\" \\ string.";
+const char *ee = R"XXX()I'm an "ascii" \ string.)XXX";
+wstring ff = LR"XXX(I'm a "raw wide" \ string.)XXX";
+const char *gg = u8R"XXX(I'm a "raw UTF-8" \ string.)XXX";
+const char16_t *hh = uR"XXX(I'm a "raw UTF-16" \ string.)XXX";
+const char32_t *ii = UR"XXX(I'm a "raw UTF-32" \ string.)XXX";
+%}
+
--- /dev/null
+%module cpp11_reference_wrapper
+
+// SWIG could provide some sort of typemaps for reference_wrapper which is acts like a C++ reference,
+// but is copy-constructible and copy-assignable
+
+%inline %{
+#include <iostream>
+#include <functional>
+using namespace std;
+
+struct B {
+ B(int &val) : val(val) {}
+ std::reference_wrapper<int> val;
+// int &val;
+};
+%}
+
+%inline %{
+void go() {
+ int val(999);
+ B b1(val);
+ int const& aa1 = b1.val;
+ cout << aa1 << endl;
+
+ // copy constructible
+ B b2(b1);
+ int const& aa2 = b2.val;
+ cout << aa2 << endl;
+
+ // copy assignable
+ B b3(val);
+ b3 = b1;
+ int const& aa3 = b3.val;
+ cout << aa3 << endl;
+}
+%}
--- /dev/null
+/* This testcase checks whether SWIG correctly uses the new result_of class
+ and its templating capabilities introduced in C++11. */
+%module cpp11_result_of
+
+%inline %{
+#include <functional>
+typedef double(*fn_ptr)(double);
+%}
+
+namespace std {
+ // Forward declaration of result_of
+ template<typename Func> struct result_of;
+ // Add in the required partial specialization of result_of
+ template<> struct result_of< fn_ptr(double) > {
+ typedef double type;
+ };
+}
+
+%template() std::result_of< fn_ptr(double) >;
+
+%inline %{
+
+double square(double x) {
+ return (x * x);
+}
+
+template<class Fun, class Arg>
+typename std::result_of<Fun(Arg)>::type test_result_impl(Fun fun, Arg arg) {
+ return fun(arg);
+}
+
+std::result_of< fn_ptr(double) >::type test_result_alternative1(double(*fun)(double), double arg) {
+ return fun(arg);
+}
+%}
+
+%{
+// Another alternative approach using decltype (not very SWIG friendly)
+std::result_of< decltype(square)&(double) >::type test_result_alternative2(double(*fun)(double), double arg) {
+ return fun(arg);
+}
+%}
+
+%inline %{
+#include <iostream>
+
+void cpp_testing() {
+ std::cout << "result: " << test_result_impl(square, 3) << std::endl;
+ std::cout << "result: " << test_result_impl<double(*)(double), double>(square, 4) << std::endl;
+ std::cout << "result: " << test_result_impl< fn_ptr, double >(square, 5) << std::endl;
+ std::cout << "result: " << test_result_alternative1(square, 6) << std::endl;
+ std::cout << "result: " << test_result_alternative2(square, 7) << std::endl;
+}
+%}
+
+%template(test_result) test_result_impl< fn_ptr, double>;
+%constant double (*SQUARE)(double) = square;
--- /dev/null
+/* This testcase checks whether SWIG correctly parses the double ampersand &&
+ move operator which is currently mapped to the reference & operator. */
+%module cpp11_rvalue_reference
+
+%inline %{
+#include <utility>
+class A {
+public:
+ int getAcopy() { return _a; }
+ int *getAptr() { return &_a; }
+ int &getAref() { return _a; }
+ int &&getAmove() { return std::move(_a); }
+
+ void setAcopy(int a) { _a = a; }
+ void setAptr(int *a) { _a = *a; }
+ void setAref(int &a) { _a = a; }
+ void setAmove(int &&a) { _a = a; }
+
+private:
+ int _a;
+};
+%}
--- /dev/null
+%module cpp11_rvalue_reference2
+
+%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK) globalrrval;
+
+// This testcase tests lots of different places that rvalue reference syntax can be used
+
+%typemap(in) Something && "/*in Something && typemap*/"
+%rename(OperatorRValue) Thingy::operator int&&;
+%rename(memberFnRenamed) memberFn(short &&i);
+%feature("compactdefaultargs") Thingy::compactDefaultArgs(const bool &&b = (const bool &&)PublicGlobalTrue, const UserDef &&u = (const UserDef &&)PublicUserDef);
+%feature("exception") Thingy::privateDefaultArgs(const bool &&b = (const bool &&)PrivateTrue);
+%ignore Thingy::operator=;
+
+%inline %{
+#include <utility>
+struct UserDef {
+ int a;
+};
+static const bool PublicGlobalTrue = true;
+static const UserDef PublicUserDef = UserDef();
+struct Thingy {
+ typedef int Integer;
+ int val;
+ int &lvalref;
+ int &&rvalref;
+ Thingy(int v) : val(v), lvalref(val), rvalref(22) {}
+ void refIn(long &i) {}
+ void rvalueIn(long &&i) {}
+ short && rvalueInOut(short &&i) { return std::move(i); }
+ static short && staticRvalueInOut(short &&i) { return std::move(i); }
+ // test both primitive and user defined rvalue reference default arguments and compactdefaultargs
+ void compactDefaultArgs(const bool &&b = (const bool &&)PublicGlobalTrue, const UserDef &&u = (const UserDef &&)PublicUserDef) {}
+ void privateDefaultArgs(const bool &&b = (const bool &&)PrivateTrue) {}
+ operator int &&() { return std::move(0); }
+ Thingy(const Thingy& rhs) : val(rhs.val), lvalref(rhs.lvalref), rvalref(copy_int(rhs.rvalref)) {}
+ Thingy& operator=(const Thingy& rhs) {
+ val = rhs.val;
+ lvalref = rhs.lvalref;
+ rvalref = rhs.rvalref;
+ return *this;
+ }
+private:
+ static const bool PrivateTrue;
+ int copy_int(int& i) { return i; }
+ Thingy();
+};
+const bool Thingy::PrivateTrue = true;
+
+short && globalRvalueInOut(short &&i) { return std::move(i); }
+
+Thingy &&globalrrval = Thingy(55);
+
+short && func(short &&i) { return std::move(i); }
+Thingy getit() { return Thingy(22); }
+
+void rvalrefFunction1(int &&v = (int &&)5) {}
+void rvalrefFunctionBYVAL(short (Thingy::*memFunc)(short)) {}
+void rvalrefFunctionLVALUE(short &(Thingy::*memFunc)(short &)) {}
+void rvalrefFunction2(short && (Thingy::*memFunc)(short &&)) {}
+void rvalrefFunction3(short && (*memFunc)(short &&)) {}
+
+template <typename T> struct RemoveReference {
+ typedef T type;
+};
+
+template <typename T> struct RemoveReference<T&> {
+ typedef T type;
+};
+
+template <typename T> struct RemoveReference<T&&> {
+ typedef T type;
+};
+
+template <> struct RemoveReference<short &&> {
+ typedef short type;
+};
+
+// like std::move
+template <typename T> typename RemoveReference<T>::type&& Move(T&& t) {
+ return static_cast<typename RemoveReference<T>::type&&>(t);
+}
+%}
+
+%template(RemoveReferenceDouble) RemoveReference<double &&>;
+%template(RemoveReferenceFloat) RemoveReference<float &&>;
+%template(RemoveReferenceShort) RemoveReference<short &&>;
+%template(MoveFloat) Move<float>;
+
+
--- /dev/null
+%module cpp11_rvalue_reference3
+
+%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK);
+
+%inline %{
+#include <utility>
+struct Thing {};
+
+Thing && global_rvalue_ref = Thing();
+Thing *&& global_rvalue_ref_ptr1 = 0;
+Thing const*&& global_rvalue_ref_ptr2 = 0;
+Thing *const&& global_rvalue_ref_ptr3 = 0;
+Thing const*const &&global_rvalue_ref_ptr4 = 0;
+
+Thing && returnit1() { return std::move(global_rvalue_ref); }
+Thing *&& returnit2() { return std::move(global_rvalue_ref_ptr1); }
+Thing const*&& returnit3() { return std::move(global_rvalue_ref_ptr2); }
+Thing *const&& returnit4() { return std::move(global_rvalue_ref_ptr3); }
+Thing const*const&& returnit5() { return std::move(global_rvalue_ref_ptr4); }
+
+void takeit1(Thing && t) {}
+void takeit2(Thing *&& t) {}
+void takeit3(Thing const*&& t) {}
+void takeit4(Thing *const&& t) {}
+void takeit5(Thing const*const&& t) {}
+
+struct Containing {
+ Thing && member_rvalue_ref;
+ Thing *&& member_rvalue_ref_ptr1 = 0;
+ Thing const*&& member_rvalue_ref_ptr2 = 0;
+ Thing *const&& member_rvalue_ref_ptr3 = 0;
+ Thing const*const &&member_rvalue_ref_ptr4 = 0;
+
+ Containing() : member_rvalue_ref(Thing()) {}
+};
+%}
+
+
+%inline %{
+int && int_global_rvalue_ref = 5;
+int *&& int_global_rvalue_ref_ptr1 = 0;
+int const*&& int_global_rvalue_ref_ptr2 = 0;
+int *const&& int_global_rvalue_ref_ptr3 = 0;
+int const*const &&int_global_rvalue_ref_ptr4 = 0;
+
+int && int_returnit1() { return std::move(int_global_rvalue_ref); }
+int *&& int_returnit2() { return std::move(int_global_rvalue_ref_ptr1); }
+int const*&& int_returnit3() { return std::move(int_global_rvalue_ref_ptr2); }
+int *const&& int_returnit4() { return std::move(int_global_rvalue_ref_ptr3); }
+int const*const&& int_returnit5() { return std::move(int_global_rvalue_ref_ptr4); }
+
+void int_takeit1(int && t) {}
+void int_takeit2(int *&& t) {}
+void int_takeit3(int const*&& t) {}
+void int_takeit4(int *const&& t) {}
+void int_takeit5(int const*const&& t) {}
+
+struct IntContaining {
+ int && member_rvalue_ref;
+ int *&& member_rvalue_ref_ptr1 = 0;
+ int const*&& member_rvalue_ref_ptr2 = 0;
+ int *const&& member_rvalue_ref_ptr3 = 0;
+ int const*const &&member_rvalue_ref_ptr4 = 0;
+
+ IntContaining() : member_rvalue_ref(55) {}
+};
+%}
--- /dev/null
+/* This testcase checks whether SWIG correctly uses the sizeof() on the
+ concrete objects and not only types introduced in C++11. */
+%module cpp11_sizeof_object
+
+%inline %{
+struct B {
+ unsigned long member1;
+ long long member2;
+ char member3;
+};
+
+struct A {
+ B member;
+};
+
+const int a = sizeof(A::member);
+%}
--- /dev/null
+/* This test case checks whether SWIG correctly parses and ignores the
+ keywords "static_assert()" inside the class or struct.
+*/
+%module cpp11_static_assert
+
+%inline %{
+template <typename T>
+struct Check1 {
+ static_assert(sizeof(int) <= sizeof(T), "not big enough");
+};
+
+template <typename T>
+class Check2 {
+ static_assert(sizeof(int) <= sizeof(T), "not big enough");
+};
+%}
+
--- /dev/null
+// This testcase checks whether SWIG produces the correct wrappers for strongly typed enums.
+
+%module cpp11_strongly_typed_enumerations
+
+%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) Class1::Struct1;
+%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) Class2::Struct1;
+
+/* Forward declarations (illegally accepted by SWIG - oh well!) */
+enum Enum1 : short;
+enum Enum3;
+enum ;
+enum : unsigned short;
+
+%inline %{
+enum class Enum1 {
+ Val1,
+ Val2,
+ Val3 = 13,
+ Val4,
+ Val5a = 13,
+ Val6a
+};
+
+enum class Enum2 : short {
+ Val1,
+ Val2,
+ Val3 = 23,
+ Val4,
+ Val5b = 23,
+ Val6b
+};
+%}
+
+// SWIG should fail this one
+enum Enum2 : unsigned short; // Illegal in C++11, because Enum2 was previously declared with a different type.
+
+%inline %{
+/* Forward declarations. */
+enum Enum4 : unsigned int; // Legal in C++11.
+enum class Enum5; // Legal in C++11, because enum class declarations have a default type of "int".
+enum class Enum6 : unsigned int; // Legal C++11.
+
+enum Enum4 : unsigned int {
+ Val1, Val2, Val3 = 43, Val4
+};
+
+enum class Enum5 {
+ Val1, Val2, Val3 = 53, Val4
+};
+
+enum class Enum6 : unsigned int {
+ Val1, Val2, Val3 = 63, Val4
+};
+
+typedef enum class Enum7 : unsigned int {
+ Val1, Val2, Val3 = 73, Val4
+} Enum7td;
+
+// enum inherits from non-primitive type
+enum class Enum8 : size_t {
+ Val1, Val2, Val3 = 83, Val4
+};
+
+template <typename T> struct TType {
+ typedef T type_name;
+};
+
+enum class Enum10 : TType<int>::type_name {
+ Val1, Val2, Val3 = 103, Val4
+};
+
+// forward declaration, no definition of enum
+enum class Enum11 : int;
+struct UseEnum11 {
+ Enum11 myenum11;
+};
+
+class Class1
+{
+public:
+ enum class Enum12
+ {
+ Val1 = 1121,
+ Val2 = 1122,
+ Val3,
+ Val4,
+ Val5c = 1121,
+ Val6c
+ };
+
+ enum Enum13
+ {
+ Val1 = 1131,
+ Val2 = 1132,
+ Val3,
+ Val4,
+ Val5d = 1131,
+ Val6d
+ };
+
+ enum class Enum14
+ {
+ Val1 = 1141,
+ Val2 = 1142,
+ Val3,
+ Val4,
+ Val5e = 1141,
+ Val6e
+ };
+
+ struct Struct1
+ {
+ enum class Enum12
+ {
+ Val1 = 3121,
+ Val2 = 3122,
+ Val3,
+ Val4,
+ Val5f = 3121,
+ Val6f
+ };
+
+ enum Enum13
+ {
+ Val1 = 3131,
+ Val2 = 3132,
+ Val3,
+ Val4,
+ };
+
+ enum class Enum14
+ {
+ Val1 = 3141,
+ Val2 = 3142,
+ Val3,
+ Val4,
+ Val5g = 3141,
+ Val6g
+ };
+ };
+ Enum1 class1Test1(Enum1 e) { return e; }
+ Enum12 class1Test2(Enum12 e) { return e; }
+ Struct1::Enum12 class1Test3(Struct1::Enum12 e) { return e; }
+};
+
+class Class2
+{
+public:
+ enum class Enum12
+ {
+ Val1 = 2121,
+ Val2 = 2122,
+ Val3,
+ Val4,
+ Val5h = 2121,
+ Val6h
+ };
+
+ enum Enum13
+ {
+ Val1 = 2131,
+ Val2 = 2132,
+ Val3,
+ Val4,
+ Val5i = 2131,
+ Val6i
+ };
+
+ enum class Enum14
+ {
+ Val1 = 2141,
+ Val2 = 2142,
+ Val3,
+ Val4,
+ Val5j = 2141,
+ Val6j
+ };
+
+ struct Struct1
+ {
+ enum class Enum12
+ {
+ Val1 = 4121,
+ Val2 = 4122,
+ Val3,
+ Val4,
+ Val5k = 4121,
+ Val6k
+ };
+
+ enum Enum13
+ {
+ Val1 = 4131,
+ Val2 = 4132,
+ Val3,
+ Val4,
+ Val5l = 4131,
+ Val6l
+ };
+
+ enum class Enum14
+ {
+ Val1 = 4141,
+ Val2 = 4142,
+ Val3,
+ Val4,
+ Val5m = 4141,
+ Val6m
+ };
+ };
+};
+
+Enum1 globalTest1(Enum1 e) { return e; }
+Class1::Enum12 globalTest2(Class1::Enum12 e) { return e; }
+Class1::Struct1::Enum12 globalTest3(Class1::Struct1::Enum12 e) { return e; }
+
+class PrivateEnumClass {
+private:
+ enum class Enum {
+ PrivateEnum1,
+ PrivateEnum2
+ };
+};
+%}
+
--- /dev/null
+%module cpp11_strongly_typed_enumerations_simple
+
+%include <enumsimple.swg>
+
+%include "cpp11_strongly_typed_enumerations.i"
--- /dev/null
+/* This interface checks whether SWIG supports the new double angled brackets
+ in the template syntax without having a space inbetween. This feature was
+ introduced in new C++11 standard.
+*/
+%module cpp11_template_double_brackets
+%inline %{
+#include <map>
+std::map<int,std::map<int, double>> map1;
+std::map< int,std::map<int, double> > map2;
+
+std::map<int,std::map<int, std::map<int, double>>> map3;
+std::map<int,std::map<int, std::map<int, std::map<int, double>>>> map4;
+%}
+
+// Check streaming operators are still okay
+%rename(ExtractionOperator) operator>>;
+%rename(InsertionOperator) operator<<;
+
+%inline %{
+class ABC {
+public:
+ int a;
+ int operator>>(ABC &) { return 0; }
+ int operator<<(ABC &) { return 0; }
+};
+
+class DEF {
+public:
+ int a;
+ int operator<<(DEF &) { return 0; }
+ int operator>>(DEF &) { return 0; }
+};
+
+
+template<class T>
+class ABC2 {
+public:
+ int a;
+
+ template<typename U>
+ U operator>>(ABC &);
+
+ template<typename U>
+ U operator<<(ABC &);
+};
+%}
+
+// Test shifts are still working
+%inline %{
+int shift_init1 = 4 << 2 >> 1;
+int shift_init2 = 4 >> 2 << 1 << 1 >> 2;
+%}
+
--- /dev/null
+/* This unit tests whether SWIG correctly parses the code and makes wrappers
+ for the new C++11 extern templates (explicit template instantiation without
+ using the translation unit).
+*/
+%module cpp11_template_explicit
+
+#pragma SWIG nowarn=SWIGWARN_PARSE_EXPLICIT_TEMPLATE
+
+%inline %{
+
+template<typename T> struct Temper {
+ T val;
+};
+
+class A {
+public:
+ int member;
+ int memberFunction() { return 100; }
+};
+
+template class Temper<A>;
+extern template class Temper<A>;
+
+template class Temper<A*>;
+extern template class Temper<A*>;
+
+template class Temper<int>;
+extern template class Temper<int>;
+%}
+
+%template(TemperInt) Temper<int>;
--- /dev/null
+/* This testcase checks whether SWIG correctly parses alias templates. */
+%module cpp11_template_typedefs
+
+%warnfilter(SWIGWARN_CPP11_ALIAS_TEMPLATE) TypedefName;
+%warnfilter(SWIGWARN_CPP11_ALIAS_TEMPLATE) TypedefNamePtr;
+%warnfilter(SWIGWARN_CPP11_ALIAS_TEMPLATE) MyIntKeyClass;
+%warnfilter(SWIGWARN_CPP11_ALIAS_DECLARATION) PF;
+%warnfilter(SWIGWARN_CPP11_ALIAS_DECLARATION) BucketAllocator1;
+%warnfilter(SWIGWARN_CPP11_ALIAS_DECLARATION) BucketAllocator2;
+
+// This warning should go away when type aliasing is supported
+#pragma SWIG nowarn=SWIGWARN_PARSE_USING_UNDEF // Nothing known about 'p.SomeType< char *,T2,4 >'.
+
+%inline %{
+template< typename T1, typename T2, int >
+class SomeType {
+ T1 a;
+ T2 b;
+ int c;
+};
+
+// template aliasing
+template< typename T2 >
+using TypedefName = SomeType<char*, T2, 5>;
+template< typename T2 >
+using TypedefNamePtr = SomeType<char*, T2, 4>*;
+
+// type aliasing
+typedef void (*PFD)(double); // Old style
+using PF = void (*)(double); // New introduced syntax
+
+
+// use of template aliasing
+template<typename Key,typename Val>
+class MyCPP11Class {
+};
+template<typename VAL> using MyIntKeyClass = MyCPP11Class<int,VAL>;
+MyIntKeyClass<char> intchar;
+
+TypedefName<int> alias1(TypedefName<int> a) { return a; }
+TypedefNamePtr<int> alias1(TypedefNamePtr<int> a = nullptr) { return a; }
+%}
+
+%inline %{
+typedef double Val;
+template<typename T> struct ListBucket {
+};
+namespace Alloc {
+ template<typename T> struct rebind {
+ typedef int other;
+ };
+}
+
+using BucketAllocator1 = typename Alloc::template rebind<ListBucket<Val>>::other;
+using BucketAllocator2 = typename Alloc::template rebind<::template ListBucket<double>>::other;
+%}
--- /dev/null
+/* This testcase checks whether SWIG correctly parses the 'thread_local' storage specifier */
+
+%module cpp11_thread_local
+
+%inline %{
+struct ThreadLocals {
+// thread_local int tval; // members must also be declared static
+ static thread_local int stval;
+ thread_local static int tsval;
+ static thread_local const int stcval88 = 88;
+ thread_local static const int tscval99 = 99;
+};
+thread_local int tval;
+static thread_local int stval;
+thread_local static int tsval;
+extern thread_local int etval;
+thread_local extern int teval;
+extern "C" thread_local int ectval;
+extern "C++" thread_local int ecpptval;
+
+thread_local int ThreadLocals::stval = 11;
+thread_local int ThreadLocals::tsval = 22;
+thread_local const int ThreadLocals::stcval88;
+thread_local const int ThreadLocals::tscval99;
+%}
+
+%{
+// externs
+thread_local int etval = 33;
+thread_local int teval = 44;
+thread_local int ectval = 55;
+thread_local int ecpptval = 66;
+%}
--- /dev/null
+%module cpp11_type_aliasing
+
+// Type aliasing seg fault : Github issue #424
+
+%warnfilter(SWIGWARN_CPP11_ALIAS_DECLARATION) Target;
+%warnfilter(SWIGWARN_CPP11_ALIAS_DECLARATION) Int;
+%warnfilter(SWIGWARN_CPP11_ALIAS_DECLARATION) IntRef;
+%warnfilter(SWIGWARN_CPP11_ALIAS_DECLARATION) IntPtrRef;
+%warnfilter(SWIGWARN_CPP11_ALIAS_DECLARATION) IntRValueRef;
+%warnfilter(SWIGWARN_CPP11_ALIAS_DECLARATION) IntArray;
+%warnfilter(SWIGWARN_CPP11_ALIAS_DECLARATION) HalideTargetPtr1;
+%warnfilter(SWIGWARN_CPP11_ALIAS_DECLARATION) HalideTargetPtr2;
+
+%inline %{
+namespace Halide {
+
+struct Target {
+ int bits;
+ Target(int bits=32) : bits(bits) {}
+};
+
+class NamesInterface {
+public:
+ using Target = Halide::Target;
+};
+
+Target get_host_target() {
+ return Target();
+}
+
+namespace Internal {
+
+template <typename T> class GeneratorParam {
+ T value;
+public:
+ GeneratorParam(const char *name, const T &v) : value(v) {}
+
+ T getValue() {
+ return value;
+ }
+};
+
+class GeneratorBase : public NamesInterface {
+public:
+ GeneratorParam<Target> target{ "target", Halide::get_host_target() };
+};
+
+}
+}
+%}
+
+%template(Halide_Target) Halide::Internal::GeneratorParam<Halide::Target>;
+
+
+%inline %{
+using Int = int;
+using IntRef = int&;
+using IntPtrRef = int*&;
+using IntRValueRef = int&&;
+using IntArray = int[];
+
+using HalideTargetPtr1 = Halide::Target*;
+namespace Halide {
+ using HalideTargetPtr2 = Target*;
+}
+%}
--- /dev/null
+%module cpp11_type_traits
+
+// The example in the CPlusPlus11.html documentation.
+// This doesn't really directly test functionality in type_traits as it doesn't provide
+// much for use by target languages, rather it tests usage of it.
+
+%inline %{
+#include <type_traits>
+
+// First way of operating.
+template< bool B > struct algorithm {
+ template< class T1, class T2 > static int do_it(T1 &, T2 &) { /*...*/ return 1; }
+};
+
+// Second way of operating.
+template<> struct algorithm<true> {
+ template< class T1, class T2 > static int do_it(T1, T2) { /*...*/ return 2; }
+};
+
+// Instantiating 'elaborate' will automatically instantiate the correct way to operate, depending on the types used.
+template< class T1, class T2 > int elaborate(T1 A, T2 B) {
+ // Use the second way only if 'T1' is an integer and if 'T2' is
+ // a floating point, otherwise use the first way.
+ return algorithm< std::is_integral<T1>::value && std::is_floating_point<T2>::value >::do_it(A, B);
+}
+%}
+
+%template(Elaborate) elaborate<int, int>;
+%template(Elaborate) elaborate<int, double>;
--- /dev/null
+/* This testcase checks whether SWIG syntactically correctly parses the initialization syntax using
+ {} braces for uniform member initialization. */
+%module cpp11_uniform_initialization
+
+%include <std_vector.i>
+
+%template(VectorInt) std::vector<int>;
+
+%inline %{
+struct BasicStruct {
+ int x;
+ double y;
+};
+
+struct AltStruct {
+ AltStruct(int x, double y) : x_{x}, y_{y} {}
+ int getX() { return x_; }
+ double getY() { return y_; }
+
+private:
+ int x_;
+ double y_;
+};
+
+BasicStruct var1{5, 3.2}; // only fills the struct components
+AltStruct var2{2, 4.3}; // calls the constructor
+
+class MoreInit
+{
+public:
+ int yarray[5] {1,2,3,4,5};
+ char *charptr {nullptr};
+ std::vector<int> vi {1,2,3,4,5};
+
+ MoreInit() {}
+
+ int more1(std::vector<int> vv = {1,2,3,4}) {
+ int sum = 0;
+ for (int i : vv)
+ sum += i;
+ return sum;
+ }
+};
+const int arr1[] = {1,2,3};
+const int arr2[]{1,2,3};
+const int arr3[][3]{ {1,2,3}, {4,5,6} };
+const int arr4[][3] = { {1,2,3}, {4,5,6} };
+%}
+
--- /dev/null
+/* This testcase checks whether SWIG correctly parses the support for types
+ without the defined trivial constructor in the unions. */
+%module cpp11_unrestricted_unions
+
+%inline %{
+struct point {
+ point() {}
+ point(int x, int y) : x_(x), y_(y) {}
+ int x_, y_;
+};
+
+#include <new> // For placement 'new' in the constructor below
+union P {
+ int z;
+ double w;
+ point p; // Illegal in C++03; legal in C++11.
+ // Due to the point member, a constructor definition is required.
+ P() {
+ new(&p) point();
+ }
+} p1;
+%}
+
--- /dev/null
+/* This testcase checks whether SWIG correctly parses the user-defined literals
+ introduced in C++11. */
+%module cpp11_userdefined_literals
+
+// Unfortunately full declaration is needed for %rename atm, the parameter list cannot be omitted.
+%rename(MyRawLiteral) operator"" _myRawLiteral(const char * value);
+%rename(MySuffixIntegral) operator "" _mySuffixIntegral(unsigned long long);
+%rename(MySuffixFloat) operator "" _mySuffixFloat(long double);
+%rename(MySuffix1) operator "" _mySuffix1(const char * string_values, size_t num_chars);
+%rename(MySuffix2) operator "" _mySuffix2(const wchar_t * string_values, size_t num_chars);
+%rename(MySuffix3) operator "" _mySuffix3(const char16_t * string_values, size_t num_chars);
+%rename(MySuffix4) operator "" _mySuffix4(const char32_t * string_values, size_t num_chars);
+
+%ignore operator "" _myRawLiteralIgnored(const char * value);
+
+%inline %{
+#include <iostream>
+
+struct OutputType {
+ int val;
+ OutputType(int v) : val(v) {}
+};
+
+// Raw literal
+OutputType operator "" _myRawLiteral(const char * value) { return OutputType(10); }
+
+// Cooked numeric literals
+OutputType operator "" _mySuffixIntegral(unsigned long long) { return OutputType(20); }
+OutputType operator "" _mySuffixFloat(long double) { return OutputType(30); }
+
+// Cooked string literals
+OutputType operator "" _mySuffix1(const char * string_values, size_t num_chars) { return OutputType(100); }
+OutputType operator "" _mySuffix2(const wchar_t * string_values, size_t num_chars) { return OutputType(200); }
+OutputType operator "" _mySuffix3(const char16_t * string_values, size_t num_chars) { return OutputType(300); }
+OutputType operator "" _mySuffix4(const char32_t * string_values, size_t num_chars) { return OutputType(400); }
+
+OutputType operator"" _myRawLiteralIgnored(const char * value) { return OutputType(15); }
+%}
+
+%{
+// TODO: SWIG cannot parse these
+OutputType some_variable_a = 1234_myRawLiteral;
+
+OutputType some_variable_b = 1234_mySuffixIntegral;
+OutputType some_variable_c = 3.1416_mySuffixFloat;
+
+OutputType some_variable_d = "1234"_mySuffix1;
+OutputType some_variable_e = u8"1234"_mySuffix1;
+OutputType some_variable_f = L"1234"_mySuffix2;
+OutputType some_variable_g = u"1234"_mySuffix3;
+OutputType some_variable_h = U"1234"_mySuffix4;
+%}
+
--- /dev/null
+/* This testcase checks whether SWIG correctly parses and generates the code
+ for variadic templates. This covers the variadic number of arguments inside
+ the template brackets, new functions sizeof... and multiple inheritance
+ using variadic number of classes.
+*/
+%module cpp11_variadic_templates
+%warnfilter(SWIGWARN_CPP11_VARIADIC_TEMPLATE) MultiArgs;
+%warnfilter(SWIGWARN_CPP11_VARIADIC_TEMPLATE) SizeOf;
+%warnfilter(SWIGWARN_CPP11_VARIADIC_TEMPLATE) MultiInherit;
+
+////////////////////////
+// Variadic templates //
+////////////////////////
+%inline %{
+#include <vector>
+#include <string>
+#include <map>
+
+template<typename... Values>
+class MultiArgs {
+};
+
+class MultiArgs<int, std::vector<int>, std::map<std::string, std::vector<int>>> multiArgs;
+
+%}
+
+// TODO
+%template (MultiArgs1) MultiArgs<int, std::vector<int>, std::map<std::string, std::vector<int>>>;
+
+////////////////////////
+// Variadic sizeof... //
+////////////////////////
+%inline %{
+template<typename... Args> struct SizeOf {
+ static const int size = sizeof...(Args);
+};
+%}
+
+%template (SizeOf1) SizeOf<int, int>;
+
+//////////////////////////
+// Variadic inheritance //
+//////////////////////////
+%inline %{
+class A {
+public:
+ A() {
+ a = 100;
+ }
+ virtual ~A() {}
+ int a;
+};
+
+class B {
+public:
+ B() {
+ b = 200;
+ }
+ virtual ~B() {}
+ int b;
+};
+
+template <typename... BaseClasses> class MultiInherit : public BaseClasses... {
+public:
+ MultiInherit(BaseClasses&... baseClasses) : BaseClasses(baseClasses)... {}
+ int InstanceMethod() { return 123; }
+ static int StaticMethod() { return 456; }
+};
+%}
+
+
+// TODO
+//%template (MultiInherit0) MultiInherit<>;
+%template (MultiInherit1) MultiInherit<A>;
+// TODO
+%template (MultiInherit2) MultiInherit<A,B>;
+
}
int (Foo::*func_ptr)(int);
+
+ const char* __str__() const { return "Foo"; }
+};
+
+class FooSub : public Foo {
+ public:
+ FooSub() :Foo(42) {}
+};
+
+class FooSubSub : public FooSub {
+ public:
+ FooSubSub() : FooSub() {}
+ const char* __str__() const { return "FooSubSub"; }
};
%}
LANGUAGE = csharp
SCRIPTSUFFIX = _runme.cs
-INTERPRETER = @CSHARPCILINTERPRETER@
-INTERPRETER_FLAGS = @CSHARPCILINTERPRETER_FLAGS@
-CSHARPPATHSEPARATOR = "@CSHARPPATHSEPARATOR@"
-CSHARPCYGPATH_W = @CSHARPCYGPATH_W@
+CSHARPCILINTERPRETER = @CSHARPCILINTERPRETER@
+CSHARPCILINTERPRETER_FLAGS = @CSHARPCILINTERPRETER_FLAGS@
+CSHARPCONVERTPATH = @top_srcdir@/@CSHARPCONVERTPATH@
+
srcdir = @srcdir@
top_srcdir = ../@top_srcdir@
top_builddir = ../@top_builddir@
CPP_TEST_CASES = \
csharp_attributes \
+ csharp_swig2_compatibility \
csharp_exceptions \
csharp_features \
csharp_lib_arrays \
+ csharp_namespace_system_collision \
csharp_prepost \
csharp_typemaps \
enum_thorough_simple \
intermediary_classname \
li_boost_intrusive_ptr
+CPP11_TEST_CASES = \
+ cpp11_strongly_typed_enumerations_simple \
+
include $(srcdir)/../common.mk
# Overridden variables here
+SRCDIR = ../$(srcdir)/
SWIGOPT += -namespace $*Namespace
CSHARPFLAGSSPECIAL =
# Custom tests - tests with additional commandline options
intermediary_classname.cpptest: SWIGOPT += -dllimport intermediary_classname
csharp_lib_arrays.cpptest: CSHARPFLAGSSPECIAL = -unsafe
+csharp_swig2_compatibility.cpptest: SWIGOPT += -DSWIG2_CSHARP
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+(cd $* && $(swig_and_compile_cpp))
+$(run_testcase)
+(cd $* && $(swig_and_compile_c))
+$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+(cd $* && $(swig_and_compile_multi_cpp))
+$(run_testcase)
# Makes a directory for the testcase if it does not exist
setup = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- echo "$(ACTION)ing testcase $* (with run test) under $(LANGUAGE)" ; \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ echo "$(ACTION)ing $(LANGUAGE) testcase $* (with run test)" ; \
else \
- echo "$(ACTION)ing testcase $* under $(LANGUAGE)" ; \
+ echo "$(ACTION)ing $(LANGUAGE) testcase $*" ; \
fi; \
if [ ! -d $* ]; then \
mkdir $*; \
# Compiles C# files then runs the testcase. A testcase is only run if
# a file is found which has _runme.cs appended after the testcase name.
# Note C# uses LD_LIBRARY_PATH under Unix, PATH under Cygwin/Windows and SHLIB_PATH on HPUX.
-# DYLD_FALLBACK_LIBRARY_PATH is cleared for MacOSX.
+# DYLD_FALLBACK_LIBRARY_PATH is cleared for Mac OS X.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
$(MAKE) -f $*/$(top_builddir)/$(EXAMPLES)/Makefile \
CSHARPFLAGS='-nologo -debug+ $(CSHARPFLAGSSPECIAL) -out:$*_runme.exe' \
- CSHARPSRCS='`$(CSHARPCYGPATH_W) $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX)` `find $* -name "*.cs" -exec $(CSHARPCYGPATH_W) "{}" \+`' csharp_compile && \
- env LD_LIBRARY_PATH="$*:$$LD_LIBRARY_PATH" PATH="$*:$$PATH" SHLIB_PATH="$*:$$SHLIB_PATH" DYLD_FALLBACK_LIBRARY_PATH= $(RUNTOOL) $(INTERPRETER) $(INTERPRETER_FLAGS) ./$*_runme.exe; \
+ CSHARPSRCS='`$(CSHARPCONVERTPATH) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX)` `find $* -name "*.cs" -exec $(CSHARPCONVERTPATH) "{}" \+`' csharp_compile && \
+ env LD_LIBRARY_PATH="$*:$$LD_LIBRARY_PATH" PATH="$*:$$PATH" SHLIB_PATH="$*:$$SHLIB_PATH" DYLD_FALLBACK_LIBRARY_PATH= $(RUNTOOL) $(CSHARPCILINTERPRETER) $(CSHARPCILINTERPRETER_FLAGS) ./$*_runme.exe; \
else \
cd $* && \
$(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile \
CSHARPFLAGS='-nologo -debug+ $(CSHARPFLAGSSPECIAL) -t:module -out:$*.netmodule' \
- CSHARPSRCS='`find . -name "*.cs" -exec $(CSHARPCYGPATH_W) "{}" \+`' csharp_compile; \
+ CSHARPSRCS='`find . -name "*.cs" -exec ../$(CSHARPCONVERTPATH) "{}" \+`' csharp_compile; \
fi
# Clean: remove testcase directories
--- /dev/null
+using System;
+using cpp11_strongly_typed_enumerationsNamespace;
+
+public class cpp11_strongly_typed_enumerations_runme {
+
+ public static int enumCheck(int actual, int expected) {
+ if (actual != expected)
+ throw new ApplicationException("Enum value mismatch. Expected " + expected + " Actual: " + actual);
+ return expected + 1;
+ }
+
+ public static void Main() {
+ int val = 0;
+ val = enumCheck((int)Enum1.Val1, val);
+ val = enumCheck((int)Enum1.Val2, val);
+ val = enumCheck((int)Enum1.Val3, 13);
+ val = enumCheck((int)Enum1.Val4, val);
+ val = enumCheck((int)Enum1.Val5a, 13);
+ val = enumCheck((int)Enum1.Val6a, val);
+
+ val = 0;
+ val = enumCheck((int)Enum2.Val1, val);
+ val = enumCheck((int)Enum2.Val2, val);
+ val = enumCheck((int)Enum2.Val3, 23);
+ val = enumCheck((int)Enum2.Val4, val);
+ val = enumCheck((int)Enum2.Val5b, 23);
+ val = enumCheck((int)Enum2.Val6b, val);
+
+ val = 0;
+ val = enumCheck((int)Enum4.Val1, val);
+ val = enumCheck((int)Enum4.Val2, val);
+ val = enumCheck((int)Enum4.Val3, 43);
+ val = enumCheck((int)Enum4.Val4, val);
+
+ val = 0;
+ val = enumCheck((int)Enum5.Val1, val);
+ val = enumCheck((int)Enum5.Val2, val);
+ val = enumCheck((int)Enum5.Val3, 53);
+ val = enumCheck((int)Enum5.Val4, val);
+
+ val = 0;
+ val = enumCheck((int)Enum6.Val1, val);
+ val = enumCheck((int)Enum6.Val2, val);
+ val = enumCheck((int)Enum6.Val3, 63);
+ val = enumCheck((int)Enum6.Val4, val);
+
+ val = 0;
+ val = enumCheck((int)Enum7td.Val1, val);
+ val = enumCheck((int)Enum7td.Val2, val);
+ val = enumCheck((int)Enum7td.Val3, 73);
+ val = enumCheck((int)Enum7td.Val4, val);
+
+ val = 0;
+ val = enumCheck((int)Enum8.Val1, val);
+ val = enumCheck((int)Enum8.Val2, val);
+ val = enumCheck((int)Enum8.Val3, 83);
+ val = enumCheck((int)Enum8.Val4, val);
+
+ val = 0;
+ val = enumCheck((int)Enum10.Val1, val);
+ val = enumCheck((int)Enum10.Val2, val);
+ val = enumCheck((int)Enum10.Val3, 103);
+ val = enumCheck((int)Enum10.Val4, val);
+
+ val = 0;
+ val = enumCheck((int)Class1.Enum12.Val1, 1121);
+ val = enumCheck((int)Class1.Enum12.Val2, 1122);
+ val = enumCheck((int)Class1.Enum12.Val3, val);
+ val = enumCheck((int)Class1.Enum12.Val4, val);
+ val = enumCheck((int)Class1.Enum12.Val5c, 1121);
+ val = enumCheck((int)Class1.Enum12.Val6c, val);
+
+ val = 0;
+ val = enumCheck((int)Class1.Enum13.Val1, 1131);
+ val = enumCheck((int)Class1.Enum13.Val2, 1132);
+ val = enumCheck((int)Class1.Enum13.Val3, val);
+ val = enumCheck((int)Class1.Enum13.Val4, val);
+ val = enumCheck((int)Class1.Enum13.Val5d, 1131);
+ val = enumCheck((int)Class1.Enum13.Val6d, val);
+
+ val = 0;
+ val = enumCheck((int)Class1.Enum14.Val1, 1141);
+ val = enumCheck((int)Class1.Enum14.Val2, 1142);
+ val = enumCheck((int)Class1.Enum14.Val3, val);
+ val = enumCheck((int)Class1.Enum14.Val4, val);
+ val = enumCheck((int)Class1.Enum14.Val5e, 1141);
+ val = enumCheck((int)Class1.Enum14.Val6e, val);
+
+ val = 0;
+ val = enumCheck((int)Class1.Struct1.Enum12.Val1, 3121);
+ val = enumCheck((int)Class1.Struct1.Enum12.Val2, 3122);
+ val = enumCheck((int)Class1.Struct1.Enum12.Val3, val);
+ val = enumCheck((int)Class1.Struct1.Enum12.Val4, val);
+ val = enumCheck((int)Class1.Struct1.Enum12.Val5f, 3121);
+ val = enumCheck((int)Class1.Struct1.Enum12.Val6f, val);
+
+ val = 0;
+ val = enumCheck((int)Class1.Struct1.Enum13.Val1, 3131);
+ val = enumCheck((int)Class1.Struct1.Enum13.Val2, 3132);
+ val = enumCheck((int)Class1.Struct1.Enum13.Val3, val);
+ val = enumCheck((int)Class1.Struct1.Enum13.Val4, val);
+
+ val = 0;
+ val = enumCheck((int)Class1.Struct1.Enum14.Val1, 3141);
+ val = enumCheck((int)Class1.Struct1.Enum14.Val2, 3142);
+ val = enumCheck((int)Class1.Struct1.Enum14.Val3, val);
+ val = enumCheck((int)Class1.Struct1.Enum14.Val4, val);
+ val = enumCheck((int)Class1.Struct1.Enum14.Val5g, 3141);
+ val = enumCheck((int)Class1.Struct1.Enum14.Val6g, val);
+
+ val = 0;
+ val = enumCheck((int)Class2.Enum12.Val1, 2121);
+ val = enumCheck((int)Class2.Enum12.Val2, 2122);
+ val = enumCheck((int)Class2.Enum12.Val3, val);
+ val = enumCheck((int)Class2.Enum12.Val4, val);
+ val = enumCheck((int)Class2.Enum12.Val5h, 2121);
+ val = enumCheck((int)Class2.Enum12.Val6h, val);
+
+ val = 0;
+ val = enumCheck((int)Class2.Enum13.Val1, 2131);
+ val = enumCheck((int)Class2.Enum13.Val2, 2132);
+ val = enumCheck((int)Class2.Enum13.Val3, val);
+ val = enumCheck((int)Class2.Enum13.Val4, val);
+ val = enumCheck((int)Class2.Enum13.Val5i, 2131);
+ val = enumCheck((int)Class2.Enum13.Val6i, val);
+
+ val = 0;
+ val = enumCheck((int)Class2.Enum14.Val1, 2141);
+ val = enumCheck((int)Class2.Enum14.Val2, 2142);
+ val = enumCheck((int)Class2.Enum14.Val3, val);
+ val = enumCheck((int)Class2.Enum14.Val4, val);
+ val = enumCheck((int)Class2.Enum14.Val5j, 2141);
+ val = enumCheck((int)Class2.Enum14.Val6j, val);
+
+ val = 0;
+ val = enumCheck((int)Class2.Struct1.Enum12.Val1, 4121);
+ val = enumCheck((int)Class2.Struct1.Enum12.Val2, 4122);
+ val = enumCheck((int)Class2.Struct1.Enum12.Val3, val);
+ val = enumCheck((int)Class2.Struct1.Enum12.Val4, val);
+ val = enumCheck((int)Class2.Struct1.Enum12.Val5k, 4121);
+ val = enumCheck((int)Class2.Struct1.Enum12.Val6k, val);
+
+ val = 0;
+ val = enumCheck((int)Class2.Struct1.Enum13.Val1, 4131);
+ val = enumCheck((int)Class2.Struct1.Enum13.Val2, 4132);
+ val = enumCheck((int)Class2.Struct1.Enum13.Val3, val);
+ val = enumCheck((int)Class2.Struct1.Enum13.Val4, val);
+ val = enumCheck((int)Class2.Struct1.Enum13.Val5l, 4131);
+ val = enumCheck((int)Class2.Struct1.Enum13.Val6l, val);
+
+ val = 0;
+ val = enumCheck((int)Class2.Struct1.Enum14.Val1, 4141);
+ val = enumCheck((int)Class2.Struct1.Enum14.Val2, 4142);
+ val = enumCheck((int)Class2.Struct1.Enum14.Val3, val);
+ val = enumCheck((int)Class2.Struct1.Enum14.Val4, val);
+ val = enumCheck((int)Class2.Struct1.Enum14.Val5m, 4141);
+ val = enumCheck((int)Class2.Struct1.Enum14.Val6m, val);
+
+ Class1 class1 = new Class1();
+ enumCheck((int)class1.class1Test1(Enum1.Val5a), 13);
+ enumCheck((int)class1.class1Test2(Class1.Enum12.Val5c), 1121);
+ enumCheck((int)class1.class1Test3(Class1.Struct1.Enum12.Val5f), 3121);
+
+ enumCheck((int)cpp11_strongly_typed_enumerations.globalTest1(Enum1.Val5a), 13);
+ enumCheck((int)cpp11_strongly_typed_enumerations.globalTest2(Class1.Enum12.Val5c), 1121);
+ enumCheck((int)cpp11_strongly_typed_enumerations.globalTest3(Class1.Struct1.Enum12.Val5f), 3121);
+ }
+}
+
} catch (ArgumentOutOfRangeException e) {
String expectedMessage = "caught:" + i + "\n" + "Parameter name: input";
if (e.Message.Replace(runme.CRLF,"\n") != expectedMessage)
- throw new Exception("Exception message incorrect. Expected:\n[" + expectedMessage + "]\n" + "Received:\n[" + e.Message + "]");
+ throw new Exception("Exception message incorrect. Expected:\n[" +
+ expectedMessage + "]\n" + "Received:\n[" +
+ e.Message + "]");
if (e.ParamName != "input")
throw new Exception("Exception ParamName incorrect. Expected:\n[input]\n" + "Received:\n[" + e.ParamName + "]");
if (e.InnerException != null)
throw new Exception("throwsException.dub = " + throwsClass.dub + " expected: 1234.5678");
}
} catch (Exception e) {
- Console.Error.WriteLine("Test failed (thread " + threadId + "): " + e.Message);
+ Console.Error.WriteLine("Test failed (thread " + threadId + "): " + e.Message + "\n TestThread Inner stack trace: " + e.StackTrace);
Failed = true;
}
}
throw new Exception("Protected destructor exception should have been thrown");
} catch (MethodAccessException) {
}
-
- // calling private destructor test
- try {
- using (FFF f = new FFF()) {
- }
- throw new Exception("Private destructor exception should have been thrown");
- } catch (MethodAccessException) {
- }
}
}
--- /dev/null
+using System;
+using director_pass_by_valueNamespace;
+
+public class runme
+{
+ private static void WaitForGC()
+ {
+ System.GC.Collect();
+ System.GC.WaitForPendingFinalizers();
+ System.Threading.Thread.Sleep(10);
+ }
+
+ static void Main()
+ {
+ runme r = new runme();
+ r.run();
+ }
+
+ void run()
+ {
+ Caller caller = new Caller();
+ caller.call_virtualMethod(new director_pass_by_value_Derived());
+ {
+ int countdown = 5;
+ while (true) {
+ WaitForGC();
+ if (--countdown == 0)
+ break;
+ };
+ }
+ // bug was the passByVal 'global' object was destroyed after the call to virtualMethod had finished.
+ int ret = runme.passByVal.getVal();
+ if (ret != 0x12345678)
+ throw new Exception("Bad return value, got " + ret.ToString("x"));
+ }
+ public static PassedByValue passByVal;
+}
+
+class director_pass_by_value_Derived : DirectorPassByValueAbstractBase {
+ public override void virtualMethod(PassedByValue pbv) {
+ runme.passByVal = pbv;
+ }
+}
using director_smartptrNamespace;
+using System;
public class runme
{
-
private class director_smartptr_MyBarFoo : Foo
{
public override string ping()
{
- return "director_smartptr_MyBarFoo.ping();";
+ return "director_smartptr_MyBarFoo.ping()";
}
public override string pong()
return "director_smartptr_MyBarFoo.pong();" + ping();
}
- public override string fooBar(FooBar fooBar)
+ public override string upcall(FooBar fooBarPtr)
{
- return fooBar.FooBarDo();
+ return "override;" + fooBarPtr.FooBarDo();
}
public override Foo makeFoo()
{
return new Foo();
}
+ }
- public override FooBar makeFooBar()
- {
- return new FooBar();
- }
+ private static void check(string got, string expected)
+ {
+ if (got != expected)
+ throw new ApplicationException("Failed, got: " + got + " expected: " + expected);
}
static void Main()
{
- director_smartptr_MyBarFoo myBarFoo =
- new director_smartptr_MyBarFoo();
+ FooBar fooBar = new FooBar();
+
+ Foo myBarFoo = new director_smartptr_MyBarFoo();
+ check(myBarFoo.ping(), "director_smartptr_MyBarFoo.ping()");
+ check(Foo.callPong(myBarFoo), "director_smartptr_MyBarFoo.pong();director_smartptr_MyBarFoo.ping()");
+ check(Foo.callUpcall(myBarFoo, fooBar), "override;Bar::Foo2::Foo2Bar()");
+
+ Foo myFoo = myBarFoo.makeFoo();
+ check(myFoo.pong(), "Foo::pong();Foo::ping()");
+ check(Foo.callPong(myFoo), "Foo::pong();Foo::ping()");
+ check(myFoo.upcall(new FooBar()), "Bar::Foo2::Foo2Bar()");
- myBarFoo.ping();
+ Foo myFoo2 = new Foo().makeFoo();
+ check(myFoo2.pong(), "Foo::pong();Foo::ping()");
+ check(Foo.callPong(myFoo2), "Foo::pong();Foo::ping()");
}
}
HiddenDestructor hidden = HiddenDestructor.create();
hidden.Dispose();
+
+ HiddenPrivateDestructor hiddenPrivate = HiddenPrivateDestructor.create();
+ if (HiddenPrivateDestructor.DeleteCount != 0)
+ throw new ApplicationException("Count should be zero");
+ hiddenPrivate.Dispose();
+ if (HiddenPrivateDestructor.DeleteCount != 1)
+ throw new ApplicationException("Count should be one");
}
}
// Debugging flag
public static bool debug = false;
+ private static void WaitForGC()
+ {
+ System.GC.Collect();
+ System.GC.WaitForPendingFinalizers();
+ System.Threading.Thread.Sleep(10);
+ }
+
static void Main()
{
if (debug)
if (debug)
Console.WriteLine("Nearly finished");
- int countdown = 100;
- while (true) {
- System.GC.Collect();
- System.GC.WaitForPendingFinalizers();
- System.Threading.Thread.Sleep(10);
- if (--countdown == 0)
- break;
- if (Klass.getTotal_count() == 1) // Expect 1 instance - the one global variable (GlobalValue)
- break;
- };
- if (Klass.getTotal_count() != 1)
- throw new ApplicationException("Klass.total_count=" + Klass.getTotal_count());
+ {
+ int countdown = 500;
+ int expectedCount = 1;
+ while (true) {
+ WaitForGC();
+ if (--countdown == 0)
+ break;
+ if (Klass.getTotal_count() == expectedCount) // Expect the one global variable (GlobalValue)
+ break;
+ }
+ int actualCount = Klass.getTotal_count();
+ if (actualCount != expectedCount)
+ Console.Error.WriteLine("Expected count: " + expectedCount + " Actual count: " + actualCount); // Finalizers are not guaranteed to be run and sometimes they just don't
+ }
int wrapper_count = li_boost_shared_ptr.shared_ptr_wrapper_count();
if (wrapper_count != li_boost_shared_ptr.NOT_COUNTING)
- if (wrapper_count != 1) // Expect 1 instance - the one global variable (GlobalSmartValue)
+ if (wrapper_count != 1) // Expect the one global variable (GlobalSmartValue)
throw new ApplicationException("shared_ptr wrapper count=" + wrapper_count);
if (debug)
--- /dev/null
+using System;
+using li_std_auto_ptrNamespace;
+
+public class li_std_auto_ptr_runme {
+ private static void WaitForGC()
+ {
+ System.GC.Collect();
+ System.GC.WaitForPendingFinalizers();
+ System.Threading.Thread.Sleep(10);
+ }
+
+ public static void Main()
+ {
+ Klass k1 = li_std_auto_ptr.makeKlassAutoPtr("first");
+ if (k1.getLabel() != "first")
+ throw new Exception("wrong object label");
+
+ Klass k2 = li_std_auto_ptr.makeKlassAutoPtr("second");
+ if (Klass.getTotal_count() != 2)
+ throw new Exception("number of objects should be 2");
+
+ k1 = null;
+ {
+ int countdown = 500;
+ int expectedCount = 1;
+ while (true) {
+ WaitForGC();
+ if (--countdown == 0)
+ break;
+ if (Klass.getTotal_count() == expectedCount)
+ break;
+ };
+ int actualCount = Klass.getTotal_count();
+ if (actualCount != expectedCount)
+ Console.Error.WriteLine("Expected count: " + expectedCount + " Actual count: " + actualCount); // Finalizers are not guaranteed to be run and sometimes they just don't
+ }
+
+ if (k2.getLabel() != "second")
+ throw new Exception("wrong object label");
+
+ k2 = null;
+ {
+ int countdown = 500;
+ int expectedCount = 0;
+ while (true) {
+ WaitForGC();
+ if (--countdown == 0)
+ break;
+ if (Klass.getTotal_count() == expectedCount)
+ break;
+ }
+ int actualCount = Klass.getTotal_count();
+ if (actualCount != expectedCount)
+ Console.Error.WriteLine("Expected count: " + expectedCount + " Actual count: " + actualCount); // Finalizers are not guaranteed to be run and sometimes they just don't
+ }
+ }
+}
} catch (ArgumentException) {
}
}
-#if SWIG_DOTNET_1
- {
- // runtime check that 2D arrays fail
- double[,] outputarray = new double[collectionSize,collectionSize];
- try {
- vect.CopyTo(outputarray);
- throw new Exception("CopyTo (5a) test failed");
- } catch (ArgumentException) {
- }
- }
-#endif
{
StructVector inputvector = new StructVector();
int arrayLen = 10;
throw new Exception("Repeat (1) test failed");
}
}
-#if !SWIG_DOTNET_1
{
System.Collections.Generic.IEnumerator<double> myEnumerator = dv.GetEnumerator();
while ( myEnumerator.MoveNext() ) {
throw new Exception("Repeat (2) test failed");
}
}
-#endif
}
{
--- /dev/null
+
+using System;
+using li_swigtype_inoutNamespace;
+
+public class li_swigtype_inout_runme {
+
+ public static void Main() {
+ XXX xxx = new XXX(999);
+ check_count(1);
+ XXX x1 = null;
+ XXX x2 = null;
+ XXX x3 = null;
+ XXX x4 = null;
+ li_swigtype_inout.ptr_ref_out(out x1, out x2, out x3, out x4);
+ check_value(111, x1.value);
+ check_value(222, x2.value);
+ check_value(333, x3.value);
+ check_value(444, x4.value);
+ check_count(5);
+ x1.Dispose();
+ x2.Dispose();
+ x3.Dispose();
+ x4.Dispose();
+ xxx.Dispose();
+ check_count(0);
+
+ x1 = null;
+ x2 = null;
+ x3 = null;
+ x4 = null;
+ new ConstructorTest(out x1, out x2, out x3, out x4);
+ check_count(4);
+ check_value(111, x1.value);
+ check_value(222, x2.value);
+ check_value(333, x3.value);
+ check_value(444, x4.value);
+ x1.Dispose();
+ x2.Dispose();
+ x3.Dispose();
+ x4.Dispose();
+ check_count(0);
+ }
+
+ public static void check_count(int count) {
+ int actual = XXX.count;
+ if( count != actual ) {
+ throw new Exception(String.Format("Count wrong. Expected: {0} Got: {1}", count, actual));
+ }
+ }
+
+ public static void check_value(int expected, int actual) {
+ if( expected != actual ) {
+ throw new Exception(String.Format("Wrong value. Expected: {0} Got: {1}", expected, actual));
+ }
+ }
+}
--- /dev/null
+using System;
+using multiple_inheritance_abstractNamespace;
+
+public class multiple_inheritance_abstract_runme {
+
+ //Test base class as a parameter in C#
+ int jcbase1b(CBase1 cb1){
+ return cb1.cbase1y();
+ }
+ int jabase1(ABase1 ab1){
+ return ab1.abase1();
+ }
+ int jcbase2(CBase2 cb2){
+ return cb2.cbase2();
+ }
+
+ public static void check(bool fail, string msg) {
+ if (fail)
+ throw new Exception(msg);
+ }
+
+ public static void Main() {
+ //Test Derived1
+ Derived1 d1=new Derived1();
+ check(d1.cbase1y()!=3, "Derived1::cbase1y() failed");
+ check(d1.cbase2()!=4, "Derived1::cbase2() failed");
+
+ //Test Derived2
+ Derived2 d2=new Derived2();
+ check(d2.cbase1y()!=6, "Derived2::cbase1y() failed");
+ check(d2.abase1()!=5, "Derived2::abase1() failed");
+
+ //Test Derived3
+ Derived3 d3=new Derived3();
+ check(d3.cbase1y()!=7, "Derived3::cbase1y() failed");
+ check(d3.cbase2()!=8, "Derived3::cbase2() failed");
+ check(d3.abase1()!=9, "Derived3::abase1() failed");
+
+ //Test Bottom1
+ Bottom1 b1=new Bottom1();
+ check(b1.cbase1y()!=103, "Bottom1::cbase1y() failed");
+ check(b1.cbase2()!=104, "Bottom1::cbase2() failed");
+
+ //Test Bottom2
+ Bottom2 b2=new Bottom2();
+ check(b2.cbase1y()!=206, "Bottom2::cbase1y() failed");
+ check(b2.abase1()!=205, "Bottom2::abase1() failed");
+
+ //Test Bottom3
+ Bottom3 b3=new Bottom3();
+ check(b3.cbase1y()!=307, "Bottom3::cbase1y() failed");
+ check(b3.cbase2()!=308, "Bottom3::cbase2() failed");
+ check(b3.abase1()!=309, "Bottom3::abase1() failed");
+
+ //Test interfaces from c++ classes
+ CBase1 cb1=new CBase1SwigImpl();
+ CBase2 cb2=new CBase2SwigImpl();
+ check(cb1.cbase1y()!=1, "CBase1::cbase1y() failed");
+ check(cb2.cbase2()!=2, "CBase2::cbase2() failed");
+
+ //Test abstract class as return value
+ ABase1 ab1=d3.cloneit();
+ check(ab1.abase1()!=9, "Derived3::abase1() through ABase1 failed");
+
+ //Test concrete base class as return value
+ CBase1 cb6=d2.cloneit();
+ CBase2 cb7=d1.cloneit();
+ check(cb6.cbase1y()!=6, "Derived2::cbase1y() through CBase1 failed");
+ check(cb7.cbase2()!=4, "Derived1:cbase2() through ABase1 failed");
+
+ //Test multi inheritance
+ CBase1 cb3=new Derived1();
+ CBase1 cb4=new Derived3();
+ CBase2 cb5=new Derived3();
+ ABase1 ab6=new Derived2();
+ check(cb3.cbase1y()!=3, "Derived1::cbase1y() through CBase1 failed");
+ check(cb4.cbase1y()!=7, "Derived3::cbase1y() through CBase1 failed");
+ check(cb5.cbase2()!=8, "Derived3::cbase2() through CBase2 failed");
+ check(ab6.abase1()!=5, "Derived2::abase1() through ABase1 failed");
+
+ //Test base classes as parameter in C#
+ multiple_inheritance_abstract_runme mhar=new multiple_inheritance_abstract_runme();
+ check(mhar.jcbase1b(d1)!=3, "jcbase1b() through Derived1 as parameter failed");
+ check(mhar.jcbase1b(d2)!=6, "jcbase1b() through Derived2 as parameter failed");
+ check(mhar.jcbase1b(d3)!=7, "jcbase1b() through Derived3 as parameter failed");
+ check(mhar.jcbase2(d1)!=4, "jcbase2() through Derived1 as parameter failed");
+ check(mhar.jcbase2(d3)!=8, "jcbase2() through Derived3 as parameter failed");
+ check(mhar.jabase1(d2)!=5, "jabase1() through Derived2 as parameter failed");
+ check(mhar.jabase1(d3)!=9, "jabase1() through Derived3 as parameter failed");
+
+ //Value parameters
+ //Test CBase1 CBase2 as parameters (note slicing for Derived and Bottom classes)
+ check(multiple_inheritance_abstract.InputValCBase1(d1)!=1, "InputValCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase1(d2)!=1, "InputValCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase1(d3)!=1, "InputValCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase2(d3)!=2, "InputValCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase2(d1)!=2, "InputValCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase1(cb1)!=1, "InputValCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase2(cb2)!=2, "InputValCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase1(b1)!=1, "InputValCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase1(b2)!=1, "InputValCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase1(b3)!=1, "InputValCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase2(b3)!=2, "InputValCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase2(b1)!=2, "InputValCBase2(), Bottom1 as a parameter failed");
+
+ //Pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_abstract.InputPtrABase1(d2)!=5, "InputPtrABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrABase1(d3)!=9, "InputPtrABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrABase1(b2)!=205, "InputPtrABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrABase1(b3)!=309, "InputPtrABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_abstract.InputPtrCBase1(d1)!=3, "InputPtrCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase1(d2)!=6, "InputPtrCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase1(d3)!=7, "InputPtrCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase2(d3)!=8, "InputPtrCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase2(d1)!=4, "InputPtrCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase1(cb1)!=1, "InputPtrCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase2(cb2)!=2, "InputPtrCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase1(b1)!=103, "InputPtrCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase1(b2)!=206, "InputPtrCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase1(b3)!=307, "InputPtrCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase2(b3)!=308, "InputPtrCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase2(b1)!=104, "InputPtrCBase2(), Bottom1 as a parameter failed");
+
+ //Reference parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_abstract.InputRefABase1(d2)!=5, "InputRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefABase1(d3)!=9, "InputRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefABase1(b2)!=205, "InputRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefABase1(b3)!=309, "InputRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_abstract.InputRefCBase1(d1)!=3, "InputRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase1(d2)!=6, "InputRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase1(d3)!=7, "InputRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase2(d3)!=8, "InputRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase2(d1)!=4, "InputRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase1(cb1)!=1, "InputRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase2(cb2)!=2, "InputRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase1(b1)!=103, "InputRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase1(b2)!=206, "InputRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase1(b3)!=307, "InputRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase2(b3)!=308, "InputRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase2(b1)!=104, "InputRefCBase2(), Bottom1 as a parameter failed");
+
+ //Const reference pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_abstract.InputCPtrRefABase1(d2)!=5, "InputCPtrRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefABase1(d3)!=9, "InputCPtrRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefABase1(b2)!=205, "InputCPtrRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefABase1(b3)!=309, "InputCPtrRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(d1)!=3, "InputCPtrRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(d2)!=6, "InputCPtrRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(d3)!=7, "InputCPtrRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase2(d3)!=8, "InputCPtrRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase2(d1)!=4, "InputCPtrRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(cb1)!=1, "InputCPtrRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase2(cb2)!=2, "InputCPtrRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(b1)!=103, "InputCPtrRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(b2)!=206, "InputCPtrRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(b3)!=307, "InputCPtrRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase2(b3)!=308, "InputCPtrRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase2(b1)!=104, "InputCPtrRefCBase2(), Bottom1 as a parameter failed");
+
+ //Derived classes as parameters
+ check(multiple_inheritance_abstract.InputValDerived1(d1)!=3+4, "InputValDerived1() failed");
+ check(multiple_inheritance_abstract.InputValDerived2(d2)!=6+5, "InputValDerived2() failed");
+ check(multiple_inheritance_abstract.InputValDerived3(d3)!=7+8+9, "InputValDerived3() failed");
+
+ check(multiple_inheritance_abstract.InputRefDerived1(d1)!=3+4, "InputRefDerived1() failed");
+ check(multiple_inheritance_abstract.InputRefDerived2(d2)!=6+5, "InputRefDerived2() failed");
+ check(multiple_inheritance_abstract.InputRefDerived3(d3)!=7+8+9, "InputRefDerived3() failed");
+
+ check(multiple_inheritance_abstract.InputPtrDerived1(d1)!=3+4, "InputPtrDerived1() failed");
+ check(multiple_inheritance_abstract.InputPtrDerived2(d2)!=6+5, "InputPtrDerived2() failed");
+ check(multiple_inheritance_abstract.InputPtrDerived3(d3)!=7+8+9, "InputPtrDerived3() failed");
+
+ check(multiple_inheritance_abstract.InputCPtrRefDerived1(d1)!=3+4, "InputCPtrRefDerived1() failed");
+ check(multiple_inheritance_abstract.InputCPtrRefDerived2(d2)!=6+5, "InputCPtrRefDerived2() failed");
+ check(multiple_inheritance_abstract.InputCPtrRefDerived3(d3)!=7+8+9, "InputCPtrRefDerived3() failed");
+
+ //Bottom classes as Derived parameters
+ check(multiple_inheritance_abstract.InputValDerived1(b1)!=3+4, "InputValDerived1() failed");
+ check(multiple_inheritance_abstract.InputValDerived2(b2)!=6+5, "InputValDerived2() failed");
+ check(multiple_inheritance_abstract.InputValDerived3(b3)!=7+8+9, "InputValDerived3() failed");
+
+ check(multiple_inheritance_abstract.InputRefDerived1(b1)!=103+104, "InputRefDerived1() failed");
+ check(multiple_inheritance_abstract.InputRefDerived2(b2)!=206+205, "InputRefDerived2() failed");
+ check(multiple_inheritance_abstract.InputRefDerived3(b3)!=307+308+309, "InputRefDerived3() failed");
+
+ check(multiple_inheritance_abstract.InputPtrDerived1(b1)!=103+104, "InputPtrDerived1() failed");
+ check(multiple_inheritance_abstract.InputPtrDerived2(b2)!=206+205, "InputPtrDerived2() failed");
+ check(multiple_inheritance_abstract.InputPtrDerived3(b3)!=307+308+309, "InputPtrDerived3() failed");
+
+ check(multiple_inheritance_abstract.InputCPtrRefDerived1(b1)!=103+104, "InputCPtrRefDerived1() failed");
+ check(multiple_inheritance_abstract.InputCPtrRefDerived2(b2)!=206+205, "InputCPtrRefDerived2() failed");
+ check(multiple_inheritance_abstract.InputCPtrRefDerived3(b3)!=307+308+309, "InputCPtrRefDerived3() failed");
+
+ //Bottom classes as Bottom parameters
+ check(multiple_inheritance_abstract.InputValBottom1(b1)!=103+104, "InputValBottom1() failed");
+ check(multiple_inheritance_abstract.InputValBottom2(b2)!=206+205, "InputValBottom2() failed");
+ check(multiple_inheritance_abstract.InputValBottom3(b3)!=307+308+309, "InputValBottom3() failed");
+
+ check(multiple_inheritance_abstract.InputRefBottom1(b1)!=103+104, "InputRefBottom1() failed");
+ check(multiple_inheritance_abstract.InputRefBottom2(b2)!=206+205, "InputRefBottom2() failed");
+ check(multiple_inheritance_abstract.InputRefBottom3(b3)!=307+308+309, "InputRefBottom3() failed");
+
+ check(multiple_inheritance_abstract.InputPtrBottom1(b1)!=103+104, "InputPtrBottom1() failed");
+ check(multiple_inheritance_abstract.InputPtrBottom2(b2)!=206+205, "InputPtrBottom2() failed");
+ check(multiple_inheritance_abstract.InputPtrBottom3(b3)!=307+308+309, "InputPtrBottom3() failed");
+
+ check(multiple_inheritance_abstract.InputCPtrRefBottom1(b1)!=103+104, "InputCPtrRefBottom1() failed");
+ check(multiple_inheritance_abstract.InputCPtrRefBottom2(b2)!=206+205, "InputCPtrRefBottom2() failed");
+ check(multiple_inheritance_abstract.InputCPtrRefBottom3(b3)!=307+308+309, "InputCPtrRefBottom3() failed");
+ // Return pointers
+ check(multiple_inheritance_abstract.MakePtrDerived1_CBase1().cbase1y()!=3, "MakePtrDerived1_CBase1 failed");
+ check(multiple_inheritance_abstract.MakePtrDerived1_CBase2().cbase2()!=4, "MakePtrDerived1_CBase2 failed");
+ check(multiple_inheritance_abstract.MakePtrDerived2_CBase1().cbase1y()!=6, "MakePtrDerived2_CBase1 failed");
+ check(multiple_inheritance_abstract.MakePtrDerived2_ABase1().abase1()!=5, "MakePtrDerived2_ABase1 failed");
+ check(multiple_inheritance_abstract.MakePtrDerived3_ABase1().abase1()!=9, "MakePtrDerived3_ABase1 failed");
+ check(multiple_inheritance_abstract.MakePtrDerived3_CBase1().cbase1y()!=7, "MakePtrDerived3_CBase1 failed");
+ check(multiple_inheritance_abstract.MakePtrDerived3_CBase2().cbase2()!=8, "MakePtrDerived3_CBase2 failed");
+
+ // Return references
+ check(multiple_inheritance_abstract.MakeRefDerived1_CBase1().cbase1y()!=3, "MakeRefDerived1_CBase1 failed");
+ check(multiple_inheritance_abstract.MakeRefDerived1_CBase2().cbase2()!=4, "MakeRefDerived1_CBase2 failed");
+ check(multiple_inheritance_abstract.MakeRefDerived2_CBase1().cbase1y()!=6, "MakeRefDerived2_CBase1 failed");
+ check(multiple_inheritance_abstract.MakeRefDerived2_ABase1().abase1()!=5, "MakeRefDerived2_ABase1 failed");
+ check(multiple_inheritance_abstract.MakeRefDerived3_ABase1().abase1()!=9, "MakeRefDerived3_ABase1 failed");
+ check(multiple_inheritance_abstract.MakeRefDerived3_CBase1().cbase1y()!=7, "MakeRefDerived3_CBase1 failed");
+ check(multiple_inheritance_abstract.MakeRefDerived3_CBase2().cbase2()!=8, "MakeRefDerived3_CBase2 failed");
+
+ // Return by value (sliced objects)
+ check(multiple_inheritance_abstract.MakeValDerived1_CBase1().cbase1y()!=1, "MakeValDerived1_CBase1 failed");
+ check(multiple_inheritance_abstract.MakeValDerived1_CBase2().cbase2()!=2, "MakeValDerived1_CBase2 failed");
+ check(multiple_inheritance_abstract.MakeValDerived2_CBase1().cbase1y()!=1, "MakeValDerived2_CBase1 failed");
+ check(multiple_inheritance_abstract.MakeValDerived3_CBase1().cbase1y()!=1, "MakeValDerived3_CBase1 failed");
+ check(multiple_inheritance_abstract.MakeValDerived3_CBase2().cbase2()!=2, "MakeValDerived3_CBase2 failed");
+
+ }
+}
--- /dev/null
+using System;
+using System.Collections.Generic;
+using multiple_inheritance_interfacesNamespace;
+
+public class multiple_inheritance_interfaces_runme {
+
+ static string SortArrayToString(string[] types) {
+ Array.Sort<string>(types);
+ return string.Join(" ", types);
+ }
+
+ static string SortArrayToString(Type[] types) {
+ List<string> stypes = new List<string>();
+ foreach (Type t in types)
+ stypes.Add(t.Name);
+ return SortArrayToString(stypes.ToArray());
+ }
+
+
+ private static void checkBaseAndInterfaces(Type cls, bool interfaceExpected, string baseClass, string[] interfaces) {
+ string[] expectedInterfaces = new string[interfaces.Length + (interfaceExpected ? 0 : 1)];
+ for (int i=0; i<interfaces.Length; ++i)
+ expectedInterfaces[i] = interfaces[i];
+ if (!interfaceExpected)
+ expectedInterfaces[interfaces.Length] = "IDisposable";
+ Type[] actualInterfaces = cls.GetInterfaces();
+ string expectedInterfacesString = SortArrayToString(expectedInterfaces);
+ string actualInterfacesString = SortArrayToString(actualInterfaces);
+ if (expectedInterfacesString != actualInterfacesString)
+ throw new Exception("Expected interfaces for " + cls.Name + ": \n" + expectedInterfacesString + "\n" + "Actual interfaces: \n" + actualInterfacesString);
+
+ string expectedBaseString = null;
+ if (interfaceExpected) {
+ // expecting an interface
+ if (!cls.IsInterface)
+ throw new Exception(cls.Name + " should be an interface but is not");
+ expectedBaseString = string.IsNullOrEmpty(baseClass) ? "" : "multiple_inheritance_interfacesNamespace." + baseClass;
+ } else {
+ // expecting a class
+ if (cls.IsInterface)
+ throw new Exception(cls.Name + " is an interface but it should not be");
+ expectedBaseString = string.IsNullOrEmpty(baseClass) ? "Object" : baseClass;
+ }
+
+ string actualBaseString = cls.BaseType == null ? "" : cls.BaseType.Name;
+ if (expectedBaseString != actualBaseString)
+ throw new Exception("Expected base for " + cls.Name + ": [" + expectedBaseString + "]" + " Actual base: [" + actualBaseString + "]");
+ }
+
+ public static void Main() {
+ // Note that we can't get just the immediate interface
+ // Type.GetInterfaces() returns all interfaces up the inheritance hierarchy
+ checkBaseAndInterfaces(typeof(IA), true, "", new string[] {});
+ checkBaseAndInterfaces(typeof(IB), true, "", new string[] {});
+ checkBaseAndInterfaces(typeof(IC), true, "", new string[] {"IA", "IB"});
+ checkBaseAndInterfaces(typeof(A), false, "", new string[] {"IA"});
+ checkBaseAndInterfaces(typeof(B), false, "", new string[] {"IB"});
+ checkBaseAndInterfaces(typeof(C), false, "", new string[] {"IA", "IB", "IC"});
+ checkBaseAndInterfaces(typeof(D), false, "", new string[] {"IA", "IB", "IC"});
+ checkBaseAndInterfaces(typeof(E), false, "D", new string[] {"IA", "IB", "IC"});
+
+ checkBaseAndInterfaces(typeof(IJ), true, "", new string[] {});
+ checkBaseAndInterfaces(typeof(IK), true, "", new string[] {"IJ"});
+ checkBaseAndInterfaces(typeof(IL), true, "", new string[] {"IJ", "IK"});
+ checkBaseAndInterfaces(typeof(J), false, "", new string[] {"IJ"});
+ checkBaseAndInterfaces(typeof(K), false, "", new string[] {"IJ", "IK"});
+ checkBaseAndInterfaces(typeof(L), false, "", new string[] {"IJ", "IK", "IL"});
+ checkBaseAndInterfaces(typeof(M), false, "", new string[] {"IJ", "IK", "IL"});
+
+ checkBaseAndInterfaces(typeof(P), false, "", new string[] {});
+ checkBaseAndInterfaces(typeof(IQ), true, "", new string[] {});
+ checkBaseAndInterfaces(typeof(Q), false, "", new string[] {"IQ"});
+ checkBaseAndInterfaces(typeof(R), false, "P", new string[] {"IQ"});
+ checkBaseAndInterfaces(typeof(S), false, "P", new string[] {"IQ"});
+ checkBaseAndInterfaces(typeof(T), false, "", new string[] {"IQ"});
+ checkBaseAndInterfaces(typeof(U), false, "R", new string[] {"IQ"});
+ checkBaseAndInterfaces(typeof(V), false, "S", new string[] {"IQ"});
+ checkBaseAndInterfaces(typeof(W), false, "T", new string[] {"IQ"});
+
+ // overloaded methods check
+ D d = new D();
+ d.ia();
+ d.ia(10);
+ d.ia("bye");
+ d.ia("bye", false);
+ }
+}
--- /dev/null
+using System;
+using multiple_inheritance_nspaceNamespace;
+using multiple_inheritance_nspaceNamespace.Space;
+
+public class multiple_inheritance_nspace_runme {
+
+ //Test base class as a parameter in C#
+ int jcbase1b(CBase1SwigInterface cb1){
+ return cb1.cbase1y();
+ }
+ int jabase1(ABase1SwigInterface ab1){
+ return ab1.abase1();
+ }
+ int jcbase2(CBase2SwigInterface cb2){
+ return cb2.cbase2();
+ }
+
+ public static void check(bool fail, string msg) {
+ if (fail)
+ throw new Exception(msg);
+ }
+
+ public static void Main() {
+ //Test Derived1
+ Derived1 d1=new Derived1();
+ check(d1.cbase1y()!=3, "Derived1::cbase1y() failed");
+ check(d1.cbase2()!=4, "Derived1::cbase2() failed");
+
+ //Test Derived2
+ Derived2 d2=new Derived2();
+ check(d2.cbase1y()!=6, "Derived2::cbase1y() failed");
+ check(d2.abase1()!=5, "Derived2::abase1() failed");
+
+ //Test Derived3
+ Derived3 d3=new Derived3();
+ check(d3.cbase1y()!=7, "Derived3::cbase1y() failed");
+ check(d3.cbase2()!=8, "Derived3::cbase2() failed");
+ check(d3.abase1()!=9, "Derived3::abase1() failed");
+
+ //Test Bottom1
+ Bottom1 b1=new Bottom1();
+ check(b1.cbase1y()!=103, "Bottom1::cbase1y() failed");
+ check(b1.cbase2()!=104, "Bottom1::cbase2() failed");
+
+ //Test Bottom2
+ Bottom2 b2=new Bottom2();
+ check(b2.cbase1y()!=206, "Bottom2::cbase1y() failed");
+ check(b2.abase1()!=205, "Bottom2::abase1() failed");
+
+ //Test Bottom3
+ Bottom3 b3=new Bottom3();
+ check(b3.cbase1y()!=307, "Bottom3::cbase1y() failed");
+ check(b3.cbase2()!=308, "Bottom3::cbase2() failed");
+ check(b3.abase1()!=309, "Bottom3::abase1() failed");
+
+ //Test interfaces from c++ classes
+ CBase1SwigInterface cb1=new CBase1();
+ CBase2SwigInterface cb2=new CBase2();
+ check(cb1.cbase1y()!=1, "CBase1::cbase1y() failed");
+ check(cb2.cbase2()!=2, "CBase2::cbase2() failed");
+
+ //Test nspace class as return value
+ ABase1SwigInterface ab1=d3.cloneit();
+ check(ab1.abase1()!=9, "Derived3::abase1() through ABase1 failed");
+
+ //Test concrete base class as return value
+ CBase1SwigInterface cb6=d2.cloneit();
+ CBase2SwigInterface cb7=d1.cloneit();
+ check(cb6.cbase1y()!=6, "Derived2::cbase1y() through CBase1 failed");
+ check(cb7.cbase2()!=4, "Derived1:cbase2() through ABase1 failed");
+
+ //Test multi inheritance
+ CBase1SwigInterface cb3=new Derived1();
+ CBase1SwigInterface cb4=new Derived3();
+ CBase2SwigInterface cb5=new Derived3();
+ ABase1SwigInterface ab6=new Derived2();
+ check(cb3.cbase1y()!=3, "Derived1::cbase1y() through CBase1 failed");
+ check(cb4.cbase1y()!=7, "Derived3::cbase1y() through CBase1 failed");
+ check(cb5.cbase2()!=8, "Derived3::cbase2() through CBase2 failed");
+ check(ab6.abase1()!=5, "Derived2::abase1() through ABase1 failed");
+
+ //Test base classes as parameter in C#
+ multiple_inheritance_nspace_runme mhar=new multiple_inheritance_nspace_runme();
+ check(mhar.jcbase1b(d1)!=3, "jcbase1b() through Derived1 as parameter failed");
+ check(mhar.jcbase1b(d2)!=6, "jcbase1b() through Derived2 as parameter failed");
+ check(mhar.jcbase1b(d3)!=7, "jcbase1b() through Derived3 as parameter failed");
+ check(mhar.jcbase2(d1)!=4, "jcbase2() through Derived1 as parameter failed");
+ check(mhar.jcbase2(d3)!=8, "jcbase2() through Derived3 as parameter failed");
+ check(mhar.jabase1(d2)!=5, "jabase1() through Derived2 as parameter failed");
+ check(mhar.jabase1(d3)!=9, "jabase1() through Derived3 as parameter failed");
+
+ //Value parameters
+ //Test CBase1 CBase2 as parameters (note slicing for Derived and Bottom classes)
+ check(multiple_inheritance_nspace.InputValCBase1(d1)!=1, "InputValCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase1(d2)!=1, "InputValCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase1(d3)!=1, "InputValCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase2(d3)!=2, "InputValCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase2(d1)!=2, "InputValCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase1(cb1)!=1, "InputValCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase2(cb2)!=2, "InputValCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase1(b1)!=1, "InputValCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase1(b2)!=1, "InputValCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase1(b3)!=1, "InputValCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase2(b3)!=2, "InputValCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase2(b1)!=2, "InputValCBase2(), Bottom1 as a parameter failed");
+
+ //Pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_nspace.InputPtrABase1(d2)!=5, "InputPtrABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrABase1(d3)!=9, "InputPtrABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrABase1(b2)!=205, "InputPtrABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrABase1(b3)!=309, "InputPtrABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_nspace.InputPtrCBase1(d1)!=3, "InputPtrCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase1(d2)!=6, "InputPtrCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase1(d3)!=7, "InputPtrCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase2(d3)!=8, "InputPtrCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase2(d1)!=4, "InputPtrCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase1(cb1)!=1, "InputPtrCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase2(cb2)!=2, "InputPtrCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase1(b1)!=103, "InputPtrCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase1(b2)!=206, "InputPtrCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase1(b3)!=307, "InputPtrCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase2(b3)!=308, "InputPtrCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase2(b1)!=104, "InputPtrCBase2(), Bottom1 as a parameter failed");
+
+ //Reference parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_nspace.InputRefABase1(d2)!=5, "InputRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefABase1(d3)!=9, "InputRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefABase1(b2)!=205, "InputRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefABase1(b3)!=309, "InputRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_nspace.InputRefCBase1(d1)!=3, "InputRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase1(d2)!=6, "InputRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase1(d3)!=7, "InputRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase2(d3)!=8, "InputRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase2(d1)!=4, "InputRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase1(cb1)!=1, "InputRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase2(cb2)!=2, "InputRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase1(b1)!=103, "InputRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase1(b2)!=206, "InputRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase1(b3)!=307, "InputRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase2(b3)!=308, "InputRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase2(b1)!=104, "InputRefCBase2(), Bottom1 as a parameter failed");
+
+ //Const reference pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_nspace.InputCPtrRefABase1(d2)!=5, "InputCPtrRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefABase1(d3)!=9, "InputCPtrRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefABase1(b2)!=205, "InputCPtrRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefABase1(b3)!=309, "InputCPtrRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(d1)!=3, "InputCPtrRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(d2)!=6, "InputCPtrRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(d3)!=7, "InputCPtrRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase2(d3)!=8, "InputCPtrRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase2(d1)!=4, "InputCPtrRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(cb1)!=1, "InputCPtrRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase2(cb2)!=2, "InputCPtrRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(b1)!=103, "InputCPtrRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(b2)!=206, "InputCPtrRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(b3)!=307, "InputCPtrRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase2(b3)!=308, "InputCPtrRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase2(b1)!=104, "InputCPtrRefCBase2(), Bottom1 as a parameter failed");
+
+ //Derived classes as parameters
+ check(multiple_inheritance_nspace.InputValDerived1(d1)!=3+4, "InputValDerived1() failed");
+ check(multiple_inheritance_nspace.InputValDerived2(d2)!=6+5, "InputValDerived2() failed");
+ check(multiple_inheritance_nspace.InputValDerived3(d3)!=7+8+9, "InputValDerived3() failed");
+
+ check(multiple_inheritance_nspace.InputRefDerived1(d1)!=3+4, "InputRefDerived1() failed");
+ check(multiple_inheritance_nspace.InputRefDerived2(d2)!=6+5, "InputRefDerived2() failed");
+ check(multiple_inheritance_nspace.InputRefDerived3(d3)!=7+8+9, "InputRefDerived3() failed");
+
+ check(multiple_inheritance_nspace.InputPtrDerived1(d1)!=3+4, "InputPtrDerived1() failed");
+ check(multiple_inheritance_nspace.InputPtrDerived2(d2)!=6+5, "InputPtrDerived2() failed");
+ check(multiple_inheritance_nspace.InputPtrDerived3(d3)!=7+8+9, "InputPtrDerived3() failed");
+
+ check(multiple_inheritance_nspace.InputCPtrRefDerived1(d1)!=3+4, "InputCPtrRefDerived1() failed");
+ check(multiple_inheritance_nspace.InputCPtrRefDerived2(d2)!=6+5, "InputCPtrRefDerived2() failed");
+ check(multiple_inheritance_nspace.InputCPtrRefDerived3(d3)!=7+8+9, "InputCPtrRefDerived3() failed");
+
+ //Bottom classes as Derived parameters
+ check(multiple_inheritance_nspace.InputValDerived1(b1)!=3+4, "InputValDerived1() failed");
+ check(multiple_inheritance_nspace.InputValDerived2(b2)!=6+5, "InputValDerived2() failed");
+ check(multiple_inheritance_nspace.InputValDerived3(b3)!=7+8+9, "InputValDerived3() failed");
+
+ check(multiple_inheritance_nspace.InputRefDerived1(b1)!=103+104, "InputRefDerived1() failed");
+ check(multiple_inheritance_nspace.InputRefDerived2(b2)!=206+205, "InputRefDerived2() failed");
+ check(multiple_inheritance_nspace.InputRefDerived3(b3)!=307+308+309, "InputRefDerived3() failed");
+
+ check(multiple_inheritance_nspace.InputPtrDerived1(b1)!=103+104, "InputPtrDerived1() failed");
+ check(multiple_inheritance_nspace.InputPtrDerived2(b2)!=206+205, "InputPtrDerived2() failed");
+ check(multiple_inheritance_nspace.InputPtrDerived3(b3)!=307+308+309, "InputPtrDerived3() failed");
+
+ check(multiple_inheritance_nspace.InputCPtrRefDerived1(b1)!=103+104, "InputCPtrRefDerived1() failed");
+ check(multiple_inheritance_nspace.InputCPtrRefDerived2(b2)!=206+205, "InputCPtrRefDerived2() failed");
+ check(multiple_inheritance_nspace.InputCPtrRefDerived3(b3)!=307+308+309, "InputCPtrRefDerived3() failed");
+
+ //Bottom classes as Bottom parameters
+ check(multiple_inheritance_nspace.InputValBottom1(b1)!=103+104, "InputValBottom1() failed");
+ check(multiple_inheritance_nspace.InputValBottom2(b2)!=206+205, "InputValBottom2() failed");
+ check(multiple_inheritance_nspace.InputValBottom3(b3)!=307+308+309, "InputValBottom3() failed");
+
+ check(multiple_inheritance_nspace.InputRefBottom1(b1)!=103+104, "InputRefBottom1() failed");
+ check(multiple_inheritance_nspace.InputRefBottom2(b2)!=206+205, "InputRefBottom2() failed");
+ check(multiple_inheritance_nspace.InputRefBottom3(b3)!=307+308+309, "InputRefBottom3() failed");
+
+ check(multiple_inheritance_nspace.InputPtrBottom1(b1)!=103+104, "InputPtrBottom1() failed");
+ check(multiple_inheritance_nspace.InputPtrBottom2(b2)!=206+205, "InputPtrBottom2() failed");
+ check(multiple_inheritance_nspace.InputPtrBottom3(b3)!=307+308+309, "InputPtrBottom3() failed");
+
+ check(multiple_inheritance_nspace.InputCPtrRefBottom1(b1)!=103+104, "InputCPtrRefBottom1() failed");
+ check(multiple_inheritance_nspace.InputCPtrRefBottom2(b2)!=206+205, "InputCPtrRefBottom2() failed");
+ check(multiple_inheritance_nspace.InputCPtrRefBottom3(b3)!=307+308+309, "InputCPtrRefBottom3() failed");
+ // Return pointers
+ check(multiple_inheritance_nspace.MakePtrDerived1_CBase1().cbase1y()!=3, "MakePtrDerived1_CBase1 failed");
+ check(multiple_inheritance_nspace.MakePtrDerived1_CBase2().cbase2()!=4, "MakePtrDerived1_CBase2 failed");
+ check(multiple_inheritance_nspace.MakePtrDerived2_CBase1().cbase1y()!=6, "MakePtrDerived2_CBase1 failed");
+ check(multiple_inheritance_nspace.MakePtrDerived2_ABase1().abase1()!=5, "MakePtrDerived2_ABase1 failed");
+ check(multiple_inheritance_nspace.MakePtrDerived3_ABase1().abase1()!=9, "MakePtrDerived3_ABase1 failed");
+ check(multiple_inheritance_nspace.MakePtrDerived3_CBase1().cbase1y()!=7, "MakePtrDerived3_CBase1 failed");
+ check(multiple_inheritance_nspace.MakePtrDerived3_CBase2().cbase2()!=8, "MakePtrDerived3_CBase2 failed");
+
+ // Return references
+ check(multiple_inheritance_nspace.MakeRefDerived1_CBase1().cbase1y()!=3, "MakeRefDerived1_CBase1 failed");
+ check(multiple_inheritance_nspace.MakeRefDerived1_CBase2().cbase2()!=4, "MakeRefDerived1_CBase2 failed");
+ check(multiple_inheritance_nspace.MakeRefDerived2_CBase1().cbase1y()!=6, "MakeRefDerived2_CBase1 failed");
+ check(multiple_inheritance_nspace.MakeRefDerived2_ABase1().abase1()!=5, "MakeRefDerived2_ABase1 failed");
+ check(multiple_inheritance_nspace.MakeRefDerived3_ABase1().abase1()!=9, "MakeRefDerived3_ABase1 failed");
+ check(multiple_inheritance_nspace.MakeRefDerived3_CBase1().cbase1y()!=7, "MakeRefDerived3_CBase1 failed");
+ check(multiple_inheritance_nspace.MakeRefDerived3_CBase2().cbase2()!=8, "MakeRefDerived3_CBase2 failed");
+
+ // Return by value (sliced objects)
+ check(multiple_inheritance_nspace.MakeValDerived1_CBase1().cbase1y()!=1, "MakeValDerived1_CBase1 failed");
+ check(multiple_inheritance_nspace.MakeValDerived1_CBase2().cbase2()!=2, "MakeValDerived1_CBase2 failed");
+ check(multiple_inheritance_nspace.MakeValDerived2_CBase1().cbase1y()!=1, "MakeValDerived2_CBase1 failed");
+ check(multiple_inheritance_nspace.MakeValDerived3_CBase1().cbase1y()!=1, "MakeValDerived3_CBase1 failed");
+ check(multiple_inheritance_nspace.MakeValDerived3_CBase2().cbase2()!=2, "MakeValDerived3_CBase2 failed");
+
+ }
+}
--- /dev/null
+using System;
+using multiple_inheritance_shared_ptrNamespace;
+
+public class multiple_inheritance_shared_ptr_runme {
+
+ //Test base class as a parameter in C#
+ int jcbase1b(CBase1 cb1){
+ return cb1.cbase1y();
+ }
+ int jabase1(ABase1 ab1){
+ return ab1.abase1();
+ }
+ int jcbase2(CBase2 cb2){
+ return cb2.cbase2();
+ }
+
+ public static void check(bool fail, string msg) {
+ if (fail)
+ throw new Exception(msg);
+ }
+
+ public static void Main() {
+ //Test Derived1
+ Derived1 d1=new Derived1();
+ check(d1.cbase1y()!=3, "Derived1::cbase1y() failed");
+ check(d1.cbase2()!=4, "Derived1::cbase2() failed");
+
+ //Test Derived2
+ Derived2 d2=new Derived2();
+ check(d2.cbase1y()!=6, "Derived2::cbase1y() failed");
+ check(d2.abase1()!=5, "Derived2::abase1() failed");
+
+ //Test Derived3
+ Derived3 d3=new Derived3();
+ check(d3.cbase1y()!=7, "Derived3::cbase1y() failed");
+ check(d3.cbase2()!=8, "Derived3::cbase2() failed");
+ check(d3.abase1()!=9, "Derived3::abase1() failed");
+
+ //Test Bottom1
+ Bottom1 b1=new Bottom1();
+ check(b1.cbase1y()!=103, "Bottom1::cbase1y() failed");
+ check(b1.cbase2()!=104, "Bottom1::cbase2() failed");
+
+ //Test Bottom2
+ Bottom2 b2=new Bottom2();
+ check(b2.cbase1y()!=206, "Bottom2::cbase1y() failed");
+ check(b2.abase1()!=205, "Bottom2::abase1() failed");
+
+ //Test Bottom3
+ Bottom3 b3=new Bottom3();
+ check(b3.cbase1y()!=307, "Bottom3::cbase1y() failed");
+ check(b3.cbase2()!=308, "Bottom3::cbase2() failed");
+ check(b3.abase1()!=309, "Bottom3::abase1() failed");
+
+ //Test interfaces from c++ classes
+ CBase1 cb1=new CBase1SwigImpl();
+ CBase2 cb2=new CBase2SwigImpl();
+ check(cb1.cbase1y()!=1, "CBase1::cbase1y() failed");
+ check(cb2.cbase2()!=2, "CBase2::cbase2() failed");
+
+ //Test abstract class as return value
+ ABase1 ab1=d3.cloneit();
+ check(ab1.abase1()!=9, "Derived3::abase1() through ABase1 failed");
+
+ //Test concrete base class as return value
+ CBase1 cb6=d2.cloneit();
+ CBase2 cb7=d1.cloneit();
+ check(cb6.cbase1y()!=6, "Derived2::cbase1y() through CBase1 failed");
+ check(cb7.cbase2()!=4, "Derived1:cbase2() through ABase1 failed");
+
+ //Test multi inheritance
+ CBase1 cb3=new Derived1();
+ CBase1 cb4=new Derived3();
+ CBase2 cb5=new Derived3();
+ ABase1 ab6=new Derived2();
+ check(cb3.cbase1y()!=3, "Derived1::cbase1y() through CBase1 failed");
+ check(cb4.cbase1y()!=7, "Derived3::cbase1y() through CBase1 failed");
+ check(cb5.cbase2()!=8, "Derived3::cbase2() through CBase2 failed");
+ check(ab6.abase1()!=5, "Derived2::abase1() through ABase1 failed");
+
+ //Test base classes as parameter in C#
+ multiple_inheritance_shared_ptr_runme mhar=new multiple_inheritance_shared_ptr_runme();
+ check(mhar.jcbase1b(d1)!=3, "jcbase1b() through Derived1 as parameter failed");
+ check(mhar.jcbase1b(d2)!=6, "jcbase1b() through Derived2 as parameter failed");
+ check(mhar.jcbase1b(d3)!=7, "jcbase1b() through Derived3 as parameter failed");
+ check(mhar.jcbase2(d1)!=4, "jcbase2() through Derived1 as parameter failed");
+ check(mhar.jcbase2(d3)!=8, "jcbase2() through Derived3 as parameter failed");
+ check(mhar.jabase1(d2)!=5, "jabase1() through Derived2 as parameter failed");
+ check(mhar.jabase1(d3)!=9, "jabase1() through Derived3 as parameter failed");
+
+ //Value parameters
+ //Test CBase1 CBase2 as parameters (note slicing for Derived and Bottom classes)
+ check(multiple_inheritance_shared_ptr.InputValCBase1(d1)!=1, "InputValCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase1(d2)!=1, "InputValCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase1(d3)!=1, "InputValCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase2(d3)!=2, "InputValCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase2(d1)!=2, "InputValCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase1(cb1)!=1, "InputValCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase2(cb2)!=2, "InputValCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase1(b1)!=1, "InputValCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase1(b2)!=1, "InputValCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase1(b3)!=1, "InputValCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase2(b3)!=2, "InputValCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase2(b1)!=2, "InputValCBase2(), Bottom1 as a parameter failed");
+
+ //Pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_shared_ptr.InputPtrABase1(d2)!=5, "InputPtrABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrABase1(d3)!=9, "InputPtrABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrABase1(b2)!=205, "InputPtrABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrABase1(b3)!=309, "InputPtrABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(d1)!=3, "InputPtrCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(d2)!=6, "InputPtrCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(d3)!=7, "InputPtrCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase2(d3)!=8, "InputPtrCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase2(d1)!=4, "InputPtrCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(cb1)!=1, "InputPtrCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase2(cb2)!=2, "InputPtrCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(b1)!=103, "InputPtrCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(b2)!=206, "InputPtrCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(b3)!=307, "InputPtrCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase2(b3)!=308, "InputPtrCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase2(b1)!=104, "InputPtrCBase2(), Bottom1 as a parameter failed");
+
+ //Reference parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_shared_ptr.InputRefABase1(d2)!=5, "InputRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefABase1(d3)!=9, "InputRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefABase1(b2)!=205, "InputRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefABase1(b3)!=309, "InputRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(d1)!=3, "InputRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(d2)!=6, "InputRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(d3)!=7, "InputRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase2(d3)!=8, "InputRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase2(d1)!=4, "InputRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(cb1)!=1, "InputRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase2(cb2)!=2, "InputRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(b1)!=103, "InputRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(b2)!=206, "InputRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(b3)!=307, "InputRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase2(b3)!=308, "InputRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase2(b1)!=104, "InputRefCBase2(), Bottom1 as a parameter failed");
+
+ //Const reference pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_shared_ptr.InputCPtrRefABase1(d2)!=5, "InputCPtrRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefABase1(d3)!=9, "InputCPtrRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefABase1(b2)!=205, "InputCPtrRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefABase1(b3)!=309, "InputCPtrRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(d1)!=3, "InputCPtrRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(d2)!=6, "InputCPtrRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(d3)!=7, "InputCPtrRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase2(d3)!=8, "InputCPtrRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase2(d1)!=4, "InputCPtrRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(cb1)!=1, "InputCPtrRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase2(cb2)!=2, "InputCPtrRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(b1)!=103, "InputCPtrRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(b2)!=206, "InputCPtrRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(b3)!=307, "InputCPtrRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase2(b3)!=308, "InputCPtrRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase2(b1)!=104, "InputCPtrRefCBase2(), Bottom1 as a parameter failed");
+
+ //Shared pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_shared_ptr.InputSharedPtrABase1(d2)!=5, "InputSharedPtrABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrABase1(d3)!=9, "InputSharedPtrABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrABase1(b2)!=205, "InputSharedPtrABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrABase1(b3)!=309, "InputSharedPtrABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(d1)!=3, "InputSharedPtrCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(d2)!=6, "InputSharedPtrCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(d3)!=7, "InputSharedPtrCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase2(d3)!=8, "InputSharedPtrCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase2(d1)!=4, "InputSharedPtrCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(cb1)!=1, "InputSharedPtrCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase2(cb2)!=2, "InputSharedPtrCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(b1)!=103, "InputSharedPtrCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(b2)!=206, "InputSharedPtrCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(b3)!=307, "InputSharedPtrCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase2(b3)!=308, "InputSharedPtrCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase2(b1)!=104, "InputSharedPtrCBase2(), Bottom1 as a parameter failed");
+
+ //Shared pointer reference parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefABase1(d2)!=5, "InputSharedPtrRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefABase1(d3)!=9, "InputSharedPtrRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefABase1(b2)!=205, "InputSharedPtrRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefABase1(b3)!=309, "InputSharedPtrRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(d1)!=3, "InputSharedPtrRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(d2)!=6, "InputSharedPtrRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(d3)!=7, "InputSharedPtrRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase2(d3)!=8, "InputSharedPtrRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase2(d1)!=4, "InputSharedPtrRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(cb1)!=1, "InputSharedPtrRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase2(cb2)!=2, "InputSharedPtrRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(b1)!=103, "InputSharedPtrRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(b2)!=206, "InputSharedPtrRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(b3)!=307, "InputSharedPtrRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase2(b3)!=308, "InputSharedPtrRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase2(b1)!=104, "InputSharedPtrRefCBase2(), Bottom1 as a parameter failed");
+
+ //Derived classes as parameters
+ check(multiple_inheritance_shared_ptr.InputValDerived1(d1)!=3+4, "InputValDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputValDerived2(d2)!=6+5, "InputValDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputValDerived3(d3)!=7+8+9, "InputValDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputRefDerived1(d1)!=3+4, "InputRefDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputRefDerived2(d2)!=6+5, "InputRefDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputRefDerived3(d3)!=7+8+9, "InputRefDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputPtrDerived1(d1)!=3+4, "InputPtrDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputPtrDerived2(d2)!=6+5, "InputPtrDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputPtrDerived3(d3)!=7+8+9, "InputPtrDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputCPtrRefDerived1(d1)!=3+4, "InputCPtrRefDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefDerived2(d2)!=6+5, "InputCPtrRefDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefDerived3(d3)!=7+8+9, "InputCPtrRefDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputSharedPtrDerived1(d1)!=3+4, "InputSharedPtrDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrDerived2(d2)!=6+5, "InputSharedPtrDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrDerived3(d3)!=7+8+9, "InputSharedPtrDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefDerived1(d1)!=3+4, "InputSharedPtrRefDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefDerived2(d2)!=6+5, "InputSharedPtrRefDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefDerived3(d3)!=7+8+9, "InputSharedPtrRefDerived3() failed");
+
+ //Bottom classes as Derived parameters
+ check(multiple_inheritance_shared_ptr.InputValDerived1(b1)!=3+4, "InputValDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputValDerived2(b2)!=6+5, "InputValDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputValDerived3(b3)!=7+8+9, "InputValDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputRefDerived1(b1)!=103+104, "InputRefDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputRefDerived2(b2)!=206+205, "InputRefDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputRefDerived3(b3)!=307+308+309, "InputRefDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputPtrDerived1(b1)!=103+104, "InputPtrDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputPtrDerived2(b2)!=206+205, "InputPtrDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputPtrDerived3(b3)!=307+308+309, "InputPtrDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputCPtrRefDerived1(b1)!=103+104, "InputCPtrRefDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefDerived2(b2)!=206+205, "InputCPtrRefDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefDerived3(b3)!=307+308+309, "InputCPtrRefDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputSharedPtrDerived1(b1)!=103+104, "InputSharedPtrDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrDerived2(b2)!=206+205, "InputSharedPtrDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrDerived3(b3)!=307+308+309, "InputSharedPtrDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefDerived1(b1)!=103+104, "InputSharedPtrRefDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefDerived2(b2)!=206+205, "InputSharedPtrRefDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefDerived3(b3)!=307+308+309, "InputSharedPtrRefDerived3() failed");
+
+ //Bottom classes as Bottom parameters
+ check(multiple_inheritance_shared_ptr.InputValBottom1(b1)!=103+104, "InputValBottom1() failed");
+ check(multiple_inheritance_shared_ptr.InputValBottom2(b2)!=206+205, "InputValBottom2() failed");
+ check(multiple_inheritance_shared_ptr.InputValBottom3(b3)!=307+308+309, "InputValBottom3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputRefBottom1(b1)!=103+104, "InputRefBottom1() failed");
+ check(multiple_inheritance_shared_ptr.InputRefBottom2(b2)!=206+205, "InputRefBottom2() failed");
+ check(multiple_inheritance_shared_ptr.InputRefBottom3(b3)!=307+308+309, "InputRefBottom3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputPtrBottom1(b1)!=103+104, "InputPtrBottom1() failed");
+ check(multiple_inheritance_shared_ptr.InputPtrBottom2(b2)!=206+205, "InputPtrBottom2() failed");
+ check(multiple_inheritance_shared_ptr.InputPtrBottom3(b3)!=307+308+309, "InputPtrBottom3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputCPtrRefBottom1(b1)!=103+104, "InputCPtrRefBottom1() failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefBottom2(b2)!=206+205, "InputCPtrRefBottom2() failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefBottom3(b3)!=307+308+309, "InputCPtrRefBottom3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputSharedPtrBottom1(b1)!=103+104, "InputSharedPtrBottom1() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrBottom2(b2)!=206+205, "InputSharedPtrBottom2() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrBottom3(b3)!=307+308+309, "InputSharedPtrBottom3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefBottom1(b1)!=103+104, "InputSharedPtrRefBottom1() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefBottom2(b2)!=206+205, "InputSharedPtrRefBottom2() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefBottom3(b3)!=307+308+309, "InputSharedPtrRefBottom3() failed");
+
+ // Return pointers
+ check(multiple_inheritance_shared_ptr.MakePtrDerived1_CBase1().cbase1y()!=3, "MakePtrDerived1_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakePtrDerived1_CBase2().cbase2()!=4, "MakePtrDerived1_CBase2 failed");
+ check(multiple_inheritance_shared_ptr.MakePtrDerived2_CBase1().cbase1y()!=6, "MakePtrDerived2_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakePtrDerived2_ABase1().abase1()!=5, "MakePtrDerived2_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakePtrDerived3_ABase1().abase1()!=9, "MakePtrDerived3_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakePtrDerived3_CBase1().cbase1y()!=7, "MakePtrDerived3_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakePtrDerived3_CBase2().cbase2()!=8, "MakePtrDerived3_CBase2 failed");
+
+ // Return references
+ check(multiple_inheritance_shared_ptr.MakeRefDerived1_CBase1().cbase1y()!=3, "MakeRefDerived1_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeRefDerived1_CBase2().cbase2()!=4, "MakeRefDerived1_CBase2 failed");
+ check(multiple_inheritance_shared_ptr.MakeRefDerived2_CBase1().cbase1y()!=6, "MakeRefDerived2_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeRefDerived2_ABase1().abase1()!=5, "MakeRefDerived2_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeRefDerived3_ABase1().abase1()!=9, "MakeRefDerived3_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeRefDerived3_CBase1().cbase1y()!=7, "MakeRefDerived3_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeRefDerived3_CBase2().cbase2()!=8, "MakeRefDerived3_CBase2 failed");
+
+ // Return by value (sliced objects)
+ check(multiple_inheritance_shared_ptr.MakeValDerived1_CBase1().cbase1y()!=1, "MakeValDerived1_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeValDerived1_CBase2().cbase2()!=2, "MakeValDerived1_CBase2 failed");
+ check(multiple_inheritance_shared_ptr.MakeValDerived2_CBase1().cbase1y()!=1, "MakeValDerived2_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeValDerived3_CBase1().cbase1y()!=1, "MakeValDerived3_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeValDerived3_CBase2().cbase2()!=2, "MakeValDerived3_CBase2 failed");
+
+ // Return smart pointers
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived1_CBase1().cbase1y()!=3, "MakeSharedPtrDerived1_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived1_CBase2().cbase2()!=4, "MakeSharedPtrDerived1_CBase2 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived2_CBase1().cbase1y()!=6, "MakeSharedPtrDerived2_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived2_ABase1().abase1()!=5, "MakeSharedPtrDerived2_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived3_ABase1().abase1()!=9, "MakeSharedPtrDerived3_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived3_CBase1().cbase1y()!=7, "MakeSharedPtrDerived3_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived3_CBase2().cbase2()!=8, "MakeSharedPtrDerived3_CBase2 failed");
+
+ // Return smart pointers
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived1_CBase1().cbase1y()!=3, "MakeSharedPtrRefDerived1_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived1_CBase2().cbase2()!=4, "MakeSharedPtrRefDerived1_CBase2 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived2_CBase1().cbase1y()!=6, "MakeSharedPtrRefDerived2_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived2_ABase1().abase1()!=5, "MakeSharedPtrRefDerived2_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived3_ABase1().abase1()!=9, "MakeSharedPtrRefDerived3_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived3_CBase1().cbase1y()!=7, "MakeSharedPtrRefDerived3_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived3_CBase2().cbase2()!=8, "MakeSharedPtrRefDerived3_CBase2 failed");
+ }
+}
--- /dev/null
+using System;
+using nested_classNamespace;
+#pragma warning disable 219
+
+public class runme {
+ static void Main() {
+
+ Outer outer = new Outer();
+ outer.a = 1;
+ outer.b = 2;
+ Outer.InnerStruct1 is1 = outer.makeInnerStruct1();
+ Outer.InnerClass1 ic1 = outer.makeInnerClass1();
+ Outer.InnerUnion1 iu1 = outer.makeInnerUnion1();
+
+ Outer.InnerStruct2 is2 = outer.makeInnerStruct2();
+ Outer.InnerClass2 ic2 = outer.makeInnerClass2();
+ Outer.InnerUnion2 iu2 = outer.makeInnerUnion2();
+
+ Outer.InnerClass4Typedef ic4 = outer.makeInnerClass4Typedef();
+ Outer.InnerStruct4Typedef is4 = outer.makeInnerStruct4Typedef();
+ Outer.InnerUnion4Typedef iu4 = outer.makeInnerUnion4Typedef();
+
+ Outer.InnerClass5Typedef ic5 = outer.makeInnerClass5();
+ Outer.InnerStruct5Typedef is5 = outer.makeInnerStruct5();
+ Outer.InnerUnion5Typedef iu5 = outer.makeInnerUnion5();
+
+ ic5 = outer.makeInnerClass5Typedef();
+ is5 = outer.makeInnerStruct5Typedef();
+ iu5 = outer.makeInnerUnion5Typedef();
+
+ {
+ Outer.InnerMultiple im1 = outer.MultipleInstance1;
+ Outer.InnerMultiple im2 = outer.MultipleInstance2;
+ Outer.InnerMultiple im3 = outer.MultipleInstance3;
+ Outer.InnerMultiple im4 = outer.MultipleInstance4;
+ }
+
+ {
+ Outer.InnerMultipleDerived im1 = outer.MultipleDerivedInstance1;
+ Outer.InnerMultipleDerived im2 = outer.MultipleDerivedInstance2;
+ Outer.InnerMultipleDerived im3 = outer.MultipleDerivedInstance3;
+ Outer.InnerMultipleDerived im4 = outer.MultipleDerivedInstance4;
+ }
+
+ {
+ Outer.InnerMultipleDerived im1 = outer.MultipleDerivedInstance1;
+ Outer.InnerMultipleDerived im2 = outer.MultipleDerivedInstance2;
+ Outer.InnerMultipleDerived im3 = outer.MultipleDerivedInstance3;
+ Outer.InnerMultipleDerived im4 = outer.MultipleDerivedInstance4;
+ }
+
+ {
+ Outer.InnerMultipleAnonTypedef1 mat1 = outer.makeInnerMultipleAnonTypedef1();
+ Outer.InnerMultipleAnonTypedef1 mat2 = outer.makeInnerMultipleAnonTypedef2();
+ SWIGTYPE_p_p_Outer__InnerMultipleAnonTypedef1 mat3 = outer.makeInnerMultipleAnonTypedef3();
+
+ Outer.InnerMultipleNamedTypedef1 mnt = outer.makeInnerMultipleNamedTypedef();
+ Outer.InnerMultipleNamedTypedef1 mnt1 = outer.makeInnerMultipleNamedTypedef1();
+ Outer.InnerMultipleNamedTypedef1 mnt2 = outer.makeInnerMultipleNamedTypedef2();
+ SWIGTYPE_p_p_Outer__InnerMultipleNamedTypedef mnt3 = outer.makeInnerMultipleNamedTypedef3();
+ }
+ {
+ Outer.InnerSameName isn = outer.makeInnerSameName();
+ }
+ }
+}
--- /dev/null
+using System;
+using nested_directorsNamespace;
+#pragma warning disable 219
+
+public class CNested : Base.Nest {
+ public override bool GetValue() {return true;}
+}
+public class CSub : Sub {
+ protected override bool GetValue() { return base.GetValue(); }
+ public bool Test(){ return GetValue(); }
+}
+
+public class runme {
+ static void Main() {
+ CNested n = new CNested();
+ CSub s = new CSub();
+ if (!s.Test())
+ throw new Exception("Sub.GetValue");
+ }
+}
--- /dev/null
+using System;
+using nested_structsNamespace;
+#pragma warning disable 219
+
+public class runme {
+ static void Main() {
+ Outer outer = new Outer();
+ nested_structs.setValues(outer, 10);
+
+ Outer_inner1 inner1 = outer.inner1;
+ Outer_inner1 inner2 = outer.inner2;
+ Outer_inner1 inner3 = outer.inner3;
+ Outer_inner1 inner4 = outer.inner4;
+ if (inner1.val != 10) throw new Exception("failed inner1");
+ if (inner2.val != 20) throw new Exception("failed inner2");
+ if (inner3.val != 20) throw new Exception("failed inner3");
+ if (inner4.val != 40) throw new Exception("failed inner4");
+
+ Named inside1 = outer.inside1;
+ Named inside2 = outer.inside2;
+ Named inside3 = outer.inside3;
+ Named inside4 = outer.inside4;
+ if (inside1.val != 100) throw new Exception("failed inside1");
+ if (inside2.val != 200) throw new Exception("failed inside2");
+ if (inside3.val != 200) throw new Exception("failed inside3");
+ if (inside4.val != 400) throw new Exception("failed inside4");
+ }
+}
--- /dev/null
+using System;
+using nested_workaroundNamespace;
+#pragma warning disable 219
+
+public class runme {
+ static void Main() {
+ {
+ Inner inner = new Inner(5);
+ Outer outer = new Outer();
+ Inner newInner = outer.doubleInnerValue(inner);
+ if (newInner.getValue() != 10)
+ throw new Exception("inner failed");
+ }
+
+ {
+ Outer outer = new Outer();
+ Inner inner = outer.createInner(3);
+ Inner newInner = outer.doubleInnerValue(inner);
+ if (outer.getInnerValue(newInner) != 6)
+ throw new Exception("inner failed");
+ }
+ }
+}
public class runme {
static void Main() {
SomeWidget w = new SomeWidget();
- w.putBorderWidth(17);
- if ( w.getBorderWidth() != 17 )
+ w.put_borderWidth(17);
+ if ( w.get_borderWidth() != 17 )
throw new Exception(String.Format("Border with should be 17, not {0}",
- w.getBorderWidth()));
+ w.get_borderWidth()));
+
+ if ( rename_pcre_encoder.StartINSAneAndUNSAvoryTraNSAtlanticRaNSAck() != 42 )
+ throw new Exception("Unexpected result of renamed function call");
}
}
--- /dev/null
+
+using System;
+using special_variable_attributesNamespace;
+
+public class special_variable_attributes_runme {
+
+ public static void Main() {
+ if (special_variable_attributes.getNumber1() != 111)
+ throw new ApplicationException("getNumber1 failed");
+ if (special_variable_attributes.getNumber2() != 222)
+ throw new ApplicationException("getNumber2 failed");
+ if (special_variable_attributes.getNumber3() != 333)
+ throw new ApplicationException("getNumber3 failed");
+
+ if (special_variable_attributes.bounceNumber1(10) != 110)
+ throw new ApplicationException("bounceNumber1 failed");
+ if (special_variable_attributes.bounceNumber2(10) != 220)
+ throw new ApplicationException("bounceNumber2 failed");
+ if (special_variable_attributes.bounceNumber3(10) != 330)
+ throw new ApplicationException("bounceNumber3 failed");
+
+ if (special_variable_attributes.multi1(12.34) != 12+34)
+ throw new ApplicationException("multi1 failed");
+ if (special_variable_attributes.multi2(12.34) != 12+34+55)
+ throw new ApplicationException("multi2 failed");
+ if (special_variable_attributes.multi3(12.34) != 12+34+77)
+ throw new ApplicationException("multi3 failed");
+ }
+
+}
--- /dev/null
+using System;
+using template_nestedNamespace;
+#pragma warning disable 219
+
+public class runme {
+ static void Main() {
+ new T_NormalTemplateNormalClass().tmethod(new NormalClass());
+ new OuterClass().T_OuterTMethodNormalClass(new NormalClass());
+
+ TemplateFuncs tf = new TemplateFuncs();
+ if (tf.T_TemplateFuncs1Int(-10) != -10)
+ throw new Exception("it failed");
+ if (tf.T_TemplateFuncs2Double(-12.3) != -12.3)
+ throw new Exception("it failed");
+
+ T_NestedOuterTemplateDouble tn = new T_NestedOuterTemplateDouble();
+ if (tn.hohum(-12.3) != -12.3)
+ throw new Exception("it failed");
+ OuterClass.T_OuterClassInner1Int inner1 = new OuterClass().useInner1(new OuterClass.T_OuterClassInner1Int());
+ OuterClass.T_OuterClassInner2NormalClass inner2 = new OuterClass.T_OuterClassInner2NormalClass();
+ inner2.embeddedVar = 2;
+ OuterClass.T_OuterClassInner2NormalClass inner22 = new OuterClass().useInner2Again(inner2);
+ }
+}
+
UnmanagedSystemException,
UnmanagedArgumentException,
UnmanagedArgumentNullException,
- UnmanagedArgumentOutOfRangeException,
+ UnmanagedArgumentOutOfRangeException
};
void check_exception(UnmanagedExceptions e) {
%module csharp_features
+%include "wchar.i"
// SWIG gets the method modifiers wrong occasionally, like with private inheritance, %csmethodmodifiers can fix this
%csmethodmodifiers Derived::VirtualMethod() "public virtual"
class MoreDerived : public Derived {
public:
int variable;
+ // test wide char literals support for C# module
+ void methodWithDefault1(const wchar_t* s = L"literal with escapes \x1234"){}
+ void methodWithDefault2(wchar_t c = L'\x1234'){}
};
%}
--- /dev/null
+%module namespace_system_collision
+
+%{
+#include <string>
+
+namespace TopLevel
+{
+ namespace System
+ {
+ class Foo {
+ public:
+ virtual ~Foo() {}
+ virtual std::string ping() { return "TopLevel::System::Foo::ping()"; }
+ };
+ }
+}
+
+%}
+
+%include <std_string.i>
+
+// nspace feature only supported by these languages
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGD)
+%nspace;
+#else
+//#warning nspace feature not yet supported in this target language
+#endif
+
+namespace TopLevel
+{
+ namespace System
+ {
+ class Foo {
+ public:
+ virtual ~Foo();
+ virtual std::string ping();
+ };
+ }
+}
// Check attributes in the typemaps
%typemap(cstype, inattributes="[CustomInt]") int val "int"
%typemap(csin, pre=" int tmp_$csinput = $csinput * 100;") int val "tmp_$csinput"
-%typemap(imtype, out="IntPtr/*overridden*/", outattributes="[CustomIntPtr]") CsinAttributes * "HandleRef/*overridden*/"
+%typemap(imtype, out="global::System.IntPtr/*overridden*/", outattributes="[CustomIntPtr]") CsinAttributes * "global::System.Runtime.InteropServices.HandleRef/*overridden*/"
%inline %{
class CsinAttributes {
%typemap(csvarout, excode=SWIGEXCODE2) CDate * %{
/* csvarout typemap code */
get {
- IntPtr cPtr = $imcall;
- CDate tempDate = (cPtr == IntPtr.Zero) ? null : new CDate(cPtr, $owner);$excode
+ global::System.IntPtr cPtr = $imcall;
+ CDate tempDate = (cPtr == global::System.IntPtr.Zero) ? null : new CDate(cPtr, $owner);$excode
return new System.DateTime(tempDate.getYear(), tempDate.getMonth(), tempDate.getDay(),
0, 0, 0);
} %}
--- /dev/null
+%module csharp_swig2_compatibility
+
+%typemap(cscode) Foo %{
+
+// Without the using directives generated by the
+// SWIG 2 compatibility mode, this code would fail
+// to build.
+public void FooBar(string input)
+{
+ Console.WriteLine(input);
+}
+
+%}
+
+%pragma(csharp) imclasscode=%{
+
+// Without the using directives generated by the
+// SWIG 2 compatibility mode, this code would fail
+// to build.
+public void IntermediateClassMethod(string input)
+{
+ Console.WriteLine(input);
+}
+
+%}
+
+%pragma(csharp) modulecode=%{
+
+// Without the using directives generated by the
+// SWIG 2 compatibility mode, this code would fail
+// to build.
+public void ModuleClassMethod(string input)
+{
+ Console.WriteLine(input);
+}
+
+%}
+
+%inline %{
+class Foo {
+public:
+ Foo() {}
+
+ void Bar() {}
+};
+
+%}
+
Number quadruple(Number n) {
n.Value *= 4;
return n;
-};
+}
Number times8(const Number& num) {
Number n(num);
n.Value *= 8;
return n;
-};
+}
Number times12(const Number* num) {
Number n(*num);
n.Value *= 12;
return n;
-};
+}
%}
// Test $csinput expansion
%typemap(csvarin, excode=SWIGEXCODE2) int %{
set {
if ($csinput < 0)
- throw new ApplicationException("number too small!");
+ throw new global::System.ApplicationException("number too small!");
$imcall;$excode
} %}
#######################################################################
LANGUAGE = d
+
srcdir = @srcdir@
top_srcdir = ../@top_srcdir@
top_builddir = ../@top_builddir@
+ifeq (,$(D_VERSION))
+ D_VERSION = @DDEFAULTVERSION@
+endif
+
ifeq (2,$(D_VERSION))
VERSIONSUFFIX = .2
else
VERSIONSUFFIX = .1
endif
-TESTSUFFIX = _runme$(VERSIONSUFFIX).d
+SCRIPTSUFFIX = _runme$(VERSIONSUFFIX).d
CPP_TEST_CASES = \
d_nativepointers \
include $(srcdir)/../common.mk
-# Override some variables from common.mk:
-
+# Overridden variables here
+SRCDIR = ../$(srcdir)/
TARGETSUFFIX = _wrap
-
SWIGOPT+=-splitproxy -package $*
# Rules for the different types of tests
# Makes a directory for the testcase if it does not exist
setup = \
- if [ -f $(srcdir)/$(TESTPREFIX)$*$(TESTSUFFIX) ]; then \
- echo "$(ACTION)ing testcase $* (with run test) under $(LANGUAGE)" ; \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ echo "$(ACTION)ing $(LANGUAGE) testcase $* (with run test)" ; \
else \
- echo "$(ACTION)ing testcase $* under $(LANGUAGE)" ; \
+ echo "$(ACTION)ing $(LANGUAGE) testcase $*" ; \
fi; \
if [ ! -d $*$(VERSIONSUFFIX) ]; then \
mkdir $*$(VERSIONSUFFIX); \
# Compiles D files then runs the testcase. A testcase is only run if
# a file is found which has _runme.d appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(TESTPREFIX)$*$(TESTSUFFIX) ]; then \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
cd $*$(VERSIONSUFFIX) && \
$(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile \
DFLAGS='-of$*_runme' \
- DSRCS='../$(srcdir)/$(TESTPREFIX)$*$(TESTSUFFIX) `find $* -name *.d`' d_compile && \
+ DSRCS='../$(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) `find $* -name *.d`' d_compile && \
env LD_LIBRARY_PATH=".:$$LD_LIBRARY_PATH" $(RUNTOOL) ./$*_runme; \
else \
cd $*$(VERSIONSUFFIX) && \
module default_constructor_runme;
-import default_constructor.FFF;
import default_constructor.G;
void main() {
throw e;
}
}
-
- // Private destructor test.
- try {
- {
- scope f = new FFF();
- }
- throw new Exception("Private destructor exception should have been thrown");
- } catch (Exception e) {
- if (e.msg != "C++ destructor does not have public access") {
- throw e;
- }
- }
}
module default_constructor_runme;
-import default_constructor.FFF;
import default_constructor.G;
void main() {
// destruction yet.
// enforceThrows((){ scope g = new G(); }, "Protected destructor exception should have been thrown");
- // enforceThrows((){ scope f = new FFF(); }, "Private destructor exception should have been thrown");
}
private void enforceThrows(void delegate() dg, string errorMessage) {
import core.memory;
import core.thread;
+import core.time;
import std.conv;
import std.exception;
import std.stdio;
if (TRACE)
writeln("---> NEARLY FINISHED <---");
- // Try to get the GC to collect everything not referenced anymore.
- int countdown = 100;
- while (--countdown) {
- GC.collect();
- if (Klass.getTotal_count() == 1)
- break;
- Thread.sleep(100);
- }
-
// A single remaining instance expected: the global variable (GlobalValue).
if (Klass.getTotal_count() != 1)
throw new Exception("Klass.total_count=" ~ to!string(Klass.getTotal_count()));
}
void runTest() {
+ // We want to check whether all the C++ Klass instances have been properly
+ // destructed after the tests have run. However, as it is legal for the GC
+ // to leave an object around even if it is unreachable, use deterministic
+ // memory management here.
+ import std.typecons : scoped;
+
// simple shared_ptr usage - created in C++
{
- auto k = new Klass("me oh my");
+ auto k = scoped!Klass("me oh my");
string val = k.getValue();
verifyValue("me oh my", val);
verifyCount(1, k);
// pass by shared_ptr
{
- auto k = new Klass("me oh my");
+ auto k = scoped!Klass("me oh my");
auto kret = smartpointertest(k);
string val = kret.getValue();
verifyValue("me oh my smartpointertest", val);
// pass by shared_ptr pointer
{
- auto k = new Klass("me oh my");
+ auto k = scoped!Klass("me oh my");
auto kret = smartpointerpointertest(k);
string val = kret.getValue();
verifyValue("me oh my smartpointerpointertest", val);
// pass by shared_ptr reference
{
- auto k = new Klass("me oh my");
+ auto k = scoped!Klass("me oh my");
auto kret = smartpointerreftest(k);
string val = kret.getValue();
verifyValue("me oh my smartpointerreftest", val);
// pass by shared_ptr pointer reference
{
- auto k = new Klass("me oh my");
+ auto k = scoped!Klass("me oh my");
auto kret = smartpointerpointerreftest(k);
string val = kret.getValue();
verifyValue("me oh my smartpointerpointerreftest", val);
// const pass by shared_ptr
{
- auto k = new Klass("me oh my");
+ auto k = scoped!Klass("me oh my");
auto kret = constsmartpointertest(k);
string val = kret.getValue();
verifyValue("me oh my", val);
// const pass by shared_ptr pointer
{
- auto k = new Klass("me oh my");
+ auto k = scoped!Klass("me oh my");
auto kret = constsmartpointerpointertest(k);
string val = kret.getValue();
verifyValue("me oh my", val);
// const pass by shared_ptr reference
{
- auto k = new Klass("me oh my");
+ auto k = scoped!Klass("me oh my");
auto kret = constsmartpointerreftest(k);
string val = kret.getValue();
verifyValue("me oh my", val);
// pass by value
{
- auto k = new Klass("me oh my");
+ auto k = scoped!Klass("me oh my");
auto kret = valuetest(k);
string val = kret.getValue();
verifyValue("me oh my valuetest", val);
// pass by pointer
{
- auto k = new Klass("me oh my");
+ auto k = scoped!Klass("me oh my");
auto kret = pointertest(k);
string val = kret.getValue();
verifyValue("me oh my pointertest", val);
// pass by reference
{
- auto k = new Klass("me oh my");
+ auto k = scoped!Klass("me oh my");
auto kret = reftest(k);
string val = kret.getValue();
verifyValue("me oh my reftest", val);
// pass by pointer reference
{
- auto k = new Klass("me oh my");
+ auto k = scoped!Klass("me oh my");
auto kret = pointerreftest(k);
string val = kret.getValue();
verifyValue("me oh my pointerreftest", val);
////////////////////////////////// Derived classes ////////////////////////////////////////
// derived pass by shared_ptr
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = derivedsmartptrtest(k);
string val = kret.getValue();
verifyValue("me oh my derivedsmartptrtest-Derived", val);
}
// derived pass by shared_ptr pointer
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = derivedsmartptrpointertest(k);
string val = kret.getValue();
verifyValue("me oh my derivedsmartptrpointertest-Derived", val);
}
// derived pass by shared_ptr ref
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = derivedsmartptrreftest(k);
string val = kret.getValue();
verifyValue("me oh my derivedsmartptrreftest-Derived", val);
}
// derived pass by shared_ptr pointer ref
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = derivedsmartptrpointerreftest(k);
string val = kret.getValue();
verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val);
}
// derived pass by pointer
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = derivedpointertest(k);
string val = kret.getValue();
verifyValue("me oh my derivedpointertest-Derived", val);
}
// derived pass by ref
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = derivedreftest(k);
string val = kret.getValue();
verifyValue("me oh my derivedreftest-Derived", val);
////////////////////////////////// Derived and base class mixed ////////////////////////////////////////
// pass by shared_ptr (mixed)
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = smartpointertest(k);
string val = kret.getValue();
verifyValue("me oh my smartpointertest-Derived", val);
// pass by shared_ptr pointer (mixed)
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = smartpointerpointertest(k);
string val = kret.getValue();
verifyValue("me oh my smartpointerpointertest-Derived", val);
// pass by shared_ptr reference (mixed)
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = smartpointerreftest(k);
string val = kret.getValue();
verifyValue("me oh my smartpointerreftest-Derived", val);
// pass by shared_ptr pointer reference (mixed)
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = smartpointerpointerreftest(k);
string val = kret.getValue();
verifyValue("me oh my smartpointerpointerreftest-Derived", val);
// pass by value (mixed)
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = valuetest(k);
string val = kret.getValue();
verifyValue("me oh my valuetest", val); // note slicing
// pass by pointer (mixed)
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = pointertest(k);
string val = kret.getValue();
verifyValue("me oh my pointertest-Derived", val);
// pass by ref (mixed)
{
- auto k = new KlassDerived("me oh my");
+ auto k = scoped!KlassDerived("me oh my");
auto kret = reftest(k);
string val = kret.getValue();
verifyValue("me oh my reftest-Derived", val);
// 3rd derived class
{
- auto k = new Klass3rdDerived("me oh my");
+ auto k = scoped!Klass3rdDerived("me oh my");
string val = k.getValue();
verifyValue("me oh my-3rdDerived", val);
verifyCount(3, k); // 3 classes in inheritance chain == 3 swigCPtr values
////////////////////////////////// Member variables ////////////////////////////////////////
// smart pointer by value
{
- auto m = new MemberVariables();
- auto k = new Klass("smart member value");
- m.SmartMemberValue = k;
- string val = k.getValue();
- verifyValue("smart member value", val);
- verifyCount(2, k);
-
- auto kmember = m.SmartMemberValue;
- val = kmember.getValue();
- verifyValue("smart member value", val);
- verifyCount(3, kmember);
- verifyCount(3, k);
-
- delete m;
+ auto k = scoped!Klass("smart member value");
+ Klass kmember;
+
+ {
+ auto m = scoped!MemberVariables();
+ m.SmartMemberValue = k;
+ string val = k.getValue();
+ verifyValue("smart member value", val);
+ verifyCount(2, k);
+
+ kmember = m.SmartMemberValue;
+ val = kmember.getValue();
+ verifyValue("smart member value", val);
+ verifyCount(3, kmember);
+ verifyCount(3, k);
+ }
verifyCount(2, kmember);
verifyCount(2, k);
}
// smart pointer by pointer
{
- auto m = new MemberVariables();
- auto k = new Klass("smart member pointer");
- m.SmartMemberPointer = k;
- string val = k.getValue();
- verifyValue("smart member pointer", val);
- verifyCount(1, k);
-
- auto kmember = m.SmartMemberPointer;
- val = kmember.getValue();
- verifyValue("smart member pointer", val);
- verifyCount(2, kmember);
- verifyCount(2, k);
-
- delete m;
+ auto k = scoped!Klass("smart member pointer");
+ Klass kmember;
+
+ {
+ auto m = scoped!MemberVariables();
+ m.SmartMemberPointer = k;
+ string val = k.getValue();
+ verifyValue("smart member pointer", val);
+ verifyCount(1, k);
+
+ kmember = m.SmartMemberPointer;
+ val = kmember.getValue();
+ verifyValue("smart member pointer", val);
+ verifyCount(2, kmember);
+ verifyCount(2, k);
+ }
verifyCount(2, kmember);
verifyCount(2, k);
}
// smart pointer by reference
{
- auto m = new MemberVariables();
- auto k = new Klass("smart member reference");
- m.SmartMemberReference = k;
- string val = k.getValue();
- verifyValue("smart member reference", val);
- verifyCount(2, k);
-
- auto kmember = m.SmartMemberReference;
- val = kmember.getValue();
- verifyValue("smart member reference", val);
- verifyCount(3, kmember);
- verifyCount(3, k);
-
- // The C++ reference refers to SmartMemberValue...
- auto kmemberVal = m.SmartMemberValue;
- val = kmember.getValue();
- verifyValue("smart member reference", val);
- verifyCount(4, kmemberVal);
- verifyCount(4, kmember);
- verifyCount(4, k);
-
- delete m;
+ auto k = scoped!Klass("smart member reference");
+ Klass kmember;
+
+ {
+ auto m = scoped!MemberVariables();
+ m.SmartMemberReference = k;
+ string val = k.getValue();
+ verifyValue("smart member reference", val);
+ verifyCount(2, k);
+
+ kmember = m.SmartMemberReference;
+ val = kmember.getValue();
+ verifyValue("smart member reference", val);
+ verifyCount(3, kmember);
+ verifyCount(3, k);
+
+ // The C++ reference refers to SmartMemberValue...
+ auto kmemberVal = m.SmartMemberValue;
+ val = kmember.getValue();
+ verifyValue("smart member reference", val);
+ verifyCount(4, kmemberVal);
+ verifyCount(4, kmember);
+ verifyCount(4, k);
+ }
verifyCount(3, kmember);
verifyCount(3, k);
}
// plain by value
{
- auto m = new MemberVariables();
- auto k = new Klass("plain member value");
- m.MemberValue = k;
- string val = k.getValue();
- verifyValue("plain member value", val);
- verifyCount(1, k);
-
- auto kmember = m.MemberValue;
- val = kmember.getValue();
- verifyValue("plain member value", val);
- verifyCount(1, kmember);
- verifyCount(1, k);
-
- delete m;
+ auto k = scoped!Klass("plain member value");
+ Klass kmember;
+
+ {
+ auto m = scoped!MemberVariables();
+ m.MemberValue = k;
+ string val = k.getValue();
+ verifyValue("plain member value", val);
+ verifyCount(1, k);
+
+ kmember = m.MemberValue;
+ val = kmember.getValue();
+ verifyValue("plain member value", val);
+ verifyCount(1, kmember);
+ verifyCount(1, k);
+ }
verifyCount(1, kmember);
verifyCount(1, k);
}
// plain by pointer
{
- auto m = new MemberVariables();
- auto k = new Klass("plain member pointer");
- m.MemberPointer = k;
- string val = k.getValue();
- verifyValue("plain member pointer", val);
- verifyCount(1, k);
-
- auto kmember = m.MemberPointer;
- val = kmember.getValue();
- verifyValue("plain member pointer", val);
- verifyCount(1, kmember);
- verifyCount(1, k);
-
- delete m;
+ auto k = scoped!Klass("plain member pointer");
+ Klass kmember;
+
+ {
+ auto m = scoped!MemberVariables();
+ m.MemberPointer = k;
+ string val = k.getValue();
+ verifyValue("plain member pointer", val);
+ verifyCount(1, k);
+
+ kmember = m.MemberPointer;
+ val = kmember.getValue();
+ verifyValue("plain member pointer", val);
+ verifyCount(1, kmember);
+ verifyCount(1, k);
+ }
verifyCount(1, kmember);
verifyCount(1, k);
}
// plain by reference
{
- auto m = new MemberVariables();
- auto k = new Klass("plain member reference");
- m.MemberReference = k;
- string val = k.getValue();
- verifyValue("plain member reference", val);
- verifyCount(1, k);
-
- auto kmember = m.MemberReference;
- val = kmember.getValue();
- verifyValue("plain member reference", val);
- verifyCount(1, kmember);
- verifyCount(1, k);
-
- delete m;
+ auto k = scoped!Klass("plain member reference");
+ Klass kmember;
+
+ {
+ auto m = scoped!MemberVariables();
+ m.MemberReference = k;
+ string val = k.getValue();
+ verifyValue("plain member reference", val);
+ verifyCount(1, k);
+
+ kmember = m.MemberReference;
+ val = kmember.getValue();
+ verifyValue("plain member reference", val);
+ verifyCount(1, kmember);
+ verifyCount(1, k);
+ }
verifyCount(1, kmember);
verifyCount(1, k);
// null member variables
{
- auto m = new MemberVariables();
+ auto m = scoped!MemberVariables();
// shared_ptr by value
auto k = m.SmartMemberValue;
auto kglobal = GlobalSmartValue;
enforce(kglobal is null, "expected null");
- auto k = new Klass("smart global value");
+ auto k = scoped!Klass("smart global value");
GlobalSmartValue = k;
verifyCount(2, k);
{
Klass kglobal;
- auto k = new Klass("global value");
+ auto k = scoped!Klass("global value");
GlobalValue = k;
verifyCount(1, k);
auto kglobal = GlobalPointer;
enforce(kglobal is null, "expected null");
- auto k = new Klass("global pointer");
+ auto k = scoped!Klass("global pointer");
GlobalPointer = k;
verifyCount(1, k);
{
Klass kglobal;
- auto k = new Klass("global reference");
+ auto k = scoped!Klass("global reference");
GlobalReference = k;
verifyCount(1, k);
assert(-a == a);
assert(-b == new Op(-5));
- // Unfortunaly, there is no way to override conversion to boolean for
+ // Unfortunately, there is no way to override conversion to boolean for
// classes in D, opCast!("bool") is only used for structs.
// test []
// Bad Python wrappers were being generated when NULL used for primitive type
float draw1(float v = 0) { return v; }
float draw2(float *v = 0) { return v ? *v : 0; }
+ bool bool0(bool x = 0) { return x; }
+ bool bool1(bool x = 1) { return x; }
+
+ typedef bool mybool;
+ bool mybool0(mybool x = 0) { return x; }
+ bool mybool1(mybool x = 1) { return x; }
};
float* createPtr(float v) { static float val; val = v; return &val; }
%}
// Bad Python wrappers were being generated when NULL used for primitive type
float draw1(float v = NULL) { return v; }
float draw2(float *v = NULL) { return v ? *v : 0; }
+ bool bool0(bool x = 0) { return x; }
+ bool bool1(bool x = 1) { return x; }
+
+ typedef bool mybool;
+ bool mybool0(mybool x = 0) { return x; }
+ bool mybool1(mybool x = 1) { return x; }
};
float* createPtr(float v) { static float val; val = v; return &val; }
%inline %{
#include <string>
+ // All kinds of numbers: hex, octal (which pose special problems to Python), negative...
+ void trickyvalue1(int first, int pos = -1) {}
+ void trickyvalue2(int first, unsigned rgb = 0xabcdef) {}
+ void trickyvalue3(int first, int mode = 0644) {}
+
+ void doublevalue1(int first, double num = 0.0e-1) {}
+ void doublevalue2(int first, double num = -0.0E2) {}
+
+ // Long long arguments are not handled at Python level currently but still work.
+ void seek(long long offset = 0LL) {}
+ void seek2(unsigned long long offset = 0ULL) {}
+ void seek3(long offset = 0L) {}
+ void seek4(unsigned long offset = 0UL) {}
+ void seek5(unsigned long offset = 0U) {}
+ void seek6(unsigned long offset = 02U) {}
+ void seek7(unsigned long offset = 00U) {}
+ void seek8(unsigned long offset = 1U) {}
+ void seek9(long offset = 1L) {}
+ void seekA(long long offset = 1LL) {}
+ void seekB(unsigned long long offset = 1ULL) {}
+
// Anonymous arguments
int anonymous(int = 7771);
int anonymous(int x) { return x; }
bool blah(speed s = FAST, flavor f = SWEET) { return (s == FAST && f == SWEET); };
};
+ // using base class enum in a derived class
+ class DerivedEnumClass : public EnumClass {
+ public:
+ void accelerate(speed s = SLOW) { }
+ };
+
// casts
const char * casts1(const char *m = (const char *) NULL) {
char *ret = NULL;
// char
char chartest1(char c = 'x') { return c; }
char chartest2(char c = '\0') { return c; }
+ char chartest3(char c = '\1') { return c; }
+ char chartest4(char c = '\n') { return c; }
+ char chartest5(char c = '\102') { return c; } // 'B'
+ char chartest6(char c = '\x43') { return c; } // 'C'
// namespaces
namespace AType {
%rename(renamed2arg) Foo::renameme(int x) const;
%rename(renamed1arg) Foo::renameme() const;
+%typemap(default) double* null_by_default "$1=0;";
+
%inline %{
+ typedef void* MyHandle;
// Define a class
class Foo {
// test the method itself being renamed
void oldname(int x = 1234) {}
void renameme(int x = 1234, double d=123.4) const {}
+
+ // test default values for pointer arguments
+ int double_if_void_ptr_is_null(int n, void* p = NULL) { return p ? n : 2*n; }
+ int double_if_handle_is_null(int n, MyHandle h = 0) { return h ? n : 2*n; }
+ int double_if_dbl_ptr_is_null(int n, double* null_by_default)
+ { return null_by_default ? n : 2*n; }
};
int Foo::bar = 1;
int Foo::spam = 2;
struct Klass {
int val;
Klass(int val = -1) : val(val) {}
+ static Klass inc(int n = 1, const Klass& k = Klass()) { return Klass(k.val + n); }
};
Klass constructorcall(const Klass& k = Klass()) { return k; }
} Pointf;
}
%}
+
+// Default arguments after ignored ones.
+%typemap(in, numinputs=0) int square_error { $1 = 2; };
+%typemap(default, noblock=1) int def17 { $1 = 17; };
+
+// Enabling autodoc feature has a side effect of disabling the generation of
+// aliases for functions that can hide problems with default arguments at
+// Python level.
+%feature("autodoc","0") slightly_off_square;
+
+%inline %{
+ inline int slightly_off_square(int square_error, int def17) { return def17*def17 + square_error; }
+%}
+
+// Python C default args
+%feature("python:cdefaultargs") CDA::cdefaultargs_test1;
+%inline %{
+struct CDA {
+ int cdefaultargs_test1(int a = 1) { return a; }
+ int cdefaultargs_test2(int a = 1) { return a; }
+};
+%}
+
--- /dev/null
+%module default_args_c
+
+/* Default arguments for C code */
+int foo1(int x = 42 || 3);
+int foo43(int x = 42 | 3);
+
+%{
+int foo1(int x) {
+ return x;
+}
+int foo43(int x) {
+ return x;
+}
+%}
SWIGWARN_D_MULTIPLE_INHERITANCE,
SWIGWARN_PHP_MULTIPLE_INHERITANCE) AD; /* C#, D, Java, PHP multiple inheritance */
+%warnfilter(SWIGWARN_JAVA_MULTIPLE_INHERITANCE,
+ SWIGWARN_CSHARP_MULTIPLE_INHERITANCE,
+ SWIGWARN_D_MULTIPLE_INHERITANCE,
+ SWIGWARN_PHP_MULTIPLE_INHERITANCE) GGG; /* C#, D, Java, PHP multiple inheritance */
+
+%warnfilter(SWIGWARN_JAVA_MULTIPLE_INHERITANCE,
+ SWIGWARN_CSHARP_MULTIPLE_INHERITANCE,
+ SWIGWARN_D_MULTIPLE_INHERITANCE,
+ SWIGWARN_PHP_MULTIPLE_INHERITANCE) HHH; /* C#, D, Java, PHP multiple inheritance */
+
%warnfilter(SWIGWARN_LANG_FRIEND_IGNORE) F; /* friend function */
%delobject F::destroy;
void bar(F *) { }
#if defined(_MSC_VER)
- #pragma warning(disable: 4624) // : destructor could not be generated because a base class destructor is inaccessible
+ #pragma warning(disable: 4624) // destructor could not be generated because a base class destructor is inaccessible or deleted
#endif
+
+// Single inheritance, base has private destructor
class FFF : public F {
};
+
+// Multiple inheritance, one base has private destructor
+class GGG : public A, public F {
+};
+class HHH : public F, public A {
+};
+
#if defined(_MSC_VER)
- #pragma warning(default: 4624) // : destructor could not be generated because a base class destructor is inaccessible
+ #pragma warning(default: 4624) // destructor could not be generated because a base class destructor is inaccessible or deleted
#endif
/* A class with a protected destructor */
}
};
-
+%inline %{
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
+%}
%inline %{
-class A { int x; };
+class A {
+public:
+ int x;
+};
class B {
class C { int y; }; //generates a warning
class D : public A { int z; }; //ok
class Example3
{
protected:
- /* the default constructor is always emitter, even when protected,
+ /* the default constructor is always emitted, even when protected,
having another public constructor, and 'dirprot' is not used.
This is just for Java compatibility */
Example3()
%apply (char *STRING, size_t LENGTH) { (char *dataBufferAA, int sizeAA) };
%apply (char *STRING, size_t LENGTH) { (char *dataBufferBB, int sizeBB) };
+%apply (char* STRING, size_t LENGTH) { (const void* data, size_t datalen) };
%inline %{
#include <stdlib.h>
if (dataBufferBB)
memset(dataBufferBB, -1, sizeBB);
}
+ virtual void writeData(const void* data, size_t datalen) = 0;
};
class Caller {
void call_null() {
_callback->run(NULL, 0, NULL, 0);
}
+ int callWriteData() {
+ int sum = 0;
+ if (_callback) {
+ char* aa = (char*)malloc(BUFFER_SIZE_AA);
+ memset(aa, 9, BUFFER_SIZE_AA);
+ _callback->writeData(aa, BUFFER_SIZE_AA);
+ for (int i = 0; i < BUFFER_SIZE_AA; i++)
+ sum += aa[i];
+ }
+ return sum;
+ }
};
%}
%module(directors="1") director_exception
+%warnfilter(SWIGWARN_TYPEMAP_DIRECTOROUT_PTR) return_const_char_star;
+
%{
#if defined(_MSC_VER)
#endif
+#ifdef SWIGJAVA
+
+// Default for director exception warns about unmapped exceptions now in java
+// Suppress warnings for this older test
+// %warnfilter(476) Bar;
+
+// Default for java is to throw Swig::DirectorException if no
+// direct:except feature. Since methods below have exception specification
+// cannot throw director exception.
+
+// Change back to old 2.0 default behavior
+
+%feature("director:except") {
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ // Dont clear exception, still be active when return to java execution
+ // Essentially ignore exception occurred -- old behavior.
+ return $null;
+ }
+}
+
+#endif
+
#ifdef SWIGRUBY
%feature("director:except") {
%}
%feature("director") Bar;
-
+%feature("director") ReturnAllTypes;
%inline %{
struct Exception1
virtual std::string pang() throw () { return "Bar::pang()"; }
};
+ // Class to allow regression testing SWIG/PHP not checking if an exception
+ // had been thrown in directorout typemaps.
+ class ReturnAllTypes
+ {
+ public:
+ int call_int() { return return_int(); }
+ double call_double() { return return_double(); }
+ const char * call_const_char_star() { return return_const_char_star(); }
+ std::string call_std_string() { return return_std_string(); }
+ Bar call_Bar() { return return_Bar(); }
+
+ virtual int return_int() { return 0; }
+ virtual double return_double() { return 0.0; }
+ virtual const char * return_const_char_star() { return ""; }
+ virtual std::string return_std_string() { return std::string(); }
+ virtual Bar return_Bar() { return Bar(); }
+ virtual ~ReturnAllTypes() {}
+ };
+
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
%}
%module(directors="1") director_frob;
#pragma SWIG nowarn=SWIGWARN_TYPEMAP_THREAD_UNSAFE,SWIGWARN_TYPEMAP_DIRECTOROUT_PTR
+#ifdef SWIGSCILAB
+%rename(cb) coreCallbacks;
+%rename(On3dEngRedrawn) coreCallbacksOn3dEngineRedrawnData;
+%rename (_On3dEngRedrawn) coreCallbacks_On3dEngineRedrawnData;
+#endif
+
%header %{
#include <iostream>
%}
virtual ~Alpha() { };
virtual const char* abs_method() = 0;
};
-
+
struct Bravo : Alpha
{
const char* abs_method()
}
};
- struct Charlie : Bravo
+ struct Charlie : Bravo
{
const char* abs_method()
{
return "Charlie::abs_method()";
}
};
-
+
struct Delta : Charlie
{
};
public:
Ops() : num(0) {}
virtual ~Ops() {}
+#if !defined(__SUNPRO_CC)
virtual operator int() { return 0; }
+#endif
virtual operator int **() const {
return (int **) 0;
}
%ignore OverloadedProtectedMethod(int n, int xoffset = 0, int yoffset = 0);
%ignore DIgnoreConstructor(bool b);
%ignore DIgnoreOnlyConstructor(bool b);
+%ignore DIgnoreDestructor::~DIgnoreDestructor;
%ignore Pointers;
%ignore References;
%ignore PublicMethod1;
DIgnoreOnlyConstructor(bool b) {}
};
+class DIgnoreDestructor
+{
+ public:
+ DIgnoreDestructor() {}
+ virtual ~DIgnoreDestructor() {}
+};
+
%{
class DIgnoreConstructor
{
private: // Hide constructor
DIgnoreOnlyConstructor(bool b) {}
};
-%}
+class DIgnoreDestructor
+{
+ public:
+ DIgnoreDestructor() {}
+ virtual ~DIgnoreDestructor() {}
+};
+
+%}
// Checks if collisions of argument names with target language keywords are
-// resolved properly when directors are used (currently only »abstract« for
-// C#, D and Java is checked).
+// resolved properly when directors are used
%module(directors="1") director_keywords
+%warnfilter(SWIGWARN_PARSE_KEYWORD);
+
%feature("director") Foo;
%inline %{
struct Foo {
virtual ~Foo() {}
- virtual void bar(int abstract) {}
+ virtual void check_abstract(int abstract) {} // for Java, C#, D...
+ virtual void check_self(int self) {} // self for Python
+ virtual void check_from(int from) {} // for Python
};
%}
--- /dev/null
+%module(directors="1") director_nested_class
+
+
+%feature("director") DirectorOuter::DirectorInner;
+%feature("director") DirectorOuter::DirectorInner::DirectorInnerInner;
+
+%inline %{
+struct DirectorOuter {
+ struct DirectorInner {
+ virtual ~DirectorInner() {}
+ virtual int vmethod(int input) const = 0;
+ struct DirectorInnerInner {
+ DirectorInnerInner(DirectorInner *din = 0) {}
+ virtual ~DirectorInnerInner() {}
+ virtual int innervmethod(int input) const = 0;
+ };
+ };
+ static int callMethod(const DirectorInner &di, int value) {
+ return di.vmethod(value);
+ }
+ static int callInnerInnerMethod(const DirectorInner::DirectorInnerInner &di, int value) {
+ return di.innervmethod(value);
+ }
+};
+%}
--- /dev/null
+%module(directors="1") "director::nestedmodule"
+
+%{
+#include <string>
+
+class Foo {
+ public:
+ virtual ~Foo() {}
+ virtual std::string ping() { return "Foo::ping()"; }
+ virtual std::string pong() { return "Foo::pong();" + ping(); }
+
+ static Foo* get_self(Foo *slf) {return slf;}
+};
+
+%}
+
+%include <std_string.i>
+
+%feature("director") Foo;
+
+
+class Foo {
+ public:
+ virtual ~Foo();
+ virtual std::string ping();
+ virtual std::string pong();
+
+ static Foo* get_self(Foo *slf);
+};
%include <std_string.i>
// nspace feature only supported by these languages
-#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGD)
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGD) || defined(SWIGLUA) || defined(SWIGJAVASCRIPT)
%nspace TopLevel::Bar::Foo;
%nspace TopLevel::Bar::FooBar;
#else
-#warning nspace feature not yet supported in this target language
+//#warning nspace feature not yet supported in this target language
#endif
%feature("director") TopLevel::Bar::Foo;
%include <std_string.i>
// nspace feature only supported by these languages
-#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGD)
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGD) || defined(SWIGLUA) || defined(SWIGJAVASCRIPT)
%nspace TopLevel::A::Foo;
%nspace TopLevel::B::Foo;
#else
-#warning nspace feature not yet supported in this target language
+//#warning nspace feature not yet supported in this target language
%ignore TopLevel::B::Foo;
#endif
};
struct OverloadDerived1 : OverloadBase {
virtual void nnn(int vvv) {}
-// virtual void nnn() {}
+#if defined(__SUNPRO_CC)
+ virtual void nnn() {}
+#endif
};
struct OverloadDerived2 : OverloadBase {
-// virtual void nnn(int vvv) {}
+#if defined(__SUNPRO_CC)
+ virtual void nnn(int vvv) {}
+#endif
virtual void nnn() {}
};
%}
--- /dev/null
+%module(directors="1") director_pass_by_value
+%director DirectorPassByValueAbstractBase;
+
+%inline %{
+class PassedByValue {
+ int val;
+public:
+ PassedByValue() { val = 0x12345678; }
+ int getVal() { return val; }
+};
+
+int doSomething(int x) {
+ int yy[256];
+ yy[0] =0x9876;
+ return yy[0];
+}
+
+class DirectorPassByValueAbstractBase {
+public:
+ virtual void virtualMethod(PassedByValue pbv) = 0;
+ virtual ~DirectorPassByValueAbstractBase () {}
+};
+
+class Caller {
+public:
+ void call_virtualMethod(DirectorPassByValueAbstractBase &f) {
+ f.virtualMethod(PassedByValue());
+ }
+};
+%}
--- /dev/null
+%module(directors="1") director_property
+
+%warnfilter(SWIGWARN_TYPEMAP_THREAD_UNSAFE,SWIGWARN_TYPEMAP_DIRECTOROUT_PTR) MyClass::pmethod;
+
+%{
+ #include <string>
+
+ class Foo {
+ private:
+ std::string a_;
+ public:
+ virtual ~Foo() {}
+ virtual std::string ping() { return "Foo::ping()"; }
+ virtual std::string pong() { return "Foo::pong();" + ping(); }
+ virtual std::string getA() { return this->a_; }
+ virtual void setA(std::string a) { this->a_ = a; }
+
+ static Foo* get_self(Foo *slf) {return slf;}
+
+ };
+
+ %}
+
+ %include <std_string.i>
+
+ %feature("director") Foo;
+
+
+ class Foo {
+ public:
+ virtual ~Foo();
+ virtual std::string ping();
+ virtual std::string pong();
+ virtual std::string getA();
+ virtual void setA(std::string a);
+
+ static Foo* get_self(Foo *slf);
+
+ };
+
+ %{
+ #include <complex>
+ %}
+ %feature("director") A;
+
+ // basic renaming
+ %rename(rg) A::gg;
+ %feature("nodirector") hi::A1::gg;
+
+ %inline %{
+
+ struct A{
+ A(std::complex<int> i, double d=0.0) {}
+ A(int i, bool j=false) {}
+ virtual ~A() {}
+
+ virtual int f(int i=0) {return i;}
+ virtual int gg(int i=0) {return i;}
+ };
+
+ namespace hi {
+
+ struct A1 : public A {
+ A1(std::complex<int> i, double d=0.0) : A(i, d) {}
+ A1(int i, bool j=false) : A(i, j) {}
+
+ virtual int ff(int i = 0) {return i;}
+ };
+ }
+
+
+ %}
+
+
+ %feature("director") MyClass;
+
+ %inline %{
+
+ typedef void VoidType;
+
+ struct Bar
+ {
+ int x;
+ Bar(int _x = 0) : x(_x)
+ {
+ }
+ };
+
+
+
+class MyClass {
+public:
+ MyClass(int a = 0)
+ {
+ }
+
+ virtual void method(VoidType *)
+ {
+ }
+
+ virtual ~MyClass()
+ {
+ }
+
+ virtual Bar vmethod(Bar b)
+ {
+ b.x += 13;
+ return b;
+ }
+
+ virtual Bar* pmethod(Bar *b)
+ {
+ b->x += 12;
+ return b;
+ }
+
+ Bar cmethod(const Bar &b)
+ {
+ return vmethod(b);
+ }
+
+ static MyClass *get_self(MyClass *c)
+ {
+ return c;
+ }
+
+ static Bar * call_pmethod(MyClass *myclass, Bar *b) {
+ return myclass->pmethod(b);
+ }
+};
+
+template<class T>
+class MyClassT {
+public:
+ MyClassT(int a = 0)
+ {
+ }
+
+ virtual void method(VoidType *)
+ {
+ }
+
+ virtual ~MyClassT()
+ {
+ }
+
+};
+
+%}
+
+%template(MyClassT_i) MyClassT<int>;
--- /dev/null
+%module(directors="1") director_ref
+
+%{
+#include <string>
+
+class Foo {
+public:
+ Foo(int i = -1) : count(0) {}
+ virtual void OnDelete() {}
+ virtual ~Foo() {}
+ virtual std::string Msg(std::string msg = "default") { return "Foo-" + msg; }
+
+ std::string GetMsg() { return Msg(); }
+ std::string GetMsg(std::string msg) { return Msg(msg); }
+
+ void Ref() { ++count; }
+ void Unref() { --count; if (count == 0) { OnDelete(); delete this; } }
+ int GetRefCount() { return count; }
+private:
+ int count;
+};
+
+class FooPtr {
+public:
+ FooPtr(Foo* f = NULL) : my_f(f) { if (my_f) { my_f->Ref(); } }
+ ~FooPtr() { if (my_f) { my_f->Unref(); } }
+ void Reset(Foo* f = NULL) {
+ if (f) { f->Ref(); }
+ if (my_f) { my_f->Unref(); }
+ my_f = f;
+ }
+ int GetOwnedRefCount() {
+ if (my_f) { return my_f->GetRefCount(); }
+ return 0;
+ }
+
+private:
+ Foo* my_f;
+};
+
+%}
+
+%include <std_string.i>
+
+%feature("director") Foo;
+%feature("ref") Foo "$this->Ref();"
+%feature("unref") Foo "$this->Unref();"
+
+class Foo {
+public:
+ Foo(int i = -1) : count(0) {}
+ virtual void OnDelete() {}
+ virtual ~Foo() {}
+ virtual std::string Msg(std::string msg = "default") { return "Foo-" + msg; }
+
+ std::string GetMsg() { return Msg(); }
+ std::string GetMsg(std::string msg) { return Msg(msg); }
+
+ void Ref() { ++count; }
+ void Unref() { --count; if (count == 0) { OnDelete(); delete this; } }
+ int GetRefCount() { return count; }
+private:
+ int count;
+};
+
+class FooPtr {
+public:
+ FooPtr(Foo* f = NULL) : my_f(f) { if (my_f) { my_f->Ref(); } }
+ ~FooPtr() { if (my_f) { my_f->Unref(); } }
+ void Reset(Foo* f = NULL) {
+ if (f) { f->Ref(); }
+ if (my_f) { my_f->Unref(); }
+ my_f = f;
+ }
+ int GetOwnedRefCount() {
+ if (my_f) { return my_f->GetRefCount(); }
+ return 0;
+ }
+
+private:
+ Foo* my_f;
+};
virtual ~Foo() {}
virtual std::string ping() { return "Foo::ping()"; }
virtual std::string pong() { return "Foo::pong();" + ping(); }
- virtual std::string fooBar(FooBar* fooBarPtr) { return fooBarPtr->FooBarDo(); }
+ virtual std::string upcall(FooBar* fooBarPtr) { return fooBarPtr->FooBarDo(); }
virtual Foo makeFoo() { return Foo(); }
virtual FooBar makeFooBar() { return FooBar(); }
+ static std::string callPong(Foo &foo) { return foo.pong(); }
+ static std::string callUpcall(Foo &foo, FooBar* fooBarPtr) { return foo.upcall(fooBarPtr); }
static Foo* get_self(Foo *self_) {return self_;}
};
%}
-#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD)
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD) || defined(SWIGOCTAVE) || defined(SWIGRUBY)
#define SHARED_PTR_WRAPPERS_IMPLEMENTED
#endif
virtual ~Foo();
virtual std::string ping();
virtual std::string pong();
- virtual std::string fooBar(FooBar* fooBarPtr);
+ virtual std::string upcall(FooBar* fooBarPtr);
virtual Foo makeFoo();
virtual FooBar makeFooBar();
+ static std::string callPong(Foo &foo);
+ static std::string callUpcall(Foo &foo, FooBar* fooBarPtr);
static Foo* get_self(Foo *self_);
};
--- /dev/null
+%module empty_c
%module enum_forward
-/* This contains C code that is not valid C++03 and Octave wrappers are always compiled as C++ */
-#if !defined(SWIGOCTAVE)
+/* This contains C code that is not valid C++03 and Octave, and Javascript(v8) wrappers are always compiled as C++ */
+#if !defined(SWIGOCTAVE) && !defined(SWIG_JAVASCRIPT_V8)
%{
enum ForwardEnum1 { AAA, BBB };
enum ForwardEnum2 { CCC, DDD };
%}
%inline %{
+#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+/* ISO C forbids forward references to ‘enum’ types [-Werror=pedantic] */
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+
+#if !defined(__SUNPRO_C)
enum ForwardEnum1;
+enum ForwardEnum2;
+enum ForwardEnum2;
+enum ForwardEnum3;
+#endif
+%}
+
+%inline %{
enum ForwardEnum1 get_enum1() { return AAA; }
enum ForwardEnum1 test_function1(enum ForwardEnum1 e) {
return e;
%}
%inline %{
-enum ForwardEnum2;
-enum ForwardEnum2;
enum ForwardEnum2 get_enum2() { return CCC; }
enum ForwardEnum2 test_function2(enum ForwardEnum2 e) {
return e;
}
-enum ForwardEnum2;
%}
%inline %{
-enum ForwardEnum3;
enum ForwardEnum3 { EEE, FFF };
enum ForwardEnum3 get_enum3() { return EEE; }
enum ForwardEnum3 test_function3(enum ForwardEnum3 e) {
return e;
}
+%}
+
+%inline %{
+#if !defined(__SUNPRO_C)
+enum ForwardEnum2;
enum ForwardEnum3;
+#endif
%}
+
#endif
--- /dev/null
+%module enum_ignore
+
+// Similar to enum_missing C test, but with namespaces and using %ignore
+
+%ignore N::C;
+
+%inline %{
+ namespace N {
+ enum C { Red, Green, Blue };
+
+ struct Draw {
+ void DrawBW() {}
+ void DrawC(C c) {}
+ void DrawC_Ptr(C* c) {}
+ void DrawC_ConstRef(C const& c) {}
+ };
+ }
+%}
+
+
%module enum_macro
%inline %{
+
+#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+/* comma at end of enumerator list [-Werror=pedantic] */
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+
+
enum Greeks1
{
#define GREEK1 -1
--- /dev/null
+%module enum_missing
+
+// Test when SWIG does not parse the enum definition
+%{
+enum AVPixelFormat {
+ AV_PIX_FMT_NONE = -1,
+ AV_PIX_FMT_YUV420P
+};
+enum AVPixelFormat2 {
+ AV_PIX_FMT_NONE2 = -1,
+ AV_PIX_FMT_YUV420P2
+};
+
+%}
+
+%inline %{
+typedef struct AVCodecCtx {
+ enum AVPixelFormat pix_fmt;
+ enum AVPixelFormat2 pix_fmt2;
+} AVCodecCtx;
+
+enum AVPixelFormat global_fmt;
+enum AVPixelFormat2 global_fmt2;
+
+enum AVPixelFormat use_pixel_format(enum AVPixelFormat px) {
+ return px;
+}
+enum AVPixelFormat * use_pixel_format_ptr(enum AVPixelFormat *px) {
+ return px;
+}
+
+enum AVPixelFormat2 use_pixel_format2(const enum AVPixelFormat2 px) {
+ return px;
+}
+const enum AVPixelFormat2 * use_pixel_format_ptr2(const enum AVPixelFormat2 *px) {
+ return px;
+}
+%}
+
%warnfilter(SWIGWARN_PARSE_REDEFINED) S_May;
-// %rename using regex can do the equivalent of these two renames, which was resulting in uncompileable code
+// %rename using regex can do the equivalent of these two renames, which was resulting in uncompilable code
%rename(May) M_May;
%rename(May) S_May;
OldNameStruct::singlename renameTest7(OldNameStruct::singlename e) { return e; }
%}
+%rename(Clash1_di1) Clash1::di1;
+%rename(Clash1_di2) Clash1::di2;
+%rename(Clash1_di3) Clash1::di3;
+%inline %{
+namespace Clash1 {
+ enum DuplicateItems1 { di1, di2 = 10, di3 };
+}
+namespace Clash2 {
+ enum DuplicateItems2 { di1, di2 = 10, di3 };
+}
+%}
+
%inline %{
struct TreesClass {
enum trees {oak, fir, pine };
};
int globalDifferentTypesTest(int n) { return n; }
}
+%}
+#if defined(SWIGCSHARP)
+%csconstvalue("1") globalenumchar1;
+%csconstvalue("'B'") globalenumcharB;
+%csconstvalue("1") enumchar1;
+%csconstvalue("'B'") enumcharB;
+#endif
+%inline %{
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Suppress: illegal character encoding in character literal
+#pragma clang diagnostic ignored "-Winvalid-source-encoding"
+#endif
+
+enum {
+ globalenumchar0 = '\0',
+ globalenumchar1 = '\1',
+ globalenumchar2 = '\n',
+ globalenumcharA = 'A',
+ globalenumcharB = '\102', // B
+ globalenumcharC = '\x43', // C
+ globalenumcharD = 0x44, // D
+ globalenumcharE = 69, // E
+ globalenumcharAE1 = 'Æ', // AE (latin1 encoded)
+ globalenumcharAE2 = '\306', // AE (latin1 encoded)
+ globalenumcharAE3 = '\xC6' // AE (latin1 encoded)
+};
+enum EnumChar {
+ enumchar0 = '\0',
+ enumchar1 = '\1',
+ enumchar2 = '\n',
+ enumcharA = 'A',
+ enumcharB = '\102', // B
+ enumcharC = '\x43', // C
+ enumcharD = 0x44, // D
+ enumcharE = 69, // E
+ enumcharAE1 = 'Æ', // AE (latin1 encoded)
+ enumcharAE2 = '\306', // AE (latin1 encoded)
+ enumcharAE3 = '\xC6' // AE (latin1 encoded)
+};
+struct EnumCharStruct {
+ enum EnumChar {
+ enumchar0 = '\0',
+ enumchar1 = '\1',
+ enumchar2 = '\n',
+ enumcharA = 'A',
+ enumcharB = '\102', // B
+ enumcharC = '\x43', // C
+ enumcharD = 0x44, // D
+ enumcharE = 69, // E
+ enumcharAE1 = 'Æ', // AE (latin1 encoded)
+ enumcharAE2 = '\306', // AE (latin1 encoded)
+ enumcharAE3 = '\xC6' // AE (latin1 encoded)
+ };
+};
%}
#if defined(SWIGJAVA)
#endif
%inline %{
+enum {
+ x_globalenumchar0 = '\0',
+ x_globalenumchar1 = '\1',
+ x_globalenumchar2 = '\n',
+ x_globalenumcharA = 'A',
+ x_globalenumcharB = '\102', // B
+ x_globalenumcharC = '\x43', // C
+ x_globalenumcharD = 0x44, // D
+ x_globalenumcharE = 69, // E
+ x_globalenumcharAE1 = 'Æ', // AE (latin1 encoded)
+ x_globalenumcharAE2 = '\306', // AE (latin1 encoded)
+ x_globalenumcharAE3 = '\xC6' // AE (latin1 encoded)
+};
+enum X_EnumChar {
+ x_enumchar0 = '\0',
+ x_enumchar1 = '\1',
+ x_enumchar2 = '\n',
+ x_enumcharA = 'A',
+ x_enumcharB = '\102', // B
+ x_enumcharC = '\x43', // C
+ x_enumcharD = 0x44, // D
+ x_enumcharE = 69, // E
+ x_enumcharAE1 = 'Æ', // AE (latin1 encoded)
+ x_enumcharAE2 = '\306', // AE (latin1 encoded)
+ x_enumcharAE3 = '\xC6' // AE (latin1 encoded)
+};
+struct X_EnumCharStruct {
+ enum X_EnumChar {
+ enumchar0 = '\0',
+ enumchar1 = '\1',
+ enumchar2 = '\n',
+ enumcharA = 'A',
+ enumcharB = '\102', // B
+ enumcharC = '\x43', // C
+ enumcharD = 0x44, // D
+ enumcharE = 69, // E
+ enumcharAE1 = 'Æ', // AE (latin1 encoded)
+ enumcharAE2 = '\306', // AE (latin1 encoded)
+ enumcharAE3 = '\xC6' // AE (latin1 encoded)
+ };
+};
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+%}
+
+%inline %{
namespace DifferentSpace {
enum DifferentTypesNoConst {
typeint_noconst = 10,
global_typedefaultint_noconst
};
}
-
%}
--- /dev/null
+/* File : equality.i */
+/*
+ Specific test for operator== overload. Partially overlaps with
+ operator_overload.i
+*/
+
+%module equality
+
+%warnfilter(SWIGWARN_LANG_IDENTIFIER) operator==;
+
+%inline %{
+
+/* Point has no equality operator */
+typedef struct Point
+{
+ double x;
+ double y;
+} Point;
+
+static const Point s_zeroPoint = { 0.0, 0.0 };
+/* stack version */
+Point MakePoint(double x, double y)
+ { Point new_point = {x, y}; return new_point; }
+
+const Point* GetZeroPointPtr() { return &s_zeroPoint; }
+Point GetZeroPointCopy() { return s_zeroPoint; }
+
+/* EqualOpDefined has correct equality operator */
+class EqualOpDefined {
+public:
+ EqualOpDefined():
+ x(5) {}
+ EqualOpDefined(int val):
+ x(val) {}
+
+ int x;
+};
+
+/* EqualOpWrong has logically incorrect equality operator */
+class EqualOpWrong {
+public:
+ inline static const EqualOpWrong* GetStaticObject();
+};
+
+static EqualOpWrong s_wrongEqOp;
+
+const EqualOpWrong* EqualOpWrong::GetStaticObject()
+ { return &s_wrongEqOp; }
+
+
+inline bool operator==( const EqualOpDefined& first, const EqualOpDefined& second )
+ { return first.x == second.x; }
+
+inline bool operator==( const EqualOpWrong& first, const EqualOpWrong& second )
+ { return false; }
+
+%}
+
+/*
+ in order to wrapper this correctly
+ we need to extend the class
+ to make the friends & non members part of the class
+*/
+%extend EqualOpDefined {
+ bool operator==(const EqualOpDefined& b){return (*$self) == b;}
+}
+%extend EqualOpWrong {
+ bool operator==(const EqualOpWrong& b){return (*$self) == b;}
+}
--- /dev/null
+#######################################################################
+# Makefile for errors test-suite
+#
+# This test-suite is for checking SWIG errors and warnings and uses
+# Python as the target language.
+#
+# It compares the stderr output from SWIG to the contents of the .stderr
+# file for each test case. The test cases are different to those used by
+# the language module test-suites. The .i files in this directory are
+# used instead of those in the parent directory.
+#
+# When adding a new test case, be sure to commit the expected output
+# file (.stderr) in addition to the test case itself.
+#######################################################################
+
+LANGUAGE = errors
+ERROR_EXT = newerr
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+top_builddir = @top_builddir@
+
+SWIG_LIB_SET = @SWIG_LIB_SET@
+SWIGINVOKE = $(SWIG_LIB_SET) $(SWIGTOOL) $(SWIGEXE)
+
+# All .i files with prefix 'cpp_' will be treated as C++ input and remaining .i files as C input
+ALL_ERROR_TEST_CASES := $(patsubst %.i,%, $(notdir $(wildcard $(srcdir)/*.i)))
+CPP_ERROR_TEST_CASES := $(filter cpp_%, $(ALL_ERROR_TEST_CASES))
+C_ERROR_TEST_CASES := $(filter-out $(CPP_ERROR_TEST_CASES), $(ALL_ERROR_TEST_CASES))
+
+ERROR_TEST_CASES := $(CPP_ERROR_TEST_CASES:=.cpptest) \
+ $(C_ERROR_TEST_CASES:=.ctest)
+
+include $(srcdir)/../common.mk
+
+# Portable dos2unix / todos for stripping CR
+TODOS = tr -d '\r'
+#TODOS = sed -e 's/\r$$//' # On Mac OS X behaves as if written 's/r$$//'
+
+# strip source directory from output, so that diffs compare
+STRIP_SRCDIR = sed -e 's|\\|/|g' -e 's|^$(SRCDIR)||'
+
+# Rules for the different types of tests
+%.cpptest:
+ echo "$(ACTION)ing errors testcase $*"
+ -$(SWIGINVOKE) -c++ -python -Wall -Fstandard $(SWIGOPT) $(SRCDIR)$*.i 2>&1 | $(TODOS) | $(STRIP_SRCDIR) > $*.$(ERROR_EXT)
+ $(COMPILETOOL) diff -c $(SRCDIR)$*.stderr $*.$(ERROR_EXT)
+
+%.ctest:
+ echo "$(ACTION)ing errors testcase $*"
+ -$(SWIGINVOKE) -python -Wall -Fstandard $(SWIGOPT) $(SRCDIR)$*.i 2>&1 | $(TODOS) | $(STRIP_SRCDIR) > $*.$(ERROR_EXT)
+ $(COMPILETOOL) diff -c $(SRCDIR)$*.stderr $*.$(ERROR_EXT)
+
+%.clean:
+ @exit 0
+
+clean:
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' python_clean
+ @rm -f *.$(ERROR_EXT) *.py
--- /dev/null
+c_bad_name.i:3: Warning 121: %name is deprecated. Use %rename instead.
+c_bad_name.i:3: Error: Missing argument to %name directive.
--- /dev/null
+c_bad_native.i:3: Error: %native declaration 'foo' is not a function.
--- /dev/null
+c_class.i:3: Warning 301: class keyword used, but not in C++ mode.
+c_class.i:3: Warning 314: 'class' is a python keyword, renaming to '_class'
+++ /dev/null
-%module xxx
-
-int foo(int x = 42 || 3);
-
--- /dev/null
+c_deprecated.i:3: Warning 102: %val directive deprecated (ignored).
+c_deprecated.i:3: Warning 103: %out directive deprecated (ignored).
--- /dev/null
+c_empty_char.i:3: Error: Empty character constant
--- /dev/null
+c_enum_badvalue.i:6: Error: Type error. Expecting an integral type
--- /dev/null
+c_extra_rblock.i:5: Error: Syntax error. Extraneous '%}'
--- /dev/null
+c_extra_rbrace.i:5: Error: Syntax error. Extraneous '}'
--- /dev/null
+c_extra_unsigned.i:3: Error: Extra unsigned specifier.
+c_extra_unsigned.i:4: Error: Extra signed specifier.
+c_extra_unsigned.i:5: Error: Extra signed specifier.
--- /dev/null
+c_insert_missing.i:3: Error: Couldn't find 'missing_file.i'.
--- /dev/null
+c_long_short.i:3: Error: Extra long specifier.
+c_long_short.i:4: Error: Extra short specifier.
+c_long_short.i:5: Error: Extra long specifier.
+c_long_short.i:6: Error: Extra short specifier.
--- /dev/null
+c_missing_rbrace.i:3: Error: Missing '}'. Reached end of input.
+c_missing_rbrace.i:3: Error: Syntax error in input(1).
--- /dev/null
+c_missing_semi.i:3: Error: Syntax error - possibly a missing semicolon.
--- /dev/null
+c_redefine.i:4: Warning 302: Identifier 'foo' redefined (ignored),
+c_redefine.i:3: Warning 302: previous definition of 'foo'.
+c_redefine.i:8: Warning 302: Identifier 'bar' redefined (ignored),
+c_redefine.i:6: Warning 302: previous definition of 'bar'.
+c_redefine.i:14: Warning 322: Redundant redeclaration of 'bar' (Renamed from 'spam'),
+c_redefine.i:6: Warning 322: previous declaration of 'bar'.
+++ /dev/null
-%module xxx
-
-int foo(int x, ...);
--- /dev/null
+c_varargs_neg.i:3: Error: Argument count in %varargs must be positive.
--- /dev/null
+cpp_bad_extern.i:5: Warning 313: Unrecognized extern type "INTERCAL".
+cpp_bad_extern.i:7: Warning 313: Unrecognized extern type "INTERCAL".
--- /dev/null
+cpp_extend_destructors.i:8: Warning 302: Identifier '~AStruct' redefined by %extend (ignored),
+cpp_extend_destructors.i:5: Warning 302: %extend definition of '~AStruct'.
+cpp_extend_destructors.i:14: Warning 302: Identifier '~BStruct' redefined (ignored),
+cpp_extend_destructors.i:13: Warning 302: previous definition of '~BStruct'.
+cpp_extend_destructors.i:87: Warning 302: Identifier '~JStruct' redefined (ignored),
+cpp_extend_destructors.i:85: Warning 302: previous definition of '~JStruct'.
+cpp_extend_destructors.i:100: Warning 302: Identifier '~LStruct' redefined (ignored),
+cpp_extend_destructors.i:98: Warning 302: previous definition of '~LStruct'.
+cpp_extend_destructors.i:24: Warning 521: Illegal destructor name CStruct::~NOT_CStruct(). Ignored.
+cpp_extend_destructors.i:30: Warning 521: Illegal destructor name DStruct::~NOT_DStruct(). Ignored.
+cpp_extend_destructors.i:44: Warning 521: Illegal destructor name EStruct::~NOT_EStruct(). Ignored.
+cpp_extend_destructors.i:50: Warning 521: Illegal destructor name FStruct::~NOT_FStruct(). Ignored.
+cpp_extend_destructors.i:65: Warning 521: Illegal destructor name GStruct::~NOT_GStruct(). Ignored.
+cpp_extend_destructors.i:72: Warning 521: Illegal destructor name HStruct::~NOT_HStruct(). Ignored.
+cpp_extend_destructors.i:81: Warning 521: Illegal destructor name IStruct::~NOT_IStruct(). Ignored.
+cpp_extend_destructors.i:86: Warning 521: Illegal destructor name JStruct::~NOT_JStruct(). Ignored.
+cpp_extend_destructors.i:92: Warning 521: Illegal destructor name KStruct::~NOT_KStruct(). Ignored.
+cpp_extend_destructors.i:99: Warning 521: Illegal destructor name LStruct< int >::~NOT_LStruct(). Ignored.
+cpp_extend_destructors.i:99: Warning 521: Illegal destructor name LStruct< short >::~NOT_LStruct(). Ignored.
--- /dev/null
+cpp_extend_redefine.i:9: Warning 302: Identifier 'bar' redefined by %extend (ignored),
+cpp_extend_redefine.i:5: Warning 302: %extend definition of 'bar'.
+cpp_extend_redefine.i:14: Warning 322: Redundant redeclaration of 'spam',
+cpp_extend_redefine.i:10: Warning 322: previous declaration of 'spam'.
--- /dev/null
+cpp_extend_undefined.i:6: Warning 303: %extend defined for an undeclared class foo.
--- /dev/null
+%module cpp_extra_brackets
+
+// Extra brackets was segfaulting in SWIG-3.0.0
+struct ABC {
+ int operator<<(ABC &))) { return 0; }
+};
--- /dev/null
+cpp_extra_brackets.i:5: Error: Unexpected ')'.
--- /dev/null
+%module cpp_extra_brackets
+
+// Extra brackets was segfaulting in SWIG-3.0.0
+struct ABC {
+;
+)))
+int operator<<(ABC &) { return 0; }
+int operator>>(ABC &) { return 0; }
+};
--- /dev/null
+cpp_extra_brackets2.i:6: Error: Syntax error in input(3).
--- /dev/null
+cpp_inherit.i:18: Warning 309: private inheritance from base 'A3' (ignored).
+cpp_inherit.i:20: Warning 309: private inheritance from base 'A4' (ignored).
+cpp_inherit.i:28: Warning 309: protected inheritance from base 'A8< double >' (ignored).
+cpp_inherit.i:39: Warning 319: No access specifier given for base class 'B1' (ignored).
+cpp_inherit.i:40: Warning 319: No access specifier given for base class 'B2< int >' (ignored).
+cpp_inherit.i:15: Warning 401: Base class 'A1' undefined.
+cpp_inherit.i:33: Warning 401: 'A1' must be defined before it is used as a base class.
+cpp_inherit.i:17: Warning 401: Nothing known about base class 'A2'. Ignored.
+cpp_inherit.i:22: Warning 402: Base class 'A5' is incomplete.
+cpp_inherit.i:4: Warning 402: Only forward declaration 'A5' was found.
+cpp_inherit.i:24: Error: 'A6' is not a valid base class.
+cpp_inherit.i:5: Error: See definition of 'A6'.
+cpp_inherit.i:24: Warning 401: Nothing known about base class 'A6'. Ignored.
+cpp_inherit.i:26: Warning 401: Nothing known about base class 'A7< int >'. Ignored.
+cpp_inherit.i:26: Warning 401: Maybe you forgot to instantiate 'A7< int >' using %template.
+cpp_inherit.i:45: Warning 323: Recursive scope inheritance of 'Recursive'.
+cpp_inherit.i:52: Warning 401: Base class 'Base< int >' has no name as it is an empty template instantiated with '%template()'. Ignored.
+cpp_inherit.i:51: Warning 401: The %template directive must be written before 'Base< int >' is used as a base class and be declared with a name.
+cpp_inherit.i:53: Warning 401: Base class 'Base< double >' undefined.
+cpp_inherit.i:54: Warning 401: 'Base< double >' must be defined before it is used as a base class.
--- /dev/null
+%module xxx
+
+// Only non-ignored classes should warn about Ignored base classes
+%ignore ActualClass;
+%ignore ActualClassNoTemplates;
+
+%{
+struct BaseClassNoTemplates {};
+%}
+%inline %{
+template<typename T>
+class TemplateClass {};
+
+class ActualClass : public TemplateClass<int> {};
+class AktuelKlass : public TemplateClass<int> {};
+
+class ActualClassNoTemplates : public BaseClassNoTemplates {};
+class AktuelKlassNoTemplates : public BaseClassNoTemplates {};
+%}
--- /dev/null
+cpp_inherit_ignored.i:15: Warning 401: Nothing known about base class 'TemplateClass< int >'. Ignored.
+cpp_inherit_ignored.i:15: Warning 401: Maybe you forgot to instantiate 'TemplateClass< int >' using %template.
+cpp_inherit_ignored.i:18: Warning 401: Nothing known about base class 'BaseClassNoTemplates'. Ignored.
--- /dev/null
+cpp_inline_namespace.i:4: Error: %inline directive inside a namespace is disallowed.
void overload5(int *) {}
void overload5(const int *) {}
-
+%ignore Outer2::QuietInner;
+struct Outer2 {
+ struct QuietInner {
+ VARIABLEMACRO(MyInnerVar)
+ };
+};
--- /dev/null
+cpp_macro_locator.i:66: Warning 204: CPP #warning, "inline warning message one".
+cpp_macro_locator.i:96: Warning 204: CPP #warning, "an inline warning message 2".
+cpp_macro_locator.i:50: Warning 325: Nested struct not currently supported (Inner ignored)
+cpp_macro_locator.i:53: Warning 509: Overloaded method overload1(int const *) effectively ignored,
+cpp_macro_locator.i:52: Warning 509: as it is shadowed by overload1(int *).
+cpp_macro_locator.i:61: Warning 509: Overloaded method overload2(int const *) effectively ignored,
+cpp_macro_locator.i:60: Warning 509: as it is shadowed by overload2(int *).
+cpp_macro_locator.i:64: Warning 509: Overloaded method Klass1::methodX(int const *) effectively ignored,
+cpp_macro_locator.i:64: Warning 509: as it is shadowed by Klass1::methodX(int *).
+cpp_macro_locator.i:68: Warning 509: Overloaded method overload3(int const *) effectively ignored,
+cpp_macro_locator.i:67: Warning 509: as it is shadowed by overload3(int *).
+cpp_macro_locator.i:90: Warning 509: Overloaded method overload4(int const *) effectively ignored,
+cpp_macro_locator.i:89: Warning 509: as it is shadowed by overload4(int *).
+cpp_macro_locator.i:94: Warning 509: Overloaded method overloadinline1(int const *) effectively ignored,
+cpp_macro_locator.i:93: Warning 509: as it is shadowed by overloadinline1(int *).
+cpp_macro_locator.i:95: Warning 509: Overloaded method Klass2::methodX(int const *) effectively ignored,
+cpp_macro_locator.i:95: Warning 509: as it is shadowed by Klass2::methodX(int *).
+cpp_macro_locator.i:98: Warning 509: Overloaded method overloadinline2(int const *) effectively ignored,
+cpp_macro_locator.i:97: Warning 509: as it is shadowed by overloadinline2(int *).
+cpp_macro_locator.i:101: Warning 509: Overloaded method overload5(int const *) effectively ignored,
+cpp_macro_locator.i:100: Warning 509: as it is shadowed by overload5(int *).
--- /dev/null
+cpp_missing_rparenthesis.i:5: Error: Missing ')'. Reached end of input.
+cpp_missing_rparenthesis.i:5: Error: Syntax error in input(3).
--- /dev/null
+cpp_missing_rtemplate.i:4: Error: Syntax error in input(1).
--- /dev/null
+cpp_namespace_alias.i:8: Warning 308: Namespace alias 'B' not allowed here. Assuming 'blah'
--- /dev/null
+cpp_namespace_aliasnot.i:4: Error: 'blah' is not a namespace
--- /dev/null
+cpp_namespace_aliasundef.i:3: Error: Unknown namespace 'blah'
+++ /dev/null
-%module xxx
-
-class Foo {
-public:
- class Bar {
- };
-};
-
-class Spam {
-public:
- class Grok {
- } x;
-};
--- /dev/null
+%module xxx
+
+template<typename T> struct Temply {
+ T thing;
+};
+
+struct A {
+ int var;
+%template(TemplyInt) Temply<int>;
+};
+
+
+struct B {
+ int var;
+};
+
+%extend B {
+%template(TemplyDouble) Temply<double>;
+}
+
--- /dev/null
+cpp_nested_template.i:9: Warning 324: Named nested template instantiations not supported. Processing as if no name was given to %template().
+cpp_nested_template.i:18: Warning 324: Named nested template instantiations not supported. Processing as if no name was given to %template().
--- /dev/null
+cpp_no_access.i:3: Warning 319: No access specifier given for base class 'foo' (ignored).
--- /dev/null
+cpp_no_return_type.i:6: Warning 504: Function S::R() must have a return type. Ignored.
+cpp_no_return_type.i:10: Warning 504: Function U::UU() must have a return type. Ignored.
--- /dev/null
+cpp_nobase.i:3: Warning 401: Nothing known about base class 'Bar'. Ignored.
+cpp_nobase.i:6: Warning 401: Nothing known about base class 'Bar< int >'. Ignored.
+cpp_nobase.i:6: Warning 401: Maybe you forgot to instantiate 'Bar< int >' using %template.
+++ /dev/null
-%module xxx
-int foo(int x);
-int foo(double x);
-
-class Foo {
-public:
- int bar(int);
- int bar(double);
-};
-
-class Spam {
-public:
- Spam();
- Spam(int);
-};
--- /dev/null
+cpp_overload_const.i:4: Warning 509: Overloaded method check(int *) effectively ignored,
+cpp_overload_const.i:3: Warning 509: as it is shadowed by check(int const *).
+cpp_overload_const.i:5: Warning 509: Overloaded method check(int &) effectively ignored,
+cpp_overload_const.i:3: Warning 509: as it is shadowed by check(int const *).
+cpp_overload_const.i:10: Warning 509: Overloaded method check(OverStruct *) effectively ignored,
+cpp_overload_const.i:9: Warning 509: as it is shadowed by check(OverStruct const *).
+cpp_overload_const.i:11: Warning 509: Overloaded method check(OverStruct &) effectively ignored,
+cpp_overload_const.i:9: Warning 509: as it is shadowed by check(OverStruct const *).
+cpp_overload_const.i:12: Warning 509: Overloaded method check(OverStruct const &) effectively ignored,
+cpp_overload_const.i:9: Warning 509: as it is shadowed by check(OverStruct const *).
+++ /dev/null
-%module xxx
-
-class foo {
-static const int BAR = 42;
-public:
- int blah(int x = BAR);
-};
--- /dev/null
+cpp_private_inherit.i:6: Warning 309: private inheritance from base 'Foo' (ignored).
+cpp_private_inherit.i:9: Warning 309: protected inheritance from base 'Foo' (ignored).
--- /dev/null
+:1: Error: Recursive typedef detected resolving 'pds *' to 'std::set< pds > *' to 'std::set< std::set< pds > > *' and so on...
--- /dev/null
+cpp_shared_ptr.i:20: Warning 520: Base class 'A' of 'C' is not similarly marked as a smart pointer.
+cpp_shared_ptr.i:24: Warning 520: Derived class 'D' of 'C' is not similarly marked as a smart pointer.
+cpp_shared_ptr.i:24: Warning 520: Derived class 'D' of 'B' is not similarly marked as a smart pointer.
+++ /dev/null
-%module xxx
-
-template<T> T blah(T x);
-
-
-
-
-
--- /dev/null
+%module cpp_template_friend
+
+template<typename T> T template_friend1(T);
+template<typename T> T template_friend1(T);
+struct MyTemplate1 {
+ template<typename T> friend T template_friend1(T);
+};
+
+template<typename T> T template_friend2(T);
+struct MyTemplate2 {
+ template<typename T> friend T template_friend2(T);
+};
+template<typename T> T template_friend2(T);
+
+
+int normal_friend1(int);
+int normal_friend1(int);
+struct MyClass1 {
+ friend int normal_friend1(int);
+};
+
+int normal_friend2(int);
+struct MyClass2 {
+ friend int normal_friend2(int);
+};
+int normal_friend2(int);
--- /dev/null
+cpp_template_friend.i:4: Warning 302: Identifier 'template_friend1' redefined (ignored),
+cpp_template_friend.i:3: Warning 302: previous definition of 'template_friend1'.
+cpp_template_friend.i:13: Warning 302: Identifier 'template_friend2' redefined (ignored),
+cpp_template_friend.i:9: Warning 302: previous definition of 'template_friend2'.
+cpp_template_friend.i:17: Warning 322: Redundant redeclaration of 'normal_friend1',
+cpp_template_friend.i:16: Warning 322: previous declaration of 'normal_friend1'.
+cpp_template_friend.i:26: Warning 322: Redundant redeclaration of 'normal_friend2',
+cpp_template_friend.i:22: Warning 322: previous declaration of 'normal_friend2'.
--- /dev/null
+cpp_template_nargs.i:5: Error: Template 'blah' undefined.
+cpp_template_nargs.i:6: Error: Template 'blah' undefined.
--- /dev/null
+cpp_template_not.i:5: Error: 'blah' is not defined as a template. (cdecl)
--- /dev/null
+cpp_template_partial.i:3: Warning 317: Specialization of non-template 'vector'.
%template(iblah) blah<int>;
%template(iiblah) blah<int>;
-
+// The second %template instantiation above should surely be ignored with a warning, but doesn't atm
--- /dev/null
+cpp_template_undef.i:3: Error: Template 'blah' undefined.
--- /dev/null
+cpp_using_not.i:4: Error: 'blah' is not a namespace.
--- /dev/null
+%module cpp_using_type_aliasing
+
+namespace Space {
+ template<typename T> struct Okay {
+ };
+ struct User {
+ protected:
+ using OkayInt = Okay<int>;
+ };
+ struct Derived : User {
+ Okay<OkayInt> ff();
+ };
+};
--- /dev/null
+cpp_using_type_aliasing.i:8: Warning 341: The 'using' keyword in type aliasing is not fully supported yet.
+cpp_using_type_aliasing.i:8: Warning 315: Nothing known about 'Okay< int >'.
+cpp_using_type_aliasing.i:8: Warning 315: Nothing known about 'Okay< int >'.
--- /dev/null
+cpp_using_undef.i:4: Error: Nothing known about namespace 'foo'
+cpp_using_undef.i:3: Warning 315: Nothing known about 'foo::bar'.
+++ /dev/null
-SWIG error and warning test. opts=
------------------------------------------------------------
-
-:::::::::::::::::::::::::::::::: c_bad_name.i :::::::::::::::::::::::::::::::::::
-c_bad_name.i:3: Warning 121: %name is deprecated. Use %rename instead.
-c_bad_name.i:3: Error: Missing argument to %name directive.
-
-:::::::::::::::::::::::::::::::: c_bad_native.i :::::::::::::::::::::::::::::::::::
-c_bad_native.i:3: Error: %native declaration 'foo' is not a function.
-
-:::::::::::::::::::::::::::::::: c_class.i :::::::::::::::::::::::::::::::::::
-c_class.i:3: Warning 301: class keyword used, but not in C++ mode.
-c_class.i:3: Warning 314: 'class' is a python keyword, renaming to '_class'
-
-:::::::::::::::::::::::::::::::: c_default_error.i :::::::::::::::::::::::::::::::::::
-
-:::::::::::::::::::::::::::::::: c_deprecated.i :::::::::::::::::::::::::::::::::::
-c_deprecated.i:3: Warning 102: %val directive deprecated (ignored).
-c_deprecated.i:3: Warning 103: %out directive deprecated (ignored).
-
-:::::::::::::::::::::::::::::::: c_empty_char.i :::::::::::::::::::::::::::::::::::
-c_empty_char.i:3: Error: Empty character constant
-0
-
-:::::::::::::::::::::::::::::::: c_enum_badvalue.i :::::::::::::::::::::::::::::::::::
-c_enum_badvalue.i:6: Error: Type error. Expecting an integral type
-
-:::::::::::::::::::::::::::::::: c_extra_rblock.i :::::::::::::::::::::::::::::::::::
-c_extra_rblock.i:5: Error: Syntax error in input(1).
-
-:::::::::::::::::::::::::::::::: c_extra_rbrace.i :::::::::::::::::::::::::::::::::::
-c_extra_rbrace.i:5: Error: Syntax error. Extraneous '}'
-
-:::::::::::::::::::::::::::::::: c_extra_unsigned.i :::::::::::::::::::::::::::::::::::
-c_extra_unsigned.i:3: Error: Extra unsigned specifier.
-c_extra_unsigned.i:4: Error: Extra signed specifier.
-c_extra_unsigned.i:5: Error: Extra signed specifier.
-
-:::::::::::::::::::::::::::::::: c_insert_missing.i :::::::::::::::::::::::::::::::::::
-c_insert_missing.i:3: Error: Couldn't find 'missing_file.i'.
-
-:::::::::::::::::::::::::::::::: c_long_short.i :::::::::::::::::::::::::::::::::::
-c_long_short.i:3: Error: Extra long specifier.
-c_long_short.i:4: Error: Extra short specifier.
-c_long_short.i:5: Error: Extra long specifier.
-c_long_short.i:6: Error: Extra short specifier.
-
-:::::::::::::::::::::::::::::::: c_missing_rbrace.i :::::::::::::::::::::::::::::::::::
-c_missing_rbrace.i:3: Error: Missing '}'. Reached end of input.
-c_missing_rbrace.i:3: Error: Syntax error in input(1).
-
-:::::::::::::::::::::::::::::::: c_missing_semi.i :::::::::::::::::::::::::::::::::::
-c_missing_semi.i:3: Error: Syntax error in input(1).
-
-:::::::::::::::::::::::::::::::: c_redefine.i :::::::::::::::::::::::::::::::::::
-c_redefine.i:4: Warning 302: Identifier 'foo' redefined (ignored),
-c_redefine.i:3: Warning 302: previous definition of 'foo'.
-c_redefine.i:8: Warning 302: Identifier 'bar' redefined (ignored),
-c_redefine.i:6: Warning 302: previous definition of 'bar'.
-c_redefine.i:14: Warning 322: Redundant redeclaration of 'bar' (Renamed from 'spam'),
-c_redefine.i:6: Warning 322: previous declaration of 'bar'.
-
-:::::::::::::::::::::::::::::::: c_varargs.i :::::::::::::::::::::::::::::::::::
-
-:::::::::::::::::::::::::::::::: c_varargs_neg.i :::::::::::::::::::::::::::::::::::
-c_varargs_neg.i:3: Error: Argument count in %varargs must be positive.
-
-:::::::::::::::::::::::::::::::: nomodule.i :::::::::::::::::::::::::::::::::::
-No module name specified using %module or -module.
-
-:::::::::::::::::::::::::::::::: pp_badeval.i :::::::::::::::::::::::::::::::::::
-pp_badeval.i:4: Warning 202: Could not evaluate expression 'FOO==4+'
-pp_badeval.i:4: Warning 202: Error: 'Expected an expression'
-
-:::::::::::::::::::::::::::::::: pp_constant.i :::::::::::::::::::::::::::::::::::
-pp_constant.i:9: Warning 305: Bad constant value (ignored).
-pp_constant.i:15: Warning 305: Bad constant value (ignored).
-pp_constant.i:23: Warning 305: Bad constant value (ignored).
-pp_constant.i:29: Warning 305: Bad constant value (ignored).
-pp_constant.i:35: Warning 305: Bad constant value (ignored).
-pp_constant.i:42: Warning 305: Bad constant value (ignored).
-pp_constant.i:46: Warning 305: Bad constant value (ignored).
-pp_constant.i:49: Warning 305: Bad constant value (ignored).
-
-:::::::::::::::::::::::::::::::: pp_defined.i :::::::::::::::::::::::::::::::::::
-pp_defined.i:6: Error: No arguments given to defined()
-pp_defined.i:6: Error: Missing expression for #if.
-
-:::::::::::::::::::::::::::::::: pp_deprecated.i :::::::::::::::::::::::::::::::::::
-pp_deprecated.i:4: Warning 101: %extern is deprecated. Use %import instead.
-pp_deprecated.i:4: Error: Unable to find 'ext;'
-pp_deprecated.i:6: Warning 204: CPP #warning, "Print this warning".
-pp_deprecated.i:8: Error: CPP #error "This is an error". Use the -cpperraswarn option to continue swig processing.
-
-:::::::::::::::::::::::::::::::: pp_illegal_argument.i :::::::::::::::::::::::::::::::::::
-pp_illegal_argument.i:6: Error: Illegal macro argument name '..'
-pp_illegal_argument.i:10: Error: Illegal macro argument name '..'
-pp_illegal_argument.i:16: Error: Illegal character in macro argument name
-
-:::::::::::::::::::::::::::::::: pp_macro_args.i :::::::::::::::::::::::::::::::::::
-
-:::::::::::::::::::::::::::::::: pp_macro_badchar.i :::::::::::::::::::::::::::::::::::
-pp_macro_badchar.i:4: Error: Illegal character in macro argument name
-
-:::::::::::::::::::::::::::::::: pp_macro_defined_unterminated.i :::::::::::::::::::::::::::::::::::
-pp_macro_defined_unterminated.i:4: Error: Unterminated call to 'defined'
-
-:::::::::::::::::::::::::::::::: pp_macro_expansion.i :::::::::::::::::::::::::::::::::::
-pp_macro_expansion.i:9: Error: Macro 'MACRO2' expects 2 arguments
-
-:::::::::::::::::::::::::::::::: pp_macro_expansion_multiline.i :::::::::::::::::::::::::::::::::::
-pp_macro_expansion_multiline.i:13: Warning 509: Overloaded method foo(int const *) effectively ignored,
-pp_macro_expansion_multiline.i:12: Warning 509: as it is shadowed by foo(int *).
-pp_macro_expansion_multiline.i:31: Warning 509: Overloaded method bar(int const *) effectively ignored,
-pp_macro_expansion_multiline.i:30: Warning 509: as it is shadowed by bar(int *).
-
-:::::::::::::::::::::::::::::::: pp_macro_inline_unterminated.i :::::::::::::::::::::::::::::::::::
-pp_macro_inline_unterminated.i:9: Error: Unterminated call invoking macro 'foo'
-pp_macro_inline_unterminated.i:12: Error: Syntax error in input(3).
-
-:::::::::::::::::::::::::::::::: pp_macro_missing_expression.i :::::::::::::::::::::::::::::::::::
-pp_macro_missing_expression.i:4: Error: Missing identifier for #ifdef.
-pp_macro_missing_expression.i:7: Error: Missing identifier for #ifndef.
-pp_macro_missing_expression.i:10: Error: Missing expression for #if.
-pp_macro_missing_expression.i:14: Error: Missing expression for #elif.
-pp_macro_missing_expression.i:21: Error: Missing expression for #elif.
-
-:::::::::::::::::::::::::::::::: pp_macro_unexpected_tokens.i :::::::::::::::::::::::::::::::::::
-pp_macro_unexpected_tokens.i:5: Warning 206: Unexpected tokens after #endif directive.
-pp_macro_unexpected_tokens.i:8: Warning 206: Unexpected tokens after #endif directive.
-pp_macro_unexpected_tokens.i:11: Warning 206: Unexpected tokens after #else directive.
-pp_macro_unexpected_tokens.i:18: Warning 206: Unexpected tokens after #endif directive.
-pp_macro_unexpected_tokens.i:21: Warning 206: Unexpected tokens after #else directive.
-
-:::::::::::::::::::::::::::::::: pp_macro_nargs.i :::::::::::::::::::::::::::::::::::
-pp_macro_nargs.i:7: Error: Macro 'foo' expects 2 arguments
-pp_macro_nargs.i:8: Error: Macro 'foo' expects 2 arguments
-pp_macro_nargs.i:10: Error: Macro 'bar' expects 1 argument
-pp_macro_nargs.i:11: Error: Macro 'spam' expects no arguments
-
-:::::::::::::::::::::::::::::::: pp_macro_redef.i :::::::::::::::::::::::::::::::::::
-pp_macro_redef.i:4: Error: Macro 'foo' redefined,
-pp_macro_redef.i:3: Error: previous definition of 'foo'.
-pp_macro_redef.i:7: Error: Macro 'foo' redefined,
-pp_macro_redef.i:3: Error: previous definition of 'foo'.
-
-:::::::::::::::::::::::::::::::: pp_macro_rparen.i :::::::::::::::::::::::::::::::::::
-pp_macro_rparen.i:3: Error: Missing ')' in macro parameters
-
-:::::::::::::::::::::::::::::::: pp_macro_unterminated.i :::::::::::::::::::::::::::::::::::
-pp_macro_unterminated.i:5: Error: Unterminated call invoking macro 'foo'
-
-:::::::::::::::::::::::::::::::: pp_misplaced_elif.i :::::::::::::::::::::::::::::::::::
-pp_misplaced_elif.i:4: Error: Misplaced #elif.
-pp_misplaced_elif.i:6: Error: Extraneous #endif.
-
-:::::::::::::::::::::::::::::::: pp_misplaced_else.i :::::::::::::::::::::::::::::::::::
-pp_misplaced_else.i:4: Error: Misplaced #else.
-pp_misplaced_else.i:6: Error: Extraneous #endif.
-
-:::::::::::::::::::::::::::::::: pp_missing_enddef.i :::::::::::::::::::::::::::::::::::
-pp_missing_enddef.i:EOF: Error: Missing %enddef for macro starting on line 3
-
-:::::::::::::::::::::::::::::::: pp_missing_endif.i :::::::::::::::::::::::::::::::::::
-pp_missing_endif.i:EOF: Error: Missing #endif for conditional starting on line 3
-
-:::::::::::::::::::::::::::::::: pp_missing_file.i :::::::::::::::::::::::::::::::::::
-pp_missing_file.i:3: Error: Unable to find 'missing_filename.i'
-
-:::::::::::::::::::::::::::::::: pp_missing_rblock.i :::::::::::::::::::::::::::::::::::
-pp_missing_rblock.i:EOF: Error: Unterminated %{ ... %} block starting on line 3
-
-:::::::::::::::::::::::::::::::: pp_pragma.i :::::::::::::::::::::::::::::::::::
-pp_pragma.i:4: Error: Unknown SWIG pragma: rubbish()
-
-:::::::::::::::::::::::::::::::: pp_unterm_char.i :::::::::::::::::::::::::::::::::::
-pp_unterm_char.i:EOF: Error: Unterminated character constant starting at line 4
-
-:::::::::::::::::::::::::::::::: pp_unterm_comment.i :::::::::::::::::::::::::::::::::::
-pp_unterm_comment.i:EOF: Error: Unterminated comment starting on line 3
-
-:::::::::::::::::::::::::::::::: pp_unterm_string.i :::::::::::::::::::::::::::::::::::
-pp_unterm_string.i:EOF: Error: Unterminated string constant starting at line 4
-
-:::::::::::::::::::::::::::::::: pp_variable_args.i :::::::::::::::::::::::::::::::::::
-pp_variable_args.i:6: Error: Variable length macro argument must be last parameter
-
-:::::::::::::::::::::::::::::::: swig_apply_nargs.i :::::::::::::::::::::::::::::::::::
-swig_apply_nargs.i:6: Error: Can't apply (char *str,int len) to (int x). Number of arguments don't match.
-
-:::::::::::::::::::::::::::::::: swig_extend.i :::::::::::::::::::::::::::::::::::
-swig_extend.i:19: Warning 326: Deprecated %extend name used - the struct name 'StructBName' should be used instead of the typedef name 'StructB'.
-swig_extend.i:45: Warning 326: Deprecated %extend name used - the struct name 'stru_struct' should be used instead of the typedef name 'stru'.
-swig_extend.i:56: Warning 326: Deprecated %extend name used - the union name 'uni_union' should be used instead of the typedef name 'uni'.
-swig_extend.i:34: Warning 303: %extend defined for an undeclared class StructDName.
-swig_extend.i:50: Warning 522: Use of an illegal constructor name 'stru' in %extend is deprecated, the constructor name should be 'stru_struct'.
-swig_extend.i:53: Warning 523: Use of an illegal destructor name 'stru' in %extend is deprecated, the destructor name should be 'stru_struct'.
-swig_extend.i:57: Warning 522: Use of an illegal constructor name 'uni' in %extend is deprecated, the constructor name should be 'uni_union'.
-swig_extend.i:58: Warning 523: Use of an illegal destructor name 'uni' in %extend is deprecated, the destructor name should be 'uni_union'.
-
-:::::::::::::::::::::::::::::::: swig_identifier.i :::::::::::::::::::::::::::::::::::
-swig_identifier.i:5: Warning 503: Can't wrap 'foo bar' unless renamed to a valid identifier.
-
-:::::::::::::::::::::::::::::::: swig_insert_bad.i :::::::::::::::::::::::::::::::::::
-swig_insert_bad.i:5: Error: Unknown target 'foobar' for %insert directive.
-
-:::::::::::::::::::::::::::::::: swig_typemap_copy.i :::::::::::::::::::::::::::::::::::
-swig_typemap_copy.i:3: Error: Can't copy typemap (in) blah = int
-
-:::::::::::::::::::::::::::::::: swig_typemap_old.i :::::::::::::::::::::::::::::::::::
-swig_typemap_old.i:6: Warning 450: Deprecated typemap feature ($source/$target).
-swig_typemap_old.i:6: Warning 450: The use of $source and $target in a typemap declaration is deprecated.
-For typemaps related to argument input (in,ignore,default,arginit,check), replace
-$source by $input and $target by $1. For typemaps related to return values (out,
-argout,ret,except), replace $source by $1 and $target by $result. See the file
-Doc/Manual/Typemaps.html for complete details.
-
-:::::::::::::::::::::::::::::::: swig_typemap_warn.i :::::::::::::::::::::::::::::::::::
-swig_typemap_warn.i:7: Warning 1000: Test warning for 'in' typemap for int abc (arg1) - argnum: 1 &1_ltype: int * descriptor: SWIGTYPE_int
-swig_typemap_warn.i:7: Warning 1000: Test warning for 'in' typemap for int arg3 (arg3) - argnum: 3 &1_ltype: int * descriptor: SWIGTYPE_int
-swig_typemap_warn.i:7: Warning 1001: Test warning for 'out' typemap for double mmm (result) - name: mmm symname: mmm &1_ltype: double * descriptor: SWIGTYPE_double
-swig_typemap_warn.i:7: Warning 1000: Test warning for 'in' typemap for int abc (arg1) - argnum: 1 &1_ltype: int * descriptor: SWIGTYPE_int
-swig_typemap_warn.i:7: Warning 1000: Test warning for 'in' typemap for int arg3 (arg3) - argnum: 3 &1_ltype: int * descriptor: SWIGTYPE_int
-swig_typemap_warn.i:7: Warning 1000: Test warning for 'in' typemap for int abc (arg1) - argnum: 1 &1_ltype: int * descriptor: SWIGTYPE_int
-swig_typemap_warn.i:7: Warning 1000: Test warning for 'in' typemap for int arg3 (arg3) - argnum: 3 &1_ltype: int * descriptor: SWIGTYPE_int
-
-:::::::::::::::::::::::::::::::: cpp_bad_extern.i :::::::::::::::::::::::::::::::::::
-cpp_bad_extern.i:5: Warning 313: Unrecognized extern type "INTERCAL".
-cpp_bad_extern.i:7: Warning 313: Unrecognized extern type "INTERCAL".
-
-:::::::::::::::::::::::::::::::: cpp_extend_destructors.i :::::::::::::::::::::::::::::::::::
-cpp_extend_destructors.i:8: Warning 302: Identifier '~AStruct' redefined by %extend (ignored),
-cpp_extend_destructors.i:5: Warning 302: %extend definition of '~AStruct'.
-cpp_extend_destructors.i:14: Warning 302: Identifier '~BStruct' redefined (ignored),
-cpp_extend_destructors.i:13: Warning 302: previous definition of '~BStruct'.
-cpp_extend_destructors.i:87: Warning 302: Identifier '~JStruct' redefined (ignored),
-cpp_extend_destructors.i:85: Warning 302: previous definition of '~JStruct'.
-cpp_extend_destructors.i:100: Warning 302: Identifier '~LStruct' redefined (ignored),
-cpp_extend_destructors.i:98: Warning 302: previous definition of '~LStruct'.
-cpp_extend_destructors.i:24: Warning 521: Illegal destructor name CStruct::~NOT_CStruct(). Ignored.
-cpp_extend_destructors.i:30: Warning 521: Illegal destructor name DStruct::~NOT_DStruct(). Ignored.
-cpp_extend_destructors.i:44: Warning 521: Illegal destructor name EStruct::~NOT_EStruct(). Ignored.
-cpp_extend_destructors.i:50: Warning 521: Illegal destructor name FStruct::~NOT_FStruct(). Ignored.
-cpp_extend_destructors.i:65: Warning 521: Illegal destructor name GStruct::~NOT_GStruct(). Ignored.
-cpp_extend_destructors.i:72: Warning 521: Illegal destructor name HStruct::~NOT_HStruct(). Ignored.
-cpp_extend_destructors.i:81: Warning 521: Illegal destructor name IStruct::~NOT_IStruct(). Ignored.
-cpp_extend_destructors.i:86: Warning 521: Illegal destructor name JStruct::~NOT_JStruct(). Ignored.
-cpp_extend_destructors.i:92: Warning 521: Illegal destructor name KStruct::~NOT_KStruct(). Ignored.
-cpp_extend_destructors.i:99: Warning 521: Illegal destructor name LStruct< int >::~NOT_LStruct(). Ignored.
-cpp_extend_destructors.i:99: Warning 521: Illegal destructor name LStruct< short >::~NOT_LStruct(). Ignored.
-
-:::::::::::::::::::::::::::::::: cpp_extend_redefine.i :::::::::::::::::::::::::::::::::::
-cpp_extend_redefine.i:9: Warning 302: Identifier 'bar' redefined by %extend (ignored),
-cpp_extend_redefine.i:5: Warning 302: %extend definition of 'bar'.
-cpp_extend_redefine.i:14: Warning 322: Redundant redeclaration of 'spam',
-cpp_extend_redefine.i:10: Warning 322: previous declaration of 'spam'.
-
-:::::::::::::::::::::::::::::::: cpp_extend_undefined.i :::::::::::::::::::::::::::::::::::
-cpp_extend_undefined.i:6: Warning 303: %extend defined for an undeclared class foo.
-
-:::::::::::::::::::::::::::::::: cpp_inline_namespace.i :::::::::::::::::::::::::::::::::::
-cpp_inline_namespace.i:4: Error: %inline directive inside a namespace is disallowed.
-
-:::::::::::::::::::::::::::::::: cpp_inherit.i :::::::::::::::::::::::::::::::::::
-cpp_inherit.i:18: Warning 309: private inheritance from base 'A3' (ignored).
-cpp_inherit.i:20: Warning 309: private inheritance from base 'A4' (ignored).
-cpp_inherit.i:28: Warning 309: protected inheritance from base 'A8< double >' (ignored).
-cpp_inherit.i:39: Warning 319: No access specifier given for base class 'B1' (ignored).
-cpp_inherit.i:40: Warning 319: No access specifier given for base class 'B2< int >' (ignored).
-cpp_inherit.i:15: Warning 401: Base class 'A1' undefined.
-cpp_inherit.i:33: Warning 401: 'A1' must be defined before it is used as a base class.
-cpp_inherit.i:17: Warning 401: Nothing known about base class 'A2'. Ignored.
-cpp_inherit.i:22: Warning 402: Base class 'A5' is incomplete.
-cpp_inherit.i:4: Warning 402: Only forward declaration 'A5' was found.
-cpp_inherit.i:24: Error: 'A6' is not a valid base class.
-cpp_inherit.i:5: Error: See definition of 'A6'.
-cpp_inherit.i:24: Warning 401: Nothing known about base class 'A6'. Ignored.
-cpp_inherit.i:26: Warning 401: Nothing known about base class 'A7< int >'. Ignored.
-cpp_inherit.i:26: Warning 401: Maybe you forgot to instantiate 'A7< int >' using %template.
-cpp_inherit.i:45: Warning 323: Recursive scope inheritance of 'Recursive'.
-cpp_inherit.i:52: Warning 401: Base class 'Base< int >' has no name as it is an empty template instantiated with '%template()'. Ignored.
-cpp_inherit.i:51: Warning 401: The %template directive must be written before 'Base< int >' is used as a base class and be declared with a name.
-cpp_inherit.i:53: Warning 401: Base class 'Base< double >' undefined.
-cpp_inherit.i:54: Warning 401: 'Base< double >' must be defined before it is used as a base class.
-
-:::::::::::::::::::::::::::::::: cpp_macro_locator.i :::::::::::::::::::::::::::::::::::
-cpp_macro_locator.i:66: Warning 204: CPP #warning, "inline warning message one".
-cpp_macro_locator.i:96: Warning 204: CPP #warning, "an inline warning message 2".
-cpp_macro_locator.i:50: Warning 325: Nested struct not currently supported (Inner ignored)
-cpp_macro_locator.i:53: Warning 509: Overloaded method overload1(int const *) effectively ignored,
-cpp_macro_locator.i:52: Warning 509: as it is shadowed by overload1(int *).
-cpp_macro_locator.i:61: Warning 509: Overloaded method overload2(int const *) effectively ignored,
-cpp_macro_locator.i:60: Warning 509: as it is shadowed by overload2(int *).
-cpp_macro_locator.i:64: Warning 509: Overloaded method Klass1::methodX(int const *) effectively ignored,
-cpp_macro_locator.i:64: Warning 509: as it is shadowed by Klass1::methodX(int *).
-cpp_macro_locator.i:68: Warning 509: Overloaded method overload3(int const *) effectively ignored,
-cpp_macro_locator.i:67: Warning 509: as it is shadowed by overload3(int *).
-cpp_macro_locator.i:90: Warning 509: Overloaded method overload4(int const *) effectively ignored,
-cpp_macro_locator.i:89: Warning 509: as it is shadowed by overload4(int *).
-cpp_macro_locator.i:94: Warning 509: Overloaded method overloadinline1(int const *) effectively ignored,
-cpp_macro_locator.i:93: Warning 509: as it is shadowed by overloadinline1(int *).
-cpp_macro_locator.i:95: Warning 509: Overloaded method Klass2::methodX(int const *) effectively ignored,
-cpp_macro_locator.i:95: Warning 509: as it is shadowed by Klass2::methodX(int *).
-cpp_macro_locator.i:98: Warning 509: Overloaded method overloadinline2(int const *) effectively ignored,
-cpp_macro_locator.i:97: Warning 509: as it is shadowed by overloadinline2(int *).
-cpp_macro_locator.i:101: Warning 509: Overloaded method overload5(int const *) effectively ignored,
-cpp_macro_locator.i:100: Warning 509: as it is shadowed by overload5(int *).
-
-:::::::::::::::::::::::::::::::: cpp_missing_rparenthesis.i :::::::::::::::::::::::::::::::::::
-cpp_missing_rparenthesis.i:5: Error: Missing ')'. Reached end of input.
-cpp_missing_rparenthesis.i:5: Error: Syntax error in input(3).
-
-:::::::::::::::::::::::::::::::: cpp_missing_rtemplate.i :::::::::::::::::::::::::::::::::::
-cpp_missing_rtemplate.i:4: Error: Syntax error in input(1).
-
-:::::::::::::::::::::::::::::::: cpp_namespace_alias.i :::::::::::::::::::::::::::::::::::
-cpp_namespace_alias.i:8: Warning 308: Namespace alias 'B' not allowed here. Assuming 'blah'
-
-:::::::::::::::::::::::::::::::: cpp_namespace_aliasnot.i :::::::::::::::::::::::::::::::::::
-cpp_namespace_aliasnot.i:4: Error: 'blah' is not a namespace
-
-:::::::::::::::::::::::::::::::: cpp_namespace_aliasundef.i :::::::::::::::::::::::::::::::::::
-cpp_namespace_aliasundef.i:3: Error: Unknown namespace 'blah'
-
-:::::::::::::::::::::::::::::::: cpp_nested.i :::::::::::::::::::::::::::::::::::
-cpp_nested.i:6: Warning 325: Nested class not currently supported (Bar ignored)
-cpp_nested.i:12: Warning 325: Nested class not currently supported (Grok ignored)
-
-:::::::::::::::::::::::::::::::: cpp_no_access.i :::::::::::::::::::::::::::::::::::
-cpp_no_access.i:3: Warning 319: No access specifier given for base class 'foo' (ignored).
-
-:::::::::::::::::::::::::::::::: cpp_no_return_type.i :::::::::::::::::::::::::::::::::::
-cpp_no_return_type.i:6: Warning 504: Function S::R() must have a return type. Ignored.
-cpp_no_return_type.i:10: Warning 504: Function U::UU() must have a return type. Ignored.
-
-:::::::::::::::::::::::::::::::: cpp_nobase.i :::::::::::::::::::::::::::::::::::
-cpp_nobase.i:3: Warning 401: Nothing known about base class 'Bar'. Ignored.
-cpp_nobase.i:6: Warning 401: Nothing known about base class 'Bar< int >'. Ignored.
-cpp_nobase.i:6: Warning 401: Maybe you forgot to instantiate 'Bar< int >' using %template.
-
-:::::::::::::::::::::::::::::::: cpp_overload.i :::::::::::::::::::::::::::::::::::
-
-:::::::::::::::::::::::::::::::: cpp_overload_const.i :::::::::::::::::::::::::::::::::::
-cpp_overload_const.i:4: Warning 509: Overloaded method check(int *) effectively ignored,
-cpp_overload_const.i:3: Warning 509: as it is shadowed by check(int const *).
-cpp_overload_const.i:5: Warning 509: Overloaded method check(int &) effectively ignored,
-cpp_overload_const.i:3: Warning 509: as it is shadowed by check(int const *).
-cpp_overload_const.i:10: Warning 509: Overloaded method check(OverStruct *) effectively ignored,
-cpp_overload_const.i:9: Warning 509: as it is shadowed by check(OverStruct const *).
-cpp_overload_const.i:11: Warning 509: Overloaded method check(OverStruct &) effectively ignored,
-cpp_overload_const.i:9: Warning 509: as it is shadowed by check(OverStruct const *).
-cpp_overload_const.i:12: Warning 509: Overloaded method check(OverStruct const &) effectively ignored,
-cpp_overload_const.i:9: Warning 509: as it is shadowed by check(OverStruct const *).
-
-:::::::::::::::::::::::::::::::: cpp_private_defvalue.i :::::::::::::::::::::::::::::::::::
-
-:::::::::::::::::::::::::::::::: cpp_private_inherit.i :::::::::::::::::::::::::::::::::::
-cpp_private_inherit.i:6: Warning 309: private inheritance from base 'Foo' (ignored).
-cpp_private_inherit.i:9: Warning 309: protected inheritance from base 'Foo' (ignored).
-
-:::::::::::::::::::::::::::::::: cpp_recursive_typedef.i :::::::::::::::::::::::::::::::::::
-:1: Error: Recursive typedef detected resolving 'pds *' to 'std::set< pds > *' to 'std::set< std::set< pds > > *' and so on...
-
-:::::::::::::::::::::::::::::::: cpp_shared_ptr.i :::::::::::::::::::::::::::::::::::
-cpp_shared_ptr.i:20: Warning 520: Base class 'A' of 'C' is not similarly marked as a smart pointer.
-cpp_shared_ptr.i:24: Warning 520: Derived class 'D' of 'C' is not similarly marked as a smart pointer.
-cpp_shared_ptr.i:24: Warning 520: Derived class 'D' of 'B' is not similarly marked as a smart pointer.
-
-:::::::::::::::::::::::::::::::: cpp_template_argname.i :::::::::::::::::::::::::::::::::::
-
-:::::::::::::::::::::::::::::::: cpp_template_nargs.i :::::::::::::::::::::::::::::::::::
-cpp_template_nargs.i:5: Error: Template 'blah' undefined.
-cpp_template_nargs.i:6: Error: Template 'blah' undefined.
-
-:::::::::::::::::::::::::::::::: cpp_template_not.i :::::::::::::::::::::::::::::::::::
-cpp_template_not.i:5: Error: 'blah' is not defined as a template. (cdecl)
-
-:::::::::::::::::::::::::::::::: cpp_template_partial.i :::::::::::::::::::::::::::::::::::
-cpp_template_partial.i:3: Warning 317: Specialization of non-template 'vector'.
-
-:::::::::::::::::::::::::::::::: cpp_template_repeat.i :::::::::::::::::::::::::::::::::::
-
-:::::::::::::::::::::::::::::::: cpp_template_undef.i :::::::::::::::::::::::::::::::::::
-cpp_template_undef.i:3: Error: Template 'blah' undefined.
-
-:::::::::::::::::::::::::::::::: cpp_using_not.i :::::::::::::::::::::::::::::::::::
-cpp_using_not.i:4: Error: 'blah' is not a namespace.
-
-:::::::::::::::::::::::::::::::: cpp_using_undef.i :::::::::::::::::::::::::::::::::::
-cpp_using_undef.i:4: Error: Nothing known about namespace 'foo'
-cpp_using_undef.i:3: Warning 315: Nothing known about 'foo::bar'.
+++ /dev/null
-#!/bin/sh
-echo "---------------------------------------"
-echo "Testing SWIG error and warning messages"
-echo "---------------------------------------"
-
-SWIG='../../../preinst-swig'
-
-# Files run in C mode
-CFILES='
-c_bad_name
-c_bad_native
-c_class
-c_default_error
-c_deprecated
-c_empty_char
-c_enum_badvalue
-c_extra_rblock
-c_extra_rbrace
-c_extra_unsigned
-c_insert_missing
-c_long_short
-c_missing_rbrace
-c_missing_semi
-c_redefine
-c_varargs
-c_varargs_neg
-nomodule
-pp_badeval
-pp_constant
-pp_defined
-pp_deprecated
-pp_illegal_argument
-pp_macro_args
-pp_macro_badchar
-pp_macro_defined_unterminated
-pp_macro_expansion
-pp_macro_expansion_multiline
-pp_macro_inline_unterminated
-pp_macro_missing_expression
-pp_macro_unexpected_tokens
-pp_macro_nargs
-pp_macro_redef
-pp_macro_rparen
-pp_macro_unterminated
-pp_misplaced_elif
-pp_misplaced_else
-pp_missing_enddef
-pp_missing_endif
-pp_missing_file
-pp_missing_rblock
-pp_pragma
-pp_unterm_char
-pp_unterm_comment
-pp_unterm_string
-pp_variable_args
-swig_apply_nargs
-swig_extend
-swig_identifier
-swig_insert_bad
-swig_typemap_copy
-swig_typemap_old
-swig_typemap_warn
-'
-
-# Files run in C++ mode
-CPPFILES='
-cpp_bad_extern
-cpp_extend_destructors
-cpp_extend_redefine
-cpp_extend_undefined
-cpp_inline_namespace
-cpp_inherit
-cpp_macro_locator
-cpp_missing_rparenthesis
-cpp_missing_rtemplate
-cpp_namespace_alias
-cpp_namespace_aliasnot
-cpp_namespace_aliasundef
-cpp_nested
-cpp_no_access
-cpp_no_return_type
-cpp_nobase
-cpp_overload
-cpp_overload_const
-cpp_private_defvalue
-cpp_private_inherit
-cpp_recursive_typedef
-cpp_shared_ptr
-cpp_template_argname
-cpp_template_nargs
-cpp_template_not
-cpp_template_partial
-cpp_template_repeat
-cpp_template_undef
-cpp_using_not
-cpp_using_undef
-'
-
-LOGFILE='test.log'
-SWIGOPT=$*
-
-rm -f ${LOGFILE}
-
-echo "SWIG error and warning test. opts=${SWIGOPT}" >> ${LOGFILE}
-echo "-----------------------------------------------------------" >> ${LOGFILE}
-
-for i in ${CFILES}; do
- echo " Testing : ${i}.i";
- echo "" >> ${LOGFILE};
- echo ":::::::::::::::::::::::::::::::: ${i}.i :::::::::::::::::::::::::::::::::::" >> ${LOGFILE};
- ${SWIG} -python -Wall ${SWIGOPT} ${i}.i >>${LOGFILE} 2>&1
-done
-
-for i in ${CPPFILES}; do
- echo " Testing : ${i}.i";
- echo "" >> ${LOGFILE}
- echo ":::::::::::::::::::::::::::::::: ${i}.i :::::::::::::::::::::::::::::::::::" >> ${LOGFILE};
- ${SWIG} -python -Wall -c++ ${SWIGOPT} ${i}.i >>${LOGFILE} 2>&1
-done
-
-echo ""
-echo "Results written to '${LOGFILE}'"
-
-
--- /dev/null
+No module name specified using %module or -module.
--- /dev/null
+pp_badeval.i:4: Warning 202: Could not evaluate expression 'FOO==4+'
+pp_badeval.i:4: Warning 202: Error: 'Expected an expression'
%constant int ddd=;
#define E1 1234
-#/*C comment*/define E2 1234
+// This case doesn't actually work, but appeared to before we gave an error
+// for unknown preprocessor directives.
+// #/*C comment*/define E2 1234
#define E3 1234
%constant int eee=;
--- /dev/null
+pp_constant.i:9: Warning 305: Bad constant value (ignored).
+pp_constant.i:15: Warning 305: Bad constant value (ignored).
+pp_constant.i:23: Warning 305: Bad constant value (ignored).
+pp_constant.i:29: Warning 305: Bad constant value (ignored).
+pp_constant.i:37: Warning 305: Bad constant value (ignored).
+pp_constant.i:44: Warning 305: Bad constant value (ignored).
+pp_constant.i:48: Warning 305: Bad constant value (ignored).
+pp_constant.i:51: Warning 305: Bad constant value (ignored).
--- /dev/null
+pp_defined.i:6: Error: No arguments given to defined()
+pp_defined.i:6: Error: Missing expression for #if.
--- /dev/null
+pp_deprecated.i:4: Warning 101: %extern is deprecated. Use %import instead.
+pp_deprecated.i:4: Error: Unable to find 'ext;'
+pp_deprecated.i:6: Warning 204: CPP #warning, "Print this warning".
+pp_deprecated.i:8: Error: CPP #error "This is an error". Use the -cpperraswarn option to continue swig processing.
--- /dev/null
+pp_illegal_argument.i:6: Error: Illegal macro argument name '..'
+pp_illegal_argument.i:10: Error: Illegal macro argument name '..'
+pp_illegal_argument.i:16: Error: Illegal character in macro argument name
+++ /dev/null
-%module xxx
-
-#define foo(a,x) a x
-
-#if foo
-#endif
-
--- /dev/null
+pp_macro_badchar.i:4: Error: Illegal character in macro argument name
--- /dev/null
+pp_macro_defined_unterminated.i:4: Error: Unterminated call to 'defined'
--- /dev/null
+pp_macro_expansion.i:9: Error: Macro 'MACRO2' expects 2 arguments
--- /dev/null
+pp_macro_expansion_multiline.i:13: Warning 509: Overloaded method foo(int const *) effectively ignored,
+pp_macro_expansion_multiline.i:12: Warning 509: as it is shadowed by foo(int *).
+pp_macro_expansion_multiline.i:31: Warning 509: Overloaded method bar(int const *) effectively ignored,
+pp_macro_expansion_multiline.i:30: Warning 509: as it is shadowed by bar(int *).
--- /dev/null
+pp_macro_inline_unterminated.i:9: Error: Unterminated call invoking macro 'foo'
+pp_macro_inline_unterminated.i:12: Error: Syntax error in input(3).
--- /dev/null
+pp_macro_missing_expression.i:4: Error: Missing identifier for #ifdef.
+pp_macro_missing_expression.i:7: Error: Missing identifier for #ifndef.
+pp_macro_missing_expression.i:10: Error: Missing expression for #if.
+pp_macro_missing_expression.i:14: Error: Missing expression for #elif.
+pp_macro_missing_expression.i:21: Error: Missing expression for #elif.
--- /dev/null
+pp_macro_nargs.i:7: Error: Macro 'foo' expects 2 arguments
+pp_macro_nargs.i:8: Error: Macro 'foo' expects 2 arguments
+pp_macro_nargs.i:10: Error: Macro 'bar' expects 1 argument
+pp_macro_nargs.i:11: Error: Macro 'spam' expects no arguments
--- /dev/null
+pp_macro_redef.i:4: Error: Macro 'foo' redefined,
+pp_macro_redef.i:3: Error: previous definition of 'foo'.
+pp_macro_redef.i:7: Error: Macro 'foo' redefined,
+pp_macro_redef.i:3: Error: previous definition of 'foo'.
--- /dev/null
+pp_macro_rparen.i:3: Error: Missing ')' in macro parameters
--- /dev/null
+pp_macro_unexpected_tokens.i:5: Warning 206: Unexpected tokens after #endif directive.
+pp_macro_unexpected_tokens.i:8: Warning 206: Unexpected tokens after #endif directive.
+pp_macro_unexpected_tokens.i:11: Warning 206: Unexpected tokens after #else directive.
+pp_macro_unexpected_tokens.i:18: Warning 206: Unexpected tokens after #endif directive.
+pp_macro_unexpected_tokens.i:21: Warning 206: Unexpected tokens after #else directive.
--- /dev/null
+pp_macro_unterminated.i:5: Error: Unterminated call invoking macro 'foo'
--- /dev/null
+pp_misplaced_elif.i:4: Error: Misplaced #elif.
+pp_misplaced_elif.i:6: Error: Extraneous #endif.
--- /dev/null
+pp_misplaced_else.i:4: Error: Misplaced #else.
+pp_misplaced_else.i:6: Error: Extraneous #endif.
--- /dev/null
+pp_missing_enddef.i:3: Error: Missing %enddef for macro starting here
--- /dev/null
+pp_missing_endif.i:3: Error: Missing #endif for conditional starting here
--- /dev/null
+%module xxx
+/* %beginfile and %endoffile are internal directives inserted when %include is
+ * used. Users should never use them directly, but test coverage for this
+ * error message still seems useful to have.
+ */
+%includefile "dummy.i" %beginfile
+
--- /dev/null
+pp_missing_endoffile.i:6: Error: Missing %endoffile for file inclusion block starting here
--- /dev/null
+pp_missing_file.i:3: Error: Unable to find 'missing_filename.i'
--- /dev/null
+pp_missing_rblock.i:3: Error: Unterminated %{ ... %} block
--- /dev/null
+pp_pragma.i:4: Error: Unknown SWIG pragma: rubbish()
--- /dev/null
+%module xxx
+
+/* Regression test for bug introduced in 3.0.4 and fixed in 3.0.6 - the '%std'
+ * here led to SWIG calling abort().
+ */
+%typemap(jstype) std::vector<std::string>, const %std::vector<std::string>&, std::vector<std::string>& "List<String>"
+
+/* This used to give the rather cryptic "Syntax error in input(1)." prior to
+ * SWIG 3.0.4. This testcase checks that the improved message is actually
+ * issued.
+ */
+%remane("typo") tyop;
--- /dev/null
+pp_unknowndirective.i:12: Error: Unknown directive '%remane'.
--- /dev/null
+%module xxx
+
+#ifndef FOO
+long long i;
+/* Check we get an error for an unknown directive (this should be #elif).
+ * Unknown directives were silently ignored by SWIG < 3.0.3. */
+#elsif defined(BAR)
+long i;
+#else
+int i;
+#endif
--- /dev/null
+pp_unknowndirective2.i:7: Error: Unknown SWIG preprocessor directive: elsif (if this is a block of target language code, delimit it with %{ and %})
--- /dev/null
+pp_unterm_char.i:4: Error: Unterminated character constant
--- /dev/null
+pp_unterm_comment.i:3: Error: Unterminated comment
--- /dev/null
+pp_unterm_string.i:4: Error: Unterminated string constant
--- /dev/null
+%module xxx
+
+%{
+int foo(int x);
+
--- /dev/null
+pp_unterminated_block.i:3: Error: Unterminated %{ ... %} block
--- /dev/null
+pp_variable_args.i:6: Error: Variable length macro argument must be last parameter
--- /dev/null
+swig_apply_nargs.i:6: Error: Can't apply (char *str,int len) to (int x). Number of arguments don't match.
--- /dev/null
+swig_extend.i:19: Warning 326: Deprecated %extend name used - the struct name 'StructBName' should be used instead of the typedef name 'StructB'.
+swig_extend.i:45: Warning 326: Deprecated %extend name used - the struct name 'stru_struct' should be used instead of the typedef name 'stru'.
+swig_extend.i:56: Warning 326: Deprecated %extend name used - the union name 'uni_union' should be used instead of the typedef name 'uni'.
+swig_extend.i:34: Warning 303: %extend defined for an undeclared class StructDName.
+swig_extend.i:50: Warning 522: Use of an illegal constructor name 'stru' in %extend is deprecated, the constructor name should be 'stru_struct'.
+swig_extend.i:53: Warning 523: Use of an illegal destructor name 'stru' in %extend is deprecated, the destructor name should be 'stru_struct'.
+swig_extend.i:57: Warning 522: Use of an illegal constructor name 'uni' in %extend is deprecated, the constructor name should be 'uni_union'.
+swig_extend.i:58: Warning 523: Use of an illegal destructor name 'uni' in %extend is deprecated, the destructor name should be 'uni_union'.
--- /dev/null
+%module xxx
+
+%fragment("awol");
+
--- /dev/null
+swig_fragment_missing.i:3: Warning 490: Fragment 'awol' not found.
--- /dev/null
+swig_identifier.i:5: Warning 503: Can't wrap 'foo bar' unless renamed to a valid identifier.
--- /dev/null
+swig_insert_bad.i:5: Error: Unknown target 'foobar' for %insert directive.
--- /dev/null
+%module xxx
+
+%pythoncode %{
+ def foo():
+ a = 1 # This line starts with a tab instead of 8 spaces.
+ return 2
+%}
--- /dev/null
+swig_pythoncode_bad.i:7: Error: Line indented less than expected (line 2 of %pythoncode or %insert("python") block) as no line should be indented less than the indentation in line 1
--- /dev/null
+%module xxx
+
+%pythoncode %{
+ def one():
+ print "in one"
+%}
+
+%pythoncode %{
+ print "still in one"
+
+ def two():
+ print "in two"
+%}
--- /dev/null
+swig_pythoncode_bad2.i:13: Error: Line indented less than expected (line 3 of %pythoncode or %insert("python") block) as no line should be indented less than the indentation in line 1
--- /dev/null
+%module xxx
+
+%pythoncode %{
+ def extra():
+ print "extra a" # indentation is 2 spaces then tab
+ print "extra b" # indentation is tab then 2 spaces
+%}
--- /dev/null
+swig_pythoncode_bad3.i:7: Warning 740: Whitespace indentation is inconsistent compared to earlier lines (line 3 of %pythoncode or %insert("python") block)
--- /dev/null
+swig_typemap_copy.i:3: Error: Can't copy typemap (in) blah = int
--- /dev/null
+swig_typemap_old.i:6: Warning 450: Deprecated typemap feature ($source/$target).
+swig_typemap_old.i:6: Warning 450: The use of $source and $target in a typemap declaration is deprecated.
+For typemaps related to argument input (in,ignore,default,arginit,check), replace
+$source by $input and $target by $1. For typemaps related to return values (out,
+argout,ret,except), replace $source by $1 and $target by $result. See the file
+Doc/Manual/Typemaps.html for complete details.
--- /dev/null
+swig_typemap_warn.i:7: Warning 1000: Test warning for 'in' typemap for int abc (arg1) - argnum: 1 &1_ltype: int * descriptor: SWIGTYPE_int
+swig_typemap_warn.i:7: Warning 1000: Test warning for 'in' typemap for int arg3 (arg3) - argnum: 3 &1_ltype: int * descriptor: SWIGTYPE_int
+swig_typemap_warn.i:7: Warning 1001: Test warning for 'out' typemap for double mmm (result) - name: mmm symname: mmm &1_ltype: double * descriptor: SWIGTYPE_double
+swig_typemap_warn.i:7: Warning 1000: Test warning for 'in' typemap for int abc (arg1) - argnum: 1 &1_ltype: int * descriptor: SWIGTYPE_int
+swig_typemap_warn.i:7: Warning 1000: Test warning for 'in' typemap for int arg3 (arg3) - argnum: 3 &1_ltype: int * descriptor: SWIGTYPE_int
+swig_typemap_warn.i:7: Warning 1000: Test warning for 'in' typemap for int abc (arg1) - argnum: 1 &1_ltype: int * descriptor: SWIGTYPE_int
+swig_typemap_warn.i:7: Warning 1000: Test warning for 'in' typemap for int arg3 (arg3) - argnum: 3 &1_ltype: int * descriptor: SWIGTYPE_int
--- /dev/null
+%module exception_classname
+
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME);
+#ifdef SWIGPHP
+%rename(ExceptionClass) Exception;
+#endif
+
+%inline %{
+class Exception {
+public:
+ int testfunc() { return 42; }
+};
+%}
}
};
int A::sfoovar = 1;
+
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
+
%}
%template(ET_i) ET<int>;
%module exception_partial_info
-// This produced compileable code for Tcl, Python in 1.3.27, fails in 1.3.29
+// This produced compilable code for Tcl, Python in 1.3.27, fails in 1.3.29
%{
#if defined(_MSC_VER)
virtual int method(int v) {
return v;
}
+#if !defined(SWIG)
+ virtual ~Base() {}
+#endif
};
struct Derived : Base {
double actualval;
// %extend overrides the class definition
%extend Override {
int over(int a) { return a*a; } // SWIG should give a warning then choose this one over the real one
- int overload(int a) { return a*a; } // Similarly, but this one generated uncompileable code in SWIG-1.3.22
+ int overload(int a) { return a*a; } // Similarly, but this one generated uncompilable code in SWIG-1.3.22
}
%inline %{
struct Override {
struct ForExtension {
};
%}
+
+%inline %{
+namespace Space {
+ template <class T> class ExtendTemplate {};
+}
+%}
+
+%extend Space::ExtendTemplate
+{
+ void extending() {
+ $parentclassname tmp;
+ (void)tmp;
+ }
+}
+
+%template(ExtendTemplateInt) Space::ExtendTemplate<int>;
void RealFunction(int value) {}
%}
+
+%inline %{
+extern "C" {
+ typedef void (*Hook1_t)(int, const char *);
+}
+extern "C" typedef void (*Hook2_t)(int, const char *);
+void funcy1(Hook1_t) {}
+void funcy2(Hook2_t) {}
+Hook1_t hook1;
+Hook2_t hook2;
+
+extern "C" typedef int Integer;
+Integer int1;
+%}
+
--- /dev/null
+%module friends_template
+
+%{
+template <typename Type> class MyClass;
+
+template <typename Type> int operator<<(double un, const MyClass <Type> & x) { return 0; }
+template <typename Type> int funk_hidden(double is, MyClass <Type> & x) { return 2; }
+
+template <typename T> T template_friend_hidden(T t) { return t + 1; }
+%}
+
+%inline %{
+template <typename Type> int operator>>(double is, MyClass <Type> & x) { return 1; }
+template <typename Type> int funk_seen(double is, MyClass <Type> & x) { return 2; }
+template <typename T> T template_friend_seen(T t1, T t2) { return t1 + t2; }
+int friend_plain_seen(int i) { return i; }
+
+template <class Type> class MyClass
+{
+ friend int operator<< <Type>(double un, const MyClass <Type> & x);
+ friend int operator>> <Type>(double is, MyClass <Type> & x);
+ friend int funk_hidden <Type>(double is, MyClass <Type> & x);
+ friend int funk_seen <Type>(double is, MyClass <Type> & x);
+};
+
+struct MyTemplate {
+ template <typename T> friend T template_friend_hidden(T);
+ template <typename T> friend T template_friend_seen(T, T);
+ friend int friend_plain_seen(int i);
+};
+
+MyClass<int> makeMyClassInt() { return MyClass<int>(); }
+%}
+
+// Although the friends in MyClass are automatically instantiated via %template(MyClassDouble) MyClass<int>,
+// the operator friends are not valid and hence %rename is needed.
+%rename(OperatorInputDouble) operator>> <double>;
+%rename(OperatorOutputDouble) operator<< <double>;
+%template(MyClassDouble) MyClass<double>;
+
+%template(TemplateFriendHiddenInt) template_friend_hidden<int>;
+%template(TemplateFriendSeenInt) template_friend_seen<int>;
+
+// These have no %template(XX) MyClass<int> to instantiate, but they can be instantiated separately...
+%template(OperatorInputInt) operator>> <int>;
+%template(OperatorFunkSeenInt) funk_seen <int>;
%constant int (*ADD_BY_VALUE)(const int &, int) = addByValue;
%constant int * (*ADD_BY_POINTER)(const int &, int) = addByPointer;
%constant int & (*ADD_BY_REFERENCE)(const int &, int) = addByReference;
-
+%constant int (* const ADD_BY_VALUE_C)(const int &, int) = addByValue;
%inline %{
typedef int AddByValueTypedef(const int &a, int b);
--- /dev/null
+%module global_functions
+
+%inline %{
+void global_void(void) {}
+int global_one(int i) { return i; }
+int global_two(int i, int j) { return i+j; }
+%}
+
Hello h;
Hello *hp;
Hello &hr = h;
+
+ void init() {
+ b = "string b";
+ x = 1234;
+ }
%}
LANGUAGE = go
GO = @GO@
GOGCC = @GOGCC@
+GCCGO = @GCCGO@
GO1 = @GO1@
+GO12 = @GO12@
+GO13 = @GO13@
+GO15 = @GO15@
GOC = @GOC@
+GOVERSIONOPTION = @GOVERSIONOPTION@
+host = @host@
SCRIPTSUFFIX = _runme.go
-GOCOMPILEARG = `if $(GOGCC) ; then echo -c -g; elif $(GO1) ; then echo tool $(GOC:c=g) ; fi`
-GOLD = $(GOC:c=l)
+GOCOMPILEARG = `if $(GO15); then echo tool compile; elif $(GO1); then echo tool $(GOC:c=g); fi`
+GOLD = `if $(GO15); then echo link; else echo $(GOC:c=l); fi`
GOTOOL = `if $(GO1) ; then echo go tool; fi`
GOPACK = `if $(GO1) ; then echo go tool pack; else echo gopack; fi`
-GOOBJEXT = $(GOC:c=)
+GOOBJEXT = `if $(GO15); then echo o; else echo $(GOC:c=); fi`
+
+OSXOLDGOLINKFLAGS = `if [ -n "\`$(GO) $(GOVERSIONOPTION) | grep -E 'go1($|.0|.1|.2|.3)'\`" ] && [ -n "\`echo $(host) | grep darwin\`" ]; then echo "-Wl,-U,__cgo_topofstack"; fi`
SO = @SO@
-srcdir = @srcdir@
-top_srcdir = @top_srcdir@
-top_builddir = @top_builddir@
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+top_builddir = @top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+
+CPP_TEST_CASES = \
+ go_inout \
+ go_director_inout
+
+MULTI_CPP_TEST_CASES = \
+ go_subdir_import
include $(srcdir)/../common.mk
+INCLUDES = -I$(abs_top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)
+
.SUFFIXES: .cpptest .ctest .multicpptest
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
- $(run_testcase)
+ $(run_testcase_cpp)
+ if ! $(GO15); then \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ INCLUDES='$(INCLUDES)' SWIGOPT='$(SWIGOPT)' NOLINK=true \
+ TARGET='$(TARGETPREFIX)$*$(TARGETSUFFIX)' INTERFACEDIR='$(INTERFACEDIR)' INTERFACE='$*.i' \
+ $(LANGUAGE)$(VARIANT)_cpp_nocgo && \
+ $(run_testcase_cpp); \
+ fi
%.ctest:
$(setup)
+$(swig_and_compile_c)
$(run_testcase)
+ if ! $(GO15); then \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' CSRCS='$(CSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ INCLUDES='$(INCLUDES)' SWIGOPT='$(SWIGOPT)' NOLINK=true \
+ TARGET='$(TARGETPREFIX)$*$(TARGETSUFFIX)' INTERFACEDIR='$(INTERFACEDIR)' INTERFACE='$*.i' \
+ $(LANGUAGE)$(VARIANT)_nocgo && \
+ $(run_testcase); \
+ fi
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_multi_testcase)
+li_windows.cpptest:
+ # Does not work because go build won't build li_windows.go,
+ # because file names with "windows" are only built on Windows.
+
multi_import.multicpptest:
$(setup)
for f in multi_import_b multi_import_a; do \
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile CXXSRCS="$(CXXSRCS)" \
- SWIG_LIB="$(SWIG_LIB)" SWIG="$(SWIG)" LIBS='$(LIBS)' \
- INCLUDES="$(INCLUDES)" SWIGOPT="$(SWIGOPT)" NOLINK=true \
- TARGET="$(TARGETPREFIX)$${f}$(TARGETSUFFIX)" INTERFACEDIR="$(INTERFACEDIR)" INTERFACE="$$f.i" \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ LIBS='$(LIBS)' INCLUDES='$(INCLUDES)' SWIGOPT='$(SWIGOPT)' NOLINK=true \
+ TARGET="$(TARGETPREFIX)$${f}$(TARGETSUFFIX)" INTERFACEDIR='$(INTERFACEDIR)' INTERFACE="$$f.i" \
+ $(LANGUAGE)$(VARIANT)_cpp; \
+ done
+ $(run_multi_testcase)
+
+go_subdir_import.multicpptest:
+ $(setup)
+ mkdir -p testdir/go_subdir_import/
+ mkdir -p gopath/src/testdir/go_subdir_import/
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ LIBS='$(LIBS)' INTERFACEPATH='$(SRCDIR)$(INTERFACEDIR)go_subdir_import_b.i' \
+ INCLUDES='$(INCLUDES)' SWIGOPT='$(SWIGOPT) -outdir .' NOLINK=true \
+ TARGET='$(TARGETPREFIX)go_subdir_import_b$(TARGETSUFFIX)' INTERFACEDIR='$(INTERFACEDIR)' \
+ INTERFACE='testdir/go_subdir_import/go_subdir_import_b.i' \
+ $(LANGUAGE)$(VARIANT)_cpp;
+ for f in testdir/go_subdir_import/go_subdir_import_c go_subdir_import_a ; do \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ LIBS='$(LIBS)' INCLUDES='$(INCLUDES)' SWIGOPT='$(SWIGOPT)' NOLINK=true \
+ TARGET="$(TARGETPREFIX)$${f}$(TARGETSUFFIX)" INTERFACEDIR='$(INTERFACEDIR)' INTERFACE="$$f.i" \
$(LANGUAGE)$(VARIANT)_cpp; \
done
+ if $(GOGCC); then \
+ cp gopath/src/testdir/go_subdir_import/go_subdir_import_b/go_subdir_import_b.a gopath/src/testdir/go_subdir_import/go_subdir_import_b.gox; \
+ cp gopath/src/testdir/go_subdir_import/go_subdir_import_b/go_subdir_import_b.a .; \
+ cp gopath/src/testdir/go_subdir_import/go_subdir_import_c/go_subdir_import_c.a gopath/src/testdir/go_subdir_import/go_subdir_import_c.gox; \
+ cp gopath/src/testdir/go_subdir_import/go_subdir_import_c/go_subdir_import_c.a testdir/go_subdir_import/; \
+ fi
$(run_multi_testcase)
# Runs the testcase.
run_testcase = \
- if test -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); then \
- $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
+ if test -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); then \
+ if $(GOGCC) ; then \
+ $(COMPILETOOL) $(GCCGO) -c -g -I . $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
+ $(COMPILETOOL) $(GCCGO) -o $*_runme $(SCRIPTPREFIX)$*_runme.@OBJEXT@ $*.a; \
+ elif $(GO12) || $(GO13) || $(GO15); then \
+ $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -linkmode external -extld $(CC) -extldflags "$(CFLAGS) $(OSXOLDGOLINKFLAGS)" -o $*_runme $(SCRIPTPREFIX)$*_runme.$(GOOBJEXT); \
+ else \
+ $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -L . -r $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`}:. -o $*_runme $(SCRIPTPREFIX)$*_runme.$(GOOBJEXT); \
+ fi && \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) ./$*_runme; \
+ fi
+
+run_testcase_cpp = \
+ if test -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); then \
if $(GOGCC) ; then \
- $(COMPILETOOL) $(GO) -o $*_runme $(SCRIPTPREFIX)$*_runme.@OBJEXT@ $*.@OBJEXT@ $*$(SO); \
+ $(COMPILETOOL) $(GCCGO) -c -g -I . $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
+ $(COMPILETOOL) $(GCCGO) -o $*_runme $(SCRIPTPREFIX)$*_runme.@OBJEXT@ $*.a -lstdc++; \
+ elif $(GO12) || $(GO13) || $(GO15); then \
+ $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -linkmode external -extld $(CXX) -extldflags "$(CXXFLAGS) $(OSXOLDGOLINKFLAGS)" -o $*_runme $(SCRIPTPREFIX)$*_runme.$(GOOBJEXT); \
else \
- $(COMPILETOOL) $(GOTOOL) $(GOLD) -L . -r $${GOROOT}/pkg/$${GOOS}_$${GOARCH}:. -o $*_runme $(SCRIPTPREFIX)$*_runme.$(GOOBJEXT); \
+ $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -L . -r $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`}:. -o $*_runme $(SCRIPTPREFIX)$*_runme.$(GOOBJEXT); \
fi && \
env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) ./$*_runme; \
fi
run_multi_testcase = \
- if test -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); then \
- $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
+ if test -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); then \
if $(GOGCC) ; then \
+ $(COMPILETOOL) $(GCCGO) -c -g -I . -I gopath/src $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
files=`cat $(top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)/$*.list`; \
- $(COMPILETOOL) $(GO) -o $*_runme $(SCRIPTPREFIX)$*_runme.@OBJEXT@ `for f in $$files; do echo $$f.@OBJEXT@ $$f$(SO); done`; \
+ $(COMPILETOOL) $(GCCGO) -o $*_runme $(SCRIPTPREFIX)$*_runme.@OBJEXT@ `for f in $$files; do echo $$f.a; done` -lstdc++; \
+ elif $(GO12) || $(GO13) || $(GO15); then \
+ $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -L . -linkmode external -extld $(CXX) -extldflags "$(CXXFLAGS) $(OSXOLDGOLINKFLAGS)" -o $*_runme $(SCRIPTPREFIX)$*_runme.$(GOOBJEXT); \
else \
- $(COMPILETOOL) $(GOTOOL) $(GOLD) -L . -r $${GOROOT}/pkg/$${GOOS}_$${GOARCH}:. -o $*_runme $(SCRIPTPREFIX)$*_runme.$(GOOBJEXT); \
+ $(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
+ $(COMPILETOOL) $(GOTOOL) $(GOLD) -L . -r $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`}:. -o $*_runme $(SCRIPTPREFIX)$*_runme.$(GOOBJEXT); \
fi && \
env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) ./$*_runme; \
fi
%.clean:
- @rm -f $*.go $*_gc.c $*_wrap.* $*_runme
+ @rm -rf $*.go $*_gc.c $*_wrap.* $*_runme $*.gox $*.a
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile go_clean
- rm -f mod_a.go mod_b.go imports_a.go imports_b.go
- rm -f clientdata_prop_a.go clientdata_prop_b.go
- rm -f multi_import_a.go multi_import_b.go
- rm -f packageoption_a.go packageoption_b.go packageoption_c.go
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' go_clean
+ rm -f mod_a.go mod_a.gox mod_b.go mod_b.gox
+ rm -f imports_a.go imports_a.gox imports_b.go imports_b.gox
+ rm -f clientdata_prop_a.go clientdata_prop_a.gox
+ rm -f clientdata_prop_b.go clientdata_prop_b.gox
+ rm -f multi_import_a.go multi_import_a.gox
+ rm -f multi_import_b.go multi_import_b.gox
+ rm -rf go_subdir_import_a.go go_subdir_import_a.gox testdir
+ rm -f packageoption_a.go packageoption_a.gox
+ rm -f packageoption_b.go packageoption_b.gox
+ rm -f packageoption_c.go packageoption_c.gox
+ rm -f import_stl_a.go import_stl_a.gox
+ rm -f import_stl_b.go import_stl_b.gox
+ rm -rf gopath
cvsignore:
@echo '*_gc.c *_wrap.* *.so *.dll *.exp *.lib'
--- /dev/null
+package main
+
+import wrap "./argout"
+
+func main() {
+ ip := wrap.New_intp()
+ wrap.Intp_assign(ip, 42)
+ if r := wrap.Incp(ip); r != 42 {
+ panic(r)
+ }
+ if r := wrap.Intp_value(ip); r != 43 {
+ panic(r)
+ }
+
+ p := wrap.New_intp()
+ wrap.Intp_assign(p, 2)
+ if r := wrap.Incp(p); r != 2 {
+ panic(r)
+ }
+ if r := wrap.Intp_value(p); r != 3 {
+ panic(r)
+ }
+
+ r := wrap.New_intp()
+ wrap.Intp_assign(r, 7)
+ if r := wrap.Incr(r); r != 7 {
+ panic(r)
+ }
+ if r := wrap.Intp_value(r); r != 8 {
+ panic(r)
+ }
+
+ tr := wrap.New_intp()
+ wrap.Intp_assign(tr, 4)
+ if r := wrap.Inctr(tr); r != 4 {
+ panic(r)
+ }
+ if r := wrap.Intp_value(tr); r != 5 {
+ panic(r)
+ }
+}
}()
//Namespace
- my := contract.NewMyClass(1)
+ contract.NewMyClass(1)
func() {
defer func() {
if recover() == nil {
panic("Failed! constructor preassertion")
}
}()
- my = contract.NewMyClass(0)
+ contract.NewMyClass(0)
}()
}
--- /dev/null
+package main
+
+import "fmt"
+import . "./cpp11_strongly_typed_enumerations"
+
+func enumCheck(actual int, expected int) int {
+ if actual != expected {
+ panic(fmt.Sprintf("Enum value mismatch. Expected: %d Actual: %d", expected, actual))
+ }
+ return expected + 1
+}
+
+func main() {
+ var val = 0
+ val = enumCheck(int(Enum1_Val1), val)
+ val = enumCheck(int(Enum1_Val2), val)
+ val = enumCheck(int(Enum1_Val3), 13)
+ val = enumCheck(int(Enum1_Val4), val)
+ val = enumCheck(int(Enum1_Val5a), 13)
+ val = enumCheck(int(Enum1_Val6a), val)
+
+ val = 0
+ val = enumCheck(int(Enum2_Val1), val)
+ val = enumCheck(int(Enum2_Val2), val)
+ val = enumCheck(int(Enum2_Val3), 23)
+ val = enumCheck(int(Enum2_Val4), val)
+ val = enumCheck(int(Enum2_Val5b), 23)
+ val = enumCheck(int(Enum2_Val6b), val)
+
+ val = 0
+ val = enumCheck(int(Val1), val)
+ val = enumCheck(int(Val2), val)
+ val = enumCheck(int(Val3), 43)
+ val = enumCheck(int(Val4), val)
+
+ val = 0
+ val = enumCheck(int(Enum5_Val1), val)
+ val = enumCheck(int(Enum5_Val2), val)
+ val = enumCheck(int(Enum5_Val3), 53)
+ val = enumCheck(int(Enum5_Val4), val)
+
+ val = 0
+ val = enumCheck(int(Enum6_Val1), val)
+ val = enumCheck(int(Enum6_Val2), val)
+ val = enumCheck(int(Enum6_Val3), 63)
+ val = enumCheck(int(Enum6_Val4), val)
+
+ val = 0
+ val = enumCheck(int(Enum7td_Val1), val)
+ val = enumCheck(int(Enum7td_Val2), val)
+ val = enumCheck(int(Enum7td_Val3), 73)
+ val = enumCheck(int(Enum7td_Val4), val)
+
+ val = 0
+ val = enumCheck(int(Enum8_Val1), val)
+ val = enumCheck(int(Enum8_Val2), val)
+ val = enumCheck(int(Enum8_Val3), 83)
+ val = enumCheck(int(Enum8_Val4), val)
+
+ val = 0
+ val = enumCheck(int(Enum10_Val1), val)
+ val = enumCheck(int(Enum10_Val2), val)
+ val = enumCheck(int(Enum10_Val3), 103)
+ val = enumCheck(int(Enum10_Val4), val)
+
+ val = 0
+ val = enumCheck(int(Class1Enum12_Val1), 1121)
+ val = enumCheck(int(Class1Enum12_Val2), 1122)
+ val = enumCheck(int(Class1Enum12_Val3), val)
+ val = enumCheck(int(Class1Enum12_Val4), val)
+ val = enumCheck(int(Class1Enum12_Val5c), 1121)
+ val = enumCheck(int(Class1Enum12_Val6c), val)
+
+ val = 0
+ val = enumCheck(int(Class1Val1), 1131)
+ val = enumCheck(int(Class1Val2), 1132)
+ val = enumCheck(int(Class1Val3), val)
+ val = enumCheck(int(Class1Val4), val)
+ val = enumCheck(int(Class1Val5d), 1131)
+ val = enumCheck(int(Class1Val6d), val)
+
+ val = 0
+ val = enumCheck(int(Class1Enum14_Val1), 1141)
+ val = enumCheck(int(Class1Enum14_Val2), 1142)
+ val = enumCheck(int(Class1Enum14_Val3), val)
+ val = enumCheck(int(Class1Enum14_Val4), val)
+ val = enumCheck(int(Class1Enum14_Val5e), 1141)
+ val = enumCheck(int(Class1Enum14_Val6e), val)
+
+ // Requires nested class support to work
+ //val = 0
+ //val = enumCheck(int(Class1Struct1Enum12_Val1), 3121)
+ //val = enumCheck(int(Class1Struct1Enum12_Val2), 3122)
+ //val = enumCheck(int(Class1Struct1Enum12_Val3), val)
+ //val = enumCheck(int(Class1Struct1Enum12_Val4), val)
+ //val = enumCheck(int(Class1Struct1Enum12_Val5f), 3121)
+ //val = enumCheck(int(Class1Struct1Enum12_Val6f), val)
+ //
+ //val = 0
+ //val = enumCheck(int(Class1Struct1Val1), 3131)
+ //val = enumCheck(int(Class1Struct1Val2), 3132)
+ //val = enumCheck(int(Class1Struct1Val3), val)
+ //val = enumCheck(int(Class1Struct1Val4), val)
+ //
+ //val = 0
+ //val = enumCheck(int(Class1Struct1Enum14_Val1), 3141)
+ //val = enumCheck(int(Class1Struct1Enum14_Val2), 3142)
+ //val = enumCheck(int(Class1Struct1Enum14_Val3), val)
+ //val = enumCheck(int(Class1Struct1Enum14_Val4), val)
+ //val = enumCheck(int(Class1Struct1Enum14_Val5g), 3141)
+ //val = enumCheck(int(Class1Struct1Enum14_Val6g), val)
+
+ val = 0
+ val = enumCheck(int(Class2Enum12_Val1), 2121)
+ val = enumCheck(int(Class2Enum12_Val2), 2122)
+ val = enumCheck(int(Class2Enum12_Val3), val)
+ val = enumCheck(int(Class2Enum12_Val4), val)
+ val = enumCheck(int(Class2Enum12_Val5h), 2121)
+ val = enumCheck(int(Class2Enum12_Val6h), val)
+
+ val = 0
+ val = enumCheck(int(Class2Val1), 2131)
+ val = enumCheck(int(Class2Val2), 2132)
+ val = enumCheck(int(Class2Val3), val)
+ val = enumCheck(int(Class2Val4), val)
+ val = enumCheck(int(Class2Val5i), 2131)
+ val = enumCheck(int(Class2Val6i), val)
+
+ val = 0
+ val = enumCheck(int(Class2Enum14_Val1), 2141)
+ val = enumCheck(int(Class2Enum14_Val2), 2142)
+ val = enumCheck(int(Class2Enum14_Val3), val)
+ val = enumCheck(int(Class2Enum14_Val4), val)
+ val = enumCheck(int(Class2Enum14_Val5j), 2141)
+ val = enumCheck(int(Class2Enum14_Val6j), val)
+
+ // Requires nested class support to work
+ //val = 0
+ //val = enumCheck(int(Class2Struct1Enum12_Val1), 4121)
+ //val = enumCheck(int(Class2Struct1Enum12_Val2), 4122)
+ //val = enumCheck(int(Class2Struct1Enum12_Val3), val)
+ //val = enumCheck(int(Class2Struct1Enum12_Val4), val)
+ //val = enumCheck(int(Class2Struct1Enum12_Val5k), 4121)
+ //val = enumCheck(int(Class2Struct1Enum12_Val6k), val)
+ //
+ //val = 0
+ //val = enumCheck(int(Class2Struct1Val1), 4131)
+ //val = enumCheck(int(Class2Struct1Val2), 4132)
+ //val = enumCheck(int(Class2Struct1Val3), val)
+ //val = enumCheck(int(Class2Struct1Val4), val)
+ //val = enumCheck(int(Class2Struct1Val5l), 4131)
+ //val = enumCheck(int(Class2Struct1Val6l), val)
+ //
+ //val = 0
+ //val = enumCheck(int(Class2Struct1Enum14_Val1), 4141)
+ //val = enumCheck(int(Class2Struct1Enum14_Val2), 4142)
+ //val = enumCheck(int(Class2Struct1Enum14_Val3), val)
+ //val = enumCheck(int(Class2Struct1Enum14_Val4), val)
+ //val = enumCheck(int(Class2Struct1Enum14_Val5m), 4141)
+ //val = enumCheck(int(Class2Struct1Enum14_Val6m), val)
+
+ class1 := NewClass1()
+ enumCheck(int(class1.Class1Test1(Enum1_Val5a)), 13)
+ enumCheck(int(class1.Class1Test2(Class1Enum12_Val5c)), 1121)
+ //enumCheck(int(class1.Class1Test3(Class1Struct1Enum12_Val5f)), 3121)
+
+ enumCheck(int(GlobalTest1(Enum1_Val5a)), 13)
+ enumCheck(int(GlobalTest2(Class1Enum12_Val5c)), 1121)
+ //enumCheck(int(GlobalTest3(Class1Struct1Enum12_Val5f)), 3121)
+
+}
f := dc.NewF()
f.Destroy()
- ff := dc.NewFFF()
- ff.Destroy()
-
g := dc.NewG()
dc.GDestroy(g)
+++ /dev/null
-package main
-
-import "./director_abstract"
-
-type MyFoo struct{}
-
-func (p *MyFoo) Ping() string {
- return "MyFoo::ping()"
-}
-
-func f1() {
- a := director_abstract.NewDirectorFoo(&MyFoo{})
-
- if a.Ping() != "MyFoo::ping()" {
- panic(a.Ping())
- }
-
- if a.Pong() != "Foo::pong();MyFoo::ping()" {
- panic(a.Pong())
- }
-}
-
-type MyExample1 struct{}
-
-func (p *MyExample1) Color(r, g, b byte) int {
- return int(r)
-}
-
-type MyExample2 struct{}
-
-func (p *MyExample2) Color(r, g, b byte) int {
- return int(g)
-}
-
-type MyExample3 struct{}
-
-func (p *MyExample3) Color(r, g, b byte) int {
- return int(b)
-}
-
-func f2() {
- me1 := director_abstract.NewDirectorExample1(&MyExample1{})
- if director_abstract.Example1Get_color(me1, 1, 2, 3) != 1 {
- println(director_abstract.Example1Get_color(me1, 1, 2, 3))
- panic(0)
- }
-
- me2 := director_abstract.NewDirectorExample2(&MyExample2{}, 1, 2)
- if director_abstract.Example2Get_color(me2, 1, 2, 3) != 2 {
- panic(0)
- }
-
- me3 := director_abstract.NewDirectorExample3_i(&MyExample3{})
- if director_abstract.Example3_iGet_color(me3, 1, 2, 3) != 3 {
- panic(0)
- }
-}
-
-func main() {
- f1()
- f2()
-}
+++ /dev/null
-package main
-
-import . "./director_thread"
-
-type Derived struct {
- abi Foo
-} // From Foo
-func (p *Derived) Do_foo() {
- p.abi.SetVal(p.abi.GetVal() - 1)
-}
-
-func main() {
-
- // FIXME: This test fails until we fix callbacks from a
- // different thread.
- return
-
- p := &Derived{nil}
- d := NewDirectorFoo(p)
- p.abi = d
- d.Run()
-
- if d.GetVal() >= 0 {
- panic(d.GetVal())
- }
-
- d.Stop()
-}
--- /dev/null
+package main
+
+import _ "./empty_c"
+
+func main() {
+}
--- /dev/null
+package main
+
+import (
+ wrap "./go_director_inout"
+)
+
+type GoMyClass struct {}
+
+func (p *GoMyClass) Adjust(m map[string]interface{}) wrap.GoRetStruct {
+ s := ""
+ for k, v := range m {
+ s += k + "," + v.(string) + ";"
+ }
+ return wrap.GoRetStruct{s}
+}
+
+func main() {
+ a := wrap.NewDirectorMyClass(&GoMyClass{})
+ m := map[string]interface{}{
+ "first": "second",
+ }
+ s := a.Adjust(m)
+ if s.Str != "first,second;" {
+ panic(s)
+ }
+
+ a = wrap.NewDirectorMyClass(nil)
+ s = a.Adjust(m)
+ if s.Str != `{"first":"second"}` {
+ panic(s.Str)
+ }
+}
--- /dev/null
+package main
+
+import (
+ "encoding/json"
+ "fmt"
+ "reflect"
+
+ "./go_inout"
+)
+
+type S struct {
+ A int
+ B string
+ C float64
+}
+
+func (p *S) MarshalJSON() ([]byte, error) {
+ return json.Marshal(*p)
+}
+
+func main() {
+ v := &S{12, "hi", 34.5}
+ m := go_inout.Same(v)
+ want := map[string]interface{}{
+ // The type of A changes from int to float64 because
+ // JSON has no ints.
+ "A": float64(12),
+ "B": "hi",
+ "C": 34.5,
+ }
+ if !reflect.DeepEqual(m, want) {
+ fmt.Println("got", m, "want", want)
+ panic(m)
+ }
+
+ a := []string{"a", "bc", "def"}
+ go_inout.DoubleArray(&a)
+ dwant := []string{"a", "bc", "def", "aa", "bcbc", "defdef"}
+ if !reflect.DeepEqual(a, dwant) {
+ fmt.Println("got", a, "want", dwant)
+ panic(a)
+ }
+
+ c2 := go_inout.NewC2()
+ pm := c2.M()
+ want = map[string]interface{}{
+ "ID": float64(1),
+ }
+ if !reflect.DeepEqual(*pm, want) {
+ fmt.Println("for c2.M got", pm, "want", want)
+ panic(pm)
+ }
+}
--- /dev/null
+package main
+
+import (
+ "go_subdir_import_a"
+ "testdir/go_subdir_import/go_subdir_import_b"
+ "testdir/go_subdir_import/go_subdir_import_c"
+)
+
+func main() {
+ b := go_subdir_import_b.NewObjB();
+ c := go_subdir_import_c.NewObjC();
+ v := go_subdir_import_a.AddFive(b, c)
+ if v != 50 {
+ panic(0)
+ }
+}
--- /dev/null
+package main
+
+import wrap "./inherit_member"
+
+func main() {
+ s := wrap.NewChild()
+ s.SetPvar("p")
+ s.SetCvar("c")
+ if s.GetPvar() != "p" {
+ panic(s.GetPvar())
+ }
+ if s.GetCvar() != "c" {
+ panic(s.GetCvar())
+ }
+}
--- /dev/null
+package main
+
+import "./keyword_rename_c"
+
+func main() {
+ keyword_rename_c.Xgo(1)
+ keyword_rename_c.Xchan(1)
+}
--- /dev/null
+package main
+
+import . "./li_carrays_cpp"
+
+func main() {
+ d := NewDoubleArray(10)
+
+ d.Setitem(0, 7)
+ d.Setitem(5, d.Getitem(0)+3)
+
+ if d.Getitem(5)+d.Getitem(0) != 17 {
+ panic(0)
+ }
+}
--- /dev/null
+package main
+
+import . "./li_cdata_cpp"
+
+func main() {
+ s := "ABC abc"
+ m := Malloc(256)
+ Memmove(m, s, len(s))
+ ss := Cdata(m, 7)
+ if string(ss) != "ABC abc" {
+ panic("failed")
+ }
+}
--- /dev/null
+package main
+
+import . "./li_cpointer_cpp"
+
+func main() {
+ p := New_intp()
+ Intp_assign(p, 3)
+
+ if Intp_value(p) != 3 {
+ panic(0)
+ }
+
+ Delete_intp(p)
+}
package main
-import "./overload_extendc"
+import "./overload_extend2"
func main() {
- f := overload_extendc.NewFoo()
+ f := overload_extend2.NewFoo()
if f.Test(3) != 1 {
panic(0)
}
--- /dev/null
+package main
+
+import "./overload_extend_c"
+
+func main() {
+ f := overload_extend_c.NewFoo()
+ if f.Test().(int) != 0 {
+ panic(0)
+ }
+ if f.Test(3).(int) != 1 {
+ panic(0)
+ }
+ if f.Test("hello").(int) != 2 {
+ panic(0)
+ }
+ if f.Test(float64(3), float64(2)).(float64) != 5 {
+ panic(0)
+ }
+ if f.Test(3.0).(float64) != 1003 {
+ panic(0)
+ }
+}
--- /dev/null
+package main
+
+import "./overload_polymorphic"
+
+func main(){
+ t := overload_polymorphic.NewDerived()
+
+ if overload_polymorphic.Test(t) != 0 {
+ panic("failed 1")
+ }
+
+ if overload_polymorphic.Test2(t) != 1 {
+ panic("failed 2")
+ }
+}
import "./template_opaque"
func main() {
- v := template_opaque.NewOpaqueVectorType(10)
+ v := template_opaque.NewOpaqueVectorType(int64(10))
template_opaque.FillVector(v)
}
+++ /dev/null
-package main
-
-import "template_typedef_cplx2"
-import "template_typedef_import"
-
-func main() {
- // this is OK
-
- s := template_typedef_import.NewSin()
- s.Get_base_value()
- s.Get_value()
- s.Get_arith_value()
- template_typedef_import.My_func_r(s)
- template_typedef_cplx2.Make_Multiplies_double_double_double_double(s, s)
-
- z := template_typedef_import.NewCSin()
- z.Get_base_value()
- z.Get_value()
- z.Get_arith_value()
- template_typedef_import.My_func_c(z)
- template_typedef_cplx2.Make_Multiplies_complex_complex_complex_complex(z, z)
-
- // Here we fail
- d := template_typedef_cplx2.Make_Identity_double()
- template_typedef_import.My_func_r(d)
-
- c := template_typedef_cplx2.Make_Identity_complex()
- template_typedef_import.My_func_c(c)
-}
func main() {
a := 2
b := -1
- wrapmacro.Maximum(a, b)
- wrapmacro.Maximum(a/7.0, -b*256)
+ wrapmacro.Maximum(int64(a), int64(b))
+ wrapmacro.Maximum(float64(a/7.0), float64(-b*256))
wrapmacro.GUINT16_SWAP_LE_BE_CONSTANT(1)
}
--- /dev/null
+// Test the goin and goout typemaps for directors.
+
+%module(directors="1") go_director_inout
+
+%{
+#include <string>
+%}
+
+%inline
+%{
+
+struct MyStruct {
+ std::string str;
+};
+
+struct RetStruct {
+ std::string str;
+};
+
+%}
+
+%go_import("encoding/json")
+
+%insert(go_header)
+%{
+
+type GoRetStruct struct {
+ Str string
+}
+
+%}
+
+%typemap(gotype) RetStruct "GoRetStruct"
+
+%typemap(imtype) RetStruct "string"
+
+%typemap(goin) RetStruct
+%{
+ $result = $input.Str
+%}
+
+%typemap(in) RetStruct
+%{
+ $result.str.assign($input.p, $input.n);
+%}
+
+%typemap(out,fragment="AllocateString") RetStruct
+%{
+ $result = Swig_AllocateString($1.str.data(), $1.str.length());
+%}
+
+%typemap(goout,fragment="CopyString") RetStruct
+%{
+ $result = GoRetStruct{Str: swigCopyString($input)}
+%}
+
+%typemap(godirectorout) RetStruct
+%{
+ $result = $input.Str
+%}
+
+%typemap(directorout) RetStruct
+%{
+ $result.str.assign($input.p, $input.n);
+%}
+
+%typemap(godirectorin) RetStruct
+%{
+%}
+
+%typemap(gotype) MyStruct "map[string]interface{}"
+
+%typemap(imtype) MyStruct "string"
+
+%typemap(goin) MyStruct
+%{
+ if b, err := json.Marshal($input); err != nil {
+ panic(err)
+ } else {
+ $result = string(b)
+ }
+%}
+
+%typemap(directorin,fragment="AllocateString") MyStruct
+%{
+ $input = Swig_AllocateString($1.str.data(), $1.str.length());
+%}
+
+%typemap(godirectorin,fragment="CopyString") MyStruct
+%{
+ if err := json.Unmarshal([]byte(swigCopyString($input)), &$result); err != nil {
+ panic(err)
+ }
+%}
+
+%typemap(out,fragment="AllocateString") MyStruct
+%{
+ $result = Swig_AllocateString($1.str.data(), $1.str.length());
+%}
+
+%typemap(goout,fragment="CopyString") MyStruct
+%{
+ $result = swigCopyString($input)
+%}
+
+%typemap(in) MyStruct
+%{
+ $1.str.assign($input.p, $input.n);
+%}
+
+%feature("director") MyClass;
+
+%inline
+%{
+
+class MyClass {
+ public:
+ virtual ~MyClass() {}
+ virtual RetStruct Adjust(MyStruct s) {
+ RetStruct r;
+ r.str = s.str;
+ return r;
+ }
+};
+
+%}
--- /dev/null
+// Test the goin, goout, and goargout typemaps.
+
+%module go_inout
+
+%{
+#include <string>
+#include <vector>
+#include <stdint.h>
+%}
+
+%inline
+%{
+
+struct MyStruct {
+ std::string str;
+};
+
+struct RetStruct {
+ std::string str;
+};
+
+%}
+
+// Write a typemap that calls C++ by converting in and out of JSON.
+
+%go_import("encoding/json", "bytes", "encoding/binary", "reflect", "unsafe")
+
+%insert(go_header)
+%{
+
+type In json.Marshaler
+
+%}
+
+%typemap(gotype) MyStruct "In"
+
+%typemap(imtype) MyStruct "string"
+
+%typemap(goin) MyStruct
+%{
+ {
+ b, err := $input.MarshalJSON()
+ if err != nil {
+ panic(err)
+ }
+ $result = string(b)
+ }
+%}
+
+%typemap(in) MyStruct
+%{
+ $1.str.assign($input.p, $input.n);
+%}
+
+%typemap(gotype) RetStruct "map[string]interface{}"
+
+%typemap(imtype) RetStruct "string"
+
+%typemap(out,fragment="AllocateString") RetStruct
+%{
+ $result = Swig_AllocateString($1.str.data(), $1.str.length());
+%}
+
+%typemap(goout,fragment="CopyString") RetStruct
+%{
+ if err := json.Unmarshal([]byte(swigCopyString($1)), &$result); err != nil {
+ panic(err)
+ }
+%}
+
+%typemap(gotype) RetStruct* "*map[string]interface{}"
+
+%typemap(imtype) RetStruct* "*string"
+
+%typemap(out,fragment="AllocateString") RetStruct*
+%{
+ $result = (_gostring_*)malloc(sizeof(_gostring_));
+ *$result = Swig_AllocateString($1->str.data(), $1->str.length());
+%}
+
+%typemap(goout,fragment="CopyString") RetStruct*
+%{
+ defer Swig_free(uintptr(unsafe.Pointer($1)))
+ var rm map[string]interface{}
+ if err := json.Unmarshal([]byte(swigCopyString(*$1)), &rm); err != nil {
+ panic(err)
+ }
+ $result = &rm
+%}
+
+%inline
+%{
+
+RetStruct Same(MyStruct s)
+{
+ RetStruct r;
+ r.str = s.str;
+ return r;
+}
+
+%}
+
+%inline
+%{
+
+struct MyArray {
+ std::vector<std::string> strings;
+};
+
+void* Allocate(int n) {
+ return new char[n];
+}
+
+static uint64_t getuint64(const char* s) {
+ uint64_t ret = 0;
+ for (int i = 0; i < 8; i++, s++) {
+ ret |= static_cast<uint64_t>(*s) << i * 8;
+ }
+ return ret;
+}
+
+static void putuint64(std::string *s, size_t off, uint64_t v) {
+ for (int i = 0; i < 8; i++) {
+ (*s)[off + i] = (v >> (i * 8)) & 0xff;
+ }
+}
+
+%}
+
+%typemap(gotype) MyArray* "*[]string"
+
+%typemap(imtype) MyArray* "*string"
+
+// Encode the slice as a single string, with length prefixes.
+%typemap(goin) MyArray*
+%{
+ {
+ var buf bytes.Buffer
+ bin := binary.LittleEndian
+ var b [8]byte
+ bin.PutUint64(b[:], uint64(len(*$input)))
+ buf.Write(b[:])
+ for _, s := range *$input {
+ bin.PutUint64(b[:], uint64(len(s)))
+ buf.Write(b[:])
+ buf.WriteString(s)
+ }
+ bb := buf.Bytes()
+ p := Allocate(len(bb))
+ copy((*[1<<15]byte)(unsafe.Pointer(p))[:len(bb)], bb)
+ var str string
+ (*reflect.StringHeader)(unsafe.Pointer(&str)).Data = uintptr(unsafe.Pointer(p))
+ (*reflect.StringHeader)(unsafe.Pointer(&str)).Len = len(bb)
+ $result = &str
+ }
+%}
+
+// Unpack the string holding the packed slice.
+%typemap(in) MyArray* (MyArray t)
+%{
+ {
+ _gostring_ *s = $input;
+ const char *p = static_cast<const char *>(s->p);
+ uint64_t len = getuint64(p);
+ p += 8;
+ t.strings.resize(len);
+ for (uint64_t i = 0; i < len; i++) {
+ uint64_t slen = getuint64(p);
+ p += 8;
+ t.strings[i].assign(p, slen);
+ p += slen;
+ }
+ $1 = &t;
+ }
+%}
+
+// Pack the vector into a string.
+%typemap(argout,fragment="AllocateString") MyArray*
+%{
+ {
+ size_t tot = 8;
+ std::vector<std::string>::const_iterator p;
+ for (p = $1->strings.begin(); p != $1->strings.end(); ++p) {
+ tot += 8 + p->size();
+ }
+ std::string str;
+ str.resize(tot);
+ putuint64(&str, 0, $1->strings.size());
+ size_t off = 8;
+ for (p = $1->strings.begin(); p != $1->strings.end(); ++p) {
+ putuint64(&str, off, p->size());
+ off += 8;
+ str.replace(off, p->size(), *p);
+ off += p->size();
+ }
+ *$input = Swig_AllocateString(str.data(), str.size());
+ }
+%}
+
+// Unpack the string into a []string.
+%typemap(goargout,fragment="CopyString") MyArray*
+%{
+ {
+ str := swigCopyString(*$input)
+ bin := binary.LittleEndian
+ size := bin.Uint64([]byte(str[:8]))
+ str = str[8:]
+ r := make([]string, size)
+ for i := range r {
+ len := bin.Uint64([]byte(str[:8]))
+ str = str[8:]
+ r[i] = str[:len]
+ str = str[len:]
+ }
+ *$1 = r
+ }
+
+%}
+
+%inline
+%{
+void DoubleArray(MyArray* v) {
+ size_t size = v->strings.size();
+ for (size_t i = 0; i < size; i++) {
+ v->strings.push_back(v->strings[i] + v->strings[i]);
+ }
+}
+%}
+
+%inline
+%{
+class C1 {
+ public:
+ RetStruct* M() {
+ RetStruct* r = new RetStruct;
+ r->str = "{\"ID\":1}";
+ return r;
+ }
+};
+
+class C2 : public C1 {
+};
+%}
--- /dev/null
+testdir/go_subdir_import/go_subdir_import_c
+go_subdir_import_b
+go_subdir_import_a
--- /dev/null
+/* File : go_subdir_import_a.i */
+
+/*
+ * This files helps check the case where the SWIG-generated .go file needs to
+ * import another, SWIG-generated, module that is in a relative subdirectory.
+ * This case might happen for two different reasons:
+ * 1) Importing a module for which the .i file is in a subdirectory relatively
+ * to this file (this is tested here with go_subdir_import_c).
+ * 2) Importing a module whos module name is a path (this is tested here with
+ * go_subdir_import_b).
+ *
+ * This file is the "root" file that imports the two modules which will be
+ * generated (by swig) in a relative subdirectory.
+ */
+%module go_subdir_import_a
+
+%import(module="testdir/go_subdir_import/go_subdir_import_c") "testdir/go_subdir_import/go_subdir_import_c.i"
+%import "go_subdir_import_b.i"
+
+%{
+class ObjC {
+ public:
+ virtual int getInt() const;
+};
+
+class ObjB {
+ public:
+ virtual int getInt() const;
+};
+%}
+
+%inline %{
+int AddFive(const ObjB& b, const ObjC& c) {
+ return b.getInt() + c.getInt() + 5;
+}
+%}
+
--- /dev/null
+/* File : go_subdir_import_b.i */
+%module "testdir/go_subdir_import/go_subdir_import_b"
+
+%inline %{
+class ObjB {
+ public:
+ virtual int getInt() const {
+ return 27;
+ }
+};
+%}
+
LANGUAGE = guile
VARIANT =
SCRIPTSUFFIX = _runme.scm
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
+
GUILE = @GUILE@
GUILE_RUNTIME=
C_TEST_CASES = long_long \
- list_vector \
- multivalue \
- pointer_in_out
+ list_vector \
+ multivalue \
+ pointer_in_out
include $(srcdir)/../common.mk
%.multicpptest: SWIGOPT += $(GUILE_RUNTIME)
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.scm appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env GUILE_AUTO_COMPILE=0 LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(GUILE) -l $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env GUILE_AUTO_COMPILE=0 LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(GUILE) -l $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
# Clean
@rm -f $*-guile
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile guile_clean
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' guile_clean
;; current module. That's enough for such a simple test.
(dynamic-call "scm_init_li_std_string_module" (dynamic-link "./libli_std_string"))
; Note: when working with non-ascii strings in guile 2
-; locale must be set explicitly
+; Guile doesn't handle non-ascii characters in the default C locale
+; The locale must be set explicitly
; The setlocale call below takes care of that
-(setlocale LC_ALL "")
+; The locale needs to be a UTF-8 locale to handle the non-ASCII characters
+; But they are named differently on different systems so we try a few until one works
+
+(define (try-set-locale name)
+; (display "testing ")
+; (display name)
+; (display "\n")
+ (catch #t
+ (lambda ()
+ (setlocale LC_ALL name)
+ #t
+ )
+ (lambda (key . parameters)
+ #f
+ ))
+)
+
+(if (not (try-set-locale "C.UTF-8")) ; Linux
+(if (not (try-set-locale "en_US.utf8")) ; Linux
+(if (not (try-set-locale "en_US.UTF-8")) ; Mac OS X
+(error "Failed to set any UTF-8 locale")
+)))
+
(load "../schemerunme/li_std_string.scm")
--- /dev/null
+(dynamic-call "scm_init_overload_extend_c_module" (dynamic-link "./liboverload_extend_c"))
+(load "../schemerunme/overload_extend_c.scm")
#if defined(SWIG_GOOD_VECTOR)
%inline %{
class Flow {
- Flow() {}
+double x;
+ Flow():x(0.0) {}
public:
- Flow(double d) {}
+ Flow(double d) : x(d) {}
};
%}
%inline %{
class Flow {
+double x;
public:
- Flow() {}
- Flow(double d) {}
+ Flow(): x(0.0) {}
+ Flow(double d) : x(d) {}
};
%}
%import "import_nomodule.h"
-#if !defined(SWIGJAVA) && !defined(SWIGRUBY) && !defined(SWIGCSHARP) && !defined(SWIGD)
+#if !defined(SWIGJAVA) && !defined(SWIGRUBY) && !defined(SWIGCSHARP) && !defined(SWIGD) && !defined(SWIGPYTHON_BUILTIN)
/**
* The proxy class does not have Bar derived from Foo, yet an instance of Bar
#endif
+%inline %{
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
+%}
--- /dev/null
+%module infinity
+
+/* C99 defines INFINITY
+ Because INFINITY may be defined by compiler built-ins, we can't use #define.
+ Instead, expose the variable MYINFINITY and then use %rename to make it INFINITY in the scripting language.
+*/
+%rename(INFINITY) MYINFINITY;
+
+%{
+#include <math.h>
+
+/* C99 math.h defines INFINITY. If not available, this is the fallback. */
+#if !defined(INFINITY)
+ #if defined(_MSC_VER)
+ union MSVC_EVIL_FLOAT_HACK
+ {
+ unsigned __int8 Bytes[4];
+ float Value;
+ };
+ const union MSVC_EVIL_FLOAT_HACK INFINITY_HACK = {{0x00, 0x00, 0x80, 0x7F}};
+ #define INFINITY (INFINITY_HACK.Value)
+ #define INFINITY_NO_CONST
+ #endif
+
+ #ifdef __GNUC__
+ #define INFINITY (__builtin_inf())
+ #elif defined(__clang__)
+ #if __has_builtin(__builtin_inf)
+ #define INFINITY (__builtin_inf())
+ #endif
+ #endif
+
+ #ifndef INFINITY
+ #define INFINITY (1e1000)
+ #endif
+#endif
+
+#ifdef INFINITY_NO_CONST
+/* To void: error C2099: initializer is not a constant */
+double MYINFINITY = 0.0;
+void initialise_MYINFINITY(void) {
+ MYINFINITY = INFINITY;
+}
+#else
+const double MYINFINITY = INFINITY;
+void initialise_MYINFINITY(void) {
+}
+#endif
+
+float use_infinity(float inf_val)
+{
+ return inf_val;
+}
+%}
+
+/* This will allow us to bind the real INFINITY value through SWIG via MYINFINITY. Use %rename to fix the name. */
+const double MYINFINITY = INFINITY;
+void initialise_MYINFINITY(void);
+/* Use of float is intentional because the original bug was in the float conversion due to overflow checking. */
+float use_infinity(float inf_val);
+
--- /dev/null
+// Based on https://github.com/swig/swig/issues/339 .
+
+%module inherit_member
+
+%include <std_string.i>
+
+%inline %{
+
+struct parent_class {
+ std::string pvar;
+};
+
+ struct child : public parent_class {
+ std::string cvar;
+};
+
+%}
%init %{
// %inserted code %init
-int inserted_init_value = inserted_wrapper(0);
+int SWIGUNUSED inserted_init_value = inserted_wrapper(0);
%}
LANGUAGE = java
JAVA = @JAVA@
JAVAC = @JAVAC@
-JAVAFLAGS = -Xcheck:jni
+JAVAFLAGS = @JAVAFLAGS@
SCRIPTSUFFIX = _runme.java
+
srcdir = @srcdir@
top_srcdir = ../@top_srcdir@
top_builddir = ../@top_builddir@
java_constants \
java_director \
java_director_assumeoverride \
+ java_director_exception_feature \
+ java_director_exception_feature_nspace \
+ java_director_ptrclass \
java_enums \
java_jnitypes \
java_lib_arrays_dimensionless \
java_prepost \
java_throws \
java_typemaps_proxy \
- java_typemaps_typewrapper
+ java_typemaps_typewrapper \
# li_boost_intrusive_ptr
+CPP11_TEST_CASES = \
+ cpp11_strongly_typed_enumerations_simple \
+
include $(srcdir)/../common.mk
# Overridden variables here
+SRCDIR = ../$(srcdir)/
JAVA_PACKAGE = $*
JAVA_PACKAGEOPT = -package $(JAVA_PACKAGE)
SWIGOPT += $(JAVA_PACKAGEOPT)
# Custom tests - tests with additional commandline options
+director_nspace.%: JAVA_PACKAGE = $*Package
+director_nspace_director_name_collision.%: JAVA_PACKAGE = $*Package
+java_director_exception_feature_nspace.%: JAVA_PACKAGE = $*Package
java_nspacewithoutpackage.%: JAVA_PACKAGEOPT =
+multiple_inheritance_nspace.%: JAVA_PACKAGE = $*Package
nspace.%: JAVA_PACKAGE = $*Package
nspace_extend.%: JAVA_PACKAGE = $*Package
-director_nspace.%: JAVA_PACKAGE = $*Package
-director_nspace_director_name_collision.%: JAVA_PACKAGE = $*Package
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+(cd $(JAVA_PACKAGE) && $(swig_and_compile_cpp))
$(run_testcase)
+(cd $(JAVA_PACKAGE) && $(swig_and_compile_c))
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+(cd $(JAVA_PACKAGE) && $(swig_and_compile_multi_cpp))
$(run_testcase)
# Makes a directory for the testcase if it does not exist
setup = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- echo "$(ACTION)ing testcase $* (with run test) under $(LANGUAGE)" ; \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ echo "$(ACTION)ing $(LANGUAGE) testcase $* (with run test)" ; \
else \
- echo "$(ACTION)ing testcase $* under $(LANGUAGE)" ; \
+ echo "$(ACTION)ing $(LANGUAGE) testcase $*" ; \
fi; \
if [ ! -d $(JAVA_PACKAGE) ]; then \
mkdir $(JAVA_PACKAGE); \
# Note Java uses LD_LIBRARY_PATH under Unix, PATH under Cygwin/Windows, SHLIB_PATH on HPUX and DYLD_LIBRARY_PATH on Mac OS X.
run_testcase = \
cd $(JAVA_PACKAGE) && $(COMPILETOOL) $(JAVAC) -classpath . `find . -name "*.java"` && cd .. && \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- $(COMPILETOOL) $(JAVAC) -classpath . -d . $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ $(COMPILETOOL) $(JAVAC) -classpath . -d . $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) && \
env LD_LIBRARY_PATH="$(JAVA_PACKAGE):$$LD_LIBRARY_PATH" PATH="$(JAVA_PACKAGE):$$PATH" SHLIB_PATH="$(JAVA_PACKAGE):$$SHLIB_PATH" DYLD_LIBRARY_PATH="$(JAVA_PACKAGE):$$DYLD_LIBRARY_PATH" $(RUNTOOL) $(JAVA) $(JAVAFLAGS) -classpath . $*_runme; \
fi
See ../README for common README file.
-The Java implementation of the test-suite is a little different to the other languages in that all of SWIGs output goes into a subdirectory named after the individual test case. This is so that all the shadow classes can be compiled as Java classes have to go into separate files. Otherwise the Makefile wouldn't know which .java files would be relevant to the testcase. For this to work the testcase must go into a Java package.
+The Java implementation of the test-suite is a little different to the other languages in that all of SWIG's output goes into a subdirectory named after the individual test case. This is so that all the shadow classes can be compiled as Java classes which have to go into separate files. Otherwise the Makefile wouldn't know which .java files would be relevant to the testcase. For this to work the testcase must go into a Java package.
Any testcases which have _runme.java appended after the testcase name will be detected and run.
if (t.strlen(hil0) != 4)
throw new RuntimeException("bad multi-arg typemap");
+
+ if (t.ustrlen(hile) != 4)
+ throw new RuntimeException("bad multi-arg typemap");
+
+ if (t.ustrlen(hil0) != 4)
+ throw new RuntimeException("bad multi-arg typemap");
}
}
--- /dev/null
+import constant_directive.*;
+
+public class constant_directive_runme {
+
+ static {
+ try {
+ System.loadLibrary("constant_directive");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+ if (constant_directive.TYPE1_CONSTANT1.getVal() != 1)
+ throw new RuntimeException("fail");
+ if (constant_directive.TYPE1_CONSTANT2.getVal() != 2)
+ throw new RuntimeException("fail");
+ if (constant_directive.TYPE1_CONSTANT3.getVal() != 3)
+ throw new RuntimeException("fail");
+ if (constant_directive.TYPE1CONST_CONSTANT1.getVal() != 1)
+ throw new RuntimeException("fail");
+ if (constant_directive.TYPE1CPTR_CONSTANT1.getVal() != 1)
+ throw new RuntimeException("fail");
+ }
+}
--- /dev/null
+import cpp11_constexpr.*;
+
+public class cpp11_constexpr_runme {
+
+ static {
+ try {
+ System.loadLibrary("cpp11_constexpr");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ private static void check(int received, int expected) {
+ if (expected != received)
+ throw new RuntimeException("check failed, expected: " + expected + " received: " + received);
+ }
+
+ public static void main(String argv[])
+ {
+ check(cpp11_constexpr.getAAA(), 10);
+ check(cpp11_constexpr.getBBB(), 20);
+ check(cpp11_constexpr.CCC(), 30);
+ check(cpp11_constexpr.DDD(), 40);
+
+ ConstExpressions ce = new ConstExpressions(0);
+ check(ce.JJJ, 100);
+ check(ce.KKK, 200);
+ check(ce.LLL, 300);
+ check(ce.MMM(), 400);
+ check(ce.NNN(), 500);
+ }
+}
--- /dev/null
+import cpp11_lambda_functions.*;
+
+public class cpp11_lambda_functions_runme {
+
+ static {
+ try {
+ System.loadLibrary("cpp11_lambda_functions");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ private static void check(int received, int expected) {
+ if (expected != received)
+ throw new RuntimeException("check failed, expected: " + expected + " received: " + received);
+ }
+
+ public static void main(String argv[])
+ {
+ check(cpp11_lambda_functions.runLambda1(), 11);
+ check(cpp11_lambda_functions.runLambda2(), 11);
+ check(cpp11_lambda_functions.runLambda3(), 11);
+ check(cpp11_lambda_functions.runLambda4(), 11);
+ check(cpp11_lambda_functions.runLambda5(), 1);
+ check(cpp11_lambda_functions.runLambda5(), 2);
+ }
+}
--- /dev/null
+import cpp11_li_std_array.*;
+
+public class cpp11_li_std_array_runme {
+
+ static {
+ try {
+ System.loadLibrary("cpp11_li_std_array");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ private static ArrayInt6 ToArray6(int [] a) {
+ ArrayInt6 ai = new ArrayInt6();
+ if (a.length != 6)
+ throw new RuntimeException("a is incorrect size");
+ for (int i=0; i<6; ++i)
+ ai.set(i, a[i]);
+ return ai;
+ }
+
+ private static void compareContainers(ArrayInt6 actual, int[] expected) {
+ if (actual.size() != expected.length)
+ throw new RuntimeException("Sizes are different: " + actual.size() + " " + expected.length);
+ for (int i=0; i<actual.size(); ++i) {
+ int actualValue = actual.get(i);
+ int expectedValue = expected[i];
+ if (actualValue != expectedValue)
+ throw new RuntimeException("Value is wrong for element " + i + ". Expected " + expectedValue + " got: " + actualValue);
+ }
+ if (actual.isEmpty())
+ throw new RuntimeException("ai should not be empty");
+ }
+
+ public static void main(String argv[]) {
+ ArrayInt6 ai = new ArrayInt6();
+ compareContainers(ai, new int[] {0, 0, 0, 0, 0, 0});
+
+ int[] vals = {10, 20, 30, 40, 50, 60};
+ for (int i=0; i<ai.size(); ++i)
+ ai.set(i, vals[i]);
+ compareContainers(ai, vals);
+
+ // Check return
+ compareContainers(cpp11_li_std_array.arrayOutVal(), new int[] {-2, -1, 0, 0, 1, 2});
+ compareContainers(cpp11_li_std_array.arrayOutConstRef(), new int[] {-2, -1, 0, 0, 1, 2});
+ compareContainers(cpp11_li_std_array.arrayOutRef(), new int[] {-2, -1, 0, 0, 1, 2});
+ compareContainers(cpp11_li_std_array.arrayOutPtr(), new int[] {-2, -1, 0, 0, 1, 2});
+
+ // Check passing arguments
+ ai = cpp11_li_std_array.arrayInVal(ToArray6(new int[] {9, 8, 7, 6, 5, 4}));
+ compareContainers(ai, new int[] {90, 80, 70, 60, 50, 40});
+
+ ai = cpp11_li_std_array.arrayInConstRef(ToArray6(new int[] {9, 8, 7, 6, 5, 4}));
+ compareContainers(ai, new int[] {90, 80, 70, 60, 50, 40});
+
+ ai = new ArrayInt6(ToArray6(new int[] {9, 8, 7, 6, 5, 4}));
+ cpp11_li_std_array.arrayInRef(ai);
+ compareContainers(ai, new int[] {90, 80, 70, 60, 50, 40});
+
+ ai = new ArrayInt6(ToArray6(new int[] {9, 8, 7, 6, 5, 4}));
+ cpp11_li_std_array.arrayInPtr(ai);
+ compareContainers(ai, new int[] {90, 80, 70, 60, 50, 40});
+
+ // fill
+ ai.fill(111);
+ compareContainers(ai, new int[] {111, 111, 111, 111, 111, 111});
+
+ // out of range errors
+ try {
+ ai.set((int)ai.size(), 0);
+ throw new RuntimeException("Out of range exception not caught");
+ } catch(IndexOutOfBoundsException e) {
+ }
+ try {
+ ai.set(-1, 0);
+ throw new RuntimeException("Out of range exception not caught");
+ } catch(IndexOutOfBoundsException e) {
+ }
+ }
+}
--- /dev/null
+import cpp11_result_of.*;
+
+public class cpp11_result_of_runme {
+
+ static {
+ try {
+ System.loadLibrary("cpp11_result_of");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[])
+ {
+ double result = cpp11_result_of.test_result(cpp11_result_ofConstants.SQUARE, 3.0);
+ if (result != 9.0)
+ throw new RuntimeException("test_result(square, 3.0) is not 9.0. Got: " + Double.toString(result));
+
+ result = cpp11_result_of.test_result_alternative1(cpp11_result_ofConstants.SQUARE, 3.0);
+ if (result != 9.0)
+ throw new RuntimeException("test_result_alternative1(square, 3.0) is not 9.0. Got: " + Double.toString(result));
+ }
+}
--- /dev/null
+import cpp11_strongly_typed_enumerations.*;
+
+public class cpp11_strongly_typed_enumerations_runme {
+
+ static {
+ try {
+ System.loadLibrary("cpp11_strongly_typed_enumerations");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static int enumCheck(int actual, int expected) {
+ if (actual != expected)
+ throw new RuntimeException("Enum value mismatch. Expected " + expected + " Actual: " + actual);
+ return expected + 1;
+ }
+
+ public static void main(String argv[]) {
+ int val = 0;
+ val = enumCheck(Enum1.Val1.swigValue(), val);
+ val = enumCheck(Enum1.Val2.swigValue(), val);
+ val = enumCheck(Enum1.Val3.swigValue(), 13);
+ val = enumCheck(Enum1.Val4.swigValue(), val);
+ val = enumCheck(Enum1.Val5a.swigValue(), 13);
+ val = enumCheck(Enum1.Val6a.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Enum2.Val1.swigValue(), val);
+ val = enumCheck(Enum2.Val2.swigValue(), val);
+ val = enumCheck(Enum2.Val3.swigValue(), 23);
+ val = enumCheck(Enum2.Val4.swigValue(), val);
+ val = enumCheck(Enum2.Val5b.swigValue(), 23);
+ val = enumCheck(Enum2.Val6b.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Enum4.Val1.swigValue(), val);
+ val = enumCheck(Enum4.Val2.swigValue(), val);
+ val = enumCheck(Enum4.Val3.swigValue(), 43);
+ val = enumCheck(Enum4.Val4.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Enum5.Val1.swigValue(), val);
+ val = enumCheck(Enum5.Val2.swigValue(), val);
+ val = enumCheck(Enum5.Val3.swigValue(), 53);
+ val = enumCheck(Enum5.Val4.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Enum6.Val1.swigValue(), val);
+ val = enumCheck(Enum6.Val2.swigValue(), val);
+ val = enumCheck(Enum6.Val3.swigValue(), 63);
+ val = enumCheck(Enum6.Val4.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Enum7td.Val1.swigValue(), val);
+ val = enumCheck(Enum7td.Val2.swigValue(), val);
+ val = enumCheck(Enum7td.Val3.swigValue(), 73);
+ val = enumCheck(Enum7td.Val4.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Enum8.Val1.swigValue(), val);
+ val = enumCheck(Enum8.Val2.swigValue(), val);
+ val = enumCheck(Enum8.Val3.swigValue(), 83);
+ val = enumCheck(Enum8.Val4.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Enum10.Val1.swigValue(), val);
+ val = enumCheck(Enum10.Val2.swigValue(), val);
+ val = enumCheck(Enum10.Val3.swigValue(), 103);
+ val = enumCheck(Enum10.Val4.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Class1.Enum12.Val1.swigValue(), 1121);
+ val = enumCheck(Class1.Enum12.Val2.swigValue(), 1122);
+ val = enumCheck(Class1.Enum12.Val3.swigValue(), val);
+ val = enumCheck(Class1.Enum12.Val4.swigValue(), val);
+ val = enumCheck(Class1.Enum12.Val5c.swigValue(), 1121);
+ val = enumCheck(Class1.Enum12.Val6c.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Class1.Enum13.Val1.swigValue(), 1131);
+ val = enumCheck(Class1.Enum13.Val2.swigValue(), 1132);
+ val = enumCheck(Class1.Enum13.Val3.swigValue(), val);
+ val = enumCheck(Class1.Enum13.Val4.swigValue(), val);
+ val = enumCheck(Class1.Enum13.Val5d.swigValue(), 1131);
+ val = enumCheck(Class1.Enum13.Val6d.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Class1.Enum14.Val1.swigValue(), 1141);
+ val = enumCheck(Class1.Enum14.Val2.swigValue(), 1142);
+ val = enumCheck(Class1.Enum14.Val3.swigValue(), val);
+ val = enumCheck(Class1.Enum14.Val4.swigValue(), val);
+ val = enumCheck(Class1.Enum14.Val5e.swigValue(), 1141);
+ val = enumCheck(Class1.Enum14.Val6e.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Class1.Struct1.Enum12.Val1.swigValue(), 3121);
+ val = enumCheck(Class1.Struct1.Enum12.Val2.swigValue(), 3122);
+ val = enumCheck(Class1.Struct1.Enum12.Val3.swigValue(), val);
+ val = enumCheck(Class1.Struct1.Enum12.Val4.swigValue(), val);
+ val = enumCheck(Class1.Struct1.Enum12.Val5f.swigValue(), 3121);
+ val = enumCheck(Class1.Struct1.Enum12.Val6f.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Class1.Struct1.Enum13.Val1.swigValue(), 3131);
+ val = enumCheck(Class1.Struct1.Enum13.Val2.swigValue(), 3132);
+ val = enumCheck(Class1.Struct1.Enum13.Val3.swigValue(), val);
+ val = enumCheck(Class1.Struct1.Enum13.Val4.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Class1.Struct1.Enum14.Val1.swigValue(), 3141);
+ val = enumCheck(Class1.Struct1.Enum14.Val2.swigValue(), 3142);
+ val = enumCheck(Class1.Struct1.Enum14.Val3.swigValue(), val);
+ val = enumCheck(Class1.Struct1.Enum14.Val4.swigValue(), val);
+ val = enumCheck(Class1.Struct1.Enum14.Val5g.swigValue(), 3141);
+ val = enumCheck(Class1.Struct1.Enum14.Val6g.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Class2.Enum12.Val1.swigValue(), 2121);
+ val = enumCheck(Class2.Enum12.Val2.swigValue(), 2122);
+ val = enumCheck(Class2.Enum12.Val3.swigValue(), val);
+ val = enumCheck(Class2.Enum12.Val4.swigValue(), val);
+ val = enumCheck(Class2.Enum12.Val5h.swigValue(), 2121);
+ val = enumCheck(Class2.Enum12.Val6h.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Class2.Enum13.Val1.swigValue(), 2131);
+ val = enumCheck(Class2.Enum13.Val2.swigValue(), 2132);
+ val = enumCheck(Class2.Enum13.Val3.swigValue(), val);
+ val = enumCheck(Class2.Enum13.Val4.swigValue(), val);
+ val = enumCheck(Class2.Enum13.Val5i.swigValue(), 2131);
+ val = enumCheck(Class2.Enum13.Val6i.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Class2.Enum14.Val1.swigValue(), 2141);
+ val = enumCheck(Class2.Enum14.Val2.swigValue(), 2142);
+ val = enumCheck(Class2.Enum14.Val3.swigValue(), val);
+ val = enumCheck(Class2.Enum14.Val4.swigValue(), val);
+ val = enumCheck(Class2.Enum14.Val5j.swigValue(), 2141);
+ val = enumCheck(Class2.Enum14.Val6j.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Class2.Struct1.Enum12.Val1.swigValue(), 4121);
+ val = enumCheck(Class2.Struct1.Enum12.Val2.swigValue(), 4122);
+ val = enumCheck(Class2.Struct1.Enum12.Val3.swigValue(), val);
+ val = enumCheck(Class2.Struct1.Enum12.Val4.swigValue(), val);
+ val = enumCheck(Class2.Struct1.Enum12.Val5k.swigValue(), 4121);
+ val = enumCheck(Class2.Struct1.Enum12.Val6k.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Class2.Struct1.Enum13.Val1.swigValue(), 4131);
+ val = enumCheck(Class2.Struct1.Enum13.Val2.swigValue(), 4132);
+ val = enumCheck(Class2.Struct1.Enum13.Val3.swigValue(), val);
+ val = enumCheck(Class2.Struct1.Enum13.Val4.swigValue(), val);
+ val = enumCheck(Class2.Struct1.Enum13.Val5l.swigValue(), 4131);
+ val = enumCheck(Class2.Struct1.Enum13.Val6l.swigValue(), val);
+
+ val = 0;
+ val = enumCheck(Class2.Struct1.Enum14.Val1.swigValue(), 4141);
+ val = enumCheck(Class2.Struct1.Enum14.Val2.swigValue(), 4142);
+ val = enumCheck(Class2.Struct1.Enum14.Val3.swigValue(), val);
+ val = enumCheck(Class2.Struct1.Enum14.Val4.swigValue(), val);
+ val = enumCheck(Class2.Struct1.Enum14.Val5m.swigValue(), 4141);
+ val = enumCheck(Class2.Struct1.Enum14.Val6m.swigValue(), val);
+
+ Class1 class1 = new Class1();
+ enumCheck(class1.class1Test1(Enum1.Val5a).swigValue(), 13);
+ enumCheck(class1.class1Test2(Class1.Enum12.Val5c).swigValue(), 1121);
+ enumCheck(class1.class1Test3(Class1.Struct1.Enum12.Val5f).swigValue(), 3121);
+
+ enumCheck(cpp11_strongly_typed_enumerations.globalTest1(Enum1.Val5a).swigValue(), 13);
+ enumCheck(cpp11_strongly_typed_enumerations.globalTest2(Class1.Enum12.Val5c).swigValue(), 1121);
+ enumCheck(cpp11_strongly_typed_enumerations.globalTest3(Class1.Struct1.Enum12.Val5f).swigValue(), 3121);
+ }
+}
--- /dev/null
+import cpp11_strongly_typed_enumerations_simple.*;
+
+public class cpp11_strongly_typed_enumerations_simple_runme {
+
+ static {
+ try {
+ System.loadLibrary("cpp11_strongly_typed_enumerations_simple");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static int enumCheck(int actual, int expected) {
+ if (actual != expected)
+ throw new RuntimeException("Enum value mismatch. Expected " + expected + " Actual: " + actual);
+ return expected + 1;
+ }
+
+ public static void main(String argv[]) {
+ int val = 0;
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum1_Val1, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum1_Val2, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum1_Val3, 13);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum1_Val4, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum1_Val5a, 13);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum1_Val6a, val);
+
+ val = 0;
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum2_Val1, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum2_Val2, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum2_Val3, 23);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum2_Val4, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum2_Val5b, 23);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum2_Val6b, val);
+
+ val = 0;
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Val1, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Val2, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Val3, 43);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Val4, val);
+
+ val = 0;
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum5_Val1, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum5_Val2, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum5_Val3, 53);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum5_Val4, val);
+
+ val = 0;
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum6_Val1, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum6_Val2, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum6_Val3, 63);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum6_Val4, val);
+
+ val = 0;
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum7td_Val1, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum7td_Val2, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum7td_Val3, 73);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum7td_Val4, val);
+
+ val = 0;
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum8_Val1, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum8_Val2, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum8_Val3, 83);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum8_Val4, val);
+
+ val = 0;
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum10_Val1, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum10_Val2, val);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum10_Val3, 103);
+ val = enumCheck(cpp11_strongly_typed_enumerations_simple.Enum10_Val4, val);
+
+ val = 0;
+ val = enumCheck(Class1.Enum12_Val1, 1121);
+ val = enumCheck(Class1.Enum12_Val2, 1122);
+ val = enumCheck(Class1.Enum12_Val3, val);
+ val = enumCheck(Class1.Enum12_Val4, val);
+ val = enumCheck(Class1.Enum12_Val5c, 1121);
+ val = enumCheck(Class1.Enum12_Val6c, val);
+
+ val = 0;
+ val = enumCheck(Class1.Val1, 1131);
+ val = enumCheck(Class1.Val2, 1132);
+ val = enumCheck(Class1.Val3, val);
+ val = enumCheck(Class1.Val4, val);
+ val = enumCheck(Class1.Val5d, 1131);
+ val = enumCheck(Class1.Val6d, val);
+
+ val = 0;
+ val = enumCheck(Class1.Enum14_Val1, 1141);
+ val = enumCheck(Class1.Enum14_Val2, 1142);
+ val = enumCheck(Class1.Enum14_Val3, val);
+ val = enumCheck(Class1.Enum14_Val4, val);
+ val = enumCheck(Class1.Enum14_Val5e, 1141);
+ val = enumCheck(Class1.Enum14_Val6e, val);
+
+ val = 0;
+ val = enumCheck(Class1.Struct1.Enum12_Val1, 3121);
+ val = enumCheck(Class1.Struct1.Enum12_Val2, 3122);
+ val = enumCheck(Class1.Struct1.Enum12_Val3, val);
+ val = enumCheck(Class1.Struct1.Enum12_Val4, val);
+ val = enumCheck(Class1.Struct1.Enum12_Val5f, 3121);
+ val = enumCheck(Class1.Struct1.Enum12_Val6f, val);
+
+ val = 0;
+ val = enumCheck(Class1.Struct1.Val1, 3131);
+ val = enumCheck(Class1.Struct1.Val2, 3132);
+ val = enumCheck(Class1.Struct1.Val3, val);
+ val = enumCheck(Class1.Struct1.Val4, val);
+
+ val = 0;
+ val = enumCheck(Class1.Struct1.Enum14_Val1, 3141);
+ val = enumCheck(Class1.Struct1.Enum14_Val2, 3142);
+ val = enumCheck(Class1.Struct1.Enum14_Val3, val);
+ val = enumCheck(Class1.Struct1.Enum14_Val4, val);
+ val = enumCheck(Class1.Struct1.Enum14_Val5g, 3141);
+ val = enumCheck(Class1.Struct1.Enum14_Val6g, val);
+
+ val = 0;
+ val = enumCheck(Class2.Enum12_Val1, 2121);
+ val = enumCheck(Class2.Enum12_Val2, 2122);
+ val = enumCheck(Class2.Enum12_Val3, val);
+ val = enumCheck(Class2.Enum12_Val4, val);
+ val = enumCheck(Class2.Enum12_Val5h, 2121);
+ val = enumCheck(Class2.Enum12_Val6h, val);
+
+ val = 0;
+ val = enumCheck(Class2.Val1, 2131);
+ val = enumCheck(Class2.Val2, 2132);
+ val = enumCheck(Class2.Val3, val);
+ val = enumCheck(Class2.Val4, val);
+ val = enumCheck(Class2.Val5i, 2131);
+ val = enumCheck(Class2.Val6i, val);
+
+ val = 0;
+ val = enumCheck(Class2.Enum14_Val1, 2141);
+ val = enumCheck(Class2.Enum14_Val2, 2142);
+ val = enumCheck(Class2.Enum14_Val3, val);
+ val = enumCheck(Class2.Enum14_Val4, val);
+ val = enumCheck(Class2.Enum14_Val5j, 2141);
+ val = enumCheck(Class2.Enum14_Val6j, val);
+
+ val = 0;
+ val = enumCheck(Class2.Struct1.Enum12_Val1, 4121);
+ val = enumCheck(Class2.Struct1.Enum12_Val2, 4122);
+ val = enumCheck(Class2.Struct1.Enum12_Val3, val);
+ val = enumCheck(Class2.Struct1.Enum12_Val4, val);
+ val = enumCheck(Class2.Struct1.Enum12_Val5k, 4121);
+ val = enumCheck(Class2.Struct1.Enum12_Val6k, val);
+
+ val = 0;
+ val = enumCheck(Class2.Struct1.Val1, 4131);
+ val = enumCheck(Class2.Struct1.Val2, 4132);
+ val = enumCheck(Class2.Struct1.Val3, val);
+ val = enumCheck(Class2.Struct1.Val4, val);
+ val = enumCheck(Class2.Struct1.Val5l, 4131);
+ val = enumCheck(Class2.Struct1.Val6l, val);
+
+ val = 0;
+ val = enumCheck(Class2.Struct1.Enum14_Val1, 4141);
+ val = enumCheck(Class2.Struct1.Enum14_Val2, 4142);
+ val = enumCheck(Class2.Struct1.Enum14_Val3, val);
+ val = enumCheck(Class2.Struct1.Enum14_Val4, val);
+ val = enumCheck(Class2.Struct1.Enum14_Val5m, 4141);
+ val = enumCheck(Class2.Struct1.Enum14_Val6m, val);
+
+ Class1 class1 = new Class1();
+ enumCheck(class1.class1Test1(cpp11_strongly_typed_enumerations_simple.Enum1_Val5a), 13);
+ enumCheck(class1.class1Test2(Class1.Enum12_Val5c), 1121);
+ enumCheck(class1.class1Test3(Class1.Struct1.Enum12_Val5f), 3121);
+
+ enumCheck(cpp11_strongly_typed_enumerations_simple.globalTest1(cpp11_strongly_typed_enumerations_simple.Enum1_Val5a), 13);
+ enumCheck(cpp11_strongly_typed_enumerations_simple.globalTest2(Class1.Enum12_Val5c), 1121);
+ enumCheck(cpp11_strongly_typed_enumerations_simple.globalTest3(Class1.Struct1.Enum12_Val5f), 3121);
+ }
+}
--- /dev/null
+import cpp11_thread_local.*;
+
+public class cpp11_thread_local_runme {
+
+ static {
+ try {
+ System.loadLibrary("cpp11_thread_local");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[])
+ {
+ if (ThreadLocals.getStval() != 11)
+ throw new RuntimeException();
+ if (ThreadLocals.getTsval() != 22)
+ throw new RuntimeException();
+ if (ThreadLocals.tscval99 != 99)
+ throw new RuntimeException();
+
+ cpp11_thread_local.setEtval(-11);
+ if (cpp11_thread_local.getEtval() != -11)
+ throw new RuntimeException();
+
+ cpp11_thread_local.setStval(-22);
+ if (cpp11_thread_local.getStval() != -22)
+ throw new RuntimeException();
+
+ cpp11_thread_local.setTsval(-33);
+ if (cpp11_thread_local.getTsval() != -33)
+ throw new RuntimeException();
+
+ cpp11_thread_local.setEtval(-44);
+ if (cpp11_thread_local.getEtval() != -44)
+ throw new RuntimeException();
+
+ cpp11_thread_local.setTeval(-55);
+ if (cpp11_thread_local.getTeval() != -55)
+ throw new RuntimeException();
+
+ cpp11_thread_local.setEctval(-55);
+ if (cpp11_thread_local.getEctval() != -55)
+ throw new RuntimeException();
+
+ cpp11_thread_local.setEcpptval(-66);
+ if (cpp11_thread_local.getEcpptval() != -66)
+ throw new RuntimeException();
+ }
+}
--- /dev/null
+import cpp11_type_aliasing.*;
+
+public class cpp11_type_aliasing_runme {
+
+ static {
+ try {
+ System.loadLibrary("cpp11_type_aliasing");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+ Halide_Target ht = new GeneratorBase().getTarget();
+ Target x = ht.getValue();
+ if (x.getBits() != 32)
+ throw new RuntimeException("Incorrect bits");
+ }
+}
throw new RuntimeException("Protected destructor exception should have been thrown");
} catch (UnsupportedOperationException e) {
}
-
- // calling private destructor test
- try {
- FFF f = new FFF();
- f.delete();
- throw new RuntimeException("Private destructor exception should have been thrown");
- } catch (UnsupportedOperationException e) {
- }
}
}
--- /dev/null
+
+import derived_nested.*;
+
+public class derived_nested_runme {
+
+ static {
+ try {
+ System.loadLibrary("derived_nested");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+ BB outer = new BB();
+ BB.DD d = new BB.DD();
+ BB.EE e = new BB.EE();
+ outer.getFf_instance().setZ(outer.getFf_instance().getX());
+ outer.useEE(e);
+ }
+}
\ No newline at end of file
Callback callback = new DirectorBinaryStringCallback();
caller.setCallback(callback);
int sum = caller.call();
+ int sumData = caller.callWriteData();
caller.delCallback();
if (sum != 9*2*8 + 13*3*5)
throw new RuntimeException("Unexpected sum: " + sum);
+ if (sumData != 9*2*8)
+ throw new RuntimeException("Unexpected sum: " + sum);
+
new Callback().run(null, null);
callback = new DirectorBinaryStringCallback();
caller.setCallback(callback);
for (int i = 0; i < dataBufferBB.length; i++)
dataBufferBB[i] = (byte)(dataBufferBB[i] * 3);
}
+
+ @Override
+ public void writeData(byte[] dataBufferAA)
+ {
+ if (dataBufferAA != null)
+ for (int i = 0; i < dataBufferAA.length; i++)
+ dataBufferAA[i] = (byte)(dataBufferAA[i] * 2);
+ }
}
Package packag = klass.getPackage();
String simpleName = null;
if (packag != null)
- simpleName = fullName.replaceAll(packag.getName() + ".", "");
+ simpleName = fullName.replaceAll(packag.getName() + "\\.", "");
else
simpleName = fullName;
return simpleName;
--- /dev/null
+
+import director_nested_class.*;
+
+public class director_nested_class_runme {
+
+ static {
+ try {
+ System.loadLibrary("director_nested_class");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+
+ director_nested_class_Derived d = new director_nested_class_Derived();
+
+ if (DirectorOuter.callMethod(d, 999) != 9990) {
+ throw new RuntimeException("callMethod(999) failed");
+ }
+
+ director_nested_class_DerivedInnerInner dinner = new director_nested_class_DerivedInnerInner();
+
+ if (DirectorOuter.callInnerInnerMethod(dinner, 999) != 999000) {
+ throw new RuntimeException("callMethod(999) failed");
+ }
+ }
+}
+
+class director_nested_class_Derived extends DirectorOuter.DirectorInner {
+ public int vmethod(int input) {
+ return input * 10;
+ }
+}
+
+class director_nested_class_DerivedInnerInner extends DirectorOuter.DirectorInner.DirectorInnerInner {
+ public int innervmethod(int input) {
+ return input * 1000;
+ }
+}
--- /dev/null
+
+import director_pass_by_value.*;
+
+public class director_pass_by_value_runme {
+
+ static {
+ try {
+ System.loadLibrary("director_pass_by_value");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ private static void WaitForGC() {
+ System.gc();
+ System.runFinalization();
+ try {
+ java.lang.Thread.sleep(10);
+ } catch (java.lang.InterruptedException e) {
+ }
+ }
+
+ public static void main(String argv[]) {
+ Caller caller = new Caller();
+ caller.call_virtualMethod(new director_pass_by_value_Derived());
+ {
+ int countdown = 5;
+ while (true) {
+ WaitForGC();
+ if (--countdown == 0)
+ break;
+ };
+ }
+ // bug was the passByVal 'global' object was destroyed after the call to virtualMethod had finished.
+ int ret = director_pass_by_value_runme.passByVal.getVal();
+ if (ret != 0x12345678)
+ throw new RuntimeException("Bad return value, got " + Integer.toHexString(ret));
+ }
+
+ static PassedByValue passByVal;
+}
+
+class director_pass_by_value_Derived extends DirectorPassByValueAbstractBase {
+ public void virtualMethod(PassedByValue pbv) {
+ director_pass_by_value_runme.passByVal = pbv;
+ }
+}
--- /dev/null
+
+import director_ref.*;
+
+public class director_ref_runme {
+
+ static {
+ try {
+ System.loadLibrary("director_ref");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+ director_ref_MyFoo a = new director_ref_MyFoo();
+ if (a.GetRefCount() != 1) {
+ throw new RuntimeException ( "Refcount test 1 failed." );
+ }
+
+ // Make sure director logic still works.
+ if (!a.GetMsg().equals("director_ref_MyFoo-default")) {
+ throw new RuntimeException ( "Test 1 failed" );
+ }
+ if (!a.GetMsg("boo").equals("director_ref_MyFoo-boo")) {
+ throw new RuntimeException ( "Test 2 failed" );
+ }
+
+ a.delete(); // should delete the object.
+ if (a.cppDeleted != true) {
+ throw new RuntimeException ( "Unref test 1 failed." );
+ }
+
+ a = new director_ref_MyFoo();
+ FooPtr p = new FooPtr(a);
+ if (a.GetRefCount() != 2) {
+ throw new RuntimeException ( "Refcount test 2 failed." );
+ }
+ a.delete(); // Shouldn't actually delete the underlying object
+ if (a.cppDeleted) {
+ throw new RuntimeException ( "Unref test 2 failed." );
+ }
+ if (p.GetOwnedRefCount() != 1) {
+ throw new RuntimeException ( "Unref test 3 failed." );
+ }
+ p.Reset(); // Now it should be deleted on the cpp side.
+ // We can't check cppDeleted because the director will stop
+ // working after a delete() call.
+ if (p.GetOwnedRefCount() != 0) {
+ throw new RuntimeException ( "Unref test 4 failed." );
+ }
+ }
+}
+
+class director_ref_MyFoo extends Foo {
+ public director_ref_MyFoo() {
+ super();
+ }
+ public director_ref_MyFoo(int i) {
+ super(i);
+ }
+ public String Msg(String msg) {
+ return "director_ref_MyFoo-" + msg;
+ }
+ public void OnDelete() {
+ cppDeleted = true;
+ }
+
+ public boolean cppDeleted = false;
+}
+
}
}
- public static void main(String argv[]) {
- director_smartptr_MyBarFoo myBarFoo =
- new director_smartptr_MyBarFoo();
+ private static void check(String got, String expected) {
+ if (!got.equals(expected))
+ throw new RuntimeException("Failed, got: " + got + " expected: " + expected);
}
+ public static void main(String argv[]) {
+ director_smartptr.FooBar fooBar = new director_smartptr.FooBar();
+
+ director_smartptr.Foo myBarFoo = new director_smartptr_MyBarFoo();
+ check(myBarFoo.ping(), "director_smartptr_MyBarFoo.ping()");
+ check(director_smartptr.Foo.callPong(myBarFoo), "director_smartptr_MyBarFoo.pong();director_smartptr_MyBarFoo.ping()");
+ check(director_smartptr.Foo.callUpcall(myBarFoo, fooBar), "override;Bar::Foo2::Foo2Bar()");
+
+ director_smartptr.Foo myFoo = myBarFoo.makeFoo();
+ check(myFoo.pong(), "Foo::pong();Foo::ping()");
+ check(director_smartptr.Foo.callPong(myFoo), "Foo::pong();Foo::ping()");
+ check(myFoo.upcall(fooBar), "Bar::Foo2::Foo2Bar()");
+
+ director_smartptr.Foo myFoo2 = new director_smartptr.Foo().makeFoo();
+ check(myFoo2.pong(), "Foo::pong();Foo::ping()");
+ check(director_smartptr.Foo.callPong(myFoo2), "Foo::pong();Foo::ping()");
+ }
}
class director_smartptr_MyBarFoo extends director_smartptr.Foo {
@Override
public String ping() {
- return "director_smartptr_MyBarFoo.ping();";
+ return "director_smartptr_MyBarFoo.ping()";
}
@Override
}
@Override
- public String fooBar(director_smartptr.FooBar fooBar) {
- return fooBar.FooBarDo();
+ public String upcall(director_smartptr.FooBar fooBarPtr) {
+ return "override;" + fooBarPtr.FooBarDo();
}
@Override
public director_smartptr.Foo makeFoo() {
return new director_smartptr.Foo();
}
-
- @Override
- public director_smartptr.FooBar makeFooBar() {
- return new director_smartptr.FooBar();
- }
-}
\ No newline at end of file
+}
// Note it is possible to downcast y with a Java cast.
String a = dynamic_cast.do_test((Bar)y);
if (!a.equals("Bar::test")) {
- System.err.println("Failed!");
- System.exit(1);
+ throw new RuntimeException("Failed!");
}
}
}
--- /dev/null
+
+import friends_template.*;
+
+public class friends_template_runme {
+
+ static {
+ try {
+ System.loadLibrary("friends_template");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+ friends_template.OperatorOutputDouble(1.1, new MyClassDouble());
+ friends_template.OperatorInputDouble(1.1, new MyClassDouble());
+ friends_template.funk_hidden(1.1, new MyClassDouble());
+ friends_template.funk_seen(1.1, new MyClassDouble());
+
+ friends_template.TemplateFriendHiddenInt(0);
+ friends_template.TemplateFriendSeenInt(0, 0);
+
+ SWIGTYPE_p_MyClassT_int_t myClassInt = friends_template.makeMyClassInt();
+ friends_template.OperatorInputInt(1, myClassInt);
+ friends_template.OperatorFunkSeenInt(1.1, myClassInt);
+ }
+}
{
// Compilation will ensure the number of arguments and type are correct.
// Then check the return value is the same as the value given to the ignored parameter.
- if (!ignore_parameter.jaguar(200, 0.0).equals("hello")) { System.err.println("Runtime Error in jaguar()");}
- if (ignore_parameter.lotus("fast", 0.0) != 101) { System.err.println("Runtime Error in lotus()");}
- if (ignore_parameter.tvr("fast", 200) != 8.8) { System.err.println("Runtime Error in tvr()");}
- if (ignore_parameter.ferrari() != 101) { System.err.println("Runtime Error in ferrari()");}
+ if (!ignore_parameter.jaguar(200, 0.0).equals("hello")) { throw new RuntimeException("Runtime Error in jaguar()");}
+ if (ignore_parameter.lotus("fast", 0.0) != 101) { throw new RuntimeException("Runtime Error in lotus()");}
+ if (ignore_parameter.tvr("fast", 200) != 8.8) { throw new RuntimeException("Runtime Error in tvr()");}
+ if (ignore_parameter.ferrari() != 101) { throw new RuntimeException("Runtime Error in ferrari()");}
SportsCars sc = new SportsCars();
- if (!sc.daimler(200, 0.0).equals("hello")) { System.err.println("Runtime Error in daimler()");}
- if (sc.astonmartin("fast", 0.0) != 101) { System.err.println("Runtime Error in astonmartin()");}
- if (sc.bugatti("fast", 200) != 8.8) { System.err.println("Runtime Error in bugatti()");}
- if (sc.lamborghini() != 101) { System.err.println("Runtime Error in lamborghini()");}
+ if (!sc.daimler(200, 0.0).equals("hello")) { throw new RuntimeException("Runtime Error in daimler()");}
+ if (sc.astonmartin("fast", 0.0) != 101) { throw new RuntimeException("Runtime Error in astonmartin()");}
+ if (sc.bugatti("fast", 200) != 8.8) { throw new RuntimeException("Runtime Error in bugatti()");}
+ if (sc.lamborghini() != 101) { throw new RuntimeException("Runtime Error in lamborghini()");}
// Check constructors are also generated correctly
MiniCooper mc = new MiniCooper(200, 0.0);
--- /dev/null
+import java_director_exception_feature_nspacePackage.*;
+import java_director_exception_feature_nspacePackage.MyNS.*;
+
+class java_director_exception_feature_nspace_Consts {
+ public static final String PINGEXCP1 = "Ping MyJavaException1"; // should get translated through an int on ping
+ public static final String PINGEXCP2 = "Ping MyJavaException2";
+
+ public static final String PONGEXCP1 = "Pong MyJavaException1";
+ public static final String PONGEXCP2 = "Pong MyJavaException2";
+ public static final String PONGUNEXPECTED = "Pong MyJavaUnexpected";
+ public static final String TRANSLATED_NPE = "Pong Translated NPE";
+
+ public static final String GENERICPONGEXCP1 = "GenericPong Wrapped MyJavaException1";
+ public static final String GENERICPONGEXCP2 = "GenericPong New Checked Exception";
+ public static final String GENERICPONGEXCP3 = "GenericPong New Unchecked Exception";
+ public static final String GENERICPONGEXCP4 = "GenericPong New Exception Without String ctor";
+}
+
+// an exception not mentioned or wrapped by the swig interface,
+// to reconstruct using generic DirectorException handling
+class java_director_exception_feature_nspace_NewCheckedException extends Exception {
+ public java_director_exception_feature_nspace_NewCheckedException(String s) {
+ super(s);
+ }
+}
+
+// an exception not mentioned or wrapped by the swig interface,
+// to reconstruct using generic DirectorException handling
+class java_director_exception_feature_nspace_NewUncheckedException extends RuntimeException {
+ public java_director_exception_feature_nspace_NewUncheckedException(String s) {
+ super(s);
+ }
+}
+
+// an exception not constructible from a string,
+// to test DirectorException fallback reconstruction
+class java_director_exception_feature_nspace_UnconstructibleException extends Exception {
+ private int extrastate;
+ public java_director_exception_feature_nspace_UnconstructibleException(int a, String s) {
+ super(s);
+ extrastate = a;
+ }
+}
+
+class java_director_exception_feature_nspace_MyFooDirectorImpl extends Foo {
+
+ public java_director_exception_feature_nspace_MyFooDirectorImpl() { };
+
+ @Override
+ public String ping(int excp) throws MyJavaException1, MyJavaException2 {
+ if (excp == 1) throw new MyJavaException1(java_director_exception_feature_nspace_Consts.PINGEXCP1);
+ if (excp == 2) throw new MyJavaException2(java_director_exception_feature_nspace_Consts.PINGEXCP2);
+ return "Ping director returned";
+ }
+ @Override
+ public String pong(int excp) throws MyJavaException1, MyJavaException2, MyJavaUnexpected {
+ if (excp == 1) throw new MyJavaException1(java_director_exception_feature_nspace_Consts.PONGEXCP1);
+ if (excp == 2) throw new MyJavaException2(java_director_exception_feature_nspace_Consts.PONGEXCP2);
+ if (excp == 3) throw new MyJavaUnexpected(java_director_exception_feature_nspace_Consts.PONGUNEXPECTED);
+ if (excp == 4) throw new java.lang.NullPointerException(java_director_exception_feature_nspace_Consts.TRANSLATED_NPE); // should be translated to ::Unexpected
+ return "Pong director returned";
+ }
+
+ @Override
+ public String genericpong(int excp) throws MyJavaException1, java_director_exception_feature_nspace_NewCheckedException, java_director_exception_feature_nspace_UnconstructibleException {
+ if (excp == 1)
+ throw new MyJavaException1(java_director_exception_feature_nspace_Consts.GENERICPONGEXCP1);
+ if (excp == 2)
+ throw new java_director_exception_feature_nspace_NewCheckedException(java_director_exception_feature_nspace_Consts.GENERICPONGEXCP2);
+ if (excp == 3)
+ throw new java_director_exception_feature_nspace_NewUncheckedException(java_director_exception_feature_nspace_Consts.GENERICPONGEXCP3);
+ if (excp == 4)
+ throw new java_director_exception_feature_nspace_UnconstructibleException(1, java_director_exception_feature_nspace_Consts.GENERICPONGEXCP4);
+ return "GenericPong director returned";
+ }
+}
+
+public class java_director_exception_feature_nspace_runme {
+
+ static {
+ try {
+ System.loadLibrary("java_director_exception_feature_nspace");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void fail(String msg) {
+ System.err.println(msg); System.exit(1);
+ }
+ public static void failif(boolean cond, String msg) {
+ if (cond) fail(msg);
+ }
+
+
+ public static void main(String argv[]) {
+
+ Bar b = new Bar(new java_director_exception_feature_nspace_MyFooDirectorImpl());
+ try {
+
+ try { b.ping(0); } catch (Exception e)
+ { fail("Exception should not have been thrown: " + e + " from ping(0)"); }
+ try { b.ping(1); fail("No exception thrown in ping(1)"); } catch (MyJavaException1 e)
+ // Should say "Threw some integer", see java_director_exception_feature.i Foo::ping throws a "1"
+ { failif( ! "Threw some integer".equals(e.getMessage()), "Ping exception not translated through int: '" + e.getMessage() + "'"); }
+ try { b.ping(2); fail("No exception thrown in ping(2)"); } catch (MyJavaException2 e)
+ { failif( ! java_director_exception_feature_nspace_Consts.PINGEXCP2.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'"); }
+
+ try { b.pong(0); } catch (Exception e)
+ { fail("Exception should not have been thrown: " + e + " from pong(0)"); }
+ try { b.pong(1); fail("No exception thrown in pong(1)"); } catch (MyJavaException1 e)
+ { failif( ! java_director_exception_feature_nspace_Consts.PONGEXCP1.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'"); }
+ try { b.pong(2); fail("No exception thrown in pong(2)");} catch (MyJavaException2 e)
+ { failif( ! java_director_exception_feature_nspace_Consts.PONGEXCP2.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'"); }
+ try { b.pong(3); fail("No exception thrown in pong(3)");} catch (MyJavaUnexpected e)
+ { failif( ! java_director_exception_feature_nspace_Consts.PONGUNEXPECTED.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'"); }
+ try { b.pong(4); fail("No exception thrown in pong(4)"); } catch (MyJavaUnexpected e)
+ { failif( ! java_director_exception_feature_nspace_Consts.TRANSLATED_NPE.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'"); }
+
+
+ try { b.genericpong(0); }
+ catch (Exception e) {
+ fail("Exception should not have been thrown: " + e + " from genericpong(0)");
+ }
+ try { b.genericpong(1); fail("No exception thrown in genericpong(1)"); }
+ catch (MyJavaException1 e) {
+ failif( ! java_director_exception_feature_nspace_Consts.GENERICPONGEXCP1.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'");
+ }
+ try { b.genericpong(2); fail("No exception thrown in genericpong(2)");}
+ catch (java_director_exception_feature_nspace_NewCheckedException e) {
+ failif( ! java_director_exception_feature_nspace_Consts.GENERICPONGEXCP2.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'");
+ }
+ try { b.genericpong(3); fail("No exception thrown in genericpong(3)");}
+ catch (java_director_exception_feature_nspace_NewUncheckedException e) {
+ failif( ! java_director_exception_feature_nspace_Consts.GENERICPONGEXCP3.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'");
+ }
+ try { b.genericpong(4); fail("No exception thrown in genericpong(4)");}
+ catch (RuntimeException e) {
+ failif ( e.getClass() != RuntimeException.class, "Exception " + e + " is not exactly RumtimeException");
+ failif( ! java_director_exception_feature_nspace_Consts.GENERICPONGEXCP4.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'");
+ }
+ }
+ catch (Exception e) {
+ e.printStackTrace();
+ fail("Unexpected exception thrown or exception not mapped properly");
+ }
+
+ }
+}
--- /dev/null
+
+import java_director_exception_feature.*;
+
+class java_director_exception_feature_Consts {
+ public static final String PINGEXCP1 = "Ping MyJavaException1"; // should get translated through an int on ping
+ public static final String PINGEXCP2 = "Ping MyJavaException2";
+
+ public static final String PONGEXCP1 = "Pong MyJavaException1";
+ public static final String PONGEXCP2 = "Pong MyJavaException2";
+ public static final String PONGUNEXPECTED = "Pong MyJavaUnexpected";
+ public static final String TRANSLATED_NPE = "Pong Translated NPE";
+
+ public static final String GENERICPONGEXCP1 = "GenericPong Wrapped MyJavaException1";
+ public static final String GENERICPONGEXCP2 = "GenericPong New Checked Exception";
+ public static final String GENERICPONGEXCP3 = "GenericPong New Unchecked Exception";
+ public static final String GENERICPONGEXCP4 = "GenericPong New Exception Without String ctor";
+
+}
+
+// an exception not mentioned or wrapped by the swig interface,
+// to reconstruct using generic DirectorException handling
+class NewCheckedException extends Exception {
+ public NewCheckedException(String s) {
+ super(s);
+ }
+}
+
+// an exception not mentioned or wrapped by the swig interface,
+// to reconstruct using generic DirectorException handling
+class NewUncheckedException extends RuntimeException {
+ public NewUncheckedException(String s) {
+ super(s);
+ }
+}
+
+// an exception not constructable from a string,
+// to test DirectorException fallback reconstruction
+class UnconstructableException extends Exception {
+ private int extrastate;
+ public UnconstructableException(int a, String s) {
+ super(s);
+ extrastate = a;
+ }
+}
+
+class java_director_exception_feature_MyFooDirectorImpl extends Foo {
+
+ public java_director_exception_feature_MyFooDirectorImpl() { };
+
+ @Override
+ public String ping(int excp) throws MyJavaException1, MyJavaException2 {
+ if (excp == 1) throw new MyJavaException1(java_director_exception_feature_Consts.PINGEXCP1);
+ if (excp == 2) throw new MyJavaException2(java_director_exception_feature_Consts.PINGEXCP2);
+ return "Ping director returned";
+ }
+ @Override
+ public String pong(int excp) throws MyJavaException1, MyJavaException2, MyJavaUnexpected {
+ if (excp == 1) throw new MyJavaException1(java_director_exception_feature_Consts.PONGEXCP1);
+ if (excp == 2) throw new MyJavaException2(java_director_exception_feature_Consts.PONGEXCP2);
+ if (excp == 3) throw new MyJavaUnexpected(java_director_exception_feature_Consts.PONGUNEXPECTED);
+ if (excp == 4) throw new java.lang.NullPointerException(java_director_exception_feature_Consts.TRANSLATED_NPE); // should be translated to ::Unexpected
+ return "Pong director returned";
+ }
+
+ @Override
+ public String genericpong(int excp) throws MyJavaException1, NewCheckedException, UnconstructableException {
+ if (excp == 1)
+ throw new MyJavaException1(java_director_exception_feature_Consts.GENERICPONGEXCP1);
+ if (excp == 2)
+ throw new NewCheckedException(java_director_exception_feature_Consts.GENERICPONGEXCP2);
+ if (excp == 3)
+ throw new NewUncheckedException(java_director_exception_feature_Consts.GENERICPONGEXCP3);
+ if (excp == 4)
+ throw new UnconstructableException(1, java_director_exception_feature_Consts.GENERICPONGEXCP4);
+ return "GenericPong director returned";
+ }
+}
+
+public class java_director_exception_feature_runme {
+
+ static {
+ try {
+ System.loadLibrary("java_director_exception_feature");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void fail(String msg) {
+ System.err.println(msg); System.exit(1);
+ }
+ public static void failif(boolean cond, String msg) {
+ if (cond) fail(msg);
+ }
+
+
+ public static void main(String argv[]) {
+
+ Bar b = new Bar(new java_director_exception_feature_MyFooDirectorImpl());
+ try {
+
+ try { b.ping(0); } catch (Exception e)
+ { fail("Exception should not have been thrown: " + e + " from ping(0)"); }
+ try { b.ping(1); fail("No exception thrown in ping(1)"); } catch (MyJavaException1 e)
+ // Should say "Threw some integer", see java_director_exception_feature.i Foo::ping throws a "1"
+ { failif( ! "Threw some integer".equals(e.getMessage()), "Ping exception not translated through int: '" + e.getMessage() + "'"); }
+ try { b.ping(2); fail("No exception thrown in ping(2)"); } catch (MyJavaException2 e)
+ { failif( ! java_director_exception_feature_Consts.PINGEXCP2.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'"); }
+
+ try { b.pong(0); } catch (Exception e)
+ { fail("Exception should not have been thrown: " + e + " from pong(0)"); }
+ try { b.pong(1); fail("No exception thrown in pong(1)"); } catch (MyJavaException1 e)
+ { failif( ! java_director_exception_feature_Consts.PONGEXCP1.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'"); }
+ try { b.pong(2); fail("No exception thrown in pong(2)");} catch (MyJavaException2 e)
+ { failif( ! java_director_exception_feature_Consts.PONGEXCP2.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'"); }
+ try { b.pong(3); fail("No exception thrown in pong(3)");} catch (MyJavaUnexpected e)
+ { failif( ! java_director_exception_feature_Consts.PONGUNEXPECTED.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'"); }
+ try { b.pong(4); fail("No exception thrown in pong(4)"); } catch (MyJavaUnexpected e)
+ { failif( ! java_director_exception_feature_Consts.TRANSLATED_NPE.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'"); }
+
+
+ try { b.genericpong(0); }
+ catch (Exception e) {
+ fail("Exception should not have been thrown: " + e + " from genericpong(0)");
+ }
+ try { b.genericpong(1); fail("No exception thrown in genericpong(1)"); }
+ catch (MyJavaException1 e) {
+ failif( ! java_director_exception_feature_Consts.GENERICPONGEXCP1.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'");
+ }
+ try { b.genericpong(2); fail("No exception thrown in genericpong(2)");}
+ catch (NewCheckedException e) {
+ failif( ! java_director_exception_feature_Consts.GENERICPONGEXCP2.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'");
+ }
+ try { b.genericpong(3); fail("No exception thrown in genericpong(3)");}
+ catch (NewUncheckedException e) {
+ failif( ! java_director_exception_feature_Consts.GENERICPONGEXCP3.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'");
+ }
+ try { b.genericpong(4); fail("No exception thrown in genericpong(4)");}
+ catch (RuntimeException e) {
+ failif ( e.getClass() != RuntimeException.class, "Exception " + e + " is not exactly RumtimeException");
+ failif( ! java_director_exception_feature_Consts.GENERICPONGEXCP4.equals(e.getMessage()), "Expected exception has unexpected message: '" + e.getMessage() + "'");
+ }
+
+ }
+ catch (Exception e) {
+ e.printStackTrace();
+ fail("Unexpected exception thrown or exception not mapped properly");
+ }
+
+ }
+}
--- /dev/null
+
+import java_director_ptrclass.*;
+
+public class java_director_ptrclass_runme {
+
+ static {
+ try {
+ System.loadLibrary("java_director_ptrclass");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+ Foo f = new Foo();
+ Foo ft = new TouchingFoo();
+ Baz b = new Baz();
+ if (b.GetTouched()) {
+ throw new RuntimeException ( "Baz should not have been touched yet." );
+ }
+
+ Baz b2 = f.FinalMaybeTouch(b);
+
+ if (b2.GetTouched() || b.GetTouched()) {
+ throw new RuntimeException ( "Baz should not have been touched by Foo." );
+ }
+
+ Baz b3 = ft.FinalMaybeTouch(b);
+
+ if (!b.GetTouched() || !b3.GetTouched() || !b2.GetTouched()) {
+ throw new RuntimeException ( "Baz was not touched by TouchingFoo. This" +
+ " might mean the directorin typemap is not" +
+ " parsing the typemap(jstype, Bar) in its" +
+ " 'descriptor' kwarg correctly." );
+ }
+ }
+}
+
+class TouchingFoo extends Foo {
+ @Override
+ public Baz MaybeTouch(Baz baz_ptr) {
+ baz_ptr.SetTouched();
+ return baz_ptr;
+ }
+}
+
}
}
+ private static void WaitForGC()
+ {
+ System.gc();
+ System.runFinalization();
+ try {
+ java.lang.Thread.sleep(10);
+ } catch (java.lang.InterruptedException e) {
+ }
+ }
+
public static void main(String argv[]) {
QuuxContainer qc = createContainer();
qc = null;
/* Watch qc get reaped, which causes the C++ object to delete
objects from the internal vector */
- System.gc();
- System.runFinalization();
-
- // Give the finalizers a chance to run
- try {
- Thread.sleep(50);
- } catch (InterruptedException e) {
+ {
+ int countdown = 500;
+ int expectedCount = 0;
+ while (true) {
+ WaitForGC();
+ if (--countdown == 0)
+ break;
+ if (Quux.instances() == expectedCount)
+ break;
+ };
+ int actualCount = Quux.instances();
+ if (actualCount != expectedCount)
+ System.err.println("GC failed to run (java_director). Expected count: " + expectedCount + " Actual count: " + actualCount); // Finalizers are not guaranteed to be run and sometimes they just don't
}
- /* Watch the Quux objects formerly in the QuuxContainer object
- get reaped */
- System.gc();
- System.runFinalization();
-
- instances = Quux.instances();
- if (instances != 0)
- throw new RuntimeException("Quux instances should be 0, actually " + instances);
-
/* Test Quux1's director disconnect method rename */
Quux1 quux1 = new Quux1("quux1");
if (quux1.disconnectMethodCalled)
}
public static void testFailed(String str) {
- System.err.println(str + " test failed");
- System.exit(1);
+ throw new RuntimeException(str + " test failed");
}
}
if (byjove[i] != b[i])
throw new RuntimeException("By jove, it failed: [" + new String(b) + "]");
}
+
+ // NIOBUFFER typemap check
+ java.nio.ByteBuffer buf = java.nio.ByteBuffer.allocateDirect(10);
+ java_lib_various.niobuffer_fill_hello(buf);
+ if (
+ (char)buf.get(0) != 'h' ||
+ (char)buf.get(1) != 'e' ||
+ (char)buf.get(2) != 'l' ||
+ (char)buf.get(3) != 'l' ||
+ (char)buf.get(4) != 'o'
+ )
+ throw new RuntimeException(
+ "nio test failed: " +
+ (char)buf.get(0) +
+ (char)buf.get(1) +
+ (char)buf.get(2) +
+ (char)buf.get(3) +
+ (char)buf.get(4)
+ );
}
}
--- /dev/null
+import kwargs_feature.*;
+
+public class kwargs_feature_runme {
+
+ static {
+ try {
+ System.loadLibrary("kwargs_feature");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+ // Check normal overloading still works (no compactdefaultargs) if the kwargs feature is used,
+ // as the kwargs feature is not supported
+ Foo f = new Foo(99);
+ if (f.foo() != 1)
+ throw new RuntimeException("It went wrong");
+ if (Foo.statfoo(2) != 2)
+ throw new RuntimeException("It went wrong");
+ }
+}
// Debugging flag
public final static boolean debug = false;
+ private static void WaitForGC()
+ {
+ System.gc();
+ System.runFinalization();
+ try {
+ java.lang.Thread.sleep(10);
+ } catch (java.lang.InterruptedException e) {
+ }
+ }
+
public static void main(String argv[])
{
if (debug)
// Change loop count to run for a long time to monitor memory
final int loopCount = 5000; //5000;
for (int i=0; i<loopCount; i++) {
- new li_boost_intrusive_ptr_runme().runtest();
+ new li_boost_intrusive_ptr_runme().runtest(i);
System.gc();
System.runFinalization();
try {
int countdown = 50;
while (true) {
- System.gc();
- System.runFinalization();
- try {
- java.lang.Thread.sleep(100);
- } catch (java.lang.InterruptedException e) {
- }
+ WaitForGC();
if (--countdown == 0)
break;
if (Klass.getTotal_count() == 1 && KlassWithoutRefCount.getTotal_count() == 0 &&
KlassDerived.getTotal_count() == 0 && KlassDerivedDerived.getTotal_count() == 1)
// Expect 1 Klass instance - the one global variable (GlobalValue)
break;
- };
+ }
if (Klass.getTotal_count() != 1)
throw new RuntimeException("Klass.total_count=" + Klass.getTotal_count());
if (KlassWithoutRefCount.getTotal_count() != 0)
System.out.println("Finished");
}
- private void runtest() {
+ private int loopCount = 0;
+ private void runtest(int loopCount) {
+ this.loopCount = loopCount;
// simple shared_ptr usage - created in C++
{
Klass k = new Klass("me oh my");
}
private void verifyValue(String expected, String got) {
if (!expected.equals(got))
- throw new RuntimeException("verify value failed. Expected: " + expected + " Got: " + got);
+ throw new RuntimeException("verify value failed. Expected: " + expected + " Got: " + got + " loopCount: " + loopCount);
}
private void verifyCount(int expected, Klass k) {
int got = li_boost_intrusive_ptr.use_count(k);
if (expected != got)
- throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);
+ throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got + " loopCount: " + loopCount);
}
private void verifyCount(int expected, KlassDerived kd) {
int got = li_boost_intrusive_ptr.use_count(kd);
if (expected != got)
- throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);
+ throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got + " loopCount: " + loopCount);
}
private void verifyCount(int expected, KlassDerivedDerived kdd) {
int got = li_boost_intrusive_ptr.use_count(kdd);
if (expected != got)
- throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);
+ throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got + " loopCount: " + loopCount);
}
private void verifyIntrusiveCount(int expected, Klass k) {
int got = k.use_count();
if (expected != got)
- throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);
+ throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got + " loopCount: " + loopCount);
}
private void verifyIntrusiveCount(int expected, KlassDerived kd) {
int got = kd.use_count();
if (expected != got)
- throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);
+ throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got + " loopCount: " + loopCount);
}
private void verifyIntrusiveCount(int expected, KlassDerivedDerived kdd) {
int got = kdd.use_count();
if (expected != got)
- throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);
+ throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got + " loopCount: " + loopCount);
}
}
--- /dev/null
+import li_boost_shared_ptr_attribute.*;
+
+public class li_boost_shared_ptr_attribute_runme {
+ static {
+ try {
+ System.loadLibrary("li_boost_shared_ptr_attribute");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void check(GetSetMe g, int expected) {
+ int got = g.getN();
+ if (got != expected)
+ throw new RuntimeException("GetSetMe value is " + got + " but should be " + expected);
+ }
+
+ public static void check(GetMe g, int expected) {
+ int got = g.getN();
+ if (got != expected)
+ throw new RuntimeException("GetMe value is " + got + " but should be " + expected);
+ }
+
+ public static void main(String argv[])
+ {
+ GetterSetter gs = new GetterSetter(5);
+ check(gs.getMyval(), 25);
+ check(gs.getAddedAttrib(), 25);
+ gs.setAddedAttrib(new GetSetMe(6));
+ check(gs.getMyval(), 6);
+ check(gs.getAddedAttrib(), 6);
+
+ GetterOnly g = new GetterOnly(4);
+ check(g.getMyval(), 16);
+ check(g.getAddedAttrib(), 16);
+ }
+}
HiddenDestructor hidden = HiddenDestructor.create();
hidden.delete();
+
+ HiddenPrivateDestructor hiddenPrivate = HiddenPrivateDestructor.create();
+ if (HiddenPrivateDestructor.getDeleteCount() != 0)
+ throw new RuntimeException("Count should be zero");
+ hiddenPrivate.delete();
+ if (HiddenPrivateDestructor.getDeleteCount() != 1)
+ throw new RuntimeException("Count should be one");
}
}
// Debugging flag
public final static boolean debug = false;
+ private static void WaitForGC()
+ {
+ System.gc();
+ System.runFinalization();
+ try {
+ java.lang.Thread.sleep(10);
+ } catch (java.lang.InterruptedException e) {
+ }
+ }
+
public static void main(String argv[])
{
if (debug)
if (debug)
System.out.println("Nearly finished");
- int countdown = 100;
- while (true) {
- System.gc();
- System.runFinalization();
- try {
- java.lang.Thread.sleep(10);
- } catch (java.lang.InterruptedException e) {
+ {
+ int countdown = 500;
+ int expectedCount = 1;
+ while (true) {
+ WaitForGC();
+ if (--countdown == 0)
+ break;
+ if (Klass.getTotal_count() == expectedCount) // Expect the one global variable (GlobalValue)
+ break;
}
- if (--countdown == 0)
- break;
- if (Klass.getTotal_count() == 1) // Expect 1 instance - the one global variable (GlobalValue)
- break;
- };
- if (Klass.getTotal_count() != 1)
- throw new RuntimeException("Klass.total_count=" + Klass.getTotal_count());
+ int actualCount = Klass.getTotal_count();
+ if (actualCount != expectedCount)
+ System.err.println("GC failed to run (li_boost_shared_ptr). Expected count: " + expectedCount + " Actual count: " + actualCount); // Finalizers are not guaranteed to be run and sometimes they just don't
+ }
int wrapper_count = li_boost_shared_ptr.shared_ptr_wrapper_count();
if (wrapper_count != li_boost_shared_ptr.getNOT_COUNTING())
--- /dev/null
+import li_carrays_cpp.*;
+
+public class li_carrays_cpp_runme {
+
+ static {
+ try {
+ System.loadLibrary("li_carrays_cpp");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) throws Throwable
+ {
+ // array_class
+ {
+ int length = 5;
+ XYArray xyArray = new XYArray(length);
+ for (int i=0; i<length; i++) {
+ XY xy = xyArray.getitem(i);
+ xy.setX(i*10);
+ xy.setY(i*100);
+ xyArray.setitem(i, xy);
+ }
+ for (int i=0; i<length; i++) {
+ Assert(xyArray.getitem(i).getX(), i*10);
+ Assert(xyArray.getitem(i).getY(), i*100);
+ }
+ }
+
+ {
+ // global array variable
+ int length = 3;
+ XY xyArrayPointer = li_carrays_cpp.getGlobalXYArray();
+ XYArray xyArray = XYArray.frompointer(xyArrayPointer);
+ for (int i=0; i<length; i++) {
+ XY xy = xyArray.getitem(i);
+ xy.setX(i*10);
+ xy.setY(i*100);
+ xyArray.setitem(i, xy);
+ }
+ for (int i=0; i<length; i++) {
+ Assert(xyArray.getitem(i).getX(), i*10);
+ Assert(xyArray.getitem(i).getY(), i*100);
+ }
+ }
+
+ // array_functions
+ {
+ int length = 5;
+ AB abArray = li_carrays_cpp.new_ABArray(length);
+ for (int i=0; i<length; i++) {
+ AB ab = li_carrays_cpp.ABArray_getitem(abArray, i);
+ ab.setA(i*10);
+ ab.setB(i*100);
+ li_carrays_cpp.ABArray_setitem(abArray, i, ab);
+ }
+ for (int i=0; i<length; i++) {
+ Assert(li_carrays_cpp.ABArray_getitem(abArray, i).getA(), i*10);
+ Assert(li_carrays_cpp.ABArray_getitem(abArray, i).getB(), i*100);
+ }
+ li_carrays_cpp.delete_ABArray(abArray);
+ }
+
+ {
+ // global array variable
+ int length = 3;
+ AB abArray = li_carrays_cpp.getGlobalABArray();
+ for (int i=0; i<length; i++) {
+ AB ab = li_carrays_cpp.ABArray_getitem(abArray, i);
+ ab.setA(i*10);
+ ab.setB(i*100);
+ li_carrays_cpp.ABArray_setitem(abArray, i, ab);
+ }
+ for (int i=0; i<length; i++) {
+ Assert(li_carrays_cpp.ABArray_getitem(abArray, i).getA(), i*10);
+ Assert(li_carrays_cpp.ABArray_getitem(abArray, i).getB(), i*100);
+ }
+ }
+ }
+
+ private static void Assert(int val1, int val2) {
+// System.out.println("val1=" + val1 + " val2=" + val2);
+ if (val1 != val2)
+ throw new RuntimeException("Mismatch. val1=" + val1 + " val2=" + val2);
+ }
+}
{
// global array variable
- int length = 5;
+ int length = 3;
XY xyArrayPointer = li_carrays.getGlobalXYArray();
XYArray xyArray = XYArray.frompointer(xyArrayPointer);
for (int i=0; i<length; i++) {
--- /dev/null
+import li_cdata_cpp.*;
+
+public class li_cdata_cpp_runme {
+
+ static {
+ try {
+ System.loadLibrary("li_cdata_cpp");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) throws Throwable
+ {
+ byte[] s = "ABC abc".getBytes();
+ SWIGTYPE_p_void m = li_cdata_cpp.malloc(256);
+ li_cdata_cpp.memmove(m, s);
+ byte[] ss = li_cdata_cpp.cdata(m, 7);
+ String ss_string = new String(ss);
+ if (!ss_string.equals("ABC abc"))
+ throw new RuntimeException("failed got: " + ss_string);
+ }
+}
--- /dev/null
+import li_cdata.*;
+
+public class li_cdata_runme {
+
+ static {
+ try {
+ System.loadLibrary("li_cdata");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) throws Throwable
+ {
+ byte[] s = "ABC abc".getBytes();
+ SWIGTYPE_p_void m = li_cdata.malloc(256);
+ li_cdata.memmove(m, s);
+ byte[] ss = li_cdata.cdata(m, 7);
+ String ss_string = new String(ss);
+ if (!ss_string.equals("ABC abc"))
+ throw new RuntimeException("failed got: " + ss_string);
+ }
+}
--- /dev/null
+import li_std_auto_ptr.*;
+
+public class li_std_auto_ptr_runme {
+ static {
+ try {
+ System.loadLibrary("li_std_auto_ptr");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ private static void WaitForGC()
+ {
+ System.gc();
+ System.runFinalization();
+ try {
+ java.lang.Thread.sleep(10);
+ } catch (java.lang.InterruptedException e) {
+ }
+ }
+
+ public static void main(String argv[]) throws Throwable
+ {
+ Klass k1 = li_std_auto_ptr.makeKlassAutoPtr("first");
+ if (!k1.getLabel().equals("first"))
+ throw new RuntimeException("wrong object label");
+
+ Klass k2 = li_std_auto_ptr.makeKlassAutoPtr("second");
+ if (Klass.getTotal_count() != 2)
+ throw new RuntimeException("number of objects should be 2");
+
+ k1 = null;
+ {
+ int countdown = 500;
+ int expectedCount = 1;
+ while (true) {
+ WaitForGC();
+ if (--countdown == 0)
+ break;
+ if (Klass.getTotal_count() == expectedCount)
+ break;
+ }
+ int actualCount = Klass.getTotal_count();
+ if (actualCount != expectedCount)
+ System.err.println("GC failed to run (li_std_auto_ptr 1). Expected count: " + expectedCount + " Actual count: " + actualCount); // Finalizers are not guaranteed to be run and sometimes they just don't
+ }
+
+ if (!k2.getLabel().equals("second"))
+ throw new RuntimeException("wrong object label");
+
+ k2 = null;
+ {
+ int countdown = 500;
+ int expectedCount = 0;
+ while (true) {
+ WaitForGC();
+ if (--countdown == 0)
+ break;
+ if (Klass.getTotal_count() == expectedCount)
+ break;
+ };
+ int actualCount = Klass.getTotal_count();
+ if (actualCount != expectedCount)
+ System.err.println("GC failed to run (li_std_auto_ptr 2). Expected count: " + expectedCount + " Actual count: " + actualCount); // Finalizers are not guaranteed to be run and sometimes they just don't
+ }
+ }
+}
// unsigned long long types map correctly to long and BigInteger respectively.
import long_long.*;
-import java.math.*;
+import java.math.BigInteger;
+import java.util.ArrayList;
public class long_long_runme {
check_ull(testNumber);
testNumber = testNumber.add(BigInteger.ONE);
}
-
+
try {
long_long.setUll(null);
throw new RuntimeException("null check failed");
} catch (NullPointerException e) {
}
+
+ // UnsignedToSigned - checks that a cast from unsigned long long to long long in C
+ // gives expected value (including -ve numbers)
+
+ long[] nums = {
+ 0x00,
+ 0xFF, 0x80, 0x7F, 0x01,
+ -0xFF, -0x80, -0x7F, -0x01,
+ 0x100, 0x10000,
+ -0x100, -0x10000,
+ 0xFFFF, 0xFF80, 0xFF7F, 0xFF01, 0xFF00,
+ -0xFFFF, -0xFF80, -0xFF7F, -0xFF01, -0xFF00,
+ 0x7FFF, 0x7F80, 0x7F7F, 0x7F01, 0x7F00,
+ -0x7FFF, -0x7F80, -0x7F7F, -0x7F01, -0x7F00,
+ 0x80FF, 0x8080, 0x807F, 0x8001, 0x8000,
+ -0x80FF, -0x8080, -0x807F, -0x8001, -0x8000,
+ Integer.MAX_VALUE, Integer.MIN_VALUE,
+ Integer.MAX_VALUE+1, Integer.MIN_VALUE-1,
+ Long.MAX_VALUE, Long.MIN_VALUE,
+ };
+
+ ArrayList<BigInteger> bigIntegers = new ArrayList<BigInteger>();
+ for (int i=0; i<nums.length; ++i) {
+ BigInteger bi = new BigInteger(new Long(nums[i]).toString());
+ bigIntegers.add(bi);
+ }
+
+ {
+ BigInteger bi = new BigInteger(new Long(Long.MAX_VALUE).toString());
+ bigIntegers.add(bi.add(BigInteger.ONE));
+ bi = new BigInteger(new Long(Long.MIN_VALUE).toString());
+ bigIntegers.add(bi.subtract(BigInteger.ONE));
+ }
+
+ boolean failed = false;
+ for (int i=0; i<bigIntegers.size(); ++i) {
+ BigInteger bi = (BigInteger)bigIntegers.get(i);
+ long longReturn = long_long.UnsignedToSigned(bi);
+ if (bi.longValue() != longReturn) {
+ System.err.println("Conversion to long failed, in:" + bi + " out:" + longReturn);
+ failed = true;
+ }
+ }
+ if (failed)
+ throw new RuntimeException("There were UnsignedToSigned failures");
}
public static void check_ll(long ll) {
long_long.setLl(ll);
long ll_check = long_long.getLl();
if (ll != ll_check) {
- System.err.println("Runtime test using long long failed. ll=" + ll + " ll_check=" + ll_check);
- System.exit(1);
+ throw new RuntimeException("Runtime test using long long failed. ll=" + ll + " ll_check=" + ll_check);
}
}
long_long.setUll(ull);
BigInteger ull_check = long_long.getUll();
if (ull.compareTo(ull_check) != 0) {
- System.err.println("Runtime test using unsigned long long failed. ull=" + ull.toString() + " ull_check=" + ull_check.toString());
- System.exit(1);
+ throw new RuntimeException("Runtime test using unsigned long long failed. ull=" + ull.toString() + " ull_check=" + ull_check.toString());
}
}
}
--- /dev/null
+import multiple_inheritance_abstract.*;
+
+public class multiple_inheritance_abstract_runme {
+
+ static {
+ try {
+ System.loadLibrary("multiple_inheritance_abstract");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ //Test base class as a parameter in java
+ int jcbase1b(CBase1 cb1){
+ return cb1.cbase1y();
+ }
+ int jabase1(ABase1 ab1){
+ return ab1.abase1();
+ }
+ int jcbase2(CBase2 cb2){
+ return cb2.cbase2();
+ }
+
+ public static void check(boolean fail, String msg) {
+ if (fail)
+ throw new RuntimeException(msg);
+ }
+
+ public static void main(String argv[]) {
+ //Test Derived1
+ Derived1 d1=new Derived1();
+ check(d1.cbase1y()!=3, "Derived1::cbase1y() failed");
+ check(d1.cbase2()!=4, "Derived1::cbase2() failed");
+
+ //Test Derived2
+ Derived2 d2=new Derived2();
+ check(d2.cbase1y()!=6, "Derived2::cbase1y() failed");
+ check(d2.abase1()!=5, "Derived2::abase1() failed");
+
+ //Test Derived3
+ Derived3 d3=new Derived3();
+ check(d3.cbase1y()!=7, "Derived3::cbase1y() failed");
+ check(d3.cbase2()!=8, "Derived3::cbase2() failed");
+ check(d3.abase1()!=9, "Derived3::abase1() failed");
+
+ //Test Bottom1
+ Bottom1 b1=new Bottom1();
+ check(b1.cbase1y()!=103, "Bottom1::cbase1y() failed");
+ check(b1.cbase2()!=104, "Bottom1::cbase2() failed");
+
+ //Test Bottom2
+ Bottom2 b2=new Bottom2();
+ check(b2.cbase1y()!=206, "Bottom2::cbase1y() failed");
+ check(b2.abase1()!=205, "Bottom2::abase1() failed");
+
+ //Test Bottom3
+ Bottom3 b3=new Bottom3();
+ check(b3.cbase1y()!=307, "Bottom3::cbase1y() failed");
+ check(b3.cbase2()!=308, "Bottom3::cbase2() failed");
+ check(b3.abase1()!=309, "Bottom3::abase1() failed");
+
+ //Test interfaces from c++ classes
+ CBase1 cb1=new CBase1SwigImpl();
+ CBase2 cb2=new CBase2SwigImpl();
+ check(cb1.cbase1y()!=1, "CBase1::cbase1y() failed");
+ check(cb2.cbase2()!=2, "CBase2::cbase2() failed");
+
+ //Test abstract class as return value
+ ABase1 ab1=d3.cloneit();
+ check(ab1.abase1()!=9, "Derived3::abase1() through ABase1 failed");
+
+ //Test concrete base class as return value
+ CBase1 cb6=d2.cloneit();
+ CBase2 cb7=d1.cloneit();
+ check(cb6.cbase1y()!=6, "Derived2::cbase1y() through CBase1 failed");
+ check(cb7.cbase2()!=4, "Derived1:cbase2() through ABase1 failed");
+
+ //Test multi inheritance
+ CBase1 cb3=new Derived1();
+ CBase1 cb4=new Derived3();
+ CBase2 cb5=new Derived3();
+ ABase1 ab6=new Derived2();
+ check(cb3.cbase1y()!=3, "Derived1::cbase1y() through CBase1 failed");
+ check(cb4.cbase1y()!=7, "Derived3::cbase1y() through CBase1 failed");
+ check(cb5.cbase2()!=8, "Derived3::cbase2() through CBase2 failed");
+ check(ab6.abase1()!=5, "Derived2::abase1() through ABase1 failed");
+
+ //Test base classes as parameter in java
+ multiple_inheritance_abstract_runme mhar=new multiple_inheritance_abstract_runme();
+ check(mhar.jcbase1b(d1)!=3, "jcbase1b() through Derived1 as parameter failed");
+ check(mhar.jcbase1b(d2)!=6, "jcbase1b() through Derived2 as parameter failed");
+ check(mhar.jcbase1b(d3)!=7, "jcbase1b() through Derived3 as parameter failed");
+ check(mhar.jcbase2(d1)!=4, "jcbase2() through Derived1 as parameter failed");
+ check(mhar.jcbase2(d3)!=8, "jcbase2() through Derived3 as parameter failed");
+ check(mhar.jabase1(d2)!=5, "jabase1() through Derived2 as parameter failed");
+ check(mhar.jabase1(d3)!=9, "jabase1() through Derived3 as parameter failed");
+
+ //Value parameters
+ //Test CBase1 CBase2 as parameters (note slicing for Derived and Bottom classes)
+ check(multiple_inheritance_abstract.InputValCBase1(d1)!=1, "InputValCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase1(d2)!=1, "InputValCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase1(d3)!=1, "InputValCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase2(d3)!=2, "InputValCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase2(d1)!=2, "InputValCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase1(cb1)!=1, "InputValCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase2(cb2)!=2, "InputValCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase1(b1)!=1, "InputValCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase1(b2)!=1, "InputValCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase1(b3)!=1, "InputValCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase2(b3)!=2, "InputValCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputValCBase2(b1)!=2, "InputValCBase2(), Bottom1 as a parameter failed");
+
+ //Pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_abstract.InputPtrABase1(d2)!=5, "InputPtrABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrABase1(d3)!=9, "InputPtrABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrABase1(b2)!=205, "InputPtrABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrABase1(b3)!=309, "InputPtrABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_abstract.InputPtrCBase1(d1)!=3, "InputPtrCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase1(d2)!=6, "InputPtrCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase1(d3)!=7, "InputPtrCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase2(d3)!=8, "InputPtrCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase2(d1)!=4, "InputPtrCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase1(cb1)!=1, "InputPtrCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase2(cb2)!=2, "InputPtrCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase1(b1)!=103, "InputPtrCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase1(b2)!=206, "InputPtrCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase1(b3)!=307, "InputPtrCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase2(b3)!=308, "InputPtrCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputPtrCBase2(b1)!=104, "InputPtrCBase2(), Bottom1 as a parameter failed");
+
+ //Reference parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_abstract.InputRefABase1(d2)!=5, "InputRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefABase1(d3)!=9, "InputRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefABase1(b2)!=205, "InputRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefABase1(b3)!=309, "InputRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_abstract.InputRefCBase1(d1)!=3, "InputRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase1(d2)!=6, "InputRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase1(d3)!=7, "InputRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase2(d3)!=8, "InputRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase2(d1)!=4, "InputRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase1(cb1)!=1, "InputRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase2(cb2)!=2, "InputRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase1(b1)!=103, "InputRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase1(b2)!=206, "InputRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase1(b3)!=307, "InputRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase2(b3)!=308, "InputRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputRefCBase2(b1)!=104, "InputRefCBase2(), Bottom1 as a parameter failed");
+
+ //Const reference pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_abstract.InputCPtrRefABase1(d2)!=5, "InputCPtrRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefABase1(d3)!=9, "InputCPtrRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefABase1(b2)!=205, "InputCPtrRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefABase1(b3)!=309, "InputCPtrRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(d1)!=3, "InputCPtrRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(d2)!=6, "InputCPtrRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(d3)!=7, "InputCPtrRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase2(d3)!=8, "InputCPtrRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase2(d1)!=4, "InputCPtrRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(cb1)!=1, "InputCPtrRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase2(cb2)!=2, "InputCPtrRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(b1)!=103, "InputCPtrRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(b2)!=206, "InputCPtrRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase1(b3)!=307, "InputCPtrRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase2(b3)!=308, "InputCPtrRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_abstract.InputCPtrRefCBase2(b1)!=104, "InputCPtrRefCBase2(), Bottom1 as a parameter failed");
+
+ //Derived classes as parameters
+ check(multiple_inheritance_abstract.InputValDerived1(d1)!=3+4, "InputValDerived1() failed");
+ check(multiple_inheritance_abstract.InputValDerived2(d2)!=6+5, "InputValDerived2() failed");
+ check(multiple_inheritance_abstract.InputValDerived3(d3)!=7+8+9, "InputValDerived3() failed");
+
+ check(multiple_inheritance_abstract.InputRefDerived1(d1)!=3+4, "InputRefDerived1() failed");
+ check(multiple_inheritance_abstract.InputRefDerived2(d2)!=6+5, "InputRefDerived2() failed");
+ check(multiple_inheritance_abstract.InputRefDerived3(d3)!=7+8+9, "InputRefDerived3() failed");
+
+ check(multiple_inheritance_abstract.InputPtrDerived1(d1)!=3+4, "InputPtrDerived1() failed");
+ check(multiple_inheritance_abstract.InputPtrDerived2(d2)!=6+5, "InputPtrDerived2() failed");
+ check(multiple_inheritance_abstract.InputPtrDerived3(d3)!=7+8+9, "InputPtrDerived3() failed");
+
+ check(multiple_inheritance_abstract.InputCPtrRefDerived1(d1)!=3+4, "InputCPtrRefDerived1() failed");
+ check(multiple_inheritance_abstract.InputCPtrRefDerived2(d2)!=6+5, "InputCPtrRefDerived2() failed");
+ check(multiple_inheritance_abstract.InputCPtrRefDerived3(d3)!=7+8+9, "InputCPtrRefDerived3() failed");
+
+ //Bottom classes as Derived parameters
+ check(multiple_inheritance_abstract.InputValDerived1(b1)!=3+4, "InputValDerived1() failed");
+ check(multiple_inheritance_abstract.InputValDerived2(b2)!=6+5, "InputValDerived2() failed");
+ check(multiple_inheritance_abstract.InputValDerived3(b3)!=7+8+9, "InputValDerived3() failed");
+
+ check(multiple_inheritance_abstract.InputRefDerived1(b1)!=103+104, "InputRefDerived1() failed");
+ check(multiple_inheritance_abstract.InputRefDerived2(b2)!=206+205, "InputRefDerived2() failed");
+ check(multiple_inheritance_abstract.InputRefDerived3(b3)!=307+308+309, "InputRefDerived3() failed");
+
+ check(multiple_inheritance_abstract.InputPtrDerived1(b1)!=103+104, "InputPtrDerived1() failed");
+ check(multiple_inheritance_abstract.InputPtrDerived2(b2)!=206+205, "InputPtrDerived2() failed");
+ check(multiple_inheritance_abstract.InputPtrDerived3(b3)!=307+308+309, "InputPtrDerived3() failed");
+
+ check(multiple_inheritance_abstract.InputCPtrRefDerived1(b1)!=103+104, "InputCPtrRefDerived1() failed");
+ check(multiple_inheritance_abstract.InputCPtrRefDerived2(b2)!=206+205, "InputCPtrRefDerived2() failed");
+ check(multiple_inheritance_abstract.InputCPtrRefDerived3(b3)!=307+308+309, "InputCPtrRefDerived3() failed");
+
+ //Bottom classes as Bottom parameters
+ check(multiple_inheritance_abstract.InputValBottom1(b1)!=103+104, "InputValBottom1() failed");
+ check(multiple_inheritance_abstract.InputValBottom2(b2)!=206+205, "InputValBottom2() failed");
+ check(multiple_inheritance_abstract.InputValBottom3(b3)!=307+308+309, "InputValBottom3() failed");
+
+ check(multiple_inheritance_abstract.InputRefBottom1(b1)!=103+104, "InputRefBottom1() failed");
+ check(multiple_inheritance_abstract.InputRefBottom2(b2)!=206+205, "InputRefBottom2() failed");
+ check(multiple_inheritance_abstract.InputRefBottom3(b3)!=307+308+309, "InputRefBottom3() failed");
+
+ check(multiple_inheritance_abstract.InputPtrBottom1(b1)!=103+104, "InputPtrBottom1() failed");
+ check(multiple_inheritance_abstract.InputPtrBottom2(b2)!=206+205, "InputPtrBottom2() failed");
+ check(multiple_inheritance_abstract.InputPtrBottom3(b3)!=307+308+309, "InputPtrBottom3() failed");
+
+ check(multiple_inheritance_abstract.InputCPtrRefBottom1(b1)!=103+104, "InputCPtrRefBottom1() failed");
+ check(multiple_inheritance_abstract.InputCPtrRefBottom2(b2)!=206+205, "InputCPtrRefBottom2() failed");
+ check(multiple_inheritance_abstract.InputCPtrRefBottom3(b3)!=307+308+309, "InputCPtrRefBottom3() failed");
+ // Return pointers
+ check(multiple_inheritance_abstract.MakePtrDerived1_CBase1().cbase1y()!=3, "MakePtrDerived1_CBase1 failed");
+ check(multiple_inheritance_abstract.MakePtrDerived1_CBase2().cbase2()!=4, "MakePtrDerived1_CBase2 failed");
+ check(multiple_inheritance_abstract.MakePtrDerived2_CBase1().cbase1y()!=6, "MakePtrDerived2_CBase1 failed");
+ check(multiple_inheritance_abstract.MakePtrDerived2_ABase1().abase1()!=5, "MakePtrDerived2_ABase1 failed");
+ check(multiple_inheritance_abstract.MakePtrDerived3_ABase1().abase1()!=9, "MakePtrDerived3_ABase1 failed");
+ check(multiple_inheritance_abstract.MakePtrDerived3_CBase1().cbase1y()!=7, "MakePtrDerived3_CBase1 failed");
+ check(multiple_inheritance_abstract.MakePtrDerived3_CBase2().cbase2()!=8, "MakePtrDerived3_CBase2 failed");
+
+ // Return references
+ check(multiple_inheritance_abstract.MakeRefDerived1_CBase1().cbase1y()!=3, "MakeRefDerived1_CBase1 failed");
+ check(multiple_inheritance_abstract.MakeRefDerived1_CBase2().cbase2()!=4, "MakeRefDerived1_CBase2 failed");
+ check(multiple_inheritance_abstract.MakeRefDerived2_CBase1().cbase1y()!=6, "MakeRefDerived2_CBase1 failed");
+ check(multiple_inheritance_abstract.MakeRefDerived2_ABase1().abase1()!=5, "MakeRefDerived2_ABase1 failed");
+ check(multiple_inheritance_abstract.MakeRefDerived3_ABase1().abase1()!=9, "MakeRefDerived3_ABase1 failed");
+ check(multiple_inheritance_abstract.MakeRefDerived3_CBase1().cbase1y()!=7, "MakeRefDerived3_CBase1 failed");
+ check(multiple_inheritance_abstract.MakeRefDerived3_CBase2().cbase2()!=8, "MakeRefDerived3_CBase2 failed");
+
+ // Return by value (sliced objects)
+ check(multiple_inheritance_abstract.MakeValDerived1_CBase1().cbase1y()!=1, "MakeValDerived1_CBase1 failed");
+ check(multiple_inheritance_abstract.MakeValDerived1_CBase2().cbase2()!=2, "MakeValDerived1_CBase2 failed");
+ check(multiple_inheritance_abstract.MakeValDerived2_CBase1().cbase1y()!=1, "MakeValDerived2_CBase1 failed");
+ check(multiple_inheritance_abstract.MakeValDerived3_CBase1().cbase1y()!=1, "MakeValDerived3_CBase1 failed");
+ check(multiple_inheritance_abstract.MakeValDerived3_CBase2().cbase2()!=2, "MakeValDerived3_CBase2 failed");
+
+ }
+}
--- /dev/null
+import multiple_inheritance_interfaces.*;
+import java.util.Arrays;
+
+public class multiple_inheritance_interfaces_runme {
+
+ static {
+ try {
+ System.loadLibrary("multiple_inheritance_interfaces");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ private static void checkBaseAndInterfaces(Class cls, boolean interfaceExpected, String base, String[] interfaces) {
+ String[] expectedInterfaces = new String[interfaces.length];
+ for (int i=0; i<interfaces.length; ++i)
+ expectedInterfaces[i] = "interface multiple_inheritance_interfaces." + interfaces[i];
+ Class[] actualInterfaces = cls.getInterfaces();
+ String expectedInterfacesString = Arrays.toString(expectedInterfaces);
+ String actualInterfacesString = Arrays.toString(actualInterfaces);
+ if (!expectedInterfacesString.equals(actualInterfacesString))
+ throw new RuntimeException("Expected interfaces for " + cls.getName() + ": \n" + expectedInterfacesString + "\n" + "Actual interfaces: \n" + actualInterfacesString);
+
+ String expectedBaseString = null;
+ if (interfaceExpected) {
+ // expecting an interface
+ if (!cls.isInterface())
+ throw new RuntimeException(cls.getName() + " should be an interface but is not");
+ expectedBaseString = base.isEmpty() ? "" : "multiple_inheritance_interfaces." + base;
+ } else {
+ // expecting a class
+ if (cls.isInterface())
+ throw new RuntimeException(cls.getName() + " is an interface but it should not be");
+ expectedBaseString = base.isEmpty() ? "java.lang.Object" : "multiple_inheritance_interfaces." + base;
+ }
+
+ String actualBaseString = cls.getSuperclass() == null ? "" : cls.getSuperclass().getName();
+ if (!expectedBaseString.equals(actualBaseString))
+ throw new RuntimeException("Expected base for " + cls.getName() + ": [" + expectedBaseString + "]" + " Actual base: [" + actualBaseString + "]");
+ }
+
+ public static void main(String argv[]) {
+ checkBaseAndInterfaces(IA.class, true, "", new String[] {});
+ checkBaseAndInterfaces(IB.class, true, "", new String[] {});
+ checkBaseAndInterfaces(IC.class, true, "", new String[] {"IA", "IB"});
+ checkBaseAndInterfaces(A.class, false, "", new String[] {"IA"});
+ checkBaseAndInterfaces(B.class, false, "", new String[] {"IB"});
+ checkBaseAndInterfaces(C.class, false, "", new String[] {"IA", "IB", "IC"});
+ checkBaseAndInterfaces(D.class, false, "", new String[] {"IA", "IB", "IC"});
+ checkBaseAndInterfaces(E.class, false, "D", new String[] {});
+
+ checkBaseAndInterfaces(IJ.class, true, "", new String[] {});
+ checkBaseAndInterfaces(IK.class, true, "", new String[] {"IJ"});
+ checkBaseAndInterfaces(IL.class, true, "", new String[] {"IK"});
+ checkBaseAndInterfaces(J.class, false, "", new String[] {"IJ"});
+ checkBaseAndInterfaces(K.class, false, "", new String[] {"IJ", "IK"});
+ checkBaseAndInterfaces(L.class, false, "", new String[] {"IJ", "IK", "IL"});
+ checkBaseAndInterfaces(M.class, false, "", new String[] {"IJ", "IK", "IL"});
+
+ checkBaseAndInterfaces(P.class, false, "", new String[] {});
+ checkBaseAndInterfaces(IQ.class, true, "", new String[] {});
+ checkBaseAndInterfaces(Q.class, false, "", new String[] {"IQ"});
+ checkBaseAndInterfaces(R.class, false, "P", new String[] {"IQ"});
+ checkBaseAndInterfaces(S.class, false, "P", new String[] {"IQ"});
+ checkBaseAndInterfaces(T.class, false, "", new String[] {"IQ"});
+ checkBaseAndInterfaces(U.class, false, "R", new String[] {});
+ checkBaseAndInterfaces(V.class, false, "S", new String[] {});
+ checkBaseAndInterfaces(W.class, false, "T", new String[] {});
+
+ // overloaded methods check
+ D d = new D();
+ d.ia();
+ d.ia(10);
+ d.ia("bye");
+ d.ia("bye", false);
+ }
+}
--- /dev/null
+import multiple_inheritance_nspacePackage.multiple_inheritance_nspace;
+import multiple_inheritance_nspacePackage.multiple_inheritance_nspaceJNI;
+import multiple_inheritance_nspacePackage.Space.*;
+
+public class multiple_inheritance_nspace_runme {
+
+ static {
+ try {
+ System.loadLibrary("multiple_inheritance_nspace");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ //Test base class as a parameter in java
+ int jcbase1b(CBase1SwigInterface cb1){
+ return cb1.cbase1y();
+ }
+ int jabase1(ABase1SwigInterface ab1){
+ return ab1.abase1();
+ }
+ int jcbase2(CBase2SwigInterface cb2){
+ return cb2.cbase2();
+ }
+
+ public static void check(boolean fail, String msg) {
+ if (fail)
+ throw new RuntimeException(msg);
+ }
+
+ public static void main(String argv[]) {
+ //Test Derived1
+ Derived1 d1=new Derived1();
+ check(d1.cbase1y()!=3, "Derived1::cbase1y() failed");
+ check(d1.cbase2()!=4, "Derived1::cbase2() failed");
+
+ //Test Derived2
+ Derived2 d2=new Derived2();
+ check(d2.cbase1y()!=6, "Derived2::cbase1y() failed");
+ check(d2.abase1()!=5, "Derived2::abase1() failed");
+
+ //Test Derived3
+ Derived3 d3=new Derived3();
+ check(d3.cbase1y()!=7, "Derived3::cbase1y() failed");
+ check(d3.cbase2()!=8, "Derived3::cbase2() failed");
+ check(d3.abase1()!=9, "Derived3::abase1() failed");
+
+ //Test Bottom1
+ Bottom1 b1=new Bottom1();
+ check(b1.cbase1y()!=103, "Bottom1::cbase1y() failed");
+ check(b1.cbase2()!=104, "Bottom1::cbase2() failed");
+
+ //Test Bottom2
+ Bottom2 b2=new Bottom2();
+ check(b2.cbase1y()!=206, "Bottom2::cbase1y() failed");
+ check(b2.abase1()!=205, "Bottom2::abase1() failed");
+
+ //Test Bottom3
+ Bottom3 b3=new Bottom3();
+ check(b3.cbase1y()!=307, "Bottom3::cbase1y() failed");
+ check(b3.cbase2()!=308, "Bottom3::cbase2() failed");
+ check(b3.abase1()!=309, "Bottom3::abase1() failed");
+
+ //Test interfaces from c++ classes
+ CBase1SwigInterface cb1=new CBase1();
+ CBase2SwigInterface cb2=new CBase2();
+ check(cb1.cbase1y()!=1, "CBase1::cbase1y() failed");
+ check(cb2.cbase2()!=2, "CBase2::cbase2() failed");
+
+ //Test nspace class as return value
+ ABase1SwigInterface ab1=d3.cloneit();
+ check(ab1.abase1()!=9, "Derived3::abase1() through ABase1 failed");
+
+ //Test concrete base class as return value
+ CBase1SwigInterface cb6=d2.cloneit();
+ CBase2SwigInterface cb7=d1.cloneit();
+ check(cb6.cbase1y()!=6, "Derived2::cbase1y() through CBase1 failed");
+ check(cb7.cbase2()!=4, "Derived1:cbase2() through ABase1 failed");
+
+ //Test multi inheritance
+ CBase1SwigInterface cb3=new Derived1();
+ CBase1SwigInterface cb4=new Derived3();
+ CBase2SwigInterface cb5=new Derived3();
+ ABase1SwigInterface ab6=new Derived2();
+ check(cb3.cbase1y()!=3, "Derived1::cbase1y() through CBase1 failed");
+ check(cb4.cbase1y()!=7, "Derived3::cbase1y() through CBase1 failed");
+ check(cb5.cbase2()!=8, "Derived3::cbase2() through CBase2 failed");
+ check(ab6.abase1()!=5, "Derived2::abase1() through ABase1 failed");
+
+ //Test base classes as parameter in java
+ multiple_inheritance_nspace_runme mhar=new multiple_inheritance_nspace_runme();
+ check(mhar.jcbase1b(d1)!=3, "jcbase1b() through Derived1 as parameter failed");
+ check(mhar.jcbase1b(d2)!=6, "jcbase1b() through Derived2 as parameter failed");
+ check(mhar.jcbase1b(d3)!=7, "jcbase1b() through Derived3 as parameter failed");
+ check(mhar.jcbase2(d1)!=4, "jcbase2() through Derived1 as parameter failed");
+ check(mhar.jcbase2(d3)!=8, "jcbase2() through Derived3 as parameter failed");
+ check(mhar.jabase1(d2)!=5, "jabase1() through Derived2 as parameter failed");
+ check(mhar.jabase1(d3)!=9, "jabase1() through Derived3 as parameter failed");
+
+ //Value parameters
+ //Test CBase1 CBase2 as parameters (note slicing for Derived and Bottom classes)
+ check(multiple_inheritance_nspace.InputValCBase1(d1)!=1, "InputValCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase1(d2)!=1, "InputValCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase1(d3)!=1, "InputValCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase2(d3)!=2, "InputValCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase2(d1)!=2, "InputValCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase1(cb1)!=1, "InputValCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase2(cb2)!=2, "InputValCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase1(b1)!=1, "InputValCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase1(b2)!=1, "InputValCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase1(b3)!=1, "InputValCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase2(b3)!=2, "InputValCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputValCBase2(b1)!=2, "InputValCBase2(), Bottom1 as a parameter failed");
+
+ //Pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_nspace.InputPtrABase1(d2)!=5, "InputPtrABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrABase1(d3)!=9, "InputPtrABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrABase1(b2)!=205, "InputPtrABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrABase1(b3)!=309, "InputPtrABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_nspace.InputPtrCBase1(d1)!=3, "InputPtrCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase1(d2)!=6, "InputPtrCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase1(d3)!=7, "InputPtrCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase2(d3)!=8, "InputPtrCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase2(d1)!=4, "InputPtrCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase1(cb1)!=1, "InputPtrCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase2(cb2)!=2, "InputPtrCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase1(b1)!=103, "InputPtrCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase1(b2)!=206, "InputPtrCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase1(b3)!=307, "InputPtrCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase2(b3)!=308, "InputPtrCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputPtrCBase2(b1)!=104, "InputPtrCBase2(), Bottom1 as a parameter failed");
+
+ //Reference parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_nspace.InputRefABase1(d2)!=5, "InputRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefABase1(d3)!=9, "InputRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefABase1(b2)!=205, "InputRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefABase1(b3)!=309, "InputRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_nspace.InputRefCBase1(d1)!=3, "InputRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase1(d2)!=6, "InputRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase1(d3)!=7, "InputRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase2(d3)!=8, "InputRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase2(d1)!=4, "InputRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase1(cb1)!=1, "InputRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase2(cb2)!=2, "InputRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase1(b1)!=103, "InputRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase1(b2)!=206, "InputRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase1(b3)!=307, "InputRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase2(b3)!=308, "InputRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputRefCBase2(b1)!=104, "InputRefCBase2(), Bottom1 as a parameter failed");
+
+ //Const reference pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_nspace.InputCPtrRefABase1(d2)!=5, "InputCPtrRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefABase1(d3)!=9, "InputCPtrRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefABase1(b2)!=205, "InputCPtrRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefABase1(b3)!=309, "InputCPtrRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(d1)!=3, "InputCPtrRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(d2)!=6, "InputCPtrRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(d3)!=7, "InputCPtrRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase2(d3)!=8, "InputCPtrRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase2(d1)!=4, "InputCPtrRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(cb1)!=1, "InputCPtrRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase2(cb2)!=2, "InputCPtrRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(b1)!=103, "InputCPtrRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(b2)!=206, "InputCPtrRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase1(b3)!=307, "InputCPtrRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase2(b3)!=308, "InputCPtrRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_nspace.InputCPtrRefCBase2(b1)!=104, "InputCPtrRefCBase2(), Bottom1 as a parameter failed");
+
+ //Derived classes as parameters
+ check(multiple_inheritance_nspace.InputValDerived1(d1)!=3+4, "InputValDerived1() failed");
+ check(multiple_inheritance_nspace.InputValDerived2(d2)!=6+5, "InputValDerived2() failed");
+ check(multiple_inheritance_nspace.InputValDerived3(d3)!=7+8+9, "InputValDerived3() failed");
+
+ check(multiple_inheritance_nspace.InputRefDerived1(d1)!=3+4, "InputRefDerived1() failed");
+ check(multiple_inheritance_nspace.InputRefDerived2(d2)!=6+5, "InputRefDerived2() failed");
+ check(multiple_inheritance_nspace.InputRefDerived3(d3)!=7+8+9, "InputRefDerived3() failed");
+
+ check(multiple_inheritance_nspace.InputPtrDerived1(d1)!=3+4, "InputPtrDerived1() failed");
+ check(multiple_inheritance_nspace.InputPtrDerived2(d2)!=6+5, "InputPtrDerived2() failed");
+ check(multiple_inheritance_nspace.InputPtrDerived3(d3)!=7+8+9, "InputPtrDerived3() failed");
+
+ check(multiple_inheritance_nspace.InputCPtrRefDerived1(d1)!=3+4, "InputCPtrRefDerived1() failed");
+ check(multiple_inheritance_nspace.InputCPtrRefDerived2(d2)!=6+5, "InputCPtrRefDerived2() failed");
+ check(multiple_inheritance_nspace.InputCPtrRefDerived3(d3)!=7+8+9, "InputCPtrRefDerived3() failed");
+
+ //Bottom classes as Derived parameters
+ check(multiple_inheritance_nspace.InputValDerived1(b1)!=3+4, "InputValDerived1() failed");
+ check(multiple_inheritance_nspace.InputValDerived2(b2)!=6+5, "InputValDerived2() failed");
+ check(multiple_inheritance_nspace.InputValDerived3(b3)!=7+8+9, "InputValDerived3() failed");
+
+ check(multiple_inheritance_nspace.InputRefDerived1(b1)!=103+104, "InputRefDerived1() failed");
+ check(multiple_inheritance_nspace.InputRefDerived2(b2)!=206+205, "InputRefDerived2() failed");
+ check(multiple_inheritance_nspace.InputRefDerived3(b3)!=307+308+309, "InputRefDerived3() failed");
+
+ check(multiple_inheritance_nspace.InputPtrDerived1(b1)!=103+104, "InputPtrDerived1() failed");
+ check(multiple_inheritance_nspace.InputPtrDerived2(b2)!=206+205, "InputPtrDerived2() failed");
+ check(multiple_inheritance_nspace.InputPtrDerived3(b3)!=307+308+309, "InputPtrDerived3() failed");
+
+ check(multiple_inheritance_nspace.InputCPtrRefDerived1(b1)!=103+104, "InputCPtrRefDerived1() failed");
+ check(multiple_inheritance_nspace.InputCPtrRefDerived2(b2)!=206+205, "InputCPtrRefDerived2() failed");
+ check(multiple_inheritance_nspace.InputCPtrRefDerived3(b3)!=307+308+309, "InputCPtrRefDerived3() failed");
+
+ //Bottom classes as Bottom parameters
+ check(multiple_inheritance_nspace.InputValBottom1(b1)!=103+104, "InputValBottom1() failed");
+ check(multiple_inheritance_nspace.InputValBottom2(b2)!=206+205, "InputValBottom2() failed");
+ check(multiple_inheritance_nspace.InputValBottom3(b3)!=307+308+309, "InputValBottom3() failed");
+
+ check(multiple_inheritance_nspace.InputRefBottom1(b1)!=103+104, "InputRefBottom1() failed");
+ check(multiple_inheritance_nspace.InputRefBottom2(b2)!=206+205, "InputRefBottom2() failed");
+ check(multiple_inheritance_nspace.InputRefBottom3(b3)!=307+308+309, "InputRefBottom3() failed");
+
+ check(multiple_inheritance_nspace.InputPtrBottom1(b1)!=103+104, "InputPtrBottom1() failed");
+ check(multiple_inheritance_nspace.InputPtrBottom2(b2)!=206+205, "InputPtrBottom2() failed");
+ check(multiple_inheritance_nspace.InputPtrBottom3(b3)!=307+308+309, "InputPtrBottom3() failed");
+
+ check(multiple_inheritance_nspace.InputCPtrRefBottom1(b1)!=103+104, "InputCPtrRefBottom1() failed");
+ check(multiple_inheritance_nspace.InputCPtrRefBottom2(b2)!=206+205, "InputCPtrRefBottom2() failed");
+ check(multiple_inheritance_nspace.InputCPtrRefBottom3(b3)!=307+308+309, "InputCPtrRefBottom3() failed");
+ // Return pointers
+ check(multiple_inheritance_nspace.MakePtrDerived1_CBase1().cbase1y()!=3, "MakePtrDerived1_CBase1 failed");
+ check(multiple_inheritance_nspace.MakePtrDerived1_CBase2().cbase2()!=4, "MakePtrDerived1_CBase2 failed");
+ check(multiple_inheritance_nspace.MakePtrDerived2_CBase1().cbase1y()!=6, "MakePtrDerived2_CBase1 failed");
+ check(multiple_inheritance_nspace.MakePtrDerived2_ABase1().abase1()!=5, "MakePtrDerived2_ABase1 failed");
+ check(multiple_inheritance_nspace.MakePtrDerived3_ABase1().abase1()!=9, "MakePtrDerived3_ABase1 failed");
+ check(multiple_inheritance_nspace.MakePtrDerived3_CBase1().cbase1y()!=7, "MakePtrDerived3_CBase1 failed");
+ check(multiple_inheritance_nspace.MakePtrDerived3_CBase2().cbase2()!=8, "MakePtrDerived3_CBase2 failed");
+
+ // Return references
+ check(multiple_inheritance_nspace.MakeRefDerived1_CBase1().cbase1y()!=3, "MakeRefDerived1_CBase1 failed");
+ check(multiple_inheritance_nspace.MakeRefDerived1_CBase2().cbase2()!=4, "MakeRefDerived1_CBase2 failed");
+ check(multiple_inheritance_nspace.MakeRefDerived2_CBase1().cbase1y()!=6, "MakeRefDerived2_CBase1 failed");
+ check(multiple_inheritance_nspace.MakeRefDerived2_ABase1().abase1()!=5, "MakeRefDerived2_ABase1 failed");
+ check(multiple_inheritance_nspace.MakeRefDerived3_ABase1().abase1()!=9, "MakeRefDerived3_ABase1 failed");
+ check(multiple_inheritance_nspace.MakeRefDerived3_CBase1().cbase1y()!=7, "MakeRefDerived3_CBase1 failed");
+ check(multiple_inheritance_nspace.MakeRefDerived3_CBase2().cbase2()!=8, "MakeRefDerived3_CBase2 failed");
+
+ // Return by value (sliced objects)
+ check(multiple_inheritance_nspace.MakeValDerived1_CBase1().cbase1y()!=1, "MakeValDerived1_CBase1 failed");
+ check(multiple_inheritance_nspace.MakeValDerived1_CBase2().cbase2()!=2, "MakeValDerived1_CBase2 failed");
+ check(multiple_inheritance_nspace.MakeValDerived2_CBase1().cbase1y()!=1, "MakeValDerived2_CBase1 failed");
+ check(multiple_inheritance_nspace.MakeValDerived3_CBase1().cbase1y()!=1, "MakeValDerived3_CBase1 failed");
+ check(multiple_inheritance_nspace.MakeValDerived3_CBase2().cbase2()!=2, "MakeValDerived3_CBase2 failed");
+
+ }
+}
--- /dev/null
+import multiple_inheritance_shared_ptr.*;
+
+public class multiple_inheritance_shared_ptr_runme {
+
+ static {
+ try {
+ System.loadLibrary("multiple_inheritance_shared_ptr");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ //Test base class as a parameter in java
+ int jcbase1b(CBase1 cb1){
+ return cb1.cbase1y();
+ }
+ int jabase1(ABase1 ab1){
+ return ab1.abase1();
+ }
+ int jcbase2(CBase2 cb2){
+ return cb2.cbase2();
+ }
+
+ public static void check(boolean fail, String msg) {
+ if (fail)
+ throw new RuntimeException(msg);
+ }
+
+ public static void main(String argv[]) {
+ //Test Derived1
+ Derived1 d1=new Derived1();
+ check(d1.cbase1y()!=3, "Derived1::cbase1y() failed");
+ check(d1.cbase2()!=4, "Derived1::cbase2() failed");
+
+ //Test Derived2
+ Derived2 d2=new Derived2();
+ check(d2.cbase1y()!=6, "Derived2::cbase1y() failed");
+ check(d2.abase1()!=5, "Derived2::abase1() failed");
+
+ //Test Derived3
+ Derived3 d3=new Derived3();
+ check(d3.cbase1y()!=7, "Derived3::cbase1y() failed");
+ check(d3.cbase2()!=8, "Derived3::cbase2() failed");
+ check(d3.abase1()!=9, "Derived3::abase1() failed");
+
+ //Test Bottom1
+ Bottom1 b1=new Bottom1();
+ check(b1.cbase1y()!=103, "Bottom1::cbase1y() failed");
+ check(b1.cbase2()!=104, "Bottom1::cbase2() failed");
+
+ //Test Bottom2
+ Bottom2 b2=new Bottom2();
+ check(b2.cbase1y()!=206, "Bottom2::cbase1y() failed");
+ check(b2.abase1()!=205, "Bottom2::abase1() failed");
+
+ //Test Bottom3
+ Bottom3 b3=new Bottom3();
+ check(b3.cbase1y()!=307, "Bottom3::cbase1y() failed");
+ check(b3.cbase2()!=308, "Bottom3::cbase2() failed");
+ check(b3.abase1()!=309, "Bottom3::abase1() failed");
+
+ //Test interfaces from c++ classes
+ CBase1 cb1=new CBase1SwigImpl();
+ CBase2 cb2=new CBase2SwigImpl();
+ check(cb1.cbase1y()!=1, "CBase1::cbase1y() failed");
+ check(cb2.cbase2()!=2, "CBase2::cbase2() failed");
+
+ //Test abstract class as return value
+ ABase1 ab1=d3.cloneit();
+ check(ab1.abase1()!=9, "Derived3::abase1() through ABase1 failed");
+
+ //Test concrete base class as return value
+ CBase1 cb6=d2.cloneit();
+ CBase2 cb7=d1.cloneit();
+ check(cb6.cbase1y()!=6, "Derived2::cbase1y() through CBase1 failed");
+ check(cb7.cbase2()!=4, "Derived1:cbase2() through ABase1 failed");
+
+ //Test multi inheritance
+ CBase1 cb3=new Derived1();
+ CBase1 cb4=new Derived3();
+ CBase2 cb5=new Derived3();
+ ABase1 ab6=new Derived2();
+ check(cb3.cbase1y()!=3, "Derived1::cbase1y() through CBase1 failed");
+ check(cb4.cbase1y()!=7, "Derived3::cbase1y() through CBase1 failed");
+ check(cb5.cbase2()!=8, "Derived3::cbase2() through CBase2 failed");
+ check(ab6.abase1()!=5, "Derived2::abase1() through ABase1 failed");
+
+ //Test base classes as parameter in java
+ multiple_inheritance_shared_ptr_runme mhar=new multiple_inheritance_shared_ptr_runme();
+ check(mhar.jcbase1b(d1)!=3, "jcbase1b() through Derived1 as parameter failed");
+ check(mhar.jcbase1b(d2)!=6, "jcbase1b() through Derived2 as parameter failed");
+ check(mhar.jcbase1b(d3)!=7, "jcbase1b() through Derived3 as parameter failed");
+ check(mhar.jcbase2(d1)!=4, "jcbase2() through Derived1 as parameter failed");
+ check(mhar.jcbase2(d3)!=8, "jcbase2() through Derived3 as parameter failed");
+ check(mhar.jabase1(d2)!=5, "jabase1() through Derived2 as parameter failed");
+ check(mhar.jabase1(d3)!=9, "jabase1() through Derived3 as parameter failed");
+
+ //Value parameters
+ //Test CBase1 CBase2 as parameters (note slicing for Derived and Bottom classes)
+ check(multiple_inheritance_shared_ptr.InputValCBase1(d1)!=1, "InputValCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase1(d2)!=1, "InputValCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase1(d3)!=1, "InputValCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase2(d3)!=2, "InputValCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase2(d1)!=2, "InputValCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase1(cb1)!=1, "InputValCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase2(cb2)!=2, "InputValCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase1(b1)!=1, "InputValCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase1(b2)!=1, "InputValCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase1(b3)!=1, "InputValCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase2(b3)!=2, "InputValCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputValCBase2(b1)!=2, "InputValCBase2(), Bottom1 as a parameter failed");
+
+ //Pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_shared_ptr.InputPtrABase1(d2)!=5, "InputPtrABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrABase1(d3)!=9, "InputPtrABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrABase1(b2)!=205, "InputPtrABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrABase1(b3)!=309, "InputPtrABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(d1)!=3, "InputPtrCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(d2)!=6, "InputPtrCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(d3)!=7, "InputPtrCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase2(d3)!=8, "InputPtrCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase2(d1)!=4, "InputPtrCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(cb1)!=1, "InputPtrCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase2(cb2)!=2, "InputPtrCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(b1)!=103, "InputPtrCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(b2)!=206, "InputPtrCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase1(b3)!=307, "InputPtrCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase2(b3)!=308, "InputPtrCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputPtrCBase2(b1)!=104, "InputPtrCBase2(), Bottom1 as a parameter failed");
+
+ //Reference parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_shared_ptr.InputRefABase1(d2)!=5, "InputRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefABase1(d3)!=9, "InputRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefABase1(b2)!=205, "InputRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefABase1(b3)!=309, "InputRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(d1)!=3, "InputRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(d2)!=6, "InputRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(d3)!=7, "InputRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase2(d3)!=8, "InputRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase2(d1)!=4, "InputRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(cb1)!=1, "InputRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase2(cb2)!=2, "InputRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(b1)!=103, "InputRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(b2)!=206, "InputRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase1(b3)!=307, "InputRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase2(b3)!=308, "InputRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputRefCBase2(b1)!=104, "InputRefCBase2(), Bottom1 as a parameter failed");
+
+ //Const reference pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_shared_ptr.InputCPtrRefABase1(d2)!=5, "InputCPtrRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefABase1(d3)!=9, "InputCPtrRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefABase1(b2)!=205, "InputCPtrRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefABase1(b3)!=309, "InputCPtrRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(d1)!=3, "InputCPtrRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(d2)!=6, "InputCPtrRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(d3)!=7, "InputCPtrRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase2(d3)!=8, "InputCPtrRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase2(d1)!=4, "InputCPtrRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(cb1)!=1, "InputCPtrRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase2(cb2)!=2, "InputCPtrRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(b1)!=103, "InputCPtrRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(b2)!=206, "InputCPtrRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase1(b3)!=307, "InputCPtrRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase2(b3)!=308, "InputCPtrRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefCBase2(b1)!=104, "InputCPtrRefCBase2(), Bottom1 as a parameter failed");
+
+ //Shared pointer parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_shared_ptr.InputSharedPtrABase1(d2)!=5, "InputSharedPtrABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrABase1(d3)!=9, "InputSharedPtrABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrABase1(b2)!=205, "InputSharedPtrABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrABase1(b3)!=309, "InputSharedPtrABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(d1)!=3, "InputSharedPtrCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(d2)!=6, "InputSharedPtrCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(d3)!=7, "InputSharedPtrCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase2(d3)!=8, "InputSharedPtrCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase2(d1)!=4, "InputSharedPtrCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(cb1)!=1, "InputSharedPtrCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase2(cb2)!=2, "InputSharedPtrCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(b1)!=103, "InputSharedPtrCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(b2)!=206, "InputSharedPtrCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase1(b3)!=307, "InputSharedPtrCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase2(b3)!=308, "InputSharedPtrCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrCBase2(b1)!=104, "InputSharedPtrCBase2(), Bottom1 as a parameter failed");
+
+ //Shared pointer reference parameters
+ //Test ABase1 as a parameter
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefABase1(d2)!=5, "InputSharedPtrRefABase1() through Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefABase1(d3)!=9, "InputSharedPtrRefABase1() through Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefABase1(b2)!=205, "InputSharedPtrRefABase1() through Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefABase1(b3)!=309, "InputSharedPtrRefABase1() through Bottom3 as a parameter failed");
+
+ //Test CBase1 CBase2 as parameters
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(d1)!=3, "InputSharedPtrRefCBase1(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(d2)!=6, "InputSharedPtrRefCBase1(), Derived2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(d3)!=7, "InputSharedPtrRefCBase1(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase2(d3)!=8, "InputSharedPtrRefCBase2(), Derived3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase2(d1)!=4, "InputSharedPtrRefCBase2(), Derived1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(cb1)!=1, "InputSharedPtrRefCBase1(), CBase1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase2(cb2)!=2, "InputSharedPtrRefCBase2(), CBase2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(b1)!=103, "InputSharedPtrRefCBase1(), Bottom1 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(b2)!=206, "InputSharedPtrRefCBase1(), Bottom2 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase1(b3)!=307, "InputSharedPtrRefCBase1(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase2(b3)!=308, "InputSharedPtrRefCBase2(), Bottom3 as a parameter failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefCBase2(b1)!=104, "InputSharedPtrRefCBase2(), Bottom1 as a parameter failed");
+
+ //Derived classes as parameters
+ check(multiple_inheritance_shared_ptr.InputValDerived1(d1)!=3+4, "InputValDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputValDerived2(d2)!=6+5, "InputValDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputValDerived3(d3)!=7+8+9, "InputValDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputRefDerived1(d1)!=3+4, "InputRefDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputRefDerived2(d2)!=6+5, "InputRefDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputRefDerived3(d3)!=7+8+9, "InputRefDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputPtrDerived1(d1)!=3+4, "InputPtrDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputPtrDerived2(d2)!=6+5, "InputPtrDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputPtrDerived3(d3)!=7+8+9, "InputPtrDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputCPtrRefDerived1(d1)!=3+4, "InputCPtrRefDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefDerived2(d2)!=6+5, "InputCPtrRefDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefDerived3(d3)!=7+8+9, "InputCPtrRefDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputSharedPtrDerived1(d1)!=3+4, "InputSharedPtrDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrDerived2(d2)!=6+5, "InputSharedPtrDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrDerived3(d3)!=7+8+9, "InputSharedPtrDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefDerived1(d1)!=3+4, "InputSharedPtrRefDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefDerived2(d2)!=6+5, "InputSharedPtrRefDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefDerived3(d3)!=7+8+9, "InputSharedPtrRefDerived3() failed");
+
+ //Bottom classes as Derived parameters
+ check(multiple_inheritance_shared_ptr.InputValDerived1(b1)!=3+4, "InputValDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputValDerived2(b2)!=6+5, "InputValDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputValDerived3(b3)!=7+8+9, "InputValDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputRefDerived1(b1)!=103+104, "InputRefDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputRefDerived2(b2)!=206+205, "InputRefDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputRefDerived3(b3)!=307+308+309, "InputRefDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputPtrDerived1(b1)!=103+104, "InputPtrDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputPtrDerived2(b2)!=206+205, "InputPtrDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputPtrDerived3(b3)!=307+308+309, "InputPtrDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputCPtrRefDerived1(b1)!=103+104, "InputCPtrRefDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefDerived2(b2)!=206+205, "InputCPtrRefDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefDerived3(b3)!=307+308+309, "InputCPtrRefDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputSharedPtrDerived1(b1)!=103+104, "InputSharedPtrDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrDerived2(b2)!=206+205, "InputSharedPtrDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrDerived3(b3)!=307+308+309, "InputSharedPtrDerived3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefDerived1(b1)!=103+104, "InputSharedPtrRefDerived1() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefDerived2(b2)!=206+205, "InputSharedPtrRefDerived2() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefDerived3(b3)!=307+308+309, "InputSharedPtrRefDerived3() failed");
+
+ //Bottom classes as Bottom parameters
+ check(multiple_inheritance_shared_ptr.InputValBottom1(b1)!=103+104, "InputValBottom1() failed");
+ check(multiple_inheritance_shared_ptr.InputValBottom2(b2)!=206+205, "InputValBottom2() failed");
+ check(multiple_inheritance_shared_ptr.InputValBottom3(b3)!=307+308+309, "InputValBottom3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputRefBottom1(b1)!=103+104, "InputRefBottom1() failed");
+ check(multiple_inheritance_shared_ptr.InputRefBottom2(b2)!=206+205, "InputRefBottom2() failed");
+ check(multiple_inheritance_shared_ptr.InputRefBottom3(b3)!=307+308+309, "InputRefBottom3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputPtrBottom1(b1)!=103+104, "InputPtrBottom1() failed");
+ check(multiple_inheritance_shared_ptr.InputPtrBottom2(b2)!=206+205, "InputPtrBottom2() failed");
+ check(multiple_inheritance_shared_ptr.InputPtrBottom3(b3)!=307+308+309, "InputPtrBottom3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputCPtrRefBottom1(b1)!=103+104, "InputCPtrRefBottom1() failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefBottom2(b2)!=206+205, "InputCPtrRefBottom2() failed");
+ check(multiple_inheritance_shared_ptr.InputCPtrRefBottom3(b3)!=307+308+309, "InputCPtrRefBottom3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputSharedPtrBottom1(b1)!=103+104, "InputSharedPtrBottom1() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrBottom2(b2)!=206+205, "InputSharedPtrBottom2() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrBottom3(b3)!=307+308+309, "InputSharedPtrBottom3() failed");
+
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefBottom1(b1)!=103+104, "InputSharedPtrRefBottom1() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefBottom2(b2)!=206+205, "InputSharedPtrRefBottom2() failed");
+ check(multiple_inheritance_shared_ptr.InputSharedPtrRefBottom3(b3)!=307+308+309, "InputSharedPtrRefBottom3() failed");
+
+ // Return pointers
+ check(multiple_inheritance_shared_ptr.MakePtrDerived1_CBase1().cbase1y()!=3, "MakePtrDerived1_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakePtrDerived1_CBase2().cbase2()!=4, "MakePtrDerived1_CBase2 failed");
+ check(multiple_inheritance_shared_ptr.MakePtrDerived2_CBase1().cbase1y()!=6, "MakePtrDerived2_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakePtrDerived2_ABase1().abase1()!=5, "MakePtrDerived2_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakePtrDerived3_ABase1().abase1()!=9, "MakePtrDerived3_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakePtrDerived3_CBase1().cbase1y()!=7, "MakePtrDerived3_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakePtrDerived3_CBase2().cbase2()!=8, "MakePtrDerived3_CBase2 failed");
+
+ // Return references
+ check(multiple_inheritance_shared_ptr.MakeRefDerived1_CBase1().cbase1y()!=3, "MakeRefDerived1_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeRefDerived1_CBase2().cbase2()!=4, "MakeRefDerived1_CBase2 failed");
+ check(multiple_inheritance_shared_ptr.MakeRefDerived2_CBase1().cbase1y()!=6, "MakeRefDerived2_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeRefDerived2_ABase1().abase1()!=5, "MakeRefDerived2_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeRefDerived3_ABase1().abase1()!=9, "MakeRefDerived3_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeRefDerived3_CBase1().cbase1y()!=7, "MakeRefDerived3_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeRefDerived3_CBase2().cbase2()!=8, "MakeRefDerived3_CBase2 failed");
+
+ // Return by value (sliced objects)
+ check(multiple_inheritance_shared_ptr.MakeValDerived1_CBase1().cbase1y()!=1, "MakeValDerived1_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeValDerived1_CBase2().cbase2()!=2, "MakeValDerived1_CBase2 failed");
+ check(multiple_inheritance_shared_ptr.MakeValDerived2_CBase1().cbase1y()!=1, "MakeValDerived2_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeValDerived3_CBase1().cbase1y()!=1, "MakeValDerived3_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeValDerived3_CBase2().cbase2()!=2, "MakeValDerived3_CBase2 failed");
+
+ // Return smart pointers
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived1_CBase1().cbase1y()!=3, "MakeSharedPtrDerived1_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived1_CBase2().cbase2()!=4, "MakeSharedPtrDerived1_CBase2 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived2_CBase1().cbase1y()!=6, "MakeSharedPtrDerived2_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived2_ABase1().abase1()!=5, "MakeSharedPtrDerived2_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived3_ABase1().abase1()!=9, "MakeSharedPtrDerived3_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived3_CBase1().cbase1y()!=7, "MakeSharedPtrDerived3_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrDerived3_CBase2().cbase2()!=8, "MakeSharedPtrDerived3_CBase2 failed");
+
+ // Return smart pointers references
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived1_CBase1().cbase1y()!=3, "MakeSharedPtrRefDerived1_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived1_CBase2().cbase2()!=4, "MakeSharedPtrRefDerived1_CBase2 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived2_CBase1().cbase1y()!=6, "MakeSharedPtrRefDerived2_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived2_ABase1().abase1()!=5, "MakeSharedPtrRefDerived2_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived3_ABase1().abase1()!=9, "MakeSharedPtrRefDerived3_ABase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived3_CBase1().cbase1y()!=7, "MakeSharedPtrRefDerived3_CBase1 failed");
+ check(multiple_inheritance_shared_ptr.MakeSharedPtrRefDerived3_CBase2().cbase2()!=8, "MakeSharedPtrRefDerived3_CBase2 failed");
+ }
+}
--- /dev/null
+
+import naturalvar_more.*;
+
+public class naturalvar_more_runme {
+ static {
+ try {
+ System.loadLibrary("naturalvar_more");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[])
+ {
+ S s = new S();
+ if (!s.getConst_string_member().equals("initial string value"))
+ throw new RuntimeException("Test 1 fail");
+ s.setString_member("some member value");
+ if (!s.getString_member().equals("some member value"))
+ throw new RuntimeException("Test 2 fail");
+ }
+}
--- /dev/null
+
+import naturalvar_onoff.*;
+
+public class naturalvar_onoff_runme {
+ static {
+ try {
+ System.loadLibrary("naturalvar_onoff");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[])
+ {
+ boolean fail = true;
+ Vars vars = new Vars();
+
+ fail = true; try {
+ vars.setMember1On(null);
+ } catch(NullPointerException e) {fail = false;} if (fail) throw new RuntimeException("Failed");
+
+ vars.setMember2Off(null);
+
+ vars.setMember3Off(null);
+
+ fail = true; try {
+ vars.setMember3On(null);
+ } catch(NullPointerException e) {fail = false;} if (fail) throw new RuntimeException("Failed");
+
+ vars.setMember4Off(null);
+
+ fail = true; try {
+ vars.setMember4On(null);
+ } catch(NullPointerException e) {fail = false;} if (fail) throw new RuntimeException("Failed");
+ }
+}
public static void main(String argv[]) {
Outer outer = new Outer();
- SWIGTYPE_p_Outer__InnerStruct1 is1 = outer.makeInnerStruct1();
- SWIGTYPE_p_Outer__InnerClass1 ic1 = outer.makeInnerClass1();
- SWIGTYPE_p_Outer__InnerUnion1 iu1 = outer.makeInnerUnion1();
+ Outer.InnerStruct1 is1 = outer.makeInnerStruct1();
+ Outer.InnerClass1 ic1 = outer.makeInnerClass1();
+ Outer.InnerUnion1 iu1 = outer.makeInnerUnion1();
- SWIGTYPE_p_Outer__InnerStruct2 is2 = outer.makeInnerStruct2();
- SWIGTYPE_p_Outer__InnerClass2 ic2 = outer.makeInnerClass2();
- SWIGTYPE_p_Outer__InnerUnion2 iu2 = outer.makeInnerUnion2();
+ Outer.InnerStruct2 is2 = outer.makeInnerStruct2();
+ Outer.InnerClass2 ic2 = outer.makeInnerClass2();
+ Outer.InnerUnion2 iu2 = outer.makeInnerUnion2();
- SWIGTYPE_p_Outer__InnerClass4Typedef ic4 = outer.makeInnerClass4Typedef();
- SWIGTYPE_p_Outer__InnerStruct4Typedef is4 = outer.makeInnerStruct4Typedef();
- SWIGTYPE_p_Outer__InnerUnion4Typedef iu4 = outer.makeInnerUnion4Typedef();
+ Outer.InnerClass4Typedef ic4 = outer.makeInnerClass4Typedef();
+ Outer.InnerStruct4Typedef is4 = outer.makeInnerStruct4Typedef();
+ Outer.InnerUnion4Typedef iu4 = outer.makeInnerUnion4Typedef();
- SWIGTYPE_p_Outer__InnerClass5 ic5 = outer.makeInnerClass5();
- SWIGTYPE_p_Outer__InnerStruct5 is5 = outer.makeInnerStruct5();
- SWIGTYPE_p_Outer__InnerUnion5 iu5 = outer.makeInnerUnion5();
+ Outer.InnerClass5Typedef ic5 = outer.makeInnerClass5();
+ Outer.InnerStruct5Typedef is5 = outer.makeInnerStruct5();
+ Outer.InnerUnion5Typedef iu5 = outer.makeInnerUnion5();
ic5 = outer.makeInnerClass5Typedef();
is5 = outer.makeInnerStruct5Typedef();
iu5 = outer.makeInnerUnion5Typedef();
{
- SWIGTYPE_p_Outer__InnerMultiple im1 = outer.getMultipleInstance1();
- SWIGTYPE_p_Outer__InnerMultiple im2 = outer.getMultipleInstance2();
- SWIGTYPE_p_Outer__InnerMultiple im3 = outer.getMultipleInstance3();
- SWIGTYPE_p_Outer__InnerMultiple im4 = outer.getMultipleInstance4();
+ Outer.InnerMultiple im1 = outer.getMultipleInstance1();
+ Outer.InnerMultiple im2 = outer.getMultipleInstance2();
+ Outer.InnerMultiple im3 = outer.getMultipleInstance3();
+ Outer.InnerMultiple im4 = outer.getMultipleInstance4();
}
{
- SWIGTYPE_p_Outer__InnerMultipleDerived im1 = outer.getMultipleDerivedInstance1();
- SWIGTYPE_p_Outer__InnerMultipleDerived im2 = outer.getMultipleDerivedInstance2();
- SWIGTYPE_p_Outer__InnerMultipleDerived im3 = outer.getMultipleDerivedInstance3();
- SWIGTYPE_p_Outer__InnerMultipleDerived im4 = outer.getMultipleDerivedInstance4();
+ Outer.InnerMultipleDerived im1 = outer.getMultipleDerivedInstance1();
+ Outer.InnerMultipleDerived im2 = outer.getMultipleDerivedInstance2();
+ Outer.InnerMultipleDerived im3 = outer.getMultipleDerivedInstance3();
+ Outer.InnerMultipleDerived im4 = outer.getMultipleDerivedInstance4();
}
{
- SWIGTYPE_p_Outer__InnerMultipleDerived im1 = outer.getMultipleDerivedInstance1();
- SWIGTYPE_p_Outer__InnerMultipleDerived im2 = outer.getMultipleDerivedInstance2();
- SWIGTYPE_p_Outer__InnerMultipleDerived im3 = outer.getMultipleDerivedInstance3();
- SWIGTYPE_p_Outer__InnerMultipleDerived im4 = outer.getMultipleDerivedInstance4();
+ Outer.InnerMultipleDerived im1 = outer.getMultipleDerivedInstance1();
+ Outer.InnerMultipleDerived im2 = outer.getMultipleDerivedInstance2();
+ Outer.InnerMultipleDerived im3 = outer.getMultipleDerivedInstance3();
+ Outer.InnerMultipleDerived im4 = outer.getMultipleDerivedInstance4();
}
{
- SWIGTYPE_p_Outer__InnerMultipleAnonTypedef1 mat1 = outer.makeInnerMultipleAnonTypedef1();
- SWIGTYPE_p_Outer__InnerMultipleAnonTypedef2 mat2 = outer.makeInnerMultipleAnonTypedef2();
- SWIGTYPE_p_Outer__InnerMultipleAnonTypedef3 mat3 = outer.makeInnerMultipleAnonTypedef3();
+ Outer.InnerMultipleAnonTypedef1 mat1 = outer.makeInnerMultipleAnonTypedef1();
+ Outer.InnerMultipleAnonTypedef1 mat2 = outer.makeInnerMultipleAnonTypedef2();
+ SWIGTYPE_p_p_Outer__InnerMultipleAnonTypedef1 mat3 = outer.makeInnerMultipleAnonTypedef3();
- SWIGTYPE_p_Outer__InnerMultipleNamedTypedef mnt = outer.makeInnerMultipleNamedTypedef();
- SWIGTYPE_p_Outer__InnerMultipleNamedTypedef mnt1 = outer.makeInnerMultipleNamedTypedef1();
- SWIGTYPE_p_Outer__InnerMultipleNamedTypedef mnt2 = outer.makeInnerMultipleNamedTypedef2();
+ Outer.InnerMultipleNamedTypedef1 mnt = outer.makeInnerMultipleNamedTypedef();
+ Outer.InnerMultipleNamedTypedef1 mnt1 = outer.makeInnerMultipleNamedTypedef1();
+ Outer.InnerMultipleNamedTypedef1 mnt2 = outer.makeInnerMultipleNamedTypedef2();
SWIGTYPE_p_p_Outer__InnerMultipleNamedTypedef mnt3 = outer.makeInnerMultipleNamedTypedef3();
}
{
- SWIGTYPE_p_Outer__InnerSameName isn = outer.makeInnerSameName();
+ Outer.InnerSameName isn = outer.makeInnerSameName();
}
}
}
--- /dev/null
+import nested_extend_c.*;
+
+public class nested_extend_c_runme {
+
+ static {
+ try {
+ System.loadLibrary("nested_extend_c");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) throws Throwable
+ {
+ {
+ hiA hi = new hiA();
+ if (hi.hi_extend() != 'h')
+ throw new RuntimeException("test failed");
+ }
+ {
+ lowA low = new lowA();
+ if (low.low_extend() != 99)
+ throw new RuntimeException("test failed");
+ }
+
+ {
+ hiB hi = new hiB();
+ if (hi.hi_extend() != 'h')
+ throw new RuntimeException("test failed");
+ }
+ {
+ lowB low = new lowB();
+ if (low.low_extend() != 99)
+ throw new RuntimeException("test failed");
+ }
+ {
+ FOO_bar foobar = new FOO_bar();
+ foobar.setD(1234);
+ if (foobar.getD() != 1234)
+ throw new RuntimeException("test failed");
+ foobar.bar_extend();
+ }
+ }
+}
nested_structs.setValues(outer, 10);
Outer_inner1 inner1 = outer.getInner1();
- Outer_inner2 inner2 = outer.getInner2();
- Outer_inner3 inner3 = outer.getInner3();
- Outer_inner4 inner4 = outer.getInner4();
+ Outer_inner1 inner2 = outer.getInner2();
+ Outer_inner1 inner3 = outer.getInner3();
+ Outer_inner1 inner4 = outer.getInner4();
if (inner1.getVal() != 10) throw new RuntimeException("failed inner1");
if (inner2.getVal() != 20) throw new RuntimeException("failed inner2");
if (inner3.getVal() != 20) throw new RuntimeException("failed inner3");
if (inner4.getVal() != 40) throw new RuntimeException("failed inner4");
- Outer_inside1 inside1 = outer.getInside1();
- Outer_inside2 inside2 = outer.getInside2();
- Outer_inside3 inside3 = outer.getInside3();
- Outer_inside4 inside4 = outer.getInside4();
+ Named inside1 = outer.getInside1();
+ Named inside2 = outer.getInside2();
+ Named inside3 = outer.getInside3();
+ Named inside4 = outer.getInside4();
if (inside1.getVal() != 100) throw new RuntimeException("failed inside1");
if (inside2.getVal() != 200) throw new RuntimeException("failed inside2");
if (inside3.getVal() != 200) throw new RuntimeException("failed inside3");
if (inside4.getVal() != 400) throw new RuntimeException("failed inside4");
+
+ outer.getInner1().setVal(11);
+ if (inner1.getVal() != 11) throw new RuntimeException("failed inner1 assignment");
+ Named named = new Named();
+ named.setVal(22);
+ outer.setInside2(named);
+ if (outer.getInside2().getVal() != 22) throw new RuntimeException("failed inside2 assignment");
}
}
--- /dev/null
+import nested_template_base.*;
+
+public class nested_template_base_runme {
+
+ static {
+ try {
+ System.loadLibrary("nested_template_base");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+ OuterC.InnerS ois = new OuterC.InnerS(123);
+ OuterC.InnerC oic = new OuterC.InnerC();
+
+ // Check base method is available
+ if (oic.outer(ois).getVal() != 123)
+ throw new RuntimeException("Wrong value calling outer");
+
+ // Check non-derived class using base class
+ if (oic.innerc().outer(ois).getVal() != 123)
+ throw new RuntimeException("Wrong value calling innerc");
+
+ }
+}
}
}
- public static String FILENAME_WINDOWS = "..\\..\\..\\..\\Examples\\test-suite\\preproc_line_file.i";
- public static String FILENAME_UNIX = "../../../../Examples/test-suite/preproc_line_file.i";
+ private static void test_file(String file, String suffix) throws Throwable
+ {
+// For swig-3.0.1 and earlier
+// String FILENAME_WINDOWS = "Examples\\test-suite\\preproc_line_file.i";
+// String FILENAME_UNIX = "Examples/test-suite/preproc_line_file.i";
+
+ String FILENAME_WINDOWS2 = "Examples\\test-suite\\java\\..\\preproc_line_file.i";
+ String FILENAME_UNIX2 = "Examples/test-suite/java/../preproc_line_file.i";
+
+ String FILENAME_WINDOWS3 = "..\\.\\..\\preproc_line_file.i";
+ String FILENAME_UNIX3 = ".././../preproc_line_file.i";
+
+ // We don't test for exact equality here because the file names are relative to the build directory, which can be different from the source directory,
+ // under Unix. But they do need to end with the same path components.
+ if (!file.endsWith(FILENAME_UNIX2 + suffix) && !file.endsWith(FILENAME_WINDOWS2 + suffix) &&
+ !file.endsWith(FILENAME_UNIX3 + suffix) && !file.endsWith(FILENAME_WINDOWS3 + suffix))
+ throw new RuntimeException("file \"" + file + "\" doesn't end with " + FILENAME_UNIX2 + suffix + " or " + FILENAME_UNIX3 + suffix);
+ }
+
public static void main(String argv[]) throws Throwable
{
int myline = preproc_line_file.MYLINE;
if (myline + 100 + 1 != myline_adjusted)
throw new RuntimeException("preproc failure");
- String myfile = preproc_line_file.MYFILE;
- String myfile_adjusted = preproc_line_file.MYFILE_ADJUSTED;
- if (!(myfile.equals(FILENAME_UNIX) || myfile.equals(FILENAME_WINDOWS)))
- throw new RuntimeException("preproc failure");
-
- if (!(myfile_adjusted.equals(FILENAME_UNIX + ".bak") || myfile_adjusted.equals(FILENAME_WINDOWS + ".bak")))
- throw new RuntimeException("preproc failure");
+ test_file(preproc_line_file.MYFILE, "");
+ test_file(preproc_line_file.MYFILE_ADJUSTED, ".bak");
if (!preproc_line_file.MY_STRINGNUM_A.equals("my15"))
throw new RuntimeException("preproc failed MY_STRINGNUM_A");
if (SillyMacroClass.LINE_NUM != 56)
throw new RuntimeException("preproc failure");
- if (SillyMultipleMacroStruct.LINE_NUM != 81)
+ if (SillyMulMacroStruc.LINE_NUM != 81)
throw new RuntimeException("preproc failure");
if (preproc_line_file.INLINE_LINE != 87)
throw new RuntimeException("preproc failure");
- String inlineFile = preproc_line_file.INLINE_FILE;
- if (!(inlineFile.equals(FILENAME_UNIX) || inlineFile.equals(FILENAME_WINDOWS)))
- throw new RuntimeException("preproc failure");
+ test_file(preproc_line_file.INLINE_FILE, "");
if (Slash.LINE_NUM != 93)
throw new RuntimeException("preproc failure");
public static void main(String argv[]) {
if (primitive_ref.ref_int(3) != 3) {
- System.err.println( "ref_int failed!" );
+ throw new RuntimeException( "ref_int failed!" );
}
if (primitive_ref.ref_uint(3) != 3) {
- System.err.println( "ref_uint failed!" );
+ throw new RuntimeException( "ref_uint failed!" );
}
if (primitive_ref.ref_short((short)3) != 3) {
- System.err.println( "ref_short failed!" );
+ throw new RuntimeException( "ref_short failed!" );
}
if (primitive_ref.ref_ushort(3) != 3) {
- System.err.println( "ref_ushort failed!" );
+ throw new RuntimeException( "ref_ushort failed!" );
}
if (primitive_ref.ref_long(3) != 3) {
- System.err.println( "ref_long failed!" );
+ throw new RuntimeException( "ref_long failed!" );
}
if (primitive_ref.ref_ulong(3) != 3) {
- System.err.println( "ref_ulong failed!" );
+ throw new RuntimeException( "ref_ulong failed!" );
}
if (primitive_ref.ref_schar((byte)3) != 3) {
- System.err.println( "ref_schar failed!" );
+ throw new RuntimeException( "ref_schar failed!" );
}
if (primitive_ref.ref_uchar((short)3) != 3) {
- System.err.println( "ref_uchar failed!" );
+ throw new RuntimeException( "ref_uchar failed!" );
}
if (primitive_ref.ref_bool(true) != true) {
- System.err.println( "ref_bool failed!" );
+ throw new RuntimeException( "ref_bool failed!" );
}
if (primitive_ref.ref_float((float)3.5) != 3.5) {
- System.err.println( "ref_float failed!" );
+ throw new RuntimeException( "ref_float failed!" );
}
if (primitive_ref.ref_double(3.5) != 3.5) {
- System.err.println( "ref_double failed!" );
+ throw new RuntimeException( "ref_double failed!" );
}
if (primitive_ref.ref_char('x') != 'x') {
- System.err.println( "ref_char failed!" );
+ throw new RuntimeException( "ref_char failed!" );
}
if (primitive_ref.ref_longlong(0x123456789ABCDEF0L) != 0x123456789ABCDEF0L) {
- System.err.println( "ref_longlong failed!" );
+ throw new RuntimeException( "ref_longlong failed!" );
}
BigInteger bi = new BigInteger("18446744073709551615"); //0xFFFFFFFFFFFFFFFFL
if (bi.compareTo(primitive_ref.ref_ulonglong(bi)) != 0) {
- System.err.println( "ref_ulonglong failed!" );
+ throw new RuntimeException( "ref_ulonglong failed!" );
}
}
}
public static void main(String argv[])
{
SomeWidget w = new SomeWidget();
- w.putBorderWidth(17);
- if ( w.getBorderWidth() != 17 )
+ w.put_borderWidth(17);
+ if ( w.get_borderWidth() != 17 )
throw new RuntimeException(String.format("Border with should be 17, not %d",
- w.getBorderWidth()));
+ w.get_borderWidth()));
+ if ( rename_pcre_encoder.StartINSAneAndUNSAvoryTraNSAtlanticRaNSAck() != 42 )
+ throw new RuntimeException("Unexpected result of renamed function call");
}
}
Assert(f.getAccess() == MUTABLE_ACCESS);
// Test static method
- b.stat();
+ b.statMethod();
Assert(f.getAccess() == CONST_ACCESS);
--- /dev/null
+import smart_pointer_ignore.*;
+
+public class smart_pointer_ignore_runme {
+
+ static {
+ try {
+ System.loadLibrary("smart_pointer_ignore");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+ DerivedPtr d = smart_pointer_ignore.makeDerived();
+ d.base();
+ d.derived();
+ }
+}
foo.setTType(a);
a = foo.method(a);
}
+
+ {
+ MapDefaults md = new MapDefaults();
+ md.test_func(10, 20, new DefaultNodeType());
+ }
}
}
T_NestedOuterTemplateDouble tn = new T_NestedOuterTemplateDouble();
if (tn.hohum(-12.3) != -12.3)
throw new RuntimeException("it failed");
+ OuterClass.T_OuterClassInner1Int inner1 = new OuterClass().useInner1(new OuterClass.T_OuterClassInner1Int());
+ OuterClass.T_OuterClassInner2NormalClass inner2 = new OuterClass.T_OuterClassInner2NormalClass();
+ inner2.setEmbeddedVar(2);
+ OuterClass.T_OuterClassInner2NormalClass inner22 = new OuterClass().useInner2Again(inner2);
+ OuterClass.T_OuterClassInner1Double inner3 = new OuterClass.T_OuterClassInner1Double();
}
}
--- /dev/null
+
+import template_templated_constructors.*;
+
+public class template_templated_constructors_runme {
+
+ static {
+ try {
+ System.loadLibrary("template_templated_constructors");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+ TConstructor1 t1 = new TConstructor1(123);
+ TConstructor2 t2a = new TConstructor2();
+ TConstructor2 t2b = new TConstructor2(123);
+
+ TClass1Int tc1 = new TClass1Int(123.4);
+ TClass2Int tc2a = new TClass2Int();
+ TClass2Int tc2b = new TClass2Int(123.4);
+
+ }
+}
+
--- /dev/null
+import template_typedef_typedef.*;
+
+public class template_typedef_typedef_runme {
+
+ static {
+ try {
+ System.loadLibrary("template_typedef_typedef");
+ } catch (UnsatisfiedLinkError e) {
+ System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
+ System.exit(1);
+ }
+ }
+
+ public static void main(String argv[]) {
+ Object1Base ob1 = new Object1Base();
+ ob1.getBlabla1(new Object1Base());
+ Object2Base ob2 = new Object2Base();
+ ob2.getBlabla2(new Object2Base());
+
+ Factory factory = new Factory();
+ factory.getBlabla3(new Object1Base());
+ factory.getBlabla4(new Object2Base());
+ }
+}
+
+
eut.getUni().setSmall(small);
short Jill1 = eut.getUni().getSmall().getJill();
if (Jill1 != 200) {
- System.err.println("Runtime test1 failed. eut.uni.small.jill=" + Jill1);
- System.exit(1);
+ throw new RuntimeException("Runtime test1 failed. eut.uni.small.jill=" + Jill1);
}
int Num1 = eut.getNumber();
if (Num1 != 1) {
- System.err.println("Runtime test2 failed. eut.number=" + Num1);
- System.exit(1);
+ throw new RuntimeException("Runtime test2 failed. eut.number=" + Num1);
}
// Secondly check the BigStruct in EmbeddedUnionTest
eut.getUni().setBig(big);
int Jack1 = eut.getUni().getBig().getJack();
if (Jack1 != 300) {
- System.err.println("Runtime test3 failed. eut.uni.big.jack=" + Jack1);
- System.exit(1);
+ throw new RuntimeException("Runtime test3 failed. eut.uni.big.jack=" + Jack1);
}
short Jill2 = eut.getUni().getBig().getSmallstruct().getJill();
if (Jill2 != 200) {
- System.err.println("Runtime test4 failed. eut.uni.big.smallstruct.jill=" + Jill2);
- System.exit(1);
+ throw new RuntimeException("Runtime test4 failed. eut.uni.big.smallstruct.jill=" + Jill2);
}
int Num2 = eut.getNumber();
if (Num2 != 2) {
- System.err.println("Runtime test5 failed. eut.number=" + Num2);
- System.exit(1);
+ throw new RuntimeException("Runtime test5 failed. eut.number=" + Num2);
}
}
}
--- /dev/null
+%module(directors="1") java_director_exception_feature
+
+%include <std_except.i>
+
+%warnfilter(SWIGWARN_TYPEMAP_DIRECTORTHROWS_UNDEF) MyNS::Foo::directorthrows_warning;
+
+%{
+#if defined(_MSC_VER)
+ #pragma warning(disable: 4290) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
+#endif
+
+#include <string>
+%}
+
+%include <std_string.i>
+
+// DEFINE exceptions in header section using std::runtime_error
+%{
+ #include <exception>
+ #include <iostream>
+
+ namespace MyNS {
+
+ struct Exception1 : public std::runtime_error {
+ Exception1(const std::string& what):runtime_error(what) {}
+ };
+ struct Exception2 : public std::runtime_error {
+ Exception2(const std::string& what):runtime_error(what) {}
+ };
+ struct Unexpected : public std::runtime_error {
+ Unexpected(const std::string& what):runtime_error(what) {}
+ };
+
+ }
+
+%}
+
+// Add an explicit handler for Foo::ping, mapping one java exception back to an 'int'
+%feature("director:except") MyNS::Foo::ping {
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ jenv->ExceptionClear(); // clear java exception since mapping to c++ exception
+ if (Swig::ExceptionMatches(jenv,$error,"$packagepath/MyJavaException1")) {
+ throw 1;
+ } else if (Swig::ExceptionMatches(jenv,$error,"$packagepath/MyJavaException2")) {
+ std::string msg(Swig::JavaExceptionMessage(jenv,$error).message());
+ throw MyNS::Exception2(msg);
+ } else {
+ std::cerr << "Test failed, unexpected exception thrown: " <<
+ Swig::JavaExceptionMessage(jenv,$error).message() << std::endl;
+ throw std::runtime_error("unexpected exception in Foo::ping");
+ }
+ }
+}
+
+// Use default handler on Foo::pong, with directorthrows typemaps
+
+// directorthrows typemaps for java->c++ conversions
+%typemap(directorthrows) MyNS::Exception1,MyNS::Exception2,MyNS::Unexpected %{
+ if (Swig::ExceptionMatches(jenv, $error, "$packagepath/$javaclassname")) {
+ std::string msg(Swig::JavaExceptionMessage(jenv,$error).message());
+ throw $1_type(msg);
+ }
+%}
+
+// Override the director:except feature so exception specification is not violated
+// (Cannot use built-in default of throw DirectorException)
+%feature("director:except") MyNS::Foo::pong %{
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ jenv->ExceptionClear();
+ $directorthrowshandlers
+ throw ::MyNS::Unexpected(Swig::JavaExceptionMessage(jenv,$error).message());
+ }
+%}
+
+// TODO 'throws' typemap emitted by emit_action (emit.cxx) has no way
+// to get access to language specific special variables like
+// $javaclassname or $packagepath ("java_director_exception_feature" here)
+
+// throws typemaps for c++->java exception conversions
+%typemap(throws,throws="MyJavaException1") MyNS::Exception1 %{
+ (void)$1;
+ jclass excpcls = jenv->FindClass("java_director_exception_feature/MyJavaException1");
+ if (excpcls) {
+ jenv->ThrowNew(excpcls, $1.what());
+ }
+ return $null;
+%}
+
+%typemap(throws,throws="MyJavaException1") int %{
+ (void)$1;
+ jclass excpcls = jenv->FindClass("java_director_exception_feature/MyJavaException1");
+ if (excpcls) {
+ jenv->ThrowNew(excpcls, "Threw some integer");
+ }
+ return $null;
+%}
+
+%typemap(throws,throws="MyJavaException2") MyNS::Exception2 %{
+ jclass excpcls = jenv->FindClass("java_director_exception_feature/MyJavaException2");
+ if (excpcls) {
+ jenv->ThrowNew(excpcls, $1.what());
+ }
+ return $null;
+%}
+
+%typemap(throws,throws="MyJavaUnexpected") MyNS::Unexpected %{
+ jclass excpcls = jenv->FindClass("java_director_exception_feature/MyJavaUnexpected");
+ if (excpcls) {
+ jenv->ThrowNew(excpcls, $1.what());
+ }
+ return $null;
+%}
+
+// Use generic exception translation approach like python, ruby
+
+%feature("director:except") MyNS::Foo::genericpong {
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ jenv->ExceptionClear();
+ throw Swig::DirectorException(jenv,$error);
+ }
+}
+
+// %exception with throws attribute. Need throws attribute for checked exceptions
+%feature ("except",throws="Exception") MyNS::Foo::genericpong %{
+%}
+
+%feature ("except",throws="Exception") MyNS::Bar::genericpong %{
+ try { $action }
+ catch (Swig::DirectorException & direxcp) {
+ direxcp.raiseJavaException(jenv); // jenv always available in JNI code
+ return $null;
+ }
+%}
+
+
+
+%feature("director") Foo;
+
+// Rename exceptions on java side to make translation of exceptions more clear
+%rename(MyJavaException1) MyNS::Exception1;
+%rename(MyJavaException2) MyNS::Exception2;
+%rename(MyJavaUnexpected) MyNS::Unexpected;
+
+%typemap(javabase) ::MyNS::Exception1,::MyNS::Exception2,::MyNS::Unexpected "java.lang.Exception";
+%rename(getMessage) what() const; // Rename all what() methods
+
+namespace MyNS {
+
+ struct Exception1 {
+ Exception1(const std::string& what);
+ const char * what() const;
+ };
+ struct Exception2 {
+ Exception2(const std::string& what);
+ const char * what() const;
+ };
+ struct Unexpected {
+ Unexpected(const std::string& what);
+ const char * what() const;
+ };
+
+}
+// In general it is better to use %catches instead of an exception specification on the method
+// since violating an exception specification calls terminate() preventing catch-all behavior
+// like throwing std::runtime_error. But an exception specification must be used if the
+// actual interface being wrapped does use them.
+%catches(MyNS::Exception1,MyNS::Exception2,MyNS::Unexpected) MyNS::Foo::pong;
+%catches(MyNS::Exception1,MyNS::Exception2,MyNS::Unexpected) MyNS::Bar::pong;
+
+%inline %{
+
+namespace MyNS {
+
+class Foo {
+public:
+ virtual ~Foo() {}
+ // ping java implementation throws a java Exception1 or an Exception2 if excp is 1 or 2.
+ // pong java implementation throws Exception1,Exception2,Unexpected,NullPointerException for 1,2,3,4
+ virtual std::string ping(int excp) throw(int,MyNS::Exception2) = 0;
+ virtual std::string pong(int excp) /* throws MyNS::Exception1 MyNS::Exception2 MyNS::Unexpected) */ = 0;
+ virtual std::string genericpong(int excp) /* unspecified throws - exception is always DirectorException in C++, translated back to whatever thrown in java */ = 0;
+ virtual std::string directorthrows_warning(int excp) throw(double) { return std::string(); }
+};
+
+// Make a bar from a foo, so a call to Java Bar
+// goes Java Bar -> C++ Bar -> C++ Foo -> Java Foo Director
+
+class Bar {
+public:
+ Bar(Foo* d) { delegate=d; }
+ virtual std::string ping(int excp) throw(int,MyNS::Exception2)
+ {
+ return delegate->ping(excp);
+ }
+
+ virtual std::string pong(int excp) /* throws MyNS::Exception1,MyNS::Exception2,MyNS::Unexpected */
+ {
+ return delegate->pong(excp);
+ }
+
+ virtual std::string genericpong(int excp)
+ {
+ return delegate->genericpong(excp);
+ }
+
+private:
+ Foo * delegate;
+};
+
+}
+%}
--- /dev/null
+%module(directors="1") java_director_exception_feature_nspace
+
+%include <std_except.i>
+
+%nspace; // turn namespace feature on for everything.
+
+#define PACKAGEDOT "java_director_exception_feature_nspacePackage."
+#define PACKAGESLASH "java_director_exception_feature_nspacePackage/"
+%{
+#define PACKAGEDOT "java_director_exception_feature_nspacePackage."
+#define PACKAGESLASH "java_director_exception_feature_nspacePackage/"
+%}
+
+%{
+#if defined(_MSC_VER)
+ #pragma warning(disable: 4290) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
+#endif
+
+#include <string>
+%}
+
+%include <std_string.i>
+
+// DEFINE exceptions in header section using std::runtime_error
+%{
+ #include <exception>
+ #include <iostream>
+
+ namespace MyNS {
+
+ struct Exception1 : public std::runtime_error {
+ Exception1(const std::string& what):runtime_error(what) {}
+ };
+ struct Exception2 : public std::runtime_error {
+ Exception2(const std::string& what):runtime_error(what) {}
+ };
+ struct Unexpected : public std::runtime_error {
+ Unexpected(const std::string& what):runtime_error(what) {}
+ };
+
+ }
+
+%}
+
+// Add an explicit handler for Foo::ping, mapping one java exception back to an 'int'
+%feature("director:except") MyNS::Foo::ping {
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ jenv->ExceptionClear(); // clear java exception since mapping to c++ exception
+ if (Swig::ExceptionMatches(jenv,$error,"$packagepath/MyNS/MyJavaException1")) {
+ throw 1;
+ } else if (Swig::ExceptionMatches(jenv,$error,"$packagepath/MyNS/MyJavaException2")) {
+ std::string msg(Swig::JavaExceptionMessage(jenv,$error).message());
+ throw MyNS::Exception2(msg);
+ } else {
+ std::cerr << "Test failed, unexpected exception thrown: " <<
+ Swig::JavaExceptionMessage(jenv,$error).message() << std::endl;
+ throw std::runtime_error("unexpected exception in Foo::ping");
+ }
+ }
+}
+
+// Use default handler on Foo::pong, with directorthrows typemaps
+
+// directorthrows typemaps for java->c++ conversions
+%typemap(directorthrows) MyNS::Exception1,MyNS::Exception2,MyNS::Unexpected %{
+ if (Swig::ExceptionMatches(jenv, $error, "$packagepath/$javaclassname")) {
+ std::string msg(Swig::JavaExceptionMessage(jenv,$error).message());
+ throw $1_type(msg);
+ }
+%}
+
+// Override the director:except feature so exception specification is not violated
+// (Cannot use built-in default of throw DirectorException)
+%feature("director:except") MyNS::Foo::pong %{
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ jenv->ExceptionClear();
+ $directorthrowshandlers
+ throw ::MyNS::Unexpected(Swig::JavaExceptionMessage(jenv,$error).message());
+ }
+%}
+
+// TODO 'throws' typemap emitted by emit_action (emit.cxx) has no way
+// to get access to language specific special variables like
+// $javaclassname or $packagepath ("java_director_exception_feature" here)
+
+// throws typemaps for c++->java exception conversions
+%typemap(throws,throws=PACKAGEDOT"MyNS.MyJavaException1") MyNS::Exception1 %{
+ jclass excpcls = jenv->FindClass(PACKAGESLASH"MyNS/MyJavaException1");
+ if (excpcls) {
+ jenv->ThrowNew(excpcls, $1.what());
+ }
+ return $null;
+%}
+
+%typemap(throws,throws=PACKAGEDOT"MyNS.MyJavaException1") int %{
+ (void)$1;
+ jclass excpcls = jenv->FindClass(PACKAGESLASH"MyNS/MyJavaException1");
+ if (excpcls) {
+ jenv->ThrowNew(excpcls, "Threw some integer");
+ }
+ return $null;
+%}
+
+%typemap(throws,throws=PACKAGEDOT"MyNS.MyJavaException2") MyNS::Exception2 %{
+ jclass excpcls = jenv->FindClass(PACKAGESLASH"MyNS/MyJavaException2");
+ if (excpcls) {
+ jenv->ThrowNew(excpcls, $1.what());
+ }
+ return $null;
+%}
+
+
+%typemap(throws,throws=PACKAGEDOT"MyNS.MyJavaUnexpected") MyNS::Unexpected %{
+ jclass excpcls = jenv->FindClass(PACKAGESLASH"MyNS/MyJavaUnexpected");
+ if (excpcls) {
+ jenv->ThrowNew(excpcls, $1.what());
+ }
+ return $null;
+%}
+
+// Use generic exception translation approach like python, ruby
+
+%feature("director:except") MyNS::Foo::genericpong {
+ jthrowable $error = jenv->ExceptionOccurred();
+ if ($error) {
+ jenv->ExceptionClear();
+ throw Swig::DirectorException(jenv,$error);
+ }
+}
+
+// %exception with throws attribute. Need throws attribute for checked exceptions
+%feature ("except",throws="Exception") MyNS::Foo::genericpong %{
+%}
+
+%feature ("except",throws="Exception") MyNS::Bar::genericpong %{
+ try { $action }
+ catch (Swig::DirectorException & direxcp) {
+ direxcp.raiseJavaException(jenv); // jenv always available in JNI code
+ return $null;
+ }
+%}
+
+
+
+%feature("director") Foo;
+
+// Rename exceptions on java side to make translation of exceptions more clear
+%rename(MyJavaException1) MyNS::Exception1;
+%rename(MyJavaException2) MyNS::Exception2;
+%rename(MyJavaUnexpected) MyNS::Unexpected;
+
+%typemap(javabase) ::MyNS::Exception1,::MyNS::Exception2,::MyNS::Unexpected "java.lang.Exception";
+%rename(getMessage) what() const; // Rename all what() methods
+
+namespace MyNS {
+
+ struct Exception1 {
+ Exception1(const std::string& what);
+ const char * what() const;
+ };
+ struct Exception2 {
+ Exception2(const std::string& what);
+ const char * what() const;
+ };
+ struct Unexpected {
+ Unexpected(const std::string& what);
+ const char * what() const;
+ };
+
+}
+// In general it is better to use %catches instead of an exception specification on the method
+// since violating an exception specification calls terminate() preventing catch-all behavior
+// like throwing std::runtime_error. But an exception specification must be used if the
+// actual interface being wrapped does use them.
+%catches(MyNS::Exception1,MyNS::Exception2,MyNS::Unexpected) MyNS::Foo::pong;
+%catches(MyNS::Exception1,MyNS::Exception2,MyNS::Unexpected) MyNS::Bar::pong;
+
+%inline %{
+
+namespace MyNS {
+
+class Foo {
+public:
+ virtual ~Foo() {}
+ // ping java implementation throws a java Exception1 or an Exception2 if excp is 1 or 2.
+ // pong java implementation throws Exception1,Exception2,Unexpected,NullPointerException for 1,2,3,4
+ virtual std::string ping(int excp) throw(int,MyNS::Exception2) = 0;
+ virtual std::string pong(int excp) /* throws MyNS::Exception1 MyNS::Exception2 MyNS::Unexpected) */ = 0;
+ virtual std::string genericpong(int excp) /* unspecified throws - exception is always DirectorException in C++, translated back to whatever thrown in java */ = 0;
+};
+
+// Make a bar from a foo, so a call to Java Bar
+// goes Java Bar -> C++ Bar -> C++ Foo -> Java Foo Director
+
+class Bar {
+public:
+ Bar(Foo* d) { delegate=d; }
+ virtual std::string ping(int excp) throw(int,MyNS::Exception2)
+ {
+ return delegate->ping(excp);
+ }
+
+ virtual std::string pong(int excp) /* throws MyNS::Exception1,MyNS::Exception2,MyNS::Unexpected */
+ {
+ return delegate->pong(excp);
+ }
+
+ virtual std::string genericpong(int excp)
+ {
+ return delegate->genericpong(excp);
+ }
+
+private:
+ Foo * delegate;
+};
+
+}
+%}
--- /dev/null
+%module(directors="1") java_director_ptrclass
+
+// Tests that custom director typemaps can be used with C++ types that
+// represent a pointer, in such a way that Java perceives this class as
+// equivalent to the underlying type. In particular, this verifies that
+// a typemap lookup within a typemap kwarg, in this case
+// directorin:descriptor, works as expected.
+
+%{
+namespace bar {
+class Baz {
+public:
+ Baz() : touched(false) {}
+ void SetTouched() { touched = true; }
+ bool GetTouched() { return touched; }
+private:
+ bool touched;
+};
+
+template <typename T>
+class Ptr {
+public:
+ Ptr(T* b) : b_(b) {}
+ T* Get() const { return b_; }
+private:
+ T* b_;
+};
+
+class Foo {
+public:
+ // Calling FinalMaybeTouch from Java unambiguously goes through C++ to
+ // reach MaybeTouch.
+ Ptr< bar::Baz > FinalMaybeTouch(Baz* b) {
+ return MaybeTouch(Ptr< bar::Baz >(b));
+ }
+ virtual Ptr< bar::Baz > MaybeTouch(Ptr< bar::Baz > f) {
+ return f; /* Don't touch */
+ }
+ virtual ~Foo() {}
+};
+}
+%}
+
+%feature("director") Foo;
+
+%typemap(jni) bar::Ptr< bar::Baz > "jlong"
+%typemap(jtype) bar::Ptr< bar::Baz > "long"
+%typemap(jstype) bar::Ptr< bar::Baz > "Baz"
+%typemap(in) bar::Ptr< bar::Baz > {
+ $1 = bar::Ptr< bar::Baz >(*( bar::Baz**)&$input);
+}
+%typemap(out) bar::Ptr< bar::Baz > {
+ const bar::Ptr< bar::Baz >& ptr = $1;
+ if (ptr.Get()) {
+ $result = ($typemap(jni, bar::Baz))ptr.Get();
+ } else {
+ $result = 0;
+ }
+}
+%typemap(javain) bar::Ptr< bar::Baz > "$typemap(jstype, bar::Baz).getCPtr($javainput)"
+%typemap(javaout) bar::Ptr< bar::Baz > {
+ long cPtr = $jnicall;
+ return (cPtr == 0) ? null : new $typemap(jstype, bar::Baz)(cPtr, false);
+}
+%typemap(directorin, descriptor="L$packagepath/$typemap(jstype, bar::Baz);") bar::Ptr< bar::Baz >
+%{ *((bar::Baz**)&$input) = ((bar::Ptr< bar::Baz >&)$1).Get(); %}
+%typemap(directorout) bar::Ptr< bar::Baz > {
+ $result = bar::Ptr< bar::Baz >(*( bar::Baz**)&$input);
+}
+%typemap(javadirectorin) bar::Ptr< bar::Baz > %{
+ ((long)$jniinput == 0) ? null : new $typemap(jstype, bar::Baz)($jniinput, false)
+%}
+%typemap(javadirectorout) bar::Ptr< bar::Baz > "$typemap(jstype, bar::Baz).getCPtr($javacall)"
+
+namespace bar {
+class Baz {
+public:
+ Baz() : touched(false) {}
+ void SetTouched() { touched = true; }
+ bool GetTouched() { return touched; }
+private:
+ bool touched;
+};
+
+template <typename T>
+class Ptr {
+public:
+ Ptr(T* b) : b_(b) {}
+ T* Get() { return b_; }
+private:
+ T* b_;
+};
+
+class Foo {
+public:
+ // Calling FinalMaybeTouch from Java unambiguously goes through C++ to
+ // reach MaybeTouch.
+ Ptr< bar::Baz > FinalMaybeTouch(Baz* b) {
+ return MaybeTouch(Ptr< bar::Baz >(b));
+ }
+ virtual Ptr< bar::Baz > MaybeTouch(Ptr< bar::Baz > f) {
+ return f; /* Don't touch */
+ }
+ virtual ~Foo() {}
+};
+}
+
%apply char **STRING_ARRAY { char **languages };
%apply char *BYTE { char *chars };
%apply char **STRING_OUT { char **string_ptr };
+%apply unsigned char *NIOBUFFER { unsigned char *buf };
%typemap(freearg) char **languages "" // don't delete memory when setting global variable
%{
*string_ptr = ret;
}
+void niobuffer_fill_hello(unsigned char *buf) {
+ sprintf ((char*)buf,"hello");
+}
%}
// Create a new getCPtr() function which takes Java null and is public
%typemap(javabody) NS::Greeting %{
- private long swigCPtr;
- protected boolean swigCMemOwn;
+ private transient long swigCPtr;
+ protected transient boolean swigCMemOwn;
protected $javaclassname(long cPtr, boolean cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
// Make the pointer constructor public
%typemap(javabody) NS::Farewell %{
- private long swigCPtr;
- protected boolean swigCMemOwn;
+ private transient long swigCPtr;
+ protected transient boolean swigCMemOwn;
public $javaclassname(long cPtr, boolean cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
// Create a new getCPtr() function which takes Java null and is public
// Make the pointer constructor public
%typemap(javabody) Farewell * %{
- private long swigCPtr;
+ private transient long swigCPtr;
public $javaclassname(long cPtr, boolean bFutureUse) {
swigCPtr = cPtr;
--- /dev/null
+#######################################################################
+# Makefile for javascript test-suite
+#######################################################################
+
+LANGUAGE = javascript
+NODEGYP = @NODEGYP@
+NODEJS = @NODEJS@
+SCRIPTSUFFIX = _runme.js
+OBJEXT = @OBJEXT@
+SO = @SO@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+top_builddir = @top_builddir@
+
+SWIGEXE = $(top_builddir)/swig
+SWIG_LIB_DIR = $(top_srcdir)/Lib
+
+ifneq (, $(ENGINE))
+ JSENGINE=$(ENGINE)
+else
+ JSENGINE=node
+endif
+
+ifneq (, $(V8_VERSION))
+ JSV8_VERSION=$(V8_VERSION)
+else
+ JSV8_VERSION=0x031110
+endif
+
+include $(srcdir)/../common.mk
+
+SWIGOPT += -DV8_VERSION=$(JSV8_VERSION)
+
+_setup = \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ echo "$(ACTION)ing $(LANGUAGE) ($(JSENGINE)) testcase $* (with run test)" ; \
+ else \
+ echo "$(ACTION)ing $(LANGUAGE) ($(JSENGINE)) testcase $*" ; \
+ fi;
+
+ifeq (node,$(JSENGINE))
+
+ SWIGOPT += -v8 -DBUILDING_NODE_EXTENSION=1
+
+ # shut up some warnings
+ # contract macro has an empty 'else' at the end...
+ aggregate.cpptest: GYP_CFLAGS = \"-Wno-empty-body\"
+ contract.cpptest: GYP_CFLAGS = \"-Wno-empty-body\"
+
+ # dunno... ignoring generously
+ apply_signed_char.cpptest: GYP_CFLAGS = \"-Wno-ignored-qualifiers\"
+ constant_pointers.cpptest: GYP_CFLAGS = \"-Wno-ignored-qualifiers\"
+ enum_thorough.cpptest: GYP_CFLAGS = \"-Wno-ignored-qualifiers\"
+
+ setup_node = \
+ test -d $* || mkdir $* && \
+ sed -e 's|$$testcase|$*|g; s|$$cflags|$(GYP_CFLAGS)|g; s|$$srcdir|$(srcdir)|g' \
+ $(srcdir)/node_template/binding.gyp.in > $*/binding.gyp && \
+ sed -e 's|$$testcase|$*|g;' \
+ $(srcdir)/node_template/index.js.in > $*/index.js
+
+ # Note: we need to use swig in C parse mode, but make node-gyp believe it is c++ (via file extension)
+ swig_and_compile_c = \
+ $(setup_node) && \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-javascript $(SWIGOPT) -o $*_wrap.cxx $(srcdir)/../$*.i' swiginvoke && \
+ $(COMPILETOOL) $(NODEGYP) --loglevel=silent --directory $* configure build 1>>/dev/null
+
+ swig_and_compile_cpp = \
+ $(setup_node) && \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' \
+ SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \
+ SWIGOPT='-c++ -javascript $(SWIGOPT) $(srcdir)/../$*.i' swiginvoke && \
+ $(COMPILETOOL) $(NODEGYP) --loglevel=silent --directory $* configure build 1>>/dev/null
+
+ run_testcase = \
+ if [ -f $(srcdir)/$*$(SCRIPTSUFFIX) ]; then \
+ env NODE_PATH=$$PWD:$(srcdir) $(RUNTOOL) $(NODEJS) $(srcdir)/$*$(SCRIPTSUFFIX); \
+ fi
+
+
+ %.ctest:
+ $(_setup)
+ $(swig_and_compile_c)
+ $(run_testcase)
+
+ %.cpptest:
+ $(_setup)
+ $(swig_and_compile_cpp)
+ $(run_testcase)
+
+ %.multicpptest:
+ $(_setup)
+
+else
+
+ SWIGOPT += -$(JSENGINE)
+
+ run_testcase = \
+ if [ -f $(srcdir)/$*$(SCRIPTSUFFIX) ]; then \
+ $(RUNTOOL) $(top_builddir)/Tools/javascript/javascript -$(JSENGINE) $(srcdir)/$*$(SCRIPTSUFFIX); \
+ fi
+
+ %.ctest:
+ $(_setup)
+ +$(swig_and_compile_c)
+ $(run_testcase)
+
+ %.cpptest:
+ $(_setup)
+ +$(swig_and_compile_cpp)
+ $(run_testcase)
+
+ %.multicpptest:
+ $(_setup)
+ +$(swig_and_compile_multi_cpp)
+ $(run_testcase)
+
+endif
+
+
+%.clean:
+ @rm -rf $*
+ @rm -f $*_wrap.* $*$(SO) $*.$(OBJEXT)
+
+clean:
+ for ext in _wrap.cxx _wrap.$(OBJEXT) $(SO); do \
+ rm -f clientdata_prop_a$${ext} clientdata_prop_b$${ext}; \
+ rm -f imports_a$${ext} imports_b$${ext}; \
+ rm -f import_stl_a$${ext} import_stl_b$${ext}; \
+ rm -f mod_a$${ext} mod_b$${ext}; \
+ rm -f multi_import_a$${ext} multi_import_b$${ext}; \
+ rm -f packageoption_a$${ext} packageoption_b$${ext} packageoption_c$${ext}; \
+ done
--- /dev/null
+var abstract_access = require("abstract_access");
+
+var d = new abstract_access.D()
+if (d.do_x() != 1) {
+ throw "Error";
+}
--- /dev/null
+var abstract_inherit = require("abstract_inherit");
+
+// Shouldn't be able to instantiate any of these classes
+// since none of them implements the pure virtual function
+// declared in the base class (Foo).
+var Foo = abstract_inherit.Foo;
+var Bar = abstract_inherit.Bar;
+var Spam = abstract_inherit.Spam;
+
+var caughtException = false;
+try {
+ new Foo();
+} catch (err) {
+ caughtException = true;
+}
+if (!caughtException) {
+ throw new Error("Foo should be instantiated as it is abstract");
+}
+
+caughtException = false;
+try {
+ new Bar();
+} catch (err) {
+ caughtException = true;
+}
+
+if (!caughtException) {
+ throw new Error("Bar should be instantiated as it is abstract");
+}
+
+caughtException = false;
+try {
+ new Spam();
+} catch (err) {
+ caughtException = true;
+}
+
+if (!caughtException) {
+ throw new Error("Spam should be instantiated as it is abstract");
+}
--- /dev/null
+var abstract_typedef2 = require("abstract_typedef2");
+
+var a = new abstract_typedef2.A_UF();
+
+if (a == undefined)
+ throw "Error";
--- /dev/null
+var abstract_typedef = require("abstract_typedef");
+
+var e = new abstract_typedef.Engine();
+var a = new abstract_typedef.A()
+
+if (a.write(e) != 1) {
+ throw "Error";
+}
--- /dev/null
+var abstract_virtual = require("abstract_virtual");
+
+d = new abstract_virtual.D()
+
+if (d == undefined)
+ throw "Error";
+
+e = new abstract_virtual.E()
+
+if (e == undefined)
+ throw "Error";
--- /dev/null
+var array_member = require("array_member");
+
+var f = new array_member.Foo();
+f.data = array_member.global_data;
+
+for (var i=0; i<8; i++) {
+ if (array_member.get_value(f.data,i) != array_member.get_value(array_member.global_data,i)) {
+ throw "Bad array assignment (1)";
+ }
+}
+
+for (var i=0; i<8; i++) {
+ array_member.set_value(f.data,i,-i);
+}
+
+array_member.global_data = f.data;
+
+for (var i=0; i<8; i++){
+ if (array_member.get_value(f.data,i) != array_member.get_value(array_member.global_data,i)) {
+ throw "Bad array assignment (2)";
+ }
+}
--- /dev/null
+var arrays_global = require("arrays_global");
+
+arrays_global.array_i = arrays_global.array_const_i;
+
+arrays_global.BeginString_FIX44a;
+arrays_global.BeginString_FIX44b;
+arrays_global.BeginString_FIX44c;
+arrays_global.BeginString_FIX44d;
+arrays_global.BeginString_FIX44d;
+arrays_global.BeginString_FIX44b = "12"+'\0'+"45";
+arrays_global.BeginString_FIX44b;
+arrays_global.BeginString_FIX44d;
+arrays_global.BeginString_FIX44e;
+arrays_global.BeginString_FIX44f;
+
+arrays_global.test_a("hello","hi","chello","chi");
+
+arrays_global.test_b("1234567","hi");
--- /dev/null
+var callback = require("callback");
+
+if (callback.foo(2) !== 2) {
+ throw new Error("Failed.");
+}
+if (callback.A_bar(2) !== 4) {
+ throw new Error("Failed.");
+}
+if (callback.foobar(3, callback.foo) != callback.foo(3)) {
+ throw new Error("Failed.");
+}
+if (callback.foobar(3, foo) != callback.foo(3)) {
+ throw new Error("Failed.");
+}
+if (callback.foobar(3, callback.A_bar) != callback.A_bar(3)) {
+ throw new Error("Failed.");
+}
+if (callback.foobar(3, callback.foof) != callback.foof(3)) {
+ throw new Error("Failed.");
+}
+if (callback.foobar_i(3, callback.foo_i) != callback.foo_i(3)) {
+ throw new Error("Failed.");
+}
+if (callback.foobar_d(3.5, callback.foo_d) != callback.foo_d(3.5)) {
+ throw new Error("Failed.");
+}
+var a = new callback.A();
+if (callback.foobarm(3, a, callback.A.foom_cb_ptr) != a.foom(3)) {
+ throw new Error("Failed.");
+}
--- /dev/null
+var char_binary = require("char_binary");
+
+var t = new char_binary.Test();
+if (t.strlen('hile') != 4) {
+ print(t.strlen('hile'));
+ throw("bad multi-arg typemap 1");
+}
+if (t.ustrlen('hile') != 4) {
+ print(t.ustrlen('hile'));
+ throw("bad multi-arg typemap 1");
+}
+
+if (t.strlen('hil\0') != 4) {
+ throw("bad multi-arg typemap 2");
+}
+if (t.ustrlen('hil\0') != 4) {
+ throw("bad multi-arg typemap 2");
+}
+
+/*
+ * creating a raw char*
+ */
+var pc = char_binary.new_pchar(5);
+char_binary.pchar_setitem(pc, 0, 'h');
+char_binary.pchar_setitem(pc, 1, 'o');
+char_binary.pchar_setitem(pc, 2, 'l');
+char_binary.pchar_setitem(pc, 3, 'a');
+char_binary.pchar_setitem(pc, 4, 0);
+
+
+if (t.strlen(pc) != 4) {
+ throw("bad multi-arg typemap (3)");
+}
+if (t.ustrlen(pc) != 4) {
+ throw("bad multi-arg typemap (3)");
+}
+
+char_binary.var_pchar = pc;
+if (char_binary.var_pchar != "hola") {
+ print(char_binary.var_pchar);
+ throw("bad pointer case (1)");
+}
+
+char_binary.var_namet = pc;
+if (char_binary.var_namet != "hola") {
+ throw("bad pointer case (2)");
+}
+char_binary.delete_pchar(pc);
--- /dev/null
+var char_strings = require("char_strings");
+
+var assertIsEqual = function(expected, actual) {
+ if (expected !== actual) {
+ throw new Error("Expected "+expected+", was "+actual);
+ }
+};
+
+assertIsEqual("hi there", char_strings.CharPingPong("hi there"));
+assertIsEqual("hi there", char_strings.CharArrayPingPong("hi there"));
+assertIsEqual("hi there", char_strings.CharArrayDimsPingPong("hi there"));
--- /dev/null
+var class_ignore = require("class_ignore");
+
+a = new class_ignore.Bar();
+
+if (class_ignore.do_blah(a) != "Bar::blah")
+ throw "Error";
--- /dev/null
+var class_scope_weird = require("class_scope_weird");
+
+f = new class_scope_weird.Foo();
+g = new class_scope_weird.Foo(3);
+if (f.bar(3) != 3)
+ throw RuntimeError;
--- /dev/null
+var complextest = require("complextest");
+
+a = [-1,2];
+
+expected = [-1, -2];
+
+a_c = complextest.Conj(a);
+if (a_c.toString() != expected.toString())
+ throw "Error in Conj(a)";
+
+a_c_f = complextest.Conjf(a);
+if (a_c_f.toString() != expected.toString())
+ throw "Error in Conjf(a)";
+
+v = new complextest.VectorStdCplx();
+v.add([1,2]);
+v.add([2,3]);
+v.add([4,3]);
+v.add(1);
+
+// TODO: how to check validity?
+complextest.Copy_h(v);
--- /dev/null
+var constover = require("constover");
+
+p = constover.test("test");
+if (p != "test") {
+ throw "test failed!";
+}
+
+p = constover.test_pconst("test");
+if (p != "test_pconst") {
+ throw "test_pconst failed!";
+}
+
+f = new constover.Foo();
+
+p = f.test("test");
+if (p != "test") {
+ throw "member-test failed!";
+}
+
+p = f.test_pconst("test");
+if (p != "test_pconst") {
+ throw "member-test_pconst failed!";
+}
+
+p = f.test_constm("test");
+if (p != "test_constmethod") {
+ throw "member-test_constm failed!";
+}
+
+p = f.test_pconstm("test");
+if (p != "test_pconstmethod") {
+ throw "member-test_pconstm failed!";
+}
--- /dev/null
+var constructor_copy = require("constructor_copy");
+
+f1 = new constructor_copy.Foo1(3);
+f11 = new constructor_copy.Foo1(f1);
+
+if (f1.x != f11.x) {
+ throw "error in ctor copy for Foo1";
+}
+
+var good = 0;
+
+f8 = new constructor_copy.Foo8()
+try {
+ f81 = new constructor_copy.Foo8(f8);
+ good = 0;
+} catch (err) {
+ good = 1;
+}
+
+if (good == 0) {
+ throw "Error: should not allow calling copy ctor for Foo8";
+}
+
+
+bi = new constructor_copy.Bari(5);
+bc = new constructor_copy.Bari(bi);
+
+if (bi.x != bc.x) {
+ throw "Error in copy ctor of Bari";
+}
+
+bd = new constructor_copy.Bard(5);
+try {
+ bc = new constructor_copy.Bard(bd);
+ good = 0;
+} catch (err) {
+ good = 1;
+}
+
+if (good == 0) {
+ throw "Error: should not allow calling copy ctor for Bard";
+}
--- /dev/null
+var cpp11_strongly_typed_enumerations = require("cpp11_strongly_typed_enumerations");
+
+function enumCheck(actual, expected) {
+ if (actual != expected) {
+ throw new Error("Enum value mismatch. Expected: " + expected + " Actual: " + actual);
+ }
+ return expected + 1;
+}
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val3, 13);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val5a, 13);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val6a, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val3, 23);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val5b, 23);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val6b, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Val3, 43);
+val = enumCheck(cpp11_strongly_typed_enumerations.Val4, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum5_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum5_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum5_Val3, 53);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum5_Val4, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum6_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum6_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum6_Val3, 63);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum6_Val4, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum7td_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum7td_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum7td_Val3, 73);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum7td_Val4, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum8_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum8_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum8_Val3, 83);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum8_Val4, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum10_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum10_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum10_Val3, 103);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum10_Val4, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum12_Val1, 1121);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum12_Val2, 1122);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum12_Val3, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum12_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum12_Val5c, 1121);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum12_Val6c, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Val1, 1131);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Val2, 1132);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Val3, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Val5d, 1131);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Val6d, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum14_Val1, 1141);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum14_Val2, 1142);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum14_Val3, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum14_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum14_Val5e, 1141);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum14_Val6e, val);
+
+// Requires nested class support to work
+//val = 0;
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val1, 3121);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val2, 3122);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val3, val);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val4, val);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val5f, 3121);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val6f, val);
+//
+//val = 0;
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Val1, 3131);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Val2, 3132);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Val3, val);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Val4, val);
+//
+//val = 0;
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum14_Val1, 3141);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum14_Val2, 3142);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum14_Val3, val);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum14_Val4, val);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum14_Val5g, 3141);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum14_Val6g, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum12_Val1, 2121);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum12_Val2, 2122);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum12_Val3, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum12_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum12_Val5h, 2121);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum12_Val6h, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Val1, 2131);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Val2, 2132);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Val3, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Val5i, 2131);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Val6i, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum14_Val1, 2141);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum14_Val2, 2142);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum14_Val3, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum14_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum14_Val5j, 2141);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum14_Val6j, val);
+
+// Requires nested class support to work
+//val = 0;
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Enum12_Val1, 4121);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Enum12_Val2, 4122);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Enum12_Val3, val);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Enum12_Val4, val);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Enum12_Val5k, 4121);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Enum12_Val6k, val);
+//
+//val = 0;
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Val1, 4131);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Val2, 4132);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Val3, val);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Val4, val);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Val5l, 4131);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Val6l, val);
+//
+//val = 0;
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Enum14_Val1, 4141);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Enum14_Val2, 4142);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Enum14_Val3, val);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Enum14_Val4, val);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Enum14_Val5m, 4141);
+//val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1_Enum14_Val6m, val);
+
+class1 = new cpp11_strongly_typed_enumerations.Class1();
+enumCheck(class1.class1Test1(cpp11_strongly_typed_enumerations.Enum1_Val5a), 13);
+enumCheck(class1.class1Test2(cpp11_strongly_typed_enumerations.Class1.Enum12_Val5c), 1121);
+//enumCheck(class1.class1Test3(cpp11_strongly_typed_enumerations.Class1.Struct1_Enum12_Val5f), 3121);
+
+enumCheck(cpp11_strongly_typed_enumerations.globalTest1(cpp11_strongly_typed_enumerations.Enum1_Val5a), 13);
+enumCheck(cpp11_strongly_typed_enumerations.globalTest2(cpp11_strongly_typed_enumerations.Class1.Enum12_Val5c), 1121);
+//enumCheck(globalTest3(cpp11_strongly_typed_enumerations.Class1.Struct1_Enum12_Val5f), 3121);
--- /dev/null
+var cpp_enum = require("cpp_enum");
+
+var f = new cpp_enum.Foo()
+
+if(f.hola != cpp_enum.Hello){
+ print(f.hola);
+ throw "Error";
+}
+
+f.hola = cpp_enum.Foo.Hi
+if(f.hola != cpp_enum.Foo.Hi){
+ print(f.hola);
+ throw "Error";
+}
+
+f.hola = cpp_enum.Hello
+
+if(f.hola != cpp_enum.Hello){
+ print(f.hola);
+ throw "Error";
+}
+
+cpp_enum.Foo.hi = cpp_enum.Hello
+if(cpp_enum.Foo.hi != cpp_enum.Hello){
+ print(cpp_enum.Foo.hi);
+ throw "Error";
+}
+
--- /dev/null
+var cpp_namespace = require("cpp_namespace");
+
+var n = cpp_namespace.fact(4);
+if (n != 24){
+ throw ("Bad return value error!");
+}
+if (cpp_namespace.Foo != 42){
+ throw ("Bad variable value error!");
+}
+
+t = new cpp_namespace.Test();
+if (t.method() != "Test::method"){
+ throw ("Bad method return value error!");
+}
+if (cpp_namespace.do_method(t) != "Test::method"){
+ throw ("Bad return value error!");
+}
+
+if (cpp_namespace.do_method2(t) != "Test::method"){
+ throw ("Bad return value error!");
+}
+cpp_namespace.weird("hello", 4);
+delete t;
+
+t2 = new cpp_namespace.Test2();
+t3 = new cpp_namespace.Test3();
+t4 = new cpp_namespace.Test4();
+t5 = new cpp_namespace.Test5();
+if (cpp_namespace.foo3(42) != 42){
+ throw ("Bad return value error!");
+}
+
+if (cpp_namespace.do_method3(t2,40) != "Test2::method"){
+ throw ("Bad return value error!");
+}
+
+if (cpp_namespace.do_method3(t3,40) != "Test3::method"){
+ throw ("Bad return value error!");
+}
+
+if (cpp_namespace.do_method3(t4,40) != "Test4::method"){
+ throw ("Bad return value error!");
+}
+
+if (cpp_namespace.do_method3(t5,40) != "Test5::method"){
+ throw ("Bad return value error!");
+}
--- /dev/null
+var cpp_static = require("cpp_static");
+
+cpp_static.StaticFunctionTest.static_func();
+cpp_static.StaticFunctionTest.static_func_2(1);
+cpp_static.StaticFunctionTest.static_func_3(1,2);
+cpp_static.StaticMemberTest.static_int = 10;
+if (cpp_static.StaticMemberTest.static_int != 10)
+throw "error";
+
--- /dev/null
+var director_alternating = require("director_alternating");
+
+id = director_alternating.getBar().id();
+if (id != director_alternating.idFromGetBar())
+ throw ("Error, Got wrong id: " + str(id));
--- /dev/null
+var disown = require("disown");
+
+var a = new disown.A();
+var tmp = a.thisown;
+a.thisown = 0
+if (a.thisown) {
+ throw new Error("Failed.");
+}
+a.thisown = 1
+if (!a.thisown) {
+ throw new Error("Failed.");
+}
+a.thisown = tmp
+if (a.thisown != tmp) {
+ throw new Error("Failed.");
+}
+
+var b = new disown.B();
+b.acquire(a);
+if (a.thisown) {
+ throw new Error("Failed.");
+}
--- /dev/null
+var dynamic_cast = require("dynamic_cast");
+
+var f = new dynamic_cast.Foo();
+var b = new dynamic_cast.Bar();
+
+var x = f.blah();
+var y = b.blah();
+
+var a = dynamic_cast.do_test(y);
+if (a != "Bar::test") {
+ throw new Error("Failed.");
+}
--- /dev/null
+var empty_c = require("empty_c");
--- /dev/null
+var empty = require("empty");
\ No newline at end of file
--- /dev/null
+var enum_template = require("enum_template");
+
+if (enum_template.MakeETest() != 1)
+ throw "RuntimeError";
+
+if (enum_template.TakeETest(0) != null)
+ throw "RuntimeError";
+
--- /dev/null
+var infinity = require("infinity");
+
+infinity.initialise_MYINFINITY();
+var my_infinity = infinity.INFINITY;
+var ret_val = infinity.use_infinity(my_infinity);
--- /dev/null
+var namespace_virtual_method = require("namespace_virtual_method");
+
+x = new namespace_virtual_method.Spam();
--- /dev/null
+{
+ "targets": [
+ {
+ "target_name": "$testcase",
+ "sources":[ "../$testcase_wrap.cxx" ],
+ "include_dirs": ["../$srcdir/.."],
+ 'defines': [
+ 'BUILDING_NODE_EXTENSION=1',
+ ],
+ 'conditions': [
+ ['OS=="mac"',
+ {
+ 'xcode_settings': {
+ 'GCC_ENABLE_CPP_RTTI': 'YES',
+ 'GCC_ENABLE_CPP_EXCEPTIONS' : 'YES'
+ }
+ }
+ ],
+ ['OS=="linux" or OS=="freebsd" or OS=="openbsd" or OS=="solaris"',
+ {
+ 'cflags': [ "-Wno-unused-variable", "-Wno-unused-but-set-variable", "-Wno-unused-but-set-parameter", $cflags],
+ 'cflags_cc': [ "-Wno-unused-variable", "-Wno-unused-but-set-variable", "-Wno-unused-but-set-parameter", $cflags],
+ 'cflags!': [ '-fno-exceptions' ],
+ 'cflags_cc!': [ '-fno-exceptions', '-fno-rtti' ]
+ }
+ ]
+ ],
+ }
+ ],
+}
--- /dev/null
+module.exports = require('./build/Release/$testcase');
--- /dev/null
+var nspace_extend = require("nspace_extend");
+
+// constructors and destructors
+var color1 = new nspace_extend.Outer.Inner1.Color();
+var color = new nspace_extend.Outer.Inner1.Color(color1);
+delete color1;
+
+// class methods
+color.colorInstanceMethod(20.0);
+nspace_extend.Outer.Inner1.Color.colorStaticMethod(20.0);
+var created = nspace_extend.Outer.Inner1.Color.create();
+
+
+// constructors and destructors
+var color2 = new nspace_extend.Outer.Inner2.Color();
+color = new nspace_extend.Outer.Inner2.Color(color2);
+delete color2;
+
+// class methods
+color.colorInstanceMethod(20.0);
+nspace_extend.Outer.Inner2.Color.colorStaticMethod(20.0);
+created = nspace_extend.Outer.Inner2.Color.create();
+
+// Same class different namespaces
+var col1 = new nspace_extend.Outer.Inner1.Color();
+var col2 = nspace_extend.Outer.Inner2.Color.create();
+col2.colors(col1, col1, col2, col2, col2);
--- /dev/null
+var nspace = require("nspace");
+
+var color1 = new nspace.Outer.Inner1.Color();
+var color = new nspace.Outer.Inner1.Color(color1);
+delete color1;
+
+// class methods
+color.colorInstanceMethod(20.0);
+nspace.Outer.Inner1.Color.colorStaticMethod(20.0);
+var created = nspace.Outer.Inner1.Color.create();
+
+// class enums
+var someClass = new nspace.Outer.SomeClass();
+var channel = someClass.GetInner1ColorChannel();
+if (channel != nspace.Outer.Inner1.Color.Transmission) {
+ throw new Error("Failed.");
+}
+
+// class anonymous enums
+var val1 = nspace.Outer.Inner1.Color.ColorEnumVal1;
+var val2 = nspace.Outer.Inner1.Color.ColorEnumVal2;
+if (val1 !== 0 || val2 !== 0x22) {
+ throw new Error("Failed.");
+}
+
+// instance member variables
+color.instanceMemberVariable = 123;
+if (color.instanceMemberVariable !== 123) {
+ throw new Error("Failed.");
+}
+
+// static member variables
+nspace.Outer.Inner1.Color.staticMemberVariable = 789;
+if (nspace.Outer.Inner1.Color.staticMemberVariable !== 789) {
+ throw new Error("Failed.");
+}
+
+if (nspace.Outer.Inner1.Color.staticConstMemberVariable !== 222) {
+ throw new Error("Failed.");
+}
+
+if (nspace.Outer.Inner1.Color.staticConstEnumMemberVariable !== nspace.Outer.Inner1.Color.Transmission) {
+ throw new Error("Failed.");
+}
+
+// Same class different namespaces
+var col1 = new nspace.Outer.Inner1.Color();
+var col2 = nspace.Outer.Inner2.Color.create();
+col2.colors(col1, col1, col2, col2, col2);
+
+nspace.Outer.Inner1.namespaceFunction(color);
+nspace.Outer.Inner1.namespaceVar = 111;
+if (nspace.Outer.Inner1.namespaceVar !== 111) {
+ throw new Error("Failed.");
+}
+
+// global enums
+var outerChannel1 = someClass.GetInner1Channel();
+if (outerChannel1 != nspace.Outer.Inner1.Transmission1) {
+ throw new Error("Failed.");
+}
+
+var outerChannel2 = someClass.GetInner2Channel();
+if (outerChannel2 !== nspace.Outer.Inner2.Transmission2) {
+ throw new Error("Failed.");
+}
+
+// turn feature off / ignoring
+var ns = new nspace.Outer.namespce();
+var nons = new nspace.NoNSpacePlease();
+
+// Derived class
+var blue3 = new nspace.Outer.Inner3.Blue();
+blue3.blueInstanceMethod();
+var blue4 = new nspace.Outer.Inner4.Blue();
+blue4.blueInstanceMethod();
--- /dev/null
+var null_pointer = require("null_pointer");
+
+if (!null_pointer.func(null)) {
+ throw new Error("Javascript 'null' should be converted into NULL.");
+}
+
+if (null_pointer.getnull() != null) {
+ throw new Error("NULL should be converted into Javascript 'null'.");
+}
--- /dev/null
+var overload_copy = require("overload_copy");
+
+f = new overload_copy.Foo();
+g = new overload_copy.Foo(f);
--- /dev/null
+var preproc_include = require("preproc_include");
+
+if (preproc_include.multiply10(10) != 100)
+ throw "RuntimeError";
+
+if (preproc_include.multiply20(10) != 200)
+ throw "RuntimeError";
+
+if (preproc_include.multiply30(10) != 300)
+ throw "RuntimeError";
+
+if (preproc_include.multiply40(10) != 400)
+ throw "RuntimeError";
+
+if (preproc_include.multiply50(10) != 500)
+ throw "RuntimeError";
+
+if (preproc_include.multiply60(10) != 600)
+ throw "RuntimeError";
+
+if (preproc_include.multiply70(10) != 700)
+ throw "RuntimeError";
+
--- /dev/null
+var preproc = require("preproc");
+
+if (preproc.endif != 1)
+ throw "RuntimeError";
+
+if (preproc.define != 1)
+ throw "RuntimeError";
+
+if (preproc.defined != 1)
+ throw "RuntimeError";
+
+if (2*preproc.one != preproc.two)
+ throw "RuntimeError";
+
--- /dev/null
+var rename = require("rename1");
+
+function part1() {
+ var xyz = new rename.XYZInt();
+ notxyz = new rename.NotXYZInt();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother2();
+ xyz.opT2();
+ xyz.tMethod2(0);
+ xyz.tMethodNotXYZ2(notxyz);
+ xyz.opNotXYZ2();
+ xyz.opXYZ2();
+}
+
+function part2() {
+ var xyz = new rename.XYZDouble();
+ var notxyz = new rename.NotXYZDouble();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother1();
+ xyz.opT1();
+ xyz.tMethod1(0);
+ xyz.tMethodNotXYZ1(notxyz);
+ xyz.opNotXYZ1();
+ xyz.opXYZ1();
+}
+
+function part3(){
+ var xyz = new rename.XYZKlass();
+ var notxyz = new rename.NotXYZKlass();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother3();
+ xyz.opT3();
+ xyz.tMethod3(new rename.Klass());
+ xyz.tMethodNotXYZ3(notxyz);
+ xyz.opNotXYZ3();
+ xyz.opXYZ3();
+}
+
+function part4() {
+ var xyz = new rename.XYZEnu();
+ var notxyz = new rename.NotXYZEnu();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother4();
+ xyz.opT4();
+ xyz.tMethod4(rename.En1);
+ xyz.tMethodNotXYZ4(notxyz);
+ xyz.opNotXYZ4();
+ xyz.opXYZ4();
+}
+
+function part5() {
+ var abc = new rename.ABC();
+ abc.methodABC(abc);
+ var k = new rename.Klass();
+ abc.methodKlass(k);
+ var a = abc.opABC();
+ k = abc.opKlass();
+}
+
+part1();
+part2();
+part3();
+part4();
+part5();
--- /dev/null
+var rename = require("rename2");
+
+function part1() {
+ var xyz = new rename.XYZInt();
+ notxyz = new rename.NotXYZInt();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother2();
+ xyz.opT2();
+ xyz.tMethod2(0);
+ xyz.tMethodNotXYZ2(notxyz);
+ xyz.opNotXYZ2();
+ xyz.opXYZ2();
+}
+
+function part2() {
+ var xyz = new rename.XYZDouble();
+ var notxyz = new rename.NotXYZDouble();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother1();
+ xyz.opT1();
+ xyz.tMethod1(0);
+ xyz.tMethodNotXYZ1(notxyz);
+ xyz.opNotXYZ1();
+ xyz.opXYZ1();
+}
+
+function part3(){
+ var xyz = new rename.XYZKlass();
+ var notxyz = new rename.NotXYZKlass();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother3();
+ xyz.opT3();
+ xyz.tMethod3(new rename.Klass());
+ xyz.tMethodNotXYZ3(notxyz);
+ xyz.opNotXYZ3();
+ xyz.opXYZ3();
+}
+
+function part4() {
+ var xyz = new rename.XYZEnu();
+ var notxyz = new rename.NotXYZEnu();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother4();
+ xyz.opT4();
+ xyz.tMethod4(rename.En1);
+ xyz.tMethodNotXYZ4(notxyz);
+ xyz.opNotXYZ4();
+ xyz.opXYZ4();
+}
+
+function part5() {
+ var abc = new rename.ABC();
+ abc.methodABC(abc);
+ var k = new rename.Klass();
+ abc.methodKlass(k);
+ var a = abc.opABC();
+ k = abc.opKlass();
+}
+
+part1();
+part2();
+part3();
+part4();
+part5();
--- /dev/null
+var rename = require("rename3");
+
+function part1() {
+ var xyz = new rename.XYZInt();
+ notxyz = new rename.NotXYZInt();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother2();
+ xyz.opT2();
+ xyz.tMethod2(0);
+ xyz.tMethodNotXYZ2(notxyz);
+ xyz.opNotXYZ2();
+ xyz.opXYZ2();
+}
+
+function part2() {
+ var xyz = new rename.XYZDouble();
+ var notxyz = new rename.NotXYZDouble();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother1();
+ xyz.opT1();
+ xyz.tMethod1(0);
+ xyz.tMethodNotXYZ1(notxyz);
+ xyz.opNotXYZ1();
+ xyz.opXYZ1();
+}
+
+function part3(){
+ var xyz = new rename.XYZKlass();
+ var notxyz = new rename.NotXYZKlass();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother3();
+ xyz.opT3();
+ xyz.tMethod3(new rename.Klass());
+ xyz.tMethodNotXYZ3(notxyz);
+ xyz.opNotXYZ3();
+ xyz.opXYZ3();
+}
+
+function part4() {
+ var xyz = new rename.XYZEnu();
+ var notxyz = new rename.NotXYZEnu();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother4();
+ xyz.opT4();
+ xyz.tMethod4(rename.En1);
+ xyz.tMethodNotXYZ4(notxyz);
+ xyz.opNotXYZ4();
+ xyz.opXYZ4();
+}
+
+function part5() {
+ var abc = new rename.ABC();
+ abc.methodABC(abc);
+ var k = new rename.Klass();
+ abc.methodKlass(k);
+ var a = abc.opABC();
+ k = abc.opKlass();
+}
+
+part1();
+part2();
+part3();
+part4();
+part5();
--- /dev/null
+var rename = require("rename4");
+
+function part1() {
+ var xyz = new rename.XYZInt();
+ notxyz = new rename.NotXYZInt();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother2();
+ xyz.opT2();
+ xyz.tMethod2(0);
+ xyz.tMethodNotXYZ2(notxyz);
+ xyz.opNotXYZ2();
+ xyz.opXYZ2();
+}
+
+function part2() {
+ var xyz = new rename.XYZDouble();
+ var notxyz = new rename.NotXYZDouble();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother1();
+ xyz.opT1();
+ xyz.tMethod1(0);
+ xyz.tMethodNotXYZ1(notxyz);
+ xyz.opNotXYZ1();
+ xyz.opXYZ1();
+}
+
+function part3(){
+ var xyz = new rename.XYZKlass();
+ var notxyz = new rename.NotXYZKlass();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother3();
+ xyz.opT3();
+ xyz.tMethod3(new rename.Klass());
+ xyz.tMethodNotXYZ3(notxyz);
+ xyz.opNotXYZ3();
+ xyz.opXYZ3();
+}
+
+function part4() {
+ var xyz = new rename.XYZEnu();
+ var notxyz = new rename.NotXYZEnu();
+ xyz.opIntPtrA();
+ xyz.opIntPtrB();
+ xyz.opAnother4();
+ xyz.opT4();
+ xyz.tMethod4(rename.En1);
+ xyz.tMethodNotXYZ4(notxyz);
+ xyz.opNotXYZ4();
+ xyz.opXYZ4();
+}
+
+function part5() {
+ var abc = new rename.ABC();
+ abc.methodABC(abc);
+ var k = new rename.Klass();
+ abc.methodKlass(k);
+ var a = abc.opABC();
+ k = abc.opKlass();
+}
+
+part1();
+part2();
+part3();
+part4();
+part5();
--- /dev/null
+var rename_scope = require("rename_scope");
+
+var a = new rename_scope.Natural_UP();
+var b = new rename_scope.Natural_BP();
+
+if (a.rtest() !== 1) {
+ throw new Error("a.rtest(): Expected 1, was " + a.rtest());
+}
+
+if (b.rtest() !== 1) {
+ throw new Error("b.rtest(): Expected 1, was " + b.rtest());
+}
+
+var f = rename_scope.equals;
+if (f === undefined) {
+ throw new Error("Equality operator has not been renamed.");
+}
--- /dev/null
+var rename_simple = require("rename_simple");
+var NewStruct = rename_simple.NewStruct;
+
+var s = new NewStruct();
+
+// renamed instance variable
+if (s.NewInstanceVariable !== 111) {
+ throw new Error("NewInstanceVariable: Expected 111, was " + s.NewInstanceVariable);
+}
+
+// renamed instance method
+if (s.NewInstanceMethod() !== 222) {
+ throw new Error("NewInstanceMethod(): Expected 222, was " + s.NewInstanceMethod());
+}
+
+// renamed static method
+if (NewStruct.NewStaticMethod() !== 333) {
+ throw new Error("NewInstanceMethod(): Expected 333, was " + NewStruct.NewStaticMethod());
+}
+
+// renamed static variable
+if (NewStruct.NewStaticVariable !== 444) {
+ throw new Error("NewInstanceMethod(): Expected 444, was " + NewStruct.NewStaticVariable);
+}
+
+// renamed global function
+if (rename_simple.NewFunction() !== 555) {
+ throw new Error("rename_simple.NewFunction(): Expected 555, was " + rename_simple.NewFunction());
+}
+
+// renamed global variable
+if (rename_simple.NewGlobalVariable !== 666) {
+ throw new Error("rename_simple.NewGlobalVariable: Expected 666, was " + rename_simple.NewGlobalVariable);
+}
+
+// setting renamed variables
+s.NewInstanceVariable = 1111;
+if (s.NewInstanceVariable !== 1111) {
+ throw new Error("NewInstanceVariable: Expected 1111, was " + s.NewInstanceVariable);
+}
+
+NewStruct.NewStaticVariable = 4444;
+if (NewStruct.NewStaticVariable !== 4444) {
+ throw new Error("NewInstanceMethod(): Expected 4444, was " + NewStruct.NewStaticVariable);
+}
+
+rename_simple.NewGlobalVariable = 6666;
+if (rename_simple.NewGlobalVariable !== 6666) {
+ throw new Error("rename_simple.NewGlobalVariable: Expected 6666, was " + rename_simple.NewGlobalVariable);
+}
--- /dev/null
+var ret_by_value = require("ret_by_value");
+
+a = ret_by_value.get_test();
+if (a.myInt != 100)
+ throw "RuntimeError";
+
+if (a.myShort != 200)
+ throw "RuntimeError";
--- /dev/null
+var string_simple = require("string_simple");
+
+// Test unicode string
+var str = "olé";
+
+var copy = string_simple.copy_string(str);
+
+if (str !== copy) {
+ throw "Error: copy is not equal: original="+str+", copy="+copy;
+}
--- /dev/null
+var struct_value = require("struct_value");
+
+b = new struct_value.Bar();
+
+b.a.x = 3;
+if (b.a.x != 3)
+throw "RuntimeError";
+
+b.b.x = 3;
+if (b.b.x != 3)
+throw "RuntimeError"
--- /dev/null
+var template_static = require("template_static");
+
+template_static.Foo.bar_double(1);
--- /dev/null
+var typedef_class = require("typedef_class");
+
+a = new typedef_class.RealA();
+a.a = 3;
+
+b = new typedef_class.B();
+b.testA(a);
--- /dev/null
+var typedef_inherit = require("typedef_inherit");
+
+a = new typedef_inherit.Foo();
+b = new typedef_inherit.Bar();
+
+x = typedef_inherit.do_blah(a);
+if (x != "Foo::blah")
+ print("Whoa! Bad return" + x);
+
+x = typedef_inherit.do_blah(b);
+if (x != "Bar::blah")
+ print("Whoa! Bad return" + x);
+
+c = new typedef_inherit.Spam();
+d = new typedef_inherit.Grok();
+
+x = typedef_inherit.do_blah2(c);
+if (x != "Spam::blah")
+ print("Whoa! Bad return" + x);
+
+x = typedef_inherit.do_blah2(d);
+if (x != "Grok::blah")
+ print ("Whoa! Bad return" + x);
--- /dev/null
+var typedef_scope = require("typedef_scope");
+
+b = new typedef_scope.Bar();
+x = b.test1(42,"hello");
+if (x != 42)
+ print("Failed!!");
+
+x = b.test2(42,"hello");
+if (x != "hello")
+ print("Failed!!");
+
+
--- /dev/null
+var typemap_arrays = require("typemap_arrays");
+
+if (typemap_arrays.sumA(null) != 60)
+ throw "RuntimeError, Sum is wrong";
+
--- /dev/null
+var typemap_delete = require("typemap_delete");
+
+r = new typemap_delete.Rect(123);
+if (r.val != 123)
+ throw "RuntimeError";
--- /dev/null
+var typemap_namespace = require("typemap_namespace");
+
+if (typemap_namespace.test1("hello") != "hello")
+ throw "RuntimeError";
+
+if (typemap_namespace.test2("hello") != "hello")
+ throw "RuntimeError";
--- /dev/null
+var typemap_ns_using = require("typemap_ns_using");
+
+if (typemap_ns_using.spam(37) != 37)
+ throw "RuntimeError";
--- /dev/null
+var using1 = require("using1");
+
+if (using1.spam(37) != 37)
+ throw "RuntimeError";
--- /dev/null
+var using2 = require("using2");
+
+if (using2.spam(37) != 37)
+ throw "RuntimeError";
--- /dev/null
+var varargs = require("varargs");
+
+if (varargs.test("Hello") != "Hello") {
+ throw new Error("Failed");
+}
+
+var f = new varargs.Foo("Greetings")
+if (f.str != "Greetings") {
+ throw new Error("Failed");
+}
+
+if (f.test("Hello") != "Hello") {
+ throw new Error("Failed");
+}
+
+if (varargs.test_def("Hello",1) != "Hello") {
+ throw new Error("Failed");
+}
+
+if (varargs.test_def("Hello") != "Hello") {
+ throw new Error("Failed");
+}
+
+if (varargs.test_plenty("Hello") != "Hello") {
+ throw new Error("Failed");
+}
+
+if (varargs.test_plenty("Hello", 1) != "Hello") {
+ throw new Error("Failed");
+}
+
+if (varargs.test_plenty("Hello", 1, 2) != "Hello") {
+ throw new Error("Failed");
+}
+
+var thrown = false;
+try {
+ varargs.test_plenty("Hello", 1, 2, 3);
+} catch (err) {
+ thrown = true;
+}
+if (!thrown) {
+ throw new Error("Failed");
+}
KW(go, defer)
KW(chan, fallthrough)
+/* Lua keywords */
+KW(end, function)
+KW(nil,local)
+
%}
--- /dev/null
+/*
+ * Test reserved keyword renaming
+ */
+
+%module keyword_rename_c
+
+%include "keyword_rename.i"
%module kwargs_feature
%nocopyctor;
-%kwargs;
+%feature("kwargs");
%rename(myDel) del;
%inline
virtual ~Foo() {
}
-
};
-
%}
// Functions
%inline %{
- int foo(int a = 1, int b = 0) {return a + b; }
-
+ int foo_fn(int a = 1, int b = 0) {return a + b; }
template<typename T> T templatedfunction(T a = 1, T b = 0) { return a + b; }
%}
%template(templatedfunction) templatedfunction<int>;
-// Deafult args with references
-%inline
-%{
-
+// Default args with references
+%inline %{
typedef int size_type;
struct Hello
static const size_type hello = 3;
};
-
-
- int rfoo( const size_type& x = Hello::hello, const Hello& y = Hello() )
+ int rfoo( int n = 0, const size_type& x = Hello::hello, const Hello& y = Hello() )
{
- return x;
+ return n - x;
}
-
%}
%{
const int Hello::hello;
int foo_kw(int from = 1, int except = 2) {return from + except; }
-
int foo_nu(int from = 1, int = 0) {return from; }
int foo_mm(int min = 1, int max = 2) {return min + max; }
-
%}
struct C
{
C(int a, int b, int c) :
- _a(a), _b(b), _c(c), _d(a), _e(b),
+ a(a), b(b), c(c), d(a), _e(b),
_f(a,b), _g(b,c)
{
/*
- _f.first = _a;
- _f.second = _b;
+ _f.first = a;
+ _f.second = b;
- _g.first = _b;
- _g.second = _c;
+ _g.first = b;
+ _g.second = c;
*/
}
int get_value() const
{
- return _a;
+ return a;
}
void set_value(int aa)
{
- _a = aa;
+ a = aa;
}
/* only one ref method */
int& get_ref()
{
- return _b;
+ return b;
}
- Foo get_class_value() const { return _d; }
- void set_class_value( Foo foo) { _d = foo; }
+ Foo get_class_value() const { return d; }
+ void set_class_value( Foo foo) { d = foo; }
const Foo& get_class_ref() const { return _e; }
void set_class_ref( const Foo& foo ) { _e = foo; }
void set_string(std::string other) { str = other; }
private:
- int _a;
- int _b;
- int _c;
- Foo _d;
+ int a;
+ int b;
+ int c;
+ Foo d;
Foo _e;
pair<T1,T2> _f;
pair<T1,T2> _g;
--- /dev/null
+%module li_boost_array
+
+#if defined(SWIGPYTHON) || defined(SWIGRUBY)
+
+// Hack to use the std::array support for boost::array.
+// Is limited as it currently exposes some 'using' bugs in SWIG though.
+// For example, the type system fails to see that pointers to std::array
+// and pointers to boost::array are the same.
+
+%{
+#if __cplusplus >= 201103 || (defined(_MSC_VER) && _MSC_VER >= 1900)
+// Use C++11 array as this is unfortunately sometimes included by <algorithm>
+#include <array>
+namespace boost {
+ using std::array;
+}
+#else
+#include <boost/array.hpp>
+namespace std {
+ using boost::array;
+}
+#endif
+%}
+namespace boost {
+ using std::array;
+}
+
+%ignore std::array::fill; // Some older versions of boost don't have this function
+
+%include <std_array.i>
+
+%template(ArrayInt6) std::array<int, 6>;
+
+%inline %{
+boost::array<int, 6> arrayOutVal() {
+ const signed char carray[] = { -2, -1, 0, 0, 1, 2 };
+ boost::array<int, 6> myarray;
+ for (size_t i=0; i<6; ++i) {
+ myarray[i] = carray[i];
+ }
+ return myarray;
+}
+
+boost::array<int, 6> & arrayOutRef() {
+ static boost::array<int, 6> a = { -2, -1, 0, 0, 1, 2 };
+ return a;
+}
+
+const boost::array<int, 6> & arrayOutConstRef() {
+ static boost::array<int, 6> a = { -2, -1, 0, 0, 1, 2 };
+ return a;
+}
+
+boost::array<int, 6> * arrayOutPtr() {
+ static boost::array<int, 6> a = { -2, -1, 0, 0, 1, 2 };
+ return &a;
+}
+
+boost::array<int, 6> arrayInVal(boost::array<int, 6> myarray) {
+ for (boost::array<int, 6>::iterator it = myarray.begin(); it!=myarray.end(); ++it) {
+ *it *= 10;
+ }
+ return myarray;
+}
+
+const boost::array<int, 6> & arrayInConstRef(const boost::array<int, 6> & myarray) {
+ static boost::array<int, 6> a = myarray;
+ for (boost::array<int, 6>::iterator it = a.begin(); it!=a.end(); ++it) {
+ *it *= 10;
+ }
+ return a;
+}
+
+void arrayInRef(boost::array<int, 6> & myarray) {
+ for (boost::array<int, 6>::iterator it = myarray.begin(); it!=myarray.end(); ++it) {
+ *it *= 10;
+ }
+}
+
+void arrayInPtr(boost::array<int, 6> * myarray) {
+ for (boost::array<int, 6>::iterator it = myarray->begin(); it!=myarray->end(); ++it) {
+ *it *= 10;
+ }
+}
+%}
+
+#endif
// count the instances of intrusive_ptr. Uncomment the INTRUSIVE_PTR_WRAPPER macro to turn this on.
//
// Also note the debug_shared flag which can be set from the target language.
+//
+// Usage of intrusive_ptr_add_ref and intrusive_ptr_release based on boost testing:
+// http://www.boost.org/doc/libs/1_36_0/libs/smart_ptr/test/intrusive_ptr_test.cpp
%module li_boost_intrusive_ptr
%warnfilter(SWIGWARN_LANG_SMARTPTR_MISSING) KlassDerived;
%warnfilter(SWIGWARN_LANG_SMARTPTR_MISSING) KlassDerivedDerived;
-%{
-template<typename T> void intrusive_ptr_add_ref(const T* r) { r->addref(); }
-template<typename T> void intrusive_ptr_release(const T* r) { r->release(); }
+%ignore intrusive_ptr_add_ref;
+%ignore intrusive_ptr_release;
+%{
#include <boost/shared_ptr.hpp>
#include <boost/intrusive_ptr.hpp>
#include <boost/detail/atomic_count.hpp>
void release(void) const { if (--count == 0) delete this; }
int use_count(void) const { return count; }
static long getTotal_count() { return total_count; }
+ friend void intrusive_ptr_add_ref(const Klass* r) { r->addref(); }
+ friend void intrusive_ptr_release(const Klass* r) { r->release(); }
private:
static void increment() { ++total_count; if (debug_shared) cout << " ++xxxxx Klass::increment tot: " << total_count << endl;}
void addref(void) const { ++count; }
void release(void) const { if (--count == 0) delete this; }
int use_count(void) const { return count; }
+ inline friend void intrusive_ptr_add_ref(const IgnoredRefCountingBase* r) { r->addref(); }
+ inline friend void intrusive_ptr_release(const IgnoredRefCountingBase* r) { r->release(); }
static long getTotal_count() { return total_count; }
private:
void addref(void) const { count++; }
void release(void) const { if (--count == 0) delete this; }
int use_count(void) const { return count; }
+ inline friend void intrusive_ptr_add_ref(const Base<T1, T2>* r) { r->addref(); }
+ inline friend void intrusive_ptr_release(const Base<T1, T2>* r) { r->release(); }
};
%}
// This tests shared_ptr is working okay. It also checks that there are no memory leaks in the
// class that shared_ptr is pointing via a counting mechanism in the constructors and destructor of Klass.
// In order to test that there are no leaks of the shared_ptr class itself (as it is created on the heap)
-// the runtime tests can be run for a long time to monitor memory leaks using memory monitor tools
+// the runtime tests can be run for a long time to monitor memory leaks using memory monitor tools
// like 'top'. There is a wrapper for shared_ptr in shared_ptr_wrapper.h which enables one to
// count the instances of shared_ptr. Uncomment the SHARED_PTR_WRAPPER macro to turn this on.
//
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK);
+#if defined(SWIGSCILAB)
+%rename(MbrVar) MemberVariables;
+%rename(MbrVal) MemberVariables::MemberValue;
+%rename(MbrPtr) MemberVariables::MemberPointer;
+%rename(MbrRef) MemberVariables::MemberReference;
+%rename(SmartMbrVal) MemberVariables::SmartMemberValue;
+%rename(SmartMbrPtr) MemberVariables::SmartMemberPointer;
+%rename(SmartMbrRef) MemberVariables::SmartMemberReference;
+#endif
+
%inline %{
#include "boost/shared_ptr.hpp"
#include "swig_examples_lock.h"
# define SWIG_SHARED_PTR_NAMESPACE SwigBoost
#endif
-#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD)
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD) || defined(SWIGOCTAVE) || defined(SWIGRUBY)
#define SHARED_PTR_WRAPPERS_IMPLEMENTED
#endif
static int getTotal_count() { return total_count; }
private:
- // lock increment and decrement as a destructor could be called at the same time as a
+ // lock increment and decrement as a destructor could be called at the same time as a
// new object is being created - C# / Java, at least, have finalizers run in a separate thread
static SwigExamples::CriticalSection critical_section;
static void increment() { SwigExamples::Lock lock(critical_section); total_count++; if (debug_shared) cout << " ++xxxxx Klass::increment tot: " << total_count << endl;}
};
SwigExamples::CriticalSection Space::Klass::critical_section;
-struct IgnoredMultipleInheritBase {
+struct IgnoredMultipleInheritBase {
IgnoredMultipleInheritBase() : d(0.0), e(0.0) {}
- virtual ~IgnoredMultipleInheritBase() {}
- double d;
+ virtual ~IgnoredMultipleInheritBase() {}
+ double d;
double e;
- virtual void AVirtualMethod() {}
+ virtual void AVirtualMethod() {}
};
-// For most compilers, this use of multiple inheritance results in different derived and base class
+// For most compilers, this use of multiple inheritance results in different derived and base class
// pointer values ... for some more challenging tests :)
struct KlassDerived : IgnoredMultipleInheritBase, Klass {
KlassDerived() : Klass() {}
long use_count(const SwigBoost::shared_ptr<Klass>& sptr) {
return sptr.use_count();
}
-const SwigBoost::shared_ptr<Klass>& ref_1() {
+const SwigBoost::shared_ptr<Klass>& ref_1() {
static SwigBoost::shared_ptr<Klass> sptr;
return sptr;
}
T2 baseVal2;
Base(T1 t1, T2 t2) : baseVal1(t1*2), baseVal2(t2*2) {}
virtual std::string getValue() const { return "Base<>"; };
+ virtual ~Base() {}
};
%}
+#if !defined(SWIGSCILAB)
%template(BaseIntDouble) Base<int, double>;
+#else
+%template(BaseIDbl) Base<int, double>;
+#endif
%inline %{
template <class T1, class T2> struct Pair : Base<T1, T2> {
%inline %{
namespace SwigBoost {
const int NOT_COUNTING = -123456;
- int shared_ptr_wrapper_count() {
+ int shared_ptr_wrapper_count() {
#ifdef SHARED_PTR_WRAPPER
- return SwigBoost::SharedPtrWrapper::getTotalCount();
+ return SwigBoost::SharedPtrWrapper::getTotalCount();
#else
return NOT_COUNTING;
#endif
--- /dev/null
+%module li_boost_shared_ptr_attribute
+
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD) || defined(SWIGOCTAVE) || defined(SWIGRUBY)
+#define SHARED_PTR_WRAPPERS_IMPLEMENTED
+#endif
+
+#if defined(SHARED_PTR_WRAPPERS_IMPLEMENTED)
+
+%include "attribute.i"
+%include "boost_shared_ptr.i"
+
+%inline %{
+#include <boost/shared_ptr.hpp>
+using namespace boost;
+%}
+%shared_ptr(GetMe);
+%shared_ptr(GetSetMe);
+%attributestring(GetterOnly, shared_ptr<GetMe>, AddedAttrib, GetIt)
+%attributestring(GetterSetter, shared_ptr<GetSetMe>, AddedAttrib, GetIt, SetIt)
+
+%inline %{
+struct GetMe {
+ explicit GetMe(int n) : n(n) {}
+ ~GetMe() {}
+ int n;
+};
+struct GetSetMe {
+ explicit GetSetMe(int n) : n(n) {}
+ ~GetSetMe() {}
+ int n;
+};
+
+struct GetterOnly {
+ explicit GetterOnly(int n) : myval(new GetMe(n*n)) {}
+ shared_ptr<GetMe> GetIt() const { return myval; }
+ shared_ptr<GetMe> myval;
+};
+struct GetterSetter {
+ explicit GetterSetter(int n) : myval(new GetSetMe(n*n)) {}
+ shared_ptr<GetSetMe> GetIt() const { return myval; }
+ void SetIt(shared_ptr<GetSetMe> newval) { myval = newval; }
+ shared_ptr<GetSetMe> myval;
+};
+%}
+
+#endif
%module li_boost_shared_ptr_bits
-#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD)
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD) || defined(SWIGOCTAVE) || defined(SWIGRUBY)
#define SHARED_PTR_WRAPPERS_IMPLEMENTED
#endif
delete impl_;
}
%}
+
+////////////////////////////
+// As above but private instead of protected destructor
////////////////////////////
+#if defined(SHARED_PTR_WRAPPERS_IMPLEMENTED)
+
+%shared_ptr(HiddenPrivateDestructor)
+
+#endif
+
+
+%inline %{
+class HiddenPrivateDestructor {
+private:
+ HiddenPrivateDestructor() {}
+ virtual ~HiddenPrivateDestructor() {
+ DeleteCount++;
+ }
+
+ class Deleter {
+ public:
+ void operator()(HiddenPrivateDestructor *hidden) {
+ delete hidden;
+ }
+ };
+
+public:
+ static boost::shared_ptr<HiddenPrivateDestructor> create() {
+ boost::shared_ptr<HiddenPrivateDestructor> hidden( new HiddenPrivateDestructor(), HiddenPrivateDestructor::Deleter() );
+ return hidden;
+ }
+ static int DeleteCount;
+};
+
+int HiddenPrivateDestructor::DeleteCount = 0;
+%}
+
+/////////////////////////////////////////////////
+// Non-public inheritance and shared_ptr
+/////////////////////////////////////////////////
+
+#if defined(SHARED_PTR_WRAPPERS_IMPLEMENTED)
+%shared_ptr(Base)
+// No %shared_ptr(DerivedPrivate1) to check Warning 520 does not appear
+// No %shared_ptr(DerivedProtected1) to check Warning 520 does not appear
+%shared_ptr(DerivedPrivate2)
+%shared_ptr(DerivedProtected2)
+
+%ignore Base2;
+%shared_ptr(DerivedPublic)
+#endif
+
+%inline %{
+class Base {
+public:
+ virtual int b() = 0;
+ virtual ~Base() {}
+};
+
+class DerivedProtected1 : protected Base {
+public:
+ virtual int b() { return 20; }
+};
+class DerivedPrivate1 : private Base {
+public:
+ virtual int b() { return 20; }
+};
+
+class DerivedProtected2 : protected Base {
+public:
+ virtual int b() { return 20; }
+};
+class DerivedPrivate2 : private Base {
+public:
+ virtual int b() { return 20; }
+};
+
+class Base2 {
+public:
+ virtual int b2() = 0;
+ virtual ~Base2() {}
+};
+class DerivedPublic : public Base2 {
+public:
+ virtual int b2() { return 20; }
+};
+%}
class Base {
public:
virtual T bar() {return 1;}
+ virtual ~Base() {}
};
template <class T>
%}
-#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD)
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD) || defined(SWIGOCTAVE) || defined(SWIGRUBY)
#define SHARED_PTR_WRAPPERS_IMPLEMENTED
#endif
class BaseDefault {
public:
virtual T bar2() {return 3;}
+ virtual ~BaseDefault() {}
};
template <class X, class T = int>
--- /dev/null
+%module li_carrays_cpp
+
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME) doubleArray; /* Ruby, wrong class name */
+
+%include <carrays.i>
+
+%array_functions(int,intArray);
+%array_class(double, doubleArray);
+
+%inline %{
+typedef struct {
+ int x;
+ int y;
+} XY;
+XY globalXYArray[3];
+
+typedef struct {
+ int a;
+ int b;
+} AB;
+
+AB globalABArray[3];
+%}
+
+// Note that struct XY { ... }; gives compiler error for C when using %array_class or %array_functions, but is okay in C++
+%array_class(XY, XYArray)
+%array_functions(AB, ABArray)
+
--- /dev/null
+%module li_cdata_carrays_cpp
+
+%include <carrays.i>
+%array_class(int, intArray);
+
+%include <cdata.i>
+
+%cdata(int);
--- /dev/null
+%module li_cdata_cpp
+
+%include <cdata.i>
+
+%cdata(int);
+%cdata(double);
+
+void *malloc(size_t size);
--- /dev/null
+%module li_cpointer_cpp
+
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME) doublep; /* Ruby, wrong class name */
+
+%include "cpointer.i"
+
+%pointer_functions(int,intp);
+%pointer_class(double,doublep);
+%pointer_cast(int, unsigned int, int_to_uint);
+
--- /dev/null
+%module li_std_auto_ptr
+
+%{
+#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations" // auto_ptr deprecation
+#endif
+%}
+
+#if defined(SWIGCSHARP) || defined(SWIGJAVA) || defined(SWIGPYTHON)
+
+%include "std_auto_ptr.i"
+
+%auto_ptr(Klass)
+
+%inline %{
+
+#include <memory>
+#include <string>
+#include "swig_examples_lock.h"
+
+class Klass {
+public:
+ explicit Klass(const char* label) :
+ m_label(label)
+ {
+ SwigExamples::Lock lock(critical_section);
+ total_count++;
+ }
+
+ const char* getLabel() const { return m_label.c_str(); }
+
+ ~Klass()
+ {
+ SwigExamples::Lock lock(critical_section);
+ total_count--;
+ }
+
+ static int getTotal_count() { return total_count; }
+
+private:
+ static SwigExamples::CriticalSection critical_section;
+ static int total_count;
+
+ std::string m_label;
+};
+
+SwigExamples::CriticalSection Klass::critical_section;
+int Klass::total_count = 0;
+
+%}
+
+%template(KlassAutoPtr) std::auto_ptr<Klass>;
+
+%inline %{
+
+std::auto_ptr<Klass> makeKlassAutoPtr(const char* label) {
+ return std::auto_ptr<Klass>(new Klass(label));
+}
+
+%}
+
+#endif
%template(PairIntString) std::pair<int, std::string>;
%template(VectorPairIntString) std::vector< std::pair<int, std::string> >;
-%template(PairIntVectorString) std::pair< int, std::vector<std::string> >;
-
%template(VectorVectorString) std::vector< std::vector<std::string> >;
+
+#if !defined(SWIGSCILAB)
+%template(PairIntVectorString) std::pair< int, std::vector<std::string> >;
%template(PairIntPairIntString) std::pair< int, std::pair<int, std::string> >;
+#else
+%template(PairIntVecStr) std::pair< int, std::vector<std::string> >;
+%template(PairIntPairIntStr) std::pair< int, std::pair<int, std::string> >;
+#endif
+
#if defined(SWIGCSHARP) || defined(SWIGD)
// Checks macro containing a type with a comma
SWIG_STD_VECTOR_ENHANCED(std::pair< double, std::string >)
#endif
+
%template(PairDoubleString) std::pair< double, std::string >;
%template(VectorPairDoubleString) std::vector< std::pair<double, std::string> >;
+
--- /dev/null
+%module li_std_container_typemaps
+
+%include stl.i
+%include std_list.i
+%include std_deque.i
+%include std_set.i
+%include std_multiset.i
+
+%{
+#include <vector>
+#include <list>
+#include <deque>
+#include <set>
+
+#include <iostream>
+#include <iterator>
+#include <algorithm>
+#include <numeric>
+
+using namespace std;
+%}
+
+%inline %{
+class ClassA
+{
+public:
+ ClassA() : a(0) {}
+ ClassA(int _a) : a(_a) {}
+ ClassA(const ClassA& c) : a(c.a) {}
+ int a;
+};
+
+typedef ClassA* ClassAPtr;
+
+enum _Color { RED=1, GREEN=10, YELLOW=11, BLUE=100, MAGENTA=101, CYAN=111 };
+typedef enum _Color Color;
+
+namespace std {
+ template<typename T> T binaryOperation(T x, T y) {
+ return static_cast<T>(x + y);
+ }
+
+ template<> bool binaryOperation(bool x, bool y) {
+ return x | y;
+ }
+
+ template<> ClassAPtr binaryOperation(ClassAPtr x, ClassAPtr y) {
+ if (x)
+ y->a += x->a;
+ return y;
+ }
+
+ template<typename SeqCont>
+ struct sequence_container {
+ typedef typename SeqCont::value_type value_type;
+
+ static SeqCont ret_container(const value_type value1, const value_type value2) {
+ SeqCont s;
+ s.insert(s.end(), value1);
+ s.insert(s.end(), value2);
+ return s;
+ }
+
+ static value_type val_container(const SeqCont container) {
+ return std::accumulate(container.begin(), container.end(), value_type(),
+ binaryOperation<value_type>);
+ }
+
+ static value_type ref_container(const SeqCont& container) {
+ return std::accumulate(container.begin(), container.end(), value_type(),
+ binaryOperation<value_type>);
+ }
+ };
+
+ template<typename T, class Container>
+ Container ret_container(const T value1, const T value2) {
+ return sequence_container<Container>::ret_container(value1, value2);
+ }
+ template<typename T, class Container>
+ T val_container(const Container container) {
+ return sequence_container<Container >::val_container(container);
+ }
+ template<typename T, class Container>
+ T ref_container(const Container& container) {
+ return sequence_container<Container >::ref_container(container);
+ }
+}
+%}
+
+%define %instantiate_containers_templates(TYPE...)
+namespace std
+{
+ %template(TYPE ## _vector) std::vector<TYPE>;
+ %template(TYPE ## _list) std::list<TYPE>;
+ %template(TYPE ## _deque) std::deque<TYPE>;
+ %template(TYPE ## _set) std::set<TYPE>;
+ %template(TYPE ## _multiset) std::multiset<TYPE>;
+}
+%enddef
+
+%define %instantiate_containers_functions(TYPE...)
+namespace std
+{
+ %template(ret_ ## TYPE ## _vector) ret_container<TYPE, std::vector<TYPE> >;
+ %template(val_ ## TYPE ## _vector) val_container<TYPE, std::vector<TYPE> >;
+ %template(ref_ ## TYPE ## _vector) ref_container<TYPE, std::vector<TYPE> >;
+ %template(ret_ ## TYPE ## _list) ret_container<TYPE, std::list<TYPE> >;
+ %template(val_ ## TYPE ## _list) val_container<TYPE, std::list<TYPE> >;
+ %template(ref_ ## TYPE ## _list) ref_container<TYPE, std::list<TYPE> >;
+ %template(ret_ ## TYPE ## _deque) ret_container<TYPE, std::deque<TYPE> >;
+ %template(val_ ## TYPE ## _deque) val_container<TYPE, std::deque<TYPE> >;
+ %template(ref_ ## TYPE ## _deque) ref_container<TYPE, std::deque<TYPE> >;
+ %template(ret_ ## TYPE ## _set) ret_container<TYPE, std::set<TYPE> >;
+ %template(val_ ## TYPE ## _set) val_container<TYPE, std::set<TYPE> >;
+ %template(ref_ ## TYPE ## _set) ref_container<TYPE, std::set<TYPE> >;
+ %template(ret_ ## TYPE ## _multiset) ret_container<TYPE, std::multiset<TYPE> >;
+ %template(val_ ## TYPE ## _multiset) val_container<TYPE, std::multiset<TYPE> >;
+ %template(ref_ ## TYPE ## _multiset) ref_container<TYPE, std::multiset<TYPE> >;
+}
+%enddef
+
+%define %instantiate_containers_templates_and_functions(TYPE...)
+ %instantiate_containers_templates(TYPE);
+ %instantiate_containers_functions(TYPE);
+%enddef
+
+%instantiate_containers_templates_and_functions(int);
+%instantiate_containers_templates_and_functions(double);
+%instantiate_containers_templates_and_functions(float);
+%instantiate_containers_templates_and_functions(bool);
+%instantiate_containers_templates_and_functions(string);
+%instantiate_containers_templates_and_functions(ClassAPtr);
%include <std_except.i>
void test_domain_error() throw(std::domain_error)
{ throw std::domain_error("std::domain_error"); }
+
+%inline %{
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
+%}
%}
+// Test that the digraph <::aa::Holder> is not generated for stl containers
+%include <std_pair.i>
+
+%inline %{
+namespace aa {
+ struct Holder {
+ Holder(int n = 0) : number(n) {}
+ int number;
+ };
+}
+%}
+
+%template(PairTest) std::pair< ::aa::Holder, int >;
+
+%inline %{
+std::pair< ::aa::Holder, int > pair1(std::pair< ::aa::Holder, int > x) { return x; }
+%}
std::string *Structure::StaticMemberString2 };
*/
+#ifdef SWIGSCILAB
+%rename(St) MemberString;
+%rename(Str) MemberString;
+%rename(Str2) MemberString2;
+%rename(StaticStr) StaticMemberString;
+%rename(StaticStr2) StaticMemberString2;
+%rename(ConstStr) ConstMemberString;
+%rename(ConstStaticStr) ConstStaticMemberString;
+#endif
+
%inline %{
std::string GlobalString;
std::string GlobalString2 = "global string 2";
return x;
}
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
+
%}
%include "li_std_string.i"
std::vector< swig::LANGUAGE_OBJ > LanguageVector;
}
#endif
+
+
+// Test that the digraph <::aa::Holder> is not generated
+%include <std_vector.i>
+
+%inline %{
+namespace aa {
+ struct Holder {
+ Holder(int n = 0) : number(n) {}
+ int number;
+ };
+}
+%}
+
+#if !defined(SWIGOCTAVE)
+// To fix: something different in Octave is preventing this from working
+%template(VectorTest) std::vector< ::aa::Holder >;
+
+%inline %{
+std::vector< ::aa::Holder > vec1(std::vector< ::aa::Holder > x) { return x; }
+%}
+#endif
+
+// exercising vectors of strings
+%inline %{
+std::vector<std::string> RevStringVec (const std::vector<std::string> &In)
+ {
+ std::vector<std::string> result(In);
+ std::reverse(result.begin(), result.end());
+ return(result);
+ }
+%}
#include <algorithm>
#include <functional>
#include <numeric>
+
+
+#if defined(__clang__)
+// Suppress:
+// warning: destination for this 'memset' call is a pointer to dynamic class
+// 'Test::B'; vtable pointer will be overwritten [-Wdynamic-class-memaccess]
+// memset(v_def,0,sizeof(Type));
+// Better generated code is probably needed though
+#pragma clang diagnostic ignored "-Wdynamic-class-memaccess"
+#endif
+
%}
namespace std {
#pragma warning(default: 4290) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
#endif
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
+
%}
%include <stdint.i>
%inline %{
- struct StdInts {
+ struct StdI {
int8_t int8_member;
int16_t int16_member;
int32_t int32_member;
uint32_t uint32_td(int32_t i) { return i; }
uint64_t uint64_td(int64_t i) { return i; }
- struct StdIntFasts {
+ struct StdIf {
int_fast8_t int_fast8_member;
int_fast16_t int_fast16_member;
int_fast32_t int_fast32_member;
uint_fast32_t uint_fast32_td(int_fast32_t i) { return i; }
uint_fast64_t uint_fast64_td(int_fast64_t i) { return i; }
- struct StdIntLeasts {
+ struct StdIl {
int_least8_t int_least8_member;
int_least16_t int_least16_member;
int_least32_t int_least32_member;
--- /dev/null
+%module li_swigtype_inout
+
+// Test SWIGTYPE *& typemaps in swigtype_inout.i library
+
+#ifdef SWIGCSHARP
+%include <swigtype_inout.i>
+%apply SWIGTYPE *& OUTPUT { SWIGTYPE *& }
+#endif
+
+%ignore XXX::operator=;
+
+%inline %{
+#include <iostream>
+struct XXX {
+ XXX(int v) : value(v) {
+ if (debugging) std::cout << "Default Constructor " << value << " " << this << std::endl;
+ count++;
+ }
+ XXX(const XXX &other) {
+ value = other.value;
+ if (debugging) std::cout << "Copy Constructor " << value << " " << this << std::endl;
+ count++;
+ }
+ XXX& operator=(const XXX &other) {
+ value = other.value;
+ if (debugging) std::cout << "Assignment operator " << value << " " << this << std::endl;
+ return *this;
+ }
+ ~XXX() {
+ if (debugging) std::cout << "Destructor " << value << " " << this << std::endl;
+ count--;
+ }
+ void showInfo() {
+ if (debugging) std::cout << "Info " << value << " " << this << std::endl;
+ }
+ int value;
+ static const bool debugging = false;
+ static int count;
+};
+int XXX::count = 0;
+
+void ptr_ref_out(XXX *& x1, XXX *& x2, XXX const*& x3, XXX const*& x4) {
+ x1 = new XXX(111);
+ x2 = new XXX(222);
+ x3 = new XXX(333);
+ x4 = new XXX(444);
+}
+struct ConstructorTest {
+ ConstructorTest(XXX *& x1, XXX *& x2, XXX const*& x3, XXX const*& x4) {
+ ptr_ref_out(x1, x2, x3, x4);
+ }
+};
+%}
#define lconst5 987654321LL
#define lconst6 987654321ULL
+
+%inline %{
+long long UnsignedToSigned(unsigned long long ull) {
+ return (long long)ull;
+}
+%}
LANGUAGE = lua
LUA = @LUABIN@
SCRIPTSUFFIX = _runme.lua
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
CPP_TEST_CASES += \
lua_no_module_global \
+ lua_inherit_getitem \
C_TEST_CASES += \
lua_no_module_global.%: SWIGOPT += -nomoduleglobal
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.lua appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(LUA) $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LUA_PATH="$(srcdir)/?.lua;" $(RUNTOOL) $(LUA) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
# Clean: (does nothing, we dont generate extra lua code)
%.clean:
-
+ @exit 0
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile lua_clean
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' lua_clean
cvsignore:
@echo '*wrap* *.so *.dll *.exp *.lib'
@echo Makefile
- @for i in ${CPP_TEST_CASES} ${C_TEST_CASES}; do echo $$i.lua; done
- @for i in ${CPP_TEST_CASES} ${C_TEST_CASES}; do if grep -q $${i}_runme.lua CVS/Entries ; then echo $${i}_runme.lua; fi; done
+ @for i in ${CPP_TEST_CASES} ${C_TEST_CASES}; do echo $$i.lua; done
+ @for i in ${CPP_TEST_CASES} ${C_TEST_CASES}; do if grep -q $${i}_runme.lua CVS/Entries ; then echo $${i}_runme.lua; fi; done
--- /dev/null
+require("import") -- the import fn
+import("array_member") -- import lib
+am = array_member
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(am.get_value(am.global_data,0) == 0)
+assert(am.get_value(am.global_data,7) == 7)
+
+foo = am.Foo()
+foo.data = am.global_data
+assert(am.get_value(foo.data,0) == 0)
+
+for i = 0, 7 do
+ assert(am.get_value(foo.data,i) == am.get_value(am.global_data,i))
+end
+
+
+for i = 0, 7 do
+ am.set_value(am.global_data,i,-i)
+end
+
+am.global_data = foo.data
+
+for i = 0, 7 do
+ assert(am.get_value(foo.data,i) == am.get_value(am.global_data,i))
+end
--- /dev/null
+require("import") -- the import fn
+import("arrays_global") -- import lib
+ag = arrays_global
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(ag.BeginString_FIX44a == "FIX.a.a")
+assert(ag.BeginString_FIX44b == "FIX.b.b")
+
+assert(ag.BeginString_FIX44c == "FIX.c.c")
+assert(ag.BeginString_FIX44d == "FIX.d.d")
--- /dev/null
+require("import") -- the import fn
+import("chartest") -- import code
+
+function char_assert(char, code)
+ assert(type(char) == 'string')
+ assert(char:len() == 1)
+ assert(char:byte() == code)
+end
+
+char_assert(chartest.GetPrintableChar(), 0x61)
+char_assert(chartest.GetUnprintableChar(), 0x7F)
+
+char_assert(chartest.printable_global_char, 0x61)
+char_assert(chartest.unprintable_global_char, 0x7F)
--- /dev/null
+require("import") -- the import fn
+import("cpp11_strongly_typed_enumerations") -- import lib
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+function enumCheck(actual, expected)
+ if not (actual == expected) then
+ error("Enum value mismatch. Expected: "..expected.." Actual: "..actual)
+ end
+ return expected + 1
+end
+
+--val = 0
+--val = enumCheck(cpp11_strongly_typed_enumerations.cpp11_strongly_typed_enumerations.Enum1_Val1, val)
+local val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val1, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val2, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val3, 13)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val4, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val5a, 13)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val6a, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val1, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val2, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val3, 23)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val4, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val5b, 23)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val6b, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Val1, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Val2, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Val3, 43)
+val = enumCheck(cpp11_strongly_typed_enumerations.Val4, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum5_Val1, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum5_Val2, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum5_Val3, 53)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum5_Val4, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum6_Val1, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum6_Val2, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum6_Val3, 63)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum6_Val4, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum7td_Val1, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum7td_Val2, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum7td_Val3, 73)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum7td_Val4, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum8_Val1, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum8_Val2, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum8_Val3, 83)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum8_Val4, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum10_Val1, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum10_Val2, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum10_Val3, 103)
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum10_Val4, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum12_Val1, 1121)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum12_Val2, 1122)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum12_Val3, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum12_Val4, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum12_Val5c, 1121)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum12_Val6c, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Val1, 1131)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Val2, 1132)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Val3, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Val4, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Val5d, 1131)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Val6d, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum14_Val1, 1141)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum14_Val2, 1142)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum14_Val3, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum14_Val4, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum14_Val5e, 1141)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Enum14_Val6e, val)
+
+-- Requires nested class support to work
+--val = 0
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val1, 3121)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val2, 3122)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val3, val)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val4, val)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val5f, 3121)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val6f, val)
+--
+--val = 0
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Val1, 3131)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Val2, 3132)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Val3, val)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Val4, val)
+--
+--val = 0
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum14_Val1, 3141)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum14_Val2, 3142)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum14_Val3, val)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum14_Val4, val)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum14_Val5g, 3141)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum14_Val6g, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum12_Val1, 2121)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum12_Val2, 2122)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum12_Val3, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum12_Val4, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum12_Val5h, 2121)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum12_Val6h, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Val1, 2131)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Val2, 2132)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Val3, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Val4, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Val5i, 2131)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Val6i, val)
+
+val = 0
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum14_Val1, 2141)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum14_Val2, 2142)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum14_Val3, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum14_Val4, val)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum14_Val5j, 2141)
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Enum14_Val6j, val)
+
+-- Requires nested class support to work
+--val = 0
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Enum12_Val1, 4121)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Enum12_Val2, 4122)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Enum12_Val3, val)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Enum12_Val4, val)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Enum12_Val5k, 4121)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Enum12_Val6k, val)
+--
+--val = 0
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Val1, 4131)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Val2, 4132)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Val3, val)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Val4, val)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Val5l, 4131)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Val6l, val)
+--
+--val = 0
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Enum14_Val1, 4141)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Enum14_Val2, 4142)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Enum14_Val3, val)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Enum14_Val4, val)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Enum14_Val5m, 4141)
+--val = enumCheck(cpp11_strongly_typed_enumerations.Class2.Struct1.Enum14_Val6m, val)
+
+class1 = cpp11_strongly_typed_enumerations.Class1()
+enumCheck(class1:class1Test1(cpp11_strongly_typed_enumerations.Enum1_Val5a), 13)
+enumCheck(class1:class1Test2(cpp11_strongly_typed_enumerations.Class1.Enum12_Val5c), 1121)
+--enumCheck(class1:class1Test3(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val5f), 3121)
+
+enumCheck(cpp11_strongly_typed_enumerations.globalTest1(cpp11_strongly_typed_enumerations.Enum1_Val5a), 13)
+enumCheck(cpp11_strongly_typed_enumerations.globalTest2(cpp11_strongly_typed_enumerations.Class1.Enum12_Val5c), 1121)
+--enumCheck(globalTest3(cpp11_strongly_typed_enumerations.Class1.Struct1.Enum12_Val5f), 3121)
+
assert(cb.Bar_global_fval.num==-34)
assert(cb.Bar.global_fval.num==-34)
+assert(cb.Bar.global_cint == -4)
+assert(cb.Bar_global_cint == -4)
+
-- Now test member function pointers
func1_ptr=cb.get_func1_ptr()
func2_ptr=cb.get_func2_ptr()
assert(cb.test_func_ptr(f,2)==16)
f.func_ptr=func2_ptr
assert(cb.test_func_ptr(f,2)==-8)
+
+-- Test that __tostring metamethod produce no internal asserts
+f2_name = tostring(f2)
+
+f3 = cb.FooSub()
+f3_name = tostring(f3)
+
+f4 = cb.FooSubSub()
+f4_name = tostring(f4)
+
+assert( f2_name == "Foo" )
+assert( f3_name == "Foo" )
+assert( f4_name == "FooSubSub" )
+
+-- Test __eq implementation supplied by default
+
+-- eq_f1 and eq_f2 must be different userdata with same Foo* pointer. If eq_f1 and eq_f2 are the same userdata (e.g.)
+-- > eq_f1 = smth
+-- > eq_f2 = eq_f1
+-- then default Lua equality comparison kicks in and considers them equal. Access to global_fptr is actually a
+-- function call (internally) and it returns new userdata each time.
+eq_f1 = cb.Bar.global_fptr
+eq_f2 = cb.Bar.global_fptr
+assert( eq_f1 == eq_f2 )
--- /dev/null
+require("import") -- the import fn
+import("cpp_enum") -- import code
+ce=cpp_enum -- renaming import
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(ce.ENUM_ONE ~= nil)
+assert(ce.ENUM_TWO ~= nil)
+
+-- Enums inside classes
+assert(ce.Foo.Hi == 0)
+assert(ce.Foo.Hello == 1);
+-- old-style bindings
+assert(ce.Foo_Hi == 0)
+assert(ce.Foo_Hello == 1);
+
+assert(ce.Hi == 0)
+assert(ce.Hello == 1)
--- /dev/null
+require("import") -- the import fn
+import("cpp_namespace") -- import lib into global
+cn=cpp_namespace --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(cn.fact(4) == 24)
+assert(cn.Foo == 42)
+
+t1 = cn.Test()
+assert(t1:method() == "Test::method")
+
+cn.weird("t1", 4)
+
+assert(cn.do_method(t1) == "Test::method")
+assert(cn.do_method2(t1) == "Test::method")
+
+t2 = cn.Test2()
+assert(t2:method() == "Test2::method")
+
+
+assert(cn.foo3(5) == 5)
+
+assert(cn.do_method3(t2, 7) == "Test2::method")
--- /dev/null
+-- Run file
+require("import") -- the import fn
+import("cpp_nodefault") -- import lib into global
+cn=cpp_nodefault --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+foo1 = cn.Foo(1,2)
+foo1.a = 5
+assert(foo1.a == 5)
+
+foo2 = cn.create(1,2)
+
+cn.consume(foo1,foo2)
+
+bar1 = cn.Bar()
+bar1:consume(cn.gvar, foo2)
+foo3 = bar1:create(1,2)
+
+foo3.a = 6
+assert(foo3.a == 6)
--- /dev/null
+-- demo of lua swig capacilities (operator overloading)
+require("import") -- the import fn
+import("cpp_static") -- import lib into global
+cs=cpp_static --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+cs.StaticMemberTest.static_int = 5;
+assert(cs.StaticMemberTest.static_int == 5);
+
+cs.StaticFunctionTest.static_func()
+cs.StaticFunctionTest.static_func_2(2)
+cs.StaticFunctionTest.static_func_3(3,3)
--- /dev/null
+
+require("import") -- the import fn
+import("cpp_typedef") -- import lib into global
+ct = cpp_typedef --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+foo1 = ct.Foo()
+bar1 = foo1:bar()
+bar2 = ct.Foo.sbar()
+
+u1 = ct.UnnamedStruct()
+n1 = ct.TypedefNamedStruct()
+
+test = ct.Test()
+
+u2 = test:test1(u1)
+n2 = test:test2(n1)
+n3 = test:test3(n1)
+n4 = test:test4(n1)
--- /dev/null
+require("import") -- the import fn
+import("enum_plus") -- import lib
+ep=enum_plus
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(ep.iFoo_Phoo == 50) -- Old variant of enum bindings
+assert(ep.iFoo.Phoo == 50) -- New variant of enum bindings
--- /dev/null
+require("import") -- the import fn
+import("enum_rename") -- import lib
+er=enum_rename
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(er.M_Jan ~= nil)
+assert(er.May ~= nil)
--- /dev/null
+require("import") -- the import fn
+import("enum_scope_template") -- import lib
+est=enum_scope_template
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(est.TreeInt.Oak ~= nil)
+assert(est.TreeInt_Oak ~= nil)
+assert(est.TreeInt.Cedar ~= nil)
--- /dev/null
+require("import") -- the import fn
+import("enum_template") -- import lib
+et=enum_template
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(et.eTest0 ~= nil)
+assert(et.eTest1 ~= nil)
+
+et.TakeETest(et.eTest0)
+
+res = et.MakeETest()
+et.TakeETest(res)
assert(enums.AnonEnum1==0)
assert(enums.AnonEnum2==100)
+-- In C enums from struct are exported into global namespace (without prefixing with struct name)
+-- In C++ they are prefixed (as compatibility thing).
+-- We are emulating xor :)
+assert(enums.BAR1 ~= enums.Foo_BAR1) -- It is either C style, or C++ style, but not both
+assert((enums.BAR1 ~= nil ) or (enums.Foo_BAR1 ~= nil))
+
+assert(enums.Phoo ~= enums.iFoo_Phoo)
+assert((enums.Phoo == 50) or (enums.iFoo_Phoo == 50))
-- no point in checking fns, C will allow any value
--- /dev/null
+require("import") -- the import fn
+import("equality") -- import code
+eq=equality -- renaming import
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+-- === No equality operator ===
+
+-- logically same data without equality operator are not equal
+p1 = eq.MakePoint(10,9);
+p2 = eq.MakePoint(10,9);
+
+assert( p1 ~= p2 );
+
+-- different wrappers for same Point* are equal
+p3 = eq.GetZeroPointPtr()
+p4 = eq.GetZeroPointPtr()
+
+assert( p3 == p4 )
+
+
+-- === Logically correct equality operator ===
+
+ed1 = eq.EqualOpDefined(10)
+ed2 = eq.EqualOpDefined(10)
+ed3 = eq.EqualOpDefined(15)
+
+assert( ed1 == ed2 )
+assert( ed1 ~= ed3 )
+
+
+-- === Logically incorrect equality operator ===
+
+ew1 = eq.EqualOpWrong()
+ew2 = eq.EqualOpWrong()
+
+assert( ew1 ~= ew2 );
+
+ew3 = eq.EqualOpWrong.GetStaticObject()
+ew4 = eq.EqualOpWrong.GetStaticObject()
+
+-- Even though these are pointers to same object, operator== overload should
+-- state that they are not equal
+assert( ew3 ~= ew4 )
--- /dev/null
+require("import") -- the import fn
+import("extend_constructor_destructor") -- import lib into global
+ecd=extend_constructor_destructor --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+a1 = ecd.AStruct(101)
+assert(a1.ivar == 101)
+assert(ecd.globalVar == 101)
+
+b1 = ecd.BStruct(201)
+assert(b1.ivar == 201)
+assert(ecd.globalVar == 201)
+
+c1 = ecd.CStruct(301)
+assert(c1.ivar == 301)
+assert(ecd.globalVar == 301)
+
+d1 = ecd.DStruct(401)
+assert(d1.ivar == 401)
+assert(ecd.globalVar == 401)
+
+e1 = ecd.EStruct(501)
+assert(e1.ivar == 501)
+assert(ecd.globalVar == 501)
+
+f1 = ecd.FStruct(601)
+assert(f1.ivar == 601)
+assert(ecd.globalVar == 601)
--- /dev/null
+require("import") -- the import fn
+import("extend_placement") -- import lib into global
+ep=extend_placement --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+function test_obj(main, suppl)
+ assert(main:spam() == 1)
+ assert(main:spam("this_is_string") == 2)
+ assert(main:spam(5) == 5)
+ assert(main:spam(5,6) == 11)
+ assert(main:spam(7,8,9) == 15)
+ assert(main:spam(suppl,12.0) == 0)
+ assert(main:spam(suppl) == 0)
+end
+
+foo1 = ep.Foo(0)
+foo2 = ep.Foo(1,2)
+foo3 = ep.Foo()
+test_obj(foo1,foo2)
+
+
+bar1 = ep.Bar()
+bar2 = ep.Bar(5)
+test_obj(bar1,bar2)
+
+fti1 = ep.FooTi(0)
+fti2 = ep.FooTi(1,2)
+fti3 = ep.FooTi()
+test_obj(fti1,foo1)
+
+bti1 = ep.BarTi()
+bti2 = ep.BarTi(5)
+test_obj(bti1,bar1)
--- /dev/null
+require("import") -- the import fn
+import("extend") -- import lib into global
+e=extend --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+base1 = e.Base()
+assert(base1.value == 0)
+base2 = e.Base(10)
+assert(base2.value == 10)
+
+assert(base1:method(5) == 5)
+assert(e.Base.zeroVal() == 0)
+assert(base2:currentValue() == 10)
+assert(base2:extendmethod(7) == 14)
+
+der1 = e.Derived(0)
+assert(der1.value == 0)
+assert(der1:method(5) == 10)
+
+der2 = e.Derived(17)
+assert(der2.value == 34)
+der2.extendval = 200.0
+assert(math.abs(der2.actualval - 2.0) < 0.001)
+assert(math.abs(der2.extendval - 200.0) < 0.001)
--- /dev/null
+require("import") -- the import fn
+import("extend_template") -- import lib into global
+et=extend_template--alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+foo1 = et.Foo_0()
+assert(foo1:test1(5) == 5)
+assert(foo1:test2(7) == 7)
--- /dev/null
+require("import") -- the import fn
+import("extend_typedef_class") -- import lib into global
+etc=extend_typedef_class --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+function test_obj(obj, const)
+ obj.membervar = const
+ assert(obj:getvar() == const)
+end
+
+a1 = etc.AClass()
+test_obj(a1,1)
+
+b1 = etc.BClass()
+test_obj(b1,2)
+
+c1 = etc.CClass()
+test_obj(c1,3)
+
+d1 = etc.DClass()
+test_obj(d1,4)
+
+a2 = etc.AStruct()
+test_obj(a2,5)
+
+b2 = etc.BStruct()
+test_obj(b2,6)
+
+c2 = etc.CStruct()
+test_obj(c2,7)
+
+d2 = etc.DStruct()
+test_obj(d2,8)
--- /dev/null
+require("import") -- the import fn
+import("extend_variable") -- import lib into global
+ev=extend_variable --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+e1 = ev.ExtendMe()
+answ = 1.0
+assert(e1:set(7.0))
+--assert(e1:get(answ)) -- doesn't work. Lua can't pass primitive type by non-const reference
+--assert(answ == 7.0)
+
+e1.ExtendVar = 5.0
+assert(e1.ExtendVar == 5.0)
+
+assert(ev.Foo.Bar == 42)
+assert(ev.Foo.AllBarOne == 4422)
+
+assert(ev.Foo.StaticInt == 1111)
+ev.Foo.StaticInt = 3333
+assert(ev.Foo.StaticInt == 3333)
+
+assert(ev.Foo.StaticConstInt == 2222)
+
+b1 = ev.Bar()
+assert(b1.x == 1)
--- /dev/null
+require("import") -- the import fn
+import("friends") -- import lib into global
+f=friends --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+f.globalscope()
+
+b1 = f.B(5)
+a1 = f.A(10)
+
+assert(f.get_val1(a1) == 10)
+assert(f.get_val1(a1, 2) == 12)
+assert(f.get_val2(a1) == 20)
+assert(f.get_val3(a1) == 30)
+
+assert(f.get_val1(100, 1, 2) == 100)
+
+assert(f.mix(a1,b1) == 15);
+
+d1 = f.D_i(7)
+assert(f.get_val1(d1) == 7)
+f.set(d1,9)
+assert(f.get_val1(d1) == 9)
--- /dev/null
+require("import") -- the import fn
+import("funcptr_cpp") -- import lib into global
+fc=funcptr_cpp --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(fc.addByValue(5,10) == 15)
+-- These two won't work. Lua will successfully store the answer as userdata, but there is
+-- no way of accessing the insides of userdata.
+-- assert(fc.addByPointer(7, 9) == 16)
+-- assert(fc.addByReference(8, 9) == 17)
+
+assert(fc.call1(fc.ADD_BY_VALUE, 5, 10) == 15)
+assert(fc.call2(fc.ADD_BY_POINTER, 7, 9) == 16)
+assert(fc.call3(fc.ADD_BY_REFERENCE, 8, 9) == 17)
+assert(fc.call1(fc.ADD_BY_VALUE_C, 2, 3) == 5)
--- /dev/null
+require("import") -- the import fn
+import("fvirtual") -- import lib into global
+f=fvirtual --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+n1 = f.Node()
+n2 = f.Node()
+assert(n1:addChild(n2) == 1)
+
+ns = f.NodeSwitch()
+assert(ns:addChild(n2) == 2)
+assert(ns:addChild(ns) == 2)
+assert(ns:addChild(n1, false) == 3)
--- /dev/null
+require("import") -- the import fn
+import("global_namespace") -- import lib into global
+gn=global_namespace --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+k1 = gn.Klass1()
+k2 = gn.Klass2()
+k3 = gn.Klass3()
+k4 = gn.Klass4()
+k5 = gn.Klass5()
+k6 = gn.Klass6()
+k7 = gn.Klass7()
+
+gn.KlassMethods.methodA(k1,k2,k3,k4,k5,k6,k7)
+gn.KlassMethods.methodB(k1,k2,k3,k4,k5,k6,k7)
+
+k1 = gn.getKlass1A()
+k2 = gn.getKlass2A()
+k3 = gn.getKlass3A()
+k4 = gn.getKlass4A()
+k5 = gn.getKlass5A()
+k6 = gn.getKlass6A()
+k7 = gn.getKlass7A()
+
+gn.KlassMethods.methodA(k1,k2,k3,k4,k5,k6,k7)
+gn.KlassMethods.methodB(k1,k2,k3,k4,k5,k6,k7)
+
+k1 = gn.getKlass1B()
+k2 = gn.getKlass2B()
+k3 = gn.getKlass3B()
+k4 = gn.getKlass4B()
+k5 = gn.getKlass5B()
+k6 = gn.getKlass6B()
+k7 = gn.getKlass7B()
+
+gn.KlassMethods.methodA(k1,k2,k3,k4,k5,k6,k7)
+gn.KlassMethods.methodB(k1,k2,k3,k4,k5,k6,k7)
+
+x1 = gn.XYZ1()
+x2 = gn.XYZ2()
+x3 = gn.XYZ3()
+x4 = gn.XYZ4()
+x5 = gn.XYZ5()
+x6 = gn.XYZ6()
+x7 = gn.XYZ7()
+
+gn.XYZMethods.methodA(x1,x2,x3,x4,x5,x6,x7)
+gn.XYZMethods.methodB(x1,x2,x3,x4,x5,x6,x7)
+
+gn.AnEnumMethods.methodA(gn.anenum1, gn.anenum2, gn.anenum3)
+gn.AnEnumMethods.methodB(gn.anenum1, gn.anenum2, gn.anenum3)
+
+gn.TheEnumMethods.methodA(gn.theenum1, gn.theenum2, gn.theenum3)
+gn.TheEnumMethods.methodB(gn.theenum1, gn.theenum2, gn.theenum3)
--- /dev/null
+require("import") -- the import fn
+import("global_vars") -- import lib
+gv = global_vars
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+gv.b = "abcde"
+assert(gv.b == "abcde")
+
+gv.a.x = 7
+assert(gv.a.x == 7)
+
+a1 = gv.A()
+a1.x = 11
+gv.a = a1
+assert(gv.a.x == 11)
+
+gv.x = 10
+assert(gv.x == 10)
+
+assert(gv.Hi ~= nil)
+assert(gv.Hola ~= nil)
+
+gv.h = gv.Hi
+assert(gv.h == gv.Hi)
+
+
+-- It is not clear whether these tests should work or not
+-- Currently they don't.
+--
+-- assert(gv.c_member == 10)
+--
+-- gv.c_member = 5
+-- assert(gv.x == 5)
+--
+-- gv.h = gv.Hi
+-- assert(gv.hr == gv.Hi)
+--
+-- gv.hr = gv.Hola
+-- assert(gv.h == gv.Hola)
+-- assert(gv.hr == gv.Hola)
--- /dev/null
+require("import") -- the import fn
+import("grouping") -- import lib into global
+g=grouping --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(g.test1(5) == 5)
+g.test2(42) -- Return value is int* packed into userdata. We can't do anything with it
+
+assert(g.test3 == 37)
+g.test3 = 42
+assert(g.test3 == 42)
+
+assert(g.NEGATE ~= nil)
+assert(g.do_unary(5, g.NEGATE) == -5)
--- /dev/null
+require("import") -- the import fn
+import("iadd") -- import lib into global
+i=iadd --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+foo1 = i.Foo()
+foo1_a = foo1.AsA
+assert(foo1_a.x == 5)
+assert(foo1_a:get_me().x == 5)
+-- Unfortunately, in Lua operator+= can't be overloaded
+
+foo1.AsLong = 1000
+assert(foo1.AsLong == 1000)
-- import
-- the lua 5.0 loading mechanism is rather poor & relies upon the loadlib() fn
-- the lua 5.1 loading mechanism is simplicity itself
--- for now we need a bridge which will use the correct verion
+-- for now we need a bridge which will use the correct version
function import_5_0(name)
-- imports the file into the program
local lib=loadlib(name..'.dll','luaopen_'..name) or loadlib(name..'.so','luaopen_'..name)
assert(lib,"error loading module:"..name)
- lib() -- execute the function: initalising the lib
+ lib() -- execute the function: initialising the lib
assert(rawget(_G,name)~=nil,"no module table found")
end
import=import_5_0
else
import=import_5_1
-end
\ No newline at end of file
+end
--- /dev/null
+require("import") -- the import fn
+import("inherit_missing") -- import lib
+im=inherit_missing
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+bar = im.Bar()
+spam = im.Spam()
+
+assert(im.do_blah(bar) == "Bar::blah")
+assert(im.do_blah(spam) == "Spam::blah")
--- /dev/null
+require("import") -- the import fn
+import("keyword_rename_c") -- import lib into global
+kn=keyword_rename_c--alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+-- Check renaming of Lua keywords
+assert(kn.c_end(5) == 5)
+assert(kn.c_nil(7) == 7)
--- /dev/null
+require("import") -- the import fn
+import("keyword_rename") -- import lib into global
+kn=keyword_rename--alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+-- Check renaming of Lua keywords
+assert(kn.c_end(5) == 5)
+assert(kn.c_nil(7) == 7)
--- /dev/null
+require("import") -- the import fn
+import("li_carrays_cpp") -- import code
+lc = li_carrays_cpp
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+-- Testing for %array_functions(int,intArray)
+ary = lc.new_intArray(2)
+lc.intArray_setitem(ary, 0, 0)
+lc.intArray_setitem(ary, 1, 1)
+assert(lc.intArray_getitem(ary, 0)==0)
+assert(lc.intArray_getitem(ary, 1)==1)
+lc.delete_intArray(ary)
+
+-- Testing for %array_class(double, doubleArray)
+d = lc.doubleArray(10)
+d[0] = 7
+d[5] = d[0] + 3
+assert(d[5] + d[0] == 17)
+--print(d[5] + d[0])
+
+ptr = d:cast() -- to ptr
+d2 = lc.doubleArray_frompointer(ptr) -- and back to array
+assert(d2[5] + d2[0] == 17)
+--print(d2[5] + d2[0])
+
require("import") -- the import fn
import("li_carrays") -- import code
-
--- moving to global
-for k,v in pairs(li_carrays) do _G[k]=v end
+lc = li_carrays
-- catch "undefined" global variables
local env = _ENV -- Lua 5.2
setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
-- Testing for %array_functions(int,intArray)
-ary = new_intArray(2)
-intArray_setitem(ary, 0, 0)
-intArray_setitem(ary, 1, 1)
-assert(intArray_getitem(ary, 0)==0)
-assert(intArray_getitem(ary, 1)==1)
-delete_intArray(ary)
+ary = lc.new_intArray(2)
+lc.intArray_setitem(ary, 0, 0)
+lc.intArray_setitem(ary, 1, 1)
+assert(lc.intArray_getitem(ary, 0)==0)
+assert(lc.intArray_getitem(ary, 1)==1)
+lc.delete_intArray(ary)
-- Testing for %array_class(double, doubleArray)
-d = doubleArray(10)
+d = lc.doubleArray(10)
d[0] = 7
d[5] = d[0] + 3
assert(d[5] + d[0] == 17)
--print(d[5] + d[0])
ptr = d:cast() -- to ptr
-d2 = doubleArray_frompointer(ptr) -- and back to array
+d2 = lc.doubleArray_frompointer(ptr) -- and back to array
assert(d2[5] + d2[0] == 17)
--print(d2[5] + d2[0])
end
for i=0,3 do
- assert( swig_type(sv[i]) =='Struct *' and sv[i].num==i)
+ assert(swig_type(sv[i]) =='Struct *' and sv[i].num==i)
end
-- range checking
--- /dev/null
+require("import") -- the import fn
+import("lua_inherit_getitem") -- import lib
+
+local t = lua_inherit_getitem;
+local base = t.CBase()
+local derived = t.CDerived()
+
+assert(base.Foo ~= nil)
+assert(base:Foo() == "CBase::Foo")
+assert(derived.Foo == base.Foo)
+assert(derived:Foo() == "CBase::Foo")
+
--Example using pointers to member functions
-
require("import") -- the import fn
import("member_pointer") -- import code
+mp = member_pointer
-for k,v in pairs(member_pointer) do _G[k]=v end
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
function check(what, expected, actual)
assert(expected == actual,"Failed: "..what.." Expected: "..expected.." Actual: "..actual)
end
-- Get the pointers
-area_pt = areapt()
-perim_pt = perimeterpt()
+area_pt = mp.areapt()
+perim_pt = mp.perimeterpt()
-- Create some objects
-s = Square(10)
+s = mp.Square(10)
-- Do some calculations
-check ("Square area ", 100.0, do_op(s,area_pt))
-check ("Square perim", 40.0, do_op(s,perim_pt))
+check ("Square area ", 100.0, mp.do_op(s,area_pt))
+check ("Square perim", 40.0, mp.do_op(s,perim_pt))
-- Try the variables
-- these have to still be part of the 'member_pointer' table
-memberPtr = member_pointer.areavar
-memberPtr = member_pointer.perimetervar
+memberPtr = mp.areavar
+memberPtr = mp.perimetervar
-check ("Square area ", 100.0, do_op(s,member_pointer.areavar))
-check ("Square perim", 40.0, do_op(s,member_pointer.perimetervar))
+check ("Square area ", 100.0, mp.do_op(s,mp.areavar))
+check ("Square perim", 40.0, mp.do_op(s,mp.perimetervar))
-- Modify one of the variables
-member_pointer.areavar = perim_pt
+mp.areavar = perim_pt
-check ("Square perimeter", 40.0, do_op(s,member_pointer.areavar))
+check ("Square perimeter", 40.0, mp.do_op(s,mp.areavar))
-- Try the constants
-memberPtr = AREAPT
-memberPtr = PERIMPT
-memberPtr = NULLPT
+memberPtr = mp.AREAPT
+memberPtr = mp.PERIMPT
+memberPtr = mp.NULLPT
-check ("Square area ", 100.0, do_op(s,AREAPT))
-check ("Square perim", 40.0, do_op(s,PERIMPT))
+check ("Square area ", 100.0, mp.do_op(s,mp.AREAPT))
+check ("Square perim", 40.0, mp.do_op(s,mp.PERIMPT))
--- /dev/null
+require("import") -- the import fn
+import("nested_workaround") -- import lib
+nw=nested_workaround
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+i1 = nw.Inner(5)
+assert(i1:getValue() == 5)
+i1:setValue(7)
+assert(i1:getValue() == 7)
+
+o1 = nw.Outer()
+i2 = o1:createInner(9)
+assert(i2:getValue() == 9)
+i2:setValue(11)
+assert(o1:getInnerValue(i2) == 11)
+
+i3 = o1:doubleInnerValue(i2)
+assert(i3:getValue() == 22)
require("import") -- the import fn
import("newobject1") -- import code
-foo1 = newobject1.Foo_makeFoo() -- lua doesnt yet support static fns properly
-assert(newobject1.Foo_fooCount() == 1) -- lua doesnt yet support static fns properly
+foo1 = newobject1.Foo_makeFoo()
+assert(newobject1.Foo_fooCount() == 1)
foo2 = foo1:makeMore()
assert(newobject1.Foo_fooCount() == 2)
--- /dev/null
+require("import") -- the import fn
+import("nspace_extend") -- import lib
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+ne = nspace_extend
+
+-- Inner1
+
+-- Constructors
+in1_clr1 = ne.Outer.Inner1.Color()
+in1_clr2 = ne.Outer.Inner1.Color.create()
+in1_clr3 = ne.Outer.Inner1.Color(in1_clr2)
+
+-- methods
+in1_clr1:colorInstanceMethod(1.0)
+ne.Outer.Inner1.Color.colorStaticMethod(2.0)
+
+-- Inner2
+
+-- Constructors
+in2_clr1 = ne.Outer.Inner2.Color()
+in2_clr2 = ne.Outer.Inner2.Color.create()
+in2_clr3 = ne.Outer.Inner2.Color(in2_clr2)
+
+assert(pcall(ne.Outer.Inner2.Color, in1_clr1) == false)
+
+-- methods
+in2_clr1:colorInstanceMethod(1.0)
+ne.Outer.Inner2.Color.colorStaticMethod(2.0)
+
+in2_clr3:colors(in1_clr1, in1_clr2, in2_clr2, in2_clr2, in2_clr3)
+
+assert(pcall(in2_clr3.colors, in2_clr3,
+ in2_clr1, in2_clr2, in1_clr2, in2_clr2, in2_clr3) == false)
+
--- /dev/null
+require("import") -- the import fn
+import("nspace") -- import lib
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+ns = nspace
+
+-- Inheritance
+blue1 = ns.Outer.Inner3.Blue()
+
+-- blue1:blueInstanceMethod()
+blue1:colorInstanceMethod(60.0)
+blue1.instanceMemberVariable = 4
+assert( blue1.instanceMemberVariable == 4 )
+
+-- Constructors
+color1 = ns.Outer.Inner1.Color()
+color2 = ns.Outer.Inner1.Color.create()
+color = ns.Outer.Inner1.Color(color1)
+color3 = ns.Outer.Inner2.Color.create()
+color4 = ns.Outer.Inner2.Color.create()
+color5 = ns.Outer.Inner2.Color.create()
+mwp2 = ns.Outer.MyWorldPart2()
+gc = ns.GlobalClass()
+
+nnsp = ns.NoNSpacePlease()
+
+-- Class methods
+color:colorInstanceMethod(20.0)
+ns.Outer.Inner1.Color.colorStaticMethod(30.0)
+color3:colorInstanceMethod(40.0)
+ns.Outer.Inner2.Color.colorStaticMethod(50.0)
+color3:colors(color1, color2, color3, color4, color5)
+
+gc:gmethod()
+
+-- Class variables
+color.instanceMemberVariable = 5
+color1.instanceMemberVariable = 7
+assert( color.instanceMemberVariable == 5 )
+assert( color1.instanceMemberVariable == 7 )
+assert(ns.Outer.Inner1.Color.staticMemberVariable == 0 )
+assert(ns.Outer.Inner2.Color.staticMemberVariable == 0 )
+ns.Outer.Inner1.Color.staticMemberVariable = 9
+ns.Outer.Inner2.Color.staticMemberVariable = 11
+assert(ns.Outer.Inner1.Color.staticMemberVariable == 9)
+assert(ns.Outer.Inner2.Color.staticMemberVariable == 11)
+
+-- Class constants
+assert( ns.Outer.Inner1.Color.Specular == 0x20 )
+assert( ns.Outer.Inner2.Color.Specular == 0x40 )
+assert( ns.Outer.Inner1.Color.staticConstMemberVariable == 222 )
+assert( ns.Outer.Inner2.Color.staticConstMemberVariable == 333 )
+assert( ns.Outer.Inner1.Color.staticConstEnumMemberVariable ~= ns.Outer.Inner2.Color.staticConstEnumMemberVariable )
+
+
+-- Aggregation
+sc = ns.Outer.SomeClass()
+assert( sc:GetInner1ColorChannel() ~= sc:GetInner2Channel() )
+assert( sc:GetInner1Channel() ~= sc:GetInner2Channel() )
+
+-- Backward compatibility
+assert(ns.Outer.Inner1.Diffuse ~= nil)
+-- Enums within class within namespace shouldn't have backward compatible name. Same for static methods
+assert(ns.Outer.Inner1.Color_Diffuse == nil)
+assert(ns.Outer.Inner1.Color_colorStaticMethod == nil)
+
+-- Enums and static methods of class marked as %nonspace should have backward compatible name
+assert(ns.NoNSpacePlease_noNspaceStaticFunc() == 10)
+assert(ns.Outer.Inner2.NoNSpacePlease_NoNspace == nil)
+-- ReallyNoNSpaceEnum is wrapped into %nonspace and thus handled correctly.
+-- NoNSpaceEnum is not (although both of them are in %nonspace-wrapped class) and thus
+-- handled rather unexpectedly
+assert(ns.NoNSpacePlease_ReallyNoNspace1 == 1)
+assert(ns.NoNSpacePlease.ReallyNoNspace2 == 10)
+
--- demo of lua swig capacilities (operator overloading)
+-- demo of lua swig capacities (operator overloading)
require("import") -- the import fn
import("operator_overload") -- import lib
assert(b>d)
assert(b>=d)
--- lua does not support += operators: skiping
+-- lua does not support += operators: skipping
-- test +
f=Op(1)
--lua 5.0.2 defines that unary - is __unm(self,nil)
--lua 5.1.2 defines that unary - is __unm(self,self)
---C++ expectes unary - as operator-()
+--C++ expects unary - as operator-()
--however the latest version of SWIG strictly checks the number of args
--and will complain if too many args are provided
--therefore disabling these tests for now
assert(tostring(Op(1))=="Op(1)")
assert(tostring(Op(-3))=="Op(-3)")
+
+-- check that operator overloads are correctly propagated down inheritance hierarchy
+
+a_d=OpDerived()
+b_d=OpDerived(5)
+c_d=OpDerived(5)
+d_d=OpDerived(2)
+-- test equality
+assert(a_d~=b_d)
+assert(b_d==c_d)
+assert(a_d~=d_d)
+
+-- test <
+assert(a_d<b_d)
+assert(a_d<=b_d)
+assert(b_d<=c_d)
+assert(b_d>=c_d)
+assert(b_d>d_d)
+assert(b_d>=d_d)
+--
+-- test + inheritance
+f_d=OpDerived(1)
+g_d=OpDerived(1)
+assert(f_d+g_d==Op(2))
+assert(f_d-g_d==Op(0))
+assert(f_d*g_d==Op(1))
+assert(f_d/g_d==Op(1))
+--
+-- plus add some code to check the __str__ fn inheritance
+assert(tostring(OpDerived(1))=="Op(1)")
+assert(tostring(OpDerived(-3))=="Op(-3)")
+
--[[
/* Sample test code in C++
--- /dev/null
+require("import") -- the import fn
+import("overload_complicated") -- import lib into global
+oc=overload_complicated --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(oc.foo(1,1,"test",1) == 15)
+
+p1 = oc.Pop(nil)
+p1 = oc.Pop(nil,false)
+
+assert(p1:hip(true) == 701)
+assert(p1:hip(nil) == 702)
+
+assert(p1:hop(true) == 801)
+assert(p1:hop(nil) == 805)
+
+assert(oc.muzak(true) == 3001)
+assert(oc.muzak(nil) == 3002)
--- /dev/null
+require("import") -- the import fn
+import("refcount") -- import lib
+r=refcount
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+a = r.A()
+assert(a:ref_count() == 1)
+
+b1 = r.B(a)
+assert(a:ref_count() == 2)
+
+b2 = r.B.create(a)
+assert(a:ref_count() == 3)
+
+b3 = b2:cloner()
+assert(a:ref_count() == 4)
+
+rca = b1:get_rca() -- RCPtr<A> is not wrapped
+assert(a:ref_count() == 5)
+
+b4 = r.global_create(a)
+assert(a:ref_count() == 6)
--- /dev/null
+require("import") -- the import fn
+import("rename_simple") -- import lib
+rs = rename_simple
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(rs.NewStruct ~= nil)
+assert(rs.NewStruct.NewStaticVariable == 444)
+assert(rs.NewStruct_NewStaticVariable == 444)
+
+assert(rs.NewStruct.NewStaticMethod() == 333)
+assert(rs.NewStruct_NewStaticMethod() == 333)
+
+assert(rs.NewStruct.ONE == 1)
+assert(rs.NewStruct_ONE == 1)
+
+assert(rs.NewFunction() == 555)
+
+assert(rs.OldStruct == nil)
+assert(rs.OldFunction == nil)
+assert(rs.OldGlobalVariable == nil)
+assert(rs.OldStruct_ONE == nil)
--- /dev/null
+require("import") -- the import fn
+import("smart_pointer_extend") -- import lib into global
+spe=smart_pointer_extend --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(spe.CBase.hello() == 1)
+assert(spe.CBase.z == 1)
+
+base1 = spe.CBase()
+base1.x = 7
+
+p1 = spe.CPtr()
+
+assert(spe.get_hello(p1) == 1)
+assert(p1:foo() == 1)
+assert(p1:bar() == 2)
+assert(p1:boo(5) == 5)
+
+foo = spe.Foo()
+bar = spe.Bar(foo)
+
+assert(bar:extension(5,7) == 5)
+assert(bar:extension(7) == 7)
+assert(bar:extension() == 1)
+
+dfoo = spe.DFoo()
+dptr = spe.DPtrFoo(dfoo)
+
+assert(dptr:Ext() == 2)
+assert(dptr:Ext(5) == 5)
--- /dev/null
+require("import") -- the import fn
+import("smart_pointer_inherit") -- import lib into global
+spi=smart_pointer_inherit --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+der = spi.Derived(7)
+
+ptr = spi.SmartDerived(der)
+
+assert(ptr.val == 7)
+assert(ptr:value() == 7)
+assert(ptr:value2() == 7)
+assert(ptr:value3() == 7)
+assert(ptr:valuehide() == -1)
--- /dev/null
+require("import") -- the import fn
+import("smart_pointer_multi") -- import lib into global
+spm=smart_pointer_multi --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+foo = spm.Foo()
+foo.x = 5
+assert(foo:getx() == 5)
+
+bar = spm.Bar(foo)
+spam = spm.Spam(bar)
+grok = spm.Grok(bar)
+
+assert(bar:getx() == 5)
+assert(spam:getx() == 5)
+spam.x = 7
+assert(grok:getx() == 7)
+grok.x = 10
+assert(foo:getx() == 10)
--- /dev/null
+require("import") -- the import fn
+import("smart_pointer_not") -- import lib into global
+spn=smart_pointer_not --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+
+foo = spn.Foo()
+foo.x = 7
+assert(foo:getx() == 7)
+
+bar = spn.Bar(foo)
+success = pcall(bar.getx, bar) -- Bar is not a smart pointer. Call should fail
+assert(not success)
+
+spam = spn.Spam(foo)
+success = pcall(spam.getx, spam) -- Spam is not a smart pointer. Call should fail
+assert(not success)
+
+grok = spn.Grok(foo)
+success = pcall(grok.getx, grok) -- Spam is not a smart pointer. Call should fail
+assert(not success)
--- /dev/null
+require("import") -- the import fn
+import("smart_pointer_rename") -- import lib into global
+spr=smart_pointer_rename --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+
+foo = spr.Foo()
+assert(foo:ftest1(1) == 1)
+assert(foo:ftest2(1,2) == 2)
+
+bar = spr.Bar(foo)
+assert(bar:test() == 3)
+assert(bar:ftest1(1) == 1)
+assert(bar:ftest2(1,2) == 2)
--- /dev/null
+require("import") -- the import fn
+import("smart_pointer_simple") -- import lib into global
+sps=smart_pointer_simple --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+foo1 = sps.Foo()
+foo1.x = 5
+assert(foo1.x == 5)
+assert(foo1:getx() == 5)
+
+bar1 = sps.Bar(foo1)
+bar1.x = 3
+assert(bar1.x == 3)
+assert(bar1:getx() == 3)
+
+bar1.x = 5
+assert(bar1.x == 5)
+assert(bar1:getx() == 5)
--- /dev/null
+require("import") -- the import fn
+import("smart_pointer_templatemethods") -- import lib into global
+spt=smart_pointer_templatemethods --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+o1 = spt.Objct()
+
+iid = spt.InterfaceId()
+
+po2 = o1:QueryInterfaceObjct(iid)
+-- we can't call po2:DisposeObjct, because smart pointer Ptr<T> always return 0 when dereferencing
+-- (see interface file). So we only check that po2 has necessary method
+assert(po2.DisposeObjct ~= nil)
+assert(po2.QueryInterfaceObjct ~= nil)
--- /dev/null
+require("import") -- the import fn
+import("static_const_member_2") -- import lib
+scm=static_const_member_2
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(scm.CavityPackFlags.forward_field == 1)
+assert(scm.CavityPackFlags.backward_field == 2)
+assert(scm.CavityPackFlags.cavity_flags == 3)
+
+assert(scm.CavityPackFlags.flags == 0)
+scm.CavityPackFlags.flags = 91
+assert(scm.CavityPackFlags.flags == 91)
+assert(scm.CavityPackFlags_flags == 91) -- old style bindings
+
+assert(scm.CavityPackFlags.reftest == 42)
+
+assert(scm.Test_int.LeftIndex ~= nil)
+assert(scm.Test_int.current_profile == 4)
+
+assert(scm.Foo.BAR.val == 1)
+assert(scm.Foo.BAZ.val == 2)
+
+assert(scm.Foo_BAR.val == 1)
+assert(scm.Foo_BAZ.val == 2)
+
+scm.Foo.BAR.val = 4
+scm.Foo.BAZ.val = 5
+
+assert(scm.Foo.BAR.val == 4)
+assert(scm.Foo.BAZ.val == 5)
+
+assert(scm.Foo_BAR.val == 4)
+assert(scm.Foo_BAZ.val == 5)
--- /dev/null
+require("import") -- the import fn
+import("static_const_member") -- import lib into global
+scm=static_const_member --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(scm.X.PN == 0)
+assert(scm.X.CN == 1)
+assert(scm.X.EN == 2)
+assert(scm.X.CHARTEST == "A")
+
+-- Old-style bindings
+assert(scm.X_PN == 0)
+assert(scm.X_CN == 1)
+assert(scm.X_EN == 2)
+assert(scm.X_CHARTEST == "A")
+
+
--- /dev/null
+require("import") -- the import fn
+import("template_construct") -- import lib into global
+tc=template_construct --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+foo = tc.Foo_int(1)
--for k,v in pairs(template_default_arg) do _G[k]=v end -- move to global
helloInt = template_default_arg.Hello_int()
+assert(template_default_arg.Hello_int_hi ~= nil)
helloInt:foo(template_default_arg.Hello_int_hi)
x = template_default_arg.X_int()
--- /dev/null
+require("import") -- the import fn
+import("template_extend1") -- import lib into global
+te=template_extend1 --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+lb = te.lBaz()
+assert(lb:foo() == "lBaz::foo")
+
+db = te.dBaz()
+assert(db:foo() == "dBaz::foo")
--- /dev/null
+require("import") -- the import fn
+import("template_extend2") -- import lib into global
+te=template_extend2 --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+lb = te.lBaz()
+assert(lb:foo() == "lBaz::foo")
+
+db = te.dBaz()
+assert(db:foo() == "dBaz::foo")
--- /dev/null
+require("import") -- the import fn
+import("template_inherit") -- import lib into global
+ti=template_inherit --alias
+
+-- catching undefined variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+
+fi = ti.FooInt()
+assert(fi:blah() == "Foo")
+assert(fi:foomethod() == "foomethod")
+
+bi = ti.BarInt()
+assert(bi:blah() == "Bar")
+assert(bi:foomethod() == "foomethod")
+
+assert(ti.invoke_blah_int(fi) == "Foo")
+assert(ti.invoke_blah_int(bi) == "Bar")
+
+bd = ti.BarDouble()
+success = pcall(ti.invoke_blah_int, bd)
+assert(not success)
--- /dev/null
+require("import") -- the import fn
+import("template_static") -- import lib
+ts=template_static
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(ts.foo_i.test == 0)
+ts.foo_i.test = 42
+assert(ts.foo_i.test == 42)
+assert(ts.foo_i_test == 42)
+ts.foo_i_test = 57
+assert(ts.foo_i.test == 57)
+assert(ts.foo_i_test == 57)
+assert(ts.foo_d.test == 0)
+
+assert(ts.Foo.bar_double(4) == 1.0)
+assert(ts.Foo_bar_double(4) == 1.0)
--- /dev/null
+require("import") -- the import fn
+import("valuewrapper") -- import code
+v=valuewrapper -- renaming import
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(v.Xi ~= nil)
+assert(v.YXi ~= nil)
+
+x1 = v.Xi(5)
+
+y1 =v.YXi()
+assert(y1:spam(x1) == 0)
+assert(y1:spam() == 0)
--- /dev/null
+require("import") -- the import fn
+import("varargs") -- import lib
+v=varargs
+
+-- catch "undefined" global variables
+local env = _ENV -- Lua 5.2
+if not env then env = getfenv () end -- Lua 5.1
+setmetatable(env, {__index=function (t,i) error("undefined global variable `"..i.."'",2) end})
+
+assert(v.test("Hello") == "Hello")
+assert(v.test_def("Hello",0) == "Hello")
+
+assert(v.Foo.statictest("Hello") == "Hello")
+assert(v.Foo.statictest("Hello",1) == "Hello")
+
+assert(v.test_plenty("Hello") == "Hello")
+assert(v.test_plenty("Hello",1) == "Hello")
+assert(v.test_plenty("Hello",1,2) == "Hello")
--- /dev/null
+%module lua_inherit_getitem
+
+%inline %{
+
+class CBase {
+public:
+ const char* Foo(void) {
+ return "CBase::Foo";
+ }
+};
+
+class CDerived : public CBase {
+public:
+ void *__getitem(const char *name) const {
+ return NULL;
+ }
+};
+
+%}
void move(double dx, double dy);
virtual double area(Shape &ref, int & (FunkSpace::Funktions::*d)(const int &, int)) { return 0.0; }
virtual double abc(Thing<short> ts, Thing< const Space::Shape * > tda[]) { return 0.0; }
+ virtual ~Shape() {}
};
}
--- /dev/null
+// This is a copy of the multiple_inheritance_abstract test
+%module multiple_inheritance_abstract
+
+%warnfilter(SWIGWARN_RUBY_MULTIPLE_INHERITANCE,
+ SWIGWARN_D_MULTIPLE_INHERITANCE,
+ SWIGWARN_PHP_MULTIPLE_INHERITANCE); /* languages not supporting multiple inheritance or %interface */
+
+#if defined(SWIGJAVA) || defined(SWIGCSHARP)
+%include "swiginterface.i"
+%interface_impl(Space::ABase1)
+%interface_impl(Space::CBase1)
+%interface_impl(Space::CBase2)
+#endif
+
+#if defined(SWIGD)
+// Missing multiple inheritance support results in incorrect use of override
+%ignore CBase1;
+%ignore CBase2;
+#endif
+
+%inline %{
+namespace Space {
+ struct CBase1 {
+ virtual void cbase1x() {
+ return;
+ }
+ virtual int cbase1y() {
+ return 1;
+ }
+ int cbase1z() {
+ return 10;
+ }
+ virtual ~CBase1() {
+ }
+ };
+
+ struct CBase2 {
+ virtual int cbase2() {
+ return 2;
+ }
+ virtual ~CBase2() {
+ }
+ };
+
+ struct ABase1 {
+ virtual int abase1() = 0;
+ virtual ~ABase1() {
+ }
+ };
+
+ struct Derived1 : CBase2, CBase1 {
+ virtual void cbase1x() {
+ return;
+ }
+ virtual int cbase1y() {
+ return 3;
+ }
+ virtual int cbase2() {
+ return 4;
+ }
+ virtual CBase2 *cloneit() {
+ return new Derived1(*this);
+ }
+ void derived1() {
+ }
+ };
+
+ struct Derived2 : CBase1, ABase1 {
+ virtual void cbase1x() {
+ return;
+ }
+ virtual int cbase1y() {
+ return 6;
+ }
+ virtual int abase1() {
+ return 5;
+ }
+ virtual CBase1 *cloneit() {
+ return new Derived2(*this);
+ }
+ void derived2() {
+ }
+ };
+
+ struct Derived3 : ABase1, CBase1, CBase2 {
+ virtual int cbase1y() {
+ return 7;
+ }
+ virtual int cbase2() {
+ return 8;
+ }
+ virtual int abase1() {
+ return 9;
+ }
+ virtual void cbase1x() {
+ }
+ virtual ABase1 *cloneit() {
+ return new Derived3(*this);
+ }
+ void derived3() {
+ }
+ };
+
+ struct Bottom1 : Derived1 {
+ virtual void cbase1x() {
+ return;
+ }
+ virtual int cbase1y() {
+ return 103;
+ }
+ virtual int cbase2() {
+ return 104;
+ }
+ };
+
+ struct Bottom2 : Derived2 {
+ virtual int cbase1y() {
+ return 206;
+ }
+ virtual int abase1() {
+ return 205;
+ }
+ };
+
+ struct Bottom3 : Derived3 {
+ virtual int cbase1y() {
+ return 307;
+ }
+ virtual int cbase2() {
+ return 308;
+ }
+ virtual int abase1() {
+ return 309;
+ }
+ };
+
+ // Base classes as input
+ int InputValCBase1(CBase1 cb1) {
+ return cb1.cbase1y();
+ }
+ int InputValCBase2(CBase2 cb2) {
+ return cb2.cbase2();
+ }
+
+ int InputPtrABase1(ABase1 *pab1) {
+ return pab1->abase1();
+ }
+ int InputPtrCBase1(CBase1 *pcb1) {
+ return pcb1->cbase1y();
+ }
+ int InputPtrCBase2(CBase2 *pcb2) {
+ return pcb2->cbase2();
+ }
+
+ int InputRefABase1(ABase1 &rab1) {
+ return rab1.abase1();
+ }
+ int InputRefCBase1(CBase1 &rcb1) {
+ return rcb1.cbase1y();
+ }
+ int InputRefCBase2(CBase2 &rcb2) {
+ return rcb2.cbase2();
+ }
+
+ int InputCPtrRefABase1(ABase1 *const& pab1) {
+ return pab1->abase1();
+ }
+ int InputCPtrRefCBase1(CBase1 *const& pcb1) {
+ return pcb1->cbase1y();
+ }
+ int InputCPtrRefCBase2(CBase2 *const& pcb2) {
+ return pcb2->cbase2();
+ }
+
+ // Derived classes as input
+ int InputValDerived1(Derived1 d) {
+ return d.cbase1y() + d.cbase2();
+ }
+ int InputValDerived2(Derived2 d) {
+ return d.cbase1y() + d.abase1();
+ }
+ int InputValDerived3(Derived3 d) {
+ return d.cbase1y() + d.cbase2() + d.abase1();
+ }
+
+ int InputRefDerived1(Derived1 &d) {
+ return d.cbase1y() + d.cbase2();
+ }
+ int InputRefDerived2(Derived2 &d) {
+ return d.cbase1y() + d.abase1();
+ }
+ int InputRefDerived3(Derived3 &d) {
+ return d.cbase1y() + d.cbase2() + d.abase1();
+ }
+
+ int InputPtrDerived1(Derived1 *d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputPtrDerived2(Derived2 *d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputPtrDerived3(Derived3 *d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ int InputCPtrRefDerived1(Derived1 *const& d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputCPtrRefDerived2(Derived2 *const& d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputCPtrRefDerived3(Derived3 *const& d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ // Bottom classes as input
+ int InputValBottom1(Bottom1 d) {
+ return d.cbase1y() + d.cbase2();
+ }
+ int InputValBottom2(Bottom2 d) {
+ return d.cbase1y() + d.abase1();
+ }
+ int InputValBottom3(Bottom3 d) {
+ return d.cbase1y() + d.cbase2() + d.abase1();
+ }
+
+ int InputRefBottom1(Bottom1 &d) {
+ return d.cbase1y() + d.cbase2();
+ }
+ int InputRefBottom2(Bottom2 &d) {
+ return d.cbase1y() + d.abase1();
+ }
+ int InputRefBottom3(Bottom3 &d) {
+ return d.cbase1y() + d.cbase2() + d.abase1();
+ }
+
+ int InputPtrBottom1(Bottom1 *d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputPtrBottom2(Bottom2 *d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputPtrBottom3(Bottom3 *d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ int InputCPtrRefBottom1(Bottom1 *const& d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputCPtrRefBottom2(Bottom2 *const& d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputCPtrRefBottom3(Bottom3 *const& d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ // Return pointers
+ CBase1 *MakePtrDerived1_CBase1() {
+ return new Derived1();
+ }
+ CBase2 *MakePtrDerived1_CBase2() {
+ return new Derived1();
+ }
+ CBase1 *MakePtrDerived2_CBase1() {
+ return new Derived2();
+ }
+ ABase1 *MakePtrDerived2_ABase1() {
+ return new Derived2();
+ }
+ ABase1 *MakePtrDerived3_ABase1() {
+ return new Derived3();
+ }
+ CBase1 *MakePtrDerived3_CBase1() {
+ return new Derived3();
+ }
+ CBase2 *MakePtrDerived3_CBase2() {
+ return new Derived3();
+ }
+
+ // Return references
+ CBase1 &MakeRefDerived1_CBase1() {
+ static Derived1 d;
+ return d;
+ }
+ CBase2 &MakeRefDerived1_CBase2() {
+ static Derived1 d;
+ return d;
+ }
+ CBase1 &MakeRefDerived2_CBase1() {
+ static Derived2 d;
+ return d;
+ }
+ ABase1 &MakeRefDerived2_ABase1() {
+ static Derived2 d;
+ return d;
+ }
+ ABase1 &MakeRefDerived3_ABase1() {
+ static Derived3 d;
+ return d;
+ }
+ CBase1 &MakeRefDerived3_CBase1() {
+ static Derived3 d;
+ return d;
+ }
+ CBase2 &MakeRefDerived3_CBase2() {
+ static Derived3 d;
+ return d;
+ }
+
+ // Return by value (sliced objects)
+ CBase1 MakeValDerived1_CBase1() {
+ return Derived1();
+ }
+ CBase2 MakeValDerived1_CBase2() {
+ return Derived1();
+ }
+ CBase1 MakeValDerived2_CBase1() {
+ return Derived2();
+ }
+ CBase1 MakeValDerived3_CBase1() {
+ return Derived3();
+ }
+ CBase2 MakeValDerived3_CBase2() {
+ return Derived3();
+ }
+}
+
+%}
--- /dev/null
+%module multiple_inheritance_interfaces
+
+%warnfilter(SWIGWARN_RUBY_MULTIPLE_INHERITANCE,
+ SWIGWARN_D_MULTIPLE_INHERITANCE,
+ SWIGWARN_PHP_MULTIPLE_INHERITANCE); /* languages not supporting multiple inheritance or %interface */
+
+#if defined(SWIGJAVA) || defined(SWIGCSHARP)
+%include "swiginterface.i"
+%interface_custom("A", "IA", IA)
+%interface_custom("B", "IB", IB)
+%interface_custom("%(strip:[I])s", "I%s", IC) // same as %interface_custom("C", "IC", IC)
+#endif
+
+%inline %{
+struct IA {
+ virtual void ia() {};
+ virtual void ia(const char *s, bool b = true) {}
+ virtual void ia(int i) {}
+ virtual ~IA() {}
+};
+struct IB { virtual ~IB() {} virtual void ib() {} };
+struct IC : IA, IB {};
+struct D : IC {};
+struct E : D {};
+%}
+
+#if defined(SWIGJAVA) || defined(SWIGCSHARP)
+%interface_custom("J", "IJ", IJ)
+%interface_custom("K", "IK", IK)
+%interface_custom("L", "IL", IL)
+#endif
+%inline %{
+struct IJ { virtual ~IJ() {}; virtual void ij() {} };
+struct IK : IJ {};
+struct IL : IK {};
+struct M : IL {};
+%}
+
+#if defined(SWIGJAVA) || defined(SWIGCSHARP)
+%interface_custom("Q", "IQ", IQ)
+#endif
+%inline %{
+struct P { virtual ~P() {} virtual void p() {} };
+struct IQ { virtual ~IQ() {} virtual void iq() {} };
+struct R : IQ, P {};
+struct S : P, IQ {};
+struct T : IQ {};
+struct U : R {};
+struct V : S {};
+struct W : T {};
+%}
+
+#if defined(SWIGJAVA) || defined(SWIGCSHARP)
+%interface_impl(BaseOverloaded);
+#endif
+%inline %{
+struct BaseOverloaded {
+ typedef P PTypedef;
+ virtual ~BaseOverloaded() {}
+ virtual void identical_overload(int i, const PTypedef &pp = PTypedef()) {}
+};
+
+struct DerivedOverloaded : public BaseOverloaded {
+ virtual void identical_overload(int i, const PTypedef &p = PTypedef()) {}
+};
+%}
--- /dev/null
+// This is a copy of the multiple_inheritance_abstract test
+%module multiple_inheritance_nspace
+
+%warnfilter(SWIGWARN_RUBY_MULTIPLE_INHERITANCE,
+ SWIGWARN_D_MULTIPLE_INHERITANCE,
+ SWIGWARN_PHP_MULTIPLE_INHERITANCE); /* languages not supporting multiple inheritance or %interface */
+
+// nspace feature only supported by these languages
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGD) || defined(SWIGLUA) || defined(SWIGJAVASCRIPT)
+%nspace;
+#endif
+
+#if defined(SWIGJAVA) || defined(SWIGCSHARP)
+%include "swiginterface.i"
+%interface(Space::ABase1)
+%interface(Space::CBase1)
+%interface(Space::CBase2)
+#endif
+
+#if defined(SWIGD)
+// Missing multiple inheritance support results in incorrect use of override
+%ignore CBase1;
+%ignore CBase2;
+#endif
+
+#if defined(SWIGJAVA)
+SWIG_JAVABODY_PROXY(public, public, SWIGTYPE)
+#endif
+
+%inline %{
+namespace Space {
+ struct CBase1 {
+ virtual void cbase1x() {
+ return;
+ }
+ virtual int cbase1y() {
+ return 1;
+ }
+ int cbase1z() {
+ return 10;
+ }
+ virtual ~CBase1() {
+ }
+ };
+
+ struct CBase2 {
+ virtual int cbase2() {
+ return 2;
+ }
+ virtual ~CBase2() {
+ }
+ };
+
+ struct ABase1 {
+ virtual int abase1() = 0;
+ virtual ~ABase1() {
+ }
+ };
+
+ struct Derived1 : CBase2, CBase1 {
+ virtual void cbase1x() {
+ return;
+ }
+ virtual int cbase1y() {
+ return 3;
+ }
+ virtual int cbase2() {
+ return 4;
+ }
+ virtual CBase2 *cloneit() {
+ return new Derived1(*this);
+ }
+ void derived1() {
+ }
+ };
+
+ struct Derived2 : CBase1, ABase1 {
+ virtual void cbase1x() {
+ return;
+ }
+ virtual int cbase1y() {
+ return 6;
+ }
+ virtual int abase1() {
+ return 5;
+ }
+ virtual CBase1 *cloneit() {
+ return new Derived2(*this);
+ }
+ void derived2() {
+ }
+ };
+
+ struct Derived3 : ABase1, CBase1, CBase2 {
+ virtual int cbase1y() {
+ return 7;
+ }
+ virtual int cbase2() {
+ return 8;
+ }
+ virtual int abase1() {
+ return 9;
+ }
+ virtual void cbase1x() {
+ }
+ virtual ABase1 *cloneit() {
+ return new Derived3(*this);
+ }
+ void derived3() {
+ }
+ };
+
+ struct Bottom1 : Derived1 {
+ virtual void cbase1x() {
+ return;
+ }
+ virtual int cbase1y() {
+ return 103;
+ }
+ virtual int cbase2() {
+ return 104;
+ }
+ };
+
+ struct Bottom2 : Derived2 {
+ virtual int cbase1y() {
+ return 206;
+ }
+ virtual int abase1() {
+ return 205;
+ }
+ };
+
+ struct Bottom3 : Derived3 {
+ virtual int cbase1y() {
+ return 307;
+ }
+ virtual int cbase2() {
+ return 308;
+ }
+ virtual int abase1() {
+ return 309;
+ }
+ };
+
+ // Base classes as input
+ int InputValCBase1(CBase1 cb1) {
+ return cb1.cbase1y();
+ }
+ int InputValCBase2(CBase2 cb2) {
+ return cb2.cbase2();
+ }
+
+ int InputPtrABase1(ABase1 *pab1) {
+ return pab1->abase1();
+ }
+ int InputPtrCBase1(CBase1 *pcb1) {
+ return pcb1->cbase1y();
+ }
+ int InputPtrCBase2(CBase2 *pcb2) {
+ return pcb2->cbase2();
+ }
+
+ int InputRefABase1(ABase1 &rab1) {
+ return rab1.abase1();
+ }
+ int InputRefCBase1(CBase1 &rcb1) {
+ return rcb1.cbase1y();
+ }
+ int InputRefCBase2(CBase2 &rcb2) {
+ return rcb2.cbase2();
+ }
+
+ int InputCPtrRefABase1(ABase1 *const& pab1) {
+ return pab1->abase1();
+ }
+ int InputCPtrRefCBase1(CBase1 *const& pcb1) {
+ return pcb1->cbase1y();
+ }
+ int InputCPtrRefCBase2(CBase2 *const& pcb2) {
+ return pcb2->cbase2();
+ }
+
+ // Derived classes as input
+ int InputValDerived1(Derived1 d) {
+ return d.cbase1y() + d.cbase2();
+ }
+ int InputValDerived2(Derived2 d) {
+ return d.cbase1y() + d.abase1();
+ }
+ int InputValDerived3(Derived3 d) {
+ return d.cbase1y() + d.cbase2() + d.abase1();
+ }
+
+ int InputRefDerived1(Derived1 &d) {
+ return d.cbase1y() + d.cbase2();
+ }
+ int InputRefDerived2(Derived2 &d) {
+ return d.cbase1y() + d.abase1();
+ }
+ int InputRefDerived3(Derived3 &d) {
+ return d.cbase1y() + d.cbase2() + d.abase1();
+ }
+
+ int InputPtrDerived1(Derived1 *d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputPtrDerived2(Derived2 *d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputPtrDerived3(Derived3 *d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ int InputCPtrRefDerived1(Derived1 *const& d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputCPtrRefDerived2(Derived2 *const& d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputCPtrRefDerived3(Derived3 *const& d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ // Bottom classes as input
+ int InputValBottom1(Bottom1 d) {
+ return d.cbase1y() + d.cbase2();
+ }
+ int InputValBottom2(Bottom2 d) {
+ return d.cbase1y() + d.abase1();
+ }
+ int InputValBottom3(Bottom3 d) {
+ return d.cbase1y() + d.cbase2() + d.abase1();
+ }
+
+ int InputRefBottom1(Bottom1 &d) {
+ return d.cbase1y() + d.cbase2();
+ }
+ int InputRefBottom2(Bottom2 &d) {
+ return d.cbase1y() + d.abase1();
+ }
+ int InputRefBottom3(Bottom3 &d) {
+ return d.cbase1y() + d.cbase2() + d.abase1();
+ }
+
+ int InputPtrBottom1(Bottom1 *d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputPtrBottom2(Bottom2 *d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputPtrBottom3(Bottom3 *d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ int InputCPtrRefBottom1(Bottom1 *const& d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputCPtrRefBottom2(Bottom2 *const& d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputCPtrRefBottom3(Bottom3 *const& d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ // Return pointers
+ CBase1 *MakePtrDerived1_CBase1() {
+ return new Derived1();
+ }
+ CBase2 *MakePtrDerived1_CBase2() {
+ return new Derived1();
+ }
+ CBase1 *MakePtrDerived2_CBase1() {
+ return new Derived2();
+ }
+ ABase1 *MakePtrDerived2_ABase1() {
+ return new Derived2();
+ }
+ ABase1 *MakePtrDerived3_ABase1() {
+ return new Derived3();
+ }
+ CBase1 *MakePtrDerived3_CBase1() {
+ return new Derived3();
+ }
+ CBase2 *MakePtrDerived3_CBase2() {
+ return new Derived3();
+ }
+
+ // Return references
+ CBase1 &MakeRefDerived1_CBase1() {
+ static Derived1 d;
+ return d;
+ }
+ CBase2 &MakeRefDerived1_CBase2() {
+ static Derived1 d;
+ return d;
+ }
+ CBase1 &MakeRefDerived2_CBase1() {
+ static Derived2 d;
+ return d;
+ }
+ ABase1 &MakeRefDerived2_ABase1() {
+ static Derived2 d;
+ return d;
+ }
+ ABase1 &MakeRefDerived3_ABase1() {
+ static Derived3 d;
+ return d;
+ }
+ CBase1 &MakeRefDerived3_CBase1() {
+ static Derived3 d;
+ return d;
+ }
+ CBase2 &MakeRefDerived3_CBase2() {
+ static Derived3 d;
+ return d;
+ }
+
+ // Return by value (sliced objects)
+ CBase1 MakeValDerived1_CBase1() {
+ return Derived1();
+ }
+ CBase2 MakeValDerived1_CBase2() {
+ return Derived1();
+ }
+ CBase1 MakeValDerived2_CBase1() {
+ return Derived2();
+ }
+ CBase1 MakeValDerived3_CBase1() {
+ return Derived3();
+ }
+ CBase2 MakeValDerived3_CBase2() {
+ return Derived3();
+ }
+}
+
+%}
+
--- /dev/null
+// This is a copy of the multiple_inheritance_abstract test and extended for testing %shared_ptr and %interface_impl
+%module multiple_inheritance_shared_ptr
+
+%warnfilter(SWIGWARN_RUBY_MULTIPLE_INHERITANCE,
+ SWIGWARN_D_MULTIPLE_INHERITANCE,
+ SWIGWARN_PHP_MULTIPLE_INHERITANCE); /* languages not supporting multiple inheritance or %interface */
+
+// Typemap changes required to mix %shared_ptr and %interface_impl
+// Note we don't have a way to use $javainterfacename/$csinterfacename (yet),
+// so we improvise somewhat by adding the SwigImpl suffix
+%define SWIG_SHARED_PTR_INTERFACE_TYPEMAPS(CONST, TYPE...)
+#if defined(SWIGJAVA)
+%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 > *& "($javainput == null) ? 0 : $javainput.$typemap(jstype, TYPE)_GetInterfaceCPtr()"
+%typemap(javaout) 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 cPtr = $jnicall;
+ return (cPtr == 0) ? null : ($typemap(jstype, TYPE))new $typemap(jstype, TYPE)SwigImpl(cPtr, true);
+ }
+#elif defined(SWIGCSHARP)
+%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 > *& "$csinput == null ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : $csinput.GetInterfaceCPtr()"
+%typemap(csout, excode=SWIGEXCODE) 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.IntPtr cPtr = $imcall;
+ $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)SwigImpl(cPtr, true);$excode
+ return ret;
+ }
+#endif
+%enddef
+
+#if defined(SWIGJAVA) || defined(SWIGCSHARP)
+%include <boost_shared_ptr.i>
+%shared_ptr(Space::ABase1)
+%shared_ptr(Space::CBase1)
+%shared_ptr(Space::CBase2)
+%shared_ptr(Space::Derived1)
+%shared_ptr(Space::Derived2)
+%shared_ptr(Space::Derived3)
+%shared_ptr(Space::Bottom1)
+%shared_ptr(Space::Bottom2)
+%shared_ptr(Space::Bottom3)
+
+%include "swiginterface.i"
+SWIG_SHARED_PTR_INTERFACE_TYPEMAPS(SWIGEMPTYHACK, Space::ABase1)
+SWIG_SHARED_PTR_INTERFACE_TYPEMAPS(SWIGEMPTYHACK, Space::CBase1)
+SWIG_SHARED_PTR_INTERFACE_TYPEMAPS(SWIGEMPTYHACK, Space::CBase2)
+%interface_impl(Space::ABase1)
+%interface_impl(Space::CBase1)
+%interface_impl(Space::CBase2)
+#endif
+
+#if defined(SWIGD)
+// Missing multiple inheritance support results in incorrect use of override
+%ignore CBase1;
+%ignore CBase2;
+#endif
+
+%inline %{
+#include <boost/shared_ptr.hpp>
+
+namespace Space {
+ struct CBase1 {
+ virtual void cbase1x() {
+ return;
+ }
+ virtual int cbase1y() {
+ return 1;
+ }
+ int cbase1z() {
+ return 10;
+ }
+ virtual ~CBase1() {
+ }
+ };
+
+ struct CBase2 {
+ virtual int cbase2() {
+ return 2;
+ }
+ virtual ~CBase2() {
+ }
+ };
+
+ struct ABase1 {
+ virtual int abase1() = 0;
+ virtual ~ABase1() {
+ }
+ };
+
+ struct Derived1 : CBase2, CBase1 {
+ virtual void cbase1x() {
+ return;
+ }
+ virtual int cbase1y() {
+ return 3;
+ }
+ virtual int cbase2() {
+ return 4;
+ }
+ virtual CBase2 *cloneit() {
+ return new Derived1(*this);
+ }
+ void derived1() {
+ }
+ };
+
+ struct Derived2 : CBase1, ABase1 {
+ virtual void cbase1x() {
+ return;
+ }
+ virtual int cbase1y() {
+ return 6;
+ }
+ virtual int abase1() {
+ return 5;
+ }
+ virtual CBase1 *cloneit() {
+ return new Derived2(*this);
+ }
+ void derived2() {
+ }
+ };
+
+ struct Derived3 : ABase1, CBase1, CBase2 {
+ virtual int cbase1y() {
+ return 7;
+ }
+ virtual int cbase2() {
+ return 8;
+ }
+ virtual int abase1() {
+ return 9;
+ }
+ virtual void cbase1x() {
+ }
+ virtual ABase1 *cloneit() {
+ return new Derived3(*this);
+ }
+ void derived3() {
+ }
+ };
+
+ struct Bottom1 : Derived1 {
+ virtual void cbase1x() {
+ return;
+ }
+ virtual int cbase1y() {
+ return 103;
+ }
+ virtual int cbase2() {
+ return 104;
+ }
+ };
+
+ struct Bottom2 : Derived2 {
+ virtual int cbase1y() {
+ return 206;
+ }
+ virtual int abase1() {
+ return 205;
+ }
+ };
+
+ struct Bottom3 : Derived3 {
+ virtual int cbase1y() {
+ return 307;
+ }
+ virtual int cbase2() {
+ return 308;
+ }
+ virtual int abase1() {
+ return 309;
+ }
+ };
+
+ typedef boost::shared_ptr<ABase1> ABase1_SharedPtr;
+ typedef boost::shared_ptr<CBase1> CBase1_SharedPtr;
+ typedef boost::shared_ptr<CBase2> CBase2_SharedPtr;
+ typedef boost::shared_ptr<Derived1> Derived1_SharedPtr;
+ typedef boost::shared_ptr<Derived2> Derived2_SharedPtr;
+ typedef boost::shared_ptr<Derived3> Derived3_SharedPtr;
+ typedef boost::shared_ptr<Bottom1> Bottom1_SharedPtr;
+ typedef boost::shared_ptr<Bottom2> Bottom2_SharedPtr;
+ typedef boost::shared_ptr<Bottom3> Bottom3_SharedPtr;
+
+ // Base classes as input
+ int InputValCBase1(CBase1 cb1) {
+ return cb1.cbase1y();
+ }
+ int InputValCBase2(CBase2 cb2) {
+ return cb2.cbase2();
+ }
+
+ int InputPtrABase1(ABase1 *pab1) {
+ return pab1->abase1();
+ }
+ int InputPtrCBase1(CBase1 *pcb1) {
+ return pcb1->cbase1y();
+ }
+ int InputPtrCBase2(CBase2 *pcb2) {
+ return pcb2->cbase2();
+ }
+
+ int InputRefABase1(ABase1 &rab1) {
+ return rab1.abase1();
+ }
+ int InputRefCBase1(CBase1 &rcb1) {
+ return rcb1.cbase1y();
+ }
+ int InputRefCBase2(CBase2 &rcb2) {
+ return rcb2.cbase2();
+ }
+
+ int InputCPtrRefABase1(ABase1 *const& pab1) {
+ return pab1->abase1();
+ }
+ int InputCPtrRefCBase1(CBase1 *const& pcb1) {
+ return pcb1->cbase1y();
+ }
+ int InputCPtrRefCBase2(CBase2 *const& pcb2) {
+ return pcb2->cbase2();
+ }
+
+ int InputSharedPtrABase1(ABase1_SharedPtr pab1) {
+ return pab1->abase1();
+ }
+ int InputSharedPtrCBase1(CBase1_SharedPtr pcb1) {
+ return pcb1->cbase1y();
+ }
+ int InputSharedPtrCBase2(CBase2_SharedPtr pcb2) {
+ return pcb2->cbase2();
+ }
+
+ int InputSharedPtrRefABase1(ABase1_SharedPtr &pab1) {
+ return pab1->abase1();
+ }
+ int InputSharedPtrRefCBase1(CBase1_SharedPtr &pcb1) {
+ return pcb1->cbase1y();
+ }
+ int InputSharedPtrRefCBase2(CBase2_SharedPtr &pcb2) {
+ return pcb2->cbase2();
+ }
+
+ // Derived classes as input
+ int InputValDerived1(Derived1 d) {
+ return d.cbase1y() + d.cbase2();
+ }
+ int InputValDerived2(Derived2 d) {
+ return d.cbase1y() + d.abase1();
+ }
+ int InputValDerived3(Derived3 d) {
+ return d.cbase1y() + d.cbase2() + d.abase1();
+ }
+
+ int InputRefDerived1(Derived1 &d) {
+ return d.cbase1y() + d.cbase2();
+ }
+ int InputRefDerived2(Derived2 &d) {
+ return d.cbase1y() + d.abase1();
+ }
+ int InputRefDerived3(Derived3 &d) {
+ return d.cbase1y() + d.cbase2() + d.abase1();
+ }
+
+ int InputPtrDerived1(Derived1 *d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputPtrDerived2(Derived2 *d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputPtrDerived3(Derived3 *d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ int InputCPtrRefDerived1(Derived1 *const& d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputCPtrRefDerived2(Derived2 *const& d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputCPtrRefDerived3(Derived3 *const& d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ int InputSharedPtrDerived1(Derived1_SharedPtr d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputSharedPtrDerived2(Derived2_SharedPtr d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputSharedPtrDerived3(Derived3_SharedPtr d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ int InputSharedPtrRefDerived1(Derived1_SharedPtr &d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputSharedPtrRefDerived2(Derived2_SharedPtr &d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputSharedPtrRefDerived3(Derived3_SharedPtr &d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ // Bottom classes as input
+ int InputValBottom1(Bottom1 d) {
+ return d.cbase1y() + d.cbase2();
+ }
+ int InputValBottom2(Bottom2 d) {
+ return d.cbase1y() + d.abase1();
+ }
+ int InputValBottom3(Bottom3 d) {
+ return d.cbase1y() + d.cbase2() + d.abase1();
+ }
+
+ int InputRefBottom1(Bottom1 &d) {
+ return d.cbase1y() + d.cbase2();
+ }
+ int InputRefBottom2(Bottom2 &d) {
+ return d.cbase1y() + d.abase1();
+ }
+ int InputRefBottom3(Bottom3 &d) {
+ return d.cbase1y() + d.cbase2() + d.abase1();
+ }
+
+ int InputPtrBottom1(Bottom1 *d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputPtrBottom2(Bottom2 *d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputPtrBottom3(Bottom3 *d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ int InputCPtrRefBottom1(Bottom1 *const& d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputCPtrRefBottom2(Bottom2 *const& d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputCPtrRefBottom3(Bottom3 *const& d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ int InputSharedPtrBottom1(Bottom1_SharedPtr d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputSharedPtrBottom2(Bottom2_SharedPtr d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputSharedPtrBottom3(Bottom3_SharedPtr d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ int InputSharedPtrRefBottom1(Bottom1_SharedPtr &d) {
+ return d->cbase1y() + d->cbase2();
+ }
+ int InputSharedPtrRefBottom2(Bottom2_SharedPtr &d) {
+ return d->cbase1y() + d->abase1();
+ }
+ int InputSharedPtrRefBottom3(Bottom3_SharedPtr &d) {
+ return d->cbase1y() + d->cbase2() + d->abase1();
+ }
+
+ // Return pointers
+ CBase1 *MakePtrDerived1_CBase1() {
+ return new Derived1();
+ }
+ CBase2 *MakePtrDerived1_CBase2() {
+ return new Derived1();
+ }
+ CBase1 *MakePtrDerived2_CBase1() {
+ return new Derived2();
+ }
+ ABase1 *MakePtrDerived2_ABase1() {
+ return new Derived2();
+ }
+ ABase1 *MakePtrDerived3_ABase1() {
+ return new Derived3();
+ }
+ CBase1 *MakePtrDerived3_CBase1() {
+ return new Derived3();
+ }
+ CBase2 *MakePtrDerived3_CBase2() {
+ return new Derived3();
+ }
+
+ // Return references
+ CBase1 &MakeRefDerived1_CBase1() {
+ static Derived1 d;
+ return d;
+ }
+ CBase2 &MakeRefDerived1_CBase2() {
+ static Derived1 d;
+ return d;
+ }
+ CBase1 &MakeRefDerived2_CBase1() {
+ static Derived2 d;
+ return d;
+ }
+ ABase1 &MakeRefDerived2_ABase1() {
+ static Derived2 d;
+ return d;
+ }
+ ABase1 &MakeRefDerived3_ABase1() {
+ static Derived3 d;
+ return d;
+ }
+ CBase1 &MakeRefDerived3_CBase1() {
+ static Derived3 d;
+ return d;
+ }
+ CBase2 &MakeRefDerived3_CBase2() {
+ static Derived3 d;
+ return d;
+ }
+
+ // Return by value (sliced objects)
+ CBase1 MakeValDerived1_CBase1() {
+ return Derived1();
+ }
+ CBase2 MakeValDerived1_CBase2() {
+ return Derived1();
+ }
+ CBase1 MakeValDerived2_CBase1() {
+ return Derived2();
+ }
+ CBase1 MakeValDerived3_CBase1() {
+ return Derived3();
+ }
+ CBase2 MakeValDerived3_CBase2() {
+ return Derived3();
+ }
+
+ // Return smart pointers
+ CBase1_SharedPtr MakeSharedPtrDerived1_CBase1() {
+ return CBase1_SharedPtr(new Derived1());
+ }
+ CBase2_SharedPtr MakeSharedPtrDerived1_CBase2() {
+ return CBase2_SharedPtr(new Derived1());
+ }
+ CBase1_SharedPtr MakeSharedPtrDerived2_CBase1() {
+ return CBase1_SharedPtr(new Derived2());
+ }
+ ABase1_SharedPtr MakeSharedPtrDerived2_ABase1() {
+ return ABase1_SharedPtr(new Derived2());
+ }
+ ABase1_SharedPtr MakeSharedPtrDerived3_ABase1() {
+ return ABase1_SharedPtr(new Derived3());
+ }
+ CBase1_SharedPtr MakeSharedPtrDerived3_CBase1() {
+ return CBase1_SharedPtr(new Derived3());
+ }
+ CBase2_SharedPtr MakeSharedPtrDerived3_CBase2() {
+ return CBase2_SharedPtr(new Derived3());
+ }
+
+ // Return smart pointer references
+ CBase1_SharedPtr MakeSharedPtrRefDerived1_CBase1() {
+ static CBase1_SharedPtr s(new Derived1());
+ return s;
+ }
+ CBase2_SharedPtr MakeSharedPtrRefDerived1_CBase2() {
+ static CBase2_SharedPtr s(new Derived1());
+ return s;
+ }
+ CBase1_SharedPtr MakeSharedPtrRefDerived2_CBase1() {
+ static CBase1_SharedPtr s(new Derived2());
+ return s;
+ }
+ ABase1_SharedPtr MakeSharedPtrRefDerived2_ABase1() {
+ static ABase1_SharedPtr s(new Derived2());
+ return s;
+ }
+ ABase1_SharedPtr MakeSharedPtrRefDerived3_ABase1() {
+ static ABase1_SharedPtr s(new Derived3());
+ return s;
+ }
+ CBase1_SharedPtr MakeSharedPtrRefDerived3_CBase1() {
+ static CBase1_SharedPtr s(new Derived3());
+ return s;
+ }
+ CBase2_SharedPtr MakeSharedPtrRefDerived3_CBase2() {
+ static CBase2_SharedPtr s(new Derived3());
+ return s;
+ }
+}
+
+%}
LANGUAGE = mzscheme
MZSCHEME = mzscheme
SCRIPTSUFFIX = _runme.scm
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
# none!
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.scm appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(MZSCHEME) -r $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(MZSCHEME) -r $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
# Clean
%.clean:
-
+ @exit 0
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile mzscheme_clean
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' mzscheme_clean
%module namespace_class
+
%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) Ala::Ola;
#ifdef SWIGD
%}
-// %copyctor doesn't work with nested class workaround
-%nocopyctor;
-
%inline %{
class Ala {
public :
};
%}
-%rename(Ala__Ola) Ala::Ola;
-class Ala::Ola {
-public:
- Ola() {}
- void eek() {}
-};
%template(hi) Ala::hi<int>;
#ifdef SWIGGO
%typemap(gotype) string_class * "string"
%typemap(in) string_class * {
- $1 = new string_class($input.p);
+ char* buf = new char[$input.n + 1];
+ memcpy(buf, $input.p, $input.n);
+ buf[$input.n] = '\0';
+ $1 = new string_class(buf);
+ delete[] buf;
}
%typemap(freearg) string_class * {
delete $1;
--- /dev/null
+%module naturalvar_more
+
+// The instantiation of a template using an enum in the template parameter was not picking up %naturalvar.
+
+// These typemaps will be used if %naturalvar is not working
+%typemap(out) T<Space::E> *te, T<Space::E> *const_te "_should_not_use_this_out_typemap_"
+%typemap(varout) T<Space::E> *te, T<Space::E> *const_te "_should_not_use_this_varout_typemap_"
+%typemap(out) Hidden *hidden "_should_not_use_this_out_typemap_"
+%typemap(varout) Hidden *hidden "_should_not_use_this_varout_typemap_"
+
+%naturalvar T<Space::E>;
+%naturalvar Hidden;
+
+%inline %{
+template <typename X> struct T {};
+struct K {};
+struct Hidden;
+namespace Ace {
+ int glob;
+}
+%}
+%{
+struct Hidden {};
+namespace Ace {
+ template<typename> struct NoIdea {};
+}
+%}
+
+%inline %{
+namespace Space {
+ enum E { E1, E2, E3 };
+}
+%}
+
+%template(TE) T<Space::E>;
+
+%include <std_string.i>
+%include <std_vector.i>
+%template(VectorString) std::vector<std::string>;
+
+%inline {
+using namespace Space;
+struct S {
+ T<E> te;
+ const T<E> const_te;
+ const std::vector<std::string>::value_type const_string_member; // check this resolves to std::string which has a naturalvar
+ std::vector<std::string>::value_type string_member; // check this resolves to std::string which has a naturalvar
+ Hidden hidden;
+ Ace::NoIdea<Hidden> noidea;
+ S() : const_te(), const_string_member("initial string value") {}
+};
+}
+
--- /dev/null
+%module naturalvar_onoff
+
+// Test naturalvar feature override is working -
+// naturalvar on the variable name has priority over naturalvar on the variable's type
+// Use runtime tests to differentiate between the const ref typemaps and pointer typemap -
+// using the fact that NULL cannot be passed to the ref typemaps
+
+%naturalvar Member1;
+%nonaturalvar Member2;
+%naturalvar Member3;
+%nonaturalvar Vars::member3Off;
+%nonaturalvar Member4;
+%naturalvar Vars::member4On;
+
+%inline %{
+struct Member1 {};
+struct Member2 {};
+struct Member3 {};
+struct Member4 {};
+
+struct Vars {
+ Member1 member1On;
+ Member2 member2Off;
+ Member3 member3Off;
+ Member3 member3On;
+ Member4 member4Off;
+ Member4 member4On;
+};
+%}
-/*
+/*
This testcase tests that nested structs/unions work. Named structs/unions declared within
a struct produced redefinition errors in SWIG 1.3.6 as reported by SF bug #447488.
Also tests reported error when a #define placed in a deeply embedded struct/union.
%module nested
+
+#if defined(SWIGSCILAB)
+%rename(OutStNamed) OuterStructNamed;
+%rename(InStNamed) OuterStructNamed::InnerStructNamed;
+%rename(InUnNamed) OuterStructNamed::Inner_union_named;
+#endif
+
%inline %{
struct TestStruct {
} inner_union_named;
};
+%}
+
+
+#if !defined(SWIGSCILAB)
+
+%inline %{
+
struct OuterStructUnnamed {
struct {
double xx;
} inner_union_unnamed;
};
-
typedef struct OuterStruct {
union {
} OuterStruct;
%}
+
+#else
+
+%inline %{
+
+struct OutStUnnamed {
+ struct {
+ double xx;
+ } inSt;
+ union {
+ double yy;
+ int zz;
+ } inUn;
+};
+
+typedef struct OutSt {
+ union {
+
+ struct nst_st {
+ union in_un {
+#define BAD_STYLE 1
+ int red;
+ struct TestStruct green;
+ } InUn;
+
+ struct in_st {
+ int blue;
+ } InSt;
+ } NstdSt;
+
+ } EmbedUn;
+} OutSt;
+
+%}
+
+#endif
+
+
%module nested_class
+
+#if defined(SWIGSCILAB)
+%rename(Out) Outer;
+%rename(InSt1) InnerStruct1;
+%rename(InCls1) InnerClass1;
+%rename(InCls2) InnerClass2;
+%rename(InClas3Inst) InnerClass3Instance;
+%rename(InSt3Inst) InnerStruct3Instance;
+%rename(InCls4Type) InnerClass4Typedef;
+%rename(InSt4Type) InnerStruct4Typedef;
+%rename(InCls5Type) InnerClass5Typedef;
+%rename(InSt5Type) InnerStruct5Typedef;
+%rename(InMul) InnerMultiple;
+%rename(InMulDrv) InnerMultipleDerived;
+%rename(MulInst1) MultipleInstance1;
+%rename(MulInst2) MultipleInstance2;
+%rename(MulInst3) MultipleInstance3;
+%rename(MulInst4) MultipleInstance4;
+%rename(MulDrvInst1) MultipleDerivedInstance1;
+%rename(MulDrvInst2) MultipleDerivedInstance2;
+%rename(MulDrvInst3) MultipleDerivedInstance3;
+%rename(MulDrvInst4) MultipleDerivedInstance4;
+%rename(MulInstAnnDrv1) MultipleInstanceAnonDerived1;
+%rename(MulInstAnnDrv2) MultipleInstanceAnonDerived2;
+%rename(MulInstAnnDrv3) MultipleInstanceAnonDerived3;
+%rename(MulInstAnnDrv4) MultipleInstanceAnonDerived4;
+#endif
+
#pragma SWIG nowarn=SWIGWARN_PARSE_UNNAMED_NESTED_CLASS
%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) Outer::InnerStruct1;
%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) Outer::InnerClass1;
%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) Outer2::IgnoreMe;
%inline %{
+
+#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+/* ISO C++ prohibits anonymous structs [-Werror=pedantic] */
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+
+namespace bar {
+ int foo() { return 0; }
+}
+
struct Outer {
typedef int Integer;
///////////////////////////////////////////
};
///////////////////////////////////////////
-#ifdef SWIG
+#if defined(__GNUC__) || defined(_MSC_VER) || defined(SWIG)
/* some compilers do not accept these */
class {
public:
struct {
Integer b;
};
+#else
+ Integer a;
+ Integer b;
#endif
union {
Integer x;
} InnerClass4Typedef;
+#ifdef _MSC_VER
+ int Outer::foo(){ return 1; } // should correctly ignore qualification here (#508)
+#endif
+
typedef struct {
Integer x;
} InnerStruct4Typedef;
+ friend int bar::foo(); // should parse correctly (#508)
+
typedef union {
Integer x;
double y;
Integer xx;
} MultipleInstanceAnonDerived1, MultipleInstanceAnonDerived2, *MultipleInstanceAnonDerived3, MultipleInstanceAnonDerived4[2];
-#ifdef SWIG
+#if defined(__GNUC__) || defined(_MSC_VER) || defined(SWIG)
/* some compilers do not accept these */
struct : public InnerMultiple {
Integer xx;
public:
Integer yy;
};
+#else
+ Integer xx;
+ Integer yy;
#endif
///////////////////////////////////////////
///////////////////////////////////////////
typedef struct InnerSameName {
Integer x;
+ struct InnerSameName2 {};
} InnerSameName;
InnerSameName* makeInnerSameName() { return 0; }
};
+#if defined(SWIGCSHARP) || defined (SWIGJAVA)
+// place a class with the same name as in Outer in global scope, to test language symbol table
+class InnerSameName {};
+class InnerSameName2 {};
+#endif
%}
// Ignore nested struct instance
--- /dev/null
+%module(directors="1", allprotected="1") nested_directors
+
+%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) NN::Base::Nest;
+%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) NN::Sub::IListener;
+
+%feature("director") Base;
+%feature("director") Sub;
+%feature("director") Base::Nest;
+
+%inline %{
+namespace NN {
+class Base {
+public:
+ virtual ~Base(){}
+ class Nest {
+ public:
+ virtual ~Nest(){}
+ virtual bool GetValue(){ return false; }
+ };
+protected:
+ virtual bool DoNothing() = 0;
+};
+
+class Sub : public Base {
+public:
+ class IListener {
+ };
+public:
+ virtual ~Sub(){}
+protected:
+ void DoSomething(){}
+ virtual bool GetValue() const { return true; }
+};
+}
+%}
--- /dev/null
+%module nested_extend_c
+
+#if !defined(SWIGOCTAVE) && !defined(SWIG_JAVASCRIPT_V8)
+%extend hiA {
+ hiA() {
+ union hiA *self = (union hiA *)malloc(sizeof(union hiA));
+ self->c = 'h';
+ return self;
+ }
+ char hi_extend() {
+ return $self->c;
+ }
+ static const long swig_size = sizeof(union hiA);
+}
+%extend lowA {
+ lowA() {
+ struct lowA *self = (struct lowA *)malloc(sizeof(struct lowA));
+ self->name = 0;
+ self->num = 99;
+ return self;
+ }
+ int low_extend() {
+ return $self->num;
+ }
+ static const long swig_size = sizeof(struct lowA);
+}
+
+%extend hiB {
+ hiB() {
+ union hiB *self = (union hiB *)malloc(sizeof(union hiB));
+ self->c = 'h';
+ return self;
+ }
+ char hi_extend() {
+ return $self->c;
+ }
+ static const long swig_size = sizeof(union hiB);
+}
+%extend lowB {
+ lowB() {
+ struct lowB *self = (struct lowB *)malloc(sizeof(struct lowB));
+ self->name = 0;
+ self->num = 99;
+ return self;
+ }
+ int low_extend() {
+ return $self->num;
+ }
+ static const long swig_size = sizeof(struct lowB);
+}
+
+%extend FOO_bar {
+ void bar_extend() {
+ $self->d = 1;
+ }
+};
+%extend NestedA {
+ static const long swig_size = sizeof(struct NestedA);
+}
+
+#endif
+
+%inline %{
+typedef struct NestedA {
+ int a;
+ union hiA {
+ char c;
+ int d;
+ } hiA_instance;
+
+ struct lowA {
+ char *name;
+ int num;
+ } lowA_instance;
+} NestedA;
+
+typedef struct {
+ int a;
+ union hiB {
+ char c;
+ int d;
+ } hiB_instance;
+
+ struct lowB {
+ char *name;
+ int num;
+ } lowB_instance;
+} NestedB;
+
+typedef struct {
+ int a;
+ union {
+ char c;
+ int d;
+ } bar;
+} FOO;
+
+static struct {
+ int i;
+} THING;
+
+int useThing() {
+ return THING.i;
+}
+%}
+
--- /dev/null
+%module nested_private
+
+// segfault due to private nested class usage
+
+%inline %{
+#include <string>
+class MotorCar {
+
+ struct DesignOpinion {
+ std::string reason;
+ };
+
+public:
+ struct WindScreen {
+ WindScreen(bool opaque) : opaque(opaque) {}
+ DesignOpinion Opinion();
+ private:
+ bool opaque;
+ };
+
+ std::string WindScreenOpinion() {
+ return MotorCar::WindScreen(true).Opinion().reason;
+ }
+};
+
+MotorCar::DesignOpinion MotorCar::WindScreen::Opinion() {
+ DesignOpinion opinion;
+ opinion.reason = !opaque ? "great design" : "you can't see out the windscreen";
+ return opinion;
+}
+
+%}
--- /dev/null
+%module nested_scope
+
+#if !defined(SWIGCSHARP) && !defined(SWIGJAVA)
+%feature ("flatnested");
+#endif
+
+%inline %{
+namespace ns {
+ // "global" is a case-insensitive keyword in PHP.
+ struct Global_ {
+#ifdef __clang__
+ struct Outer {
+ struct Nested;
+ struct Nested {
+ int data;
+ };
+ };
+ struct Outer::Nested instance;
+#else
+ struct Outer {
+ struct Nested;
+ };
+ struct Outer::Nested {
+ int data;
+ } instance;
+#endif
+ };
+}
+ class Outer1 {
+ struct Nested1;
+ public:
+ struct Nested2;
+#ifdef __clang__
+ struct Nested2 {
+ int data;
+ };
+#endif
+ template <class T> class AbstractClass;
+ class Real;
+ };
+#ifndef __clang__
+ struct Outer1::Nested2 {
+ int data;
+ };
+#endif
+
+ class Klass {
+ public:
+ template <class T> class AbstractClass;
+ class Real;
+ };
+
+ template <class T> class Klass::AbstractClass {
+ public:
+ virtual void Method() = 0;
+ virtual ~AbstractClass() {}
+ };
+%}
+
+%template(abstract_int) Klass::AbstractClass <int>;
+
+%inline %{
+ class Klass::Real : public AbstractClass <int> {
+ public:
+ virtual void Method() {}
+ };
+%}
struct Outer {
struct {
int val;
- } inner1, inner2, *inner3, inner4[1];
+ } inner1, inner2, *inner3, inner4[1], **inner5;
struct Named {
int val;
- } inside1, inside2, *inside3, inside4[1];
+ } inside1, inside2, *inside3, inside4[1], **inside5;
} outer;
void setValues(struct Outer *outer, int val) {
outer->inner2.val = val * 2;
outer->inner3 = &outer->inner2;
outer->inner4[0].val = val * 4;
+ outer->inner5 = &outer->inner3;
val = val * 10;
outer->inside1.val = val;
outer->inside2.val = val * 2;
outer->inside3 = &outer->inside2;
outer->inside4[0].val = val * 4;
+ outer->inside5 = &outer->inside3;
}
+
+int getInside1Val(struct Outer *n) { return n->inside1.val; }
+%}
+
+/*
+Below was causing problems in Octave as wrappers were compiled as C++.
+Solution requires regenerating the inner struct into
+the global C++ namespace (which is where it is intended to be in C).
+See cparse_cplusplusout / Swig_cparse_cplusplusout in the Source.
+*/
+%inline %{
+int nestedByVal(struct Named s);
+int nestedByPtr(struct Named *s);
+%}
+%{
+int nestedByVal(struct Named s) { return s.val; }
+int nestedByPtr(struct Named *s) { return s->val; }
%}
--- /dev/null
+%module nested_template_base
+
+%inline %{
+ template <class T> class OuterT {
+ public:
+ T outer(T t) { return t; }
+ };
+%}
+
+// The %template goes after OuterT and before OuterC as OuterC::InnerC's base is handled inside OuterC
+%template(OuterTInnerS) OuterT<OuterC::InnerS>;
+
+#if !defined(SWIGCSHARP) && !defined(SWIGJAVA)
+%feature("flatnested") OuterC::InnerS;
+%feature("flatnested") OuterC::InnerC;
+#endif
+
+
+%inline %{
+ class OuterC {
+ public:
+ struct InnerS;
+ class InnerC;
+ };
+
+ struct OuterC::InnerS {
+ int val;
+ InnerS(int val = 0) : val(val) {}
+ };
+
+
+ class OuterC::InnerC : public OuterT<InnerS> {
+ public:
+ OuterT<InnerS>& innerc() {
+ return *this;
+ }
+ };
+%}
%module nested_workaround
-// Similar to "Nested classes" documentation example.
-
-class Inner {
- int val;
- public:
- Inner(int v = 0) : val(v) {}
- void setValue(int v) { val = v; }
- int getValue() const { return val; }
-};
-%nestedworkaround Outer::Inner;
+// "flatnested" emulates deprecated feature "nested_workaround" for the languages not supporting nested classes
+%feature ("flatnested");
%inline %{
class Outer {
}
};
%}
-
-// We've fooled SWIG into thinking that Inner is a global class, so now we need
-// to trick the C++ compiler into understanding this apparent global type.
-%{
-typedef Outer::Inner Inner;
-%}
-
-
%module nspace
// nspace feature only supported by these languages
-#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGD)
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGD) || defined(SWIGLUA) || defined(SWIGJAVASCRIPT)
#if defined(SWIGJAVA)
SWIG_JAVABODY_PROXY(public, public, SWIGTYPE)
%nspace;
%nonspace Outer::Inner2::NoNSpacePlease;
+%nonspace Outer::Inner2::NoNSpacePlease::ReallyNoNSpaceEnum;
%copyctor;
%ignore Outer::Inner2::Color::Color();
const Outer::Inner2::Color& col2c) {}
}; // Color
int Color::staticMemberVariable = 0;
- class NoNSpacePlease {};
+ class NoNSpacePlease {
+ public:
+ enum NoNSpaceEnum { NoNspace1 = 1, NoNspace2 = 10 };
+ enum ReallyNoNSpaceEnum { ReallyNoNspace1 = 1, ReallyNoNspace2 = 10 };
+ static int noNspaceStaticFunc() { return 10; }
+ };
} // Inner2
// Derived class
%}
#else
-#warning nspace feature not yet supported in this target language
+//#warning nspace feature not yet supported in this target language
#endif
%module nspace_extend
// nspace feature only supported by these languages
-#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGD)
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGD) || defined(SWIGLUA) || defined(SWIGJAVASCRIPT)
#if defined(SWIGJAVA)
SWIG_JAVABODY_PROXY(public, public, SWIGTYPE)
}
#else
-#warning nspace feature not yet supported in this target language
+//#warning nspace feature not yet supported in this target language
#endif
#######################################################################
LANGUAGE = ocaml
-OCAMLC = ocamlc
+OCAMLC = @OCAMLC@
VARIANT = _static
SCRIPTSUFFIX = _runme.ml
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
-C_TEST_CASES =
+C_TEST_CASES =
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) -a \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) -a \
-f $(top_srcdir)/Examples/test-suite/$*.list ] ; then \
- $(COMPILETOOL) $(OCAMLC) -c $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ $(COMPILETOOL) $(OCAMLC) -c $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
$(COMPILETOOL) $(OCAMLC) swig.cmo -custom -g -cc '$(CXX)' -o runme `cat $(top_srcdir)/Examples/test-suite/$(*).list | sed -e 's/\(.*\)/\1_wrap.o \1.cmo/g'`&& $(RUNTOOL) ./runme; \
- elif [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- $(COMPILETOOL) $(OCAMLC) -c $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ elif [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ $(COMPILETOOL) $(OCAMLC) -c $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
$(COMPILETOOL) $(OCAMLC) swig.cmo -custom -g -cc '$(CXX)' -o runme $(srcdir)/$(*).cmo $(srcdir)/$(*)_runme.cmo $(srcdir)/$(*)_wrap.o && \
$(RUNTOOL) ./runme; \
- fi ;
+ fi ;
check_quant:
- cat /dev/null > testing
- cat /dev/null > success
- cat /dev/null > results
+ : > testing
+ : > success
$(MAKE) check
- echo "Failed:" >> results
- for element in `cat testing` ; do \
- if grep $$element success >/dev/null 2>/dev/null ; then \
- : ; \
- else \
- echo $$element >> results ; \
- fi ; \
- done
+ echo "Failed:" > results
+ diff testing success | sed 's/^< //p;d' >> results
echo "Success:" >> results
cat success >> results
@rm -f $*.ml $*.mli;
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile ocaml_clean
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' ocaml_clean
LANGUAGE = octave
OCTAVE = @OCTAVE@
SCRIPTSUFFIX = _runme.m
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
li_std_set \
li_std_stream
-#C_TEST_CASES +=
+#C_TEST_CASES +=
#
# This test only works with modern C compilers
# none!
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.m appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH OCTAVE_PATH=$(srcdir):$$OCTAVE_PATH $(RUNTOOL) $(OCTAVE) $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH OCTAVE_PATH=$(srcdir):$$OCTAVE_PATH $(RUNTOOL) $(OCTAVE) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
# Clean: remove the generated .m file
@rm -f $*.m;
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile octave_clean
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' octave_clean
cvsignore:
@echo '*wrap* *.mc *.so *.dll *.exp *.lib'
@echo Makefile
- @for i in ${CPP_TEST_CASES} ${C_TEST_CASES}; do echo $$i.m; done
- @for i in ${CPP_TEST_CASES} ${C_TEST_CASES}; do if grep -q $${i}_runme.m CVS/Entries ; then echo $${i}_runme.m; fi; done
- @echo clientdata_prop_a.m
- @echo clientdata_prop_b.m
- @echo imports_a.m
- @echo imports_b.m
- @echo mod_a.m mod_b.m
+ @for i in ${CPP_TEST_CASES} ${C_TEST_CASES}; do echo $$i.m; done
+ @for i in ${CPP_TEST_CASES} ${C_TEST_CASES}; do if grep -q $${i}_runme.m CVS/Entries ; then echo $${i}_runme.m; fi; done
+ @echo clientdata_prop_a.m
+ @echo clientdata_prop_b.m
+ @echo imports_a.m
+ @echo imports_b.m
+ @echo mod_a.m mod_b.m
@echo hugemod.h hugemod_a.i hugemod_b.i hugemod_a.m hugemod_b.m hugemod_runme.m
@echo template_typedef_import.m
--- /dev/null
+cpp11_strongly_typed_enumerations
+
+function newvalue = enumCheck(actual, expected)
+ if (actual != expected);
+ error("Enum value mismatch. Expected: %d Actual: %d", expected, actual);
+ endif
+ newvalue = expected + 1;
+end
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val3, 13);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val5a, 13);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum1_Val6a, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val3, 23);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val5b, 23);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum2_Val6b, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Val3, 43);
+val = enumCheck(cpp11_strongly_typed_enumerations.Val4, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum5_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum5_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum5_Val3, 53);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum5_Val4, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum6_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum6_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum6_Val3, 63);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum6_Val4, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum7td_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum7td_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum7td_Val3, 73);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum7td_Val4, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum8_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum8_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum8_Val3, 83);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum8_Val4, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum10_Val1, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum10_Val2, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum10_Val3, 103);
+val = enumCheck(cpp11_strongly_typed_enumerations.Enum10_Val4, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Enum12_Val1, 1121);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Enum12_Val2, 1122);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Enum12_Val3, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Enum12_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Enum12_Val5c, 1121);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Enum12_Val6c, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Val1, 1131);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Val2, 1132);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Val3, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Val5d, 1131);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Val6d, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Enum14_Val1, 1141);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Enum14_Val2, 1142);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Enum14_Val3, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Enum14_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Enum14_Val5e, 1141);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Enum14_Val6e, val);
+
+# Requires nested class support to work
+#val = 0;
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Enum12_Val1, 3121);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Enum12_Val2, 3122);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Enum12_Val3, val);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Enum12_Val4, val);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Enum12_Val5f, 3121);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Enum12_Val6f, val);
+#
+#val = 0;
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Val1, 3131);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Val2, 3132);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Val3, val);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Val4, val);
+#
+#val = 0;
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Enum14_Val1, 3141);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Enum14_Val2, 3142);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Enum14_Val3, val);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Enum14_Val4, val);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Enum14_Val5g, 3141);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class1_Struct1.Enum14_Val6g, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Enum12_Val1, 2121);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Enum12_Val2, 2122);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Enum12_Val3, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Enum12_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Enum12_Val5h, 2121);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Enum12_Val6h, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Val1, 2131);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Val2, 2132);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Val3, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Val5i, 2131);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Val6i, val);
+
+val = 0;
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Enum14_Val1, 2141);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Enum14_Val2, 2142);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Enum14_Val3, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Enum14_Val4, val);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Enum14_Val5j, 2141);
+val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Enum14_Val6j, val);
+
+# Requires nested class support to work
+#val = 0;
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Enum12_Val1, 4121);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Enum12_Val2, 4122);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Enum12_Val3, val);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Enum12_Val4, val);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Enum12_Val5k, 4121);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Enum12_Val6k, val);
+#
+#val = 0;
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Val1, 4131);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Val2, 4132);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Val3, val);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Val4, val);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Val5l, 4131);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Val6l, val);
+#
+#val = 0;
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Enum14_Val1, 4141);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Enum14_Val2, 4142);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Enum14_Val3, val);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Enum14_Val4, val);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Enum14_Val5m, 4141);
+#val = enumCheck(cpp11_strongly_typed_enumerations.Class2_Struct1_Enum14_Val6m, val);
+
+class1 = Class1();
+enumCheck(class1.class1Test1(cpp11_strongly_typed_enumerations.Enum1_Val5a), 13);
+enumCheck(class1.class1Test2(cpp11_strongly_typed_enumerations.Class1_Enum12_Val5c), 1121);
+#enumCheck(class1.class1Test3(cpp11_strongly_typed_enumerations.Class1_Struct1_Enum12_Val5f), 3121);
+
+enumCheck(cpp11_strongly_typed_enumerations.globalTest1(cpp11_strongly_typed_enumerations.Enum1_Val5a), 13);
+enumCheck(cpp11_strongly_typed_enumerations.globalTest2(cpp11_strongly_typed_enumerations.Class1_Enum12_Val5c), 1121);
+#enumCheck(globalTest3(cpp11_strongly_typed_enumerations.Class1_Struct1_Enum12_Val5f), 3121);
+
catch
end_try_catch
-del_b = dc.delete_B;
-
try
bb = dc.new_BB();
error("Whoa. new_BB created.")
catch
end_try_catch
-del_bb = dc.delete_BB;
-
try
c = dc.new_C();
error("Whoa. new_C created.")
catch
end_try_catch
-del_c = dc.delete_C;
-
cc = dc.new_CC();
dc.delete_CC(cc);
catch
end_try_catch
-del_d = dc.delete_D;
-
try
dd = dc.new_DD();
error("Whoa. new_DD created")
catch
end_try_catch
-dd = dc.delete_DD;
-
try
ad = dc.new_AD();
error("Whoa. new_AD created")
catch
end_try_catch
-del_ad = dc.delete_AD;
-
e = dc.new_E();
dc.delete_E(e);
catch
end_try_catch
-del_eb = dc.delete_EB;
-
f = dc.new_F();
try
- del_f = dc.delete_F;
+ del_f = dc.delete_F(f);
error("Whoa. delete_F created")
catch
end_try_catch
dc.F_destroy(f);
-ff = dc.new_FFF();
-try
- del_ff = dc.delete_FFF;
- error("Whoa. delete_FFF created")
-catch
-end_try_catch
-
-dc.F_destroy(ff);
-
g = dc.new_G();
try
- del_g = dc.delete_G;
+ del_g = dc.delete_G(g);
error("Whoa. delete_G created")
catch
end_try_catch
director_detect
-global MyBar=@(val=2) \
- subclass(director_detect.Bar(),'val',val,@get_value,@get_class,@just_do_it,@clone);
+global MyBar=@(val=2) subclass(director_detect.Bar(),'val',val,@get_value,@get_class,@just_do_it,@clone);
+
function val=get_value(self)
self.val = self.val + 1;
val = self.val;
--- /dev/null
+1;
+li_boost_shared_ptr;
+
+function verifyValue(expected, got)
+ if (expected ~= got)
+ error("verify value failed.");% Expected: ", expected, " Got: ", got)
+ end
+endfunction
+
+function verifyCount(expected, k)
+ got = use_count(k);
+ if (expected ~= got)
+ error("verify use_count failed. Expected: %d Got: %d ", expected, got);
+ end
+endfunction
+
+function runtest()
+ li_boost_shared_ptr; # KTTODO this needs to be here at present. Global module failure?
+ # simple shared_ptr usage - created in C++
+ k = Klass("me oh my");
+ val = k.getValue();
+ verifyValue("me oh my", val)
+ verifyCount(1, k)
+
+ # simple shared_ptr usage - not created in C++
+ k = factorycreate();
+ val = k.getValue();
+ verifyValue("factorycreate", val)
+ verifyCount(1, k)
+
+ # pass by shared_ptr
+ k = Klass("me oh my");
+ kret = smartpointertest(k);
+ val = kret.getValue();
+ verifyValue("me oh my smartpointertest", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # pass by shared_ptr pointer
+ k = Klass("me oh my");
+ kret = smartpointerpointertest(k);
+ val = kret.getValue();
+ verifyValue("me oh my smartpointerpointertest", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # pass by shared_ptr reference
+ k = Klass("me oh my");
+ kret = smartpointerreftest(k);
+ val = kret.getValue();
+ verifyValue("me oh my smartpointerreftest", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # pass by shared_ptr pointer reference
+ k = Klass("me oh my");
+ kret = smartpointerpointerreftest(k);
+ val = kret.getValue();
+ verifyValue("me oh my smartpointerpointerreftest", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # const pass by shared_ptr
+ k = Klass("me oh my");
+ kret = constsmartpointertest(k);
+ val = kret.getValue();
+ verifyValue("me oh my", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # const pass by shared_ptr pointer
+ k = Klass("me oh my");
+ kret = constsmartpointerpointertest(k);
+ val = kret.getValue();
+ verifyValue("me oh my", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # const pass by shared_ptr reference
+ k = Klass("me oh my");
+ kret = constsmartpointerreftest(k);
+ val = kret.getValue();
+ verifyValue("me oh my", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # pass by value
+ k = Klass("me oh my");
+ kret = valuetest(k);
+ val = kret.getValue();
+ verifyValue("me oh my valuetest", val)
+ verifyCount(1, k)
+ verifyCount(1, kret)
+
+ # pass by pointer
+ k = Klass("me oh my");
+ kret = pointertest(k);
+ val = kret.getValue();
+ verifyValue("me oh my pointertest", val)
+ verifyCount(1, k)
+ verifyCount(1, kret)
+
+ # pass by reference
+ k = Klass("me oh my");
+ kret = reftest(k);
+ val = kret.getValue();
+ verifyValue("me oh my reftest", val)
+ verifyCount(1, k)
+ verifyCount(1, kret)
+
+ # pass by pointer reference
+ k = Klass("me oh my");
+ kret = pointerreftest(k);
+ val = kret.getValue();
+ verifyValue("me oh my pointerreftest", val)
+ verifyCount(1, k)
+ verifyCount(1, kret)
+
+ # null tests
+ #KTODO None not defined
+ # k = None;
+
+ # if (smartpointertest(k) ~= None)
+ # error("return was not null")
+ # end
+
+ # if (smartpointerpointertest(k) ~= None)
+ # error("return was not null")
+ # end
+
+ # if (smartpointerreftest(k) ~= None)
+ # error("return was not null")
+ # end
+
+ # if (smartpointerpointerreftest(k) ~= None)
+ # error("return was not null")
+ # end
+
+ # if (nullsmartpointerpointertest(None) ~= "null pointer")
+ # error("not null smartpointer pointer")
+ # end
+
+ # # try:
+ # # valuetest(k)
+ # # error("Failed to catch null pointer")
+ # # except ValueError:
+ # # pass
+
+ # if (pointertest(k) ~= None)
+ # error("return was not null")
+ # end
+
+ # # try:
+ # # reftest(k)
+ # # error("Failed to catch null pointer")
+ # # except ValueError:
+ # # pass
+
+ # $owner
+ k = pointerownertest();
+ val = k.getValue();
+ verifyValue("pointerownertest", val)
+ verifyCount(1, k)
+ k = smartpointerpointerownertest();
+ val = k.getValue();
+ verifyValue("smartpointerpointerownertest", val)
+ verifyCount(1, k)
+
+ # //////////////////////////////// Derived class ////////////////////////////////////////
+ # derived pass by shared_ptr
+ k = KlassDerived("me oh my");
+ kret = derivedsmartptrtest(k);
+ val = kret.getValue();
+ verifyValue("me oh my derivedsmartptrtest-Derived", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # derived pass by shared_ptr pointer
+ k = KlassDerived("me oh my");
+ kret = derivedsmartptrpointertest(k);
+ val = kret.getValue();
+ verifyValue("me oh my derivedsmartptrpointertest-Derived", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # derived pass by shared_ptr ref
+ k = KlassDerived("me oh my");
+ kret = derivedsmartptrreftest(k);
+ val = kret.getValue();
+ verifyValue("me oh my derivedsmartptrreftest-Derived", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # derived pass by shared_ptr pointer ref
+ k = KlassDerived("me oh my");
+ kret = derivedsmartptrpointerreftest(k);
+ val = kret.getValue();
+ verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # derived pass by pointer
+ k = KlassDerived("me oh my");
+ kret = derivedpointertest(k);
+ val = kret.getValue();
+ verifyValue("me oh my derivedpointertest-Derived", val)
+ verifyCount(1, k)
+ verifyCount(1, kret)
+
+ # derived pass by ref
+ k = KlassDerived("me oh my");
+ kret = derivedreftest(k);
+ val = kret.getValue();
+ verifyValue("me oh my derivedreftest-Derived", val)
+ verifyCount(1, k)
+ verifyCount(1, kret)
+
+ # //////////////////////////////// Derived and base class mixed ////////////////////////////////////////
+ # pass by shared_ptr (mixed)
+ k = KlassDerived("me oh my");
+ kret = smartpointertest(k);
+ val = kret.getValue();
+ verifyValue("me oh my smartpointertest-Derived", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # pass by shared_ptr pointer (mixed)
+ k = KlassDerived("me oh my");
+ kret = smartpointerpointertest(k);
+ val = kret.getValue();
+ verifyValue("me oh my smartpointerpointertest-Derived", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # pass by shared_ptr reference (mixed)
+ k = KlassDerived("me oh my");
+ kret = smartpointerreftest(k);
+ val = kret.getValue();
+ verifyValue("me oh my smartpointerreftest-Derived", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # pass by shared_ptr pointer reference (mixed)
+ k = KlassDerived("me oh my");
+ kret = smartpointerpointerreftest(k);
+ val = kret.getValue();
+ verifyValue("me oh my smartpointerpointerreftest-Derived", val)
+ verifyCount(2, k)
+ verifyCount(2, kret)
+
+ # pass by value (mixed)
+ k = KlassDerived("me oh my");
+ kret = valuetest(k);
+ val = kret.getValue();
+ verifyValue("me oh my valuetest", val) # note slicing
+ verifyCount(1, k)
+ verifyCount(1, kret)
+
+ # pass by pointer (mixed)
+ k = KlassDerived("me oh my");
+ kret = pointertest(k);
+ val = kret.getValue();
+ verifyValue("me oh my pointertest-Derived", val)
+ verifyCount(1, k)
+ verifyCount(1, kret)
+ # pass by ref (mixed)
+ k = KlassDerived("me oh my");
+ kret = reftest(k);
+ val = kret.getValue();
+ verifyValue("me oh my reftest-Derived", val)
+ verifyCount(1, k)
+ verifyCount(1, kret)
+
+ # //////////////////////////////// Overloading tests ////////////////////////////////////////
+ # Base class
+ k = Klass("me oh my");
+ verifyValue(overload_rawbyval(k), "rawbyval")
+ verifyValue(overload_rawbyref(k), "rawbyref")
+ verifyValue(overload_rawbyptr(k), "rawbyptr")
+ verifyValue(overload_rawbyptrref(k), "rawbyptrref")
+
+ verifyValue(overload_smartbyval(k), "smartbyval")
+ verifyValue(overload_smartbyref(k), "smartbyref")
+ verifyValue(overload_smartbyptr(k), "smartbyptr")
+ verifyValue(overload_smartbyptrref(k), "smartbyptrref")
+
+ # Derived class
+ k = KlassDerived("me oh my");
+ verifyValue(overload_rawbyval(k), "rawbyval")
+ verifyValue(overload_rawbyref(k), "rawbyref")
+ verifyValue(overload_rawbyptr(k), "rawbyptr")
+ verifyValue(overload_rawbyptrref(k), "rawbyptrref")
+
+ verifyValue(overload_smartbyval(k), "smartbyval")
+ verifyValue(overload_smartbyref(k), "smartbyref")
+ verifyValue(overload_smartbyptr(k), "smartbyptr")
+ verifyValue(overload_smartbyptrref(k), "smartbyptrref")
+
+ # 3rd derived class
+ k = Klass3rdDerived("me oh my");
+ val = k.getValue();
+ verifyValue("me oh my-3rdDerived", val)
+ verifyCount(1, k)
+
+ val = test3rdupcast(k);
+ verifyValue("me oh my-3rdDerived", val)
+ verifyCount(1, k)
+
+ # //////////////////////////////// Member variables ////////////////////////////////////////
+ # smart pointer by value
+ m = MemberVariables();
+ k = Klass("smart member value");
+ m.SmartMemberValue = k;
+ val = k.getValue();
+ verifyValue("smart member value", val)
+ verifyCount(2, k)
+
+ kmember = m.SmartMemberValue;
+ val = kmember.getValue();
+ verifyValue("smart member value", val)
+ verifyCount(3, kmember)
+ verifyCount(3, k)
+
+ clear m
+ verifyCount(2, kmember)
+ verifyCount(2, k)
+
+ # smart pointer by pointer
+ m = MemberVariables();
+ k = Klass("smart member pointer");
+ m.SmartMemberPointer = k;
+ val = k.getValue();
+ verifyValue("smart member pointer", val)
+ verifyCount(1, k)
+
+ kmember = m.SmartMemberPointer;
+ val = kmember.getValue();
+ verifyValue("smart member pointer", val)
+ verifyCount(2, kmember)
+ verifyCount(2, k)
+
+ clear m
+ verifyCount(2, kmember)
+ verifyCount(2, k)
+
+ # smart pointer by reference
+ m = MemberVariables();
+ k = Klass("smart member reference");
+ m.SmartMemberReference = k;
+ val = k.getValue();
+ verifyValue("smart member reference", val)
+ verifyCount(2, k)
+
+ kmember = m.SmartMemberReference;
+ val = kmember.getValue();
+ verifyValue("smart member reference", val)
+ verifyCount(3, kmember)
+ verifyCount(3, k)
+
+ # The C++ reference refers to SmartMemberValue...
+ kmemberVal = m.SmartMemberValue;
+ val = kmember.getValue();
+ verifyValue("smart member reference", val)
+ verifyCount(4, kmemberVal)
+ verifyCount(4, kmember)
+ verifyCount(4, k)
+
+ clear m
+ verifyCount(3, kmemberVal)
+ verifyCount(3, kmember)
+ verifyCount(3, k)
+
+ # plain by value
+ m = MemberVariables();
+ k = Klass("plain member value");
+ m.MemberValue = k;
+ val = k.getValue();
+ verifyValue("plain member value", val)
+ verifyCount(1, k)
+
+ kmember = m.MemberValue;
+ val = kmember.getValue();
+ verifyValue("plain member value", val)
+ verifyCount(1, kmember)
+ verifyCount(1, k)
+
+ clear m
+ verifyCount(1, kmember)
+ verifyCount(1, k)
+
+ # plain by pointer
+ m = MemberVariables();
+ k = Klass("plain member pointer");
+ m.MemberPointer = k;
+ val = k.getValue();
+ verifyValue("plain member pointer", val)
+ verifyCount(1, k)
+
+ kmember = m.MemberPointer;
+ val = kmember.getValue();
+ verifyValue("plain member pointer", val)
+ verifyCount(1, kmember)
+ verifyCount(1, k)
+
+ clear m
+ verifyCount(1, kmember)
+ verifyCount(1, k)
+
+ # plain by reference
+ m = MemberVariables();
+ k = Klass("plain member reference");
+ m.MemberReference = k;
+ val = k.getValue();
+ verifyValue("plain member reference", val)
+ verifyCount(1, k)
+
+ kmember = m.MemberReference;
+ val = kmember.getValue();
+ verifyValue("plain member reference", val)
+ verifyCount(1, kmember)
+ verifyCount(1, k)
+
+ clear m
+ verifyCount(1, kmember)
+ verifyCount(1, k)
+
+ # null member variables
+ m = MemberVariables();
+
+ # shared_ptr by value
+ k = m.SmartMemberValue;
+ #KTODO None not defined
+ # if (k ~= None)
+ # error("expected null")
+ # end
+
+ # m.SmartMemberValue = None
+ # k = m.SmartMemberValue
+ # if (k ~= None)
+ # error("expected null")
+ # end
+ # verifyCount(0, k)
+
+ # # plain by value
+ # # try:
+ # # m.MemberValue = None
+ # # error("Failed to catch null pointer")
+ # # except ValueError:
+ # # pass
+
+ # # ////////////////////////////////// Global variables ////////////////////////////////////////
+ # # smart pointer
+ # kglobal = cvar.GlobalSmartValue
+ # if (kglobal ~= None)
+ # error("expected null")
+ # end
+
+ k = Klass("smart global value");
+ cvar.GlobalSmartValue = k;
+ verifyCount(2, k)
+
+ kglobal = cvar.GlobalSmartValue;
+ val = kglobal.getValue();
+ verifyValue("smart global value", val)
+ verifyCount(3, kglobal)
+ verifyCount(3, k)
+ verifyValue("smart global value", cvar.GlobalSmartValue.getValue())
+ #KTTODO cvar.GlobalSmartValue = None
+
+ # plain value
+ k = Klass("global value");
+ cvar.GlobalValue = k;
+ verifyCount(1, k)
+
+ kglobal = cvar.GlobalValue;
+ val = kglobal.getValue();
+ verifyValue("global value", val)
+ verifyCount(1, kglobal)
+ verifyCount(1, k)
+ verifyValue("global value", cvar.GlobalValue.getValue())
+
+ # try:
+ # cvar.GlobalValue = None
+ # error("Failed to catch null pointer")
+ # except ValueError:
+ # pass
+
+ # plain pointer
+ kglobal = cvar.GlobalPointer;
+ #KTODO if (kglobal ~= None)
+ #KTODO error("expected null")
+ #KTODO end
+
+ k = Klass("global pointer");
+ cvar.GlobalPointer = k;
+ verifyCount(1, k)
+
+ kglobal = cvar.GlobalPointer;
+ val = kglobal.getValue();
+ verifyValue("global pointer", val)
+ verifyCount(1, kglobal)
+ verifyCount(1, k)
+ #KTODO cvar.GlobalPointer = None
+
+ # plain reference
+ k = Klass("global reference");
+ cvar.GlobalReference = k;
+ verifyCount(1, k)
+
+ kglobal = cvar.GlobalReference;
+ val = kglobal.getValue();
+ verifyValue("global reference", val)
+ verifyCount(1, kglobal)
+ verifyCount(1, k)
+
+ # try:
+ # cvar.GlobalReference = None
+ # error("Failed to catch null pointer")
+ # except ValueError:
+ # pass
+
+ # ////////////////////////////////// Templates ////////////////////////////////////////
+ pid = PairIntDouble(10, 20.2);
+ if (pid.baseVal1 ~= 20 || pid.baseVal2 ~= 40.4)
+ error("Base values wrong")
+ end
+ if (pid.val1 ~= 10 || pid.val2 ~= 20.2)
+ error("Derived Values wrong")
+ end
+
+endfunction
+
+debug = false;%true;
+
+ if (debug)
+ fprintf( "Started\n" )
+ end
+
+ cvar.debug_shared = debug;
+
+ # Change loop count to run for a long time to monitor memory
+ loopCount = 1; #5000
+ for i=0:loopCount
+ runtest()
+ end
+
+ # Expect 1 instance - the one global variable (GlobalValue)
+ #KTTODO next fails, possibly because we commented GlobalSmartValue=None
+ #if (Klass.getTotal_count() ~= 1)
+ # error("Klass.total_count=%d", Klass.getTotal_count())
+ #end
+
+ wrapper_count = shared_ptr_wrapper_count() ;
+ #KTTODO next fails as NOT_COUNTING not in octave name space, so we hard-wire it here
+ #if (wrapper_count ~= NOT_COUNTING)
+ if (wrapper_count ~= -123456)
+ # Expect 1 instance - the one global variable (GlobalSmartValue)
+ if (wrapper_count ~= 1)
+ error("shared_ptr wrapper count=%s", wrapper_count)
+ end
+ end
+
+ if (debug)
+ fprintf( "Finished\n" )
+ end
--- /dev/null
+li_carrays_cpp
+
+d = doubleArray(10);
+
+d(0) = 7;
+d(5) = d(0) + 3;
+
+if (d(5) + d(0) != 17)
+ error
+endif
--- /dev/null
+li_cpointer_cpp
+
+
+p = new_intp();
+intp_assign(p,3);
+
+if (intp_value(p) != 3)
+ error
+endif
+
+delete_intp(p);
+
--- /dev/null
+nested_structs
+
+named = nested_structs.Named();
+named.val = 999;
+assert(nested_structs.nestedByVal(named), 999);
+assert(nested_structs.nestedByPtr(named), 999);
+
+outer = nested_structs.Outer();
+outer.inside1.val = 456;
+assert(nested_structs.getInside1Val(outer), 456);
+
+outer.inside1 = named;
+assert(nested_structs.getInside1Val(outer), 999);
+
-overload_extendc
+overload_extend2
-f = overload_extendc.Foo();
+f = overload_extend2.Foo();
if (f.test(3) != 1)
error
endif
--- /dev/null
+overload_extend_c
+
+f = overload_extend_c.Foo();
+if (f.test() != 0)
+ error
+endif
+if (f.test(3) != 1)
+ error
+endif
+if (f.test("hello") != 2)
+ error
+endif
+if (f.test(3,2) != 5)
+ error
+endif
+if (f.test(3.1)-.1 != 1003) # :)
+ error
+endif
+
%rename(OrOperator) operator ||;
#endif
-#ifdef SWIG_ALLEGRO_CL
-%{
-#include <stdio.h>
-%}
+#if defined(SWIGPYTHON)
+%feature("python:slot", "tp_str", functype="reprfunc") Op::__str__;
#endif
#ifdef SWIGD
%rename(DoubleCast) operator double();
%inline %{
+#include <stdio.h>
#if defined(_MSC_VER)
#include <iso646.h> /* for named logical operator, eg 'operator or' */
#endif
-#include <assert.h>
-
class Op {
public:
int i;
return *this;
}
// +=,-=... are member fns
- void operator+=(const Op& o){ i+=o.i;}
- void operator-=(const Op& o){ i-=o.i;}
- void operator*=(const Op& o){ i*=o.i;}
- void operator/=(const Op& o){ i/=o.i;}
- void operator%=(const Op& o){ i%=o.i;}
+ Op &operator+=(const Op& o){ i+=o.i; return *this; }
+ Op &operator-=(const Op& o){ i-=o.i; return *this; }
+ Op &operator*=(const Op& o){ i*=o.i; return *this; }
+ Op &operator/=(const Op& o){ i/=o.i; return *this; }
+ Op &operator%=(const Op& o){ i%=o.i; return *this; }
// the +,-,*,... are friends
// (just to make life harder)
friend Op operator+(const Op& a,const Op& b){return Op(a.i+b.i);}
__getitem__,__setitem__ for operator[]
-Operators overloaded without C++ equivilents
+Operators overloaded without C++ equivalents
__pow__ for power operator
__str__ converts object to a string (should return a const char*)
-__concat__ for contatenation (if language supports)
+__concat__ for concatenation (if language supports)
*/
%{
-
-#include <assert.h>
+#include <stdexcept>
+#define ASSERT(X) { if (!(X)) { throw std::runtime_error(#X); } }
void Op::sanity_check()
{
Op dd=d; // assignment operator
// test equality
- assert(a!=b);
- assert(b==c);
- assert(a!=d);
- assert(d==dd);
+ ASSERT(a!=b);
+ ASSERT(b==c);
+ ASSERT(a!=d);
+ ASSERT(d==dd);
// test <
- assert(a<b);
- assert(a<=b);
- assert(b<=c);
- assert(b>=c);
- assert(b>d);
- assert(b>=d);
+ ASSERT(a<b);
+ ASSERT(a<=b);
+ ASSERT(b<=c);
+ ASSERT(b>=c);
+ ASSERT(b>d);
+ ASSERT(b>=d);
// test +=
Op e=3;
e+=d;
- assert(e==b);
+ ASSERT(e==b);
e-=c;
- assert(e==a);
+ ASSERT(e==a);
e=Op(1);
e*=b;
- assert(e==c);
+ ASSERT(e==c);
e/=d;
- assert(e==d);
+ ASSERT(e==d);
e%=c;
- assert(e==d);
+ ASSERT(e==d);
// test +
Op f(1),g(1);
- assert(f+g==Op(2));
- assert(f-g==Op(0));
- assert(f*g==Op(1));
- assert(f/g==Op(1));
- assert(f%g==Op(0));
+ ASSERT(f+g==Op(2));
+ ASSERT(f-g==Op(0));
+ ASSERT(f*g==Op(1));
+ ASSERT(f/g==Op(1));
+ ASSERT(f%g==Op(0));
// test unary operators
- assert(!a==true);
- assert(!b==false);
- assert(-a==a);
- assert(-b==Op(-5));
+ ASSERT(!a==true);
+ ASSERT(!b==false);
+ ASSERT(-a==a);
+ ASSERT(-b==Op(-5));
// test []
Op h=3;
- assert(h[0]==3);
- assert(h[1]==0);
+ ASSERT(h[0]==3);
+ ASSERT(h[1]==0);
h[0]=2; // set
- assert(h[0]==2);
+ ASSERT(h[0]==2);
h[1]=2; // ignored
- assert(h[0]==2);
- assert(h[1]==0);
+ ASSERT(h[0]==2);
+ ASSERT(h[1]==0);
// test ()
Op i=3;
- assert(i()==3);
- assert(i(1)==4);
- assert(i(1,2)==6);
+ ASSERT(i()==3);
+ ASSERT(i(1)==4);
+ ASSERT(i(1,2)==6);
// plus add some code to check the __str__ fn
- //assert(str(Op(1))=="Op(1)");
- //assert(str(Op(-3))=="Op(-3)");
+ //ASSERT(str(Op(1))=="Op(1)");
+ //ASSERT(str(Op(-3))=="Op(-3)");
// test ++ and --
Op j(100);
{
Op newOp = j++;
int newInt = original++;
- assert(j.i == original);
- assert(newOp.i == newInt);
+ ASSERT(j.i == original);
+ ASSERT(newOp.i == newInt);
}
{
Op newOp = j--;
int newInt = original--;
- assert(j.i == original);
- assert(newOp.i == newInt);
+ ASSERT(j.i == original);
+ ASSERT(newOp.i == newInt);
}
{
Op newOp = ++j;
int newInt = ++original;
- assert(j.i == original);
- assert(newOp.i == newInt);
+ ASSERT(j.i == original);
+ ASSERT(newOp.i == newInt);
}
{
Op newOp = --j;
int newInt = --original;
- assert(j.i == original);
- assert(newOp.i == newInt);
+ ASSERT(j.i == original);
+ ASSERT(newOp.i == newInt);
}
// cast operators
Op k=3;
int check_k = k;
- assert (check_k == 3);
+ ASSERT (check_k == 3);
Op l=4;
double check_l = l;
- assert (check_l == 4);
+ ASSERT (check_l == 4);
}
%}
%rename(PlusPlusPostfix) operator++(int);
#endif
+%ignore operator new (size_t);
+%ignore operator delete (void *);
+%ignore operator delete[] (void *);
+
%{
#include <iostream>
using namespace std;
int k;
};
+struct Op2 {
+ void *operator new
+ (size_t); // definition split over two lines was giving syntax error
+ void operator delete /* comment here did not work */ (void *);
+ void operator
+ delete[] (void *);
+};
+
+void *Op2::operator new(size_t) { return malloc(sizeof(Op)); }
+void Op2::operator delete(void *p) { free(p); }
+void Op2::operator delete[] (void *) {}
+
%}
--- /dev/null
+// Tests of overloaded functions of arrays
+// Based on overload_simple testcase
+%module overload_arrays
+
+#ifdef SWIGCHICKEN
+%warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) fbool;
+#endif
+
+#ifdef SWIGLUA
+// lua only has one numeric type, so most of the overloads shadow each other creating warnings
+%warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) foo;
+%warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) bar;
+%warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) Spam;
+#endif
+
+#ifdef SWIGGO
+%warnfilter(SWIGWARN_PARSE_KEYWORD) type; // 'type' is a Go keyword, renamed as 'Xtype'
+%rename(Foos) Foo;
+#endif
+
+
+
+#ifndef SWIG_NO_OVERLOAD
+%immutable Spam::type;
+
+%inline %{
+
+#define SIZE 3
+
+struct Foo {
+};
+
+class Bar {
+public:
+ Bar(int i = 0) { num = i; }
+
+ static int foo(int a=0, int b=0) {return 0;}
+
+ int num;
+};
+
+char *foo() {
+ return (char *) "foo:";
+}
+char *foo(int[SIZE]) {
+ return (char*) "foo:int[SIZE]";
+}
+
+char *foo(double[SIZE]) {
+ return (char*) "foo:double[SIZE]";
+}
+
+char *foo(char *[SIZE]) {
+ return (char*) "foo:char *[SIZE]";
+}
+
+char *foo(Foo *[SIZE]) {
+ return (char*) "foo:Foo *[SIZE]";
+}
+char *foo(Bar *[SIZE]) {
+ return (char *) "foo:Bar *[SIZE]";
+}
+char *foo(void *[SIZE]) {
+ return (char *) "foo:void *[SIZE]";
+}
+char *foo(Foo *[SIZE], int[SIZE]) {
+ return (char *) "foo:Foo *[SIZE],int[SIZE]";
+}
+char *foo(double[SIZE], Bar *[SIZE]) {
+ return (char *) "foo:double[SIZE],Bar *[SIZE]";
+}
+
+char *blah(double[SIZE]) {
+ return (char *) "blah:double[SIZE]";
+}
+
+char *blah(char *[SIZE]) {
+ return (char *) "blah:char *[SIZE]";
+}
+
+class Spam {
+public:
+ Spam() { type = "none"; }
+ Spam(int[SIZE]) { type = "int[SIZE]"; }
+ Spam(double[SIZE]) { type = "double[SIZE]"; }
+ Spam(char *[SIZE]) { type = "char *[SIZE]"; }
+ Spam(Foo *[SIZE]) { type = "Foo *[SIZE]"; }
+ Spam(Bar *[SIZE]) { type = "Bar *[SIZE]"; }
+ Spam(void *[SIZE]) { type = "void *[SIZE]"; }
+ const char *type;
+
+char *foo(int[SIZE]) {
+ return (char*) "foo:int[SIZE]";
+}
+char *foo(double[SIZE]) {
+ return (char*) "foo:double[SIZE]";
+}
+char *foo(char *[SIZE]) {
+ return (char*) "foo:char *[SIZE]";
+}
+char *foo(Foo *[SIZE]) {
+ return (char*) "foo:Foo *[SIZE]";
+}
+char *foo(Bar *[SIZE]) {
+ return (char *) "foo:Bar *[SIZE]";
+}
+char *foo(void *[SIZE]) {
+ return (char *) "foo:void *[SIZE]";
+}
+
+static char *bar(int[SIZE]) {
+ return (char*) "bar:int[SIZE]";
+}
+static char *bar(double[SIZE]) {
+ return (char*) "bar:double[SIZE]";
+}
+static char *bar(char *[SIZE]) {
+ return (char*) "bar:char *[SIZE]";
+}
+static char *bar(Foo *[SIZE]) {
+ return (char*) "bar:Foo *[SIZE]";
+}
+static char *bar(Bar *[SIZE]) {
+ return (char *) "bar:Bar *[SIZE]";
+}
+static char *bar(void *[SIZE]) {
+ return (char *) "bar:void *[SIZE]";
+}
+};
+
+%}
+
+#endif
+
+
+%inline {
+ class ClassA
+ {
+ public:
+ ClassA() {}
+ int method1( ) {return 0;}
+ int method1( int arg1[SIZE] ) {return arg1[0];}
+ protected:
+ int method1( int arg1[SIZE], int arg2[SIZE] ) {return arg1[0] + arg2[0];}
+
+ };
+}
+
--- /dev/null
+%module overload_bool
+
+%inline %{
+const char* overloaded(bool value) { return "bool"; }
+const char* overloaded(int value) { return "int"; }
+const char* overloaded(const char *value) { return "string"; }
+
+const char* boolfunction(bool value) { return value ? "true" : "false"; }
+const char* intfunction(int value) { return "int"; }
+
+
+// Const references
+const char* overloaded_ref(bool const& value) { return "bool"; }
+const char* overloaded_ref(int const& value) { return "int"; }
+const char* overloaded_ref(const char *value) { return "string"; }
+
+const char* boolfunction_ref(bool const& value) { return value ? "true" : "false"; }
+const char* intfunction_ref(int const& value) { return "int"; }
+%}
-%module overload_extendc
+%module overload_extend2
%typemap(default) int int2 "$1=1000;";
--- /dev/null
+%module overload_extend_c
+
+%include "overload_extend.i"
--- /dev/null
+%module overload_polymorphic
+
+%inline %{
+
+class Base {
+public:
+ Base(){}
+ virtual ~Base(){}
+};
+
+class Derived : public Base {
+public:
+ Derived(){}
+ virtual ~Derived(){}
+};
+
+
+
+int test(Base* base){ return 0;}
+int test(int hello){ return 1; }
+
+class Unknown;
+int test2(Unknown* unknown) { return 0; }
+int test2(Base* base) { return 1; }
+
+%}
LANGUAGE = perl5
PERL = @PERL@
SCRIPTSUFFIX = _runme.pl
-TEST_RUNNER = run-perl-test.pl
+TEST_RUNNER = $(srcdir)/run-perl-test.pl
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
CPP_TEST_CASES += \
primitive_types \
- li_cdata \
li_cstring \
- li_cdata_carrays \
+ li_cdata_carrays_cpp \
li_reference \
+ director_nestedmodule \
C_TEST_CASES += \
- li_cdata \
li_cstring \
li_cdata_carrays \
# none!
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.pl appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(PERL) $(TEST_RUNNER) $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(PERL) $(TEST_RUNNER) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
# Clean: remove the generated .pm file
@rm -f $*.pm;
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile perl5_clean
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' perl5_clean
Test::More Support
==
-Test::More and Test::Harness are two of the standard perl test harness
-tools. Support has been added for these modules as of 1.3.28. If
-adding a new test to this suite, please use Test::More.
+Test::More is a standard perl test harness tool.
+Support was added for for using Test::More in 1.3.28.
+If adding a new test to this suite, please use Test::More.
-Currently converted test cases include:
+There are a few legacy test cases which do not use Test::More and these ought to be converted:
-* operator_overload
-* operator_overload_break
-* package
-* overload_simple
-* apply_strings
-* char_strings
-* default_args
-* enum_thorough
-* global_vars
-* import_nomodule
-* inherit
-* li_cdata_carrays
-* li_std_string
-* member_pointer
-* multiple_inheritance
-* primitive_ref
-* template_default_arg
-* unions
-* voidtest
+disown
+imports
+overload_copy
+profiletest
+template_ref_type
use strict;
use warnings;
-use Test::More tests => 7;
+use Test::More tests => 10;
BEGIN { use_ok('char_binary') }
require_ok('char_binary');
my $t = char_binary::Test->new();
is($t->strlen('hile'), 4, "string typemap");
+is($t->ustrlen('hile'), 4, "unsigned string typemap");
is($t->strlen("hil\0"), 4, "string typemap");
+is($t->ustrlen("hil\0"), 4, "unsigned string typemap");
#
# creating a raw char*
is($t->strlen($pc), 4, "string typemap");
+is($t->ustrlen($pc), 4, "unsigned string typemap");
$char_binary::var_pchar = $pc;
is($char_binary::var_pchar, "hola", "pointer case");
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 78;
+BEGIN { use_ok('cpp11_strongly_typed_enumerations') }
+require_ok('cpp11_strongly_typed_enumerations');
+
+sub enumCheck { my($actual, $expected) = @_;
+ is($actual, $expected);
+ return $expected + 1;
+}
+
+my $val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum1_Val1, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum1_Val2, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum1_Val3, 13);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum1_Val4, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum1_Val5a, 13);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum1_Val6a, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum2_Val1, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum2_Val2, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum2_Val3, 23);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum2_Val4, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum2_Val5b, 23);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum2_Val6b, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Val1, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Val2, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Val3, 43);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Val4, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum5_Val1, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum5_Val2, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum5_Val3, 53);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum5_Val4, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum6_Val1, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum6_Val2, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum6_Val3, 63);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum6_Val4, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum7td_Val1, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum7td_Val2, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum7td_Val3, 73);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum7td_Val4, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum8_Val1, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum8_Val2, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum8_Val3, 83);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum8_Val4, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum10_Val1, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum10_Val2, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum10_Val3, 103);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Enum10_Val4, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Enum12_Val1, 1121);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Enum12_Val2, 1122);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Enum12_Val3, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Enum12_Val4, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Enum12_Val5c, 1121);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Enum12_Val6c, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Val1, 1131);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Val2, 1132);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Val3, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Val4, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Val5d, 1131);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Val6d, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Enum14_Val1, 1141);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Enum14_Val2, 1142);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Enum14_Val3, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Enum14_Val4, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Enum14_Val5e, 1141);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Enum14_Val6e, $val);
+
+# Requires nested class support to work
+#$val = 0;
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum12_Val1, 3121);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum12_Val2, 3122);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum12_Val3, $val);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum12_Val4, $val);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum12_Val5f, 3121);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum12_Val6f, $val);
+#
+#$val = 0;
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Val1, 3131);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Val2, 3132);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Val3, $val);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Val4, $val);
+#
+#$val = 0;
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum14_Val1, 3141);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum14_Val2, 3142);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum14_Val3, $val);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum14_Val4, $val);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum14_Val5g, 3141);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum14_Val6g, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Enum12_Val1, 2121);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Enum12_Val2, 2122);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Enum12_Val3, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Enum12_Val4, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Enum12_Val5h, 2121);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Enum12_Val6h, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Val1, 2131);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Val2, 2132);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Val3, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Val4, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Val5i, 2131);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Val6i, $val);
+
+$val = 0;
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Enum14_Val1, 2141);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Enum14_Val2, 2142);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Enum14_Val3, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Enum14_Val4, $val);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Enum14_Val5j, 2141);
+$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Enum14_Val6j, $val);
+
+# Requires nested class support to work
+#$val = 0;
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Enum12_Val1, 4121);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Enum12_Val2, 4122);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Enum12_Val3, $val);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Enum12_Val4, $val);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Enum12_Val5k, 4121);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Enum12_Val6k, $val);
+#
+#$val = 0;
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Val1, 4131);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Val2, 4132);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Val3, $val);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Val4, $val);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Val5l, 4131);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Val6l, $val);
+#
+#$val = 0;
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Enum14_Val1, 4141);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Enum14_Val2, 4142);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Enum14_Val3, $val);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Enum14_Val4, $val);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Enum14_Val5m, 4141);
+#$val = enumCheck($cpp11_strongly_typed_enumerations::Class2::Struct1::Enum14_Val6m, $val);
+
+my $class1 = cpp11_strongly_typed_enumerations::Class1->new();
+enumCheck($class1->class1Test1($cpp11_strongly_typed_enumerations::Enum1_Val5a), 13);
+enumCheck($class1->class1Test2($cpp11_strongly_typed_enumerations::Class1::Enum12_Val5c), 1121);
+#enumCheck($class1->class1Test3($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum12_Val5f), 3121);
+
+enumCheck(cpp11_strongly_typed_enumerations::globalTest1($cpp11_strongly_typed_enumerations::Enum1_Val5a), 13);
+enumCheck(cpp11_strongly_typed_enumerations::globalTest2($cpp11_strongly_typed_enumerations::Class1::Enum12_Val5c), 1121);
+#enumCheck(cpp11_strongly_typed_enumerations::globalTest3($cpp11_strongly_typed_enumerations::Class1::Struct1::Enum12_Val5f), 3121);
+
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 13;
+BEGIN { use_ok('director_abstract') }
+require_ok('director_abstract');
+
+{
+ package MyFoo;
+ use base 'director_abstract::Foo';
+ sub ping {
+ return 'MyFoo::ping()';
+ }
+}
+
+my $f = MyFoo->new();
+
+is($f->ping, "MyFoo::ping()");
+
+is($f->pong(),"Foo::pong();MyFoo::ping()");
+
+{
+ package MyExample1;
+ use base 'director_abstract::Example1';
+ sub Color { my($self, $r, $g, $b) = @_;
+ return $r;
+ }
+}
+{
+ package MyExample2;
+ use base 'director_abstract::Example2';
+ sub Color { my($self, $r, $g, $b) = @_;
+ return $g;
+ }
+}
+{
+ package MyExample3;
+ use base 'director_abstract::Example3_i';
+ sub Color { my($self, $r, $g, $b) = @_;
+ return $b;
+ }
+}
+
+my $me1 = MyExample1->new();
+isa_ok($me1, 'MyExample1');
+is(director_abstract::Example1::get_color($me1, 1, 2, 3), 1, 'me1');
+
+my $me2 = MyExample2->new(1,2);
+isa_ok($me2, 'MyExample2');
+is(director_abstract::Example2::get_color($me2, 1, 2, 3), 2, 'me2');
+
+my $me3 = MyExample3->new();
+isa_ok($me3, 'MyExample3');
+is(director_abstract::Example3_i::get_color($me3, 1, 2, 3), 3, 'me3');
+
+eval { $me1 = director_abstract::Example1->new() };
+like($@, qr/\babstract\b/i, 'E1.new()');
+
+eval { $me2 = director_abstract::Example2->new() };
+like($@, qr/Example2/, 'E2.new()');
+
+eval { $me3 = director_abstract::Example3_i->new() };
+like($@, qr/\babstract\b/i, 'E3.new()');
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 3;
+BEGIN { use_ok('director_alternating') }
+require_ok('director_alternating');
+
+my $id = director_alternating::getBar()->id();
+is($id, director_alternating::idFromGetBar(), "got Bar id");
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 12;
+BEGIN { use_ok 'director_basic' }
+require_ok 'director_basic';
+
+{
+ package MyFoo;
+ use base 'director_basic::Foo';
+ sub ping {
+ return 'MyFoo::ping()';
+ }
+}
+
+{
+ package MyOverriddenClass;
+ use base 'director_basic::MyClass';
+ use fields qw(expectNull nonNullReceived);
+ sub new {
+ my $self = shift->SUPER::new(@_);
+ $self->{expectNull} = undef;
+ $self->{nonNullReceived} = undef;
+ return $self;
+ }
+ sub pmethod { my($self, $b) = @_;
+ die "null not received as expected"
+ if $self->{expectNull} and defined $b;
+ return $b;
+ }
+}
+
+{
+ my $a = MyFoo->new();
+ isa_ok $a, 'MyFoo';
+ is $a->ping(), 'MyFoo::ping()', 'a.ping()';
+ is $a->pong(), 'Foo::pong();MyFoo::ping()', 'a.pong()';
+
+ my $b = director_basic::Foo->new();
+ isa_ok $b, 'director_basic::Foo';
+ is $b->ping(), 'Foo::ping()', 'b.ping()';
+ is $b->pong(), 'Foo::pong();Foo::ping()', 'b.pong()';
+
+ my $a1 = director_basic::A1->new(1, undef);
+ isa_ok $a1, 'director_basic::A1';
+ is $a1->rg(2), 2, 'A1.rg';
+
+ my $my = MyOverriddenClass->new();
+ $my->{expectNull} = 1;
+ is(director_basic::MyClass::call_pmethod($my, undef), undef,
+ 'null pointer marshalling');
+
+ my $myBar = director_basic::Bar->new();
+ $my->{expectNull} = undef;
+ my $myNewBar = director_basic::MyClass::call_pmethod($my, $myBar);
+ isnt($myNewBar, undef, 'non-null pointer marshalling');
+ $myNewBar->{x} = 10;
+}
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 29;
+BEGIN { use_ok 'director_classes' }
+require_ok 'director_classes';
+
+{
+ package PerlDerived;
+ use base 'director_classes::Base';
+ sub Val { $_[1] }
+ sub Ref { $_[1] }
+ sub Ptr { $_[1] }
+ sub FullyOverloaded {
+ my $rv = shift->SUPER::FullyOverloaded(@_);
+ $rv =~ s/Base/__PACKAGE__/sge;
+ return $rv;
+ }
+ sub SemiOverloaded {
+ # this is going to be awkward because we can't really
+ # semi-overload in Perl, but we can sort of fake it.
+ return shift->SUPER::SemiOverloaded(@_) unless $_[0] =~ /^\d+/;
+ my $rv = shift->SUPER::SemiOverloaded(@_);
+ $rv =~ s/Base/__PACKAGE__/sge;
+ return $rv;
+ }
+ sub DefaultParms {
+ my $rv = shift->SUPER::DefaultParms(@_);
+ $rv =~ s/Base/__PACKAGE__/sge;
+ return $rv;
+ }
+}
+
+{
+ my $c = director_classes::Caller->new();
+ makeCalls($c, director_classes::Base->new(100.0));
+ makeCalls($c, director_classes::Derived->new(200.0));
+ makeCalls($c, PerlDerived->new(300.0));
+}
+
+sub makeCalls { my($caller, $base) = @_;
+ my $bname = ref $base;
+ $bname = $1 if $bname =~ /^director_classes::(.*)$/;
+ $caller->set($base);
+ my $dh = director_classes::DoubleHolder->new(444.555);
+ is($caller->ValCall($dh)->{val}, $dh->{val}, "$bname.Val");
+ is($caller->RefCall($dh)->{val}, $dh->{val}, "$bname.Ref");
+ is($caller->PtrCall($dh)->{val}, $dh->{val}, "$bname.Ptr");
+ is($caller->FullyOverloadedCall(1),
+ "${bname}::FullyOverloaded(int)",
+ "$bname.FullyOverloaded(int)");
+ is($caller->FullyOverloadedCall(''),
+ "${bname}::FullyOverloaded(bool)",
+ "$bname.FullyOverloaded(bool)");
+TODO: {
+ local $TODO = 'investigation needed here' if $bname eq 'PerlDerived';
+ is($caller->SemiOverloadedCall(-678),
+ "${bname}::SemiOverloaded(int)",
+ "$bname.SemiOverloaded(int)");
+}
+ is($caller->SemiOverloadedCall(''),
+ "Base::SemiOverloaded(bool)",
+ "$bname.SemiOverloaded(bool)");
+ is($caller->DefaultParmsCall(10, 2.2),
+ "${bname}::DefaultParms(int, double)",
+ "$bname.DefaultParms(int, double)");
+ is($caller->DefaultParmsCall(10),
+ "${bname}::DefaultParms(int)",
+ "$bname.DefaultParms(int)");
+ $caller->reset();
+}
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 41;
+BEGIN { use_ok('director_classic') }
+require_ok('director_classic');
+
+{
+ package TargetLangPerson;
+ use base 'director_classic::Person';
+ sub id { return 'TargetLangPerson' }
+}
+
+{
+ package TargetLangChild;
+ use base 'director_classic::Child';
+ sub id { return 'TargetLangChild' }
+}
+
+{
+ package TargetLangGrandChild;
+ use base 'director_classic::GrandChild';
+ sub id { return 'TargetLangGrandChild' }
+}
+
+# Semis - don't override id() in target language
+{
+ package TargetLangSemiPerson;
+ use base 'director_classic::Person';
+ # No id() override
+}
+
+{
+ package TargetLangSemiChild;
+ use base 'director_classic::Child';
+ # No id() override
+}
+
+{
+ package TargetLangSemiGrandChild;
+ use base 'director_classic::GrandChild';
+ # No id() override
+}
+
+# Orphans - don't override id() in C++
+{
+ package TargetLangOrphanPerson;
+ use base 'director_classic::OrphanPerson';
+ sub id { return "TargetLangOrphanPerson" }
+}
+
+{
+ package TargetLangOrphanChild;
+ use base 'director_classic::OrphanChild';
+ sub id { return "TargetLangOrphanChild" }
+}
+
+sub check { my($person, $expected) = @_;
+ # Normal target language polymorphic call
+ is($person->id(), $expected, "$expected from Perl");
+
+ # Polymorphic call from C++
+ my $caller = director_classic::Caller->new();
+ $caller->setCallback($person);
+ is($caller->call(), $expected, "$expected from C++");
+
+ # Polymorphic call of object created in target language and passed to C++ and back again
+ my $baseclass = $caller->baseClass();
+ is($baseclass->id(), $expected, "$expected after bounce");
+
+ $caller->resetCallback();
+}
+
+my $person;
+
+$person = director_classic::Person->new();
+check($person, "Person");
+undef $person;
+
+$person = director_classic::Child->new();
+check($person, "Child");
+undef $person;
+
+$person = director_classic::GrandChild->new();
+check($person, "GrandChild");
+undef $person;
+
+$person = TargetLangPerson->new();
+check($person, "TargetLangPerson");
+undef $person;
+
+$person = TargetLangChild->new();
+check($person, "TargetLangChild");
+undef $person;
+
+$person = TargetLangGrandChild->new();
+check($person, "TargetLangGrandChild");
+undef $person;
+
+# Semis - don't override id() in target language
+$person = TargetLangSemiPerson->new();
+check($person, "Person");
+undef $person;
+
+$person = TargetLangSemiChild->new();
+check($person, "Child");
+undef $person;
+
+$person = TargetLangSemiGrandChild->new();
+check($person, "GrandChild");
+undef $person;
+
+# Orphans - don't override id() in C++
+$person = director_classic::OrphanPerson->new();
+check($person, "Person");
+undef $person;
+
+$person = director_classic::OrphanChild->new();
+check($person, "Child");
+undef $person;
+
+$person = TargetLangOrphanPerson->new();
+check($person, "TargetLangOrphanPerson");
+undef $person;
+
+$person = TargetLangOrphanChild->new();
+check($person, "TargetLangOrphanChild");
+undef $person;
+
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 9;
+BEGIN { use_ok 'director_constructor' }
+require_ok 'director_constructor';
+
+{
+ package Test;
+ use base 'director_constructor::Foo';
+ sub doubleit { my($self) = @_;
+ $self->{a} *= 2;
+ }
+ sub test { 3 }
+}
+my $t = Test->new(5);
+isa_ok $t, 'Test';
+is $t->getit, 5;
+is $t->do_test, 3;
+
+$t->doubleit();
+
+is $t->getit, 10;
+
+{
+ package Wrong;
+ use base 'director_constructor::Foo';
+ sub doubleit { my($self) = @_;
+ # calling this should trigger a type error on attribute
+ # assignment
+ $self->{a} = {};
+ }
+ sub test {
+ # if c++ calls this, retval copyout should trigger a type error
+ return bless {}, 'TotallyBogus';
+ }
+}
+
+# TODO: these TypeErrors in director classes should be more detailed
+my $w = Wrong->new(12);
+is eval { $w->doubleit() }, undef;
+like $@, qr/TypeError/;
+is $w->getit(), 12, 'W.a should be unaffected';
+
+# TODO: this is giving an unhandled C++ exception right now
+#is eval { $W->do_test() }, undef;
+#like $@, qr/TypeError/;
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 6;
+BEGIN { use_ok 'director_default' }
+require_ok 'director_default';
+
+my $f;
+
+$f = director_default::Foo->new();
+isa_ok $f, 'director_default::Foo';
+$f = director_default::Foo->new(1);
+isa_ok $f, 'director_default::Foo';
+
+
+$f = director_default::Bar->new();
+isa_ok $f, 'director_default::Bar';
+$f = director_default::Bar->new(1);
+isa_ok $f, 'director_default::Bar';
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 9;
+BEGIN { use_ok 'director_detect' }
+require_ok 'director_detect';
+
+{
+ package MyBar;
+ use base 'director_detect::Bar';
+ sub new { my $class = shift;
+ my $val = @_ ? shift : 2;
+ my $self = $class->SUPER::new();
+ $self->{val} = $val;
+ return $self;
+ }
+ sub get_value { my($self) = @_;
+ $self->{val}++;
+ return $self->{val};
+ }
+ sub get_class { my($self) = @_;
+ $self->{val}++;
+ return director_detect::A->new();
+ }
+ sub just_do_it { my($self) = @_;
+ $self->{val}++;
+ }
+ sub clone { my($self) = @_;
+ MyBar->new($self->{val});
+ }
+}
+
+my $b = MyBar->new();
+isa_ok $b, 'MyBar';
+
+my $f = $b->baseclass();
+isa_ok $f, 'director_detect::Foo';
+is $f->get_value(), 3;
+
+isa_ok $f->get_class(), 'director_detect::A';
+$f->just_do_it();
+
+my $c = $b->clone();
+isa_ok $c, 'MyBar';
+is $b->{val}, 5;
+is $c->get_value(), 6;
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 5;
+BEGIN { use_ok 'director_enum' }
+require_ok 'director_enum';
+
+{
+ package MyFoo;
+ use base 'director_enum::Foo';
+ sub say_hi { my($self, $val) = @_;
+ return $val;
+ }
+}
+
+my $b = director_enum::Foo->new();
+isa_ok $b, 'director_enum::Foo';
+my $a = MyFoo->new();
+isa_ok $a, 'MyFoo';
+
+is $a->say_hi($director_enum::hello),
+ $a->say_hello($director_enum::hi);
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 7;
+BEGIN { use_ok 'director_exception' }
+require_ok 'director_exception';
+
+{
+ package MyFoo;
+ use base 'director_exception::Foo';
+ sub ping {
+ die "MyFoo::ping() EXCEPTION";
+ }
+}
+{
+ package MyFoo2;
+ use base 'director_exception::Foo';
+ sub ping {
+ # error should return a string
+ return bless [ 1 ], 'main';
+ }
+}
+{
+ package MyFoo3;
+ use base 'director_exception::Foo';
+ sub ping {
+ # error should return a string
+ return sub { 1 }
+ }
+}
+
+{
+ my $a = MyFoo->new();
+ my $b = director_exception::launder($a);
+ eval { $b->pong() };
+ like($@, qr/\bMyFoo::ping\(\) EXCEPTION\b/,
+ 'MyFoo.pong() error content preserved');
+}
+{
+ my $a = MyFoo2->new();
+ my $b = director_exception::launder($a);
+ eval { $b->pong() };
+ like($@, qr/\bTypeError\b/,
+ 'MyFoo2.pong() error content preserved');
+}
+{
+ my $a = MyFoo3->new();
+ my $b = director_exception::launder($a);
+ eval { $b->pong() };
+ like($@, qr/\bTypeError\b/,
+ 'MyFoo2.pong() error content preserved');
+}
+
+eval { die director_exception::Exception1->new() };
+isa_ok($@, 'director_exception::Exception1', 'Exception1');
+
+eval { die director_exception::Exception2->new() };
+isa_ok($@, 'director_exception::Exception2', 'Exception2');
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 5;
+BEGIN { use_ok 'director_extend' }
+require_ok 'director_extend';
+
+{
+ package MyObject;
+ use base 'director_extend::SpObject';
+ sub getFoo { 123 }
+}
+
+my $m = MyObject->new();
+isa_ok $m, 'MyObject';
+is($m->dummy(), 666, '1st call');
+is($m->dummy(), 666, '2nd call');
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 13;
+BEGIN { use_ok('director_finalizer') }
+require_ok('director_finalizer');
+
+{
+ package MyFoo;
+ use base 'director_finalizer::Foo';
+ sub DESTROY { my($self, $final) = @_;
+ $self->orStatus(2) if $final;
+ shift->SUPER::DESTROY(@_);
+ }
+}
+
+{
+ director_finalizer::resetStatus();
+ my $f = MyFoo->new();
+ undef $f;
+ is(director_finalizer::getStatus(), 3, 'shadow release fires destructor');
+}
+
+{ # again, this time with DESTROY
+ director_finalizer::resetStatus();
+ my $f = MyFoo->new();
+ $f->DESTROY();
+ is(director_finalizer::getStatus(), 3, 'DESTROY method fires destructor');
+}
+
+{
+ director_finalizer::resetStatus();
+ my $f = MyFoo->new();
+ director_finalizer::launder($f);
+ is(director_finalizer::getStatus(), 0, 'wrap release does not fire destructor');
+ undef $f;
+ is(director_finalizer::getStatus(), 3, 'shadow release still fires destructor');
+}
+
+{ # again, this time with DESTROY
+ director_finalizer::resetStatus();
+ my $f = MyFoo->new();
+ director_finalizer::launder($f);
+ is(director_finalizer::getStatus(), 0, 'wrap release does not fire destructor');
+ $f->DESTROY();
+ is(director_finalizer::getStatus(), 3, 'DESTROY method still fires destructor');
+}
+
+{
+ director_finalizer::resetStatus();
+ my $f = MyFoo->new();
+ $f->DISOWN();
+ is(director_finalizer::getStatus(), 0, 'shadow release does not fire destructor of disowned object');
+ director_finalizer::deleteFoo($f);
+ is(director_finalizer::getStatus(), 3, 'c++ release fires destructors of disowned object');
+}
+
+{ # again, this time with DESTROY
+ my $f = MyFoo->new();
+ $f->DISOWN();
+ director_finalizer::deleteFoo($f);
+ director_finalizer::resetStatus();
+ $f->DESTROY();
+ is(director_finalizer::getStatus(), 0, 'DESTROY method does not fire destructor of disowned object');
+}
+
+{
+ director_finalizer::resetStatus();
+ my $f = MyFoo->new();
+ $f->DISOWN();
+ my $g = director_finalizer::launder($f);
+ undef $f;
+ director_finalizer::deleteFoo($g);
+ is(director_finalizer::getStatus(), 3, 'c++ release fires destructors on disowned opaque object');
+}
+
+{ # again, this time with DESTROY
+ director_finalizer::resetStatus();
+ my $f = MyFoo->new();
+ $f->DISOWN();
+ my $g = director_finalizer::launder($f);
+ $f->DESTROY();
+ director_finalizer::deleteFoo($g);
+ is(director_finalizer::getStatus(), 3, 'c++ release fires destructors on disowned opaque object after DESTROY');
+}
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 4;
+BEGIN { use_ok 'director_frob' }
+require_ok 'director_frob';
+
+my $foo = director_frob::Bravo->new();
+isa_ok $foo, 'director_frob::Bravo';
+
+is($foo->abs_method(), 'Bravo::abs_method()');
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 6;
+BEGIN { use_ok 'director_ignore' }
+require_ok 'director_ignore';
+
+{
+ package DIgnoresDerived;
+ use base 'director_ignore::DIgnores';
+ sub PublicMethod1 {
+ return 18.75;
+ }
+}
+{
+ package DAbstractIgnoresDerived;
+ use base 'director_ignore::DAbstractIgnores';
+}
+
+my $a = DIgnoresDerived->new();
+isa_ok $a, 'DIgnoresDerived';
+is $a->Triple(5), 15;
+
+my $b = DAbstractIgnoresDerived->new();
+isa_ok $b, 'DAbstractIgnoresDerived';
+is $b->Quadruple(5), 20;
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 9;
+BEGIN { use_ok 'director_nested' }
+require_ok 'director_nested';
+
+{
+ package A;
+ use base 'director_nested::FooBar_int';
+ sub do_step { 'A::do_step;' }
+ sub get_value { 'A::get_value' }
+}
+
+my $a = A->new();
+isa_ok $a, 'A';
+
+is $a->step(), "Bar::step;Foo::advance;Bar::do_advance;A::do_step;",
+ 'A virtual resolution';
+
+{
+ package B;
+ use base 'director_nested::FooBar_int';
+ sub do_advance { my($self) = @_;
+ return "B::do_advance;" . $self->do_step();
+ }
+ sub do_step { "B::do_step;" }
+ sub get_value { 1 }
+}
+
+my $b = B->new();
+isa_ok $b, 'B';
+is $b->step(), "Bar::step;Foo::advance;B::do_advance;B::do_step;",
+ 'B virtual resolution';
+
+{
+ package C;
+ use base 'director_nested::FooBar_int';
+ our $in_do_advance = 0;
+ sub do_advance { my($self) = @_;
+ # found a case where upcall didn't happen right in a perl space
+ # SUPER:: call.
+ die "SUPERCALL RESOLVE FAILURE" if $in_do_advance;
+ local $in_do_advance = 1;
+ return "C::do_advance;" .
+ $self->SUPER::do_advance();
+ }
+ sub do_step { "C::do_step;" }
+ sub get_value { 2 }
+ sub get_name { my($self) = @_;
+ return $self->director_nested::FooBar_int::get_name() . " hello";
+ }
+}
+
+my $cc = C->new();
+isa_ok $cc, 'C';
+my $c = director_nested::FooBar_int::get_self($cc);
+$c->advance();
+is $c->get_name(), "FooBar::get_name hello";
+is $c->name(), "FooBar::get_name hello";
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 27;
+BEGIN { use_ok 'director_primitives' }
+require_ok 'director_primitives';
+
+{
+ package PerlDerived;
+ use base 'director_primitives::Base';
+ sub NoParmsMethod {
+ }
+ sub BoolMethod { my($self, $x) = @_;
+ return $x;
+ }
+ sub IntMethod { my($self, $x) = @_;
+ return $x;
+ }
+ sub UIntMethod { my($self, $x) = @_;
+ return $x;
+ }
+ sub FloatMethod { my($self, $x) = @_;
+ return $x;
+ }
+ sub CharPtrMethod { my($self, $x) = @_;
+ return $x;
+ }
+ sub ConstCharPtrMethod { my($self, $x) = @_;
+ return $x;
+ }
+ sub EnumMethod { my($self, $x) = @_;
+ return $x;
+ }
+ sub ManyParmsMethod {
+ }
+}
+
+my $myCaller = director_primitives::Caller->new();
+isa_ok $myCaller, 'director_primitives::Caller';
+
+{
+ my $myBase = director_primitives::Base->new(100.0);
+ makeCalls($myCaller, $myBase);
+}
+{
+ my $myBase = director_primitives::Derived->new(200.0);
+ makeCalls($myCaller, $myBase);
+}
+{
+ my $myBase = PerlDerived->new(300.0);
+ makeCalls($myCaller, $myBase);
+}
+
+sub makeCalls { my($myCaller, $myBase) = @_;
+ $myCaller->set($myBase);
+ $myCaller->NoParmsMethodCall();
+ is $myCaller->BoolMethodCall(1), '1';
+ is $myCaller->BoolMethodCall(0), '';
+ is $myCaller->IntMethodCall(-123), -123;
+ is $myCaller->UIntMethodCall(123), 123;
+ is $myCaller->FloatMethodCall(-123 / 128), -0.9609375;
+ is $myCaller->CharPtrMethodCall("test string"), "test string";
+ is $myCaller->ConstCharPtrMethodCall("another string"), "another string";
+ is $myCaller->EnumMethodCall($director_primitives::HShadowHard), $director_primitives::HShadowHard;
+ $myCaller->ManyParmsMethodCall(1, -123, 123, 123.456, "test string", "another string", $director_primitives::HShadowHard);
+ $myCaller->NotOverriddenMethodCall();
+ $myCaller->reset();
+}
+
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 19;
+BEGIN { use_ok 'director_protected' }
+require_ok 'director_protected';
+
+{
+ package FooBar;
+ use base 'director_protected::Bar';
+ sub ping { 'FooBar::ping();' }
+}
+{
+ package FooBar2;
+ use base 'director_protected::Bar';
+ sub ping { 'FooBar2::ping();' }
+ sub pang { 'FooBar2::pang();' }
+}
+
+my $b = director_protected::Bar->new();
+isa_ok $b, 'director_protected::Bar';
+my $f = $b->create();
+my $fb = FooBar->new();
+isa_ok $fb, 'FooBar';
+my $fb2 = FooBar2->new();
+isa_ok $fb2, 'FooBar2';
+
+is $b->used(), "Foo::pang();Bar::pong();Foo::pong();Bar::ping();";
+eval { $f->used() };
+like $@, qr/protected member/;
+is $fb->used(), "Foo::pang();Bar::pong();Foo::pong();FooBar::ping();";
+is $fb2->used(), "FooBar2::pang();Bar::pong();Foo::pong();FooBar2::ping();";
+
+is $b->pong(), "Bar::pong();Foo::pong();Bar::ping();";
+is $f->pong(), "Bar::pong();Foo::pong();Bar::ping();";
+is $fb->pong(), "Bar::pong();Foo::pong();FooBar::ping();";
+is $fb2->pong(), "Bar::pong();Foo::pong();FooBar2::ping();";
+
+eval { $b->ping() };
+like $@, qr/protected member/;
+eval { $f->ping () };
+like $@, qr/protected member/;
+is $fb->ping(), 'FooBar::ping();';
+is $fb2->ping(), 'FooBar2::ping();';
+
+eval { $b->pang() };
+like $@, qr/protected member/;
+eval { $f->pang() };
+like $@, qr/protected member/;
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 5;
+BEGIN { use_ok 'director_string' }
+require_ok 'director_string';
+
+{
+ package B;
+ use base 'director_string::A';
+ our $in_first = 0;
+ sub get_first { my($self) = @_;
+ die "SUPER RESOLVE BAD" if $in_first;
+ local $in_first = 1;
+ return $self->SUPER::get_first() . " world!";
+ }
+ our $in_process_text = 0;
+ sub process_text { my($self, $string) = @_;
+ die "SUPER RESOLVE BAD" if $in_process_text;
+ local $in_process_text = 1;
+ $self->SUPER::process_text($string);
+ $self->{'smem'} = "hello";
+ }
+}
+
+my $b = B->new("hello");
+isa_ok $b, 'B';
+
+$b->get(0);
+
+is $b->get_first(), "hello world!";
+
+$b->call_process_func();
+
+is $b->{'smem'}, "hello";
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 3;
+BEGIN { use_ok 'director_unroll' };
+require_ok 'director_unroll';
+
+{
+ package MyFoo;
+ use base 'director_unroll::Foo';
+ sub ping { "MyFoo::ping()" }
+}
+
+$a = MyFoo->new();
+$b = director_unroll::Bar->new();
+$b->set($a);
+my $c = $b->get();
+is(${$a->this}, ${$c->this}, "unrolling");
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 9;
+BEGIN { use_ok 'director_wombat' }
+require_ok 'director_wombat';
+
+{
+ package director_wombat_Foo_integers_derived;
+ use base 'director_wombat::Foo_integers';
+ sub meth { my($self, $param) = @_;
+ return $param + 2;
+ }
+}
+{
+ package director_wombat_Foo_integers_derived_2;
+ use base 'director_wombat::Foo_integers';
+}
+{
+ package director_wombat_Bar_derived_1;
+ use base 'director_wombat::Bar';
+ sub foo_meth_ref { my($self, $foo_obj, $param) = @_;
+ die "foo_obj in foo_meth_ref is not director_wombat_Foo_integers_derived_2"
+ unless $foo_obj->isa('director_wombat_Foo_integers_derived_2');
+ }
+ sub foo_meth_ptr { my($self, $foo_obj, $param) = @_;
+ die "foo_obj in foo_meth_ptr is not director_wombat_Foo_integers_derived_2"
+ unless $foo_obj->isa('director_wombat_Foo_integers_derived_2');
+ }
+ sub foo_meth_val { my($self, $foo_obj, $param) = @_;
+ die "foo_obj in foo_meth_val is not director_wombat_Foo_integers_derived_2"
+ unless $foo_obj->isa('director_wombat_Foo_integers_derived_2');
+ }
+}
+
+my $b = director_wombat::Bar->new();
+isa_ok $b, 'director_wombat::Bar';
+my $a = $b->meth();
+is $a->meth(49), 49;
+
+$a = director_wombat_Foo_integers_derived->new();
+isa_ok $a, 'director_wombat_Foo_integers_derived';
+is $a->meth(62), 62 + 2;
+
+$a = director_wombat_Foo_integers_derived_2->new();
+isa_ok $a, 'director_wombat_Foo_integers_derived_2';
+is $a->meth(37), 37;
+
+$b = director_wombat_Bar_derived_1->new();
+isa_ok $b, 'director_wombat_Bar_derived_1';
+$b->foo_meth_ref($a, 0);
+$b->foo_meth_ptr($a, 1);
+$b->foo_meth_val($a, 2);
+
--- /dev/null
+#!/usr/bin/perl
+use strict;
+use warnings;
+use Test::More tests => 34;
+BEGIN { use_ok('li_carrays_cpp') }
+require_ok('li_carrays_cpp');
+
+# array_class
+{
+ my $length = 5;
+ my $xyArray = new li_carrays_cpp::XYArray($length);
+ for (my $i=0; $i<$length; $i++) {
+ my $xy = $xyArray->getitem($i);
+ $xy->{x} = $i*10;
+ $xy->{y} = $i*100;
+ $xyArray->setitem($i, $xy);
+ }
+ for (my $i=0; $i<$length; $i++) {
+ is($xyArray->getitem($i)->{x}, $i*10);
+ is($xyArray->getitem($i)->{y}, $i*100);
+ }
+}
+
+{
+ # global array variable
+ my $length = 3;
+ my $xyArrayPointer = $li_carrays_cpp::globalXYArray;
+ my $xyArray = li_carrays_cpp::XYArray::frompointer($xyArrayPointer);
+ for (my $i=0; $i<$length; $i++) {
+ my $xy = $xyArray->getitem($i);
+ $xy->{x} = $i*10;
+ $xy->{y} = $i*100;
+ $xyArray->setitem($i, $xy);
+ }
+ for (my $i=0; $i<$length; $i++) {
+ is($xyArray->getitem($i)->{x}, $i*10);
+ is($xyArray->getitem($i)->{y}, $i*100);
+ }
+}
+
+# array_functions
+{
+ my $length = 5;
+ my $abArray = li_carrays_cpp::new_ABArray($length);
+ for (my $i=0; $i<$length; $i++) {
+ my $ab = li_carrays_cpp::ABArray_getitem($abArray, $i);
+ $ab->{a} = $i*10;
+ $ab->{b} = $i*100;
+ li_carrays_cpp::ABArray_setitem($abArray, $i, $ab);
+ }
+ for (my $i=0; $i<$length; $i++) {
+ is(li_carrays_cpp::ABArray_getitem($abArray, $i)->{a}, $i*10);
+ is(li_carrays_cpp::ABArray_getitem($abArray, $i)->{b}, $i*100);
+ }
+ li_carrays_cpp::delete_ABArray($abArray);
+}
+
+{
+ # global array variable
+ my $length = 3;
+ my $abArray = $li_carrays_cpp::globalABArray;
+ for (my $i=0; $i<$length; $i++) {
+ my $ab = li_carrays_cpp::ABArray_getitem($abArray, $i);
+ $ab->{a} = $i*10;
+ $ab->{b} = $i*100;
+ li_carrays_cpp::ABArray_setitem($abArray, $i, $ab);
+ }
+ for (my $i=0; $i<$length; $i++) {
+ is(li_carrays_cpp::ABArray_getitem($abArray, $i)->{a}, $i*10);
+ is(li_carrays_cpp::ABArray_getitem($abArray, $i)->{b}, $i*100);
+ }
+}
#!/usr/bin/perl
use strict;
use warnings;
-use Test::More tests => 38;
+use Test::More tests => 34;
BEGIN { use_ok('li_carrays') }
require_ok('li_carrays');
{
# global array variable
- my $length = 5;
+ my $length = 3;
my $xyArrayPointer = $li_carrays::globalXYArray;
my $xyArray = li_carrays::XYArray::frompointer($xyArrayPointer);
for (my $i=0; $i<$length; $i++) {
--- /dev/null
+use strict;
+use warnings;
+use Test::More tests => 4;
+BEGIN { use_ok('li_cdata_carrays_cpp') }
+require_ok('li_cdata_carrays_cpp');
+
+my $ia = li_cdata_carrays_cpp::intArray->new(5);
+for (0..4) {
+ $ia->setitem($_, $_**2);
+}
+ok(1, "setitems");
+my $x = pack q{I5}, map $_**2, (0..4);
+my $y = li_cdata_carrays_cpp::cdata_int($ia->cast, 5);
+is($x, $y, "carrays");
use overload_simple;
use vars qw/$DOWARN/;
use strict;
-use Test::More tests => 75;
+use Test::More tests => 97;
pass("loaded");
is(overload_simple::int_object(0), 0, "int_object(0)");
is(overload_simple::int_object(undef), 999, "int_object(Spam*)");
is(overload_simple::int_object($s), 999, "int_object(Spam*)");
+
+# some of this section is duplication of above tests, but I want to see
+# parity with the coverage in wrapmacro_runme.pl.
+
+sub check {
+ my($args, $want) = @_;
+ my($s, $rslt) = defined $want ? ($want, "bar:$want") : ('*boom*', undef);
+ is(eval("overload_simple::Spam::bar($args)"), $rslt, "bar($args) => $s");
+}
+
+# normal use patterns
+check("11", 'int');
+check("11.0", 'double');
+check("'11'", 'char *');
+check("'11.0'", 'char *');
+check("-13", 'int');
+check("-13.0", 'double');
+check("'-13'", 'char *');
+check("'-13.0'", 'char *');
+
+check("' '", 'char *');
+check("' 11 '", 'char *');
+# TypeError explosions
+check("\\*STDIN", undef);
+check("[]", undef);
+check("{}", undef);
+check("sub {}", undef);
+
+# regression cases
+check("''", 'char *');
+check("' 11'", 'char *');
+check("' 11.0'", 'char *');
+check("' -11.0'", 'char *');
+check("\"11\x{0}\"", 'char *');
+check("\"\x{0}\"", 'char *');
+check("\"\x{9}11\x{0}this is not eleven.\"", 'char *');
+check("\"\x{9}11.0\x{0}this is also not eleven.\"", 'char *');
$t->{var_paramc} = $primitive_types::sct_paramc;
ok($t->v_check(), 'v_check');
-is($primitive_types::def_namet, "ho\0la", "namet");
+is($primitive_types::def_namet, "hola", "namet");
$t->{var_namet} = $primitive_types::def_namet;
is($t->{var_namet}, $primitive_types::def_namet, "namet");
-$t->{var_namet} = 'holac';
+$t->{var_namet} = 'hola';
-is($t->{var_namet}, 'holac', "namet");
+is($t->{var_namet}, 'hola', "namet");
$t->{var_namet} = 'hol';
#!/usr/bin/perl
use strict;
use warnings;
-use Test::More tests => 5;
+use Test::More tests => 27;
BEGIN { use_ok('wrapmacro') }
require_ok('wrapmacro');
is(wrapmacro::maximum($a,$b), 2);
is(wrapmacro::maximum($a/7.0, -$b*256), 256);
is(wrapmacro::GUINT16_SWAP_LE_BE_CONSTANT(1), 256);
+
+# some of this section is duplication of above tests, but I want to see
+# parity with the coverage in overload_simple_runme.pl.
+
+sub check {
+ my($args, $rslt) = @_;
+ my $s = defined $rslt ? $rslt : '*boom*';
+ is(eval("wrapmacro::maximum($args)"), $rslt, "max($args) => $s");
+}
+
+# normal use patterns
+check("0, 11", 11);
+check("0, 11.0", 11);
+check("0, '11'", 11);
+check("0, '11.0'", 11);
+check("11, -13", 11);
+check("11, -13.0", 11);
+{ local $TODO = 'strtoull() handles /^\s*-\d+$/ amusingly';
+check("11, '-13'", 11);
+}
+check("11, '-13.0'", 11);
+
+# TypeError explosions
+check("0, ' '", undef);
+check("0, ' 11 '", undef);
+check("0, \\*STDIN", undef);
+check("0, []", undef);
+check("0, {}", undef);
+check("0, sub {}", undef);
+
+# regression cases
+{ local $TODO = 'strtol() and friends have edge cases we should guard against';
+check("-11, ''", undef);
+check("0, ' 11'", undef);
+check("0, ' 11.0'", undef);
+check("-13, ' -11.0'", undef);
+check("0, \"11\x{0}\"", undef);
+check("0, \"\x{0}\"", undef);
+check("0, \"\x{9}11\x{0}this is not eleven.\"", undef);
+check("0, \"\x{9}11.0\x{0}this is also not eleven.\"", undef);
+}
LANGUAGE = php
SCRIPTSUFFIX = _runme.php
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
CPP_TEST_CASES += \
+ callback \
+ php_iterator \
php_namewarn_rename \
include $(srcdir)/../common.mk
missingtests: missingcpptests missingctests
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
+$(run_testcase)
+$(swig_and_compile_c)
+$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
+$(run_testcase)
# Runs the testcase. Tries to run testcase_runme.php, and if that's not
# found, runs testcase.php, except for multicpptests.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile PHP_SCRIPT=$(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) RUNTOOL="$(RUNTOOL)" php_run; \
- elif [ -f $(srcdir)/$(SCRIPTPREFIX)$*.php -a ! -f $(top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)/$*.list ]; then \
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile PHP_SCRIPT=$(srcdir)/$(SCRIPTPREFIX)$*.php RUNTOOL="$(RUNTOOL)" php_run; \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile PHP_SCRIPT=$(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) RUNTOOL='$(RUNTOOL)' php_run; \
+ elif [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*.php -a ! -f $(top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)/$*.list ]; then \
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile PHP_SCRIPT=$(SCRIPTDIR)/$(SCRIPTPREFIX)$*.php RUNTOOL='$(RUNTOOL)' php_run; \
fi
# Clean: remove the generated .php file
%.clean:
- @rm -f $*.php;
+ @rm -f $*.php php_$*.h
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile php_clean
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' php_clean
+ rm -f clientdata_prop_a.php clientdata_prop_b.php php_clientdata_prop_a.h php_clientdata_prop_b.h
+ rm -f import_stl_a.php import_stl_b.php php_import_stl_a.h php_import_stl_b.h
+ rm -f imports_a.php imports_b.php php_imports_a.h php_imports_b.h
+ rm -f mod_a.php mod_b.php php_mod_a.h php_mod_b.h
+ rm -f multi_import_a.php multi_import_b.php php_multi_import_a.h php_multi_import_b.h
+ rm -f packageoption_a.php packageoption_b.php packageoption_c.php php_packageoption_a.h php_packageoption_b.h php_packageoption_c.h
$as=new arraystruct();
$as->array_c="abc";
check::equal($as->array_c,"a",'$as->array_c=="a"');
+check::equal(isset($as->array_const_i),TRUE,'isset($as->array_const_i)');
check::done();
?>
+++ /dev/null
-<?php
-
-require "tests.php";
-require "autodoc.php";
-// In 2.0.6 and earlier, the constant was misnamed.
-if (gettype(autodoc::FUNC_CB_CALLBACK) !== 'resource') die("autodoc::FUNC_CB_CALLBACK not a resource\n");
-
-check::done();
-?>
--- /dev/null
+<?php
+
+require "tests.php";
+require "callback.php";
+// In 2.0.6 and earlier, the constant was misnamed.
+if (gettype(callback::FOO_I_Cb_Ptr) !== 'resource') die("callback::FOO_I_Cb_Ptr not a resource\n");
+
+check::done();
+?>
--- /dev/null
+<?php
+
+require "tests.php";
+require "cpp11_strongly_typed_enumerations.php";
+
+function enumCheck($actual, $expected) {
+ check::equal($actual, $expected, "Enum value mismatch");
+ return $expected + 1;
+}
+
+
+$val = 0;
+$val = enumCheck(Enum1_Val1, $val);
+$val = enumCheck(Enum1_Val2, $val);
+$val = enumCheck(Enum1_Val3, 13);
+$val = enumCheck(Enum1_Val4, $val);
+$val = enumCheck(Enum1_Val5a, 13);
+$val = enumCheck(Enum1_Val6a, $val);
+
+$val = 0;
+$val = enumCheck(Enum2_Val1, $val);
+$val = enumCheck(Enum2_Val2, $val);
+$val = enumCheck(Enum2_Val3, 23);
+$val = enumCheck(Enum2_Val4, $val);
+$val = enumCheck(Enum2_Val5b, 23);
+$val = enumCheck(Enum2_Val6b, $val);
+
+$val = 0;
+$val = enumCheck(Val1, $val);
+$val = enumCheck(Val2, $val);
+$val = enumCheck(Val3, 43);
+$val = enumCheck(Val4, $val);
+
+$val = 0;
+$val = enumCheck(Enum5_Val1, $val);
+$val = enumCheck(Enum5_Val2, $val);
+$val = enumCheck(Enum5_Val3, 53);
+$val = enumCheck(Enum5_Val4, $val);
+
+$val = 0;
+$val = enumCheck(Enum6_Val1, $val);
+$val = enumCheck(Enum6_Val2, $val);
+$val = enumCheck(Enum6_Val3, 63);
+$val = enumCheck(Enum6_Val4, $val);
+
+$val = 0;
+$val = enumCheck(Enum7td_Val1, $val);
+$val = enumCheck(Enum7td_Val2, $val);
+$val = enumCheck(Enum7td_Val3, 73);
+$val = enumCheck(Enum7td_Val4, $val);
+
+$val = 0;
+$val = enumCheck(Enum8_Val1, $val);
+$val = enumCheck(Enum8_Val2, $val);
+$val = enumCheck(Enum8_Val3, 83);
+$val = enumCheck(Enum8_Val4, $val);
+
+$val = 0;
+$val = enumCheck(Enum10_Val1, $val);
+$val = enumCheck(Enum10_Val2, $val);
+$val = enumCheck(Enum10_Val3, 103);
+$val = enumCheck(Enum10_Val4, $val);
+
+$val = 0;
+$val = enumCheck(Class1::Enum12_Val1, 1121);
+$val = enumCheck(Class1::Enum12_Val2, 1122);
+$val = enumCheck(Class1::Enum12_Val3, $val);
+$val = enumCheck(Class1::Enum12_Val4, $val);
+$val = enumCheck(Class1::Enum12_Val5c, 1121);
+$val = enumCheck(Class1::Enum12_Val6c, $val);
+
+$val = 0;
+$val = enumCheck(Class1::Val1, 1131);
+$val = enumCheck(Class1::Val2, 1132);
+$val = enumCheck(Class1::Val3, $val);
+$val = enumCheck(Class1::Val4, $val);
+$val = enumCheck(Class1::Val5d, 1131);
+$val = enumCheck(Class1::Val6d, $val);
+
+$val = 0;
+$val = enumCheck(Class1::Enum14_Val1, 1141);
+$val = enumCheck(Class1::Enum14_Val2, 1142);
+$val = enumCheck(Class1::Enum14_Val3, $val);
+$val = enumCheck(Class1::Enum14_Val4, $val);
+$val = enumCheck(Class1::Enum14_Val5e, 1141);
+$val = enumCheck(Class1::Enum14_Val6e, $val);
+
+# Requires nested class support to work
+#$val = 0;
+#$val = enumCheck(Class1::Struct1.Enum12_Val1, 3121);
+#$val = enumCheck(Class1::Struct1.Enum12_Val2, 3122);
+#$val = enumCheck(Class1::Struct1.Enum12_Val3, $val);
+#$val = enumCheck(Class1::Struct1.Enum12_Val4, $val);
+#$val = enumCheck(Class1::Struct1.Enum12_Val5f, 3121);
+#$val = enumCheck(Class1::Struct1.Enum12_Val6f, $val);
+#
+#$val = 0;
+#$val = enumCheck(Class1::Struct1.$val1, 3131);
+#$val = enumCheck(Class1::Struct1.$val2, 3132);
+#$val = enumCheck(Class1::Struct1.$val3, $val);
+#$val = enumCheck(Class1::Struct1.$val4, $val);
+#
+#$val = 0;
+#$val = enumCheck(Class1::Struct1.Enum14_Val1, 3141);
+#$val = enumCheck(Class1::Struct1.Enum14_Val2, 3142);
+#$val = enumCheck(Class1::Struct1.Enum14_Val3, $val);
+#$val = enumCheck(Class1::Struct1.Enum14_Val4, $val);
+#$val = enumCheck(Class1::Struct1.Enum14_Val5g, 3141);
+#$val = enumCheck(Class1::Struct1.Enum14_Val6g, $val);
+
+$val = 0;
+$val = enumCheck(Class2::Enum12_Val1, 2121);
+$val = enumCheck(Class2::Enum12_Val2, 2122);
+$val = enumCheck(Class2::Enum12_Val3, $val);
+$val = enumCheck(Class2::Enum12_Val4, $val);
+$val = enumCheck(Class2::Enum12_Val5h, 2121);
+$val = enumCheck(Class2::Enum12_Val6h, $val);
+
+$val = 0;
+$val = enumCheck(Class2::Val1, 2131);
+$val = enumCheck(Class2::Val2, 2132);
+$val = enumCheck(Class2::Val3, $val);
+$val = enumCheck(Class2::Val4, $val);
+$val = enumCheck(Class2::Val5i, 2131);
+$val = enumCheck(Class2::Val6i, $val);
+
+$val = 0;
+$val = enumCheck(Class2::Enum14_Val1, 2141);
+$val = enumCheck(Class2::Enum14_Val2, 2142);
+$val = enumCheck(Class2::Enum14_Val3, $val);
+$val = enumCheck(Class2::Enum14_Val4, $val);
+$val = enumCheck(Class2::Enum14_Val5j, 2141);
+$val = enumCheck(Class2::Enum14_Val6j, $val);
+
+# Requires nested class support to work
+#$val = 0;
+#$val = enumCheck(Class2::Struct1.Enum12_Val1, 4121);
+#$val = enumCheck(Class2::Struct1.Enum12_Val2, 4122);
+#$val = enumCheck(Class2::Struct1.Enum12_Val3, $val);
+#$val = enumCheck(Class2::Struct1.Enum12_Val4, $val);
+#$val = enumCheck(Class2::Struct1.Enum12_Val5k, 4121);
+#$val = enumCheck(Class2::Struct1.Enum12_Val6k, $val);
+#
+#$val = 0;
+#$val = enumCheck(Class2::Struct1.$val1, 4131);
+#$val = enumCheck(Class2::Struct1.$val2, 4132);
+#$val = enumCheck(Class2::Struct1.$val3, $val);
+#$val = enumCheck(Class2::Struct1.$val4, $val);
+#$val = enumCheck(Class2::Struct1.$val5l, 4131);
+#$val = enumCheck(Class2::Struct1.$val6l, $val);
+#
+#$val = 0;
+#$val = enumCheck(Class2::Struct1.Enum14_Val1, 4141);
+#$val = enumCheck(Class2::Struct1.Enum14_Val2, 4142);
+#$val = enumCheck(Class2::Struct1.Enum14_Val3, $val);
+#$val = enumCheck(Class2::Struct1.Enum14_Val4, $val);
+#$val = enumCheck(Class2::Struct1.Enum14_Val5m, 4141);
+#$val = enumCheck(Class2::Struct1.Enum14_Val6m, $val);
+
+$class1 = new Class1();
+enumCheck($class1->class1Test1(Enum1_Val5a), 13);
+enumCheck($class1->class1Test2(Class1::Enum12_Val5c), 1121);
+#enumCheck($class1.class1Test3(Class1::Struct1.Enum12_Val5f), 3121);
+
+enumCheck(globalTest1(Enum1_Val5a), 13);
+enumCheck(globalTest2(Class1::Enum12_Val5c), 1121);
+#enumCheck(globalTest3(Class1::Struct1.Enum12_Val5f), 3121);
+
+?>
require "director_exception.php";
// No new functions
-check::functions(array(foo_ping,foo_pong,launder,bar_ping,bar_pong,bar_pang));
+check::functions(array(foo_ping,foo_pong,launder,bar_ping,bar_pong,bar_pang,returnalltypes_return_int,returnalltypes_return_double,returnalltypes_return_const_char_star,returnalltypes_return_std_string,returnalltypes_return_bar,returnalltypes_call_int,returnalltypes_call_double,returnalltypes_call_const_char_star,returnalltypes_call_std_string,returnalltypes_call_bar,is_python_builtin));
// No new classes
-check::classes(array(director_exception,Foo,Exception1,Exception2,Base,Bar));
+check::classes(array(director_exception,Foo,Exception1,Exception2,Base,Bar,ReturnAllTypes));
// now new vars
check::globals(array());
} catch (Exception1 $e1) {
}
+// Check that we can throw exceptions from director methods (this didn't used
+// to work in all cases, as the exception gets "set" in PHP and the method
+// then returns PHP NULL, which the directorout template may fail to convert.
+
+class Bad extends ReturnAllTypes {
+ function return_int() { throw new Exception("bad int"); }
+ function return_double() { throw new Exception("bad double"); }
+ function return_const_char_star() { throw new Exception("bad const_char_star"); }
+ function return_std_string() { throw new Exception("bad std_string"); }
+ function return_Bar() { throw new Exception("bad Bar"); }
+}
+
+$bad = new Bad();
+
+try {
+ $bad->call_int();
+ check::fail("Exception wasn't propagated from Bad::return_int()");
+} catch (Exception $e) {
+ check::equal($e->getMessage(), "bad int", "propagated exception incorrect");
+}
+
+try {
+ $bad->call_double();
+ check::fail("Exception wasn't propagated from Bad::return_double()");
+} catch (Exception $e) {
+ check::equal($e->getMessage(), "bad double", "propagated exception incorrect");
+}
+
+try {
+ $bad->call_const_char_star();
+ check::fail("Exception wasn't propagated from Bad::return_const_char_star()");
+} catch (Exception $e) {
+ check::equal($e->getMessage(), "bad const_char_star", "propagated exception incorrect");
+}
+
+try {
+ $bad->call_std_string();
+ check::fail("Exception wasn't propagated from Bad::return_std_string()");
+} catch (Exception $e) {
+ check::equal($e->getMessage(), "bad std_string", "propagated exception incorrect");
+}
+
+try {
+ $bad->call_Bar();
+ check::fail("Exception wasn't propagated from Bad::return_Bar()");
+} catch (Exception $e) {
+ check::equal($e->getMessage(), "bad Bar", "propagated exception incorrect");
+}
+
check::done();
?>
--- /dev/null
+<?php
+
+require "tests.php";
+require "director_pass_by_value.php";
+
+$passByVal = null;
+
+class director_pass_by_value_Derived extends DirectorPassByValueAbstractBase {
+ function virtualMethod($b) {
+ global $passByVal;
+ $passByVal = $b;
+ }
+}
+
+# bug was the passByVal global object was destroyed after the call to virtualMethod had finished.
+$caller = new Caller();
+$caller->call_virtualMethod(new director_pass_by_value_Derived());
+$ret = $passByVal->getVal();
+if ($ret != 0x12345678) {
+ check::fail("Bad return value, got " . dechex($ret));
+}
+
+check::done();
+?>
require "tests.php";
require "director_protected.php";
-// No new functions
-check::functions(array(foo_pong,foo_s,foo_q,foo_ping,foo_pang,foo_used,bar_create,bar_pong,bar_used,bar_ping,bar_pang,a_draw,b_draw));
-// No new classes
+check::functions(array(foo_pong,foo_s,foo_q,foo_ping,foo_pang,foo_used,foo_cheer,bar_create,bar_callping,bar_callcheer,bar_cheer,bar_pong,bar_used,bar_ping,bar_pang,a_draw,b_draw));
check::classes(array(Foo,Bar,PrivateFoo,A,B,AA,BB));
-// now new vars
check::globals(array(bar_a));
class FooBar extends Bar {
require "tests.php";
require "director_thread.php";
+# Fails in a ZTS-build of PHP - see: https://github.com/swig/swig/pull/155
+exit(0);
+
// No new functions
check::functions(array(millisecondsleep,foo_stop,foo_run,foo_do_foo));
// No new classes
require "tests.php";
require "exception_order.php";
-check::functions(array(a_foo,a_bar,a_foobar,a_barfoo));
+check::functions(array(a_foo,a_bar,a_foobar,a_barfoo,is_python_builtin));
check::classes(array(A,E1,E2,E3,exception_order,ET_i,ET_d));
check::globals(array(efoovar,foovar,cfoovar,a_sfoovar,a_foovar,a_efoovar));
require "import_nomodule.php";
// No new functions
-check::functions(array(create_foo,delete_foo,test1));
+check::functions(array(create_foo,delete_foo,test1,is_python_builtin));
// No new classes
check::classes(array(import_nomodule,Bar));
// now new vars
--- /dev/null
+<?php
+require "tests.php";
+require "li_carrays_cpp.php";
+
+// Check functions.
+check::functions(array(new_intarray,delete_intarray,intarray_getitem,intarray_setitem,doublearray_getitem,doublearray_setitem,doublearray_cast,doublearray_frompointer,xyarray_getitem,xyarray_setitem,xyarray_cast,xyarray_frompointer,delete_abarray,abarray_getitem,abarray_setitem));
+
+// Check classes.
+// NB An "li_carrays_cpp" class is created as a mock namespace.
+check::classes(array(li_carrays_cpp,doubleArray,AB,XY,XYArray));
+
+// Check global variables.
+check::globals(array(xy_x,xy_y,globalxyarray,ab_a,ab_b,globalabarray));
+
+$d = new doubleArray(10);
+
+$d->setitem(0, 7);
+$d->setitem(5, $d->getitem(0) + 3);
+check::equal($d->getitem(0) + $d->getitem(5), 17., "7+10==17");
+
+check::done();
+?>
--- /dev/null
+<?php
+
+require "tests.php";
+require "php_iterator.php";
+
+check::functions(array(myiterator_rewind,myiterator_key,myiterator_current,myiterator_next,myiterator_valid));
+check::classes(array(MyIterator));
+// No new global variables.
+check::globals(array());
+
+$s = '';
+foreach (new MyIterator(1, 6) as $i) {
+ $s .= $i;
+}
+check::equal($s, '12345', 'Simple iteration failed');
+
+$s = '';
+foreach (new MyIterator(2, 5) as $k => $v) {
+ $s .= "($k=>$v)";
+}
+check::equal($s, '(0=>2)(1=>3)(2=>4)', 'Simple iteration failed');
+
+check::done();
+?>
require "threads_exception.php";
// Check functions
-check::functions(array(test_simple,test_message,test_hosed,test_unknown,test_multi));
+check::functions(array(test_simple,test_message,test_hosed,test_unknown,test_multi,is_python_builtin));
// Check classes.
-check::classes(array(Exc,Test));
+check::classes(array(Exc,Test,threads_exception));
// Chek globals.
check::globals(array(exc_code,exc_msg));
--- /dev/null
+/* php_iterator.i - PHP-specific testcase for wrapping to a PHP Iterator */
+%module php_iterator
+
+%typemap("phpinterfaces") MyIterator "Iterator";
+
+%inline %{
+
+class MyIterator {
+ int i, from, to;
+public:
+ MyIterator(int from_, int to_)
+ : i(from_), from(from_), to(to_) { }
+ void rewind() { i = from; }
+ bool valid() const { return i != to; }
+ int key() const { return i - from; }
+ int current() const { return i; }
+ void next() { ++i; }
+};
+
+%}
%warnfilter(SWIGWARN_PARSE_KEYWORD) Hello::empty();
#endif
+%ignore prev::operator++;
+%extend prev {
+ void next() { ++(*self); }
+}
+
%inline %{
int Exception() { return 13; }
void empty() {}
};
+ struct prev {
+ prev & operator++() { return *this; }
+ prev operator++(int) { return *this; }
+ };
+
%}
LANGUAGE = pike
PIKE = pike
SCRIPTSUFFIX = _runme.pike
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
# none!
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.pike appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(PIKE) $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(PIKE) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
# Clean: remove the generated .pike file
@rm -f $*.pike;
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile pike_clean
-
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' pike_clean
#pragma SWIG nowarn=890 /* lots of Go name conflicts */
#pragma SWIG nowarn=206 /* Unexpected tokens after #endif directive. */
+%{
+#if defined(__clang__)
+//Suppress: warning: use of logical '&&' with constant operand [-Wconstant-logical-operand]
+#pragma clang diagnostic ignored "-Wconstant-logical-operand"
+#endif
+%}
+
/* check __cplusplus case */
%header
%{
#define A7 13 & 14
#define A8 15 | 16
#define A9 17 ^ 18
-#define A10 19 && 20
-#define A11 21 || 21
+#define A10 1 && 0
+#define A11 1 || 0
#define A12 ~22
#define A13 !23
return tnt.val;
}
%}
+
+/* Null directive */
+# /* comment 1 */
+# // comment 2
+# /** comment 3 */
+# /* comment 4 */ /*comment 5*/
+# /** comment 6
+#
+# more comment 6 */
+#
+#
+#
+int methodX(int x);
+%{
+int methodX(int x) { return x+100; }
+%}
+
%module preproc_constants
+%{
+#if defined(__clang__)
+//Suppress: warning: use of logical '&&' with constant operand [-Wconstant-logical-operand]
+#pragma clang diagnostic ignored "-Wconstant-logical-operand"
+#endif
+%}
+
// Note: C types are slightly different to C++ types as (a && b) is int in C and bool in C++
// Simple constants
/// constant assignment in enum
#if defined(SWIGCSHARP)
%csconstvalue("1<<2") kValue;
+#elif defined(SWIGD)
+%dconstvalue("1<<2") kValue;
#endif
%{
enum MyEnum {
kValue = BIT(2)
};
+
void another_macro_checking(void) {
struct Defined d;
d.defined = 10;
+ (void)d;
thing(10);
stuff(10);
bumpf(10);
}
%}
+
+/* Check that unknown preprocessor directives are ignored inside an inactive
+ * conditional (github issue #394).
+ */
+#ifdef APPLE_OPENGL
+# import <OpenGLES/ES1/gl.h>
+#endif
+#ifdef AAA
+# define B
+#else
+# wibble wibble
+#endif
+#if 0
+# wobble wobble
+#endif
// Test __LINE__ and __FILE__ (don't change line numbering in here else runtime tests will need modifying)
#define MYLINE __LINE__
-#define MYLINE_ADJUSTED __LINE__ + 100
+#define MYLINE_ADJUSTED __LINE__ + 100
#define MYFILE __FILE__
#define MYFILE_ADJUSTED __FILE__ ".bak"
int num; \
};
#endif
-KLASS(SillyMultipleMacroStruct)
+KLASS(SillyMulMacroStruc)
%}
%inline %{
// Massive primitive datatype test.
%module(directors="1") primitive_types
+#if defined(SWIGSCILAB)
+%warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) ovr_str;
+%warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) ovr_val;
+%rename(TestDir) TestDirector;
+#endif
+
%{
#if defined(_MSC_VER)
#pragma warning(disable: 4290) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
char* const def_pchar = (char *const)"hello";
const char* const def_pcharc = "hija";
- const namet def_namet = {'h','o',0, 'l','a'};
+ const namet def_namet = {'h','o','l','a', 0};
extern namet gbl_namet;
if (a.str() != b.str()) {
std::cout << "failing in pfx""_""name : "
<< a.str() << " : " << b.str() << std::endl;
- // return 0;
}
}
%enddef
+/* check variables (arrays can't be compared so compare as strings) */
+%define var_array_check(type, pfx, name)
+ std::ostringstream a; std::ostringstream b;
+ a << pfx##_##name;
+ b << def_##name;
+ if (a.str() != b.str()) {
+ std::cout << "failing in pfx""_""name : "
+ << a.str() << " : " << b.str() << std::endl;
+ }
+%enddef
/* check a function call */
%define call_check(type, pfx, name)
if (a.str() != b.str()) {
std::cout << "failing in pfx""_""name : "
<< a.str() << " : " << b.str() << std::endl;
- // return 0;
}
}
%enddef
%define ovr_decl(type, pfx, name)
virtual int pfx##_##val(type x) { return 1; }
virtual int pfx##_##ref(const type& x) { return 1; }
+ virtual const char* pfx##_##str(type x) { return "name"; }
%enddef
+/* checking size_t and ptrdiff_t typemaps */
+%begin %{
+// Must be defined before Python.h is included, since this may indirectly include stdint.h
+#define __STDC_LIMIT_MACROS
+%}
+%include "stdint.i"
+%inline {
+ size_t get_size_min() { return 0; }
+ size_t get_size_max() { return SIZE_MAX; }
+ ptrdiff_t get_ptrdiff_min() { return PTRDIFF_MIN; }
+ ptrdiff_t get_ptrdiff_max() { return PTRDIFF_MAX; }
+
+ size_t size_echo (size_t val) { return val; }
+ ptrdiff_t ptrdiff_echo(ptrdiff_t val) { return val; }
+}
%inline {
struct Foo
{
%test_prim_types_stc(var_check, stc)
%test_prim_types(var_check, var)
- var_check(namet, var, namet);
+ var_array_check(namet, var, namet);
return 1;
}
{
%test_prim_types(var_check, cct)
%test_prim_types(var_check, var)
- var_check(namet, var, namet);
+ var_array_check(namet, var, namet);
return 1;
}
LANGUAGE = python
PYTHON = $(PYBIN)
+PEP8 = @PEP8@
+PEP8_FLAGS = --ignore=E30,E402,E501,E731,W291,W391
#*_runme.py for Python 2.x, *_runme3.py for Python 3.x
PY2SCRIPTSUFFIX = _runme.py
PY3SCRIPTSUFFIX = _runme3.py
+PY2TO3 = 2to3 -x import
ifeq (,$(PY3))
SCRIPTSUFFIX = $(PY2SCRIPTSUFFIX)
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
-
-PY2TO3 = 2to3 -x import
-
-
CPP_TEST_CASES += \
argcargvtest \
callback \
inout \
inplaceadd \
input \
- kwargs_feature \
li_cstring \
li_cwstring \
li_factory \
primitive_types \
python_abstractbase \
python_append \
+ python_destructor_exception \
python_director \
+ python_docstring \
python_nondynamic \
python_overload_simple_cast \
+ python_pythoncode \
python_richcompare \
+ python_strict_unicode \
simutry \
std_containers \
swigobject \
include $(srcdir)/../common.mk
-BUILTIN_BROKEN = \
- default_constructor.cpptest \
- director_exception.cpptest \
- exception_order.cpptest \
- li_std_string_extra.cpptest \
- li_std_wstring.cpptest \
- python_abstractbase.cpptest \
- threads_exception.cpptest
-
-BUILTIN_NOT_BROKEN = $(filter-out $(BUILTIN_BROKEN),$(NOT_BROKEN_TEST_CASES))
-
-builtin-check : $(BUILTIN_NOT_BROKEN)
-
# Overridden variables here
-LIBS = -L.
+SCRIPTDIR = .
+LIBS = -L.
VALGRIND_OPT += --suppressions=pythonswig.supp
# Custom tests - tests with additional commandline options
# none!
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
+$(convert_testcase)
$(setup)
+$(swig_and_compile_cpp)
+ $(check_pep8)
$(run_testcase)
%.ctest:
+$(convert_testcase)
$(setup)
+$(swig_and_compile_c)
+ $(check_pep8)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
+$(convert_testcase)
$(setup)
+$(swig_and_compile_multi_cpp)
+ $(check_pep8_multi_cpp)
$(run_testcase)
-# Call 2to3 to generate Python 3.x test from the Python 2.x's *_runme.py file
-%$(PY3SCRIPTSUFFIX): %$(PY2SCRIPTSUFFIX)
- cp $< $@
- $(PY2TO3) -w $@ >/dev/null 2>&1
-
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.py (or _runme3.py for Python 3) appended after the testcase name.
-run_python = env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PYTHONPATH=.:$(srcdir):$$PYTHONPATH $(RUNTOOL) $(PYTHON) $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX)
+py_runme = $(SCRIPTPREFIX)$*$(SCRIPTSUFFIX)
+py2_runme = $(SCRIPTPREFIX)$*$(PY2SCRIPTSUFFIX)
+py3_runme = $(SCRIPTPREFIX)$*$(PY3SCRIPTSUFFIX)
-py2_runme = $(srcdir)/$(SCRIPTPREFIX)$*$(PY2SCRIPTSUFFIX)
-py3_runme = $(srcdir)/$(SCRIPTPREFIX)$*$(PY3SCRIPTSUFFIX)
+ifneq (,$(PEP8))
+check_pep8 = $(COMPILETOOL) $(PEP8) $(PEP8_FLAGS) $(SCRIPTPREFIX)$*.py
+
+check_pep8_multi_cpp = \
+ for f in `cat $(top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)/$*.list` ; do \
+ $(COMPILETOOL) $(PEP8) $(PEP8_FLAGS) $$f.py; \
+ done
+endif
+
+run_python = env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PYTHONPATH=.:$(srcdir):$$PYTHONPATH $(RUNTOOL) $(PYTHON) $(py_runme)
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ if [ -f $(SCRIPTDIR)/$(py_runme) ]; then \
$(run_python);\
fi
-ifeq (,$(PY3))
+# No copying/conversion needed for in-source-tree Python 2 scripts
+ifeq ($(SCRIPTDIR)|$(SCRIPTSUFFIX),$(srcdir)|$(PY2SCRIPTSUFFIX))
convert_testcase =
else
+
convert_testcase = \
- if [ -f $(py2_runme) ]; then \
- $(MAKE) -f $(srcdir)/Makefile $(py3_runme); \
+ if [ -f $(srcdir)/$(py2_runme) ]; then \
+ $(MAKE) $(SCRIPTDIR)/$(py_runme); \
fi
+
+$(SCRIPTDIR)/$(SCRIPTPREFIX)%$(SCRIPTSUFFIX): $(srcdir)/$(SCRIPTPREFIX)%$(PY2SCRIPTSUFFIX)
+ test x$< = x$@ || cp $< $@ || exit 1
+ test x$(PY3) = x || $(PY2TO3) -w $@ >/dev/null 2>&1 || exit 1
+
endif
# Clean: remove the generated .py file
+# We only remove the _runme3.py if it is generated by 2to3 from a _runme.py.
%.clean:
- @rm -f $*.py;
- @#We only remove the _runme3.py if it is generated by 2to3 from a _runme.py.
- @if [ -f $(py2_runme) ]; then rm -f $(py3_runme) $(py3_runme).bak; fi
+ @rm -f $*.py
+ @if test -f $(srcdir)/$(py2_runme); then rm -f $(SCRIPTDIR)/$(py3_runme) $(SCRIPTDIR)/$(py3_runme).bak; fi
+ @if test "x$(SCRIPTDIR)" != "x$(srcdir)"; then rm -f $(SCRIPTDIR)/$(py2_runme); fi
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile python_clean
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' python_clean
rm -f hugemod.h hugemod_a.i hugemod_b.i hugemod_a.py hugemod_b.py hugemod_runme.py
rm -f clientdata_prop_a.py clientdata_prop_b.py import_stl_a.py import_stl_b.py
rm -f imports_a.py imports_b.py mod_a.py mod_b.py multi_import_a.py
cvsignore:
@echo '*wrap* *.pyc *.so *.dll *.exp *.lib'
@echo Makefile
- @for i in ${CPP_TEST_CASES} ${C_TEST_CASES}; do echo $$i.py; done
- @for i in ${CPP_TEST_CASES} ${C_TEST_CASES}; do if grep -q $${i}_runme.py CVS/Entries ; then echo $${i}_runme.py; fi; done
- @echo clientdata_prop_a.py
- @echo clientdata_prop_b.py
- @echo imports_a.py
- @echo imports_b.py
+ @for i in ${CPP_TEST_CASES} ${C_TEST_CASES}; do echo $$i.py; done
+ @for i in ${CPP_TEST_CASES} ${C_TEST_CASES}; do if grep -q $${i}_runme.py CVS/Entries ; then echo $${i}_runme.py; fi; done
+ @echo clientdata_prop_a.py
+ @echo clientdata_prop_b.py
+ @echo imports_a.py
+ @echo imports_b.py
@echo mod_a.py mod_b.py
@echo hugemod.h hugemod_a.i hugemod_b.i hugemod_a.py hugemod_b.py hugemod_runme.py
@echo template_typedef_import.py
hugemod_runme = hugemod$(SCRIPTPREFIX)
hugemod:
- perl hugemod.pl $(hugemod_runme)
+ perl hugemod.pl $(hugemod_runme)
$(MAKE) hugemod_a.cpptest
$(MAKE) hugemod_b.cpptest
sh -c "time $(PYTHON) $(hugemod_runme)"
sh -c "time $(PYTHON) $(hugemod_runme)"
-
d = abstract_access.D()
if d.do_x() != 1:
- raise RuntimeError
-
+ raise RuntimeError
-from abstract_typedef2 import *
+from abstract_typedef2 import *
a = A_UF()
-
-
-
-
-
-from abstract_typedef import *
+from abstract_typedef import *
e = Engine()
a = A()
-
-
-if a.write(e) != 1:
- raise RuntimeError
-
+if a.write(e) != 1:
+ raise RuntimeError
from argcargvtest import *
-largs=['hi','hola','hello']
+largs = ['hi', 'hola', 'hello']
if mainc(largs) != 3:
- raise RuntimeError("bad main typemap")
+ raise RuntimeError("bad main typemap")
-targs=('hi','hola')
-if mainv(targs,1) != 'hola':
- print(mainv(targs,1))
- raise RuntimeError("bad main typemap")
+targs = ('hi', 'hola')
+if mainv(targs, 1) != 'hola':
+ print(mainv(targs, 1))
+ raise RuntimeError("bad main typemap")
-targs=('hi', 'hola')
-if mainv(targs,1) != 'hola':
- raise RuntimeError("bad main typemap")
+targs = ('hi', 'hola')
+if mainv(targs, 1) != 'hola':
+ raise RuntimeError("bad main typemap")
try:
- error = 0
- mainv('hello',1)
- error = 1
+ error = 0
+ mainv('hello', 1)
+ error = 1
except TypeError:
- pass
+ pass
if error:
- raise RuntimeError("bad main typemap")
-
+ raise RuntimeError("bad main typemap")
initializeApp(largs)
f = Foo()
f.data = cvar.global_data
-for i in range(0,8):
- if get_value(f.data,i) != get_value(cvar.global_data,i):
+for i in range(0, 8):
+ if get_value(f.data, i) != get_value(cvar.global_data, i):
raise RuntimeError, "Bad array assignment"
-for i in range(0,8):
- set_value(f.data,i,-i)
+for i in range(0, 8):
+ set_value(f.data, i, -i)
cvar.global_data = f.data
-for i in range(0,8):
- if get_value(f.data,i) != get_value(cvar.global_data,i):
+for i in range(0, 8):
+ if get_value(f.data, i) != get_value(cvar.global_data, i):
raise RuntimeError, "Bad array assignment"
-
-
-
arrays_global.cvar.array_i = arrays_global.cvar.array_const_i
-from arrays_global import *
+from arrays_global import *
BeginString_FIX44a
cvar.BeginString_FIX44b
BeginString_FIX44c
cvar.BeginString_FIX44d
cvar.BeginString_FIX44d
-cvar.BeginString_FIX44b ="12"'\0'"45"
+cvar.BeginString_FIX44b = "12"'\0'"45"
cvar.BeginString_FIX44b
cvar.BeginString_FIX44d
cvar.BeginString_FIX44e
BeginString_FIX44f
-test_a("hello","hi","chello","chi")
+test_a("hello", "hi", "chello", "chi")
-test_b("1234567","hi")
+test_b("1234567", "hi")
from autodoc import *
import sys
-def check(got, expected):
- if expected != got:
- raise RuntimeError("\n" + "Expected: [" + str(expected) + "]\n" + "Got : [" + str(got) + "]")
-check(A.__doc__, "Proxy of C++ A class")
-check(A.funk.__doc__, "just a string")
-check(A.func0.__doc__, "func0(self, arg2, hello) -> int")
-check(A.func1.__doc__, "func1(A self, short arg2, Tuple hello) -> int")
-check(A.func2.__doc__, "\n"
-" func2(self, arg2, hello) -> int\n"
-"\n"
-" Parameters:\n"
-" arg2: short\n"
-" hello: int tuple[2]\n"
-"\n"
-" "
-)
-check(A.func3.__doc__, "\n"
-" func3(A self, short arg2, Tuple hello) -> int\n"
-"\n"
-" Parameters:\n"
-" arg2: short\n"
-" hello: int tuple[2]\n"
-"\n"
-" "
-)
+def check(got, expected, expected_builtin=None, skip=False):
+ if not skip:
+ expect = expected
+ if is_python_builtin() and expected_builtin != None:
+ expect = expected_builtin
+ if expect != got:
+ raise RuntimeError(
+ "\n" + "Expected: [" + str(expect) + "]\n" + "Got : [" + str(got) + "]")
-check(A.func0default.__doc__, "\n"
-" func0default(self, e, arg3, hello, f=2) -> int\n"
-" func0default(self, e, arg3, hello) -> int\n"
-" "
-)
-check(A.func1default.__doc__, "\n"
-" func1default(A self, A e, short arg3, Tuple hello, double f=2) -> int\n"
-" func1default(A self, A e, short arg3, Tuple hello) -> int\n"
-" "
-)
-check(A.func2default.__doc__, "\n"
-" func2default(self, e, arg3, hello, f=2) -> int\n"
-"\n"
-" Parameters:\n"
-" e: A *\n"
-" arg3: short\n"
-" hello: int tuple[2]\n"
-" f: double\n"
-"\n"
-" func2default(self, e, arg3, hello) -> int\n"
-"\n"
-" Parameters:\n"
-" e: A *\n"
-" arg3: short\n"
-" hello: int tuple[2]\n"
-"\n"
-" "
-)
-check(A.func3default.__doc__, "\n"
-" func3default(A self, A e, short arg3, Tuple hello, double f=2) -> int\n"
-"\n"
-" Parameters:\n"
-" e: A *\n"
-" arg3: short\n"
-" hello: int tuple[2]\n"
-" f: double\n"
-"\n"
-" func3default(A self, A e, short arg3, Tuple hello) -> int\n"
-"\n"
-" Parameters:\n"
-" e: A *\n"
-" arg3: short\n"
-" hello: int tuple[2]\n"
-"\n"
-" "
-)
-check(A.func0static.__doc__, "\n"
-" func0static(e, arg2, hello, f=2) -> int\n"
-" func0static(e, arg2, hello) -> int\n"
-" "
-)
-check(A.func1static.__doc__, "\n"
-" func1static(A e, short arg2, Tuple hello, double f=2) -> int\n"
-" func1static(A e, short arg2, Tuple hello) -> int\n"
-" "
-)
-check(A.func2static.__doc__, "\n"
-" func2static(e, arg2, hello, f=2) -> int\n"
-"\n"
-" Parameters:\n"
-" e: A *\n"
-" arg2: short\n"
-" hello: int tuple[2]\n"
-" f: double\n"
-"\n"
-" func2static(e, arg2, hello) -> int\n"
-"\n"
-" Parameters:\n"
-" e: A *\n"
-" arg2: short\n"
-" hello: int tuple[2]\n"
-"\n"
-" "
-)
-check(A.func3static.__doc__, "\n"
-" func3static(A e, short arg2, Tuple hello, double f=2) -> int\n"
-"\n"
-" Parameters:\n"
-" e: A *\n"
-" arg2: short\n"
-" hello: int tuple[2]\n"
-" f: double\n"
-"\n"
-" func3static(A e, short arg2, Tuple hello) -> int\n"
-"\n"
-" Parameters:\n"
-" e: A *\n"
-" arg2: short\n"
-" hello: int tuple[2]\n"
-"\n"
-" "
-)
+def is_new_style_class(cls):
+ return hasattr(cls, "__class__")
+
+if not is_new_style_class(A):
+ # Missing static methods make this hard to test... skip if -classic is
+ # used!
+ sys.exit(0)
+
+# skip builtin check - the autodoc is missing, but it probably should not be
+skip = True
+
+check(A.__doc__, "Proxy of C++ A class.", "::A")
+check(A.funk.__doc__, "just a string.")
+check(A.func0.__doc__,
+ "func0(self, arg2, hello) -> int",
+ "func0(arg2, hello) -> int")
+check(A.func1.__doc__,
+ "func1(A self, short arg2, Tuple hello) -> int",
+ "func1(short arg2, Tuple hello) -> int")
+check(A.func2.__doc__,
+ "\n"
+ " func2(self, arg2, hello) -> int\n"
+ "\n"
+ " Parameters\n"
+ " ----------\n"
+ " arg2: short\n"
+ " hello: int tuple[2]\n"
+ "\n"
+ " ",
+ "\n"
+ "func2(arg2, hello) -> int\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "arg2: short\n"
+ "hello: int tuple[2]\n"
+ "\n"
+ ""
+ )
+check(A.func3.__doc__,
+ "\n"
+ " func3(A self, short arg2, Tuple hello) -> int\n"
+ "\n"
+ " Parameters\n"
+ " ----------\n"
+ " arg2: short\n"
+ " hello: int tuple[2]\n"
+ "\n"
+ " ",
+ "\n"
+ "func3(short arg2, Tuple hello) -> int\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "arg2: short\n"
+ "hello: int tuple[2]\n"
+ "\n"
+ ""
+ )
+
+check(A.func0default.__doc__,
+ "\n"
+ " func0default(self, e, arg3, hello, f=2) -> int\n"
+ " func0default(self, e, arg3, hello) -> int\n"
+ " ",
+ "\n"
+ "func0default(e, arg3, hello, f=2) -> int\n"
+ "func0default(e, arg3, hello) -> int\n"
+ ""
+ )
+check(A.func1default.__doc__,
+ "\n"
+ " func1default(A self, A e, short arg3, Tuple hello, double f=2) -> int\n"
+ " func1default(A self, A e, short arg3, Tuple hello) -> int\n"
+ " ",
+ "\n"
+ "func1default(A e, short arg3, Tuple hello, double f=2) -> int\n"
+ "func1default(A e, short arg3, Tuple hello) -> int\n"
+ ""
+ )
+check(A.func2default.__doc__,
+ "\n"
+ " func2default(self, e, arg3, hello, f=2) -> int\n"
+ "\n"
+ " Parameters\n"
+ " ----------\n"
+ " e: A *\n"
+ " arg3: short\n"
+ " hello: int tuple[2]\n"
+ " f: double\n"
+ "\n"
+ " func2default(self, e, arg3, hello) -> int\n"
+ "\n"
+ " Parameters\n"
+ " ----------\n"
+ " e: A *\n"
+ " arg3: short\n"
+ " hello: int tuple[2]\n"
+ "\n"
+ " ",
+ "\n"
+ "func2default(e, arg3, hello, f=2) -> int\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "e: A *\n"
+ "arg3: short\n"
+ "hello: int tuple[2]\n"
+ "f: double\n"
+ "\n"
+ "func2default(e, arg3, hello) -> int\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "e: A *\n"
+ "arg3: short\n"
+ "hello: int tuple[2]\n"
+ "\n"
+ ""
+ )
+check(A.func3default.__doc__,
+ "\n"
+ " func3default(A self, A e, short arg3, Tuple hello, double f=2) -> int\n"
+ "\n"
+ " Parameters\n"
+ " ----------\n"
+ " e: A *\n"
+ " arg3: short\n"
+ " hello: int tuple[2]\n"
+ " f: double\n"
+ "\n"
+ " func3default(A self, A e, short arg3, Tuple hello) -> int\n"
+ "\n"
+ " Parameters\n"
+ " ----------\n"
+ " e: A *\n"
+ " arg3: short\n"
+ " hello: int tuple[2]\n"
+ "\n"
+ " ",
+ "\n"
+ "func3default(A e, short arg3, Tuple hello, double f=2) -> int\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "e: A *\n"
+ "arg3: short\n"
+ "hello: int tuple[2]\n"
+ "f: double\n"
+ "\n"
+ "func3default(A e, short arg3, Tuple hello) -> int\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "e: A *\n"
+ "arg3: short\n"
+ "hello: int tuple[2]\n"
+ "\n"
+ ""
+ )
+
+check(A.func0static.__doc__,
+ "\n"
+ " func0static(e, arg2, hello, f=2) -> int\n"
+ " func0static(e, arg2, hello) -> int\n"
+ " ",
+ "\n"
+ "func0static(e, arg2, hello, f=2) -> int\n"
+ "func0static(e, arg2, hello) -> int\n"
+ ""
+ )
+check(A.func1static.__doc__,
+ "\n"
+ " func1static(A e, short arg2, Tuple hello, double f=2) -> int\n"
+ " func1static(A e, short arg2, Tuple hello) -> int\n"
+ " ",
+ "\n"
+ "func1static(A e, short arg2, Tuple hello, double f=2) -> int\n"
+ "func1static(A e, short arg2, Tuple hello) -> int\n"
+ ""
+ )
+check(A.func2static.__doc__,
+ "\n"
+ " func2static(e, arg2, hello, f=2) -> int\n"
+ "\n"
+ " Parameters\n"
+ " ----------\n"
+ " e: A *\n"
+ " arg2: short\n"
+ " hello: int tuple[2]\n"
+ " f: double\n"
+ "\n"
+ " func2static(e, arg2, hello) -> int\n"
+ "\n"
+ " Parameters\n"
+ " ----------\n"
+ " e: A *\n"
+ " arg2: short\n"
+ " hello: int tuple[2]\n"
+ "\n"
+ " ",
+ "\n"
+ "func2static(e, arg2, hello, f=2) -> int\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "e: A *\n"
+ "arg2: short\n"
+ "hello: int tuple[2]\n"
+ "f: double\n"
+ "\n"
+ "func2static(e, arg2, hello) -> int\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "e: A *\n"
+ "arg2: short\n"
+ "hello: int tuple[2]\n"
+ "\n"
+ ""
+ )
+check(A.func3static.__doc__,
+ "\n"
+ " func3static(A e, short arg2, Tuple hello, double f=2) -> int\n"
+ "\n"
+ " Parameters\n"
+ " ----------\n"
+ " e: A *\n"
+ " arg2: short\n"
+ " hello: int tuple[2]\n"
+ " f: double\n"
+ "\n"
+ " func3static(A e, short arg2, Tuple hello) -> int\n"
+ "\n"
+ " Parameters\n"
+ " ----------\n"
+ " e: A *\n"
+ " arg2: short\n"
+ " hello: int tuple[2]\n"
+ "\n"
+ " ",
+ "\n"
+ "func3static(A e, short arg2, Tuple hello, double f=2) -> int\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "e: A *\n"
+ "arg2: short\n"
+ "hello: int tuple[2]\n"
+ "f: double\n"
+ "\n"
+ "func3static(A e, short arg2, Tuple hello) -> int\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "e: A *\n"
+ "arg2: short\n"
+ "hello: int tuple[2]\n"
+ "\n"
+ ""
+ )
if sys.version_info[0:2] > (2, 4):
- # Python 2.4 does not seem to work
- check(A.variable_a.__doc__, "A_variable_a_get(self) -> int")
- check(A.variable_b.__doc__, "A_variable_b_get(A self) -> int")
- check(A.variable_c.__doc__, "\n"
- "A_variable_c_get(self) -> int\n"
- "\n"
- "Parameters:\n"
- " self: A *\n"
- "\n"
- )
- check(A.variable_d.__doc__, "\n"
- "A_variable_d_get(A self) -> int\n"
- "\n"
- "Parameters:\n"
- " self: A *\n"
- "\n"
- )
+ # Python 2.4 does not seem to work
+ check(A.variable_a.__doc__,
+ "A_variable_a_get(self) -> int",
+ "A.variable_a"
+ )
+ check(A.variable_b.__doc__,
+ "A_variable_b_get(A self) -> int",
+ "A.variable_b"
+ )
+ check(A.variable_c.__doc__,
+ "\n"
+ "A_variable_c_get(self) -> int\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "self: A *\n"
+ "\n",
+ "A.variable_c"
+ )
+ check(A.variable_d.__doc__,
+ "\n"
+ "A_variable_d_get(A self) -> int\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "self: A *\n"
+ "\n",
+ "A.variable_d"
+ )
-check(B.__doc__, "Proxy of C++ B class")
-check(C.__init__.__doc__, "__init__(self, a, b, h) -> C")
-check(D.__init__.__doc__, "__init__(D self, int a, int b, Hola h) -> D")
-check(E.__init__.__doc__, "\n"
-" __init__(self, a, b, h) -> E\n"
-"\n"
-" Parameters:\n"
-" a: special comment for parameter a\n"
-" b: another special comment for parameter b\n"
-" h: enum Hola\n"
-"\n"
-" "
-)
-check(F.__init__.__doc__, "\n"
-" __init__(F self, int a, int b, Hola h) -> F\n"
-"\n"
-" Parameters:\n"
-" a: special comment for parameter a\n"
-" b: another special comment for parameter b\n"
-" h: enum Hola\n"
-"\n"
-" "
-)
+check(B.__doc__,
+ "Proxy of C++ B class.",
+ "::B"
+ )
+check(C.__init__.__doc__, "__init__(self, a, b, h) -> C", None, skip)
+check(D.__init__.__doc__,
+ "__init__(D self, int a, int b, Hola h) -> D", None, skip)
+check(E.__init__.__doc__,
+ "\n"
+ " __init__(self, a, b, h) -> E\n"
+ "\n"
+ " Parameters\n"
+ " ----------\n"
+ " a: special comment for parameter a\n"
+ " b: another special comment for parameter b\n"
+ " h: enum Hola\n"
+ "\n"
+ " ", None, skip
+ )
+check(F.__init__.__doc__,
+ "\n"
+ " __init__(F self, int a, int b, Hola h) -> F\n"
+ "\n"
+ " Parameters\n"
+ " ----------\n"
+ " a: special comment for parameter a\n"
+ " b: another special comment for parameter b\n"
+ " h: enum Hola\n"
+ "\n"
+ " ", None, skip
+ )
-check(B.funk.__doc__, "funk(B self, int c, int d) -> int")
+check(B.funk.__doc__,
+ "funk(B self, int c, int d) -> int",
+ "funk(int c, int d) -> int")
check(funk.__doc__, "funk(A e, short arg2, int c, int d) -> int")
-check(funkdefaults.__doc__, "\n"
-" funkdefaults(A e, short arg2, int c, int d, double f=2) -> int\n"
-" funkdefaults(A e, short arg2, int c, int d) -> int\n"
-" "
-)
+check(funkdefaults.__doc__,
+ "\n"
+ " funkdefaults(A e, short arg2, int c, int d, double f=2) -> int\n"
+ " funkdefaults(A e, short arg2, int c, int d) -> int\n"
+ " ",
+ "\n"
+ "funkdefaults(A e, short arg2, int c, int d, double f=2) -> int\n"
+ "funkdefaults(A e, short arg2, int c, int d) -> int\n"
+ ""
+ )
check(func_input.__doc__, "func_input(int * INPUT) -> int")
check(func_output.__doc__, "func_output() -> int")
check(func_inout.__doc__, "func_inout(int * INOUT) -> int")
+check(func_cb.__doc__, "func_cb(int c, int d) -> int")
check(banana.__doc__, "banana(S a, S b, int c, Integer d)")
from callback import *
if foo(2) != 2:
- raise RuntimeError
+ raise RuntimeError
if A_bar(2) != 4:
- raise RuntimeError
+ raise RuntimeError
if foobar(3, _callback.foo) != foo(3):
- raise RuntimeError
+ raise RuntimeError
if foobar(3, foo) != foo(3):
- raise RuntimeError
+ raise RuntimeError
if foobar(3, A_bar) != A_bar(3):
- raise RuntimeError
+ raise RuntimeError
if foobar(3, foof) != foof(3):
- raise RuntimeError
+ raise RuntimeError
if foobar_i(3, foo_i) != foo_i(3):
- raise RuntimeError
+ raise RuntimeError
if foobar_d(3.5, foo_d) != foo_d(3.5):
- raise RuntimeError
+ raise RuntimeError
a = A()
if foobarm(3, a, A.foom_cb_ptr) != a.foom(3):
- raise RuntimeError
+ raise RuntimeError
t = Test()
if t.strlen('hile') != 4:
- print t.strlen('hile')
- raise RuntimeError, "bad multi-arg typemap"
+ print t.strlen('hile')
+ raise RuntimeError, "bad multi-arg typemap"
+if t.ustrlen('hile') != 4:
+ print t.ustrlen('hile')
+ raise RuntimeError, "bad multi-arg typemap"
if t.strlen('hil\0') != 4:
- raise RuntimeError, "bad multi-arg typemap"
+ raise RuntimeError, "bad multi-arg typemap"
+if t.ustrlen('hil\0') != 4:
+ raise RuntimeError, "bad multi-arg typemap"
#
# creating a raw char*
if t.strlen(pc) != 4:
- raise RuntimeError, "bad multi-arg typemap"
+ raise RuntimeError, "bad multi-arg typemap"
+if t.ustrlen(pc) != 4:
+ raise RuntimeError, "bad multi-arg typemap"
cvar.var_pchar = pc
if cvar.var_pchar != "hola":
- print cvar.var_pchar
- raise RuntimeError, "bad pointer case"
+ print cvar.var_pchar
+ raise RuntimeError, "bad pointer case"
cvar.var_namet = pc
-#if cvar.var_namet != "hola\0":
+# if cvar.var_namet != "hola\0":
if cvar.var_namet != "hola":
- raise RuntimeError, "bad pointer case"
+ raise RuntimeError, "bad pointer case"
delete_pchar(pc)
-
defaults1 = Defaults1()
if defaults1.ret(10.0) != 10.0:
- raise RuntimeError
+ raise RuntimeError
if defaults1.ret() != -1.0:
- raise RuntimeError
+ raise RuntimeError
defaults2 = Defaults2(1000)
defaults2 = Defaults2()
if defaults2.ret(10.0) != 10.0:
- raise RuntimeError
+ raise RuntimeError
if defaults2.ret() != -1.0:
- raise RuntimeError
+ raise RuntimeError
+if defaults2.nodefault(-2) != -2:
+ raise RuntimeError
import complextest
-a = complex(-1,2)
+a = complex(-1, 2)
if complextest.Conj(a) != a.conjugate():
- raise RuntimeError, "bad complex mapping"
+ raise RuntimeError, "bad complex mapping"
if complextest.Conjf(a) != a.conjugate():
- raise RuntimeError, "bad complex mapping"
+ raise RuntimeError, "bad complex mapping"
-v = (complex(1,2), complex(2,3), complex(4,3), 1)
+v = (complex(1, 2), complex(2, 3), complex(4, 3), 1)
try:
- complextest.Copy_h(v)
+ complextest.Copy_h(v)
except:
- pass
+ pass
--- /dev/null
+import constant_directive
+
+if not isinstance(constant_directive.TYPE1_CONSTANT1, constant_directive.Type1):
+ raise RuntimeError("Failure: TYPE1_CONSTANT1 type: {}".format(
+ type(constant_directive.TYPE1_CONSTANT1)))
+if not isinstance(constant_directive.getType1Instance(), constant_directive.Type1):
+ raise RuntimeError("Failure: getType1Instance() type: {}".format(
+ type(constant_directive.getType1Instance())))
+
+if constant_directive.TYPE1_CONSTANT1.val != 1:
+ raise RuntimeError("constant_directive.TYPE1_CONSTANT1.val is %r (should be 1)" %
+ constant_directive.TYPE1_CONSTANT1.val)
+
+if constant_directive.TYPE1_CONSTANT2.val != 2:
+ raise RuntimeError("constant_directive.TYPE1_CONSTANT2.val is %r (should be 2)" %
+ constant_directive.TYPE1_CONSTANT2.val)
+
+if constant_directive.TYPE1_CONSTANT3.val != 3:
+ raise RuntimeError("constant_directive.TYPE1_CONSTANT3.val is %r (should be 3)" %
+ constant_directive.TYPE1_CONSTANT3.val)
+
+if constant_directive.TYPE1CONST_CONSTANT1.val != 1:
+ raise RuntimeError("constant_directive.TYPE1CONST_CONSTANT1.val is %r (should be 1)" %
+ constant_directive.TYPE1CONST_CONSTANT1.val)
+
+if constant_directive.TYPE1CPTR_CONSTANT1.val != 1:
+ raise RuntimeError("constant_directive.TYPE1CPTR_CONSTANT1.val is %r (should be 1)" %
+ constant_directive.TYPE1CPTR_CONSTANT1.val)
if p != "test_pconst":
print "test_pconst failed!"
error = 1
-
+
f = constover.Foo()
p = f.test("test")
if p != "test":
if p != "test_pconstmethod":
print "member-test_pconstm failed!"
error = 1
-
-sys.exit(error)
-
+sys.exit(error)
from constructor_copy import *
-f1 = Foo1(3);
-f11 = Foo1(f1);
+f1 = Foo1(3)
+f11 = Foo1(f1)
if f1.x != f11.x:
if (bi.x != bc.x):
raise RuntimeError
-
+
bd = Bard(5)
try:
if not good:
raise RuntimeError
-
import contract
-contract.test_preassert(1,2)
+contract.test_preassert(1, 2)
try:
- contract.test_preassert(-1)
- print "Failed! Preassertions are broken"
+ contract.test_preassert(-1)
+ print "Failed! Preassertions are broken"
except:
- pass
+ pass
contract.test_postassert(3)
try:
- contract.test_postassert(-3)
- print "Failed! Postassertions are broken"
+ contract.test_postassert(-3)
+ print "Failed! Postassertions are broken"
except:
- pass
+ pass
-contract.test_prepost(2,3)
-contract.test_prepost(5,-4)
+contract.test_prepost(2, 3)
+contract.test_prepost(5, -4)
try:
- contract.test_prepost(-3,4)
- print "Failed! Preassertions are broken"
+ contract.test_prepost(-3, 4)
+ print "Failed! Preassertions are broken"
except:
- pass
+ pass
try:
- contract.test_prepost(4,-10)
- print "Failed! Postassertions are broken"
+ contract.test_prepost(4, -10)
+ print "Failed! Postassertions are broken"
except:
- pass
+ pass
f = contract.Foo()
-f.test_preassert(4,5)
+f.test_preassert(4, 5)
try:
- f.test_preassert(-2,3)
- print "Failed! Method preassertion."
+ f.test_preassert(-2, 3)
+ print "Failed! Method preassertion."
except:
- pass
+ pass
f.test_postassert(4)
try:
- f.test_postassert(-4)
- print "Failed! Method postassertion"
+ f.test_postassert(-4)
+ print "Failed! Method postassertion"
except:
- pass
+ pass
-f.test_prepost(3,4)
-f.test_prepost(4,-3)
+f.test_prepost(3, 4)
+f.test_prepost(4, -3)
try:
- f.test_prepost(-4,2)
- print "Failed! Method preassertion."
+ f.test_prepost(-4, 2)
+ print "Failed! Method preassertion."
except:
- pass
+ pass
try:
- f.test_prepost(4,-10)
- print "Failed! Method postassertion."
+ f.test_prepost(4, -10)
+ print "Failed! Method postassertion."
except:
- pass
+ pass
-contract.Foo_stest_prepost(4,0)
+contract.Foo_stest_prepost(4, 0)
try:
- contract.Foo_stest_prepost(-4,2)
- print "Failed! Static method preassertion"
+ contract.Foo_stest_prepost(-4, 2)
+ print "Failed! Static method preassertion"
except:
- pass
+ pass
try:
- contract.Foo_stest_prepost(4,-10)
- print "Failed! Static method posteassertion"
+ contract.Foo_stest_prepost(4, -10)
+ print "Failed! Static method posteassertion"
except:
- pass
-
+ pass
+
b = contract.Bar()
try:
- b.test_prepost(2,-4)
- print "Failed! Inherited preassertion."
+ b.test_prepost(2, -4)
+ print "Failed! Inherited preassertion."
except:
- pass
+ pass
d = contract.D()
try:
- d.foo(-1,1,1,1,1)
- print "Failed! Inherited preassertion (D)."
+ d.foo(-1, 1, 1, 1, 1)
+ print "Failed! Inherited preassertion (D)."
except:
- pass
+ pass
try:
- d.foo(1,-1,1,1,1)
- print "Failed! Inherited preassertion (D)."
+ d.foo(1, -1, 1, 1, 1)
+ print "Failed! Inherited preassertion (D)."
except:
- pass
+ pass
try:
- d.foo(1,1,-1,1,1)
- print "Failed! Inherited preassertion (D)."
+ d.foo(1, 1, -1, 1, 1)
+ print "Failed! Inherited preassertion (D)."
except:
- pass
+ pass
try:
- d.foo(1,1,1,-1,1)
- print "Failed! Inherited preassertion (D)."
+ d.foo(1, 1, 1, -1, 1)
+ print "Failed! Inherited preassertion (D)."
except:
- pass
+ pass
try:
- d.foo(1,1,1,1,-1)
- print "Failed! Inherited preassertion (D)."
+ d.foo(1, 1, 1, 1, -1)
+ print "Failed! Inherited preassertion (D)."
except:
- pass
+ pass
try:
- d.bar(-1,1,1,1,1)
- print "Failed! Inherited preassertion (D)."
+ d.bar(-1, 1, 1, 1, 1)
+ print "Failed! Inherited preassertion (D)."
except:
- pass
+ pass
try:
- d.bar(1,-1,1,1,1)
- print "Failed! Inherited preassertion (D)."
+ d.bar(1, -1, 1, 1, 1)
+ print "Failed! Inherited preassertion (D)."
except:
- pass
+ pass
try:
- d.bar(1,1,-1,1,1)
- print "Failed! Inherited preassertion (D)."
+ d.bar(1, 1, -1, 1, 1)
+ print "Failed! Inherited preassertion (D)."
except:
- pass
+ pass
try:
- d.bar(1,1,1,-1,1)
- print "Failed! Inherited preassertion (D)."
+ d.bar(1, 1, 1, -1, 1)
+ print "Failed! Inherited preassertion (D)."
except:
- pass
+ pass
try:
- d.bar(1,1,1,1,-1)
- print "Failed! Inherited preassertion (D)."
+ d.bar(1, 1, 1, 1, -1)
+ print "Failed! Inherited preassertion (D)."
except:
- pass
+ pass
-#Namespace
+# Namespace
my = contract.myClass(1)
try:
- my = contract.myClass(0)
- print "Failed! constructor preassertion"
+ my = contract.myClass(0)
+ print "Failed! constructor preassertion"
except:
- pass
-
+ pass
--- /dev/null
+import cpp11_alternate_function_syntax
+
+a = cpp11_alternate_function_syntax.SomeStruct()
+
+res = a.addNormal(4, 5)
+if res != 9:
+ raise RuntimeError, ("SomeStruct::addNormal(4,5) returns ",
+ res, " should be 9.")
+
+
+res = a.addAlternate(4, 5)
+if res != 9:
+ raise RuntimeError, ("SomeStruct::addAlternate(4,5) returns ",
+ res, " should be 9.")
--- /dev/null
+import cpp11_decltype
+
+a = cpp11_decltype.A()
+a.i = 5
+if a.i != 5:
+ raise RuntimeError, "Assignment to a.i failed."
+
+a.j = 10
+if a.j != 10:
+ raise RuntimeError, "Assignment to a.j failed."
+
+b = a.foo(5)
+if b != 10:
+ raise RuntimeError, "foo(5) should return 10."
+
+b = a.foo(6)
+if b != 0:
+ raise RuntimeError, "foo(6) should return 0."
--- /dev/null
+import cpp11_function_objects
+import sys
+
+
+class Test1(cpp11_function_objects.Test):
+
+ def __init__(self):
+ cpp11_function_objects.Test.__init__(self)
+
+ def __call__(self, a, b):
+ self.value = a * b
+
+t = cpp11_function_objects.Test()
+if t.value != 0:
+ raise RuntimeError(
+ "Runtime cpp11_function_objects failed. t.value should be 0, but is " + str(t.value))
+
+t(1, 2) # adds numbers and sets value
+
+if t.value != 3:
+ raise RuntimeError(
+ "Runtime cpp11_function_objects failed. t.value not changed - should be 3, but is " + str(t.value))
+
+t2 = Test1()
+a = cpp11_function_objects.testit1(t2, 4, 3)
+if a != 12:
+ raise RuntimeError(
+ "Runtime cpp11_function_objects failed. t.value not changed - should be 12, but is " + str(a))
--- /dev/null
+import cpp11_initializer_list_extend
+
+c = cpp11_initializer_list_extend.Container([10, 20, 30, 40])
--- /dev/null
+import cpp11_initializer_list
+
+a = cpp11_initializer_list.A()
+a = cpp11_initializer_list.A(11.1)
--- /dev/null
+from cpp11_li_std_array import *
+import sys
+
+
+def failed(a, b, msg):
+ raise RuntimeError, msg + " " + str(list(a)) + " " + str(list(b))
+
+
+def compare_sequences(a, b):
+ if len(a) != len(b):
+ failed(a, b, "different sizes")
+ for i in range(len(a)):
+ if a[i] != b[i]:
+ failed(a, b, "elements are different")
+
+def compare_containers(pythonlist, swigarray):
+ compare_sequences(pythonlist, swigarray)
+
+def steps_exception(swigarray, i, j, step):
+ try:
+ if i == None and j == None:
+ a = swigarray[::step]
+ elif i == None:
+ a = swigarray[:j:step]
+ elif j == None:
+ a = swigarray[i::step]
+ else:
+ a = swigarray[i:j:step]
+ raise RuntimeError, "swigarray[" + str(i) + ":" + str(j) + ":" + str(step) + "] missed steps exception for " + str(list(swigarray))
+ except ValueError, e:
+# print("exception: {}".format(e))
+ pass
+
+def del_exception(swigarray, i, j, step):
+ try:
+ if i == None and j == None:
+ del swigarray[::step]
+ elif j == None and step == None:
+ del swigarray[i]
+ elif i == None:
+ del swigarray[:j:step]
+ elif j == None:
+ del swigarray[i::step]
+ else:
+ del swigarray[i:j:step]
+ raise RuntimeError, "swigarray[" + str(i) + ":" + str(j) + ":" + str(step) + "] missed del exception for " + str(list(swigarray))
+ except ValueError, e:
+# print("exception: {}".format(e))
+ pass
+
+def setslice_exception(swigarray, newval):
+ try:
+ swigarray[::] = newval
+ raise RuntimeError, "swigarray[::] = " + str(newval) + " missed set exception for swigarray:" + str(list(swigarray))
+ except TypeError, e:
+# print("exception: {}".format(e))
+ pass
+
+
+# Check std::array has similar behaviour to a Python list
+# except it is not resizable
+
+ps = [0, 1, 2, 3, 4, 5]
+
+ai = ArrayInt6(ps)
+
+compare_containers(ps, ai)
+
+# slices
+compare_containers(ps[0:6], ai[0:6])
+compare_containers(ps[0:10], ai[0:10])
+compare_containers(ps[-10:6], ai[-10:6])
+compare_containers(ps[-10:10], ai[-10:10])
+
+compare_containers(ps[0:6:1], ai[0:6:1])
+compare_containers(ps[::], ai[::])
+compare_containers(ps[::1], ai[::1])
+
+compare_containers([x for x in ps], [x for x in ai])
+
+# Reverse
+compare_containers(ps[::-1], ai[::-1])
+compare_containers(ps[5::-1], ai[5::-1])
+compare_containers(ps[10::-1], ai[10::-1])
+
+# Steps other than +1 and -1 not supported
+steps_exception(ai, 0, 6, 3)
+steps_exception(ai, None, None, 0)
+steps_exception(ai, None, None, 2)
+steps_exception(ai, None, None, -2)
+steps_exception(ai, 1, 3, 1)
+steps_exception(ai, 3, 1, -1)
+
+# Modify content
+for i in range(len(ps)):
+ ps[i] = (ps[i] + 1) * 10
+ ai[i] = (ai[i] + 1) * 10
+compare_containers(ps, ai)
+
+# Delete
+del_exception(ai, 0, 6, 3)
+del_exception(ai, None, None, 0)
+del_exception(ai, None, None, 2)
+del_exception(ai, None, None, -2)
+del_exception(ai, 1, 3, 1)
+del_exception(ai, 3, 1, -1)
+
+del_exception(ai, 0, None, None)
+del_exception(ai, 5, None, None)
+
+# Empty
+ai = ArrayInt6()
+compare_containers([0, 0, 0, 0, 0, 0], ai)
+
+# Set slice
+newvals = [10, 20, 30, 40, 50, 60]
+ai[::] = newvals
+compare_containers(ai, newvals)
+
+newvals = [100, 200, 300, 400, 500, 600]
+ai[0:6:1] = newvals
+compare_containers(ai, newvals)
+
+newvals = [1000, 2000, 3000, 4000, 5000, 6000]
+ai[::-1] = newvals
+compare_containers(ai, newvals[::-1])
+
+newvals = [10000, 20000, 30000, 40000, 50000, 60000]
+ai[-10:100:1] = newvals
+compare_containers(ai, newvals[-10:100:1])
+
+setslice_exception(ai, [1, 2, 3, 4, 5, 6, 7])
+setslice_exception(ai, [1, 2, 3, 4, 5])
+setslice_exception(ai, [1, 2, 3, 4])
+setslice_exception(ai, [1, 2, 3])
+setslice_exception(ai, [1, 2])
+setslice_exception(ai, [1])
+setslice_exception(ai, [])
+
+# Check return
+compare_containers(arrayOutVal(), [-2, -1, 0, 0, 1, 2])
+compare_containers(arrayOutConstRef(), [-2, -1, 0, 0, 1, 2])
+compare_containers(arrayOutRef(), [-2, -1, 0, 0, 1, 2])
+compare_containers(arrayOutPtr(), [-2, -1, 0, 0, 1, 2])
+
+# Check passing arguments
+ai = arrayInVal([9, 8, 7, 6, 5, 4])
+compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+ai = arrayInConstRef([9, 8, 7, 6, 5, 4])
+compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+ai = ArrayInt6([9, 8, 7, 6, 5, 4])
+arrayInRef(ai)
+compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+ai = ArrayInt6([9, 8, 7, 6, 5, 4])
+arrayInPtr(ai)
+compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+# fill
+ai.fill(111)
+compare_containers(ai, [111, 111, 111, 111, 111, 111])
--- /dev/null
+import cpp11_null_pointer_constant
+
+a = cpp11_null_pointer_constant.A()
+
+if a._myA != None:
+ raise RuntimeError, (
+ "cpp11_null_pointer_constant: _myA should be None, but is ", a._myA)
+
+b = cpp11_null_pointer_constant.A()
+if a._myA != b._myA:
+ raise RuntimeError, (
+ "cpp11_null_pointer_constant: a._myA should be the same as b._myA, but ", a._myA, "!=", b._myA)
+
+a._myA = cpp11_null_pointer_constant.A()
+if a._myA == None:
+ raise RuntimeError, (
+ "cpp11_null_pointer_constant: _myA should be object, but is None")
--- /dev/null
+from cpp11_raw_string_literals import *
+
+if cvar.L != 100:
+ raise RuntimeError
+
+if cvar.u8 != 100:
+ raise RuntimeError
+
+if cvar.u != 100:
+ raise RuntimeError
+
+if UStruct.U != 100:
+ raise RuntimeError
+
+
+if cvar.R != 100:
+ raise RuntimeError
+
+if cvar.LR != 100:
+ raise RuntimeError
+
+if cvar.u8R != 100:
+ raise RuntimeError
+
+if cvar.uR != 100:
+ raise RuntimeError
+
+if URStruct.UR != 100:
+ raise RuntimeError
+
+
+if cvar.aa != "Wide string":
+ raise RuntimeError
+
+if cvar.bb != "UTF-8 string":
+ raise RuntimeError, cvar.wide
+
+if cvar.xx != ")I'm an \"ascii\" \\ string.":
+ raise RuntimeError, cvar.xx
+
+if cvar.ee != ")I'm an \"ascii\" \\ string.":
+ raise RuntimeError, cvar.ee
+
+if cvar.ff != "I'm a \"raw wide\" \\ string.":
+ raise RuntimeError, cvar.ff
+
+if cvar.gg != "I'm a \"raw UTF-8\" \\ string.":
+ raise RuntimeError, cvar.gg
--- /dev/null
+import cpp11_result_of
+
+result = cpp11_result_of.test_result(cpp11_result_of.SQUARE, 3.0)
+if result != 9.0:
+ raise RuntimeError, "test_result(square, 3.0) is not 9.0. Got: " + str(
+ result)
+
+result = cpp11_result_of.test_result_alternative1(cpp11_result_of.SQUARE, 3.0)
+if result != 9.0:
+ raise RuntimeError, "test_result_alternative1(square, 3.0) is not 9.0. Got: " + str(
+ result)
--- /dev/null
+import cpp11_rvalue_reference
+
+a = cpp11_rvalue_reference.A()
+
+a.setAcopy(5)
+if a.getAcopy() != 5:
+ raise RunTimeError, ("int A::getAcopy() value is ",
+ a.getAcopy(), " should be 5")
+
+ptr = a.getAptr()
+
+a.setAptr(ptr)
+if a.getAcopy() != 5:
+ raise RunTimeError, ("after A::setAptr(): int A::getAcopy() value is ", a.getAcopy(
+ ), " should be 5")
+
+a.setAref(ptr)
+if a.getAcopy() != 5:
+ raise RunTimeError, ("after A::setAref(): int A::getAcopy() value is ", a.getAcopy(
+ ), " should be 5")
+
+rvalueref = a.getAmove()
+
+a.setAmove(rvalueref)
+if a.getAcopy() != 5:
+ raise RunTimeError, ("after A::setAmove(): int A::getAcopy() value is ", a.getAcopy(
+ ), " should be 5")
--- /dev/null
+from cpp11_strongly_typed_enumerations import *
+
+
+def enumCheck(actual, expected):
+ if actual != expected:
+ raise RuntimeError(
+ "Enum value mismatch. Expected " + str(expected) + " Actual: " + str(actual))
+ return expected + 1
+
+val = 0
+val = enumCheck(Enum1_Val1, val)
+val = enumCheck(Enum1_Val2, val)
+val = enumCheck(Enum1_Val3, 13)
+val = enumCheck(Enum1_Val4, val)
+val = enumCheck(Enum1_Val5a, 13)
+val = enumCheck(Enum1_Val6a, val)
+
+val = 0
+val = enumCheck(Enum2_Val1, val)
+val = enumCheck(Enum2_Val2, val)
+val = enumCheck(Enum2_Val3, 23)
+val = enumCheck(Enum2_Val4, val)
+val = enumCheck(Enum2_Val5b, 23)
+val = enumCheck(Enum2_Val6b, val)
+
+val = 0
+val = enumCheck(Val1, val)
+val = enumCheck(Val2, val)
+val = enumCheck(Val3, 43)
+val = enumCheck(Val4, val)
+
+val = 0
+val = enumCheck(Enum5_Val1, val)
+val = enumCheck(Enum5_Val2, val)
+val = enumCheck(Enum5_Val3, 53)
+val = enumCheck(Enum5_Val4, val)
+
+val = 0
+val = enumCheck(Enum6_Val1, val)
+val = enumCheck(Enum6_Val2, val)
+val = enumCheck(Enum6_Val3, 63)
+val = enumCheck(Enum6_Val4, val)
+
+val = 0
+val = enumCheck(Enum7td_Val1, val)
+val = enumCheck(Enum7td_Val2, val)
+val = enumCheck(Enum7td_Val3, 73)
+val = enumCheck(Enum7td_Val4, val)
+
+val = 0
+val = enumCheck(Enum8_Val1, val)
+val = enumCheck(Enum8_Val2, val)
+val = enumCheck(Enum8_Val3, 83)
+val = enumCheck(Enum8_Val4, val)
+
+val = 0
+val = enumCheck(Enum10_Val1, val)
+val = enumCheck(Enum10_Val2, val)
+val = enumCheck(Enum10_Val3, 103)
+val = enumCheck(Enum10_Val4, val)
+
+val = 0
+val = enumCheck(Class1.Enum12_Val1, 1121)
+val = enumCheck(Class1.Enum12_Val2, 1122)
+val = enumCheck(Class1.Enum12_Val3, val)
+val = enumCheck(Class1.Enum12_Val4, val)
+val = enumCheck(Class1.Enum12_Val5c, 1121)
+val = enumCheck(Class1.Enum12_Val6c, val)
+
+val = 0
+val = enumCheck(Class1.Val1, 1131)
+val = enumCheck(Class1.Val2, 1132)
+val = enumCheck(Class1.Val3, val)
+val = enumCheck(Class1.Val4, val)
+val = enumCheck(Class1.Val5d, 1131)
+val = enumCheck(Class1.Val6d, val)
+
+val = 0
+val = enumCheck(Class1.Enum14_Val1, 1141)
+val = enumCheck(Class1.Enum14_Val2, 1142)
+val = enumCheck(Class1.Enum14_Val3, val)
+val = enumCheck(Class1.Enum14_Val4, val)
+val = enumCheck(Class1.Enum14_Val5e, 1141)
+val = enumCheck(Class1.Enum14_Val6e, val)
+
+# Requires nested class support to work
+#val = 0
+#val = enumCheck(Class1.Struct1.Enum12_Val1, 3121)
+#val = enumCheck(Class1.Struct1.Enum12_Val2, 3122)
+#val = enumCheck(Class1.Struct1.Enum12_Val3, val)
+#val = enumCheck(Class1.Struct1.Enum12_Val4, val)
+#val = enumCheck(Class1.Struct1.Enum12_Val5f, 3121)
+#val = enumCheck(Class1.Struct1.Enum12_Val6f, val)
+#
+#val = 0
+#val = enumCheck(Class1.Struct1.Val1, 3131)
+#val = enumCheck(Class1.Struct1.Val2, 3132)
+#val = enumCheck(Class1.Struct1.Val3, val)
+#val = enumCheck(Class1.Struct1.Val4, val)
+#
+#val = 0
+#val = enumCheck(Class1.Struct1.Enum14_Val1, 3141)
+#val = enumCheck(Class1.Struct1.Enum14_Val2, 3142)
+#val = enumCheck(Class1.Struct1.Enum14_Val3, val)
+#val = enumCheck(Class1.Struct1.Enum14_Val4, val)
+#val = enumCheck(Class1.Struct1.Enum14_Val5g, 3141)
+#val = enumCheck(Class1.Struct1.Enum14_Val6g, val)
+
+val = 0
+val = enumCheck(Class2.Enum12_Val1, 2121)
+val = enumCheck(Class2.Enum12_Val2, 2122)
+val = enumCheck(Class2.Enum12_Val3, val)
+val = enumCheck(Class2.Enum12_Val4, val)
+val = enumCheck(Class2.Enum12_Val5h, 2121)
+val = enumCheck(Class2.Enum12_Val6h, val)
+
+val = 0
+val = enumCheck(Class2.Val1, 2131)
+val = enumCheck(Class2.Val2, 2132)
+val = enumCheck(Class2.Val3, val)
+val = enumCheck(Class2.Val4, val)
+val = enumCheck(Class2.Val5i, 2131)
+val = enumCheck(Class2.Val6i, val)
+
+val = 0
+val = enumCheck(Class2.Enum14_Val1, 2141)
+val = enumCheck(Class2.Enum14_Val2, 2142)
+val = enumCheck(Class2.Enum14_Val3, val)
+val = enumCheck(Class2.Enum14_Val4, val)
+val = enumCheck(Class2.Enum14_Val5j, 2141)
+val = enumCheck(Class2.Enum14_Val6j, val)
+
+# Requires nested class support to work
+#val = 0
+#val = enumCheck(Class2.Struct1.Enum12_Val1, 4121)
+#val = enumCheck(Class2.Struct1.Enum12_Val2, 4122)
+#val = enumCheck(Class2.Struct1.Enum12_Val3, val)
+#val = enumCheck(Class2.Struct1.Enum12_Val4, val)
+#val = enumCheck(Class2.Struct1.Enum12_Val5k, 4121)
+#val = enumCheck(Class2.Struct1.Enum12_Val6k, val)
+#
+#val = 0
+#val = enumCheck(Class2.Struct1.Val1, 4131)
+#val = enumCheck(Class2.Struct1.Val2, 4132)
+#val = enumCheck(Class2.Struct1.Val3, val)
+#val = enumCheck(Class2.Struct1.Val4, val)
+#val = enumCheck(Class2.Struct1.Val5l, 4131)
+#val = enumCheck(Class2.Struct1.Val6l, val)
+#
+#val = 0
+#val = enumCheck(Class2.Struct1.Enum14_Val1, 4141)
+#val = enumCheck(Class2.Struct1.Enum14_Val2, 4142)
+#val = enumCheck(Class2.Struct1.Enum14_Val3, val)
+#val = enumCheck(Class2.Struct1.Enum14_Val4, val)
+#val = enumCheck(Class2.Struct1.Enum14_Val5m, 4141)
+#val = enumCheck(Class2.Struct1.Enum14_Val6m, val)
+
+class1 = Class1()
+enumCheck(class1.class1Test1(Enum1_Val5a), 13)
+enumCheck(class1.class1Test2(Class1.Enum12_Val5c), 1121)
+#enumCheck(class1.class1Test3(Class1.Struct1.Enum12_Val5f), 3121)
+
+enumCheck(globalTest1(Enum1_Val5a), 13)
+enumCheck(globalTest2(Class1.Enum12_Val5c), 1121)
+#enumCheck(globalTest3(Class1.Struct1.Enum12_Val5f), 3121)
--- /dev/null
+from cpp11_thread_local import *
+
+t = ThreadLocals()
+if t.stval != 11:
+ raise RuntimeError
+if t.tsval != 22:
+ raise RuntimeError
+if t.tscval99 != 99:
+ raise RuntimeError
+
+cvar.etval = -11
+if cvar.etval != -11:
+ raise RuntimeError
+
+cvar.stval = -22
+if cvar.stval != -22:
+ raise RuntimeError
+
+cvar.tsval = -33
+if cvar.tsval != -33:
+ raise RuntimeError
+
+cvar.etval = -44
+if cvar.etval != -44:
+ raise RuntimeError
+
+cvar.teval = -55
+if cvar.teval != -55:
+ raise RuntimeError
+
+cvar.ectval = -66
+if cvar.ectval != -66:
+ raise RuntimeError
+
+cvar.ecpptval = -66
+if cvar.ecpptval != -66:
+ raise RuntimeError
--- /dev/null
+from cpp11_type_traits import *
+
+if Elaborate(0, 0) != 1:
+ raise RuntimeError("Elaborate should have returned 1")
+
+if Elaborate(0, 0.0) != 2:
+ raise RuntimeError("Elaborate should have returned 2")
--- /dev/null
+import cpp11_uniform_initialization
+
+var1 = cpp11_uniform_initialization.cvar.var1
+if var1.x != 5:
+ raise RuntimeError
+var2 = cpp11_uniform_initialization.cvar.var2
+if var2.getX() != 2:
+ raise RuntimeError
+
+m = cpp11_uniform_initialization.MoreInit()
+if m.charptr != None:
+ raise RuntimeError, m.charptr
+m.charptr = "hello sir"
+if m.charptr != "hello sir":
+ raise RuntimeError, m.charptr
+if m.more1(m.vi) != 15:
+ raise RuntimeError, m.vi
+if m.more1([-1, 1, 2]) != 2:
+ raise RuntimeError, m.vi
+if m.more1() != 10:
+ raise RuntimeError
f = cpp_enum.Foo()
if f.hola != f.Hello:
- print f.hola
- raise RuntimeError
+ print f.hola
+ raise RuntimeError
f.hola = f.Hi
if f.hola != f.Hi:
- print f.hola
- raise RuntimeError
+ print f.hola
+ raise RuntimeError
f.hola = f.Hello
if f.hola != f.Hello:
- print f.hola
- raise RuntimeError
+ print f.hola
+ raise RuntimeError
cpp_enum.cvar.hi = cpp_enum.Hello
if cpp_enum.cvar.hi != cpp_enum.Hello:
- print cpp_enum.cvar.hi
- raise RuntimeError
+ print cpp_enum.cvar.hi
+ raise RuntimeError
if cpp_namespace.do_method2(t) != "Test::method":
raise RuntimeError("Bad return value!")
-
+
cpp_namespace.weird("hello", 4)
del t
if cpp_namespace.foo3(42) != 42:
raise RuntimeError("Bad return value!")
-if cpp_namespace.do_method3(t2,40) != "Test2::method":
+if cpp_namespace.do_method3(t2, 40) != "Test2::method":
raise RuntimeError("Bad return value!")
-if cpp_namespace.do_method3(t3,40) != "Test3::method":
+if cpp_namespace.do_method3(t3, 40) != "Test3::method":
raise RuntimeError("Bad return value!")
-if cpp_namespace.do_method3(t4,40) != "Test4::method":
+if cpp_namespace.do_method3(t4, 40) != "Test4::method":
raise RuntimeError("Bad return value!")
-if cpp_namespace.do_method3(t5,40) != "Test5::method":
+if cpp_namespace.do_method3(t5, 40) != "Test5::method":
raise RuntimeError("Bad return value!")
-
-
#!/usr/bin/evn python
from cpp_static import *
-StaticFunctionTest.static_func()
-StaticFunctionTest.static_func_2(1)
-StaticFunctionTest.static_func_3(1,2)
+
+
+def is_new_style_class(cls):
+ return hasattr(cls, "__class__")
+
+if is_new_style_class(StaticFunctionTest):
+ StaticFunctionTest.static_func()
+ StaticFunctionTest.static_func_2(1)
+ StaticFunctionTest.static_func_3(1, 2)
+else:
+ StaticFunctionTest().static_func()
+ StaticFunctionTest().static_func_2(1)
+ StaticFunctionTest().static_func_3(1, 2)
StaticMemberTest.static_int = 10
assert StaticMemberTest.static_int == 10
d = Display()
if d.draw1() != 0:
- raise RuntimeError
+ raise RuntimeError
if d.draw1(12) != 12:
- raise RuntimeError
+ raise RuntimeError
-p = createPtr(123);
+p = createPtr(123)
if d.draw2() != 0:
- raise RuntimeError
+ raise RuntimeError
if d.draw2(p) != 123:
- raise RuntimeError
+ raise RuntimeError
+if d.bool0() != False or type(d.bool0()) != type(False):
+ raise RuntimeError
+
+if d.bool1() != True or type(d.bool1()) != type(True):
+ raise RuntimeError
+
+if d.mybool0() != False or type(d.mybool0()) != type(False):
+ raise RuntimeError
+
+if d.mybool1() != True or type(d.mybool1()) != type(True):
+ raise RuntimeError
--- /dev/null
+import default_args_c
+
+if default_args_c.foo1() != 1:
+ raise RuntimeError("failed")
+if default_args_c.foo43() != 43:
+ raise RuntimeError("failed")
-import default_args
-
-
-if default_args.Statics_staticMethod() != 60:
- raise RuntimeError
-
-if default_args.cfunc1(1) != 2:
- raise RuntimeError
-
-if default_args.cfunc2(1) != 3:
- raise RuntimeError
-
-if default_args.cfunc3(1) != 4:
- raise RuntimeError
-
-
-f = default_args.Foo()
-
-f.newname()
-f.newname(1)
-
-
-try:
- f = default_args.Foo(1)
- error = 1
-except:
- error = 0
-if error: raise RuntimeError,"Foo::Foo ignore is not working"
-
-try:
- f = default_args.Foo(1,2)
- error = 1
-except:
- error = 0
-if error: raise RuntimeError,"Foo::Foo ignore is not working"
-
-try:
- f = default_args.Foo(1,2,3)
- error = 1
-except:
- error = 0
-if error: raise RuntimeError,"Foo::Foo ignore is not working"
-
-try:
- m = f.meth(1)
- error = 1
-except:
- error = 0
-if error: raise RuntimeError,"Foo::meth ignore is not working"
-
-try:
- m = f.meth(1,2)
- error = 1
-except:
- error = 0
-if error: raise RuntimeError,"Foo::meth ignore is not working"
-
-try:
- m = f.meth(1,2,3)
- error = 1
-except:
- error = 0
-if error: raise RuntimeError,"Foo::meth ignore is not working"
+# Note that this test is also used by python_default_args_runme.py hence
+# the use of __main__ and the run function
+
+def is_new_style_class(cls):
+ return hasattr(cls, "__class__")
+
+
+def run(module_name):
+ default_args = __import__(module_name)
+ ec = default_args.EnumClass()
+ if not ec.blah():
+ raise RuntimeError("EnumClass::blah() default arguments don't work")
+
+ de = default_args.DerivedEnumClass()
+ de.accelerate()
+ de.accelerate(default_args.EnumClass.SLOW)
+
+ if default_args.Statics_staticMethod() != 60:
+ raise RuntimeError
+
+ if default_args.cfunc1(1) != 2:
+ raise RuntimeError
+
+ if default_args.cfunc2(1) != 3:
+ raise RuntimeError
+
+ if default_args.cfunc3(1) != 4:
+ raise RuntimeError
+
+ f = default_args.Foo()
+
+ f.newname()
+ f.newname(1)
+
+ if f.double_if_void_ptr_is_null(2, None) != 4:
+ raise RuntimeError
+
+ if f.double_if_void_ptr_is_null(3) != 6:
+ raise RuntimeError
+
+ if f.double_if_handle_is_null(4, None) != 8:
+ raise RuntimeError
+
+ if f.double_if_handle_is_null(5) != 10:
+ raise RuntimeError
+
+ if f.double_if_dbl_ptr_is_null(6, None) != 12:
+ raise RuntimeError
+
+ if f.double_if_dbl_ptr_is_null(7) != 14:
+ raise RuntimeError
+
+ try:
+ f = default_args.Foo(1)
+ error = 1
+ except:
+ error = 0
+ if error:
+ raise RuntimeError("Foo::Foo ignore is not working")
+
+ try:
+ f = default_args.Foo(1, 2)
+ error = 1
+ except:
+ error = 0
+ if error:
+ raise RuntimeError("Foo::Foo ignore is not working")
+
+ try:
+ f = default_args.Foo(1, 2, 3)
+ error = 1
+ except:
+ error = 0
+ if error:
+ raise RuntimeError("Foo::Foo ignore is not working")
+
+ try:
+ m = f.meth(1)
+ error = 1
+ except:
+ error = 0
+ if error:
+ raise RuntimeError("Foo::meth ignore is not working")
+
+ try:
+ m = f.meth(1, 2)
+ error = 1
+ except:
+ error = 0
+ if error:
+ raise RuntimeError("Foo::meth ignore is not working")
+
+ try:
+ m = f.meth(1, 2, 3)
+ error = 1
+ except:
+ error = 0
+ if error:
+ raise RuntimeError("Foo::meth ignore is not working")
+
+ if is_new_style_class(default_args.Klass):
+ Klass_inc = default_args.Klass.inc
+ else:
+ Klass_inc = default_args.Klass_inc
+
+ if Klass_inc(100, default_args.Klass(22)).val != 122:
+ raise RuntimeError("Klass::inc failed")
+
+ if Klass_inc(100).val != 99:
+ raise RuntimeError("Klass::inc failed")
+
+ if Klass_inc().val != 0:
+ raise RuntimeError("Klass::inc failed")
+
+ default_args.trickyvalue1(10)
+ default_args.trickyvalue1(10, 10)
+ default_args.trickyvalue2(10)
+ default_args.trickyvalue2(10, 10)
+ default_args.trickyvalue3(10)
+ default_args.trickyvalue3(10, 10)
+ default_args.seek()
+ default_args.seek(10)
+
+ if default_args.slightly_off_square(10) != 102:
+ raise RuntimeError
+
+ if default_args.slightly_off_square() != 291:
+ raise RuntimeError
+
+ # It is difficult to test the python:cdefaultargs feature properly as -builtin
+ # and -fastproxy do not use the Python layer for default args
+ if default_args.CDA().cdefaultargs_test1() != 1:
+ raise RuntimeError
+
+ if default_args.CDA().cdefaultargs_test2() != 1:
+ raise RuntimeError
+
+ if default_args.chartest1() != 'x':
+ raise RuntimeError
+
+ if default_args.chartest2() != '\0':
+ raise RuntimeError
+
+ if default_args.chartest3() != '\1':
+ raise RuntimeError
+
+ if default_args.chartest4() != '\n':
+ raise RuntimeError
+
+ if default_args.chartest5() != 'B':
+ raise RuntimeError
+
+ if default_args.chartest6() != 'C':
+ raise RuntimeError
+
+if __name__ == "__main__":
+ run('default_args')
+import _default_constructor
+
# This test is expected to fail with -builtin option.
# It uses the old static syntax (e.g., dc.new_A() rather than dc.A()),
# which is not provided with the -builtin option.
-
-import _default_constructor
+if _default_constructor.is_python_builtin():
+ exit(0)
dc = _default_constructor
del_b = dc.delete_B
try:
- bb = dc.new_BB();
+ bb = dc.new_BB()
print "Whoa. new_BB created."
except:
pass
dc.delete_CC(cc)
try:
- d = dc.new_D();
+ d = dc.new_D()
print "Whoa. new_D created"
except:
pass
dc.F_destroy(f)
-ff = dc.new_FFF()
-try:
- del_ff = dc.delete_FFF
- print "Whoa. delete_FFF created"
-except AttributeError:
- pass
-
-dc.F_destroy(ff)
-
g = dc.new_G()
try:
import default_constructor
-hh = default_constructor.HH(1,1)
-
+hh = default_constructor.HH(1, 1)
import director_abstract
+
+def is_new_style_class(cls):
+ return hasattr(cls, "__class__")
+
+
class MyFoo(director_abstract.Foo):
- def __init__(self):
- director_abstract.Foo.__init__(self)
- def ping(self):
- return "MyFoo::ping()"
+
+ def __init__(self):
+ director_abstract.Foo.__init__(self)
+
+ def ping(self):
+ return "MyFoo::ping()"
a = MyFoo()
if a.ping() != "MyFoo::ping()":
- raise RuntimeError, a.ping()
+ raise RuntimeError, a.ping()
if a.pong() != "Foo::pong();MyFoo::ping()":
- raise RuntimeError, a.pong()
+ raise RuntimeError, a.pong()
class MyExample1(director_abstract.Example1):
- def Color(self, r, g, b):
- return r
+
+ def Color(self, r, g, b):
+ return r
+
class MyExample2(director_abstract.Example2):
- def Color(self, r, g, b):
- return g
-class MyExample3(director_abstract.Example3_i):
- def Color(self, r, g, b):
- return b
+ def Color(self, r, g, b):
+ return g
-me1 = MyExample1()
-if director_abstract.Example1_get_color(me1, 1,2,3) != 1:
- raise RuntimeError
-me2 = MyExample2(1,2)
-if MyExample2.get_color(me2, 1,2,3) != 2:
- raise RuntimeError
+class MyExample3(director_abstract.Example3_i):
+
+ def Color(self, r, g, b):
+ return b
+me1 = MyExample1()
+if director_abstract.Example1_get_color(me1, 1, 2, 3) != 1:
+ raise RuntimeError
+
+if is_new_style_class(MyExample2):
+ MyExample2_static = MyExample2
+else:
+ MyExample2_static = MyExample2(0, 0)
+me2 = MyExample2(1, 2)
+if MyExample2_static.get_color(me2, 1, 2, 3) != 2:
+ raise RuntimeError
+
+if is_new_style_class(MyExample3):
+ MyExample3_static = MyExample3
+else:
+ MyExample3_static = MyExample3()
me3 = MyExample3()
-if MyExample3.get_color(me3, 1,2,3) != 3:
- raise RuntimeError
+if MyExample3_static.get_color(me3, 1, 2, 3) != 3:
+ raise RuntimeError
error = 1
try:
- me1 = director_abstract.Example1()
+ me1 = director_abstract.Example1()
except:
- error = 0
-if (error): raise RuntimeError
+ error = 0
+if (error):
+ raise RuntimeError
error = 1
try:
- me2 = director_abstract.Example2()
+ me2 = director_abstract.Example2()
except:
- error = 0
-if (error): raise RuntimeError
+ error = 0
+if (error):
+ raise RuntimeError
error = 1
try:
- me3 = director_abstract.Example3_i()
+ me3 = director_abstract.Example3_i()
except:
- error = 0
-if (error): raise RuntimeError
+ error = 0
+if (error):
+ raise RuntimeError
try:
- f = director_abstract.A.f
+ f = director_abstract.A.f
except:
- raise RuntimeError
+ raise RuntimeError
id = getBar().id()
if id != idFromGetBar():
- raise RuntimeError, "Got wrong id: " + str(id)
+ raise RuntimeError, "Got wrong id: " + str(id)
import director_basic
+
class PyFoo(director_basic.Foo):
- def ping(self):
- return "PyFoo::ping()"
+
+ def ping(self):
+ return "PyFoo::ping()"
a = PyFoo()
if a.ping() != "PyFoo::ping()":
- raise RuntimeError, a.ping()
+ raise RuntimeError, a.ping()
if a.pong() != "Foo::pong();PyFoo::ping()":
- raise RuntimeError, a.pong()
+ raise RuntimeError, a.pong()
b = director_basic.Foo()
if b.ping() != "Foo::ping()":
- raise RuntimeError, b.ping()
+ raise RuntimeError, b.ping()
if b.pong() != "Foo::pong();Foo::ping()":
- raise RuntimeError, b.pong()
+ raise RuntimeError, b.pong()
a = director_basic.A1(1)
if a.rg(2) != 2:
- raise RuntimeError
-
+ raise RuntimeError
class PyClass(director_basic.MyClass):
- def method(self, vptr):
- self.cmethod = 7
- pass
-
- def vmethod(self, b):
- b.x = b.x + 31
- return b
+
+ def method(self, vptr):
+ self.cmethod = 7
+ pass
+
+ def vmethod(self, b):
+ b.x = b.x + 31
+ return b
b = director_basic.Bar(3)
cc.method(b)
if c.cmethod != 7:
- raise RuntimeError
+ raise RuntimeError
if bc.x != 34:
- raise RuntimeError
+ raise RuntimeError
if bd.x != 16:
- raise RuntimeError
-
+ raise RuntimeError
class PyMulti(director_basic.Foo, director_basic.MyClass):
- def __init__(self):
- director_basic.Foo.__init__(self)
- director_basic.MyClass.__init__(self)
- pass
-
- def vmethod(self, b):
- b.x = b.x + 31
- return b
+ def __init__(self):
+ director_basic.Foo.__init__(self)
+ director_basic.MyClass.__init__(self)
+ pass
-
- def ping(self):
- return "PyFoo::ping()"
+ def vmethod(self, b):
+ b.x = b.x + 31
+ return b
+
+ def ping(self):
+ return "PyFoo::ping()"
a = 0
-for i in range(0,100):
+for i in range(0, 100):
pymult = PyMulti()
pymult.pong()
- del pymult
-
+ del pymult
pymult = PyMulti()
-
-
p1 = director_basic.Foo_get_self(pymult)
p2 = director_basic.MyClass_get_self(pymult)
p1.ping()
p2.vmethod(bc)
-
-
from director_classic import *
+
class TargetLangPerson(Person):
+
def __init__(self):
Person.__init__(self)
+
def id(self):
identifier = "TargetLangPerson"
return identifier
+
class TargetLangChild(Child):
+
def __init__(self):
Child.__init__(self)
+
def id(self):
identifier = "TargetLangChild"
return identifier
+
class TargetLangGrandChild(GrandChild):
+
def __init__(self):
GrandChild.__init__(self)
+
def id(self):
identifier = "TargetLangGrandChild"
return identifier
# Semis - don't override id() in target language
+
+
class TargetLangSemiPerson(Person):
+
def __init__(self):
Person.__init__(self)
# No id() override
+
class TargetLangSemiChild(Child):
+
def __init__(self):
Child.__init__(self)
# No id() override
+
class TargetLangSemiGrandChild(GrandChild):
+
def __init__(self):
GrandChild.__init__(self)
# No id() override
# Orphans - don't override id() in C++
+
+
class TargetLangOrphanPerson(OrphanPerson):
+
def __init__(self):
OrphanPerson.__init__(self)
+
def id(self):
identifier = "TargetLangOrphanPerson"
return identifier
+
class TargetLangOrphanChild(OrphanChild):
+
def __init__(self):
- Child.__init__(self)
+ OrphanChild.__init__(self)
+
def id(self):
identifier = "TargetLangOrphanChild"
return identifier
def check(person, expected):
- debug = 0
- # Normal target language polymorphic call
- ret = person.id()
- if (debug):
- print(ret)
- if (ret != expected):
- raise RuntimeError("Failed. Received: " + str(ret) + " Expected: " + expected)
-
- # Polymorphic call from C++
- caller = Caller()
- caller.setCallback(person)
- ret = caller.call()
- if (debug):
- print(ret)
- if (ret != expected):
- raise RuntimeError("Failed. Received: " + str(ret) + " Expected: " + expected)
-
- # Polymorphic call of object created in target language and passed to C++ and back again
- baseclass = caller.baseClass()
- ret = baseclass.id()
- if (debug):
- print(ret)
- if (ret != expected):
- raise RuntimeError("Failed. Received: " + str(ret)+ " Expected: " + expected)
-
- caller.resetCallback()
- if (debug):
- print("----------------------------------------")
-
-
-
-person = Person();
-check(person, "Person");
+ debug = 0
+ # Normal target language polymorphic call
+ ret = person.id()
+ if (debug):
+ print(ret)
+ if (ret != expected):
+ raise RuntimeError(
+ "Failed. Received: " + str(ret) + " Expected: " + expected)
+
+ # Polymorphic call from C++
+ caller = Caller()
+ caller.setCallback(person)
+ ret = caller.call()
+ if (debug):
+ print(ret)
+ if (ret != expected):
+ raise RuntimeError(
+ "Failed. Received: " + str(ret) + " Expected: " + expected)
+
+ # Polymorphic call of object created in target language and passed to C++
+ # and back again
+ baseclass = caller.baseClass()
+ ret = baseclass.id()
+ if (debug):
+ print(ret)
+ if (ret != expected):
+ raise RuntimeError(
+ "Failed. Received: " + str(ret) + " Expected: " + expected)
+
+ caller.resetCallback()
+ if (debug):
+ print("----------------------------------------")
+
+
+person = Person()
+check(person, "Person")
del person
-person = Child();
-check(person, "Child");
+person = Child()
+check(person, "Child")
del person
-person = GrandChild();
-check(person, "GrandChild");
+person = GrandChild()
+check(person, "GrandChild")
del person
-person = TargetLangPerson();
-check(person, "TargetLangPerson");
+person = TargetLangPerson()
+check(person, "TargetLangPerson")
del person
-person = TargetLangChild();
-check(person, "TargetLangChild");
+person = TargetLangChild()
+check(person, "TargetLangChild")
del person
-person = TargetLangGrandChild();
-check(person, "TargetLangGrandChild");
+person = TargetLangGrandChild()
+check(person, "TargetLangGrandChild")
del person
# Semis - don't override id() in target language
-person = TargetLangSemiPerson();
-check(person, "Person");
+person = TargetLangSemiPerson()
+check(person, "Person")
del person
-person = TargetLangSemiChild();
-check(person, "Child");
+person = TargetLangSemiChild()
+check(person, "Child")
del person
-person = TargetLangSemiGrandChild();
-check(person, "GrandChild");
+person = TargetLangSemiGrandChild()
+check(person, "GrandChild")
del person
# Orphans - don't override id() in C++
-person = OrphanPerson();
-check(person, "Person");
+person = OrphanPerson()
+check(person, "Person")
del person
-person = OrphanChild();
-check(person, "Child");
+person = OrphanChild()
+check(person, "Child")
del person
-person = TargetLangOrphanPerson();
-check(person, "TargetLangOrphanPerson");
+person = TargetLangOrphanPerson()
+check(person, "TargetLangOrphanPerson")
del person
-person = TargetLangOrphanChild();
-check(person, "TargetLangOrphanChild");
+person = TargetLangOrphanChild()
+check(person, "TargetLangOrphanChild")
del person
-
-import director_detect
+import director_detect
+
class MyBar(director_detect.Bar):
- def __init__(self, val = 2):
- director_detect.Bar.__init__(self)
- self.val = val
- def get_value(self):
- self.val = self.val + 1
- return self.val
-
- def get_class(self):
- self.val = self.val + 1
- return director_detect.A()
+ def __init__(self, val=2):
+ director_detect.Bar.__init__(self)
+ self.val = val
+
+ def get_value(self):
+ self.val = self.val + 1
+ return self.val
+
+ def get_class(self):
+ self.val = self.val + 1
+ return director_detect.A()
- def just_do_it(self):
- self.val = self.val + 1
+ def just_do_it(self):
+ self.val = self.val + 1
- def clone(self):
- return MyBar(self.val)
- pass
+ def clone(self):
+ return MyBar(self.val)
+ pass
b = MyBar()
vc = c.get_value()
if (v != 3) or (b.val != 5) or (vc != 6):
- raise RuntimeError,"Bad virtual detection"
+ raise RuntimeError, "Bad virtual detection"
import director_enum
+
class MyFoo(director_enum.Foo):
- def say_hi(self, val):
- return val
+
+ def say_hi(self, val):
+ return val
b = director_enum.Foo()
a = MyFoo()
if a.say_hi(director_enum.hello) != b.say_hello(director_enum.hi):
- raise RuntimeError
+ raise RuntimeError
from director_exception import *
+
class MyException(Exception):
- def __init__(self, a, b):
- self.msg = a + b
+
+ def __init__(self, a, b):
+ self.msg = a + b
+
class MyFoo(Foo):
- def ping(self):
- raise NotImplementedError, "MyFoo::ping() EXCEPTION"
+
+ def ping(self):
+ raise NotImplementedError, "MyFoo::ping() EXCEPTION"
+
class MyFoo2(Foo):
- def ping(self):
- return True
- pass # error: should return a string
+
+ def ping(self):
+ return True
+ pass # error: should return a string
+
class MyFoo3(Foo):
- def ping(self):
- raise MyException("foo", "bar")
+
+ def ping(self):
+ raise MyException("foo", "bar")
# Check that the NotImplementedError raised by MyFoo.ping() is returned by
# MyFoo.pong().
a = MyFoo()
b = launder(a)
try:
- b.pong()
+ b.pong()
except NotImplementedError, e:
- if str(e) == "MyFoo::ping() EXCEPTION":
- ok = 1
- else:
- print "Unexpected error message: %s" % str(e)
+ if str(e) == "MyFoo::ping() EXCEPTION":
+ ok = 1
+ else:
+ print "Unexpected error message: %s" % str(e)
except:
- pass
+ pass
if not ok:
- raise RuntimeError
+ raise RuntimeError
# Check that the director returns the appropriate TypeError if the return type
a = MyFoo2()
b = launder(a)
try:
- b.pong()
+ b.pong()
except TypeError, e:
- if str(e) == "SWIG director type mismatch in output value of type 'std::string'":
- ok = 1
- else:
- print "Unexpected error message: %s" % str(e)
+ if str(e) == "SWIG director type mismatch in output value of type 'std::string'":
+ ok = 1
+ else:
+ print "Unexpected error message: %s" % str(e)
if not ok:
- raise RuntimeError
+ raise RuntimeError
# Check that the director can return an exception which requires two arguments
a = MyFoo3()
b = launder(a)
try:
- b.pong()
+ b.pong()
except MyException, e:
- if e.msg == 'foobar':
- ok = 1
- else:
- print "Unexpected error message: %s" % str(e)
+ if e.msg == 'foobar':
+ ok = 1
+ else:
+ print "Unexpected error message: %s" % str(e)
if not ok:
- raise RuntimeError
+ raise RuntimeError
# This is expected to fail with -builtin option
# Throwing builtin classes as exceptions not supported
-try:
- raise Exception2()
-except Exception2:
- pass
+if not is_python_builtin():
+ try:
+ raise Exception2()
+ except Exception2:
+ pass
-# This is expected to fail with -builtin option
-# Throwing builtin classes as exceptions not supported
-try:
- raise Exception1()
-except Exception1:
- pass
+ try:
+ raise Exception1()
+ except Exception1:
+ pass
# Test case from bug #1506850
#"When threading is enabled, the interpreter will infinitely wait on a mutex the second
-#time this type of extended method is called. Attached is an example
-#program that waits on the mutex to be unlocked."
+# time this type of extended method is called. Attached is an example
+# program that waits on the mutex to be unlocked."
from director_extend import *
+
class MyObject(SpObject):
+
def __init__(self):
SpObject.__init__(self)
return
def getFoo(self):
return 123
-
+
m = MyObject()
if m.dummy() != 666:
- raise RuntimeError, "1st call"
+ raise RuntimeError, "1st call"
if m.dummy() != 666: # Locked system
- raise RuntimeError, "2nd call"
+ raise RuntimeError, "2nd call"
from director_finalizer import *
+
class MyFoo(Foo):
- def __del__(self):
- self.orStatus(2)
- try: Foo.__del__(self)
- except: pass
+
+ def __del__(self):
+ self.orStatus(2)
+ try:
+ Foo.__del__(self)
+ except:
+ pass
resetStatus()
del a
if getStatus() != 3:
- raise RuntimeError
+ raise RuntimeError
resetStatus()
launder(a)
if getStatus() != 0:
- raise RuntimeError
+ raise RuntimeError
del a
if getStatus() != 3:
- raise RuntimeError
+ raise RuntimeError
resetStatus()
deleteFoo(a)
if getStatus() != 3:
- raise RuntimeError
-
+ raise RuntimeError
+
resetStatus()
a = MyFoo().__disown__()
deleteFoo(launder(a))
if getStatus() != 3:
- raise RuntimeError
-
-resetStatus()
+ raise RuntimeError
+resetStatus()
from director_frob import *
-foo = Bravo();
-s = foo.abs_method();
+foo = Bravo()
+s = foo.abs_method()
if s != "Bravo::abs_method()":
- raise RuntimeError, s
+ raise RuntimeError, s
--- /dev/null
+from director_keywords import *
+
+f = Foo()
+f.check_self(20)
class A(FooBar_int):
- def do_step(self):
- return "A::do_step;"
-
- def get_value(self):
- return "A::get_value"
- pass
+ def do_step(self):
+ return "A::do_step;"
+
+ def get_value(self):
+ return "A::get_value"
+
+ pass
a = A()
if a.step() != "Bar::step;Foo::advance;Bar::do_advance;A::do_step;":
- raise RuntimeError,"Bad A virtual resolution"
+ raise RuntimeError, "Bad A virtual resolution"
class B(FooBar_int):
- def do_advance(self):
- return "B::do_advance;" + self.do_step()
- def do_step(self):
- return "B::do_step;"
-
- def get_value(self):
- return 1
+ def do_advance(self):
+ return "B::do_advance;" + self.do_step()
+
+ def do_step(self):
+ return "B::do_step;"
+
+ def get_value(self):
+ return 1
- pass
+ pass
b = B()
if b.step() != "Bar::step;Foo::advance;B::do_advance;B::do_step;":
- raise RuntimeError,"Bad B virtual resolution"
-
+ raise RuntimeError, "Bad B virtual resolution"
class C(FooBar_int):
- def do_advance(self):
- return "C::do_advance;" + FooBar_int.do_advance(self)
- def do_step(self):
- return "C::do_step;"
-
- def get_value(self):
- return 2
+ def do_advance(self):
+ return "C::do_advance;" + FooBar_int.do_advance(self)
+
+ def do_step(self):
+ return "C::do_step;"
+
+ def get_value(self):
+ return 2
- def get_name(self):
- return FooBar_int.get_name(self) + " hello"
+ def get_name(self):
+ return FooBar_int.get_name(self) + " hello"
-
- pass
+ pass
cc = C()
c = FooBar_int_get_self(cc)
c.advance()
if c.get_name() != "FooBar::get_name hello":
- raise RuntimeError
+ raise RuntimeError
if c.name() != "FooBar::get_name hello":
- raise RuntimeError
+ raise RuntimeError
--- /dev/null
+import director_pass_by_value
+
+passByVal = None
+class director_pass_by_value_Derived(director_pass_by_value.DirectorPassByValueAbstractBase):
+ def virtualMethod(self, b):
+ global passByVal
+ passByVal = b
+
+# bug was the passByVal global object was destroyed after the call to virtualMethod had finished.
+director_pass_by_value.Caller().call_virtualMethod(director_pass_by_value_Derived())
+ret = passByVal.getVal();
+if ret != 0x12345678:
+ raise RuntimeError("Bad return value, got " + hex(ret))
import director_profile
+
class MyB(director_profile.B):
- def vfi(self, a):
- return a+3
+ def vfi(self, a):
+ return a + 3
a = director_profile.A()
i = 50000
a = 1
while i:
- a = fi(a) #1
- a = fi(a) #2
- a = fi(a) #3
- a = fi(a) #4
- a = fi(a) #5
- a = fi(a) #6
- a = fi(a) #7
- a = fi(a) #8
- a = fi(a) #9
- a = fi(a) #10
- a = fi(a) #1
- a = fi(a) #2
- a = fi(a) #3
- a = fi(a) #4
- a = fi(a) #5
- a = fi(a) #6
- a = fi(a) #7
- a = fi(a) #8
- a = fi(a) #9
- a = fi(a) #20
- i -= 1
+ a = fi(a) # 1
+ a = fi(a) # 2
+ a = fi(a) # 3
+ a = fi(a) # 4
+ a = fi(a) # 5
+ a = fi(a) # 6
+ a = fi(a) # 7
+ a = fi(a) # 8
+ a = fi(a) # 9
+ a = fi(a) # 10
+ a = fi(a) # 1
+ a = fi(a) # 2
+ a = fi(a) # 3
+ a = fi(a) # 4
+ a = fi(a) # 5
+ a = fi(a) # 6
+ a = fi(a) # 7
+ a = fi(a) # 8
+ a = fi(a) # 9
+ a = fi(a) # 20
+ i -= 1
print a
-
--- /dev/null
+import director_property
+
+
+class PyFoo(director_property.Foo):
+ a = property(director_property.Foo.getA, director_property.Foo.setA)
+
+ def ping(self):
+ return "PyFoo::ping()"
+
+
+foo = PyFoo()
+
+foo.setA("BLABLA")
+if foo.getA() != "BLABLA":
+ raise RuntimeError
+
+foo.a = "BIBI"
+if foo.a != "BIBI":
+ raise RuntimeError
from director_protected import *
-
class FooBar(Bar):
- def ping(self):
- return "FooBar::ping();"
+
+ def ping(self):
+ return "FooBar::ping();"
+
class FooBar2(Bar):
- def ping(self):
- return "FooBar2::ping();"
- def pang(self):
- return "FooBar2::pang();"
+
+ def ping(self):
+ return "FooBar2::ping();"
+
+ def pang(self):
+ return "FooBar2::pang();"
+
class FooBar3(Bar):
- def cheer(self):
- return "FooBar3::cheer();"
+ def cheer(self):
+ return "FooBar3::cheer();"
-b = Bar()
-f = b.create()
+
+b = Bar()
+f = b.create()
fb = FooBar()
fb2 = FooBar2()
fb3 = FooBar3()
try:
- s = fb.used()
- if s != "Foo::pang();Bar::pong();Foo::pong();FooBar::ping();":
- raise RuntimeError
- pass
+ s = fb.used()
+ if s != "Foo::pang();Bar::pong();Foo::pong();FooBar::ping();":
+ raise RuntimeError
+ pass
except:
- raise RuntimeError, "bad FooBar::used"
+ raise RuntimeError, "bad FooBar::used"
try:
- s = fb2.used()
- if s != "FooBar2::pang();Bar::pong();Foo::pong();FooBar2::ping();":
- raise RuntimeError
- pass
+ s = fb2.used()
+ if s != "FooBar2::pang();Bar::pong();Foo::pong();FooBar2::ping();":
+ raise RuntimeError
+ pass
except:
- raise RuntimeError, "bad FooBar2::used"
+ raise RuntimeError, "bad FooBar2::used"
try:
- s = b.pong()
- if s != "Bar::pong();Foo::pong();Bar::ping();":
- raise RuntimeError
- pass
+ s = b.pong()
+ if s != "Bar::pong();Foo::pong();Bar::ping();":
+ raise RuntimeError
+ pass
except:
- raise RuntimeError, "bad Bar::pong"
+ raise RuntimeError, "bad Bar::pong"
try:
- s = f.pong()
- if s != "Bar::pong();Foo::pong();Bar::ping();":
- raise RuntimeError
- pass
+ s = f.pong()
+ if s != "Bar::pong();Foo::pong();Bar::ping();":
+ raise RuntimeError
+ pass
except:
- raise RuntimeError," bad Foo::pong"
-
+ raise RuntimeError, " bad Foo::pong"
+
try:
- s = fb.pong()
- if s != "Bar::pong();Foo::pong();FooBar::ping();":
- raise RuntimeError
- pass
+ s = fb.pong()
+ if s != "Bar::pong();Foo::pong();FooBar::ping();":
+ raise RuntimeError
+ pass
except:
- raise RuntimeError," bad FooBar::pong"
+ raise RuntimeError, " bad FooBar::pong"
-protected=1
+protected = 1
try:
- b.ping()
- protected=0
+ b.ping()
+ protected = 0
except:
- pass
+ pass
if not protected:
- raise RuntimeError,"Foo::ping is protected"
-
-protected=1
+ raise RuntimeError, "Foo::ping is protected"
+
+protected = 1
try:
- f.ping()
- protected=0
+ f.ping()
+ protected = 0
except:
- pass
+ pass
if not protected:
- raise RuntimeError,"Foo::ping is protected"
+ raise RuntimeError, "Foo::ping is protected"
-protected=1
+protected = 1
try:
- f.pang()
- protected=0
+ f.pang()
+ protected = 0
except:
- pass
+ pass
if not protected:
- raise RuntimeError,"FooBar::pang is protected"
+ raise RuntimeError, "FooBar::pang is protected"
-protected=1
+protected = 1
try:
- b.cheer()
- protected=0
+ b.cheer()
+ protected = 0
except:
- pass
+ pass
if not protected:
- raise RuntimeError,"Bar::cheer is protected"
+ raise RuntimeError, "Bar::cheer is protected"
-protected=1
+protected = 1
try:
- f.cheer()
- protected=0
+ f.cheer()
+ protected = 0
except:
- pass
+ pass
if not protected:
- raise RuntimeError,"Foo::cheer is protected"
+ raise RuntimeError, "Foo::cheer is protected"
if fb3.cheer() != "FooBar3::cheer();":
- raise RuntimeError, "bad fb3::cheer"
+ raise RuntimeError, "bad fb3::cheer"
if fb2.callping() != "FooBar2::ping();":
- raise RuntimeError, "bad fb2.callping"
+ raise RuntimeError, "bad fb2.callping"
if fb2.callcheer() != "FooBar2::pang();Bar::pong();Foo::pong();FooBar2::ping();":
- raise RuntimeError, "bad fb2.callcheer"
+ raise RuntimeError, "bad fb2.callcheer"
if fb3.callping() != "Bar::ping();":
- raise RuntimeError, "bad fb3.callping"
+ raise RuntimeError, "bad fb3.callping"
if fb3.callcheer() != "FooBar3::cheer();":
- raise RuntimeError, "bad fb3.callcheer"
-
-
+ raise RuntimeError, "bad fb3.callcheer"
--- /dev/null
+from director_smartptr import *
+
+
+class director_smartptr_MyBarFoo(Foo):
+
+ def ping(self):
+ return "director_smartptr_MyBarFoo.ping()"
+
+ def pong(self):
+ return "director_smartptr_MyBarFoo.pong();" + self.ping()
+
+ def upcall(self, fooBarPtr):
+ return "override;" + fooBarPtr.FooBarDo()
+
+ def makeFoo(self):
+ return Foo()
+
+def check(got, expected):
+ if (got != expected):
+ raise RuntimeError, "Failed, got: " + got + " expected: " + expected
+
+fooBar = FooBar()
+
+myBarFoo = director_smartptr_MyBarFoo()
+check(myBarFoo.ping(), "director_smartptr_MyBarFoo.ping()")
+check(Foo.callPong(myBarFoo), "director_smartptr_MyBarFoo.pong();director_smartptr_MyBarFoo.ping()")
+check(Foo.callUpcall(myBarFoo, fooBar), "override;Bar::Foo2::Foo2Bar()")
+
+myFoo = myBarFoo.makeFoo()
+check(myFoo.pong(), "Foo::pong();Foo::ping()")
+check(Foo.callPong(myFoo), "Foo::pong();Foo::ping()")
+check(myFoo.upcall(FooBar()), "Bar::Foo2::Foo2Bar()")
+
+myFoo2 = Foo().makeFoo()
+check(myFoo2.pong(), "Foo::pong();Foo::ping()")
+check(Foo.callPong(myFoo2), "Foo::pong();Foo::ping()")
+check(myFoo2.upcall(FooBar()), "Bar::Foo2::Foo2Bar()")
import director_stl
+
class MyFoo(director_stl.Foo):
- def ping(self, s):
- return "MyFoo::ping():" + s
- def pident(self, arg):
- return arg
-
- def vident(self,v):
- return v
+ def ping(self, s):
+ return "MyFoo::ping():" + s
+
+ def pident(self, arg):
+ return arg
+
+ def vident(self, v):
+ return v
- def vidents(self,v):
- return v
+ def vidents(self, v):
+ return v
- def vsecond(self,v1,v2):
- return v2
+ def vsecond(self, v1, v2):
+ return v2
a = MyFoo()
a.tping("hello")
a.tpong("hello")
-p = (1,2)
+p = (1, 2)
a.pident(p)
-v = (3,4)
+v = (3, 4)
a.vident(v)
a.tpident(p)
a.tvident(v)
-v1 = (3,4)
-v2 = (5,6)
-a.tvsecond(v1,v2)
+v1 = (3, 4)
+v2 = (5, 6)
+a.tvsecond(v1, v2)
-vs=("hi", "hello")
+vs = ("hi", "hello")
vs
a.tvidents(vs)
from director_string import *
+
class B(A):
- def __init__(self,string):
- A.__init__(self,string)
- def get_first(self):
- return A.get_first(self) + " world!"
+ def __init__(self, string):
+ A.__init__(self, string)
+
+ def get_first(self):
+ return A.get_first(self) + " world!"
- def process_text(self, string):
- A.process_text(self, string)
- self.smem = "hello"
-
+ def process_text(self, string):
+ A.process_text(self, string)
+ self.smem = "hello"
b = B("hello")
b.get(0)
if b.get_first() != "hello world!":
- print b.get_first()
- raise RuntimeError
+ print b.get_first()
+ raise RuntimeError
b.call_process_func()
if b.smem != "hello":
- print smem
- raise RuntimeError
-
+ print smem
+ raise RuntimeError
from director_thread import Foo
-class Derived(Foo) :
+
+class Derived(Foo):
+
def __init__(self):
Foo.__init__(self)
import director_unroll
+
class MyFoo(director_unroll.Foo):
- def ping(self):
- return "MyFoo::ping()"
+
+ def ping(self):
+ return "MyFoo::ping()"
a = MyFoo()
if not (a.this == c.this):
- print a, c
- raise RuntimeError
-
+ print a, c
+ raise RuntimeError
from director_wstring import *
+
class B(A):
- def __init__(self,string):
- A.__init__(self,string)
- def get_first(self):
- return A.get_first(self) + u" world!"
+ def __init__(self, string):
+ A.__init__(self, string)
+
+ def get_first(self):
+ return A.get_first(self) + u" world!"
- def process_text(self, string):
- self.smem = u"hello"
-
+ def process_text(self, string):
+ self.smem = u"hello"
b = B(u"hello")
b.get(0)
if b.get_first() != u"hello world!":
- print b.get_first()
- raise RuntimeError
+ print b.get_first()
+ raise RuntimeError
b.call_process_func()
if b.smem != u"hello":
- print smem
- raise RuntimeError
-
+ print smem
+ raise RuntimeError
a.thisown = tmp
if (a.thisown != tmp):
- raise RuntimeError
+ raise RuntimeError
b = B()
a = dynamic_cast.do_test(y)
if a != "Bar::test":
print "Failed!!"
-
--- /dev/null
+import empty_c
import enum_forward
-
-f1 = enum_forward.get_enum1();
-f1 = enum_forward.test_function1(f1);
-f2 = enum_forward.get_enum2();
-f2 = enum_forward.test_function2(f2);
+f1 = enum_forward.get_enum1()
+f1 = enum_forward.test_function1(f1)
-f3 = enum_forward.get_enum3();
-f3 = enum_forward.test_function3(f3);
+f2 = enum_forward.get_enum2()
+f2 = enum_forward.test_function2(f2)
+
+f3 = enum_forward.get_enum3()
+f3 = enum_forward.test_function3(f3)
import enum_template
if enum_template.MakeETest() != 1:
- raise RuntimeError
+ raise RuntimeError
if enum_template.TakeETest(0) != None:
- raise RuntimeError
-
+ raise RuntimeError
_enums.bar1(1)
if _enums.cvar.enumInstance != 2:
- raise RuntimeError
+ raise RuntimeError
if _enums.cvar.Slap != 10:
- raise RuntimeError
+ raise RuntimeError
if _enums.cvar.Mine != 11:
- raise RuntimeError
+ raise RuntimeError
if _enums.cvar.Thigh != 12:
- raise RuntimeError
-
+ raise RuntimeError
--- /dev/null
+import exception_classname
+
+a = exception_classname.Exception()
+assert a.testfunc() == 42
# This test is expected to fail with -builtin option.
# Throwing builtin classes as exceptions not supported
+if is_python_builtin():
+ exit(0)
a = A()
try:
- a.foo()
-except E1,e:
- pass
+ a.foo()
+except E1, e:
+ pass
except:
- raise RuntimeError, "bad exception order"
+ raise RuntimeError, "bad exception order"
try:
- a.bar()
-except E2,e:
- pass
+ a.bar()
+except E2, e:
+ pass
except:
- raise RuntimeError, "bad exception order"
+ raise RuntimeError, "bad exception order"
try:
- a.foobar()
-except RuntimeError,e:
- if e.args[0] != "postcatch unknown":
- print "bad exception order",
- raise RuntimeError, e.args
-
+ a.foobar()
+except RuntimeError, e:
+ if e.args[0] != "postcatch unknown":
+ print "bad exception order",
+ raise RuntimeError, e.args
try:
- a.barfoo(1)
-except E1,e:
- pass
+ a.barfoo(1)
+except E1, e:
+ pass
except:
- raise RuntimeError, "bad exception order"
+ raise RuntimeError, "bad exception order"
try:
- a.barfoo(2)
-except E2,e:
- pass
+ a.barfoo(2)
+except E2, e:
+ pass
except:
- raise RuntimeError, "bad exception order"
+ raise RuntimeError, "bad exception order"
foo = extend_placement.Foo()
foo = extend_placement.Foo(1)
-foo = extend_placement.Foo(1,1)
+foo = extend_placement.Foo(1, 1)
foo.spam()
foo.spam("hello")
foo.spam(1)
-foo.spam(1,1)
-foo.spam(1,1,1)
+foo.spam(1, 1)
+foo.spam(1, 1, 1)
foo.spam(extend_placement.Foo())
foo.spam(extend_placement.Foo(), 1.0)
bar.spam()
bar.spam("hello")
bar.spam(1)
-bar.spam(1,1)
-bar.spam(1,1,1)
+bar.spam(1, 1)
+bar.spam(1, 1, 1)
bar.spam(extend_placement.Bar())
bar.spam(extend_placement.Bar(), 1.0)
foo = extend_placement.FooTi()
foo = extend_placement.FooTi(1)
-foo = extend_placement.FooTi(1,1)
+foo = extend_placement.FooTi(1, 1)
foo.spam()
foo.spam("hello")
foo.spam(1)
-foo.spam(1,1)
-foo.spam(1,1,1)
+foo.spam(1, 1)
+foo.spam(1, 1, 1)
foo.spam(extend_placement.Foo())
foo.spam(extend_placement.Foo(), 1.0)
bar.spam()
bar.spam("hello")
bar.spam(1)
-bar.spam(1,1)
-bar.spam(1,1,1)
+bar.spam(1, 1)
+bar.spam(1, 1, 1)
bar.spam(extend_placement.Bar())
bar.spam(extend_placement.Bar(), 1.0)
import extern_c
extern_c.RealFunction(2)
-
import file_test
if sys.version_info[0:2] < (3, 0):
- file_test.nfile(sys.stdout)
+ file_test.nfile(sys.stdout)
cstdout = file_test.GetStdOut()
a = friends.A(2)
-if friends.get_val1(a) != 2: raise RuntimeError
-if friends.get_val2(a) != 4: raise RuntimeError
-if friends.get_val3(a) != 6: raise RuntimeError
+if friends.get_val1(a) != 2:
+ raise RuntimeError
+if friends.get_val2(a) != 4:
+ raise RuntimeError
+if friends.get_val3(a) != 6:
+ raise RuntimeError
# nice overload working fine
-if friends.get_val1(1,2,3) != 1: raise RuntimeError
+if friends.get_val1(1, 2, 3) != 1:
+ raise RuntimeError
b = friends.B(3)
# David's case
-if friends.mix(a,b) != 5: raise RuntimeError
+if friends.mix(a, b) != 5:
+ raise RuntimeError
di = friends.D_d(2)
dd = friends.D_d(3.3)
# incredible template overloading working just fine
-if friends.get_val1(di) != 2: raise RuntimeError
-if friends.get_val1(dd) != 3.3: raise RuntimeError
+if friends.get_val1(di) != 2:
+ raise RuntimeError
+if friends.get_val1(dd) != 3.3:
+ raise RuntimeError
friends.set(di, 4)
friends.set(dd, 1.3)
-if friends.get_val1(di) != 4: raise RuntimeError
-if friends.get_val1(dd) != 1.3: raise RuntimeError
+if friends.get_val1(di) != 4:
+ raise RuntimeError
+if friends.get_val1(dd) != 1.3:
+ raise RuntimeError
from funcptr_cpp import *
if call1(ADD_BY_VALUE, 10, 11) != 21:
- raise RuntimeError
+ raise RuntimeError
if call2(ADD_BY_POINTER, 12, 13) != 25:
- raise RuntimeError
+ raise RuntimeError
if call3(ADD_BY_REFERENCE, 14, 15) != 29:
- raise RuntimeError
-
+ raise RuntimeError
+if call1(ADD_BY_VALUE_C, 2, 3) != 5:
+ raise RuntimeError
sw = NodeSwitch()
n = Node()
-i = sw.addChild(n);
+i = sw.addChild(n)
if i != 2:
- raise RuntimeError, "addChild"
-
+ raise RuntimeError, "addChild"
--- /dev/null
+from global_functions import *
+
+
+def check(a, b):
+ if a != b:
+ raise RuntimeError("Failed: " + str(a) + " != " + str(b))
+global_void()
+check(global_one(1), 1)
+check(global_two(2, 2), 4)
+
+fail = True
+try:
+ global_void(1)
+except TypeError, e:
+ fail = False
+if fail:
+ raise RuntimeError("argument count check failed")
+
+fail = True
+try:
+ global_one()
+except TypeError, e:
+ fail = False
+if fail:
+ raise RuntimeError("argument count check failed")
+
+fail = True
+try:
+ global_one(2, 2)
+except TypeError, e:
+ fail = False
+
+if fail:
+ raise RuntimeError("argument count check failed")
+
+fail = True
+try:
+ global_two(1)
+except TypeError, e:
+ fail = False
+
+if fail:
+ raise RuntimeError("argument count check failed")
+
+fail = True
+try:
+ global_two(3, 3, 3)
+except TypeError, e:
+ fail = False
+
+if fail:
+ raise RuntimeError("argument count check failed")
from global_namespace import *
+
+def is_new_style_class(cls):
+ return hasattr(cls, "__class__")
+
k1 = Klass1()
k2 = Klass2()
k3 = Klass3()
k6 = Klass6()
k7 = Klass7()
-KlassMethods.methodA(k1, k2, k3, k4, k5, k6, k7)
-KlassMethods.methodB(k1, k2, k3, k4, k5, k6, k7)
+if is_new_style_class(KlassMethods):
+ KlassMethods_static = KlassMethods
+else:
+ KlassMethods_static = KlassMethods()
+KlassMethods_static.methodA(k1, k2, k3, k4, k5, k6, k7)
+KlassMethods_static.methodB(k1, k2, k3, k4, k5, k6, k7)
k1 = getKlass1A()
k2 = getKlass2A()
k6 = getKlass6A()
k7 = getKlass7A()
-KlassMethods.methodA(k1, k2, k3, k4, k5, k6, k7)
-KlassMethods.methodB(k1, k2, k3, k4, k5, k6, k7)
+KlassMethods_static.methodA(k1, k2, k3, k4, k5, k6, k7)
+KlassMethods_static.methodB(k1, k2, k3, k4, k5, k6, k7)
k1 = getKlass1B()
k2 = getKlass2B()
k6 = getKlass6B()
k7 = getKlass7B()
-KlassMethods.methodA(k1, k2, k3, k4, k5, k6, k7)
-KlassMethods.methodB(k1, k2, k3, k4, k5, k6, k7)
-
-XYZMethods.methodA(XYZ1(), XYZ2(), XYZ3(), XYZ4(), XYZ5(), XYZ6(), XYZ7())
-XYZMethods.methodB(XYZ1(), XYZ2(), XYZ3(), XYZ4(), XYZ5(), XYZ6(), XYZ7())
-
-TheEnumMethods.methodA(theenum1, theenum2, theenum3)
-TheEnumMethods.methodA(theenum1, theenum2, theenum3)
+KlassMethods_static.methodA(k1, k2, k3, k4, k5, k6, k7)
+KlassMethods_static.methodB(k1, k2, k3, k4, k5, k6, k7)
+
+if is_new_style_class(XYZMethods):
+ XYZMethods_static = XYZMethods
+else:
+ XYZMethods_static = XYZMethods()
+XYZMethods_static.methodA(
+ XYZ1(), XYZ2(), XYZ3(), XYZ4(), XYZ5(), XYZ6(), XYZ7())
+XYZMethods_static.methodB(
+ XYZ1(), XYZ2(), XYZ3(), XYZ4(), XYZ5(), XYZ6(), XYZ7())
+
+if is_new_style_class(TheEnumMethods):
+ TheEnumMethods_static = TheEnumMethods
+else:
+ TheEnumMethods_static = TheEnumMethods()
+TheEnumMethods_static.methodA(theenum1, theenum2, theenum3)
+TheEnumMethods_static.methodA(theenum1, theenum2, theenum3)
a = foo(1)
b = bar_fn()
-
--- /dev/null
+import global_vars
+
+global_vars.init()
+b = global_vars.cvar.b
+if b != "string b":
+ raise RuntimeError("Unexpected string: " + b)
+global_vars.cvar.b = "a string value"
+b = global_vars.cvar.b
+if b != "a string value":
+ raise RuntimeError("Unexpected string: " + b)
+
+x = global_vars.cvar.x
+if x != 1234:
+ raise RuntimeError("Unexpected x: " + str(x))
+global_vars.cvar.x = 9876
+x = global_vars.cvar.x
+if x != 9876:
+ raise RuntimeError("Unexpected string: " + str(x))
+
+fail = True
+try:
+ global_vars.cvar.notexist = "something"
+except AttributeError, e:
+ fail = False
+if fail:
+ raise RuntimeError("AttributeError should have been thrown")
+
+fail = True
+try:
+ g = global_vars.cvar.notexist
+except AttributeError, e:
+ fail = False
+if fail:
+ raise RuntimeError("AttributeError should have been thrown")
f = iadd.Foo()
f.AsA.x = 3
-f.AsA += f.AsA
+f.AsA += f.AsA
if f.AsA.x != 6:
raise RuntimeError
from implicittest import *
+
def check(a, b):
if a != b:
raise RuntimeError(str(a) + " does not equal " + str(b))
+
+def is_new_style_class(cls):
+ return hasattr(cls, "__class__")
+
#### Class ####
# No implicit conversion
except ValueError:
# ValueError: invalid null reference in method 'new_A', argument 1 of type 'B const &'
# Arguably A(char *) should be chosen, but there is a bug to do with None passed to methods overloaded by value,
- # references and pointers to different types, where pointers ought to be given a slightly higher precedence.
+ # references and pointers to different types, where pointers ought to be
+ # given a slightly higher precedence.
pass
check(1, get(1))
check(3, A_int(B()).get())
check(4, A_int("hello").get())
-check(1, A_int.sget(1))
-check(2, A_int.sget(1.0))
-check(3, A_int.sget(B()))
+if is_new_style_class(A_int):
+ A_int_static = A_int
+else:
+ A_int_static = A_int(0)
+check(1, A_int_static.sget(1))
+check(2, A_int_static.sget(1.0))
+check(3, A_int_static.sget(B()))
# explicit constructor:
try:
- check(4, A_int.sget("hello"))
+ check(4, A_int_static.sget("hello"))
raise RuntimeError
except TypeError:
pass
#### Global variable assignment ####
-cvar.foo = Foo(1); check(cvar.foo.ii, 1)
-cvar.foo = 1; check(cvar.foo.ii, 1)
-cvar.foo = 1.0; check(cvar.foo.ii, 2)
-cvar.foo = Foo("hello"); check(cvar.foo.ii, 3)
+cvar.foo = Foo(1)
+check(cvar.foo.ii, 1)
+cvar.foo = 1
+check(cvar.foo.ii, 1)
+cvar.foo = 1.0
+check(cvar.foo.ii, 2)
+cvar.foo = Foo("hello")
+check(cvar.foo.ii, 3)
# explicit constructor:
try:
#### Member variable assignment ####
# Note: also needs naturalvar
-b = Bar(); check(b.f.ii, 0)
-b.f = Foo("hello"); check(b.f.ii, 3)
-b.f = 1; check(b.f.ii, 1)
-b.f = 1.0; check(b.f.ii, 2)
+b = Bar()
+check(b.f.ii, 0)
+b.f = Foo("hello")
+check(b.f.ii, 3)
+b.f = 1
+check(b.f.ii, 1)
+b.f = 1.0
+check(b.f.ii, 2)
# explicit constructor:
try:
check(ccc.checkvalue, 10)
check(ccc.xx(123), 11)
check(ccc.yy(123, 123), 111)
-
from import_nomodule import *
+# This test is expected to fail with -builtin option.
+# The base class is needed for the builtin class hierarchy
+if is_python_builtin():
+ exit(0)
+
f = create_Foo()
-test1(f,42)
+test1(f, 42)
delete_Foo(f)
b = Bar()
-test1(b,37)
+test1(b, 37)
import import_stl_b
import import_stl_a
-v_new = import_stl_b.process_vector([1,2,3])
-if v_new != (1,2,3,4):
- raise RuntimeError, v_new
-
+v_new = import_stl_b.process_vector([1, 2, 3])
+if v_new != (1, 2, 3, 4):
+ raise RuntimeError, v_new
a2 = c.get_a_type(c)
if a1.hello() != a2.hello():
- raise RuntimeError
+ raise RuntimeError
error = 0
try:
- a = inctest.A()
+ a = inctest.A()
except:
- print "didn't find A"
- print "therefore, I didn't include 'testdir/subdir1/hello.i'"
- error = 1
+ print "didn't find A"
+ print "therefore, I didn't include 'testdir/subdir1/hello.i'"
+ error = 1
pass
try:
- b = inctest.B()
+ b = inctest.B()
except:
- print "didn't find B"
- print "therefore, I didn't include 'testdir/subdir2/hello.i'"
- error = 1
+ print "didn't find B"
+ print "therefore, I didn't include 'testdir/subdir2/hello.i'"
+ error = 1
pass
if error == 1:
- raise RuntimeError
+ raise RuntimeError
# Check the import in subdirectory worked
if inctest.importtest1(5) != 15:
- print "import test 1 failed"
- raise RuntimeError
+ print "import test 1 failed"
+ raise RuntimeError
if inctest.importtest2("black") != "white":
- print "import test 2 failed"
- raise RuntimeError
-
+ print "import test 2 failed"
+ raise RuntimeError
a = inout.AddOne1(1)
if a != 2:
- raise RuntimeError
+ raise RuntimeError
-a = inout.AddOne3(1,1,1)
-if a != [2,2,2]:
- raise RuntimeError
+a = inout.AddOne3(1, 1, 1)
+if a != [2, 2, 2]:
+ raise RuntimeError
-a = inout.AddOne1p((1,1))
-if a != (2,2):
- raise RuntimeError
+a = inout.AddOne1p((1, 1))
+if a != (2, 2):
+ raise RuntimeError
-a = inout.AddOne2p((1,1),1)
-if a != [(2,2),2]:
- raise RuntimeError
-
-a = inout.AddOne3p(1,(1,1),1)
-if a != [2,(2,2),2]:
- raise RuntimeError
+a = inout.AddOne2p((1, 1), 1)
+if a != [(2, 2), 2]:
+ raise RuntimeError
+a = inout.AddOne3p(1, (1, 1), 1)
+if a != [2, (2, 2), 2]:
+ raise RuntimeError
a += 5
if a.val != 12:
- print a.val
- raise RuntimeError
+ print a.val
+ raise RuntimeError
a -= 5
if a.val != 7:
- raise RuntimeError
+ raise RuntimeError
a *= 2
if a.val != 14:
- raise RuntimeError
+ raise RuntimeError
a += a
if a.val != 28:
- raise RuntimeError
+ raise RuntimeError
f = Foo()
if f.foo(2) != 4:
- raise RuntimeError
-
-if f.foo(None)!= None:
- raise RuntimeError
+ raise RuntimeError
-if f.foo()!= None:
- raise RuntimeError
+if f.foo(None) != None:
+ raise RuntimeError
+
+if f.foo() != None:
+ raise RuntimeError
if sfoo("Hello") != "Hello world":
- raise RuntimeError
+ raise RuntimeError
if sfoo(None) != None:
- raise RuntimeError
+ raise RuntimeError
if sfoo() != None:
- raise RuntimeError
+ raise RuntimeError
--- /dev/null
+#!/usr/bin/env python
+import keyword_rename_c
+keyword_rename_c._in(1)
+keyword_rename_c._except(1)
from kwargs_feature import *
+
class MyFoo(Foo):
- def __init__(self, a , b = 0):
- Foo.__init__(self, a, b)
-
+ def __init__(self, a, b=0):
+ Foo.__init__(self, a, b)
+
# Simple class
f1 = MyFoo(2)
-f = Foo(b=2,a=1)
+f = Foo(b=2, a=1)
-if f.foo(b=1,a=2) != 3:
- raise RuntimeError
+if f.foo(b=1, a=2) != 3:
+ raise RuntimeError
if Foo_statfoo(b=2) != 3:
- raise RuntimeError
+ raise RuntimeError
if f.efoo(b=2) != 3:
- raise RuntimeError
+ raise RuntimeError
if Foo_sfoo(b=2) != 3:
- raise RuntimeError
+ raise RuntimeError
# Templated class
-b = BarInt(b=2,a=1)
+b = BarInt(b=2, a=1)
-if b.bar(b=1,a=2) != 3:
- raise RuntimeError
+if b.bar(b=1, a=2) != 3:
+ raise RuntimeError
if BarInt_statbar(b=2) != 3:
- raise RuntimeError
+ raise RuntimeError
if b.ebar(b=2) != 3:
- raise RuntimeError
+ raise RuntimeError
if BarInt_sbar(b=2) != 3:
- raise RuntimeError
+ raise RuntimeError
# Functions
if templatedfunction(b=2) != 3:
- raise RuntimeError
+ raise RuntimeError
-if foo(a=1,b=2) != 3:
- raise RuntimeError
+if foo_fn(a=1, b=2) != 3:
+ raise RuntimeError
-if foo(b=2) != 3:
- raise RuntimeError
+if foo_fn(b=2) != 3:
+ raise RuntimeError
-#Funtions with keywords
+# Functions with keywords
if foo_kw(_from=2) != 4:
- raise RuntimeError
+ raise RuntimeError
if foo_nu(_from=2, arg2=3) != 2:
- raise RuntimeError
+ raise RuntimeError
if foo_mm(min=2) != 4:
- raise RuntimeError
+ raise RuntimeError
if foo_mm(max=3) != 4:
- raise RuntimeError
-
+ raise RuntimeError
+
+# Default args with references
+
+if rfoo(n=123) != 120:
+ raise RuntimeError
+
+if rfoo(x=10) != -10:
+ raise RuntimeError
+
+if rfoo(n=11, x=22) != -11:
+ raise RuntimeError
+
+if rfoo(x=11, n=22) != 11:
+ raise RuntimeError
from langobj import *
-x ="hello"
+x = "hello"
rx = sys.getrefcount(x)
v = identity(x)
rv = sys.getrefcount(v)
import li_attribute
-aa = li_attribute.A(1,2,3)
+aa = li_attribute.A(1, 2, 3)
if aa.a != 1:
- raise RuntimeError
+ raise RuntimeError
aa.a = 3
if aa.a != 3:
- print aa.a
- raise RuntimeError
+ print aa.a
+ raise RuntimeError
if aa.b != 2:
- print aa.b
- raise RuntimeError
+ print aa.b
+ raise RuntimeError
aa.b = 5
if aa.b != 5:
- raise RuntimeError
+ raise RuntimeError
if aa.d != aa.b:
- raise RuntimeError
+ raise RuntimeError
if aa.c != 3:
- raise RuntimeError
+ raise RuntimeError
#aa.c = 5
-#if aa.c != 3:
+# if aa.c != 3:
# raise RuntimeError
pi = li_attribute.Param_i(7)
if pi.value != 7:
- raise RuntimeError
+ raise RuntimeError
-pi.value=3
+pi.value = 3
if pi.value != 3:
- raise RuntimeError
+ raise RuntimeError
b = li_attribute.B(aa)
if b.a.c != 3:
- raise RuntimeError
-
+ raise RuntimeError
+
# class/struct attribute with get/set methods using return/pass by reference
myFoo = li_attribute.MyFoo()
myFoo.x = 8
myClass = li_attribute.MyClass()
myClass.Foo = myFoo
if myClass.Foo.x != 8:
- raise RuntimeError
+ raise RuntimeError
# class/struct attribute with get/set methods using return/pass by value
myClassVal = li_attribute.MyClassVal()
if myClassVal.ReadWriteFoo.x != -1:
- raise RuntimeError
+ raise RuntimeError
if myClassVal.ReadOnlyFoo.x != -1:
- raise RuntimeError
+ raise RuntimeError
myClassVal.ReadWriteFoo = myFoo
if myClassVal.ReadWriteFoo.x != 8:
- raise RuntimeError
+ raise RuntimeError
if myClassVal.ReadOnlyFoo.x != 8:
- raise RuntimeError
+ raise RuntimeError
# string attribute with get/set methods using return/pass by value
myStringyClass = li_attribute.MyStringyClass("initial string")
if myStringyClass.ReadWriteString != "initial string":
- raise RuntimeError
+ raise RuntimeError
if myStringyClass.ReadOnlyString != "initial string":
- raise RuntimeError
+ raise RuntimeError
myStringyClass.ReadWriteString = "changed string"
if myStringyClass.ReadWriteString != "changed string":
- raise RuntimeError
+ raise RuntimeError
if myStringyClass.ReadOnlyString != "changed string":
- raise RuntimeError
+ raise RuntimeError
+
+# Check a proper AttributeError is raised for non-existent attributes, old versions used to raise unhelpful error:
+# AttributeError: type object 'object' has no attribute '__getattr__'
+try:
+ x = myFoo.does_not_exist
+ raise RuntimeError
+except AttributeError, e:
+ if str(e).find("does_not_exist") == -1:
+ raise RuntimeError
import li_attribute_template
-chell = li_attribute_template.Cintint(1,2,3)
+chell = li_attribute_template.Cintint(1, 2, 3)
-def rassert( what, master ):
+
+def rassert(what, master):
if what != master:
print what
raise RuntimeError
-## Testing primitive by value attribute
-rassert( chell.a, 1 )
+# Testing primitive by value attribute
+rassert(chell.a, 1)
chell.a = 3
-rassert( chell.a, 3 )
+rassert(chell.a, 3)
-## Testing primitive by ref attribute
+# Testing primitive by ref attribute
-rassert( chell.b, 2 )
+rassert(chell.b, 2)
chell.b = 5
-rassert( chell.b,5 )
+rassert(chell.b, 5)
-## Testing string
+# Testing string
chell.str = "abc"
-rassert( chell.str, "abc" )
+rassert(chell.str, "abc")
# Testing class by value
-rassert( chell.d.value, 1 )
+rassert(chell.d.value, 1)
chell.d = li_attribute_template.Foo(2)
-rassert( chell.d.value, 2 )
+rassert(chell.d.value, 2)
# Testing class by reference
-rassert( chell.e.value, 2 )
+rassert(chell.e.value, 2)
-chell.e= li_attribute_template.Foo(3)
-rassert( chell.e.value, 3 )
+chell.e = li_attribute_template.Foo(3)
+rassert(chell.e.value, 3)
chell.e.value = 4
-rassert( chell.e.value, 4 )
+rassert(chell.e.value, 4)
# Testing moderately complex template by value
-rassert( chell.f.first, 1 )
-rassert( chell.f.second, 2 )
+rassert(chell.f.first, 1)
+rassert(chell.f.second, 2)
-pair = li_attribute_template.pair_intint(3,4)
+pair = li_attribute_template.pair_intint(3, 4)
chell.f = pair
-rassert( chell.f.first, 3 )
-rassert( chell.f.second, 4 )
+rassert(chell.f.first, 3)
+rassert(chell.f.second, 4)
# Testing moderately complex template by ref
-rassert( chell.g.first, 2 )
-rassert( chell.g.second, 3 )
+rassert(chell.g.first, 2)
+rassert(chell.g.second, 3)
-pair = li_attribute_template.pair_intint(4,5)
+pair = li_attribute_template.pair_intint(4, 5)
chell.g = pair
-rassert( chell.g.first, 4 )
-rassert( chell.g.second, 5 )
+rassert(chell.g.first, 4)
+rassert(chell.g.second, 5)
chell.g.first = 6
chell.g.second = 7
-rassert( chell.g.first, 6 )
-rassert( chell.g.second, 7 )
+rassert(chell.g.first, 6)
+rassert(chell.g.second, 7)
--- /dev/null
+from li_boost_array import *
+import sys
+
+
+def failed(a, b, msg):
+ raise RuntimeError, msg + " " + str(list(a)) + " " + str(list(b))
+
+
+def compare_sequences(a, b):
+ if len(a) != len(b):
+ failed(a, b, "different sizes")
+ for i in range(len(a)):
+ if a[i] != b[i]:
+ failed(a, b, "elements are different")
+
+def compare_containers(pythonlist, swigarray):
+ compare_sequences(pythonlist, swigarray)
+
+ps = [0, 1, 2, 3, 4, 5]
+
+ai = ArrayInt6(ps)
+
+compare_containers(ps, ai)
+
+# Modify content
+for i in range(len(ps)):
+ ps[i] = (ps[i] + 1) * 10
+ ai[i] = (ai[i] + 1) * 10
+compare_containers(ps, ai)
+
+# Empty
+ai = ArrayInt6()
+compare_containers([0, 0, 0, 0, 0, 0], ai)
+
+# Check return
+compare_containers(arrayOutVal(), [-2, -1, 0, 0, 1, 2])
+compare_containers(arrayOutConstRef(), [-2, -1, 0, 0, 1, 2])
+#compare_containers(arrayOutRef(), [-2, -1, 0, 0, 1, 2])
+#compare_containers(arrayOutPtr(), [-2, -1, 0, 0, 1, 2])
+
+# Check passing arguments
+ai = arrayInVal([9, 8, 7, 6, 5, 4])
+compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+ai = arrayInConstRef([9, 8, 7, 6, 5, 4])
+compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+#ai = ArrayInt6([9, 8, 7, 6, 5, 4])
+#arrayInRef(ai)
+#compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+#ai = ArrayInt6([9, 8, 7, 6, 5, 4])
+#arrayInPtr(ai)
+#compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
from li_boost_shared_ptr_bits import *
+
+def is_new_style_class(cls):
+ return hasattr(cls, "__class__")
+
+
def check(nd):
- nd.i = 200
- i = nd.i
+ nd.i = 200
+ i = nd.i
- try:
- nd.notexist = 100
- passed = 0
- except:
- passed = 1
+ try:
+ nd.notexist = 100
+ passed = 0
+ except:
+ passed = 1
- if not passed:
- raise "Test failed"
+ if not passed:
+ raise "Test failed"
nd = NonDynamic()
check(nd)
sum = sum(v)
if sum != 66:
- raise "sum is wrong"
+ raise "sum is wrong"
################################
-p = HiddenDestructor.create()
-
+if is_new_style_class(HiddenDestructor):
+ p = HiddenDestructor.create()
+else:
+ p = HiddenDestructor_create()
debug = False
# simple shared_ptr usage - created in C++
+
+
class li_boost_shared_ptr_runme:
- def main(self):
- if (debug):
- print "Started"
-
- li_boost_shared_ptr.cvar.debug_shared = debug
-
- # Change loop count to run for a long time to monitor memory
- loopCount = 1 #5000
- for i in range (0,loopCount):
- self.runtest()
-
- # Expect 1 instance - the one global variable (GlobalValue)
- if (li_boost_shared_ptr.Klass.getTotal_count() != 1):
- raise RuntimeError("Klass.total_count=%s" % li_boost_shared_ptr.Klass.getTotal_count())
-
- wrapper_count = li_boost_shared_ptr.shared_ptr_wrapper_count()
- if (wrapper_count != li_boost_shared_ptr.NOT_COUNTING):
- # Expect 1 instance - the one global variable (GlobalSmartValue)
- if (wrapper_count != 1):
- raise RuntimeError("shared_ptr wrapper count=%s" % wrapper_count)
-
- if (debug):
- print "Finished"
-
- def runtest(self):
- # simple shared_ptr usage - created in C++
- k = li_boost_shared_ptr.Klass("me oh my")
- val = k.getValue()
- self.verifyValue("me oh my", val)
- self.verifyCount(1, k)
-
- # simple shared_ptr usage - not created in C++
- k = li_boost_shared_ptr.factorycreate()
- val = k.getValue()
- self.verifyValue("factorycreate", val)
- self.verifyCount(1, k)
-
- # pass by shared_ptr
- k = li_boost_shared_ptr.Klass("me oh my")
- kret = li_boost_shared_ptr.smartpointertest(k)
- val = kret.getValue()
- self.verifyValue("me oh my smartpointertest", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # pass by shared_ptr pointer
- k = li_boost_shared_ptr.Klass("me oh my")
- kret = li_boost_shared_ptr.smartpointerpointertest(k)
- val = kret.getValue()
- self.verifyValue("me oh my smartpointerpointertest", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # pass by shared_ptr reference
- k = li_boost_shared_ptr.Klass("me oh my")
- kret = li_boost_shared_ptr.smartpointerreftest(k)
- val = kret.getValue()
- self.verifyValue("me oh my smartpointerreftest", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # pass by shared_ptr pointer reference
- k = li_boost_shared_ptr.Klass("me oh my")
- kret = li_boost_shared_ptr.smartpointerpointerreftest(k)
- val = kret.getValue()
- self.verifyValue("me oh my smartpointerpointerreftest", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # const pass by shared_ptr
- k = li_boost_shared_ptr.Klass("me oh my")
- kret = li_boost_shared_ptr.constsmartpointertest(k)
- val = kret.getValue()
- self.verifyValue("me oh my", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # const pass by shared_ptr pointer
- k = li_boost_shared_ptr.Klass("me oh my")
- kret = li_boost_shared_ptr.constsmartpointerpointertest(k)
- val = kret.getValue()
- self.verifyValue("me oh my", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # const pass by shared_ptr reference
- k = li_boost_shared_ptr.Klass("me oh my")
- kret = li_boost_shared_ptr.constsmartpointerreftest(k)
- val = kret.getValue()
- self.verifyValue("me oh my", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # pass by value
- k = li_boost_shared_ptr.Klass("me oh my")
- kret = li_boost_shared_ptr.valuetest(k)
- val = kret.getValue()
- self.verifyValue("me oh my valuetest", val)
- self.verifyCount(1, k)
- self.verifyCount(1, kret)
-
- # pass by pointer
- k = li_boost_shared_ptr.Klass("me oh my")
- kret = li_boost_shared_ptr.pointertest(k)
- val = kret.getValue()
- self.verifyValue("me oh my pointertest", val)
- self.verifyCount(1, k)
- self.verifyCount(1, kret)
-
- # pass by reference
- k = li_boost_shared_ptr.Klass("me oh my")
- kret = li_boost_shared_ptr.reftest(k)
- val = kret.getValue()
- self.verifyValue("me oh my reftest", val)
- self.verifyCount(1, k)
- self.verifyCount(1, kret)
-
- # pass by pointer reference
- k = li_boost_shared_ptr.Klass("me oh my")
- kret = li_boost_shared_ptr.pointerreftest(k)
- val = kret.getValue()
- self.verifyValue("me oh my pointerreftest", val)
- self.verifyCount(1, k)
- self.verifyCount(1, kret)
-
- # null tests
- k = None
-
- if (li_boost_shared_ptr.smartpointertest(k) != None):
- raise RuntimeError("return was not null")
-
- if (li_boost_shared_ptr.smartpointerpointertest(k) != None):
- raise RuntimeError("return was not null")
-
- if (li_boost_shared_ptr.smartpointerreftest(k) != None):
- raise RuntimeError("return was not null")
-
- if (li_boost_shared_ptr.smartpointerpointerreftest(k) != None):
- raise RuntimeError("return was not null")
-
- if (li_boost_shared_ptr.nullsmartpointerpointertest(None) != "null pointer"):
- raise RuntimeError("not null smartpointer pointer")
-
- try:
- li_boost_shared_ptr.valuetest(k)
- raise RuntimeError("Failed to catch null pointer")
- except ValueError:
- pass
-
- if (li_boost_shared_ptr.pointertest(k) != None):
- raise RuntimeError("return was not null")
-
- try:
- li_boost_shared_ptr.reftest(k)
- raise RuntimeError("Failed to catch null pointer")
- except ValueError:
- pass
-
- # $owner
- k = li_boost_shared_ptr.pointerownertest()
- val = k.getValue()
- self.verifyValue("pointerownertest", val)
- self.verifyCount(1, k)
- k = li_boost_shared_ptr.smartpointerpointerownertest()
- val = k.getValue()
- self.verifyValue("smartpointerpointerownertest", val)
- self.verifyCount(1, k)
-
- # //////////////////////////////// Derived class ////////////////////////////////////////
- # derived pass by shared_ptr
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.derivedsmartptrtest(k)
- val = kret.getValue()
- self.verifyValue("me oh my derivedsmartptrtest-Derived", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # derived pass by shared_ptr pointer
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.derivedsmartptrpointertest(k)
- val = kret.getValue()
- self.verifyValue("me oh my derivedsmartptrpointertest-Derived", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # derived pass by shared_ptr ref
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.derivedsmartptrreftest(k)
- val = kret.getValue()
- self.verifyValue("me oh my derivedsmartptrreftest-Derived", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # derived pass by shared_ptr pointer ref
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.derivedsmartptrpointerreftest(k)
- val = kret.getValue()
- self.verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # derived pass by pointer
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.derivedpointertest(k)
- val = kret.getValue()
- self.verifyValue("me oh my derivedpointertest-Derived", val)
- self.verifyCount(1, k)
- self.verifyCount(1, kret)
-
- # derived pass by ref
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.derivedreftest(k)
- val = kret.getValue()
- self.verifyValue("me oh my derivedreftest-Derived", val)
- self.verifyCount(1, k)
- self.verifyCount(1, kret)
-
- # //////////////////////////////// Derived and base class mixed ////////////////////////////////////////
- # pass by shared_ptr (mixed)
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.smartpointertest(k)
- val = kret.getValue()
- self.verifyValue("me oh my smartpointertest-Derived", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # pass by shared_ptr pointer (mixed)
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.smartpointerpointertest(k)
- val = kret.getValue()
- self.verifyValue("me oh my smartpointerpointertest-Derived", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # pass by shared_ptr reference (mixed)
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.smartpointerreftest(k)
- val = kret.getValue()
- self.verifyValue("me oh my smartpointerreftest-Derived", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # pass by shared_ptr pointer reference (mixed)
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.smartpointerpointerreftest(k)
- val = kret.getValue()
- self.verifyValue("me oh my smartpointerpointerreftest-Derived", val)
- self.verifyCount(2, k)
- self.verifyCount(2, kret)
-
- # pass by value (mixed)
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.valuetest(k)
- val = kret.getValue()
- self.verifyValue("me oh my valuetest", val) # note slicing
- self.verifyCount(1, k)
- self.verifyCount(1, kret)
-
- # pass by pointer (mixed)
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.pointertest(k)
- val = kret.getValue()
- self.verifyValue("me oh my pointertest-Derived", val)
- self.verifyCount(1, k)
- self.verifyCount(1, kret)
-
- # pass by ref (mixed)
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- kret = li_boost_shared_ptr.reftest(k)
- val = kret.getValue()
- self.verifyValue("me oh my reftest-Derived", val)
- self.verifyCount(1, k)
- self.verifyCount(1, kret)
-
- # //////////////////////////////// Overloading tests ////////////////////////////////////////
- # Base class
- k = li_boost_shared_ptr.Klass("me oh my")
- self.verifyValue(li_boost_shared_ptr.overload_rawbyval(k), "rawbyval")
- self.verifyValue(li_boost_shared_ptr.overload_rawbyref(k), "rawbyref")
- self.verifyValue(li_boost_shared_ptr.overload_rawbyptr(k), "rawbyptr")
- self.verifyValue(li_boost_shared_ptr.overload_rawbyptrref(k), "rawbyptrref")
-
- self.verifyValue(li_boost_shared_ptr.overload_smartbyval(k), "smartbyval")
- self.verifyValue(li_boost_shared_ptr.overload_smartbyref(k), "smartbyref")
- self.verifyValue(li_boost_shared_ptr.overload_smartbyptr(k), "smartbyptr")
- self.verifyValue(li_boost_shared_ptr.overload_smartbyptrref(k), "smartbyptrref")
-
- # Derived class
- k = li_boost_shared_ptr.KlassDerived("me oh my")
- self.verifyValue(li_boost_shared_ptr.overload_rawbyval(k), "rawbyval")
- self.verifyValue(li_boost_shared_ptr.overload_rawbyref(k), "rawbyref")
- self.verifyValue(li_boost_shared_ptr.overload_rawbyptr(k), "rawbyptr")
- self.verifyValue(li_boost_shared_ptr.overload_rawbyptrref(k), "rawbyptrref")
-
- self.verifyValue(li_boost_shared_ptr.overload_smartbyval(k), "smartbyval")
- self.verifyValue(li_boost_shared_ptr.overload_smartbyref(k), "smartbyref")
- self.verifyValue(li_boost_shared_ptr.overload_smartbyptr(k), "smartbyptr")
- self.verifyValue(li_boost_shared_ptr.overload_smartbyptrref(k), "smartbyptrref")
-
- # 3rd derived class
- k = li_boost_shared_ptr.Klass3rdDerived("me oh my")
- val = k.getValue()
- self.verifyValue("me oh my-3rdDerived", val)
- self.verifyCount(1, k)
- val = li_boost_shared_ptr.test3rdupcast(k)
- self.verifyValue("me oh my-3rdDerived", val)
- self.verifyCount(1, k)
-
- # //////////////////////////////// Member variables ////////////////////////////////////////
- # smart pointer by value
- m = li_boost_shared_ptr.MemberVariables()
- k = li_boost_shared_ptr.Klass("smart member value")
- m.SmartMemberValue = k
- val = k.getValue()
- self.verifyValue("smart member value", val)
- self.verifyCount(2, k)
-
- kmember = m.SmartMemberValue
- val = kmember.getValue()
- self.verifyValue("smart member value", val)
- self.verifyCount(3, kmember)
- self.verifyCount(3, k)
-
- del m
- self.verifyCount(2, kmember)
- self.verifyCount(2, k)
-
- # smart pointer by pointer
- m = li_boost_shared_ptr.MemberVariables()
- k = li_boost_shared_ptr.Klass("smart member pointer")
- m.SmartMemberPointer = k
- val = k.getValue()
- self.verifyValue("smart member pointer", val)
- self.verifyCount(1, k)
-
- kmember = m.SmartMemberPointer
- val = kmember.getValue()
- self.verifyValue("smart member pointer", val)
- self.verifyCount(2, kmember)
- self.verifyCount(2, k)
-
- del m
- self.verifyCount(2, kmember)
- self.verifyCount(2, k)
-
- # smart pointer by reference
- m = li_boost_shared_ptr.MemberVariables()
- k = li_boost_shared_ptr.Klass("smart member reference")
- m.SmartMemberReference = k
- val = k.getValue()
- self.verifyValue("smart member reference", val)
- self.verifyCount(2, k)
-
- kmember = m.SmartMemberReference
- val = kmember.getValue()
- self.verifyValue("smart member reference", val)
- self.verifyCount(3, kmember)
- self.verifyCount(3, k)
-
- # The C++ reference refers to SmartMemberValue...
- kmemberVal = m.SmartMemberValue
- val = kmember.getValue()
- self.verifyValue("smart member reference", val)
- self.verifyCount(4, kmemberVal)
- self.verifyCount(4, kmember)
- self.verifyCount(4, k)
-
- del m
- self.verifyCount(3, kmemberVal)
- self.verifyCount(3, kmember)
- self.verifyCount(3, k)
-
- # plain by value
- m = li_boost_shared_ptr.MemberVariables()
- k = li_boost_shared_ptr.Klass("plain member value")
- m.MemberValue = k
- val = k.getValue()
- self.verifyValue("plain member value", val)
- self.verifyCount(1, k)
-
- kmember = m.MemberValue
- val = kmember.getValue()
- self.verifyValue("plain member value", val)
- self.verifyCount(1, kmember)
- self.verifyCount(1, k)
-
- del m
- self.verifyCount(1, kmember)
- self.verifyCount(1, k)
-
- # plain by pointer
- m = li_boost_shared_ptr.MemberVariables()
- k = li_boost_shared_ptr.Klass("plain member pointer")
- m.MemberPointer = k
- val = k.getValue()
- self.verifyValue("plain member pointer", val)
- self.verifyCount(1, k)
-
- kmember = m.MemberPointer
- val = kmember.getValue()
- self.verifyValue("plain member pointer", val)
- self.verifyCount(1, kmember)
- self.verifyCount(1, k)
-
- del m
- self.verifyCount(1, kmember)
- self.verifyCount(1, k)
-
- # plain by reference
- m = li_boost_shared_ptr.MemberVariables()
- k = li_boost_shared_ptr.Klass("plain member reference")
- m.MemberReference = k
- val = k.getValue()
- self.verifyValue("plain member reference", val)
- self.verifyCount(1, k)
-
- kmember = m.MemberReference
- val = kmember.getValue()
- self.verifyValue("plain member reference", val)
- self.verifyCount(1, kmember)
- self.verifyCount(1, k)
-
- del m
- self.verifyCount(1, kmember)
- self.verifyCount(1, k)
-
- # null member variables
- m = li_boost_shared_ptr.MemberVariables()
-
- # shared_ptr by value
- k = m.SmartMemberValue
- if (k != None):
- raise RuntimeError("expected null")
- m.SmartMemberValue = None
- k = m.SmartMemberValue
- if (k != None):
- raise RuntimeError("expected null")
- self.verifyCount(0, k)
-
- # plain by value
- try:
- m.MemberValue = None
- raise RuntimeError("Failed to catch null pointer")
- except ValueError:
- pass
-
- # ////////////////////////////////// Global variables ////////////////////////////////////////
- # smart pointer
- kglobal = li_boost_shared_ptr.cvar.GlobalSmartValue
- if (kglobal != None):
- raise RuntimeError("expected null")
-
- k = li_boost_shared_ptr.Klass("smart global value")
- li_boost_shared_ptr.cvar.GlobalSmartValue = k
- self.verifyCount(2, k)
-
- kglobal = li_boost_shared_ptr.cvar.GlobalSmartValue
- val = kglobal.getValue()
- self.verifyValue("smart global value", val)
- self.verifyCount(3, kglobal)
- self.verifyCount(3, k)
- self.verifyValue("smart global value", li_boost_shared_ptr.cvar.GlobalSmartValue.getValue())
- li_boost_shared_ptr.cvar.GlobalSmartValue = None
-
- # plain value
- k = li_boost_shared_ptr.Klass("global value")
- li_boost_shared_ptr.cvar.GlobalValue = k
- self.verifyCount(1, k)
-
- kglobal = li_boost_shared_ptr.cvar.GlobalValue
- val = kglobal.getValue()
- self.verifyValue("global value", val)
- self.verifyCount(1, kglobal)
- self.verifyCount(1, k)
- self.verifyValue("global value", li_boost_shared_ptr.cvar.GlobalValue.getValue())
-
- try:
- li_boost_shared_ptr.cvar.GlobalValue = None
- raise RuntimeError("Failed to catch null pointer")
- except ValueError:
- pass
-
- # plain pointer
- kglobal = li_boost_shared_ptr.cvar.GlobalPointer
- if (kglobal != None):
- raise RuntimeError("expected null")
-
- k = li_boost_shared_ptr.Klass("global pointer")
- li_boost_shared_ptr.cvar.GlobalPointer = k
- self.verifyCount(1, k)
-
- kglobal = li_boost_shared_ptr.cvar.GlobalPointer
- val = kglobal.getValue()
- self.verifyValue("global pointer", val)
- self.verifyCount(1, kglobal)
- self.verifyCount(1, k)
- li_boost_shared_ptr.cvar.GlobalPointer = None
-
- # plain reference
- kglobal
-
- k = li_boost_shared_ptr.Klass("global reference")
- li_boost_shared_ptr.cvar.GlobalReference = k
- self.verifyCount(1, k)
-
- kglobal = li_boost_shared_ptr.cvar.GlobalReference
- val = kglobal.getValue()
- self.verifyValue("global reference", val)
- self.verifyCount(1, kglobal)
- self.verifyCount(1, k)
-
- try:
- li_boost_shared_ptr.cvar.GlobalReference = None
- raise RuntimeError("Failed to catch null pointer")
- except ValueError:
- pass
-
- # ////////////////////////////////// Templates ////////////////////////////////////////
- pid = li_boost_shared_ptr.PairIntDouble(10, 20.2)
- if (pid.baseVal1 != 20 or pid.baseVal2 != 40.4):
- raise RuntimeError("Base values wrong")
- if (pid.val1 != 10 or pid.val2 != 20.2):
- raise RuntimeError("Derived Values wrong")
-
- def verifyValue(self, expected, got):
- if (expected != got):
- raise RuntimeError("verify value failed. Expected: ", expected, " Got: ", got)
-
- def verifyCount(self, expected, k):
- got = li_boost_shared_ptr.use_count(k)
- if (expected != got):
- raise RuntimeError("verify use_count failed. Expected: ", expected, " Got: ", got)
+
+ def main(self):
+ if (debug):
+ print "Started"
+
+ li_boost_shared_ptr.cvar.debug_shared = debug
+
+ # Change loop count to run for a long time to monitor memory
+ loopCount = 1 # 5000
+ for i in range(0, loopCount):
+ self.runtest()
+
+ # Expect 1 instance - the one global variable (GlobalValue)
+ if (li_boost_shared_ptr.Klass_getTotal_count() != 1):
+ raise RuntimeError("Klass.total_count=%s" %
+ li_boost_shared_ptr.Klass.getTotal_count())
+
+ wrapper_count = li_boost_shared_ptr.shared_ptr_wrapper_count()
+ if (wrapper_count != li_boost_shared_ptr.NOT_COUNTING):
+ # Expect 1 instance - the one global variable (GlobalSmartValue)
+ if (wrapper_count != 1):
+ raise RuntimeError(
+ "shared_ptr wrapper count=%s" % wrapper_count)
+
+ if (debug):
+ print "Finished"
+
+ def runtest(self):
+ # simple shared_ptr usage - created in C++
+ k = li_boost_shared_ptr.Klass("me oh my")
+ val = k.getValue()
+ self.verifyValue("me oh my", val)
+ self.verifyCount(1, k)
+
+ # simple shared_ptr usage - not created in C++
+ k = li_boost_shared_ptr.factorycreate()
+ val = k.getValue()
+ self.verifyValue("factorycreate", val)
+ self.verifyCount(1, k)
+
+ # pass by shared_ptr
+ k = li_boost_shared_ptr.Klass("me oh my")
+ kret = li_boost_shared_ptr.smartpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointertest", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by shared_ptr pointer
+ k = li_boost_shared_ptr.Klass("me oh my")
+ kret = li_boost_shared_ptr.smartpointerpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointerpointertest", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by shared_ptr reference
+ k = li_boost_shared_ptr.Klass("me oh my")
+ kret = li_boost_shared_ptr.smartpointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointerreftest", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by shared_ptr pointer reference
+ k = li_boost_shared_ptr.Klass("me oh my")
+ kret = li_boost_shared_ptr.smartpointerpointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointerpointerreftest", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # const pass by shared_ptr
+ k = li_boost_shared_ptr.Klass("me oh my")
+ kret = li_boost_shared_ptr.constsmartpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # const pass by shared_ptr pointer
+ k = li_boost_shared_ptr.Klass("me oh my")
+ kret = li_boost_shared_ptr.constsmartpointerpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # const pass by shared_ptr reference
+ k = li_boost_shared_ptr.Klass("me oh my")
+ kret = li_boost_shared_ptr.constsmartpointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by value
+ k = li_boost_shared_ptr.Klass("me oh my")
+ kret = li_boost_shared_ptr.valuetest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my valuetest", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # pass by pointer
+ k = li_boost_shared_ptr.Klass("me oh my")
+ kret = li_boost_shared_ptr.pointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my pointertest", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # pass by reference
+ k = li_boost_shared_ptr.Klass("me oh my")
+ kret = li_boost_shared_ptr.reftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my reftest", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # pass by pointer reference
+ k = li_boost_shared_ptr.Klass("me oh my")
+ kret = li_boost_shared_ptr.pointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my pointerreftest", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # null tests
+ k = None
+
+ if (li_boost_shared_ptr.smartpointertest(k) != None):
+ raise RuntimeError("return was not null")
+
+ if (li_boost_shared_ptr.smartpointerpointertest(k) != None):
+ raise RuntimeError("return was not null")
+
+ if (li_boost_shared_ptr.smartpointerreftest(k) != None):
+ raise RuntimeError("return was not null")
+
+ if (li_boost_shared_ptr.smartpointerpointerreftest(k) != None):
+ raise RuntimeError("return was not null")
+
+ if (li_boost_shared_ptr.nullsmartpointerpointertest(None) != "null pointer"):
+ raise RuntimeError("not null smartpointer pointer")
+
+ try:
+ li_boost_shared_ptr.valuetest(k)
+ raise RuntimeError("Failed to catch null pointer")
+ except ValueError:
+ pass
+
+ if (li_boost_shared_ptr.pointertest(k) != None):
+ raise RuntimeError("return was not null")
+
+ try:
+ li_boost_shared_ptr.reftest(k)
+ raise RuntimeError("Failed to catch null pointer")
+ except ValueError:
+ pass
+
+ # $owner
+ k = li_boost_shared_ptr.pointerownertest()
+ val = k.getValue()
+ self.verifyValue("pointerownertest", val)
+ self.verifyCount(1, k)
+ k = li_boost_shared_ptr.smartpointerpointerownertest()
+ val = k.getValue()
+ self.verifyValue("smartpointerpointerownertest", val)
+ self.verifyCount(1, k)
+
+ # //////////////////////////////// Derived class //////////////////////
+ # derived pass by shared_ptr
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.derivedsmartptrtest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my derivedsmartptrtest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # derived pass by shared_ptr pointer
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.derivedsmartptrpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my derivedsmartptrpointertest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # derived pass by shared_ptr ref
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.derivedsmartptrreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my derivedsmartptrreftest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # derived pass by shared_ptr pointer ref
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.derivedsmartptrpointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # derived pass by pointer
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.derivedpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my derivedpointertest-Derived", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # derived pass by ref
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.derivedreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my derivedreftest-Derived", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # //////////////////////////////// Derived and base class mixed ///////
+ # pass by shared_ptr (mixed)
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.smartpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointertest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by shared_ptr pointer (mixed)
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.smartpointerpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointerpointertest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by shared_ptr reference (mixed)
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.smartpointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointerreftest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by shared_ptr pointer reference (mixed)
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.smartpointerpointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointerpointerreftest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by value (mixed)
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.valuetest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my valuetest", val) # note slicing
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # pass by pointer (mixed)
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.pointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my pointertest-Derived", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # pass by ref (mixed)
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ kret = li_boost_shared_ptr.reftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my reftest-Derived", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # //////////////////////////////// Overloading tests //////////////////
+ # Base class
+ k = li_boost_shared_ptr.Klass("me oh my")
+ self.verifyValue(li_boost_shared_ptr.overload_rawbyval(k), "rawbyval")
+ self.verifyValue(li_boost_shared_ptr.overload_rawbyref(k), "rawbyref")
+ self.verifyValue(li_boost_shared_ptr.overload_rawbyptr(k), "rawbyptr")
+ self.verifyValue(
+ li_boost_shared_ptr.overload_rawbyptrref(k), "rawbyptrref")
+
+ self.verifyValue(
+ li_boost_shared_ptr.overload_smartbyval(k), "smartbyval")
+ self.verifyValue(
+ li_boost_shared_ptr.overload_smartbyref(k), "smartbyref")
+ self.verifyValue(
+ li_boost_shared_ptr.overload_smartbyptr(k), "smartbyptr")
+ self.verifyValue(
+ li_boost_shared_ptr.overload_smartbyptrref(k), "smartbyptrref")
+
+ # Derived class
+ k = li_boost_shared_ptr.KlassDerived("me oh my")
+ self.verifyValue(li_boost_shared_ptr.overload_rawbyval(k), "rawbyval")
+ self.verifyValue(li_boost_shared_ptr.overload_rawbyref(k), "rawbyref")
+ self.verifyValue(li_boost_shared_ptr.overload_rawbyptr(k), "rawbyptr")
+ self.verifyValue(
+ li_boost_shared_ptr.overload_rawbyptrref(k), "rawbyptrref")
+
+ self.verifyValue(
+ li_boost_shared_ptr.overload_smartbyval(k), "smartbyval")
+ self.verifyValue(
+ li_boost_shared_ptr.overload_smartbyref(k), "smartbyref")
+ self.verifyValue(
+ li_boost_shared_ptr.overload_smartbyptr(k), "smartbyptr")
+ self.verifyValue(
+ li_boost_shared_ptr.overload_smartbyptrref(k), "smartbyptrref")
+
+ # 3rd derived class
+ k = li_boost_shared_ptr.Klass3rdDerived("me oh my")
+ val = k.getValue()
+ self.verifyValue("me oh my-3rdDerived", val)
+ self.verifyCount(1, k)
+ val = li_boost_shared_ptr.test3rdupcast(k)
+ self.verifyValue("me oh my-3rdDerived", val)
+ self.verifyCount(1, k)
+
+ # //////////////////////////////// Member variables ///////////////////
+ # smart pointer by value
+ m = li_boost_shared_ptr.MemberVariables()
+ k = li_boost_shared_ptr.Klass("smart member value")
+ m.SmartMemberValue = k
+ val = k.getValue()
+ self.verifyValue("smart member value", val)
+ self.verifyCount(2, k)
+
+ kmember = m.SmartMemberValue
+ val = kmember.getValue()
+ self.verifyValue("smart member value", val)
+ self.verifyCount(3, kmember)
+ self.verifyCount(3, k)
+
+ del m
+ self.verifyCount(2, kmember)
+ self.verifyCount(2, k)
+
+ # smart pointer by pointer
+ m = li_boost_shared_ptr.MemberVariables()
+ k = li_boost_shared_ptr.Klass("smart member pointer")
+ m.SmartMemberPointer = k
+ val = k.getValue()
+ self.verifyValue("smart member pointer", val)
+ self.verifyCount(1, k)
+
+ kmember = m.SmartMemberPointer
+ val = kmember.getValue()
+ self.verifyValue("smart member pointer", val)
+ self.verifyCount(2, kmember)
+ self.verifyCount(2, k)
+
+ del m
+ self.verifyCount(2, kmember)
+ self.verifyCount(2, k)
+
+ # smart pointer by reference
+ m = li_boost_shared_ptr.MemberVariables()
+ k = li_boost_shared_ptr.Klass("smart member reference")
+ m.SmartMemberReference = k
+ val = k.getValue()
+ self.verifyValue("smart member reference", val)
+ self.verifyCount(2, k)
+
+ kmember = m.SmartMemberReference
+ val = kmember.getValue()
+ self.verifyValue("smart member reference", val)
+ self.verifyCount(3, kmember)
+ self.verifyCount(3, k)
+
+ # The C++ reference refers to SmartMemberValue...
+ kmemberVal = m.SmartMemberValue
+ val = kmember.getValue()
+ self.verifyValue("smart member reference", val)
+ self.verifyCount(4, kmemberVal)
+ self.verifyCount(4, kmember)
+ self.verifyCount(4, k)
+
+ del m
+ self.verifyCount(3, kmemberVal)
+ self.verifyCount(3, kmember)
+ self.verifyCount(3, k)
+
+ # plain by value
+ m = li_boost_shared_ptr.MemberVariables()
+ k = li_boost_shared_ptr.Klass("plain member value")
+ m.MemberValue = k
+ val = k.getValue()
+ self.verifyValue("plain member value", val)
+ self.verifyCount(1, k)
+
+ kmember = m.MemberValue
+ val = kmember.getValue()
+ self.verifyValue("plain member value", val)
+ self.verifyCount(1, kmember)
+ self.verifyCount(1, k)
+
+ del m
+ self.verifyCount(1, kmember)
+ self.verifyCount(1, k)
+
+ # plain by pointer
+ m = li_boost_shared_ptr.MemberVariables()
+ k = li_boost_shared_ptr.Klass("plain member pointer")
+ m.MemberPointer = k
+ val = k.getValue()
+ self.verifyValue("plain member pointer", val)
+ self.verifyCount(1, k)
+
+ kmember = m.MemberPointer
+ val = kmember.getValue()
+ self.verifyValue("plain member pointer", val)
+ self.verifyCount(1, kmember)
+ self.verifyCount(1, k)
+
+ del m
+ self.verifyCount(1, kmember)
+ self.verifyCount(1, k)
+
+ # plain by reference
+ m = li_boost_shared_ptr.MemberVariables()
+ k = li_boost_shared_ptr.Klass("plain member reference")
+ m.MemberReference = k
+ val = k.getValue()
+ self.verifyValue("plain member reference", val)
+ self.verifyCount(1, k)
+
+ kmember = m.MemberReference
+ val = kmember.getValue()
+ self.verifyValue("plain member reference", val)
+ self.verifyCount(1, kmember)
+ self.verifyCount(1, k)
+
+ del m
+ self.verifyCount(1, kmember)
+ self.verifyCount(1, k)
+
+ # null member variables
+ m = li_boost_shared_ptr.MemberVariables()
+
+ # shared_ptr by value
+ k = m.SmartMemberValue
+ if (k != None):
+ raise RuntimeError("expected null")
+ m.SmartMemberValue = None
+ k = m.SmartMemberValue
+ if (k != None):
+ raise RuntimeError("expected null")
+ self.verifyCount(0, k)
+
+ # plain by value
+ try:
+ m.MemberValue = None
+ raise RuntimeError("Failed to catch null pointer")
+ except ValueError:
+ pass
+
+ # ////////////////////////////////// Global variables /////////////////
+ # smart pointer
+ kglobal = li_boost_shared_ptr.cvar.GlobalSmartValue
+ if (kglobal != None):
+ raise RuntimeError("expected null")
+
+ k = li_boost_shared_ptr.Klass("smart global value")
+ li_boost_shared_ptr.cvar.GlobalSmartValue = k
+ self.verifyCount(2, k)
+
+ kglobal = li_boost_shared_ptr.cvar.GlobalSmartValue
+ val = kglobal.getValue()
+ self.verifyValue("smart global value", val)
+ self.verifyCount(3, kglobal)
+ self.verifyCount(3, k)
+ self.verifyValue(
+ "smart global value", li_boost_shared_ptr.cvar.GlobalSmartValue.getValue())
+ li_boost_shared_ptr.cvar.GlobalSmartValue = None
+
+ # plain value
+ k = li_boost_shared_ptr.Klass("global value")
+ li_boost_shared_ptr.cvar.GlobalValue = k
+ self.verifyCount(1, k)
+
+ kglobal = li_boost_shared_ptr.cvar.GlobalValue
+ val = kglobal.getValue()
+ self.verifyValue("global value", val)
+ self.verifyCount(1, kglobal)
+ self.verifyCount(1, k)
+ self.verifyValue(
+ "global value", li_boost_shared_ptr.cvar.GlobalValue.getValue())
+
+ try:
+ li_boost_shared_ptr.cvar.GlobalValue = None
+ raise RuntimeError("Failed to catch null pointer")
+ except ValueError:
+ pass
+
+ # plain pointer
+ kglobal = li_boost_shared_ptr.cvar.GlobalPointer
+ if (kglobal != None):
+ raise RuntimeError("expected null")
+
+ k = li_boost_shared_ptr.Klass("global pointer")
+ li_boost_shared_ptr.cvar.GlobalPointer = k
+ self.verifyCount(1, k)
+
+ kglobal = li_boost_shared_ptr.cvar.GlobalPointer
+ val = kglobal.getValue()
+ self.verifyValue("global pointer", val)
+ self.verifyCount(1, kglobal)
+ self.verifyCount(1, k)
+ li_boost_shared_ptr.cvar.GlobalPointer = None
+
+ # plain reference
+
+ k = li_boost_shared_ptr.Klass("global reference")
+ li_boost_shared_ptr.cvar.GlobalReference = k
+ self.verifyCount(1, k)
+
+ kglobal = li_boost_shared_ptr.cvar.GlobalReference
+ val = kglobal.getValue()
+ self.verifyValue("global reference", val)
+ self.verifyCount(1, kglobal)
+ self.verifyCount(1, k)
+
+ try:
+ li_boost_shared_ptr.cvar.GlobalReference = None
+ raise RuntimeError("Failed to catch null pointer")
+ except ValueError:
+ pass
+
+ # ////////////////////////////////// Templates ////////////////////////
+ pid = li_boost_shared_ptr.PairIntDouble(10, 20.2)
+ if (pid.baseVal1 != 20 or pid.baseVal2 != 40.4):
+ raise RuntimeError("Base values wrong")
+ if (pid.val1 != 10 or pid.val2 != 20.2):
+ raise RuntimeError("Derived Values wrong")
+
+ def verifyValue(self, expected, got):
+ if (expected != got):
+ raise RuntimeError(
+ "verify value failed. Expected: ", expected, " Got: ", got)
+
+ def verifyCount(self, expected, k):
+ got = li_boost_shared_ptr.use_count(k)
+ if (expected != got):
+ raise RuntimeError(
+ "verify use_count failed. Expected: ", expected, " Got: ", got)
runme = li_boost_shared_ptr_runme()
runme.main()
-
b = BaseINTEGER()
d = DerivedINTEGER()
if b.bar() != 1:
- raise RuntimeError
+ raise RuntimeError
if d.bar() != 2:
- raise RuntimeError
+ raise RuntimeError
if bar_getter(b) != 1:
- raise RuntimeError
+ raise RuntimeError
# Fix reverted in rev 12953
-#if bar_getter(d) != 2:
+# if bar_getter(d) != 2:
# raise RuntimeError
b = BaseDefaultInt()
d = DerivedDefaultInt()
d2 = DerivedDefaultInt2()
if b.bar2() != 3:
- raise RuntimeError
+ raise RuntimeError
if d.bar2() != 4:
- raise RuntimeError
+ raise RuntimeError
if d2.bar2() != 4:
- raise RuntimeError
+ raise RuntimeError
if bar2_getter(b) != 3:
- raise RuntimeError
+ raise RuntimeError
# Fix reverted in rev 12953
-#if bar2_getter(d) != 4:
+# if bar2_getter(d) != 4:
# raise RuntimeError
-#if bar2_getter(d2) != 4:
+# if bar2_getter(d2) != 4:
# raise RuntimeError
--- /dev/null
+from li_carrays_cpp import *
+
+d = doubleArray(10)
+
+d[0] = 7
+d[5] = d[0] + 3
+
+if d[5] + d[0] != 17:
+ raise RuntimeError
--- /dev/null
+
+from li_cdata_cpp import *
+
+s = "ABC abc"
+m = malloc(256)
+memmove(m, s)
+ss = cdata(m, 7)
+if ss != "ABC abc":
+ raise "failed"
memmove(m, s)
ss = cdata(m, 7)
if ss != "ABC abc":
- raise "failed"
-
+ raise "failed"
--- /dev/null
+from li_cpointer_cpp import *
+
+
+p = new_intp()
+intp_assign(p, 3)
+
+if intp_value(p) != 3:
+ raise RuntimeError
+
+delete_intp(p)
p = new_intp()
-intp_assign(p,3)
+intp_assign(p, 3)
if intp_value(p) != 3:
raise RuntimeError
if count("ab\0ab\0ab\0", 0) != 3:
- raise RuntimeError
+ raise RuntimeError
if test1() != "Hello World":
raise RuntimeError
if test4("hello") != "hello-suffix":
print test4("hello")
raise RuntimeError
-
+
if test5(4) != 'xxxx':
raise RuntimeError
if test6(10) != 'xxxxx':
raise RuntimeError
-
-if test7() !="Hello world!":
+
+if test7() != "Hello world!":
raise RuntimeError
if test8() != " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_":
raise RuntimeError
-
from li_cwstring import *
if count(u"ab\0ab\0ab\0", 0) != 3:
- raise RuntimeError
+ raise RuntimeError
if test1() != u"Hello World":
raise RuntimeError
if test4("hello") != u"hello-suffix":
raise RuntimeError
-
+
if test5(4) != u'xxxx':
raise RuntimeError
if test6(10) != u'xxxxx':
raise RuntimeError
-
+
if test7() != u"Hello world!":
raise RuntimeError
if test8() != u" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_":
raise RuntimeError
-
ab, get(ab)
if get(ai) != get(1):
- raise RuntimeError,"bad implicit type"
+ raise RuntimeError, "bad implicit type"
if get(ad) != get(2.0):
- raise RuntimeError,"bad implicit type"
+ raise RuntimeError, "bad implicit type"
if get(ab) != get(b):
- raise RuntimeError,"bad implicit type"
-
+ raise RuntimeError, "bad implicit type"
--- /dev/null
+from li_std_auto_ptr import *
+
+k1 = makeKlassAutoPtr("first")
+k2 = makeKlassAutoPtr("second")
+if Klass_getTotal_count() != 2:
+ raise "number of objects should be 2"
+
+del k1
+if Klass_getTotal_count() != 1:
+ raise "number of objects should be 1"
+
+if k2.getLabel() != "second":
+ raise "wrong object label"
+
+del k2
+if Klass_getTotal_count() != 0:
+ raise "no objects should be left"
v3 = Vector3()
-for i in range(0,len(v3)):
+for i in range(0, len(v3)):
v3[i] = i
i = 0
m3 = Matrix3()
-for i in range(0,len(m3)):
+for i in range(0, len(m3)):
v3 = m3[i]
- for j in range(0,len(v3)):
+ for j in range(0, len(v3)):
v3[j] = i + j
i = 0
i = i + 1
pass
-for i in range(0,len(m3)):
- for j in range(0,len(m3)):
+for i in range(0, len(m3)):
+ for j in range(0, len(m3)):
if m3[i][j] != i + j:
raise RuntimeError
-da = Vector3((1,2,3))
-ma = Matrix3(((1,2,3),(4,5,6),(7,8,9)))
-
-
+da = Vector3((1, 2, 3))
+ma = Matrix3(((1, 2, 3), (4, 5, 6), (7, 8, 9)))
-# Check std::vector and std::list behaves the same as Python iterable types (list)
+# Check std::vector and std::list behaves the same as Python iterable
+# types (list)
from li_std_containers_int import *
import sys
+
def failed(a, b, msg):
- raise RuntimeError, msg + " " + str(list(a)) + " " + str(list(b))
+ raise RuntimeError, msg + " " + str(list(a)) + " " + str(list(b))
+
def compare_sequences(a, b):
- if len(a) != len(b):
- failed(a, b, "different sizes")
- for i in range(len(a)):
- if a[i] != b[i]:
- failed(a, b, "elements are different")
+ if len(a) != len(b):
+ failed(a, b, "different sizes")
+ for i in range(len(a)):
+ if a[i] != b[i]:
+ failed(a, b, "elements are different")
+
def compare_containers(pythonlist, swigvector, swiglist):
- compare_sequences(pythonlist, swigvector)
- compare_sequences(pythonlist, swiglist)
+ compare_sequences(pythonlist, swigvector)
+ compare_sequences(pythonlist, swiglist)
+
+# Check std::vector and std::list assignment behaves same as Python list
+# assignment including exceptions
+
-# Check std::vector and std::list assignment behaves same as Python list assignment including exceptions
def container_insert_step(i, j, step, newval):
- ps = range(6)
- iv = vector_int(ps)
- il = list_int(ps)
-
- # Python slice
- try:
- if step == None:
- if j == None:
- ps[i] = newval
- else:
- ps[i:j] = newval
- else:
- if j == None:
- ps[i::step] = newval
- else:
- ps[i:j:step] = newval
- ps_error = None
- except ValueError, e:
- ps_error = e
- except IndexError, e:
- ps_error = e
-
- # std::vector<int>
- try:
- if step == None:
- if j == None:
- iv[i] = newval
- else:
- iv[i:j] = newval
- else:
- if j == None:
- iv[i::step] = newval
- else:
- iv[i:j:step] = newval
- iv_error = None
- except ValueError, e:
- iv_error = e
- except IndexError, e:
- iv_error = e
-
- # std::list<int>
- try:
- if step == None:
- if j == None:
- il[i] = newval
- else:
- il[i:j] = newval
- else:
- if j == None:
- il[i::step] = newval
- else:
- il[i:j:step] = newval
- il_error = None
- except ValueError, e:
- il_error = e
- except IndexError, e:
- il_error = e
-
- # Python 2.6 contains bug fixes in extended slicing syntax: http://docs.python.org/2/whatsnew/2.6.html
- skip_check = ps_error != None and(iv_error == il_error == None) and step > 0 and (sys.version_info[0:2] < (2, 6))
- if not(skip_check):
+ ps = range(6)
+ iv = vector_int(ps)
+ il = list_int(ps)
+
+ # Python slice
+ try:
+ if step == None:
+ if j == None:
+ ps[i] = newval
+ else:
+ ps[i:j] = newval
+ else:
+ if j == None:
+ ps[i::step] = newval
+ else:
+ ps[i:j:step] = newval
+ ps_error = None
+ except ValueError, e:
+ ps_error = e
+ except IndexError, e:
+ ps_error = e
+
+ # std::vector<int>
+ try:
+ if step == None:
+ if j == None:
+ iv[i] = newval
+ else:
+ iv[i:j] = newval
+ else:
+ if j == None:
+ iv[i::step] = newval
+ else:
+ iv[i:j:step] = newval
+ iv_error = None
+ except ValueError, e:
+ iv_error = e
+ except IndexError, e:
+ iv_error = e
+
+ # std::list<int>
+ try:
+ if step == None:
+ if j == None:
+ il[i] = newval
+ else:
+ il[i:j] = newval
+ else:
+ if j == None:
+ il[i::step] = newval
+ else:
+ il[i:j:step] = newval
+ il_error = None
+ except ValueError, e:
+ il_error = e
+ except IndexError, e:
+ il_error = e
+
+ # Python 2.6 contains bug fixes in extended slicing syntax:
+ # http://docs.python.org/2/whatsnew/2.6.html
+ skip_check = ps_error != None and(
+ iv_error == il_error == None) and step > 0 and (sys.version_info[0:2] < (2, 6))
+ if not(skip_check):
+ if not((type(ps_error) == type(iv_error)) and (type(ps_error) == type(il_error))):
+ raise RuntimeError, "ValueError exception not consistently thrown: " + \
+ str(ps_error) + " " + str(iv_error) + " " + str(il_error)
+
+ compare_containers(ps, iv, il)
+
+
+# Check std::vector and std::list delete behaves same as Python list
+# delete including exceptions
+def container_delete_step(i, j, step):
+ ps = range(6)
+ iv = vector_int(ps)
+ il = list_int(ps)
+
+ # Python slice
+ try:
+ if step == None:
+ if j == None:
+ del ps[i]
+ else:
+ del ps[i:j]
+ else:
+ if j == None:
+ del ps[i::step]
+ else:
+ del ps[i:j:step]
+ ps_error = None
+ except ValueError, e:
+ ps_error = e
+ except IndexError, e:
+ ps_error = e
+
+ # std::vector<int>
+ try:
+ if step == None:
+ if j == None:
+ del iv[i]
+ else:
+ del iv[i:j]
+ else:
+ if j == None:
+ del iv[i::step]
+ else:
+ del iv[i:j:step]
+ iv_error = None
+ except ValueError, e:
+ iv_error = e
+ except IndexError, e:
+ iv_error = e
+
+ # std::list<int>
+ try:
+ if step == None:
+ if j == None:
+ del il[i]
+ else:
+ del il[i:j]
+ else:
+ if j == None:
+ del il[i::step]
+ else:
+ del il[i:j:step]
+ il_error = None
+ except ValueError, e:
+ il_error = e
+ except IndexError, e:
+ il_error = e
+
if not((type(ps_error) == type(iv_error)) and (type(ps_error) == type(il_error))):
- raise RuntimeError, "ValueError exception not consistently thrown: " + str(ps_error) + " " + str(iv_error) + " " + str(il_error)
+ raise RuntimeError, "ValueError exception not consistently thrown: " + \
+ str(ps_error) + " " + str(iv_error) + " " + str(il_error)
compare_containers(ps, iv, il)
-# Check std::vector and std::list delete behaves same as Python list delete including exceptions
-def container_delete_step(i, j, step):
- ps = range(6)
- iv = vector_int(ps)
- il = list_int(ps)
-
- # Python slice
- try:
- if step == None:
- if j == None:
- del ps[i]
- else:
- del ps[i:j]
- else:
- if j == None:
- del ps[i::step]
- else:
- del ps[i:j:step]
- ps_error = None
- except ValueError, e:
- ps_error = e
- except IndexError, e:
- ps_error = e
-
- # std::vector<int>
- try:
- if step == None:
- if j == None:
- del iv[i]
- else:
- del iv[i:j]
- else:
- if j == None:
- del iv[i::step]
- else:
- del iv[i:j:step]
- iv_error = None
- except ValueError, e:
- iv_error = e
- except IndexError, e:
- iv_error = e
-
- # std::list<int>
- try:
- if step == None:
- if j == None:
- del il[i]
- else:
- del il[i:j]
- else:
- if j == None:
- del il[i::step]
- else:
- del il[i:j:step]
- il_error = None
- except ValueError, e:
- il_error = e
- except IndexError, e:
- il_error = e
-
- if not((type(ps_error) == type(iv_error)) and (type(ps_error) == type(il_error))):
- raise RuntimeError, "ValueError exception not consistently thrown: " + str(ps_error) + " " + str(iv_error) + " " + str(il_error)
-
- compare_containers(ps, iv, il)
-
-
-ps = [0,1,2,3,4,5]
+ps = [0, 1, 2, 3, 4, 5]
iv = vector_int(ps)
il = list_int(ps)
compare_containers(ps[2:4], iv[2:4], il[2:4])
compare_containers(ps[0:3], iv[0:3], il[0:3])
compare_containers(ps[3:6], iv[3:6], il[3:6])
-compare_containers(ps[3:10], iv[3:10], il[3:10]) # beyond end of range
+compare_containers(ps[3:10], iv[3:10], il[3:10]) # beyond end of range
# before beginning of range (negative indexing)
compare_containers(ps[-1:7], iv[-1:7], il[-1:7])
compare_containers(ps[-5:7], iv[-5:7], il[-5:7])
compare_containers(ps[-6:7], iv[-6:7], il[-6:7])
-# before beginning of range (negative indexing, negative index is > container size)
+# before beginning of range (negative indexing, negative index is >
+# container size)
compare_containers(ps[-7:7], iv[-7:7], il[-7:7])
compare_containers(ps[-100:7], iv[-100:7], il[-100:7])
# insert sequences (growing, shrinking and staying same size)
for start in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:
- # single element set/replace
- container_insert_step(start, None, None, 111)
- for end in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:
- container_insert_step(start, end, None, [111, 222, 333, 444, 555, 666, 777])
- container_insert_step(start, end, None, [111, 222, 333, 444, 555, 666])
- container_insert_step(start, end, None, [111, 222, 333, 444, 555])
- container_insert_step(start, end, None, [111, 222, 333, 444])
- container_insert_step(start, end, None, [111, 222, 333])
- container_insert_step(start, end, None, [111, 222])
- container_insert_step(start, end, None, [111])
- container_insert_step(start, end, None, [])
+ # single element set/replace
+ container_insert_step(start, None, None, 111)
+ for end in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:
+ container_insert_step(
+ start, end, None, [111, 222, 333, 444, 555, 666, 777])
+ container_insert_step(start, end, None, [111, 222, 333, 444, 555, 666])
+ container_insert_step(start, end, None, [111, 222, 333, 444, 555])
+ container_insert_step(start, end, None, [111, 222, 333, 444])
+ container_insert_step(start, end, None, [111, 222, 333])
+ container_insert_step(start, end, None, [111, 222])
+ container_insert_step(start, end, None, [111])
+ container_insert_step(start, end, None, [])
# delete sequences (growing, shrinking and staying same size)
for start in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:
- # single element delete
- container_delete_step(start, None, None)
- for end in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:
- container_delete_step(start, end, None)
- for step in range(-7,7):
- container_delete_step(start, end, step)
+ # single element delete
+ container_delete_step(start, None, None)
+ for end in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:
+ container_delete_step(start, end, None)
+ for step in range(-7, 7):
+ container_delete_step(start, end, step)
ps = range(6)
iv = vector_int(ps)
il = list_int(ps)
-del ps[:]; del iv[:]; del il[:]
+del ps[:]
+del iv[:]
+del il[:]
compare_containers(ps, iv, il)
for end in range(7):
- for step in range(-7,7):
- for start in range(7):
- container_insert_step(start, end, step, [111, 222, 333, 444, 555, 666, 777])
- container_insert_step(start, end, step, [111, 222, 333, 444, 555, 666])
- container_insert_step(start, end, step, [111, 222, 333, 444, 555])
- container_insert_step(start, end, step, [111, 222, 333, 444])
- container_insert_step(start, end, step, [111, 222, 333])
- container_insert_step(start, end, step, [111, 222])
- container_insert_step(start, end, step, [111])
- container_insert_step(start, end, step, [])
+ for step in range(-7, 7):
+ for start in range(7):
+ container_insert_step(
+ start, end, step, [111, 222, 333, 444, 555, 666, 777])
+ container_insert_step(
+ start, end, step, [111, 222, 333, 444, 555, 666])
+ container_insert_step(start, end, step, [111, 222, 333, 444, 555])
+ container_insert_step(start, end, step, [111, 222, 333, 444])
+ container_insert_step(start, end, step, [111, 222, 333])
+ container_insert_step(start, end, step, [111, 222])
+ container_insert_step(start, end, step, [111])
+ container_insert_step(start, end, step, [])
try:
- x = iv[::0]
- raise RuntimeError("Zero step not caught")
+ x = iv[::0]
+ raise RuntimeError("Zero step not caught")
except ValueError:
- pass
-
+ pass
from li_std_except_as_class import *
-# std::domain_error hierarchy
-try: test_domain_error()
-except domain_error: pass
-try: test_domain_error()
-except logic_error: pass
-try: test_domain_error()
-except exception: pass
+# This test is expected to fail with -builtin option.
+# Throwing builtin classes as exceptions not supported
+if is_python_builtin():
+ try:
+ test_domain_error()
+ except RuntimeError:
+ pass
+ try:
+ test_domain_error()
+ except RuntimeError:
+ pass
+ try:
+ test_domain_error()
+ except RuntimeError:
+ pass
+else:
+ # std::domain_error hierarchy
+ try:
+ test_domain_error()
+ except domain_error:
+ pass
+ try:
+ test_domain_error()
+ except logic_error:
+ pass
+ try:
+ test_domain_error()
+ except exception:
+ pass
a = li_std_map_member.mapita()
a[1] = li_std_map_member.TestA()
-if (a[1].i != 1) :
+if (a[1].i != 1):
raise RuntimeError("a[1] != 1")
a[1].i = 2
-if (a[1].i != 2) :
+if (a[1].i != 2):
raise RuntimeError("a[1] != 2")
a2 = li_std_map.A(7)
-p0 = li_std_map.pairii(1,2)
-p1 = li_std_map.pairA(1,a1.this)
+p0 = li_std_map.pairii(1, 2)
+p1 = li_std_map.pairA(1, a1.this)
m = {}
m[1] = a1
m[2] = a2
mm = li_std_map.m_identa(m)
-
m = li_std_map.mapA()
m[1] = a1
m[2] = a2
-pm ={}
+pm = {}
for k in m:
- pm[k] = m[k]
-
-for k in m:
- if pm[k].this != m[k].this:
- print pm[k], m[k]
- raise RuntimeError
-
-
+ pm[k] = m[k]
+for k in m:
+ if pm[k].this != m[k].this:
+ print pm[k], m[k]
+ raise RuntimeError
m = {}
-m[1] = (1,2)
+m[1] = (1, 2)
m["foo"] = "hello"
pm = li_std_map.pymap()
-for k in m:
- pm[k] = m[k]
-
-for k in pm:
- if (pm[k] != m[k]):
- raise RuntimeError
+for k in m:
+ pm[k] = m[k]
+for k in pm:
+ if (pm[k] != m[k]):
+ raise RuntimeError
mii = li_std_map.IntIntMap()
mii[1] = 2
if mii[1] != 2:
- raise RuntimeError
-
+ raise RuntimeError
import li_std_pair_extra
-p = (1,2)
+p = (1, 2)
p1 = li_std_pair_extra.p_inout(p)
p2 = li_std_pair_extra.p_inoutd(p1)
d1 = li_std_pair_extra.d_inout(2)
-i,d2 = li_std_pair_extra.d_inout2(2)
+i, d2 = li_std_pair_extra.d_inout2(2)
-i,p = li_std_pair_extra.p_inout2(p)
-p3,p4 = li_std_pair_extra.p_inout3(p1,p1)
+i, p = li_std_pair_extra.p_inout2(p)
+p3, p4 = li_std_pair_extra.p_inout3(p1, p1)
-psi = li_std_pair_extra.SIPair("hello",1)
-pci = li_std_pair_extra.CIPair(1,1)
+psi = li_std_pair_extra.SIPair("hello", 1)
+pci = li_std_pair_extra.CIPair(1, 1)
#psi.first = "hi"
-psi = li_std_pair_extra.SIPair("hi",1)
-if psi != ("hi",1):
- raise RuntimeError
+psi = li_std_pair_extra.SIPair("hi", 1)
+if psi != ("hi", 1):
+ raise RuntimeError
-psii = li_std_pair_extra.SIIPair(psi,1)
+psii = li_std_pair_extra.SIIPair(psi, 1)
a = li_std_pair_extra.A()
b = li_std_pair_extra.B()
-pab = li_std_pair_extra.ABPair(a,b);
+pab = li_std_pair_extra.ABPair(a, b)
pab.first = a
pab.first.val = 2
if pab.first.val != 2:
- raise RuntimeError
-
+ raise RuntimeError
-pci = li_std_pair_extra.CIntPair(1,0)
+
+pci = li_std_pair_extra.CIntPair(1, 0)
a = li_std_pair_extra.A(5)
-p1 = li_std_pair_extra.pairP1(1,a.this)
-p2 = li_std_pair_extra.pairP2(a,1)
-p3 = li_std_pair_extra.pairP3(a,a)
+p1 = li_std_pair_extra.pairP1(1, a.this)
+p2 = li_std_pair_extra.pairP2(a, 1)
+p3 = li_std_pair_extra.pairP3(a, a)
if a.val != li_std_pair_extra.p_identa(p1.this)[1].val:
- raise RuntimeError
-
-p = li_std_pair_extra.IntPair(1,10)
+ raise RuntimeError
+
+p = li_std_pair_extra.IntPair(1, 10)
p.first = 1
-p = li_std_pair_extra.paircA1(1,a)
+p = li_std_pair_extra.paircA1(1, a)
p.first
p.second
-p = li_std_pair_extra.paircA2(1,a)
-pp = li_std_pair_extra.pairiiA(1,p)
-
+p = li_std_pair_extra.paircA2(1, a)
+pp = li_std_pair_extra.pairiiA(1, p)
two = StringIntPair(two_tuple)
if bounce(one) != one_tuple:
- raise RuntimeError
-
+ raise RuntimeError
b = s.begin()
e = s.end()
sum = ""
-while (b != e):
+while (b != e):
sum = sum + b.next()
if sum != "abc":
raise RuntimeError
b = s.rbegin()
e = s.rend()
sum = ""
-while (b != e):
- sum = sum + b.next()
+while (b != e):
+ sum = sum + b.next()
if sum != "cba":
raise RuntimeError
-
si = set_int()
si.append(1)
raise RuntimeError
-
-
i = s.begin()
i.next()
s.erase(i)
b = s.begin()
e = s.end()
sum = ""
-while (b != e):
+while (b != e):
sum = sum + b.next()
if sum != "ac":
raise RuntimeError
e = s.end()
if e - b != 2:
raise RuntimeError
-
+
m = b + 1
if m.value() != "c":
raise RuntimeError
-
s = pyset()
-s.insert((1,2))
+s.insert((1, 2))
s.insert(1)
s.insert("hello")
sum = ()
for i in s:
- sum = sum + (i,)
+ sum = sum + (i,)
-if (len(sum) != 3 or (not 1 in sum) or (not 'hello' in sum) or (not (1, 2) in sum)) :
+if (len(sum) != 3 or (not 1 in sum) or (not 'hello' in sum) or (not (1, 2) in sum)):
raise RuntimeError
from li_std_stream import *
-
a = A()
o = ostringstream()
o << a << " " << 2345 << " " << 1.435
-if o.str() != "A class 2345 1.435":
- print "\"%s\"" % (o.str(),)
- raise RuntimeError
+if o.str() != "A class 2345 1.435":
+ print "\"%s\"" % (o.str(),)
+ raise RuntimeError
import li_std_string_extra
-x="hello"
-
+x = "hello"
if li_std_string_extra.test_ccvalue(x) != x:
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
if li_std_string_extra.test_cvalue(x) != x:
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
if li_std_string_extra.test_value(x) != x:
- print x, li_std_string_extra.test_value(x)
- raise RuntimeError, "bad string mapping"
+ print x, li_std_string_extra.test_value(x)
+ raise RuntimeError, "bad string mapping"
if li_std_string_extra.test_const_reference(x) != x:
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
s = li_std_string_extra.string("he")
#s += "ll"
-#s.append('o')
+# s.append('o')
s = s + "llo"
if s != x:
- print s, x
- raise RuntimeError, "bad string mapping"
+ print s, x
+ raise RuntimeError, "bad string mapping"
if s[1:4] != x[1:4]:
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
if li_std_string_extra.test_value(s) != x:
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
if li_std_string_extra.test_const_reference(s) != x:
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
a = li_std_string_extra.A(s)
if li_std_string_extra.test_value(a) != x:
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
if li_std_string_extra.test_const_reference(a) != x:
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
b = li_std_string_extra.string(" world")
s = a + b
if a + b != "hello world":
- print a + b
- raise RuntimeError, "bad string mapping"
-
+ print a + b
+ raise RuntimeError, "bad string mapping"
+
if a + " world" != "hello world":
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
# This is expected to fail with -builtin option
# Reverse operators not supported in builtin types
-if "hello" + b != "hello world":
- raise RuntimeError, "bad string mapping"
+if not li_std_string_extra.is_python_builtin():
+ if "hello" + b != "hello world":
+ raise RuntimeError, "bad string mapping"
+
+ c = "hello" + b
+ if c.find_last_of("l") != 9:
+ raise RuntimeError, "bad string mapping"
-# This is expected to fail with -builtin option
-# Reverse operators not supported in builtin types
-c = "hello" + b
-if c.find_last_of("l") != 9:
- raise RuntimeError, "bad string mapping"
-
s = "hello world"
b = li_std_string_extra.B("hi")
b.name = li_std_string_extra.string("hello")
if b.name != "hello":
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
b.a = li_std_string_extra.A("hello")
if b.a != "hello":
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
if li_std_string_extra.test_value_basic1(x) != x:
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
if li_std_string_extra.test_value_basic2(x) != x:
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
if li_std_string_extra.test_value_basic3(x) != x:
- raise RuntimeError, "bad string mapping"
+ raise RuntimeError, "bad string mapping"
# Global variables
s = "initial string"
if li_std_string_extra.cvar.GlobalString2 != "global string 2":
- raise RuntimeError, "GlobalString2 test 1"
+ raise RuntimeError, "GlobalString2 test 1"
li_std_string_extra.cvar.GlobalString2 = s
if li_std_string_extra.cvar.GlobalString2 != s:
- raise RuntimeError, "GlobalString2 test 2"
+ raise RuntimeError, "GlobalString2 test 2"
if li_std_string_extra.cvar.ConstGlobalString != "const global string":
- raise RuntimeError, "ConstGlobalString test"
+ raise RuntimeError, "ConstGlobalString test"
# Member variables
myStructure = li_std_string_extra.Structure()
if myStructure.MemberString2 != "member string 2":
- raise RuntimeError, "MemberString2 test 1"
+ raise RuntimeError, "MemberString2 test 1"
myStructure.MemberString2 = s
if myStructure.MemberString2 != s:
- raise RuntimeError, "MemberString2 test 2"
+ raise RuntimeError, "MemberString2 test 2"
if myStructure.ConstMemberString != "const member string":
- raise RuntimeError, "ConstMemberString test"
+ raise RuntimeError, "ConstMemberString test"
if li_std_string_extra.cvar.Structure_StaticMemberString2 != "static member string 2":
- raise RuntimeError, "StaticMemberString2 test 1"
+ raise RuntimeError, "StaticMemberString2 test 1"
li_std_string_extra.cvar.Structure_StaticMemberString2 = s
if li_std_string_extra.cvar.Structure_StaticMemberString2 != s:
- raise RuntimeError, "StaticMemberString2 test 2"
+ raise RuntimeError, "StaticMemberString2 test 2"
if li_std_string_extra.cvar.Structure_ConstStaticMemberString != "const static member string":
- raise RuntimeError, "ConstStaticMemberString test"
+ raise RuntimeError, "ConstStaticMemberString test"
if li_std_string_extra.test_reference_input("hello") != "hello":
- raise RuntimeError
+ raise RuntimeError
s = li_std_string_extra.test_reference_inout("hello")
if s != "hellohello":
- raise RuntimeError
+ raise RuntimeError
if li_std_string_extra.stdstring_empty() != "":
- raise RuntimeError
-
+ raise RuntimeError
+
if li_std_string_extra.c_empty() != "":
- raise RuntimeError
+ raise RuntimeError
if li_std_string_extra.c_null() != None:
- raise RuntimeError
+ raise RuntimeError
import li_std_vector_enum
+
def check(a, b):
- if (a != b):
- raise RuntimeError("Not equal: ", a, b)
+ if (a != b):
+ raise RuntimeError("Not equal: ", a, b)
ev = li_std_vector_enum.EnumVector()
v = it.value()
check(v, 20)
-expected = 10
+expected = 10
for val in ev.nums:
- check(val, expected)
- expected += 10
-
+ check(val, expected)
+ expected += 10
from li_std_vector_extra import *
iv = IntVector(4)
-for i in range(0,4):
+for i in range(0, 4):
iv[i] = i
x = average(iv)
-y = average([1,2,3,4])
+y = average([1, 2, 3, 4])
-a = half([10,10.5,11,11.5])
+a = half([10, 10.5, 11, 11.5])
dv = DoubleVector(10)
-for i in range(0,10):
- dv[i] = i/2.0
+for i in range(0, 10):
+ dv[i] = i / 2.0
halve_in_place(dv)
bv = BoolVector(4)
-bv[0]= 1
-bv[1]= 0
-bv[2]= 4
-bv[3]= 0
+bv[0] = bool(1)
+bv[1] = bool(0)
+bv[2] = bool(4)
+bv[3] = bool(0)
if bv[0] != bv[2]:
- raise RuntimeError,"bad std::vector<bool> mapping"
+ raise RuntimeError, "bad std::vector<bool> mapping"
b = B(5)
-va = VecA([b,None,b,b])
+va = VecA([b, None, b, b])
if va[0].f(1) != 6:
- raise RuntimeError,"bad std::vector<A*> mapping"
+ raise RuntimeError,
"bad std::vector<A*> mapping"
if vecAptr(va) != 6:
- raise RuntimeError,"bad std::vector<A*> mapping"
+ raise RuntimeError,
"bad std::vector<A*> mapping"
b.val = 7
if va[3].f(1) != 8:
- raise RuntimeError,"bad std::vector<A*> mapping"
+ raise RuntimeError,
"bad std::vector<A*> mapping"
ip = PtrInt()
ap = new_ArrInt(10)
-ArrInt_setitem(ip,0,123)
-ArrInt_setitem(ap,2,123)
+ArrInt_setitem(ip, 0, 123)
+ArrInt_setitem(ap, 2, 123)
-vi = IntPtrVector((ip,ap,None))
-if ArrInt_getitem(vi[0],0) != ArrInt_getitem(vi[1],2):
- raise RuntimeError,"bad std::vector<int*> mapping"
+vi = IntPtrVector((ip, ap, None))
+if ArrInt_getitem(vi[0], 0) != ArrInt_getitem(vi[1], 2):
+ raise RuntimeError, "bad std::vector<int*> mapping"
-delete_ArrInt(ap)
+delete_ArrInt(ap)
-a = halfs([10,8,4,3])
+a = halfs([10, 8, 4, 3])
v = IntVector()
-v[0:2] = [1,2]
+v[0:2] = [1, 2]
if v[0] != 1 or v[1] != 2:
- raise RuntimeError,"bad setslice"
+ raise RuntimeError, "bad setslice"
if v[0:-1][0] != 1:
- raise RuntimeError,"bad getslice"
+ raise RuntimeError, "bad getslice"
if v[0:-2].size() != 0:
- raise RuntimeError,"bad getslice"
+ raise RuntimeError, "bad getslice"
v[0:1] = [2]
if v[0] != 2:
- raise RuntimeError,"bad setslice"
+ raise RuntimeError, "bad setslice"
v[1:] = [3]
if v[1] != 3:
- raise RuntimeError,"bad setslice"
+ raise RuntimeError, "bad setslice"
v[2:] = [3]
if v[2] != 3:
- raise RuntimeError,"bad setslice"
+ raise RuntimeError, "bad setslice"
if v[0:][0] != v[0]:
- raise RuntimeError,"bad getslice"
+ raise RuntimeError, "bad getslice"
del v[:]
if v.size() != 0:
- raise RuntimeError,"bad getslice"
+ raise RuntimeError, "bad getslice"
del v[:]
if v.size() != 0:
- raise RuntimeError,"bad getslice"
-
+ raise RuntimeError, "bad getslice"
v = vecStr(["hello ", "world"])
if v[0] != 'hello world':
- raise RuntimeError,"bad std::string+std::vector"
-
+ raise RuntimeError, "bad std::string+std::vector"
-pv = pyvector([1, "hello", (1,2)])
+pv = pyvector([1, "hello", (1, 2)])
if pv[1] != "hello":
raise RuntimeError
iv = IntVector(5)
-for i in range(0,5):
+for i in range(0, 5):
iv[i] = i
iv[1:3] = []
# Overloading checks
if overloaded1(iv) != "vector<int>":
- raise RuntimeError
+ raise RuntimeError
if overloaded1(dv) != "vector<double>":
- raise RuntimeError
+ raise RuntimeError
if overloaded2(iv) != "vector<int>":
- raise RuntimeError
+ raise RuntimeError
if overloaded2(dv) != "vector<double>":
- raise RuntimeError
+ raise RuntimeError
if overloaded3(iv) != "vector<int> *":
- raise RuntimeError
+ raise RuntimeError
if overloaded3(None) != "vector<int> *":
- raise RuntimeError
+ raise RuntimeError
if overloaded3(100) != "int":
- raise RuntimeError
+ raise RuntimeError
# vector pointer checks
dp = makeDoublePtr(33.3)
error = 0
try:
- vi = IntPtrVector((ip, dp)) # check vector<int *> does not accept double * element
- error = 1
+ # check vector<int *> does not accept double * element
+ vi = IntPtrVector((ip, dp))
+ error = 1
except:
- pass
+ pass
if error:
- raise RuntimeError
+ raise RuntimeError
vi = IntPtrVector((ip, makeIntPtr(22)))
if extractInt(vi[0]) != 11:
- raise RuntimeError
+ raise RuntimeError
if extractInt(vi[1]) != 22:
- raise RuntimeError
+ raise RuntimeError
# vector const pointer checks
csp = makeConstShortPtr(111)
error = 0
try:
- vcs = ConstShortPtrVector((csp, dp)) # check vector<const unsigned short *> does not accept double * element
- error = 1
+ # check vector<const unsigned short *> does not accept double * element
+ vcs = ConstShortPtrVector((csp, dp))
+ error = 1
except:
- pass
+ pass
if error:
- raise RuntimeError
+ raise RuntimeError
vcs = ConstShortPtrVector((csp, makeConstShortPtr(222)))
if extractConstShort(vcs[0]) != 111:
- raise RuntimeError
+ raise RuntimeError
if extractConstShort(vcs[1]) != 222:
- raise RuntimeError
-
+ raise RuntimeError
vi = IntPtrVector((ip1, ip2))
displayVector(vi)
-
from li_std_wstream import *
-
a = A()
o = wostringstream()
o << a << u" " << 2345 << u" " << 1.435 << wends
-if o.str() != "A class 2345 1.435\0":
- print "\"%s\"" % (o.str(),)
- raise RuntimeError
+if o.str() != "A class 2345 1.435\0":
+ print "\"%s\"" % (o.str(),)
+ raise RuntimeError
import li_std_wstring
-x=u"h"
+x = u"h"
if li_std_wstring.test_wcvalue(x) != x:
- print li_std_wstring.test_wcvalue(x)
- raise RuntimeError("bad string mapping")
+ print li_std_wstring.test_wcvalue(x)
+ raise RuntimeError("bad string mapping")
-x=u"hello"
+x = u"hello"
if li_std_wstring.test_ccvalue(x) != x:
- raise RuntimeError("bad string mapping")
+ raise RuntimeError("bad string mapping")
if li_std_wstring.test_cvalue(x) != x:
- raise RuntimeError("bad string mapping")
+ raise RuntimeError("bad string mapping")
if li_std_wstring.test_wchar_overload(x) != x:
- raise RuntimeError("bad string mapping")
+ raise RuntimeError("bad string mapping")
if li_std_wstring.test_wchar_overload("not unicode") != "not unicode":
- raise RuntimeError("bad string mapping")
+ raise RuntimeError("bad string mapping")
if li_std_wstring.test_value(x) != x:
- print x, li_std_wstring.test_value(x)
- raise RuntimeError("bad string mapping")
+ print x, li_std_wstring.test_value(x)
+ raise RuntimeError("bad string mapping")
if li_std_wstring.test_const_reference(x) != x:
- raise RuntimeError("bad string mapping")
+ raise RuntimeError("bad string mapping")
s = li_std_wstring.wstring(u"he")
s = s + u"llo"
if s != x:
- print s, x
- raise RuntimeError("bad string mapping")
+ print s, x
+ raise RuntimeError("bad string mapping")
if s[1:4] != x[1:4]:
- raise RuntimeError("bad string mapping")
+ raise RuntimeError("bad string mapping")
if li_std_wstring.test_value(s) != x:
- raise RuntimeError("bad string mapping")
+ raise RuntimeError("bad string mapping")
if li_std_wstring.test_const_reference(s) != x:
- raise RuntimeError("bad string mapping")
+ raise RuntimeError("bad string mapping")
a = li_std_wstring.A(s)
if li_std_wstring.test_value(a) != x:
- raise RuntimeError("bad string mapping")
+ raise RuntimeError("bad string mapping")
if li_std_wstring.test_const_reference(a) != x:
- raise RuntimeError("bad string mapping")
+ raise RuntimeError("bad string mapping")
b = li_std_wstring.wstring(" world")
if a + b != "hello world":
- raise RuntimeError("bad string mapping")
-
+ raise RuntimeError("bad string mapping")
+
if a + " world" != "hello world":
- raise RuntimeError("bad string mapping")
+ raise RuntimeError("bad string mapping")
# This is expected to fail if -builtin is used
-if "hello" + b != "hello world":
- raise RuntimeError("bad string mapping")
+# Reverse operators not supported in builtin types
+if not li_std_wstring.is_python_builtin():
+ if "hello" + b != "hello world":
+ raise RuntimeError("bad string mapping")
+
+ c = "hello" + b
+ if c.find_last_of("l") != 9:
+ raise RuntimeError("bad string mapping")
-# This is expected to fail if -builtin is used
-c = "hello" + b
-if c.find_last_of("l") != 9:
- raise RuntimeError("bad string mapping")
-
s = "hello world"
b = li_std_wstring.B("hi")
b.name = li_std_wstring.wstring(u"hello")
if b.name != "hello":
- raise RuntimeError("bad string mapping")
+ raise RuntimeError("bad string mapping")
b.a = li_std_wstring.A("hello")
if b.a != u"hello":
- raise RuntimeError("bad string mapping")
-
-
+ raise RuntimeError("bad string mapping")
from member_pointer import *
+
def check(what, expected, actual):
- if expected != actual:
- raise RuntimeError ("Failed: " , what , " Expected: " , expected , " Actual: " , actual)
+ if expected != actual:
+ raise RuntimeError(
+ "Failed: ", what, " Expected: ", expected, " Actual: ", actual)
# Get the pointers
# Do some calculations
-check ("Square area ", 100.0, do_op(s,area_pt))
-check ("Square perim", 40.0, do_op(s,perim_pt))
+check("Square area ", 100.0, do_op(s, area_pt))
+check("Square perim", 40.0, do_op(s, perim_pt))
memberPtr = cvar.areavar
memberPtr = cvar.perimetervar
# Try the variables
-check ("Square area ", 100.0, do_op(s,cvar.areavar))
-check ("Square perim", 40.0, do_op(s,cvar.perimetervar))
+check("Square area ", 100.0, do_op(s, cvar.areavar))
+check("Square perim", 40.0, do_op(s, cvar.perimetervar))
# Modify one of the variables
cvar.areavar = perim_pt
-check ("Square perimeter", 40.0, do_op(s,cvar.areavar))
+check("Square perimeter", 40.0, do_op(s, cvar.areavar))
# Try the constants
memberPtr = PERIMPT
memberPtr = NULLPT
-check ("Square area ", 100.0, do_op(s,AREAPT))
-check ("Square perim", 40.0, do_op(s,PERIMPT))
+check("Square area ", 100.0, do_op(s, AREAPT))
+check("Square perim", 40.0, do_op(s, PERIMPT))
-check ("Add by value", 3, call1(ADD_BY_VALUE, 1, 2))
-check ("Add by pointer", 7, call2(ADD_BY_POINTER, 3, 4))
-check ("Add by reference", 11, call3(ADD_BY_REFERENCE, 5, 6))
+check("Add by value", 3, call1(ADD_BY_VALUE, 1, 2))
+check("Add by pointer", 7, call2(ADD_BY_POINTER, 3, 4))
+check("Add by reference", 11, call3(ADD_BY_REFERENCE, 5, 6))
t = memberin_extend_c.Person()
t.name = "Fred Bloggs"
if t.name != "FRED BLOGGS":
- raise RuntimeError("name wrong")
+ raise RuntimeError("name wrong")
raise RuntimeError, "Bad attribute value"
if b.yget() != 2:
- raise RuntimeError, "Bad attribute value"
+ raise RuntimeError, "Bad attribute value"
if c.xget() != 1 or c.yget() != 2 or c.zget() != 3:
- raise RuntimeError, "Bad attribute value"
+ raise RuntimeError, "Bad attribute value"
if d.xget() != 1 or d.yget() != 2 or d.zget() != 3 or d.wget() != 4:
- raise RuntimeError, "Bad attribute value"
+ raise RuntimeError, "Bad attribute value"
if minherit.xget(a) != 1:
- raise RuntimeError, "Bad attribute value %d" % (minherit.xget(a))
+ raise RuntimeError, "Bad attribute value %d" % (minherit.xget(a))
if minherit.yget(b) != 2:
- raise RuntimeError, "Bad attribute value %d" % (minherit.yget(b))
+ raise RuntimeError, "Bad attribute value %d" % (minherit.yget(b))
if minherit.xget(c) != 1 or minherit.yget(c) != 2 or minherit.zget(c) != 3:
- raise RuntimeError, "Bad attribute value %d %d %d" % (minherit.xget(c), minherit.yget(c), minherit.zget(c))
+ raise RuntimeError, "Bad attribute value %d %d %d" % (
+ minherit.xget(c), minherit.yget(c), minherit.zget(c))
if minherit.xget(d) != 1 or minherit.yget(d) != 2 or minherit.zget(d) != 3 or minherit.wget(d) != 4:
- raise RuntimeError, "Bad attribute value %d %d %d %d" % (minherit.xget(d), minherit.yget(d), minherit.zget(d), minherit.wget(d))
+ raise RuntimeError, "Bad attribute value %d %d %d %d" % (
+ minherit.xget(d), minherit.yget(d), minherit.zget(d), minherit.wget(d))
# Cleanse all of the pointers and see what happens
raise RuntimeError, "Bad attribute value"
if bb.yget() != 2:
- raise RuntimeError, "Bad attribute value"
+ raise RuntimeError, "Bad attribute value"
if cc.xget() != 1 or cc.yget() != 2 or cc.zget() != 3:
- raise RuntimeError, "Bad attribute value"
+ raise RuntimeError, "Bad attribute value"
if dd.xget() != 1 or dd.yget() != 2 or dd.zget() != 3 or dd.wget() != 4:
- raise RuntimeError, "Bad attribute value"
+ raise RuntimeError, "Bad attribute value"
if minherit.xget(aa) != 1:
- raise RuntimeError, "Bad attribute value %d" % (minherit.xget(aa))
+ raise RuntimeError, "Bad attribute value %d" % (minherit.xget(aa))
if minherit.yget(bb) != 2:
- raise RuntimeError, "Bad attribute value %d" % (minherit.yget(bb))
+ raise RuntimeError, "Bad attribute value %d" % (minherit.yget(bb))
if minherit.xget(cc) != 1 or minherit.yget(cc) != 2 or minherit.zget(cc) != 3:
- raise RuntimeError, "Bad attribute value %d %d %d" % (minherit.xget(cc), minherit.yget(cc), minherit.zget(cc))
+ raise RuntimeError, "Bad attribute value %d %d %d" % (
+ minherit.xget(cc), minherit.yget(cc), minherit.zget(cc))
if minherit.xget(dd) != 1 or minherit.yget(dd) != 2 or minherit.zget(dd) != 3 or minherit.wget(dd) != 4:
- raise RuntimeError, "Bad attribute value %d %d %d %d" % (minherit.xget(dd), minherit.yget(dd), minherit.zget(dd), minherit.wget(dd))
-
-
-
-
-
-
-
-
+ raise RuntimeError, "Bad attribute value %d %d %d %d" % (
+ minherit.xget(dd), minherit.yget(dd), minherit.zget(dd), minherit.wget(dd))
x = multi_import_b.XXX()
if x.testx() != 0:
- raise RuntimeError
+ raise RuntimeError
y = multi_import_b.YYY()
if y.testx() != 0:
- raise RuntimeError
+ raise RuntimeError
if y.testy() != 1:
- raise RuntimeError
+ raise RuntimeError
z = multi_import_a.ZZZ()
if z.testx() != 0:
- raise RuntimeError
+ raise RuntimeError
if z.testz() != 2:
- raise RuntimeError
+ raise RuntimeError
from namespace_class import *
+
+def is_new_style_class(cls):
+ return hasattr(cls, "__class__")
+
try:
- p = Private1()
- error = 1
+ p = Private1()
+ error = 1
except:
- error = 0
+ error = 0
if (error):
- raise RuntimeError, "Private1 is private"
+ raise RuntimeError, "Private1 is private"
try:
- p = Private2()
- error = 1
+ p = Private2()
+ error = 1
except:
- error = 0
+ error = 0
if (error):
- raise RuntimeError, "Private2 is private"
+ raise RuntimeError, "Private2 is private"
-EulerT3D.toFrame(1,1,1)
+if is_new_style_class(EulerT3D):
+ EulerT3D.toFrame(1, 1, 1)
+else:
+ EulerT3D().toFrame(1, 1, 1)
b = BooT_i()
b = BooT_H()
f = FooT_H()
f.foo(Hi)
+
+if is_new_style_class(FooT_H):
+ f_type = str(type(f))
+ if f_type.find("'namespace_class.FooT_H'") == -1:
+ raise RuntimeError("Incorrect type: " + f_type)
if stest12("hello") != "hello":
raise RuntimeError
-c = complex(2,3)
+c = complex(2, 3)
r = c.real
if ctest1(c) != r:
--- /dev/null
+from nested_template_base import *
+
+
+ois = InnerS(123)
+oic = InnerC()
+
+# Check base method is available
+if (oic.outer(ois).val != 123):
+ raise RuntimeError("Wrong value calling outer")
+
+# Check non-derived class using base class
+if (oic.innerc().outer(ois).val != 123):
+ raise RuntimeError("Wrong value calling innerc")
outer = Outer()
newInner = outer.doubleInnerValue(inner)
if newInner.getValue() != 10:
- raise RuntimeError
+ raise RuntimeError
outer = Outer()
inner = outer.createInner(3)
newInner = outer.doubleInnerValue(inner)
if outer.getInnerValue(newInner) != 6:
- raise RuntimeError
+ raise RuntimeError
--- /dev/null
+from operator_overload import *
+
+# first check all the operators are implemented correctly from pure C++ code
+Op_sanity_check()
+
+pop = Op(6)/Op(3)
+
+# test routine:
+a=Op()
+b=Op(5)
+c=Op(b) # copy construct
+d=Op(2)
+dd=d # assignment operator
+
+# test equality
+if not a!=b:
+ raise RuntimeError("a!=b")
+if not b==c:
+ raise RuntimeError("b==c")
+if not a!=d:
+ raise RuntimeError("a!=d")
+if not d==dd:
+ raise RuntimeError("d==dd")
+
+# test <
+if not a<b:
+ raise RuntimeError("a<b")
+if not a<=b:
+ raise RuntimeError("a<=b")
+if not b<=c:
+ raise RuntimeError("b<=c")
+if not b>=c:
+ raise RuntimeError("b>=c")
+if not b>d:
+ raise RuntimeError("b>d")
+if not b>=d:
+ raise RuntimeError("b>=d")
+
+# test +=
+e=Op(3)
+e+=d
+if not e==b:
+ raise RuntimeError("e==b (%s==%s)" % (e.i, b.i))
+e-=c
+if not e==a:
+ raise RuntimeError("e==a")
+e=Op(1)
+e*=b
+if not e==c:
+ raise RuntimeError("e==c")
+e/=d
+if not e==d:
+ raise RuntimeError("e==d")
+e%=c;
+if not e==d:
+ raise RuntimeError("e==d")
+
+# test +
+f=Op(1)
+g=Op(1)
+if not f+g==Op(2):
+ raise RuntimeError("f+g==Op(2)")
+if not f-g==Op(0):
+ raise RuntimeError("f-g==Op(0)")
+if not f*g==Op(1):
+ raise RuntimeError("f*g==Op(1)")
+if not f/g==Op(1):
+ raise RuntimeError("f/g==Op(1)")
+if not f%g==Op(0):
+ raise RuntimeError("f%g==Op(0)")
+
+# test unary operators
+if not -a==a:
+ raise RuntimeError("-a==a")
+if not -b==Op(-5):
+ raise RuntimeError("-b==Op(-5)")
+
#!/usr/bin/env python
import operbool
assert not operbool.Test()
-
--- /dev/null
+import overload_bool
+
+# Overloading bool, int, string
+if overload_bool.overloaded(True) != "bool":
+ raise RuntimeError("wrong!")
+if overload_bool.overloaded(False) != "bool":
+ raise RuntimeError("wrong!")
+
+if overload_bool.overloaded(0) != "int":
+ raise RuntimeError("wrong!")
+if overload_bool.overloaded(1) != "int":
+ raise RuntimeError("wrong!")
+if overload_bool.overloaded(2) != "int":
+ raise RuntimeError("wrong!")
+
+if overload_bool.overloaded("1234") != "string":
+ raise RuntimeError("wrong!")
+
+# Test bool masquerading as int
+if overload_bool.intfunction(True) != "int":
+ raise RuntimeError("wrong!")
+if overload_bool.intfunction(False) != "int":
+ raise RuntimeError("wrong!")
+
+# Test int masquerading as bool
+# Not possible
+
+
+#############################################
+
+# Overloading bool, int, string
+if overload_bool.overloaded_ref(True) != "bool":
+ raise RuntimeError("wrong!")
+if overload_bool.overloaded_ref(False) != "bool":
+ raise RuntimeError("wrong!")
+
+if overload_bool.overloaded_ref(0) != "int":
+ raise RuntimeError("wrong!")
+if overload_bool.overloaded_ref(1) != "int":
+ raise RuntimeError("wrong!")
+if overload_bool.overloaded_ref(2) != "int":
+ raise RuntimeError("wrong!")
+
+if overload_bool.overloaded_ref("1234") != "string":
+ raise RuntimeError("wrong!")
+
+# Test bool masquerading as int
+if overload_bool.intfunction_ref(True) != "int":
+ raise RuntimeError("wrong!")
+if overload_bool.intfunction_ref(False) != "int":
+ raise RuntimeError("wrong!")
+
+# Test int masquerading as bool
+# Not possible
p = Pop(pInt, 0)
-# Check overloaded in const only and pointers/references which target languages cannot disambiguate
+# Check overloaded in const only and pointers/references which target
+# languages cannot disambiguate
if p.hip(0) != 701:
- raise RuntimeError,"Test 1 failed"
+ raise RuntimeError, "Test 1 failed"
if p.hip(pInt) != 702:
- raise RuntimeError,"Test 2 failed"
+ raise RuntimeError, "Test 2 failed"
# Reverse the order for the above
if p.hop(pInt) != 805:
- raise RuntimeError,"Test 3 failed"
+ raise RuntimeError, "Test 3 failed"
if p.hop(0) != 801:
- raise RuntimeError,"Test 4 failed"
+ raise RuntimeError, "Test 4 failed"
# Few more variations and order shuffled
if p.pop(0) != 901:
- raise RuntimeError,"Test 5 failed"
+ raise RuntimeError, "Test 5 failed"
if p.pop(pInt) != 902:
- raise RuntimeError,"Test 6 failed"
+ raise RuntimeError, "Test 6 failed"
if p.pop() != 905:
- raise RuntimeError,"Test 7 failed"
+ raise RuntimeError, "Test 7 failed"
# Overload on const only
if p.bop(pInt) != 1001:
- raise RuntimeError,"Test 8 failed"
+ raise RuntimeError, "Test 8 failed"
if p.bip(pInt) != 2001:
- raise RuntimeError,"Test 9 failed"
+ raise RuntimeError, "Test 9 failed"
# Globals
if muzak(0) != 3001:
- raise RuntimeError,"Test 10 failed"
+ raise RuntimeError, "Test 10 failed"
if muzak(pInt) != 3002:
- raise RuntimeError,"Test 11 failed"
-
+ raise RuntimeError, "Test 11 failed"
-import overload_extendc
+import overload_extend2
-f = overload_extendc.Foo()
+f = overload_extend2.Foo()
if f.test(3) != 1:
raise RuntimeError
if f.test("hello") != 2:
raise RuntimeError
-if f.test(3.5,2.5) != 3:
+if f.test(3.5, 2.5) != 3:
raise RuntimeError
-if f.test("hello",20) != 1020:
+if f.test("hello", 20) != 1020:
raise RuntimeError
-if f.test("hello",20,100) != 120:
+if f.test("hello", 20, 100) != 120:
raise RuntimeError
# C default args
if f.test(f) != 30:
raise RuntimeError
-if f.test(f,100) != 120:
+if f.test(f, 100) != 120:
raise RuntimeError
-if f.test(f,100,200) != 300:
+if f.test(f, 100, 200) != 300:
raise RuntimeError
-
--- /dev/null
+import overload_extend_c
+
+f = overload_extend_c.Foo()
+if f.test() != 0:
+ raise RuntimeError
+if f.test(3) != 1:
+ raise RuntimeError
+if f.test("hello") != 2:
+ raise RuntimeError
+if f.test(3, 2) != 5:
+ raise RuntimeError
+if f.test(3.0) != 1003:
+ raise RuntimeError
raise RuntimeError
if f.test("hello") != 2:
raise RuntimeError
-if f.test(3,2) != 5:
+if f.test(3, 2) != 5:
raise RuntimeError
if f.test(3.0) != 1003:
raise RuntimeError
-
nums = Nums()
limits = Limits()
+
def check(got, expected):
- if got != expected:
- raise RuntimeError("got: " + got + " expected: " + expected)
+ if got != expected:
+ raise RuntimeError("got: " + got + " expected: " + expected)
check(nums.over(0), "signed char")
check(nums.over(0.0), "float")
check(nums.over(limits.schar_min()), "signed char")
check(nums.over(limits.schar_max()), "signed char")
-check(nums.over(limits.schar_min()-1), "short")
-check(nums.over(limits.schar_max()+1), "short")
+check(nums.over(limits.schar_min() - 1), "short")
+check(nums.over(limits.schar_max() + 1), "short")
check(nums.over(limits.shrt_min()), "short")
check(nums.over(limits.shrt_max()), "short")
-check(nums.over(limits.shrt_min()-1), "int")
-check(nums.over(limits.shrt_max()+1), "int")
+check(nums.over(limits.shrt_min() - 1), "int")
+check(nums.over(limits.shrt_max() + 1), "int")
check(nums.over(limits.int_min()), "int")
check(nums.over(limits.int_max()), "int")
check(nums.over(limits.flt_min()), "float")
check(nums.over(limits.flt_max()), "float")
-check(nums.over(limits.flt_max()*10), "double")
-check(nums.over(-limits.flt_max()*10), "double")
+check(nums.over(limits.flt_max() * 10), "double")
+check(nums.over(-limits.flt_max() * 10), "double")
check(nums.over(limits.dbl_max()), "double")
check(nums.over(-limits.dbl_max()), "double")
f = overload_rename.Foo(1)
-f = overload_rename.Foo(1,1)
-f = overload_rename.Foo_int(1,1)
-f = overload_rename.Foo_int(1,1,1)
-
+f = overload_rename.Foo(1, 1)
+f = overload_rename.Foo_int(1, 1)
+f = overload_rename.Foo_int(1, 1, 1)
s = Spam(3)
if s.type != "int":
raise RuntimeError, "Spam(int)"
-
+
s = Spam(3.4)
if s.type != "double":
raise RuntimeError, "Spam(double)"
raise RuntimeError, "Spam(void *)"
-
-
-
free_void(v)
if spam(b) != 2:
raise RuntimeError, "bar"
-
from overload_template_fast import *
+
+
+def is_new_style_class(cls):
+ return hasattr(cls, "__class__")
+
f = foo()
-a = maximum(3,4)
-b = maximum(3.4,5.2)
+a = maximum(3, 4)
+b = maximum(3.4, 5.2)
# mix 1
if (mix1("hi") != 101):
- raise RuntimeError, ("mix1(const char*)")
+ raise RuntimeError, ("mix1(const char*)")
if (mix1(1.0, 1.0) != 102):
- raise RuntimeError, ("mix1(double, const double &)")
+ raise RuntimeError, ("mix1(double, const double &)")
if (mix1(1.0) != 103):
- raise RuntimeError, ("mix1(double)")
+ raise RuntimeError, ("mix1(double)")
# mix 2
if (mix2("hi") != 101):
- raise RuntimeError, ("mix2(const char*)")
+ raise RuntimeError, ("mix2(const char*)")
if (mix2(1.0, 1.0) != 102):
- raise RuntimeError, ("mix2(double, const double &)")
+ raise RuntimeError, ("mix2(double, const double &)")
if (mix2(1.0) != 103):
- raise RuntimeError, ("mix2(double)")
+ raise RuntimeError, ("mix2(double)")
# mix 3
if (mix3("hi") != 101):
- raise RuntimeError, ("mix3(const char*)")
+ raise RuntimeError, ("mix3(const char*)")
if (mix3(1.0, 1.0) != 102):
- raise RuntimeError, ("mix3(double, const double &)")
+ raise RuntimeError, ("mix3(double, const double &)")
if (mix3(1.0) != 103):
- raise RuntimeError, ("mix3(double)")
+ raise RuntimeError, ("mix3(double)")
# Combination 1
if (overtparams1(100) != 10):
- raise RuntimeError, ("overtparams1(int)")
+ raise RuntimeError, ("overtparams1(int)")
if (overtparams1(100.0, 100) != 20):
- raise RuntimeError, ("overtparams1(double, int)")
+ raise RuntimeError, ("overtparams1(double, int)")
# Combination 2
if (overtparams2(100.0, 100) != 40):
- raise RuntimeError, ("overtparams2(double, int)")
+ raise RuntimeError, ("overtparams2(double, int)")
# Combination 3
if (overloaded() != 60):
- raise RuntimeError, ("overloaded()")
+ raise RuntimeError, ("overloaded()")
if (overloaded(100.0, 100) != 70):
- raise RuntimeError, ("overloaded(double, int)")
+ raise RuntimeError, ("overloaded(double, int)")
# Combination 4
if (overloadedagain("hello") != 80):
- raise RuntimeError, ("overloadedagain(const char *)")
+ raise RuntimeError, ("overloadedagain(const char *)")
if (overloadedagain() != 90):
- raise RuntimeError, ("overloadedagain(double)")
+ raise RuntimeError, ("overloadedagain(double)")
# specializations
if (specialization(10) != 202):
- raise RuntimeError, ("specialization(int)")
+ raise RuntimeError, ("specialization(int)")
if (specialization(10.0) != 203):
- raise RuntimeError, ("specialization(double)")
+ raise RuntimeError, ("specialization(double)")
if (specialization(10, 10) != 204):
- raise RuntimeError, ("specialization(int, int)")
+ raise RuntimeError, ("specialization(int, int)")
if (specialization(10.0, 10.0) != 205):
- raise RuntimeError, ("specialization(double, double)")
+ raise RuntimeError, ("specialization(double, double)")
if (specialization("hi", "hi") != 201):
- raise RuntimeError, ("specialization(const char *, const char *)")
+ raise RuntimeError, ("specialization(const char *, const char *)")
# simple specialization
# a bit of everything
if (overload("hi") != 0):
- raise RuntimeError, ("overload()")
+ raise RuntimeError, ("overload()")
if (overload(1) != 10):
- raise RuntimeError, ("overload(int t)")
+ raise RuntimeError, ("overload(int t)")
if (overload(1, 1) != 20):
- raise RuntimeError, ("overload(int t, const int &)")
+ raise RuntimeError, ("overload(int t, const int &)")
if (overload(1, "hello") != 30):
- raise RuntimeError, ("overload(int t, const char *)")
+ raise RuntimeError, ("overload(int t, const char *)")
k = Klass()
if (overload(k) != 10):
- raise RuntimeError, ("overload(Klass t)")
+ raise RuntimeError, ("overload(Klass t)")
if (overload(k, k) != 20):
- raise RuntimeError, ("overload(Klass t, const Klass &)")
+ raise RuntimeError, ("overload(Klass t, const Klass &)")
if (overload(k, "hello") != 30):
- raise RuntimeError, ("overload(Klass t, const char *)")
+ raise RuntimeError, ("overload(Klass t, const char *)")
if (overload(10.0, "hi") != 40):
- raise RuntimeError, ("overload(double t, const char *)")
+ raise RuntimeError, ("overload(double t, const char *)")
if (overload() != 50):
- raise RuntimeError, ("overload(const char *)")
+ raise RuntimeError, ("overload(const char *)")
# everything put in a namespace
if (nsoverload("hi") != 1000):
- raise RuntimeError, ("nsoverload()")
+ raise RuntimeError, ("nsoverload()")
if (nsoverload(1) != 1010):
- raise RuntimeError, ("nsoverload(int t)")
+ raise RuntimeError, ("nsoverload(int t)")
if (nsoverload(1, 1) != 1020):
- raise RuntimeError, ("nsoverload(int t, const int &)")
+ raise RuntimeError, ("nsoverload(int t, const int &)")
if (nsoverload(1, "hello") != 1030):
- raise RuntimeError, ("nsoverload(int t, const char *)")
+ raise RuntimeError, ("nsoverload(int t, const char *)")
if (nsoverload(k) != 1010):
- raise RuntimeError, ("nsoverload(Klass t)")
+ raise RuntimeError, ("nsoverload(Klass t)")
if (nsoverload(k, k) != 1020):
- raise RuntimeError, ("nsoverload(Klass t, const Klass &)")
+ raise RuntimeError, ("nsoverload(Klass t, const Klass &)")
if (nsoverload(k, "hello") != 1030):
- raise RuntimeError, ("nsoverload(Klass t, const char *)")
+ raise RuntimeError, ("nsoverload(Klass t, const char *)")
if (nsoverload(10.0, "hi") != 1040):
- raise RuntimeError, ("nsoverload(double t, const char *)")
+ raise RuntimeError, ("nsoverload(double t, const char *)")
if (nsoverload() != 1050):
- raise RuntimeError, ("nsoverload(const char *)")
+ raise RuntimeError, ("nsoverload(const char *)")
-A.foo(1)
+if is_new_style_class(A):
+ A.foo(1)
+else:
+ A_foo(1)
b = B()
b.foo(1)
from overload_template import *
f = foo()
-a = maximum(3,4)
-b = maximum(3.4,5.2)
+a = maximum(3, 4)
+b = maximum(3.4, 5.2)
# mix 1
if (mix1("hi") != 101):
- raise RuntimeError, ("mix1(const char*)")
+ raise RuntimeError, ("mix1(const char*)")
if (mix1(1.0, 1.0) != 102):
- raise RuntimeError, ("mix1(double, const double &)")
+ raise RuntimeError, ("mix1(double, const double &)")
if (mix1(1.0) != 103):
- raise RuntimeError, ("mix1(double)")
+ raise RuntimeError, ("mix1(double)")
# mix 2
if (mix2("hi") != 101):
- raise RuntimeError, ("mix2(const char*)")
+ raise RuntimeError, ("mix2(const char*)")
if (mix2(1.0, 1.0) != 102):
- raise RuntimeError, ("mix2(double, const double &)")
+ raise RuntimeError, ("mix2(double, const double &)")
if (mix2(1.0) != 103):
- raise RuntimeError, ("mix2(double)")
+ raise RuntimeError, ("mix2(double)")
# mix 3
if (mix3("hi") != 101):
- raise RuntimeError, ("mix3(const char*)")
+ raise RuntimeError, ("mix3(const char*)")
if (mix3(1.0, 1.0) != 102):
- raise RuntimeError, ("mix3(double, const double &)")
+ raise RuntimeError, ("mix3(double, const double &)")
if (mix3(1.0) != 103):
- raise RuntimeError, ("mix3(double)")
+ raise RuntimeError, ("mix3(double)")
# Combination 1
if (overtparams1(100) != 10):
- raise RuntimeError, ("overtparams1(int)")
+ raise RuntimeError, ("overtparams1(int)")
if (overtparams1(100.0, 100) != 20):
- raise RuntimeError, ("overtparams1(double, int)")
+ raise RuntimeError, ("overtparams1(double, int)")
# Combination 2
if (overtparams2(100.0, 100) != 40):
- raise RuntimeError, ("overtparams2(double, int)")
+ raise RuntimeError, ("overtparams2(double, int)")
# Combination 3
if (overloaded() != 60):
- raise RuntimeError, ("overloaded()")
+ raise RuntimeError, ("overloaded()")
if (overloaded(100.0, 100) != 70):
- raise RuntimeError, ("overloaded(double, int)")
+ raise RuntimeError, ("overloaded(double, int)")
# Combination 4
if (overloadedagain("hello") != 80):
- raise RuntimeError, ("overloadedagain(const char *)")
+ raise RuntimeError, ("overloadedagain(const char *)")
if (overloadedagain() != 90):
- raise RuntimeError, ("overloadedagain(double)")
+ raise RuntimeError, ("overloadedagain(double)")
# specializations
if (specialization(10) != 202):
- raise RuntimeError, ("specialization(int)")
+ raise RuntimeError, ("specialization(int)")
if (specialization(10.0) != 203):
- raise RuntimeError, ("specialization(double)")
+ raise RuntimeError, ("specialization(double)")
if (specialization(10, 10) != 204):
- raise RuntimeError, ("specialization(int, int)")
+ raise RuntimeError, ("specialization(int, int)")
if (specialization(10.0, 10.0) != 205):
- raise RuntimeError, ("specialization(double, double)")
+ raise RuntimeError, ("specialization(double, double)")
if (specialization("hi", "hi") != 201):
- raise RuntimeError, ("specialization(const char *, const char *)")
+ raise RuntimeError, ("specialization(const char *, const char *)")
# simple specialization
# a bit of everything
if (overload("hi") != 0):
- raise RuntimeError, ("overload()")
+ raise RuntimeError, ("overload()")
if (overload(1) != 10):
- raise RuntimeError, ("overload(int t)")
+ raise RuntimeError, ("overload(int t)")
if (overload(1, 1) != 20):
- raise RuntimeError, ("overload(int t, const int &)")
+ raise RuntimeError, ("overload(int t, const int &)")
if (overload(1, "hello") != 30):
- raise RuntimeError, ("overload(int t, const char *)")
+ raise RuntimeError, ("overload(int t, const char *)")
k = Klass()
if (overload(k) != 10):
- raise RuntimeError, ("overload(Klass t)")
+ raise RuntimeError, ("overload(Klass t)")
if (overload(k, k) != 20):
- raise RuntimeError, ("overload(Klass t, const Klass &)")
+ raise RuntimeError, ("overload(Klass t, const Klass &)")
if (overload(k, "hello") != 30):
- raise RuntimeError, ("overload(Klass t, const char *)")
+ raise RuntimeError, ("overload(Klass t, const char *)")
if (overload(10.0, "hi") != 40):
- raise RuntimeError, ("overload(double t, const char *)")
+ raise RuntimeError, ("overload(double t, const char *)")
if (overload() != 50):
- raise RuntimeError, ("overload(const char *)")
+ raise RuntimeError, ("overload(const char *)")
# everything put in a namespace
if (nsoverload("hi") != 1000):
- raise RuntimeError, ("nsoverload()")
+ raise RuntimeError, ("nsoverload()")
if (nsoverload(1) != 1010):
- raise RuntimeError, ("nsoverload(int t)")
+ raise RuntimeError, ("nsoverload(int t)")
if (nsoverload(1, 1) != 1020):
- raise RuntimeError, ("nsoverload(int t, const int &)")
+ raise RuntimeError, ("nsoverload(int t, const int &)")
if (nsoverload(1, "hello") != 1030):
- raise RuntimeError, ("nsoverload(int t, const char *)")
+ raise RuntimeError, ("nsoverload(int t, const char *)")
if (nsoverload(k) != 1010):
- raise RuntimeError, ("nsoverload(Klass t)")
+ raise RuntimeError, ("nsoverload(Klass t)")
if (nsoverload(k, k) != 1020):
- raise RuntimeError, ("nsoverload(Klass t, const Klass &)")
+ raise RuntimeError, ("nsoverload(Klass t, const Klass &)")
if (nsoverload(k, "hello") != 1030):
- raise RuntimeError, ("nsoverload(Klass t, const char *)")
+ raise RuntimeError, ("nsoverload(Klass t, const char *)")
if (nsoverload(10.0, "hi") != 1040):
- raise RuntimeError, ("nsoverload(double t, const char *)")
+ raise RuntimeError, ("nsoverload(double t, const char *)")
if (nsoverload() != 1050):
- raise RuntimeError, ("nsoverload(const char *)")
+ raise RuntimeError, ("nsoverload(const char *)")
A_foo(1)
s = pointer_reference.get()
if s.value != 10:
- raise RuntimeError, "get test failed"
+ raise RuntimeError, "get test failed"
ss = pointer_reference.Struct(20)
pointer_reference.set(ss)
if pointer_reference.cvar.Struct_instance.value != 20:
- raise RuntimeError, "set test failed"
+ raise RuntimeError, "set test failed"
if pointer_reference.overloading(1) != 111:
- raise RuntimeError, "overload test 1 failed"
+ raise RuntimeError, "overload test 1 failed"
if pointer_reference.overloading(ss) != 222:
- raise RuntimeError, "overload test 2 failed"
+ raise RuntimeError, "overload test 2 failed"
import preproc_defined
if preproc_defined.call_checking() != 1:
- raise RuntimeError
+ raise RuntimeError
d = preproc_defined.Defined()
d.defined = 10
import preproc_include
if preproc_include.multiply10(10) != 100:
- raise RuntimeError
+ raise RuntimeError
if preproc_include.multiply20(10) != 200:
- raise RuntimeError
+ raise RuntimeError
if preproc_include.multiply30(10) != 300:
- raise RuntimeError
+ raise RuntimeError
if preproc_include.multiply40(10) != 400:
- raise RuntimeError
+ raise RuntimeError
if preproc_include.multiply50(10) != 500:
- raise RuntimeError
+ raise RuntimeError
if preproc_include.multiply60(10) != 600:
- raise RuntimeError
+ raise RuntimeError
if preproc_include.multiply70(10) != 700:
- raise RuntimeError
-
+ raise RuntimeError
import preproc
if preproc.endif != 1:
- raise RuntimeError
+ raise RuntimeError
if preproc.define != 1:
- raise RuntimeError
+ raise RuntimeError
if preproc.defined != 1:
- raise RuntimeError
+ raise RuntimeError
-if 2*preproc.one != preproc.two:
- raise RuntimeError
+if 2 * preproc.one != preproc.two:
+ raise RuntimeError
+if preproc.methodX(99) != 199:
+ raise RuntimeError
if ref_double(3.5) != 3.5:
raise RuntimeError
-if ref_bool(1) != 1:
+if ref_bool(True) != True:
raise RuntimeError
if ref_char('x') != 'x':
+import sys
from primitive_types import *
var_init()
v_check()
+
def pyerror(name, val, cte):
- print "bad val/cte", name, val, cte
- raise RuntimeError
- pass
-
-if cvar.var_bool != cct_bool: pyerror("bool", cvar.var_bool, cct_bool)
-if cvar.var_schar != cct_schar: pyerror("schar", cvar.var_schar, cct_schar)
-if cvar.var_uchar != cct_uchar: pyerror("uchar", cvar.var_uchar, cct_uchar)
-if cvar.var_int != cct_int: pyerror("int", cvar.var_int, cct_int)
-if cvar.var_uint != cct_uint: pyerror("uint", cvar.var_uint, cct_uint)
-if cvar.var_short != cct_short: pyerror("short", cvar.var_short, cct_short)
-if cvar.var_ushort != cct_ushort: pyerror("ushort", cvar.var_ushort, cct_ushort)
-if cvar.var_long != cct_long: pyerror("long", cvar.var_long, cct_long)
-if cvar.var_ulong != cct_ulong: pyerror("ulong", cvar.var_ulong, cct_ulong)
-if cvar.var_llong != cct_llong: pyerror("llong", cvar.var_llong, cct_llong)
-if cvar.var_ullong != cct_ullong: pyerror("ullong", cvar.var_ullong, cct_ullong)
-if cvar.var_char != cct_char: pyerror("char", cvar.var_char, cct_char)
-if cvar.var_pchar != cct_pchar: pyerror("pchar", cvar.var_pchar, cct_pchar)
-if cvar.var_pcharc != cct_pcharc: pyerror("pchar", cvar.var_pcharc, cct_pcharc)
-if cvar.var_pint != cct_pint: pyerror("pint", cvar.var_pint, cct_pint)
-if cvar.var_sizet != cct_sizet: pyerror("sizet", cvar.var_sizet, cct_sizet)
-if cvar.var_hello != cct_hello: pyerror("hello", cvar.var_hello, cct_hello)
-if cvar.var_myint != cct_myint: pyerror("myint", cvar.var_myint, cct_myint)
-if cvar.var_namet != def_namet: pyerror("name", cvar.var_namet, def_namet)
+ print "bad val/cte", name, val, cte
+ raise RuntimeError
+ pass
+
+if cvar.var_bool != cct_bool:
+ pyerror("bool", cvar.var_bool, cct_bool)
+if cvar.var_schar != cct_schar:
+ pyerror("schar", cvar.var_schar, cct_schar)
+if cvar.var_uchar != cct_uchar:
+ pyerror("uchar", cvar.var_uchar, cct_uchar)
+if cvar.var_int != cct_int:
+ pyerror("int", cvar.var_int, cct_int)
+if cvar.var_uint != cct_uint:
+ pyerror("uint", cvar.var_uint, cct_uint)
+if cvar.var_short != cct_short:
+ pyerror("short", cvar.var_short, cct_short)
+if cvar.var_ushort != cct_ushort:
+ pyerror("ushort", cvar.var_ushort, cct_ushort)
+if cvar.var_long != cct_long:
+ pyerror("long", cvar.var_long, cct_long)
+if cvar.var_ulong != cct_ulong:
+ pyerror("ulong", cvar.var_ulong, cct_ulong)
+if cvar.var_llong != cct_llong:
+ pyerror("llong", cvar.var_llong, cct_llong)
+if cvar.var_ullong != cct_ullong:
+ pyerror("ullong", cvar.var_ullong, cct_ullong)
+if cvar.var_char != cct_char:
+ pyerror("char", cvar.var_char, cct_char)
+if cvar.var_pchar != cct_pchar:
+ pyerror("pchar", cvar.var_pchar, cct_pchar)
+if cvar.var_pcharc != cct_pcharc:
+ pyerror("pchar", cvar.var_pcharc, cct_pcharc)
+if cvar.var_pint != cct_pint:
+ pyerror("pint", cvar.var_pint, cct_pint)
+if cvar.var_sizet != cct_sizet:
+ pyerror("sizet", cvar.var_sizet, cct_sizet)
+if cvar.var_hello != cct_hello:
+ pyerror("hello", cvar.var_hello, cct_hello)
+if cvar.var_myint != cct_myint:
+ pyerror("myint", cvar.var_myint, cct_myint)
+if cvar.var_namet != def_namet:
+ pyerror("name", cvar.var_namet, def_namet)
+
class PyTest (TestDirector):
- def __init__(self):
- TestDirector.__init__(self)
+
+ def __init__(self):
+ TestDirector.__init__(self)
+ pass
+
+ def ident(self, x):
+ return x
+
+ def vval_bool(self, x): return self.ident(x)
+
+ def vval_schar(self, x): return self.ident(x)
+
+ def vval_uchar(self, x): return self.ident(x)
+
+ def vval_int(self, x): return self.ident(x)
+
+ def vval_uint(self, x): return self.ident(x)
+
+ def vval_short(self, x): return self.ident(x)
+
+ def vval_ushort(self, x): return self.ident(x)
+
+ def vval_long(self, x): return self.ident(x)
+
+ def vval_ulong(self, x): return self.ident(x)
+
+ def vval_llong(self, x): return self.ident(x)
+
+ def vval_ullong(self, x): return self.ident(x)
+
+ def vval_float(self, x): return self.ident(x)
+
+ def vval_double(self, x): return self.ident(x)
+
+ def vval_char(self, x): return self.ident(x)
+
+ def vval_pchar(self, x): return self.ident(x)
+
+ def vval_pcharc(self, x): return self.ident(x)
+
+ def vval_pint(self, x): return self.ident(x)
+
+ def vval_sizet(self, x): return self.ident(x)
+
+ def vval_hello(self, x): return self.ident(x)
+
+ def vval_myint(self, x): return self.ident(x)
+
+ def vref_bool(self, x): return self.ident(x)
+
+ def vref_schar(self, x): return self.ident(x)
+
+ def vref_uchar(self, x): return self.ident(x)
+
+ def vref_int(self, x): return self.ident(x)
+
+ def vref_uint(self, x): return self.ident(x)
+
+ def vref_short(self, x): return self.ident(x)
+
+ def vref_ushort(self, x): return self.ident(x)
+
+ def vref_long(self, x): return self.ident(x)
+
+ def vref_ulong(self, x): return self.ident(x)
+
+ def vref_llong(self, x): return self.ident(x)
+
+ def vref_ullong(self, x): return self.ident(x)
+
+ def vref_float(self, x): return self.ident(x)
+
+ def vref_double(self, x): return self.ident(x)
+
+ def vref_char(self, x): return self.ident(x)
+
+ def vref_pchar(self, x): return self.ident(x)
+
+ def vref_pcharc(self, x): return self.ident(x)
+
+ def vref_pint(self, x): return self.ident(x)
+
+ def vref_sizet(self, x): return self.ident(x)
+
+ def vref_hello(self, x): return self.ident(x)
+
+ def vref_myint(self, x): return self.ident(x)
+
pass
- def ident(self, x):
- return x
-
- def vval_bool(self, x): return self.ident(x)
- def vval_schar(self, x): return self.ident(x)
- def vval_uchar(self, x): return self.ident(x)
- def vval_int(self, x): return self.ident(x)
- def vval_uint(self, x): return self.ident(x)
- def vval_short(self, x): return self.ident(x)
- def vval_ushort(self, x): return self.ident(x)
- def vval_long(self, x): return self.ident(x)
- def vval_ulong(self, x): return self.ident(x)
- def vval_llong(self, x): return self.ident(x)
- def vval_ullong(self, x): return self.ident(x)
- def vval_float(self, x): return self.ident(x)
- def vval_double(self, x): return self.ident(x)
- def vval_char(self, x): return self.ident(x)
- def vval_pchar(self, x): return self.ident(x)
- def vval_pcharc(self, x): return self.ident(x)
- def vval_pint(self, x): return self.ident(x)
- def vval_sizet(self, x): return self.ident(x)
- def vval_hello(self, x): return self.ident(x)
- def vval_myint(self, x): return self.ident(x)
-
- def vref_bool(self, x): return self.ident(x)
- def vref_schar(self, x): return self.ident(x)
- def vref_uchar(self, x): return self.ident(x)
- def vref_int(self, x): return self.ident(x)
- def vref_uint(self, x): return self.ident(x)
- def vref_short(self, x): return self.ident(x)
- def vref_ushort(self, x): return self.ident(x)
- def vref_long(self, x): return self.ident(x)
- def vref_ulong(self, x): return self.ident(x)
- def vref_llong(self, x): return self.ident(x)
- def vref_ullong(self, x): return self.ident(x)
- def vref_float(self, x): return self.ident(x)
- def vref_double(self, x): return self.ident(x)
- def vref_char(self, x): return self.ident(x)
- def vref_pchar(self, x): return self.ident(x)
- def vref_pcharc(self, x): return self.ident(x)
- def vref_pint(self, x): return self.ident(x)
- def vref_sizet(self, x): return self.ident(x)
- def vref_hello(self, x): return self.ident(x)
- def vref_myint(self, x): return self.ident(x)
-
- pass
t = Test()
# internal call check
if t.c_check() != p.c_check():
- raise RuntimeError, "bad director"
+ raise RuntimeError, "bad director"
p.var_bool = p.stc_bool
p.var_schar = p.stc_schar
t.v_check()
# this value contains a '0' char!
-if def_namet != 'ho\0la':
- print "bad namet", def_namet
- raise RuntimeError
+if def_namet != 'hola':
+ print "bad namet", def_namet
+ raise RuntimeError
t.var_namet = def_namet
if t.var_namet != def_namet:
- print "bad namet", t.var_namet, def_namet
- raise RuntimeError
+ print "bad namet", t.var_namet, def_namet
+ raise RuntimeError
-t.var_namet = 'holac'
+t.var_namet = 'hola'
-if t.var_namet != 'holac':
- print "bad namet", t.var_namet
- raise RuntimeError
+if t.var_namet != 'hola':
+ print "bad namet", t.var_namet
+ raise RuntimeError
t.var_namet = 'hol'
if t.var_namet != 'hol':
-#if t.var_namet != 'hol\0\0':
- print "bad namet", t.var_namet
- raise RuntimeError
+ # if t.var_namet != 'hol\0\0':
+ print "bad namet", t.var_namet
+ raise RuntimeError
cvar.var_char = '\0'
if cvar.var_char != '\0':
- raise RuntimeError, "bad char '0' case"
-
+ raise RuntimeError, "bad char '0' case"
+
cvar.var_char = 0
if cvar.var_char != '\0':
- raise RuntimeError, "bad char '0' case"
+ raise RuntimeError, "bad char '0' case"
cvar.var_namet = '\0'
-#if cvar.var_namet != '\0\0\0\0\0':
+# if cvar.var_namet != '\0\0\0\0\0':
if cvar.var_namet != '':
- print 'hola', '', cvar.var_namet
- raise RuntimeError, "bad char '\0' case"
+ print 'hola', '', cvar.var_namet
+ raise RuntimeError, "bad char '\0' case"
cvar.var_namet = ''
-#if cvar.var_namet != '\0\0\0\0\0':
+# if cvar.var_namet != '\0\0\0\0\0':
if cvar.var_namet != '':
- raise RuntimeError, "bad char empty case"
+ raise RuntimeError, "bad char empty case"
cvar.var_pchar = None
if cvar.var_pchar != None:
- raise RuntimeError, "bad None case"
+ raise RuntimeError, "bad None case"
cvar.var_pchar = ''
if cvar.var_pchar != '':
- print '%c' % (cvar.var_pchar[0],)
- raise RuntimeError, "bad char empty case"
+ print '%c' % (cvar.var_pchar[0],)
+ raise RuntimeError, "bad char empty case"
cvar.var_pcharc = None
if cvar.var_pcharc != None:
- raise RuntimeError, "bad None case"
+ raise RuntimeError, "bad None case"
cvar.var_pcharc = ''
if cvar.var_pcharc != '':
- raise RuntimeError, "bad char empty case"
+ raise RuntimeError, "bad char empty case"
#
cvar.var_pchar = pc
if cvar.var_pchar != "hola":
- print cvar.var_pchar
- raise RuntimeError, "bad pointer case"
+ print cvar.var_pchar
+ raise RuntimeError, "bad pointer case"
cvar.var_namet = pc
-#if cvar.var_namet != "hola\0":
+# if cvar.var_namet != "hola\0":
if cvar.var_namet != "hola":
- raise RuntimeError, "bad pointer case"
+ raise RuntimeError, "bad pointer case"
delete_pchar(pc)
try:
- error = 0
- a = t.var_uchar
- t.var_uchar = 10000
- error = 1
-except OverflowError:
- if a != t.var_uchar:
+ error = 0
+ a = t.var_uchar
+ t.var_uchar = 10000
error = 1
- pass
+except OverflowError:
+ if a != t.var_uchar:
+ error = 1
+ pass
if error:
- raise RuntimeError, "bad uchar typemap"
-
+ raise RuntimeError, "bad uchar typemap"
try:
- error = 0
- a = t.var_char
- t.var_char = '23'
- error = 1
-except TypeError:
- if a != t.var_char:
+ error = 0
+ a = t.var_char
+ t.var_char = '23'
error = 1
- pass
+except TypeError:
+ if a != t.var_char:
+ error = 1
+ pass
if error:
- raise RuntimeError, "bad char typemap"
+ raise RuntimeError, "bad char typemap"
try:
- error = 0
- a = t.var_ushort
- t.var_ushort = -1
- error = 1
-except OverflowError:
- if a != t.var_ushort:
+ error = 0
+ a = t.var_ushort
+ t.var_ushort = -1
error = 1
- pass
+except OverflowError:
+ if a != t.var_ushort:
+ error = 1
+ pass
if error:
- raise RuntimeError, "bad ushort typemap"
+ raise RuntimeError, "bad ushort typemap"
try:
- error = 0
- a = t.var_uint
- t.var_uint = -1
- error = 1
-except OverflowError:
- if a != t.var_uint:
+ error = 0
+ a = t.var_uint
+ t.var_uint = -1
error = 1
- pass
+except OverflowError:
+ if a != t.var_uint:
+ error = 1
+ pass
if error:
- raise RuntimeError, "bad uint typemap"
+ raise RuntimeError, "bad uint typemap"
try:
- error = 0
- a = t.var_sizet
- t.var_sizet = -1
- error = 1
-except OverflowError:
- if a != t.var_sizet:
+ error = 0
+ a = t.var_sizet
+ t.var_sizet = -1
error = 1
- pass
+except OverflowError:
+ if a != t.var_sizet:
+ error = 1
+ pass
if error:
- raise RuntimeError, "bad sizet typemap"
+ raise RuntimeError, "bad sizet typemap"
try:
- error = 0
- a = t.var_ulong
- t.var_ulong = -1
- error = 1
-except OverflowError:
- if a != t.var_ulong:
+ error = 0
+ a = t.var_ulong
+ t.var_ulong = -1
error = 1
- pass
+except OverflowError:
+ if a != t.var_ulong:
+ error = 1
+ pass
if error:
- raise RuntimeError, "bad ulong typemap"
+ raise RuntimeError, "bad ulong typemap"
#
#
try:
- error = 0
- a = t.var_namet
- t.var_namet = '123456'
- error = 1
-except TypeError:
- if a != t.var_namet:
+ error = 0
+ a = t.var_namet
+ t.var_namet = '123456'
error = 1
- pass
+except TypeError:
+ if a != t.var_namet:
+ error = 1
+ pass
if error:
- raise RuntimeError, "bad namet typemap"
+ raise RuntimeError, "bad namet typemap"
#
#
#
t2 = p.vtest(t)
-if t.var_namet != t2.var_namet:
- raise RuntimeError, "bad SWIGTYPE* typemap"
-
+if t.var_namet != t2.var_namet:
+ raise RuntimeError, "bad SWIGTYPE* typemap"
+
if cvar.fixsize != 'ho\0la\0\0\0':
- raise RuntimeError, "bad FIXSIZE typemap"
+ raise RuntimeError, "bad FIXSIZE typemap"
cvar.fixsize = 'ho'
if cvar.fixsize != 'ho\0\0\0\0\0\0':
- raise RuntimeError, "bad FIXSIZE typemap"
+ raise RuntimeError, "bad FIXSIZE typemap"
f = Foo(3)
f1 = fptr_val(f)
f2 = fptr_ref(f)
if f1._a != f2._a:
- raise RuntimeError, "bad const ptr& typemap"
-
+ raise RuntimeError, "bad const ptr& typemap"
+
+
+v = char_foo(1, 3)
+if v != 3:
+ raise RuntimeError, "bad int typemap"
-v = char_foo(1,3)
-if v !=3:
- raise RuntimeError, "bad int typemap"
+s = char_foo(1, "hello")
+if s != "hello":
+ raise RuntimeError, "bad char* typemap"
-s = char_foo(1,"hello")
-if s !="hello":
- raise RuntimeError, "bad char* typemap"
-
-v = SetPos(1,3)
-if v !=4:
- raise RuntimeError, "bad int typemap"
+v = SetPos(1, 3)
+if v != 4:
+ raise RuntimeError, "bad int typemap"
+
+#
+# Check the bounds for converting various types
+#
+
+# ctypes not available until 2.5
+if sys.version_info[0:2] <= (2, 4):
+ sys.exit(0)
+import ctypes
+
+# Get the minimum and maximum values that fit in signed char, short, int, long, and long long
+overchar = 2 ** 7
+while ctypes.c_byte(overchar).value > 0:
+ overchar *= 2
+minchar = -overchar
+maxchar = overchar - 1
+maxuchar = 2 * maxchar + 1
+overshort = overchar
+while ctypes.c_short(overshort).value > 0:
+ overshort *= 2
+minshort = -overshort
+maxshort = overshort - 1
+maxushort = 2 * maxshort + 1
+overint = overshort
+while ctypes.c_int(overint).value > 0:
+ overint *= 2
+minint = -overint
+maxint = overint - 1
+maxuint = 2 * maxint + 1
+overlong = overint
+while ctypes.c_long(overlong).value > 0:
+ overlong *= 2
+minlong = -overlong
+maxlong = overlong - 1
+maxulong = 2 * maxlong + 1
+overllong = overlong
+while ctypes.c_longlong(overllong).value > 0:
+ overllong *= 2
+minllong = -overllong
+maxllong = overllong - 1
+maxullong = 2 * maxllong + 1
+
+# Make sure Python 2's sys.maxint is the same as the maxlong we calculated
+if sys.version_info[0] <= 2 and maxlong != sys.maxint:
+ raise RuntimeError, "sys.maxint is not the maximum value of a signed long"
+
+def checkType(t, e, val, delta):
+ """t = Test object, e = type name (e.g. ulong), val = max or min allowed value, delta = +1 for max, -1 for min"""
+ error = 0
+ # Set the extreme valid value for var_*
+ setattr(t, 'var_' + e, val)
+ # Make sure it was set properly and works properly in the val_* and ref_* methods
+ if getattr(t, 'var_' + e) != val or getattr(t, 'val_' + e)(val) != val or getattr(t, 'ref_' + e)(val) != val:
+ error = 1
+ # Make sure setting a more extreme value fails without changing the value
+ try:
+ a = getattr(t, 'var_' + e)
+ setattr(t, 'var_' + e, val + delta)
+ error = 1
+ except OverflowError:
+ if a != getattr(t, 'var_' + e):
+ error = 1
+ # Make sure the val_* and ref_* methods fail with a more extreme value
+ try:
+ getattr(t, 'val_' + e)(val + delta)
+ error = 1
+ except OverflowError:
+ pass
+ try:
+ getattr(t, 'ref_' + e)(val + delta)
+ error = 1
+ except OverflowError:
+ pass
+ if error:
+ raise RuntimeError, "bad " + e + " typemap"
+
+def checkFull(t, e, maxval, minval):
+ """Check the maximum and minimum bounds for the type given by e"""
+ checkType(t, e, maxval, 1)
+ checkType(t, e, minval, -1)
+
+checkFull(t, 'llong', maxllong, minllong)
+checkFull(t, 'long', maxlong, minlong)
+checkFull(t, 'int', maxint, minint)
+checkFull(t, 'short', maxshort, minshort)
+checkFull(t, 'schar', maxchar, minchar)
+checkFull(t, 'ullong', maxullong, 0)
+checkFull(t, 'ulong', maxulong, 0)
+checkFull(t, 'uint', maxuint, 0)
+checkFull(t, 'ushort', maxushort, 0)
+checkFull(t, 'uchar', maxuchar, 0)
+
+def checkOverload(t, name, val, delta, prevval, limit):
+ """
+ Check that overloading works
+ t = Test object
+ name = type name (e.g. ulong)
+ val = max or min allowed value
+ delta = +1 for max, -1 for min
+ prevval = corresponding value for one smaller type
+ limit = most extreme value for any type
+ """
+ # If val == prevval, then the smaller typemap will win
+ if val != prevval:
+ # Make sure the most extreme value of this type gives the name of this type
+ if t.ovr_str(val) != name:
+ raise RuntimeError, "bad " + name + " typemap"
+ # Make sure a more extreme value doesn't give the name of this type
+ try:
+ if t.ovr_str(val + delta) == name:
+ raise RuntimeError, "bad " + name + " typemap"
+ if val == limit:
+ # Should raise NotImplementedError here since this is the largest integral type
+ raise RuntimeError, "bad " + name + " typemap"
+ except NotImplementedError:
+ # NotImplementedError is expected only if this is the most extreme type
+ if val != limit:
+ raise RuntimeError, "bad " + name + " typemap"
+ except TypeError:
+ # TypeError is raised instead if swig is run with -O or -fastdispatch
+ if val != limit:
+ raise RuntimeError, "bad " + name + " typemap"
+
+# Check that overloading works: uchar > schar > ushort > short > uint > int > ulong > long > ullong > llong
+checkOverload(t, 'uchar', maxuchar, +1, 0, maxullong)
+checkOverload(t, 'ushort', maxushort, +1, maxuchar, maxullong)
+checkOverload(t, 'uint', maxuint, +1, maxushort, maxullong)
+checkOverload(t, 'ulong', maxulong, +1, maxuint, maxullong)
+checkOverload(t, 'ullong', maxullong, +1, maxulong, maxullong)
+checkOverload(t, 'schar', minchar, -1, 0, minllong)
+checkOverload(t, 'short', minshort, -1, minchar, minllong)
+checkOverload(t, 'int', minint, -1, minshort, minllong)
+checkOverload(t, 'long', minlong, -1, minint, minllong)
+checkOverload(t, 'llong', minllong, -1, minlong, minllong)
+
+# Make sure that large ints can be converted to doubles properly
+if val_double(sys.maxint + 1) != float(sys.maxint + 1):
+ raise RuntimeError, "bad double typemap"
+if val_double(-sys.maxint - 2) != float(-sys.maxint - 2):
+ raise RuntimeError, "bad double typemap"
+
+
+# Check the minimum and maximum values that fit in ptrdiff_t and size_t
+def checkType(name, maxfunc, maxval, minfunc, minval, echofunc):
+ if maxfunc() != maxval:
+ raise RuntimeError, "bad " + name + " typemap"
+ if minfunc() != minval:
+ raise RuntimeError, "bad " + name + " typemap"
+ if echofunc(maxval) != maxval:
+ raise RuntimeError, "bad " + name + " typemap"
+ if echofunc(minval) != minval:
+ raise RuntimeError, "bad " + name + " typemap"
+ error = 0
+ try:
+ echofunc(maxval + 1)
+ error = 1
+ except OverflowError:
+ pass
+ if error == 1:
+ raise RuntimeError, "bad " + name + " typemap"
+ try:
+ echofunc(minval - 1)
+ error = 1
+ except OverflowError:
+ pass
+ if error == 1:
+ raise RuntimeError, "bad " + name + " typemap"
+
+# sys.maxsize is the largest value supported by Py_ssize_t, which should be the same as ptrdiff_t
+if sys.version_info[0:2] >= (2, 6):
+ checkType("ptrdiff_t", get_ptrdiff_max, sys.maxsize, get_ptrdiff_min, -(sys.maxsize + 1), ptrdiff_echo)
+ checkType("size_t", get_size_max, (2 * sys.maxsize) + 1, get_size_min, 0, size_echo)
-import _profiletest
-import profiletest
+import _profiletest
+import profiletest
a = profiletest.A()
print a
fn = b.fn
i = 50000
while i:
- a = fn(a) #1
- a = fn(a) #2
- a = fn(a) #3
- a = fn(a) #4
- a = fn(a) #5
- a = fn(a) #6
- a = fn(a) #7
- a = fn(a) #8
- a = fn(a) #9
- a = fn(a) #10
- a = fn(a) #1
- a = fn(a) #2
- a = fn(a) #3
- a = fn(a) #4
- a = fn(a) #5
- a = fn(a) #6
- a = fn(a) #7
- a = fn(a) #8
- a = fn(a) #9
- a = fn(a) #20
- i -= 1
+ a = fn(a) # 1
+ a = fn(a) # 2
+ a = fn(a) # 3
+ a = fn(a) # 4
+ a = fn(a) # 5
+ a = fn(a) # 6
+ a = fn(a) # 7
+ a = fn(a) # 8
+ a = fn(a) # 9
+ a = fn(a) # 10
+ a = fn(a) # 1
+ a = fn(a) # 2
+ a = fn(a) # 3
+ a = fn(a) # 4
+ a = fn(a) # 5
+ a = fn(a) # 6
+ a = fn(a) # 7
+ a = fn(a) # 8
+ a = fn(a) # 9
+ a = fn(a) # 20
+ i -= 1
-import _profiletest
-#import profiletest
+import _profiletest
+#import profiletest
pa = _profiletest.new_A()
-pb = _profiletest.new_B()
+pb = _profiletest.new_B()
fn = _profiletest.B_fn
destroy = _profiletest.delete_A
i = 50000
a = pa
while i:
- a = fn(pb,a) #1
- destroy(a)
- a = fn(pb,a) #2
- destroy(a)
- a = fn(pb,a) #3
- destroy(a)
- a = fn(pb,a) #4
- destroy(a)
- a = fn(pb,a) #5
- destroy(a)
- a = fn(pb,a) #6
- destroy(a)
- a = fn(pb,a) #7
- destroy(a)
- a = fn(pb,a) #8
- destroy(a)
- a = fn(pb,a) #9
- destroy(a)
- a = fn(pb,a) #10
- destroy(a)
- a = fn(pb,a) #1
- destroy(a)
- a = fn(pb,a) #2
- destroy(a)
- a = fn(pb,a) #3
- destroy(a)
- a = fn(pb,a) #4
- destroy(a)
- a = fn(pb,a) #5
- destroy(a)
- a = fn(pb,a) #6
- destroy(a)
- a = fn(pb,a) #7
- destroy(a)
- a = fn(pb,a) #8
- destroy(a)
- a = fn(pb,a) #9
- destroy(a)
- a = fn(pb,a) #20
- destroy(a)
- i -= 1
+ a = fn(pb, a) # 1
+ destroy(a)
+ a = fn(pb, a) # 2
+ destroy(a)
+ a = fn(pb, a) # 3
+ destroy(a)
+ a = fn(pb, a) # 4
+ destroy(a)
+ a = fn(pb, a) # 5
+ destroy(a)
+ a = fn(pb, a) # 6
+ destroy(a)
+ a = fn(pb, a) # 7
+ destroy(a)
+ a = fn(pb, a) # 8
+ destroy(a)
+ a = fn(pb, a) # 9
+ destroy(a)
+ a = fn(pb, a) # 10
+ destroy(a)
+ a = fn(pb, a) # 1
+ destroy(a)
+ a = fn(pb, a) # 2
+ destroy(a)
+ a = fn(pb, a) # 3
+ destroy(a)
+ a = fn(pb, a) # 4
+ destroy(a)
+ a = fn(pb, a) # 5
+ destroy(a)
+ a = fn(pb, a) # 6
+ destroy(a)
+ a = fn(pb, a) # 7
+ destroy(a)
+ a = fn(pb, a) # 8
+ destroy(a)
+ a = fn(pb, a) # 9
+ destroy(a)
+ a = fn(pb, a) # 20
+ destroy(a)
+ i -= 1
_profiletest.delete_A(pa)
_profiletest.delete_B(pb)
# This is expected to fail with -builtin option
# Builtin types can't inherit from pure-python abstract bases
+if is_python_builtin():
+ exit(0)
+
+# Python abc is only turned on when -py3 option is passed to SWIG
+if not is_swig_py3:
+ exit(0)
assert issubclass(Mapii, MutableMapping)
assert issubclass(Multimapii, MutableMapping)
intmultiset = IntMultiset()
intvector = IntVector()
intlist = IntList()
-
from python_append import *
-t=Test()
+
+
+def is_new_style_class(cls):
+ return hasattr(cls, "__class__")
+
+# test not relevant for -builtin
+if is_python_builtin():
+ exit(0)
+
+t = Test()
t.func()
-t.static_func()
+if is_new_style_class(Test):
+ t.static_func()
+else:
+ Test_static_func()
if grabpath() != os.path.dirname(mypath):
- raise RuntimeError
+ raise RuntimeError("grabpath failed")
if grabstaticpath() != os.path.basename(mypath):
- raise RuntimeError
+ raise RuntimeError("grabstaticpath failed")
+clearstaticpath()
+if grabstaticpath() != None:
+ raise RuntimeError("Resetting staticfuncpath failed")
+Test.static_func()
+if grabstaticpath() != os.path.basename(mypath):
+ raise RuntimeError("grabstaticpath failed")
--- /dev/null
+import python_destructor_exception
+from StringIO import StringIO
+import sys
+
+def error_function():
+ python_destructor_exception.ClassWithThrowingDestructor().GetBlah()
+
+def runtest():
+ attributeErrorOccurred = False
+ try:
+ error_function()
+ except AttributeError, e:
+ attributeErrorOccurred = True
+ return attributeErrorOccurred
+
+def test1():
+ stderr_saved = sys.stderr
+ buffer = StringIO()
+ attributeErrorOccurred = False
+ try:
+ # Suppress stderr while making this call to suppress the output shown by PyErr_WriteUnraisable
+ sys.stderr = buffer
+
+ attributeErrorOccurred = runtest()
+ finally:
+ sys.stderr.flush()
+ sys.stderr = stderr_saved
+
+ assert attributeErrorOccurred
+ assert buffer.getvalue().count("I am the ClassWithThrowingDestructor dtor doing bad things") >= 1
+
+class VectorHolder(object):
+ def __init__(self, v):
+ self.v = v
+ def gen(self):
+ for e in self.v:
+ yield e
+
+# See issue #559, #560, #573 - In Python 3.5, test2() call to the generator 'gen' was
+# resulting in the following (not for -builtin where there is no call to SWIG_Python_CallFunctor
+# as SwigPyObject_dealloc is not used):
+#
+# StopIteration
+#
+# During handling of the above exception, another exception occurred:
+# ...
+# SystemError: <built-in function delete_VectorInt> returned a result with an error set
+
+def addup():
+ sum = 0
+ for i in VectorHolder(python_destructor_exception.VectorInt([1, 2, 3])).gen():
+ sum = sum + i
+ return sum
+
+def test2():
+ sum = addup()
+
+ if sum != 6:
+ raise RuntimeError("Sum is incorrect")
+
+# These two tests are different are two different ways to recreate essentially the same problem
+# reported by Python 3.5 that an exception was already set when destroying a wrapped object
+test1()
+test2()
--- /dev/null
+from python_docstring import *
+import inspect
+
+def check(got, expected):
+ expected_list = expected.split("\n")
+ got_list = got.split("\n")
+
+ if expected_list != got_list:
+ raise RuntimeError("\n" + "Expected: " + str(expected_list) + "\n" + "Got : " + str(got_list))
+
+# When getting docstrings, use inspect.getdoc(x) instead of x.__doc__ otherwise the different options
+# such as -O, -builtin, -classic produce different initial indentation.
+
+check(inspect.getdoc(DocStrings.docstring1),
+ " line 1\n"
+ "line 2\n"
+ "\n"
+ "\n"
+ "\n"
+ "line 3"
+ )
+
+check(inspect.getdoc(DocStrings.docstring2),
+ "line 1\n"
+ " line 2\n"
+ "\n"
+ "\n"
+ "\n"
+ " line 3"
+ )
+
+check(inspect.getdoc(DocStrings.docstring3),
+ "line 1\n"
+ " line 2\n"
+ "\n"
+ "\n"
+ "\n"
+ " line 3"
+ )
+
+check(inspect.getdoc(DocStrings.docstring4),
+ "line 1\n"
+ " line 2\n"
+ "\n"
+ "\n"
+ "\n"
+ " line 3"
+ )
+
+check(inspect.getdoc(DocStrings.docstring5),
+ "line 1\n"
+ " line 2\n"
+ "\n"
+ "\n"
+ "\n"
+ " line 3"
+ )
+
+check(inspect.getdoc(DocStrings.docstring6),
+ "line 1\n"
+ " line 2\n"
+ "\n"
+ "\n"
+ "\n"
+ " line 3"
+ )
+
+check(inspect.getdoc(DocStrings.docstring7),
+ "line 1\n"
+ "line 2\n"
+ "line 3"
+ )
+
+check(inspect.getdoc(DocStrings.docstringA),
+ "first line\n"
+ "second line"
+ )
+
+check(inspect.getdoc(DocStrings.docstringB),
+ "first line\n"
+ "second line"
+ )
+
+check(inspect.getdoc(DocStrings.docstringC),
+ "first line\n"
+ "second line"
+ )
+
+# One line doc special case, use __doc__
+check(DocStrings.docstringX.__doc__,
+ " one line docs"
+ )
+
+check(inspect.getdoc(DocStrings.docstringX),
+ "one line docs"
+ )
+
+check(inspect.getdoc(DocStrings.docstringY),
+ "one line docs"
+ )
aa.a = 1
aa.b = 2
try:
- aa.c = 2
- err = 0
+ aa.c = 2
+ err = 0
except:
- err = 1
+ err = 1
+
+if not err:
+ raise RuntimeError, "A is not static"
-if not err:
- raise RuntimeError, "A is not static"
class B(python_nondynamic.A):
- c = 4
- def __init__(self):
- python_nondynamic.A.__init__(self)
+ c = 4
+
+ def __init__(self):
+ python_nondynamic.A.__init__(self)
+ pass
pass
- pass
bb = B()
try:
- bb.c = 3
- err = 0
+ bb.c = 3
+ err = 0
except:
- err = 1
+ err = 1
if not err:
- print "bb.c = %d" % bb.c
- print "B.c = %d" % B.c
- raise RuntimeError, "B.c class variable messes up nondynamic-ness of B"
+ print "bb.c = %d" % bb.c
+ print "B.c = %d" % B.c
+ raise RuntimeError, "B.c class variable messes up nondynamic-ness of B"
try:
- bb.d = 2
- err = 0
+ bb.d = 2
+ err = 0
except:
- err = 1
+ err = 1
+
+if not err:
+ raise RuntimeError, "B is not static"
-if not err:
- raise RuntimeError, "B is not static"
-
cc = python_nondynamic.C()
cc.d = 3
from python_overload_simple_cast import *
+
class Ai:
- def __init__(self,x):
+
+ def __init__(self, x):
self.x = x
-
+
def __int__(self):
return self.x
+
class Ad:
- def __init__(self,x):
+
+ def __init__(self, x):
self.x = x
-
+
def __float__(self):
return self.x
good = 1
if not good:
- raise RuntimeError, "fint(int)"
+ raise RuntimeError, "fint(int)"
if fint(ad) != "fint:int":
if fint(5.0) != "fint:int":
raise RuntimeError, "fint(int)"
-
+
if fint(3) != "fint:int":
raise RuntimeError, "fint(int)"
if fint(3.0) != "fint:int":
if fdouble(3.0) != "fdouble:double":
raise RuntimeError, "fdouble(double)"
-if fid(3,3.0) != "fid:intdouble":
+if fid(3, 3.0) != "fid:intdouble":
raise RuntimeError, "fid:intdouble"
-if fid(3.0,3) != "fid:doubleint":
+if fid(3.0, 3) != "fid:doubleint":
raise RuntimeError, "fid:doubleint"
-if fid(ad,ai) != "fid:doubleint":
+if fid(ad, ai) != "fid:doubleint":
raise RuntimeError, "fid:doubleint"
-if fid(ai,ad) != "fid:intdouble":
+if fid(ai, ad) != "fid:intdouble":
raise RuntimeError, "fid:intdouble"
-
if foo(3) != "foo:int":
raise RuntimeError, "foo(int)"
s = Spam(3)
if s.type != "int":
raise RuntimeError, "Spam(int)"
-
+
s = Spam(3.4)
if s.type != "double":
raise RuntimeError, "Spam(double)"
# unsigned long long
-ullmax = 9223372036854775807 #0xffffffffffffffff
+ullmax = 9223372036854775807 # 0xffffffffffffffff
ullmaxd = 9007199254740992.0
ullmin = 0
ullmind = 0.0
raise RuntimeError, "ull(ullmaxd)"
# long long
-llmax = 9223372036854775807 #0x7fffffffffffffff
+llmax = 9223372036854775807 # 0x7fffffffffffffff
llmin = -9223372036854775808
# these are near the largest floats we can still convert into long long
llmaxd = 9007199254740992.0
-#run:
+# run:
# python python_pybuf_runme3.py benchmark
-#for the benchmark, other wise the test case will be run
+# for the benchmark, other wise the test case will be run
import python_pybuf
import sys
-if len(sys.argv)>=2 and sys.argv[1]=="benchmark":
- #run the benchmark
+if len(sys.argv) >= 2 and sys.argv[1] == "benchmark":
+ # run the benchmark
import time
- k=1000000 #number of times to excute the functions
+ k = 1000000 # number of times to excute the functions
- t=time.time()
+ t = time.time()
a = bytearray(b'hello world')
for i in range(k):
- pybuf.title1(a)
- print("Time used by bytearray:",time.time()-t)
+ pybuf.title1(a)
+ print("Time used by bytearray:", time.time() - t)
- t=time.time()
+ t = time.time()
b = 'hello world'
for i in range(k):
- pybuf.title2(b)
- print("Time used by string:",time.time()-t)
+ pybuf.title2(b)
+ print("Time used by string:", time.time() - t)
else:
- #run the test case
+ # run the test case
buf1 = bytearray(10)
buf2 = bytearray(50)
pybuf.func1(buf1)
- assert buf1 == b'a'*10
+ assert buf1 == b'a' * 10
pybuf.func2(buf2)
assert buf2.startswith(b"Hello world!\x00")
count = pybuf.func3(buf2)
- assert count==10 #number of alpha and number in 'Hello world!'
+ assert count == 10 # number of alpha and number in 'Hello world!'
length = pybuf.func4(buf2)
- assert length==12
+ assert length == 12
buf3 = bytearray(b"hello")
pybuf.title1(buf3)
- assert buf3==b'Hello'
-
+ assert buf3 == b'Hello'
--- /dev/null
+import python_pythoncode
+
+# No need to actually do anything, this is a regression test for a bug which
+# caused an invalid python_pythoncode.py to be generated, so if we can import
+# it the bug is still fixed.
b3 = python_richcompare.SubClassB(3)
# Check == and != within a single type
-#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------
-if not (base1 == base1) :
+if not (base1 == base1):
raise RuntimeError("Object not == to itself")
-if not (base1 == python_richcompare.BaseClass(1)) :
+if not (base1 == python_richcompare.BaseClass(1)):
raise RuntimeError("Object not == to an equivalent object")
-if (base1 == base2) :
- raise RuntimeError("Comparing non-equivalent objects of the same type, == returned True")
+if (base1 == base2):
+ raise RuntimeError(
+ "Comparing non-equivalent objects of the same type, == returned True")
-if (base1 != base1) :
+if (base1 != base1):
raise RuntimeError("Object is != itself")
-if (base1 != python_richcompare.BaseClass(1)) :
+if (base1 != python_richcompare.BaseClass(1)):
raise RuntimeError("Object is != an equivalent object")
-if not (base1 != base2) :
- raise RuntimeError("Comparing non-equivalent objects of the same type, != returned False")
+if not (base1 != base2):
+ raise RuntimeError(
+ "Comparing non-equivalent objects of the same type, != returned False")
# Check redefined operator== in SubClassA
-#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------
-if (a2 == base2) :
+if (a2 == base2):
raise RuntimeError("Redefined operator== in SubClassA failed")
-if (a2 == b2) :
+if (a2 == b2):
raise RuntimeError("Redefined operator== in SubClassA failed")
-if not (a1 == a2) :
+if not (a1 == a2):
raise RuntimeError("Redefined operator== in SubClassA failed")
# Check up-casting of subclasses
-#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------
-if (base2 != a2) :
- raise RuntimeError("Comparing equivalent base and subclass instances, != returned True")
+if (base2 != a2):
+ raise RuntimeError(
+ "Comparing equivalent base and subclass instances, != returned True")
-if (a2 == base2) :
- raise RuntimeError("Comparing non-equivalent base and subclass instances, == returned True")
+if (a2 == base2):
+ raise RuntimeError(
+ "Comparing non-equivalent base and subclass instances, == returned True")
-if (a1 == b1) :
- raise RuntimeError("Comparing equivalent instances of different subclasses, == returned True")
+if (a1 == b1):
+ raise RuntimeError(
+ "Comparing equivalent instances of different subclasses, == returned True")
+
+if (b1 == a1):
+ raise RuntimeError(
+ "Comparing equivalent instances of different subclasses, == returned True")
-if (b1 == a1) :
- raise RuntimeError("Comparing equivalent instances of different subclasses, == returned True")
-
# Check inequalities
-#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------
-if (a2 > b2) :
+if (a2 > b2):
raise RuntimeError("operator> failed")
-if (a2 < b2) :
+if (a2 < b2):
raise RuntimeError("operator< failed")
-if not (a2 >= b2) :
+if not (a2 >= b2):
raise RuntimeError("operator>= failed")
-if not (a2 <= b2) :
+if not (a2 <= b2):
raise RuntimeError("operator<= failed")
# Check inequalities used for ordering
-#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------
x = sorted([a2, a3, a1])
-if not (x[0] is a1) :
+if not (x[0] is a1):
raise RuntimeError("Ordering failed")
-if not (x[1] is a2) :
+if not (x[1] is a2):
raise RuntimeError("Ordering failed")
-if not (x[2] is a3) :
+if not (x[2] is a3):
raise RuntimeError("Ordering failed")
x = sorted([base2, a3, b1])
-if not (x[0] is b1) :
+if not (x[0] is b1):
raise RuntimeError("Ordering failed")
-if not (x[1] is base2) :
+if not (x[1] is base2):
raise RuntimeError("Ordering failed")
-if not (x[2] is a3) :
+if not (x[2] is a3):
raise RuntimeError("Ordering failed")
--- /dev/null
+import python_strict_unicode
+from sys import version_info
+
+test_bytes = 'hello \x01world\x99'
+BYTES = 'BYTES'
+test_unicode = u'h\udce9llo w\u00f6rld'
+
+# Python < 2.6 rejects the b prefix for byte string literals as a SyntaxError,
+# so instead create Python3 bytes objects by encoding unicode strings as
+# latin-1, which maps code points 0-255 directly to the corresponding bytes.
+if version_info[0] >= 3:
+ test_bytes = test_bytes.encode('latin-1')
+ BYTES = BYTES.encode('latin-1')
+
+# Test that byte string inputs and outputs work as expected
+bdbl = python_strict_unicode.double_str(test_bytes)
+if bdbl != test_bytes + test_bytes:
+ raise RuntimeError("Failed to double string")
+if type(bdbl) != type(BYTES):
+ raise RuntimeError("Wrong type output for string")
+bout = python_strict_unicode.same_str(test_bytes)
+if bout != test_bytes:
+ raise RuntimeError("Failed to copy char*")
+if type(bout) != type(BYTES):
+ raise RuntimeError("Wrong type output for char*")
+
+# Test that unicode string inputs and outputs work as expected
+udbl = python_strict_unicode.double_wstr(test_unicode)
+if udbl != test_unicode + test_unicode:
+ raise RuntimeError("Failed to double wide string")
+if type(udbl) != type(u''):
+ raise RuntimeError("Wrong type output for wide string")
+uout = python_strict_unicode.same_wstr(test_unicode)
+if uout != test_unicode:
+ raise RuntimeError("Failed to copy wchar_t*")
+if type(uout) != type(u''):
+ raise RuntimeError("Wrong type output for wchar_t*")
+
+# Test that overloading is handled properly
+bovr = python_strict_unicode.overload(test_bytes)
+if bovr != BYTES:
+ raise RuntimeError("Failed to return bytes from overload")
+if type(bovr) != type(BYTES):
+ raise RuntimeError("Wrong type output from overload")
+uovr = python_strict_unicode.overload(test_unicode)
+if uovr != u'UNICODE':
+ raise RuntimeError("Failed to return unicode from overload")
+if type(uovr) != type(u''):
+ raise RuntimeERror("Wrong type output from overload")
+
+# Test that bytes aren't accepted as wide strings and unicode isn't accepted as narrow strings
+try:
+ python_strict_unicode.double_str(test_unicode)
+ error = 1
+except TypeError:
+ error = 0
+if error:
+ raise RuntimeError("Unicode accepted for string")
+try:
+ python_strict_unicode.same_str(test_unicode)
+ error = 1
+except TypeError:
+ error = 0
+if error:
+ raise RuntimeError("Unicode accepted for char*")
+try:
+ python_strict_unicode.double_wstr(test_bytes)
+ error = 1
+except TypeError:
+ error = 0
+if error:
+ raise RuntimeError("Bytes accepted for wstring")
+try:
+ python_strict_unicode.same_wstr(test_bytes)
+ error = 1
+except TypeError:
+ error = 0
+if error:
+ raise RuntimeError("Bytes accepted for wchar_t*")
--- /dev/null
+from python_threads import *
+
+action = ActionGroup()
+count = 1
+for child in action.GetActionList():
+ if child.val != count:
+ raise RuntimeError(
+ "Expected: " + str(count) + " got: " + str(child.val))
+ count = count + 1
+
+# Was seg faulting at the end here
import python_varargs_typemap
-if (python_varargs_typemap.testfunc(1, 2.0, "three") != "three") :
+if (python_varargs_typemap.testfunc(1, 2.0, "three") != "three"):
raise RuntimeError("testfunc failed!")
-if (python_varargs_typemap.testfunc(1, 2.0, "three", "four", "five") != "threefourfive") :
+if (python_varargs_typemap.testfunc(1, 2.0, "three", "four", "five") != "threefourfive"):
raise RuntimeError("testfunc failed! {}")
a = A3()
b1 = B(a)
-b2 = B.create(a)
-
+b2 = B_create(a)
if a.ref_count() != 3:
- raise RuntimeError("Count = %d" % a.ref_count())
+ raise RuntimeError("Count = %d" % a.ref_count())
rca = b2.get_rca()
-b3 = B.create(rca)
+b3 = B_create(rca)
if a.ref_count() != 5:
- raise RuntimeError("Count = %d" % a.ref_count())
+ raise RuntimeError("Count = %d" % a.ref_count())
v = vector_A(2)
del v
if a.ref_count() != 6:
- raise RuntimeError("Count = %d" % a.ref_count())
+ raise RuntimeError("Count = %d" % a.ref_count())
# Check %newobject
b4 = b2.cloner()
if b4.ref_count() != 1:
- raise RuntimeError
+ raise RuntimeError
b5 = global_create(a)
if b5.ref_count() != 1:
- raise RuntimeError
+ raise RuntimeError
-b6 = Factory.create(a)
+b6 = Factory_create(a)
if b6.ref_count() != 1:
- raise RuntimeError
+ raise RuntimeError
b7 = Factory().create2(a)
if b7.ref_count() != 1:
- raise RuntimeError
+ raise RuntimeError
if a.ref_count() != 10:
- raise RuntimeError("Count = %d" % a.ref_count())
+ raise RuntimeError("Count = %d" % a.ref_count())
del b4
del b5
del b7
if a.ref_count() != 6:
- raise RuntimeError("Count = %d" % a.ref_count())
-
+ raise RuntimeError("Count = %d" % a.ref_count())
raise RuntimeError
# primitive reference variables
-cvar.var_bool = createref_bool(0)
-if value_bool(cvar.var_bool) != 0:
+cvar.var_bool = createref_bool(False)
+if value_bool(cvar.var_bool) != False:
raise RuntimeError
-cvar.var_bool = createref_bool(1)
-if value_bool(cvar.var_bool) != 1:
+cvar.var_bool = createref_bool(True)
+if value_bool(cvar.var_bool) != True:
raise RuntimeError
cvar.var_char = createref_char('w')
cvar.var_TestClass = createref_TestClass(TestClass(20))
if value_TestClass(cvar.var_TestClass).num != 20:
raise RuntimeError
-
from rename_pcre_encoder import *
s = SomeWidget()
-s.putBorderWidth(3)
-if s.getBorderWidth() != 3:
- raise RuntimeError("Border should be 3, not %d" % (s.getBorderWidth(),))
+s.put_borderWidth(3)
+if s.get_borderWidth() != 3:
+ raise RuntimeError("Border should be 3, not %d" % (s.get_borderWidth(),))
-s.putSize(4, 5)
+s.put_size(4, 5)
a = AnotherWidget()
a.DoSomething()
evt = wxEVTSomeEvent()
-t = xUnchangedName()
+t = xUnchangedName()
+
+if StartINSAneAndUNSAvoryTraNSAtlanticRaNSAck() != 42:
+ raise RuntimeError("Unexpected result of renamed function call")
--- /dev/null
+from rename_predicates import *
+
+r = RenamePredicates(123)
+r.MF_member_function()
+r.MF_static_member_function()
+r.MF_extend_function_before()
+r.MF_extend_function_after()
+GF_global_function()
+
+if r.MV_member_variable != 123:
+ raise RuntimeError("variable wrong")
+r.MV_member_variable = 1234
+if r.MV_member_variable != 1234:
+ raise RuntimeError("variable wrong")
+
+if cvar.RenamePredicates_MV_static_member_variable != 456:
+ raise RuntimeError("variable wrong")
+cvar.RenamePredicates_MV_static_member_variable = 4567
+if cvar.RenamePredicates_MV_static_member_variable != 4567:
+ raise RuntimeError("variable wrong")
+
+if cvar.GV_global_variable != 789:
+ raise RuntimeError("variable wrong")
+cvar.GV_global_variable = 7890
+if cvar.GV_global_variable != 7890:
+ raise RuntimeError("variable wrong")
+
+UC_UPPERCASE()
+LC_lowercase()
+TI_Title()
+FU_FirstUpperCase()
+FL_firstLowerCase()
+CA_CamelCase()
+LC_lowerCamelCase()
+UC_under_case_it()
+
+ex = ExtendCheck()
+ex.MF_real_member1()
+ex.MF_real_member2()
+ex.EX_EXTENDMETHOD1()
+ex.EX_EXTENDMETHOD2()
+ex.EX_EXTENDMETHOD3()
--- /dev/null
+from rename_rstrip_encoder import *
+
+s = SomeThing()
+a = AnotherThing()
+a.DoClsX()
s = SomeWidget()
a = AnotherWidget()
a.DoSomething()
-
import return_const_value
import sys
-p = return_const_value.Foo_ptr.getPtr()
+p = return_const_value.Foo_ptr_getPtr()
if (p.getVal() != 17):
- print "Runtime test1 faild. p.getVal()=", p.getVal()
- sys.exit(1)
+ print "Runtime test1 faild. p.getVal()=", p.getVal()
+ sys.exit(1)
-p = return_const_value.Foo_ptr.getConstPtr()
+p = return_const_value.Foo_ptr_getConstPtr()
if (p.getVal() != 17):
- print "Runtime test2 faild. p.getVal()=", p.getVal()
- sys.exit(1)
+ print "Runtime test2 faild. p.getVal()=", p.getVal()
+ sys.exit(1)
CONST_ACCESS = 1
MUTABLE_ACCESS = 2
+
def test(b, f):
- if f.x != 0:
- raise RuntimeError
-
- # Test member variable get
- if b.x != 0:
- raise RuntimeError
-
- if f.access != CONST_ACCESS:
- raise RuntimeError
-
- # Test member variable set
- b.x = 1
-
- if f.x != 1:
- raise RuntimeError
-
- if f.access != MUTABLE_ACCESS:
- raise RuntimeError
-
- # Test const method
- if b.getx() != 1:
- raise RuntimeError
-
- if f.access != CONST_ACCESS:
- raise RuntimeError
-
- # Test mutable method
- b.setx(2)
-
- if f.x != 2:
- raise RuntimeError
-
- if f.access != MUTABLE_ACCESS:
- raise RuntimeError
-
- # Test extended const method
- if b.getx2() != 2:
- raise RuntimeError
-
- if f.access != CONST_ACCESS:
- raise RuntimeError
-
- # Test extended mutable method
- b.setx2(3)
-
- if f.x != 3:
- raise RuntimeError
-
- if f.access != MUTABLE_ACCESS:
- raise RuntimeError
-
- # Test static method
- b.stat()
-
- if f.access != CONST_ACCESS:
- raise RuntimeError
-
- # Test const member
- f.access = MUTABLE_ACCESS
-
- if b.y != 0:
- raise RuntimeError
-
- if f.access != CONST_ACCESS:
- raise RuntimeError
-
- # Test get through mutable pointer to const member
- f.access = MUTABLE_ACCESS
-
- if get_int(b.yp) != 0:
- raise RuntimeError
-
- if f.access != CONST_ACCESS:
- raise RuntimeError
-
- # Test get through const pointer to mutable member
- f.x = 4
- f.access = MUTABLE_ACCESS
-
- if get_int(b.xp) != 4:
- raise RuntimeError
-
- if f.access != CONST_ACCESS:
- raise RuntimeError
-
- # Test set through const pointer to mutable member
- f.access = MUTABLE_ACCESS
- set_int(b.xp, 5)
-
- if f.x != 5:
- raise RuntimeError
-
- if f.access != CONST_ACCESS:
- raise RuntimeError
-
- # Test set pointer to const member
- b.yp = new_int(6)
-
- if f.y != 0:
- raise RuntimeError
-
- if get_int(f.yp) != 6:
- raise RuntimeError
-
- if f.access != MUTABLE_ACCESS:
- raise RuntimeError
-
- delete_int(f.yp);
+ if f.x != 0:
+ raise RuntimeError
+
+ # Test member variable get
+ if b.x != 0:
+ raise RuntimeError
+
+ if f.access != CONST_ACCESS:
+ raise RuntimeError
+
+ # Test member variable set
+ b.x = 1
+
+ if f.x != 1:
+ raise RuntimeError
+
+ if f.access != MUTABLE_ACCESS:
+ raise RuntimeError
+
+ # Test const method
+ if b.getx() != 1:
+ raise RuntimeError
+
+ if f.access != CONST_ACCESS:
+ raise RuntimeError
+
+ # Test mutable method
+ b.setx(2)
+
+ if f.x != 2:
+ raise RuntimeError
+
+ if f.access != MUTABLE_ACCESS:
+ raise RuntimeError
+
+ # Test extended const method
+ if b.getx2() != 2:
+ raise RuntimeError
+
+ if f.access != CONST_ACCESS:
+ raise RuntimeError
+
+ # Test extended mutable method
+ b.setx2(3)
+
+ if f.x != 3:
+ raise RuntimeError
+
+ if f.access != MUTABLE_ACCESS:
+ raise RuntimeError
+
+ # Test static method
+ b.statMethod()
+
+ if f.access != CONST_ACCESS:
+ raise RuntimeError
+
+ # Test const member
+ f.access = MUTABLE_ACCESS
+
+ if b.y != 0:
+ raise RuntimeError
+
+ if f.access != CONST_ACCESS:
+ raise RuntimeError
+
+ # Test get through mutable pointer to const member
+ f.access = MUTABLE_ACCESS
+
+ if get_int(b.yp) != 0:
+ raise RuntimeError
+
+ if f.access != CONST_ACCESS:
+ raise RuntimeError
+
+ # Test get through const pointer to mutable member
+ f.x = 4
+ f.access = MUTABLE_ACCESS
+
+ if get_int(b.xp) != 4:
+ raise RuntimeError
+
+ if f.access != CONST_ACCESS:
+ raise RuntimeError
+
+ # Test set through const pointer to mutable member
+ f.access = MUTABLE_ACCESS
+ set_int(b.xp, 5)
+
+ if f.x != 5:
+ raise RuntimeError
+
+ if f.access != CONST_ACCESS:
+ raise RuntimeError
+
+ # Test set pointer to const member
+ b.yp = new_int(6)
+
+ if f.y != 0:
+ raise RuntimeError
+
+ if get_int(f.yp) != 6:
+ raise RuntimeError
+
+ if f.access != MUTABLE_ACCESS:
+ raise RuntimeError
+
+ delete_int(f.yp)
f = Foo()
b = Bar(f)
b = Bar(f)
if b.extension() != f.extension():
- raise RuntimeError
+ raise RuntimeError
b = CBase()
p = CPtr()
if b.bar() != p.bar():
- raise RuntimeError
+ raise RuntimeError
if d.foo() != p.foo():
- raise RuntimeError
+ raise RuntimeError
if b.hello() != p.hello():
- raise RuntimeError
-
+ raise RuntimeError
d = DFoo()
dp = DPtrFoo(d)
if d.SExt(1) != dp.SExt(1):
- raise RuntimeError
+ raise RuntimeError
if d.Ext(1) != dp.Ext(1):
- raise RuntimeError
-
+ raise RuntimeError
from smart_pointer_member import *
+
+def is_new_style_class(cls):
+ return hasattr(cls, "__class__")
+
f = Foo()
f.y = 1
if f.y != 1:
- raise RuntimeError
+ raise RuntimeError
b = Bar(f)
b.y = 2
if f.y != 2:
- print f.y
- print b.y
- raise RuntimeError
+ print f.y
+ print b.y
+ raise RuntimeError
if b.x != f.x:
- raise RuntimeError
+ raise RuntimeError
if b.z != f.z:
- raise RuntimeError
-
-if Foo.z == Bar.z:
- raise RuntimeError
-
-
-
-
-
+ raise RuntimeError
+if is_new_style_class(Bar): # feature not supported in old style classes
+ if Foo.z == Bar.z:
+ raise RuntimeError
g.x = 4
if g.getx() != 4:
raise RuntimeError
-
g.x = 4
if g.getx() != 4:
raise RuntimeError
-
try:
x = s.x
- print "Error! s.x"
+ print "Error! s.x"
except:
pass
try:
x = b.getx()
- print "Error! b.getx()"
+ print "Error! b.getx()"
except:
pass
try:
x = s.getx()
- print "Error! s.getx()"
+ print "Error! s.getx()"
except:
pass
raise RuntimeError
if b.test("hello") != 3:
raise RuntimeError
-
-
if b.ftest1(1) != 1:
raise RuntimeError
-if b.ftest2(2,3) != 2:
+if b.ftest2(2, 3) != 2:
raise RuntimeError
d = DiffImContainerPtr_D(create(1234, 5678))
if (d.id != 1234):
- raise RuntimeError
-#if (d.xyz != 5678):
+ raise RuntimeError
+# if (d.xyz != 5678):
# raise RuntimeError
d.id = 4321
#d.xyz = 8765
if (d.id != 4321):
- raise RuntimeError
-#if (d.xyz != 8765):
+ raise RuntimeError
+# if (d.xyz != 8765):
# raise RuntimeError
-
import sneaky1
-x = sneaky1.add(3,4)
-y = sneaky1.subtract(3,4)
-z = sneaky1.mul(3,4)
-w = sneaky1.divide(3,4)
+x = sneaky1.add(3, 4)
+y = sneaky1.subtract(3, 4)
+z = sneaky1.mul(3, 4)
+w = sneaky1.divide(3, 4)
name = special_variable_macros.Name()
if special_variable_macros.testFred(name) != "none":
- raise "test failed"
+ raise "test failed"
if special_variable_macros.testJack(name) != "$specialname":
- raise "test failed"
+ raise "test failed"
if special_variable_macros.testJill(name) != "jilly":
- raise "test failed"
+ raise "test failed"
if special_variable_macros.testMary(name) != "SWIGTYPE_p_NameWrap":
- raise "test failed"
+ raise "test failed"
if special_variable_macros.testJames(name) != "SWIGTYPE_Name":
- raise "test failed"
+ raise "test failed"
if special_variable_macros.testJim(name) != "multiname num":
- raise "test failed"
+ raise "test failed"
if special_variable_macros.testJohn(special_variable_macros.PairIntBool(10, False)) != 123:
- raise "test failed"
-
+ raise "test failed"
raise RuntimeError
-if Foo.BAZ.val != 2*Foo.BAR.val:
+if Foo.BAZ.val != 2 * Foo.BAR.val:
raise RuntimeError
cube = (((1, 2), (3, 4)), ((5, 6), (7, 8)))
icube = std_containers.cident(cube)
-for i in range(0,len(cube)):
- if cube[i] != icube[i]:
- raise RuntimeError, "bad cident"
+for i in range(0, len(cube)):
+ if cube[i] != icube[i]:
+ raise RuntimeError, "bad cident"
-p = (1,2)
+p = (1, 2)
if p != std_containers.pident(p):
- raise RuntimeError, "bad pident"
+ raise RuntimeError, "bad pident"
-v = (1,2,3,4,5,6)
+v = (1, 2, 3, 4, 5, 6)
iv = std_containers.vident(v)
-for i in range(0,len(v)):
- if v[i] != iv[i]:
- raise RuntimeError, "bad vident"
-
+for i in range(0, len(v)):
+ if v[i] != iv[i]:
+ raise RuntimeError, "bad vident"
iv = std_containers.videntu(v)
-for i in range(0,len(v)):
- if v[i] != iv[i]:
- raise RuntimeError, "bad videntu"
+for i in range(0, len(v)):
+ if v[i] != iv[i]:
+ raise RuntimeError, "bad videntu"
vu = std_containers.vector_ui(v)
if vu[2] != std_containers.videntu(vu)[2]:
- raise RuntimeError, "bad videntu"
-
+ raise RuntimeError, "bad videntu"
+
if v[0:3][1] != vu[0:3][1]:
- print v[0:3][1], vu[0:3][1]
- raise RuntimeError, "bad getslice"
-
+ print v[0:3][1], vu[0:3][1]
+ raise RuntimeError, "bad getslice"
-m = ((1,2,3),(2,3),(3,4))
+
+m = ((1, 2, 3), (2, 3), (3, 4))
im = std_containers.midenti(m)
-for i in range(0,len(m)):
- for j in range(0,len(m[i])):
- if m[i][j] != im[i][j]:
- raise RuntimeError, "bad getslice"
+for i in range(0, len(m)):
+ for j in range(0, len(m[i])):
+ if m[i][j] != im[i][j]:
+ raise RuntimeError, "bad getslice"
-m = ((1,0,1),(1,1),(1,1))
+m = ((True, False, True), (True, True), (True, True))
im = std_containers.midentb(m)
-for i in range(0,len(m)):
- for j in range(0,len(m[i])):
- if m[i][j] != im[i][j]:
- raise RuntimeError, "bad getslice"
+for i in range(0, len(m)):
+ for j in range(0, len(m[i])):
+ if m[i][j] != im[i][j]:
+ raise RuntimeError, "bad getslice"
mi = std_containers.imatrix(m)
mc = std_containers.cmatrix(m)
if mi[0][1] != mc[0][1]:
- raise RuntimeError, "bad matrix"
+ raise RuntimeError, "bad matrix"
-map ={}
+map = {}
map['hello'] = 1
map['hi'] = 2
map['3'] = 2
imap = std_containers.mapident(map)
for k in map:
- if map[k] != imap[k]:
- raise RuntimeError, "bad map"
+ if map[k] != imap[k]:
+ raise RuntimeError, "bad map"
-mapc ={}
+mapc = {}
c1 = std_containers.C()
c2 = std_containers.C()
mapc[1] = c1.this
std_containers.mapidentc(mapc)
-vi = std_containers.vector_i((2,2,3,4))
+vi = std_containers.vector_i((2, 2, 3, 4))
-v = (1,2)
+v = (1, 2)
v1 = std_containers.v_inout(vi)
vi[1], v1[1]
-v1,v2 = ((1,2),(3,4))
-v1,v2 = std_containers.v_inout2(v1,v2)
+v1, v2 = ((1, 2), (3, 4))
+v1, v2 = std_containers.v_inout2(v1, v2)
a1 = std_containers.A(1)
a2 = std_containers.A(2)
-p1 = (1,a1)
-p2 = (2,a2)
-v = (p1,p2)
-v2= std_containers.pia_vident(v)
+p1 = (1, a1)
+p2 = (2, a2)
+v = (p1, p2)
+v2 = std_containers.pia_vident(v)
v2[0][1].a
v2[1][1].a
s.append(1)
s.append(2)
s.append(3)
-j=1
+j = 1
for i in s:
- if i != j:
- raise RuntimeError
- j = j + 1
-
-
+ if i != j:
+ raise RuntimeError
+ j = j + 1
from struct_initialization import *
if cvar.instanceC1.x != 10:
- raise RuntimeError
+ raise RuntimeError
if cvar.instanceD1.x != 10:
- raise RuntimeError
+ raise RuntimeError
if cvar.instanceD2.x != 20:
- raise RuntimeError
+ raise RuntimeError
if cvar.instanceD3.x != 30:
- raise RuntimeError
+ raise RuntimeError
if cvar.instanceE1.x != 1:
- raise RuntimeError
+ raise RuntimeError
if cvar.instanceF1.x != 1:
- raise RuntimeError
-
+ raise RuntimeError
b = struct_value.Bar()
b.a.x = 3
-if b.a.x != 3: raise RuntimeError
+if b.a.x != 3:
+ raise RuntimeError
b.b.x = 3
-if b.b.x != 3: raise RuntimeError
+if b.b.x != 3:
+ raise RuntimeError
+
+
+# Test dynamically added attributes - Github pull request #320
+b.added = 123
+
+if b.added != 123:
+ raise RuntimeError("Wrong attribute value")
+
+if not b.__dict__.has_key("added"):
+ raise RuntimeError("Missing added attribute in __dict__")
+
+
+class PyBar(struct_value.Bar):
+
+ def __init__(self):
+ self.extra = "hi"
+ struct_value.Bar.__init__(self)
+
+pybar = PyBar()
+if not pybar.__dict__.has_key("extra"):
+ raise RuntimeError("Missing extra attribute in __dict__")
+if pybar.extra != "hi":
+ raise RuntimeError("Incorrect attribute value for extra")
-from swigobject import *
+from swigobject import *
a = A()
a2 = a_ptr(a)
if a1.this != a2.this:
- raise RuntimeError
-
+ raise RuntimeError
+
lthis = long(a.this)
-# match pointer value, but deal with leading zeros on 8/16 bit systems and different C++ compilers interpretation of %p
+# match pointer value, but deal with leading zeros on 8/16 bit systems and
+# different C++ compilers interpretation of %p
xstr1 = "%016X" % (lthis,)
xstr1 = str.lstrip(xstr1, '0')
xstr2 = pointer_str(a)
xstr2 = str.upper(xstr2)
if xstr1 != xstr2:
- print xstr1, xstr2
- raise RuntimeError
+ print xstr1, xstr2
+ raise RuntimeError
s = str(a.this)
r = repr(a.this)
v1 = v_ptr(a)
v2 = v_ptr(a)
if long(v1) != long(v2):
- raise RuntimeError
+ raise RuntimeError
--- /dev/null
+from template_classes import *
+
+# This test is just testing incorrect number of arguments/parameters checking
+
+point = PointInt()
+
+rectangle = RectangleInt()
+rectangle.setPoint(point)
+rectangle.getPoint()
+RectangleInt.static_noargs()
+RectangleInt.static_onearg(1)
+
+fail = True
+try:
+ rectangle.setPoint()
+except TypeError, e:
+ fail = False
+if fail:
+ raise RuntimeError("argument count check failed")
+
+
+fail = True
+try:
+ rectangle.getPoint(0)
+except TypeError, e:
+ fail = False
+if fail:
+ raise RuntimeError("argument count check failed")
+
+fail = True
+try:
+ RectangleInt.static_noargs(0)
+except TypeError, e:
+ fail = False
+if fail:
+ raise RuntimeError("argument count check failed")
+
+fail = True
+try:
+ RectangleInt.static_onearg()
+except TypeError, e:
+ fail = False
+if fail:
+ raise RuntimeError("argument count check failed")
--- /dev/null
+from template_default_arg_overloaded_extend import *
+
+def check(flag):
+ if not flag:
+ raise RuntimeError("failed")
+
+rs = ResultSet()
+
+check(rs.go_get_method(0, SearchPoint()) == -1)
+check(rs.go_get_method(0, SearchPoint(), 100) == 100)
+
+check(rs.go_get_template(0, SearchPoint()) == -2)
+check(rs.go_get_template(0, SearchPoint(), 100) == 100)
+
+check(rs.over() == "over(int)")
+check(rs.over(10) == "over(int)")
+check(rs.over(SearchPoint()) == "over(giai2::SearchPoint, int)")
+check(rs.over(SearchPoint(), 10) == "over(giai2::SearchPoint, int)")
+check(rs.over(True, SearchPoint()) == "over(bool, gaia2::SearchPoint, int)")
+check(rs.over(True, SearchPoint(), 10) == "over(bool, gaia2::SearchPoint, int)")
--- /dev/null
+from template_default_arg_overloaded import *
+
+def check(expected, got):
+ if expected != got:
+ raise RuntimeError("Expected: " + str(expected) + " got: " + str(got))
+
+
+pl = PropertyList()
+check(1, pl.setInt("int", 10))
+check(1, pl.setInt("int", 10, False))
+
+check(2, pl.set("int", pl))
+check(2, pl.set("int", pl, False))
+
+check(3, pl.setInt("int", 10, "int"))
+check(3, pl.setInt("int", 10, "int", False))
+
+
+pl = PropertyListGlobal()
+check(1, pl.setIntGlobal("int", 10))
+check(1, pl.setIntGlobal("int", 10, False))
+
+check(2, pl.set("int", pl))
+check(2, pl.set("int", pl, False))
+
+check(3, pl.setIntGlobal("int", 10, "int"))
+check(3, pl.setIntGlobal("int", 10, "int", False))
+
+
+check(1, GoopIntGlobal(10))
+check(1, GoopIntGlobal(10, True))
+
+check(2, goopGlobal(3))
+check(2, goopGlobal())
+
+check(3, GoopIntGlobal("int", False))
+check(3, GoopIntGlobal("int"))
+
+
+check(1, GoopInt(10))
+check(1, GoopInt(10, True))
+
+check(2, goop(3))
+check(2, goop())
+
+check(3, GoopInt("int", False))
+check(3, GoopInt("int"))
x = template_default_arg.X_int()
if (x.meth(20.0, 200) != 200):
- raise RuntimeError, ("X_int test 1 failed")
+ raise RuntimeError, ("X_int test 1 failed")
if (x.meth(20) != 20):
- raise RuntimeError, ("X_int test 2 failed")
+ raise RuntimeError, ("X_int test 2 failed")
if (x.meth() != 0):
- raise RuntimeError, ("X_int test 3 failed")
-
+ raise RuntimeError, ("X_int test 3 failed")
y = template_default_arg.Y_unsigned()
if (y.meth(20.0, 200) != 200):
- raise RuntimeError, ("Y_unsigned test 1 failed")
+ raise RuntimeError, ("Y_unsigned test 1 failed")
if (y.meth(20) != 20):
- raise RuntimeError, ("Y_unsigned test 2 failed")
+ raise RuntimeError, ("Y_unsigned test 2 failed")
if (y.meth() != 0):
- raise RuntimeError, ("Y_unsigned test 3 failed")
-
+ raise RuntimeError, ("Y_unsigned test 3 failed")
x = template_default_arg.X_longlong()
x = template_default_arg.X_hello_unsigned()
x = template_default_arg.X_hello_unsigned(20.0)
-x = template_default_arg.X_hello_unsigned(20.0, template_default_arg.Hello_int())
+x = template_default_arg.X_hello_unsigned(
+ 20.0, template_default_arg.Hello_int())
y = template_default_arg.Y_hello_unsigned()
y.meth()
-
fz = template_default_arg.Foo_Z_8()
x = template_default_arg.X_Foo_Z_8()
fzc = x.meth(fz)
# plain function: int ott(Foo<int>)
if (template_default_arg.ott(template_default_arg.Foo_int()) != 30):
- raise RuntimeError, ("ott test 1 failed")
+ raise RuntimeError, ("ott test 1 failed")
# %template(ott) ott<int, int>
if (template_default_arg.ott() != 10):
- raise RuntimeError, ("ott test 2 failed")
+ raise RuntimeError, ("ott test 2 failed")
if (template_default_arg.ott(1) != 10):
- raise RuntimeError, ("ott test 3 failed")
+ raise RuntimeError, ("ott test 3 failed")
if (template_default_arg.ott(1, 1) != 10):
- raise RuntimeError, ("ott test 4 failed")
+ raise RuntimeError, ("ott test 4 failed")
if (template_default_arg.ott("hi") != 20):
- raise RuntimeError, ("ott test 5 failed")
+ raise RuntimeError, ("ott test 5 failed")
if (template_default_arg.ott("hi", 1) != 20):
- raise RuntimeError, ("ott test 6 failed")
+ raise RuntimeError, ("ott test 6 failed")
if (template_default_arg.ott("hi", 1, 1) != 20):
- raise RuntimeError, ("ott test 7 failed")
+ raise RuntimeError, ("ott test 7 failed")
# %template(ott) ott<const char *>
if (template_default_arg.ottstring(template_default_arg.Hello_int(), "hi") != 40):
- raise RuntimeError, ("ott test 8 failed")
+ raise RuntimeError, ("ott test 8 failed")
if (template_default_arg.ottstring(template_default_arg.Hello_int()) != 40):
- raise RuntimeError, ("ott test 9 failed")
+ raise RuntimeError, ("ott test 9 failed")
# %template(ott) ott<int>
if (template_default_arg.ottint(template_default_arg.Hello_int(), 1) != 50):
- raise RuntimeError, ("ott test 10 failed")
+ raise RuntimeError, ("ott test 10 failed")
if (template_default_arg.ottint(template_default_arg.Hello_int()) != 50):
- raise RuntimeError, ("ott test 11 failed")
+ raise RuntimeError, ("ott test 11 failed")
# %template(ott) ott<double>
if (template_default_arg.ott(template_default_arg.Hello_int(), 1.0) != 60):
- raise RuntimeError, ("ott test 12 failed")
+ raise RuntimeError, ("ott test 12 failed")
if (template_default_arg.ott(template_default_arg.Hello_int()) != 60):
- raise RuntimeError, ("ott test 13 failed")
-
-
-
+ raise RuntimeError, ("ott test 13 failed")
if invoke_blah_uint(f) != "Bar":
raise ValueError
-
-from template_matrix import *
-passVector([1,2,3])
-passMatrix([[1,2],[1,2,3]])
-passCube([[[1,2],[1,2,3]],[[1,2],[1,2,3]]])
-
-
+from template_matrix import *
+passVector([1, 2, 3])
+passMatrix([[1, 2], [1, 2, 3]])
+passCube([[[1, 2], [1, 2, 3]], [[1, 2], [1, 2, 3]]])
from template_ns4 import *
-d = make_Class_DD();
+d = make_Class_DD()
if d.test() != "test":
- raise RuntimeError
+ raise RuntimeError
from template_ns import *
-p1 = pairii(2,3)
+p1 = pairii(2, 3)
p2 = pairii(p1)
if p2.first != 2:
if p2.second != 3:
raise RuntimeError
-p3 = pairdd(3.5,2.5)
+p3 = pairdd(3.5, 2.5)
p4 = pairdd(p3)
if p4.first != 3.5:
v = template_opaque.OpaqueVectorType(10)
template_opaque.FillVector(v)
-
import template_ref_type
xr = template_ref_type.XC()
-y = template_ref_type.Y()
+y = template_ref_type.Y()
y.find(xr)
-from template_static import *
+from template_static import *
Foo_bar_double(1)
a = make_Class_dd()
if a.test() != "test":
- raise RuntimeError
+ raise RuntimeError
from template_type_namespace import *
if type(foo()[0]) != type(""):
- raise RuntimeError
-
+ raise RuntimeError
#
try:
- d = make_Identity_double()
- a = d.this
+ d = make_Identity_double()
+ a = d.this
except:
- print d, "is not an instance"
- raise RuntimeError
+ print d, "is not an instance"
+ raise RuntimeError
s = '%s' % d
if str.find(s, 'ArithUnaryFunction') == -1:
- print d, "is not an ArithUnaryFunction"
- raise RuntimeError
+ print d, "is not an ArithUnaryFunction"
+ raise RuntimeError
try:
- e = make_Multiplies_double_double_double_double(d, d)
- a = e.this
+ e = make_Multiplies_double_double_double_double(d, d)
+ a = e.this
except:
- print e, "is not an instance"
- raise RuntimeError
+ print e, "is not an instance"
+ raise RuntimeError
s = '%s' % e
if str.find(s, 'ArithUnaryFunction') == -1:
- print e, "is not an ArithUnaryFunction"
- raise RuntimeError
+ print e, "is not an ArithUnaryFunction"
+ raise RuntimeError
#
#
try:
- c = make_Identity_complex()
- a = c.this
+ c = make_Identity_complex()
+ a = c.this
except:
- print c, "is not an instance"
- raise RuntimeError
+ print c, "is not an instance"
+ raise RuntimeError
s = '%s' % c
if str.find(s, 'ArithUnaryFunction') == -1:
- print c, "is not an ArithUnaryFunction"
- raise RuntimeError
+ print c, "is not an ArithUnaryFunction"
+ raise RuntimeError
try:
- f = make_Multiplies_complex_complex_complex_complex(c, c)
- a = f.this
+ f = make_Multiplies_complex_complex_complex_complex(c, c)
+ a = f.this
except:
- print f, "is not an instance"
- raise RuntimeError
+ print f, "is not an instance"
+ raise RuntimeError
s = '%s' % f
if str.find(s, 'ArithUnaryFunction') == -1:
- print f, "is not an ArithUnaryFunction"
- raise RuntimeError
+ print f, "is not an ArithUnaryFunction"
+ raise RuntimeError
#
# Mix case
#
try:
- g = make_Multiplies_double_double_complex_complex(d, c)
- a = g.this
+ g = make_Multiplies_double_double_complex_complex(d, c)
+ a = g.this
except:
- print g, "is not an instance"
- raise RuntimeError
+ print g, "is not an instance"
+ raise RuntimeError
s = '%s' % g
if str.find(s, 'ArithUnaryFunction') == -1:
- print g, "is not an ArithUnaryFunction"
- raise RuntimeError
+ print g, "is not an ArithUnaryFunction"
+ raise RuntimeError
try:
- h = make_Multiplies_complex_complex_double_double(c, d)
- a = h.this
+ h = make_Multiplies_complex_complex_double_double(c, d)
+ a = h.this
except:
- print h, "is not an instance"
- raise RuntimeError
+ print h, "is not an instance"
+ raise RuntimeError
s = '%s' % h
if str.find(s, 'ArithUnaryFunction') == -1:
- print h, "is not an ArithUnaryFunction"
- raise RuntimeError
+ print h, "is not an ArithUnaryFunction"
+ raise RuntimeError
try:
- a = g.get_value()
+ a = g.get_value()
except:
- print g, "has not get_value() method"
- raise RuntimeError
-
+ print g, "has not get_value() method"
+ raise RuntimeError
s.get_value()
s.get_arith_value()
my_func_r(s)
-make_Multiplies_double_double_double_double(s,s)
+make_Multiplies_double_double_double_double(s, s)
z = CSin()
z.get_base_value()
z.get_value()
z.get_arith_value()
my_func_c(z)
-make_Multiplies_complex_complex_complex_complex(z,z)
+make_Multiplies_complex_complex_complex_complex(z, z)
#
# Here we fail
c = make_Identity_complex()
my_func_c(c)
-
-
-
-
s.get_value()
s.get_arith_value()
my_func_r(s)
-make_Multiplies_double_double_double_double(s,s)
+make_Multiplies_double_double_double_double(s, s)
z = CSin()
z.get_base_value()
z.get_value()
z.get_arith_value()
my_func_c(z)
-make_Multiplies_complex_complex_complex_complex(z,z)
+make_Multiplies_complex_complex_complex_complex(z, z)
#
# Here we fail
c = make_Identity_complex()
my_func_c(c)
-
-
-
-
#
try:
- d = make_Identity_double()
- a = d.this
+ d = make_Identity_double()
+ a = d.this
except:
- print d, "is not an instance"
- raise RuntimeError
+ print d, "is not an instance"
+ raise RuntimeError
s = '%s' % d
if str.find(s, 'ArithUnaryFunction') == -1:
- print d, "is not an ArithUnaryFunction"
- raise RuntimeError
+ print d, "is not an ArithUnaryFunction"
+ raise RuntimeError
try:
- e = make_Multiplies_double_double_double_double(d, d)
- a = e.this
+ e = make_Multiplies_double_double_double_double(d, d)
+ a = e.this
except:
- print e, "is not an instance"
- raise RuntimeError
+ print e, "is not an instance"
+ raise RuntimeError
s = '%s' % e
if str.find(s, 'ArithUnaryFunction') == -1:
- print e, "is not an ArithUnaryFunction"
- raise RuntimeError
+ print e, "is not an ArithUnaryFunction"
+ raise RuntimeError
#
#
try:
- c = make_Identity_complex()
- a = c.this
+ c = make_Identity_complex()
+ a = c.this
except:
- print c, "is not an instance"
- raise RuntimeError
+ print c, "is not an instance"
+ raise RuntimeError
s = '%s' % c
if str.find(s, 'ArithUnaryFunction') == -1:
- print c, "is not an ArithUnaryFunction"
- raise RuntimeError
+ print c, "is not an ArithUnaryFunction"
+ raise RuntimeError
try:
- f = make_Multiplies_complex_complex_complex_complex(c, c)
- a = f.this
+ f = make_Multiplies_complex_complex_complex_complex(c, c)
+ a = f.this
except:
- print f, "is not an instance"
- raise RuntimeError
+ print f, "is not an instance"
+ raise RuntimeError
s = '%s' % f
if str.find(s, 'ArithUnaryFunction') == -1:
- print f, "is not an ArithUnaryFunction"
- raise RuntimeError
+ print f, "is not an ArithUnaryFunction"
+ raise RuntimeError
#
# Mix case
#
try:
- g = make_Multiplies_double_double_complex_complex(d, c)
- a = g.this
+ g = make_Multiplies_double_double_complex_complex(d, c)
+ a = g.this
except:
- print g, "is not an instance"
- raise RuntimeError
+ print g, "is not an instance"
+ raise RuntimeError
s = '%s' % g
if str.find(s, 'ArithUnaryFunction') == -1:
- print g, "is not an ArithUnaryFunction"
- raise RuntimeError
+ print g, "is not an ArithUnaryFunction"
+ raise RuntimeError
try:
- h = make_Multiplies_complex_complex_double_double(c, d)
- a = h.this
+ h = make_Multiplies_complex_complex_double_double(c, d)
+ a = h.this
except:
- print h, "is not an instance"
- raise RuntimeError
+ print h, "is not an instance"
+ raise RuntimeError
s = '%s' % h
if str.find(s, 'ArithUnaryFunction') == -1:
- print h, "is not an ArithUnaryFunction"
- raise RuntimeError
+ print h, "is not an ArithUnaryFunction"
+ raise RuntimeError
s.get_value()
s.get_arith_value()
my_func_r(s)
-make_Multiplies_double_double_double_double(s,s)
+make_Multiplies_double_double_double_double(s, s)
z = CSin()
z.get_base_value()
z.get_value()
z.get_arith_value()
my_func_c(z)
-make_Multiplies_complex_complex_complex_complex(z,z)
+make_Multiplies_complex_complex_complex_complex(z, z)
#
# Here we fail
c = make_Identity_complex()
my_func_c(c)
-
-
-
-
try:
- a = d.this
- a = c.this
+ a = d.this
+ a = c.this
except:
- raise RuntimeError
+ raise RuntimeError
try:
- e = make_Multiplies_float_float_float_float(d, d)
- a = e.this
+ e = make_Multiplies_float_float_float_float(d, d)
+ a = e.this
except:
- print e, "is not an instance"
- raise RuntimeError
+ print e, "is not an instance"
+ raise RuntimeError
try:
- f = make_Multiplies_reald_reald_reald_reald(c, c)
- a = f.this
+ f = make_Multiplies_reald_reald_reald_reald(c, c)
+ a = f.this
except:
- print f, "is not an instance"
- raise RuntimeError
+ print f, "is not an instance"
+ raise RuntimeError
try:
- g = make_Multiplies_float_float_reald_reald(d, c)
- a = g.this
+ g = make_Multiplies_float_float_reald_reald(d, c)
+ a = g.this
except:
- print g, "is not an instance"
- raise RuntimeError
+ print g, "is not an instance"
+ raise RuntimeError
# the old large format
if not SWIG_TypeQuery("vfncs::ArithUnaryFunction<vfncs::arith_traits<float,double>::argument_type,vfncs::arith_traits<float,double >::result_type > *"):
- raise RuntimeError
+ raise RuntimeError
# the reduced format
if not SWIG_TypeQuery("vfncs::ArithUnaryFunction<double,double> *"):
- raise RuntimeError
+ raise RuntimeError
# this is a bad name
if SWIG_TypeQuery("vfncs::ArithUnaryFunction<double,doublex> *"):
- raise RuntimeError
+ raise RuntimeError
#dummy_pair = m2.make_dummy_pair()
#val = m2.typemap_test(dummy_pair)
-#print val
-#if val != 4321:
+# print val
+# if val != 4321:
# raise RuntimeError, "typemaps not working"
if typedef_test1(dummy_pair).val != 1234:
if typedef_test6(dummy_pair).val != 1234:
raise RuntimeError, "typedef_test6 not working"
-
#dummy_pair = m2.make_dummy_pair()
#val = m2.typemap_test(dummy_pair)
-#print val
-#if val != 4321:
+# print val
+# if val != 4321:
# raise RuntimeError, "typemaps not working"
if typedef_test1(dummy_pair).val != 1234:
if typedef_test6(dummy_pair).val != 1234:
raise RuntimeError, "typedef_test6 not working"
-
t = threads_exception.Test()
try:
- t.unknown()
-except RuntimeError,e:
- pass
+ t.unknown()
+except RuntimeError, e:
+ pass
try:
- t.simple()
-except RuntimeError,e:
- if e.args[0] != 37:
- raise RuntimeError
+ t.simple()
+except RuntimeError, e:
+ if e.args[0] != 37:
+ raise RuntimeError
try:
- t.message()
-except RuntimeError,e:
- if e.args[0] != "I died.":
- raise RuntimeError
+ t.message()
+except RuntimeError, e:
+ if e.args[0] != "I died.":
+ raise RuntimeError
# This is expected fail with -builtin option
# Throwing builtin classes as exceptions not supported
-try:
- t.hosed()
-except threads_exception.Exc,e:
- code = e.code
- if code != 42:
- raise RuntimeError, "bad... code: %d" % code
- msg = e.msg
- if msg != "Hosed":
- raise RuntimeError, "bad... msg: '%s' len: %d" % (msg, len(msg))
-
-for i in range(1,4):
- try:
- t.multi(i)
- except RuntimeError,e:
- pass
- except threads_exception.Exc,e:
- pass
+if not threads_exception.is_python_builtin():
+ try:
+ t.hosed()
+ except threads_exception.Exc, e:
+ code = e.code
+ if code != 42:
+ raise RuntimeError, "bad... code: %d" % code
+ msg = e.msg
+ if msg != "Hosed":
+ raise RuntimeError, "bad... msg: '%s' len: %d" % (msg, len(msg))
+for i in range(1, 4):
+ try:
+ t.multi(i)
+ except RuntimeError, e:
+ pass
+ except threads_exception.Exc, e:
+ pass
import typedef_class
-a = typedef_class.RealA()
-a.a = 3
-
-b = typedef_class.B()
-b.testA(a)
+a = typedef_class.RealA()
+a.a = 3
+
+b = typedef_class.B()
+b.testA(a)
import typedef_scope
b = typedef_scope.Bar()
-x = b.test1(42,"hello")
+x = b.test1(42, "hello")
if x != 42:
print "Failed!!"
-x = b.test2(42,"hello")
+x = b.test2(42, "hello")
if x != "hello":
print "Failed!!"
-
-
--- /dev/null
+import typedef_typedef
+
+b = typedef_typedef.B()
+if b.getValue(123) != 1234:
+ raise Exception("Failed")
if sumA(None) != 60:
raise RuntimeError, "Sum is wrong"
-
if test2("hello") != "hello":
raise RuntimeError
-
from typemap_out_optimal import *
cvar.XX_debug = False
-x = XX.create()
-
+x = XX_create()
if typemap_qualifier_strip.testD4(val) != 111:
raise RuntimeError
-
b = typename.Bar()
x = typename.twoFoo(f)
-if not isinstance(x,types.FloatType):
- raise RuntimeError,"Wrong return type (FloatType) !"
+if not isinstance(x, types.FloatType):
+ raise RuntimeError, "Wrong return type (FloatType) !"
y = typename.twoBar(b)
-if not isinstance(y,types.IntType):
- raise RuntimeError,"Wrong return type (IntType)!"
-
+if not isinstance(y, types.IntType):
+ raise RuntimeError, "Wrong return type (IntType)!"
from types_directive import *
d1 = Time1(2001, 2, 3, 60)
-newDate = add(d1, 7) # check that a Time1 instance is accepted where Date is expected
+# check that a Time1 instance is accepted where Date is expected
+newDate = add(d1, 7)
if newDate.day != 10:
- raise RuntimeError
+ raise RuntimeError
d2 = Time2(1999, 8, 7, 60)
-newDate = add(d2, 7) # check that a Time2 instance is accepted where Date is expected
+# check that a Time2 instance is accepted where Date is expected
+newDate = add(d2, 7)
if newDate.day != 14:
- raise RuntimeError
-
+ raise RuntimeError
--- /dev/null
+import sys
+
+import unicode_strings
+
+# The 'u' string prefix isn't valid in Python 3.0 - 3.2 and is redundant
+# in 3.3+. Since this file is run through 2to3 before testing, though,
+# mark this as a unicode string in 2.x so it'll become a str in 3.x.
+test_string = u'h\udce9llo w\u00f6rld'
+
+if sys.version_info[0:2] >= (3, 1):
+ if unicode_strings.non_utf8_c_str() != test_string:
+ raise ValueError('Test comparison mismatch')
+ if unicode_strings.non_utf8_std_string() != test_string:
+ raise ValueError('Test comparison mismatch')
+
+# Testing SWIG_PYTHON_2_UNICODE flag which allows unicode strings to be passed to C
+if sys.version_info[0:2] < (3, 0):
+ assert unicode_strings.charstring("hello1") == "hello1"
+ assert unicode_strings.charstring(str(u"hello2")) == "hello2"
+ assert unicode_strings.charstring(u"hello3") == "hello3"
+ assert unicode_strings.charstring(unicode("hello4")) == "hello4"
+ unicode_strings.charstring(u"hell\xb05")
+ unicode_strings.charstring(u"hell\u00f66")
-# This is the union runtime testcase. It ensures that values within a
+# This is the union runtime testcase. It ensures that values within a
# union embedded within a struct can be set and read correctly.
import unions
eut.uni.small = small
Jill1 = eut.uni.small.jill
if (Jill1 != 200):
- print "Runtime test1 failed. eut.uni.small.jill=" , Jill1
+ print "Runtime test1 failed. eut.uni.small.jill=", Jill1
sys.exit(1)
Num1 = eut.number
if (Num1 != 1):
- print "Runtime test2 failed. eut.number=" , Num1
+ print "Runtime test2 failed. eut.number=", Num1
sys.exit(1)
# Secondly check the BigStruct in EmbeddedUnionTest
eut.uni.big = big
Jack1 = eut.uni.big.jack
if (Jack1 != 300):
- print "Runtime test3 failed. eut.uni.big.jack=" , Jack1
+ print "Runtime test3 failed. eut.uni.big.jack=", Jack1
sys.exit(1)
Jill2 = eut.uni.big.smallstruct.jill
if (Jill2 != 200):
- print "Runtime test4 failed. eut.uni.big.smallstruct.jill=" , Jill2
+ print "Runtime test4 failed. eut.uni.big.smallstruct.jill=", Jill2
sys.exit(1)
Num2 = eut.number
if (Num2 != 2):
- print "Runtime test5 failed. eut.number=" , Num2
+ print "Runtime test5 failed. eut.number=", Num2
sys.exit(1)
-
f = FooBar()
if f.blah(3) != 3:
- raise RuntimeError,"FooBar::blah(int)"
+ raise RuntimeError, "FooBar::blah(int)"
if f.blah(3.5) != 3.5:
- raise RuntimeError,"FooBar::blah(double)"
+ raise RuntimeError, "FooBar::blah(double)"
if f.blah("hello") != "hello":
- raise RuntimeError,"FooBar::blah(char *)"
+ raise RuntimeError, "FooBar::blah(char *)"
f = FooBar2()
if f.blah(3) != 3:
- raise RuntimeError,"FooBar2::blah(int)"
+ raise RuntimeError, "FooBar2::blah(int)"
if f.blah(3.5) != 3.5:
- raise RuntimeError,"FooBar2::blah(double)"
+ raise RuntimeError, "FooBar2::blah(double)"
if f.blah("hello") != "hello":
- raise RuntimeError,"FooBar2::blah(char *)"
+ raise RuntimeError, "FooBar2::blah(char *)"
f = FooBar3()
if f.blah(3) != 3:
- raise RuntimeError,"FooBar3::blah(int)"
+ raise RuntimeError, "FooBar3::blah(int)"
if f.blah(3.5) != 3.5:
- raise RuntimeError,"FooBar3::blah(double)"
+ raise RuntimeError, "FooBar3::blah(double)"
if f.blah("hello") != "hello":
- raise RuntimeError,"FooBar3::blah(char *)"
-
+ raise RuntimeError, "FooBar3::blah(char *)"
f = FooBar()
if f.blah(3) != 3:
- raise RuntimeError,"blah(int)"
+ raise RuntimeError, "blah(int)"
if f.blah(3.5) != 3.5:
- raise RuntimeError,"blah(double)"
+ raise RuntimeError, "blah(double)"
if f.blah("hello") != "hello":
- raise RuntimeError,"blah(char *)"
+ raise RuntimeError, "blah(char *)"
-if f.blah(3,4) != 7:
- raise RuntimeError,"blah(int,int)"
+if f.blah(3, 4) != 7:
+ raise RuntimeError, "blah(int,int)"
-if f.blah(3.5,7.5) != (3.5+7.5):
- raise RuntimeError,"blah(double,double)"
+if f.blah(3.5, 7.5) != (3.5 + 7.5):
+ raise RuntimeError, "blah(double,double)"
if f.duh(3) != 3:
- raise RuntimeError,"duh(int)"
+ raise RuntimeError, "duh(int)"
b = Bar()
if b.test(3) != 3:
- raise RuntimeError,"Bar::test(int)"
+ raise RuntimeError, "Bar::test(int)"
if b.test(3.5) != 3.5:
- raise RuntimeError, "Bar::test(double)"
+ raise RuntimeError, "Bar::test(double)"
b = Bar2()
if b.test(3) != 6:
- raise RuntimeError,"Bar2::test(int)"
+ raise RuntimeError, "Bar2::test(int)"
if b.test(3.5) != 7.0:
- raise RuntimeError, "Bar2::test(double)"
+ raise RuntimeError, "Bar2::test(double)"
b = Bar3()
if b.test(3) != 6:
- raise RuntimeError,"Bar3::test(int)"
+ raise RuntimeError, "Bar3::test(int)"
if b.test(3.5) != 7.0:
- raise RuntimeError, "Bar3::test(double)"
+ raise RuntimeError, "Bar3::test(double)"
b = Bar4()
if b.test(3) != 6:
- raise RuntimeError,"Bar4::test(int)"
+ raise RuntimeError, "Bar4::test(int)"
if b.test(3.5) != 7.0:
- raise RuntimeError, "Bar4::test(double)"
+ raise RuntimeError, "Bar4::test(double)"
b = Fred1()
if b.test(3) != 3:
- raise RuntimeError,"Fred1::test(int)"
+ raise RuntimeError, "Fred1::test(int)"
if b.test(3.5) != 7.0:
- raise RuntimeError, "Fred1::test(double)"
+ raise RuntimeError, "Fred1::test(double)"
b = Fred2()
if b.test(3) != 3:
- raise RuntimeError,"Fred2::test(int)"
+ raise RuntimeError, "Fred2::test(int)"
if b.test(3.5) != 7.0:
- raise RuntimeError, "Fred2::test(double)"
-
+ raise RuntimeError, "Fred2::test(double)"
if varargs_overload.vararg_over4("Hello", 123) != "Hello":
raise RuntimeError, "Failed"
-
raise RuntimeError, "Failed"
-if varargs.test_def("Hello",1) != "Hello":
+if varargs.test_def("Hello", 1) != "Hello":
raise RuntimeError, "Failed"
if varargs.test_def("Hello") != "Hello":
#
b = B(3)
if b.get_a() != b.get_b():
- raise RuntimeError, "something is really wrong"
-
+ raise RuntimeError, "something is really wrong"
#
# the copy methods return the right polymorphic types
-#
+#
dc = d.copy()
ic = i.copy()
if d.get() != dc.get():
- raise RuntimeError
+ raise RuntimeError
if i.get() != ic.get():
- raise RuntimeError
+ raise RuntimeError
virtual_poly.incr(ic)
if (i.get() + 1) != ic.get():
- raise RuntimeError
+ raise RuntimeError
dr = d.ref_this()
if d.get() != dr.get():
- raise RuntimeError
+ raise RuntimeError
#
#
ddc = virtual_poly.NDouble_narrow(d.nnumber())
if d.get() != ddc.get():
- raise RuntimeError
+ raise RuntimeError
dic = virtual_poly.NInt_narrow(i.nnumber())
if i.get() != dic.get():
- raise RuntimeError
+ raise RuntimeError
voidtest.Foo_staticmemberfunc()
+
def fvoid():
pass
-if f.memberfunc() != fvoid():
+if f.memberfunc() != fvoid():
raise RuntimeError
a = 2
b = -1
-wrapmacro.maximum(a,b)
-wrapmacro.maximum(a/7.0, -b*256)
+wrapmacro.maximum(a, b)
+wrapmacro.maximum(a / 7.0, -b * 256)
wrapmacro.GUINT16_SWAP_LE_BE_CONSTANT(1)
%template(IntVector) vector<int>;
%template(IntList) list<int>;
}
+
+%inline %{
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
+%}
+
+#ifdef SWIGPYTHON_PY3 // set when using -py3
+#define is_swig_py3 1
+#else
+#define is_swig_py3 0
+#endif
%module python_append
%pythoncode %{
- mypath = os.path.dirname("/a/b/c/d.txt")
- funcpath = None
- staticfuncpath = None
- def grabpath():
+mypath = os.path.dirname("/a/b/c/d.txt")
+funcpath = None
+staticfuncpath = None
+def grabpath():
return funcpath
- def grabstaticpath():
+def grabstaticpath():
return staticfuncpath
+def clearstaticpath():
+ global staticfuncpath
+ staticfuncpath = None
%}
%pythonappend Test::func %{
- funcpath = os.path.dirname(funcpath)
+funcpath = os.path.dirname(funcpath)
%}
%pythonprepend Test::func %{
- global funcpath
- funcpath = mypath
+global funcpath
+funcpath = mypath
%}
%pythonappend Test::static_func %{
%}
%pythonprepend Test::static_func {
- global staticfuncpath
- staticfuncpath = mypath
- pass
+global staticfuncpath
+staticfuncpath = mypath
+pass
}
%pythonbegin %{
void func() {};
};
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
%}
--- /dev/null
+/* File : example.i */
+%module python_destructor_exception
+%include exception.i
+
+%exception ClassWithThrowingDestructor::~ClassWithThrowingDestructor()
+{
+ $action
+ SWIG_exception(SWIG_RuntimeError, "I am the ClassWithThrowingDestructor dtor doing bad things");
+}
+
+%inline %{
+class ClassWithThrowingDestructor
+{
+};
+
+%}
+
+%include <std_vector.i>
+%template(VectorInt) std::vector<int>;
--- /dev/null
+%module python_docstring
+
+// Test indentation when using the docstring feature.
+// Checks tabs and spaces as input for indentation.
+
+%feature("docstring") docstring1 %{
+ line 1
+line 2
+
+
+
+line 3
+%}
+
+%feature("docstring") docstring2 %{
+line 1
+ line 2
+
+
+
+ line 3
+ %}
+
+%feature("docstring") docstring3 %{
+ line 1
+ line 2
+
+
+
+ line 3
+ %}
+
+%feature("docstring") docstring4 %{
+ line 1
+ line 2
+
+
+
+ line 3
+ %}
+
+%feature("docstring") docstring5
+%{ line 1
+ line 2
+
+
+
+ line 3
+ %}
+
+%feature("docstring") docstring6
+{
+ line 1
+ line 2
+
+
+
+ line 3
+}
+
+%feature("docstring") docstring7
+{
+line 1
+line 2
+line 3
+}
+
+%feature("docstring") docstringA
+%{ first line
+ second line%}
+
+%feature("docstring") docstringB
+%{ first line
+ second line%}
+
+%feature("docstring") docstringC
+%{ first line
+ second line%}
+
+%feature("docstring") docstringX " one line docs"
+%feature("docstring") docstringY "one line docs"
+
+%inline %{
+struct DocStrings {
+ void docstring1() {}
+ void docstring2() {}
+ void docstring3() {}
+ void docstring4() {}
+ void docstring5() {}
+ void docstring6() {}
+ void docstring7() {}
+ void docstringA() {}
+ void docstringB() {}
+ void docstringC() {}
+ void docstringX() {}
+ void docstringY() {}
+};
+%}
%module python_nondynamic
/*
- Use the %pythonnondynamic directuve to make the wrapped class a
+ Use the %pythonnondynamic directive to make the wrapped class a
nondynamic one, ie, a python class that doesn't dynamically add new
attributes. Hence, for the class
--- /dev/null
+%module python_pythoncode
+
+// github issue#379 - these examples failed with 3.0.5 and earlier (at least as
+// far back as 1.3.37):
+
+struct TYPE {
+%pythoncode %{
+ def one():
+ a = 1
+# Comment XXXX
+ return a
+%}
+};
+
+%define %bar
+%pythoncode %{
+ def one():
+ a = 1
+ #
+ return a
+%}
+%enddef
+
+struct TYPE2 {
+%bar
+};
+
+%{
+struct TYPE { };
+struct TYPE2 { };
+%}
--- /dev/null
+%module python_strict_unicode
+
+%include <std_string.i>
+%include <std_wstring.i>
+
+%begin %{
+#define SWIG_PYTHON_STRICT_BYTE_CHAR
+#define SWIG_PYTHON_STRICT_UNICODE_WCHAR
+%}
+
+%inline %{
+std::string double_str(const std::string& in)
+{
+ return in + in;
+}
+
+char *same_str(char* in)
+{
+ return in;
+}
+
+std::wstring double_wstr(const std::wstring& in)
+{
+ return in + in;
+}
+
+wchar_t *same_wstr(wchar_t* in)
+{
+ return in;
+}
+
+std::wstring overload(const std::wstring& in)
+{
+ return L"UNICODE";
+}
+
+std::string overload(const std::string& in)
+{
+ return "BYTES";
+}
+%}
--- /dev/null
+%module(threads=1) python_threads
+
+%include <std_vector.i>
+
+%inline %{
+struct Action {
+ int val;
+ Action(int val = 0) : val(val) {}
+};
+%}
+
+%template(VectorActionPtr) std::vector<Action *>;
+
+%inline %{
+#include <vector>
+#include <iostream>
+template <typename T> struct myStlVector : public std::vector<T> {
+};
+typedef myStlVector <Action *> ActionList;
+
+%}
+
+%template(ActionList) myStlVector<Action *>;
+
+%inline %{
+class ActionGroup
+{
+public:
+ ActionList &GetActionList () const {
+ static ActionList list;
+ list.push_back(new Action(1));
+ list.push_back(new Action(2));
+ list.push_back(new Action(3));
+ list.push_back(new Action(4));
+ return list;
+ }
+};
+%}
+
+
%typemap(in) (...)(char *vargs[10]) {
int i;
- int argc;
+ Py_ssize_t argc;
for (i = 0; i < 10; i++) vargs[i] = 0;
argc = PyTuple_Size(varargs);
if (argc > 10) {
LANGUAGE = r
SCRIPTSUFFIX = _runme.R
WRAPSUFFIX = .R
-RUNR = R CMD BATCH --no-save --no-restore
+R_OPT = --quiet --no-save --no-restore
+RUNR = R CMD BATCH $(R_OPT) '--args $(SCRIPTDIR)'
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
# none!
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_multitestcase)
+
# Runs the testcase.
-#
-# Run the runme if it exists. If not just load the R wrapper to
+#
+# Run the runme if it exists. If not just load the R wrapper to
# check for syntactic correctness
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PATH=.:"$$PATH" $(RUNTOOL) $(RUNR) $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PATH=.:"$$PATH" $(RUNTOOL) $(RUNR) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) || (cat $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX)out ; false); \
else \
- $(RUNTOOL) $(RUNR) $(srcdir)/$(SCRIPTPREFIX)$*$(WRAPSUFFIX); \
+ $(RUNTOOL) $(RUNR) ./$(SCRIPTPREFIX)$*$(WRAPSUFFIX) || (cat ./$(SCRIPTPREFIX)$*$(WRAPSUFFIX)out ; false); \
fi
run_multitestcase = \
for f in `cat $(top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)/$*.list` ; do \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$${f}$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PATH=.:"$$PATH" \
- $(RUNTOOL) $(RUNR) $(srcdir)/$(SCRIPTPREFIX)$${f}$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$${f}$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PATH=.:"$$PATH" $(RUNTOOL) $(RUNR) $(SCRIPTDIR)/$(SCRIPTPREFIX)$${f}$(SCRIPTSUFFIX) || (cat $(SCRIPTDIR)/$(SCRIPTPREFIX)$${f}$(SCRIPTSUFFIX)out ; false); \
else \
- $(RUNTOOL) $(RUNR) $(srcdir)/$(SCRIPTPREFIX)$${f}$(WRAPSUFFIX); \
+ $(RUNTOOL) $(RUNR) ./$(SCRIPTPREFIX)$${f}$(WRAPSUFFIX) || (cat ./$(SCRIPTPREFIX)$${f}$(WRAPSUFFIX)out ; false); \
fi; \
done
# Clean
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile r_clean
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' r_clean
%.clean:
@rm -f $*.R $*_wrap.so $*_wrap.cpp $*_wrap.c $*_wrap.o $*_runme.Rout $*.Rout
rm -f $${f}.R $${f}.Rout ; \
done \
fi
-
-
-source("unittest.R")
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
+
dyn.load(paste("arrays_dimensionless", .Platform$dynlib.ext, sep=""))
source("arrays_dimensionless.R")
cacheMetaData(1)
-source("unittest.R")
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
+
dyn.load(paste("funcptr", .Platform$dynlib.ext, sep=""))
source("funcptr.R")
cacheMetaData(1)
-source("unittest.R")
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
+
dyn.load(paste("ignore_parameter", .Platform$dynlib.ext, sep=""))
source("ignore_parameter.R")
cacheMetaData(1)
-source("unittest.R")
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
+
dyn.load(paste("integers", .Platform$dynlib.ext, sep=""))
source("integers.R")
cacheMetaData(1)
--- /dev/null
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
+
+dyn.load(paste("li_std_vector", .Platform$dynlib.ext, sep=""))
+source("li_std_vector.R")
+cacheMetaData(1)
+
+testvec <- c(1, 2, 3)
+
+unittest(half(testvec), testvec/2)
+unittest(average(testvec), mean(testvec))
+## string vector test
+vlen <- 13
+stringvec <- paste(letters[1:vlen], as.character(rnorm(vlen)))
+unittest(rev(stringvec), RevStringVec(stringvec))
+q(save="no")
+
+
+
-source("unittest.R")
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
+
dyn.load(paste("overload_method", .Platform$dynlib.ext, sep=""))
source("overload_method.R")
cacheMetaData(1)
--- /dev/null
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
+
+dyn.load(paste("preproc_constants", .Platform$dynlib.ext, sep=""))
+source("preproc_constants.R")
+cacheMetaData(1)
+
+v <- enumToInteger('kValue', '_MyEnum')
+print(v)
+# temporarily removed until fixed (in progress, see Github patch #500)
+#unittest(v,4)
+q(save="no")
-source("unittest.R")
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
+
dyn.load(paste("r_copy_struct", .Platform$dynlib.ext, sep=""))
source("r_copy_struct.R")
cacheMetaData(1)
-source("unittest.R")
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
+
dyn.load(paste("r_legacy", .Platform$dynlib.ext, sep=""))
source("r_legacy.R")
cacheMetaData(1)
-source("unittest.R")
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
+
dyn.load(paste("r_sexp", .Platform$dynlib.ext, sep=""))
source("r_sexp.R")
cacheMetaData(1)
-source("unittest.R")
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
+
dyn.load(paste("rename_simple", .Platform$dynlib.ext, sep=""))
source("rename_simple.R")
cacheMetaData(1)
-source("unittest.R")
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
dyn.load(paste("simple_array", .Platform$dynlib.ext, sep=""))
source("simple_array.R")
cacheMetaData(1)
-source("unittest.R")
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
dyn.load(paste("unions", .Platform$dynlib.ext, sep=""))
source("unions.R")
cacheMetaData(1)
unittest <- function (x,y) {
- if (x==y) {
+ if (all(x==y)) {
print("PASS")
} else {
print("FAIL")
}
unittesttol <- function(x,y,z) {
- if (abs(x-y) < z) {
+ if (all(abs(x-y) < z)) {
print("PASS")
} else {
print("FAIL")
return a;
}
-static struct A fixed = {20, 3, 42.0};
+static struct A fixed = {20, 3, 42.0, 0, 0};
struct A *
getARef()
%module r_overload_array
-%include "stl.i"
-# this tests the situation in which there is a scalar function
-# corresponding with a vector one
+
+%include <stl.i>
+// this tests the situation in which there is a scalar function
+// corresponding with a vector one
%inline %{
class Foo {
};
}
+#if defined(SWIG)
+%exception Space::ABC::operator ABC %{
+#if defined(__clang__)
+ // Workaround for: warning: conversion function converting 'Space::ABC' to itself will never be used
+ result = *arg1;
+#else
+ $action
+#endif
+%}
+#endif
+
namespace Space {
// non-templated class using itself in method and operator
class ABC {
public:
void method(ABC a) const {}
void method(Klass k) const {}
+#if !defined(__clang__)
+ // Workaround for: warning: conversion function converting 'Space::ABC' to itself will never be used
operator ABC() const { ABC a; return a; }
+#endif
operator Klass() const { Klass k; return k; }
};
}
};
}
+%exception Space::ABC::operator ABC %{
+#if defined(__clang__)
+ // Workaround for: warning: conversion function converting 'Space::ABC' to itself will never be used
+ result = *arg1;
+#else
+ $action
+#endif
+%}
+
namespace Space {
// non-templated class using itself in method and operator
class ABC {
void method(ABC a) const {}
void method(Klass k) const {}
+#if !defined(__clang__)
+ // Workaround for: warning: conversion function converting 'Space::ABC' to itself will never be used
operator ABC() const { ABC a; return a; }
+#endif
operator Klass() const { Klass k; return k; }
};
}
// strip the wx prefix from all identifiers except those starting with wxEVT
%rename("%(regex:/wx(?!EVT)(.*)/\\1/)s") "";
-// Replace "Set" and "Get" prefixes with "put" and "get" respectively.
-%rename("%(regex:/^Set(.*)/put\\1/)s", %$isfunction) "";
-%rename("%(regex:/^Get(.*)/get\\1/)s", %$isfunction) "";
+// Change "{Set,Get}Foo" naming convention to "{put,get}_foo" one.
+%rename("%(regex:/^Set(.*)/put_\\l\\1/)s", %$isfunction) "";
+%rename("%(regex:/^Get(.*)/get_\\l\\1/)s", %$isfunction) "";
+
+// Make some words stand out (unfortunately we don't have "global" flag): we
+// use \U to capitalize the second capture group and then \E to preserve the
+// case of the rest.
+%rename("%(regex:/(.*?)(nsa)(.*?)\\2(.*?)\\2(.*?)\\2(.*)/\\1\\U\\2\\E\\3\\U\\2\\E\\4\\U\\2\\E\\5\\U\\2\\E\\6/)s") "";
%inline %{
class xUnchangedName {
};
+inline int StartInsaneAndUnsavoryTransatlanticRansack() { return 42; }
+
%}
--- /dev/null
+%module rename_predicates
+
+// Test a few of the predicates - %$isfunction etc
+%rename("AF_%(utitle)s", %$isfunction) "";
+%rename("MF_%(utitle)s", %$isfunction, %$ismember) "";
+%rename("GF_%(utitle)s", %$isfunction, %$not %$ismember) "";
+%rename("MV_%(utitle)s", %$isvariable) "";
+%rename("GV_%(utitle)s", %$isvariable, %$isglobal) "";
+
+%extend RenamePredicates {
+ void extend_function_before() {}
+}
+
+%inline %{
+struct RenamePredicates {
+ RenamePredicates(int v = 0) : member_variable(v) {}
+ void member_function() {}
+ static void static_member_function() {}
+ int member_variable;
+ static int static_member_variable;
+};
+int RenamePredicates::static_member_variable = 456;
+int global_variable = 789;
+void global_function() {}
+%}
+
+%extend RenamePredicates {
+ void extend_function_after() {}
+}
+
+// Test the various %rename functions - %(upper) etc
+%rename("UC_%(upper)s") "uppercase";
+%rename("LC_%(lower)s") "LOWERcase";
+%rename("TI_%(title)s") "title";
+%rename("FU_%(firstuppercase)s") "firstUpperCase";
+%rename("FL_%(firstlowercase)s") "FirstLowerCase";
+%rename("CA_%(camelcase)s") "camel_Case";
+%rename("LC_%(lowercamelcase)s") "Lower_camel_Case";
+%rename("UC_%(undercase)s") "UnderCaseIt";
+
+%inline %{
+void uppercase() {}
+void LOWERcase() {}
+void title() {}
+void firstUpperCase() {}
+void FirstLowerCase() {}
+void camel_Case() {}
+void Lower_camel_Case() {}
+void UnderCaseIt() {}
+%}
+
+// Test renaming only member functions in %extend
+%rename("EX_%(upper)s", %$isfunction, %$isextendmember) "";
+%extend ExtendCheck {
+ void ExtendMethod1() {}
+}
+%inline %{
+struct ExtendCheck {
+ void RealMember1() {}
+#ifdef SWIG
+ %extend {
+ void ExtendMethod2() {}
+ }
+#endif
+ void RealMember2() {}
+};
+%}
+%extend ExtendCheck {
+ void ExtendMethod3() {}
+}
+
--- /dev/null
+%module rename_rstrip_encoder
+
+// strip the Cls suffix from all identifiers
+%rename("%(rstrip:[Cls])s") "";
+
+%inline %{
+
+class SomeThingCls {
+};
+
+struct AnotherThingCls {
+ void DoClsXCls() {}
+};
+
+%}
%inline %{
struct OldStruct {
+ enum { ONE = 1, TWO, THREE };
OldStruct() : OldInstanceVariable(111) {}
int OldInstanceVariable;
int OldInstanceMethod() { return 222; }
LANGUAGE = ruby
RUBY = @RUBY@
SCRIPTSUFFIX = _runme.rb
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
CPP_TEST_CASES = \
- kwargs_feature \
- li_cdata \
li_cstring \
li_factory \
li_std_functors \
li_std_stack \
primitive_types \
ruby_keywords \
+ ruby_minherit_shared_ptr \
ruby_naming \
ruby_track_objects \
ruby_track_objects_directors \
# stl_new
C_TEST_CASES += \
- li_cdata \
- li_cstring
+ li_cstring \
+ ruby_manual_proxy \
include $(srcdir)/../common.mk
ruby_naming.cpptest: SWIGOPT += -autorename
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.rb appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(RUBY) -I$(srcdir):. $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(RUBY) $(RUBYFLAGS) -I$(srcdir):. $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
# Clean
%.clean:
-
+ @exit 0
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile ruby_clean
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' ruby_clean
--- /dev/null
+#!/usr/bin/env ruby
+#
+# Put description here
+#
+#
+#
+#
+#
+
+require 'swig_assert'
+
+require 'cpp11_li_std_array'
+
+include Cpp11_li_std_array
+
+
+def failed(a, b, msg)
+ raise RuntimeError, "#{msg} #{a} #{b}"
+end
+
+def compare_sequences(a, b)
+ if a.size != b.size
+ failed(a, b, "different sizes")
+ end
+ for i in 0..a.size-1
+ failed(a, b, "elements are different:") if a[i] != b[i]
+ end
+end
+
+def compare_containers(rubyarray, swigarray)
+ compare_sequences(rubyarray, swigarray)
+end
+
+def setslice_exception(swigarray, newval)
+ begin
+ swigarray[0..swigarray.size] = newval
+ raise RuntimeError, "swigarray[] = #{newval} missed set exception for swigarray: #{swigarray}"
+ rescue ArgumentError => e
+# print "exception: #{e}"
+ end
+end
+
+
+# Check std::array has similar behaviour to a Ruby array
+# except it is not resizable
+
+ps = [0, 1, 2, 3, 4, 5]
+
+ai = ArrayInt6.new(ps)
+
+compare_containers(ps, ai)
+
+# slices
+compare_containers(ps[0..5], ai[0..5])
+compare_containers(ps[-6..-1], ai[-6..-1])
+compare_containers(ps[0..10], ai[0..10])
+
+# Reverse (.reverse is not provided)
+rev = []
+ai.reverse_each { |i| rev.push i }
+compare_containers(ps.reverse, rev)
+
+# Modify content
+for i in 0..ps.size-1
+ ps[i] = ps[i] * 10
+ ai[i] = ai[i] * 10
+end
+compare_containers(ps, ai)
+
+# Empty
+ai = ArrayInt6.new()
+compare_containers([0, 0, 0, 0, 0, 0], ai)
+
+# Set slice
+newvals = [10, 20, 30, 40, 50, 60]
+ai[0, 6] = newvals
+compare_containers(ai, newvals)
+
+ai[-6, 6] = newvals
+compare_containers(ai, newvals)
+
+setslice_exception(ai, [1, 2, 3, 4, 5, 6, 7])
+setslice_exception(ai, [1, 2, 3, 4, 5])
+setslice_exception(ai, [1, 2, 3, 4])
+setslice_exception(ai, [1, 2, 3])
+setslice_exception(ai, [1, 2])
+setslice_exception(ai, [1])
+setslice_exception(ai, [])
+
+# Check return
+compare_containers(arrayOutVal(), [-2, -1, 0, 0, 1, 2])
+compare_containers(arrayOutConstRef(), [-2, -1, 0, 0, 1, 2])
+compare_containers(arrayOutRef(), [-2, -1, 0, 0, 1, 2])
+compare_containers(arrayOutPtr(), [-2, -1, 0, 0, 1, 2])
+
+# Check passing arguments
+ai = arrayInVal([9, 8, 7, 6, 5, 4])
+compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+ai = arrayInConstRef([9, 8, 7, 6, 5, 4])
+compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+ai = ArrayInt6.new([9, 8, 7, 6, 5, 4])
+arrayInRef(ai)
+compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+ai = ArrayInt6.new([9, 8, 7, 6, 5, 4])
+arrayInPtr(ai)
+compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+# indexing
+ai = ArrayInt6.new([9, 8, 7, 6, 5, 4])
+swig_assert_equal(ai[0], 9, binding)
+swig_assert_equal(ai[5], 4, binding)
+swig_assert_equal(ai[6], nil, binding)
+swig_assert_equal(ai[-7], nil, binding)
+
+# fill
+ai.fill(111)
+compare_containers(ai, [111, 111, 111, 111, 111, 111])
+
+# various
+ai = ArrayInt6.new([9, 8, 7, 6, 5, 4])
+swig_assert(ai.include? 9)
+swig_assert(!ai.include?(99))
+swig_assert(ai.kind_of? ArrayInt6)
+swig_assert(ai.find {|x| x == 6 } == 6)
+swig_assert(ai.find {|x| x == 66 } == nil)
+swig_assert(ai.respond_to?(:each))
+swig_assert(ai.respond_to?(:each_with_index))
+
+ai = [0, 10, 20, 30, 40, 50]
+ai.each_with_index { |e,i| swig_assert(e/10 == i) }
+
--- /dev/null
+#!/usr/bin/env ruby
+#
+# Put description here
+#
+#
+#
+#
+#
+
+require 'swig_assert'
+
+require 'cpp11_strongly_typed_enumerations'
+
+include Cpp11_strongly_typed_enumerations
+
+def enumCheck(actual, expected)
+ raise RuntimeError,"Enum value mismatch. Expected #{expected} Actual: #{actual}" if actual != expected
+ return expected + 1
+end
+
+val = 0
+val = enumCheck(Enum1_Val1, val)
+val = enumCheck(Enum1_Val2, val)
+val = enumCheck(Enum1_Val3, 13)
+val = enumCheck(Enum1_Val4, val)
+val = enumCheck(Enum1_Val5a, 13)
+val = enumCheck(Enum1_Val6a, val)
+
+val = 0
+val = enumCheck(Enum2_Val1, val)
+val = enumCheck(Enum2_Val2, val)
+val = enumCheck(Enum2_Val3, 23)
+val = enumCheck(Enum2_Val4, val)
+val = enumCheck(Enum2_Val5b, 23)
+val = enumCheck(Enum2_Val6b, val)
+
+val = 0
+val = enumCheck(Val1, val)
+val = enumCheck(Val2, val)
+val = enumCheck(Val3, 43)
+val = enumCheck(Val4, val)
+
+val = 0
+val = enumCheck(Enum5_Val1, val)
+val = enumCheck(Enum5_Val2, val)
+val = enumCheck(Enum5_Val3, 53)
+val = enumCheck(Enum5_Val4, val)
+
+val = 0
+val = enumCheck(Enum6_Val1, val)
+val = enumCheck(Enum6_Val2, val)
+val = enumCheck(Enum6_Val3, 63)
+val = enumCheck(Enum6_Val4, val)
+
+val = 0
+val = enumCheck(Enum7td_Val1, val)
+val = enumCheck(Enum7td_Val2, val)
+val = enumCheck(Enum7td_Val3, 73)
+val = enumCheck(Enum7td_Val4, val)
+
+val = 0
+val = enumCheck(Enum8_Val1, val)
+val = enumCheck(Enum8_Val2, val)
+val = enumCheck(Enum8_Val3, 83)
+val = enumCheck(Enum8_Val4, val)
+
+val = 0
+val = enumCheck(Enum10_Val1, val)
+val = enumCheck(Enum10_Val2, val)
+val = enumCheck(Enum10_Val3, 103)
+val = enumCheck(Enum10_Val4, val)
+
+val = 0
+val = enumCheck(Class1::Enum12_Val1, 1121)
+val = enumCheck(Class1::Enum12_Val2, 1122)
+val = enumCheck(Class1::Enum12_Val3, val)
+val = enumCheck(Class1::Enum12_Val4, val)
+val = enumCheck(Class1::Enum12_Val5c, 1121)
+val = enumCheck(Class1::Enum12_Val6c, val)
+
+val = 0
+val = enumCheck(Class1::Val1, 1131)
+val = enumCheck(Class1::Val2, 1132)
+val = enumCheck(Class1::Val3, val)
+val = enumCheck(Class1::Val4, val)
+val = enumCheck(Class1::Val5d, 1131)
+val = enumCheck(Class1::Val6d, val)
+
+val = 0
+val = enumCheck(Class1::Enum14_Val1, 1141)
+val = enumCheck(Class1::Enum14_Val2, 1142)
+val = enumCheck(Class1::Enum14_Val3, val)
+val = enumCheck(Class1::Enum14_Val4, val)
+val = enumCheck(Class1::Enum14_Val5e, 1141)
+val = enumCheck(Class1::Enum14_Val6e, val)
+
+# Requires nested class support to work
+#val = 0
+#val = enumCheck(Class1::Struct1.Enum12_Val1, 3121)
+#val = enumCheck(Class1::Struct1.Enum12_Val2, 3122)
+#val = enumCheck(Class1::Struct1.Enum12_Val3, val)
+#val = enumCheck(Class1::Struct1.Enum12_Val4, val)
+#val = enumCheck(Class1::Struct1.Enum12_Val5f, 3121)
+#val = enumCheck(Class1::Struct1.Enum12_Val6f, val)
+#
+#val = 0
+#val = enumCheck(Class1::Struct1.Val1, 3131)
+#val = enumCheck(Class1::Struct1.Val2, 3132)
+#val = enumCheck(Class1::Struct1.Val3, val)
+#val = enumCheck(Class1::Struct1.Val4, val)
+#
+#val = 0
+#val = enumCheck(Class1::Struct1.Enum14_Val1, 3141)
+#val = enumCheck(Class1::Struct1.Enum14_Val2, 3142)
+#val = enumCheck(Class1::Struct1.Enum14_Val3, val)
+#val = enumCheck(Class1::Struct1.Enum14_Val4, val)
+#val = enumCheck(Class1::Struct1.Enum14_Val5g, 3141)
+#val = enumCheck(Class1::Struct1.Enum14_Val6g, val)
+
+val = 0
+val = enumCheck(Class2::Enum12_Val1, 2121)
+val = enumCheck(Class2::Enum12_Val2, 2122)
+val = enumCheck(Class2::Enum12_Val3, val)
+val = enumCheck(Class2::Enum12_Val4, val)
+val = enumCheck(Class2::Enum12_Val5h, 2121)
+val = enumCheck(Class2::Enum12_Val6h, val)
+
+val = 0
+val = enumCheck(Class2::Val1, 2131)
+val = enumCheck(Class2::Val2, 2132)
+val = enumCheck(Class2::Val3, val)
+val = enumCheck(Class2::Val4, val)
+val = enumCheck(Class2::Val5i, 2131)
+val = enumCheck(Class2::Val6i, val)
+
+val = 0
+val = enumCheck(Class2::Enum14_Val1, 2141)
+val = enumCheck(Class2::Enum14_Val2, 2142)
+val = enumCheck(Class2::Enum14_Val3, val)
+val = enumCheck(Class2::Enum14_Val4, val)
+val = enumCheck(Class2::Enum14_Val5j, 2141)
+val = enumCheck(Class2::Enum14_Val6j, val)
+
+# Requires nested class support to work
+#val = 0
+#val = enumCheck(Class2::Struct1.Enum12_Val1, 4121)
+#val = enumCheck(Class2::Struct1.Enum12_Val2, 4122)
+#val = enumCheck(Class2::Struct1.Enum12_Val3, val)
+#val = enumCheck(Class2::Struct1.Enum12_Val4, val)
+#val = enumCheck(Class2::Struct1.Enum12_Val5k, 4121)
+#val = enumCheck(Class2::Struct1.Enum12_Val6k, val)
+#
+#val = 0
+#val = enumCheck(Class2::Struct1.Val1, 4131)
+#val = enumCheck(Class2::Struct1.Val2, 4132)
+#val = enumCheck(Class2::Struct1.Val3, val)
+#val = enumCheck(Class2::Struct1.Val4, val)
+#val = enumCheck(Class2::Struct1.Val5l, 4131)
+#val = enumCheck(Class2::Struct1.Val6l, val)
+#
+#val = 0
+#val = enumCheck(Class2::Struct1.Enum14_Val1, 4141)
+#val = enumCheck(Class2::Struct1.Enum14_Val2, 4142)
+#val = enumCheck(Class2::Struct1.Enum14_Val3, val)
+#val = enumCheck(Class2::Struct1.Enum14_Val4, val)
+#val = enumCheck(Class2::Struct1.Enum14_Val5m, 4141)
+#val = enumCheck(Class2::Struct1.Enum14_Val6m, val)
+
+class1 = Class1.new
+enumCheck(class1.class1Test1(Enum1_Val5a), 13)
+enumCheck(class1.class1Test2(Class1::Enum12_Val5c), 1121)
+#enumCheck(class1.class1Test3(Class1::Struct1.Enum12_Val5f), 3121)
+
+enumCheck(globalTest1(Enum1_Val5a), 13)
+enumCheck(globalTest2(Class1::Enum12_Val5c), 1121)
+#enumCheck(globalTest3(Class1::Struct1.Enum12_Val5f), 3121)
+
f = F.new
# This should work fine
-ff = FFF.new
-
-# This should work fine
g = G.new
# This should work fine
--- /dev/null
+#!/usr/bin/env ruby
+#
+# Put description here
+#
+#
+#
+#
+#
+
+require 'director_smartptr'
+
+include Director_smartptr
+
+class Director_smartptr_MyBarFoo < Foo
+
+ def ping()
+ return "director_smartptr_MyBarFoo.ping()"
+ end
+
+ def pong()
+ return "director_smartptr_MyBarFoo.pong();" + ping()
+ end
+
+ def upcall(fooBarPtr)
+ return "override;" + fooBarPtr.FooBarDo()
+ end
+
+ def makeFoo()
+ return Foo.new()
+ end
+end
+
+def check(got, expected)
+ if (got != expected)
+ raise RuntimeError, "Failed, got: #{got} expected: #{expected}"
+ end
+end
+
+fooBar = Director_smartptr::FooBar.new()
+
+myBarFoo = Director_smartptr_MyBarFoo.new()
+check(myBarFoo.ping(), "director_smartptr_MyBarFoo.ping()")
+check(Foo.callPong(myBarFoo), "director_smartptr_MyBarFoo.pong();director_smartptr_MyBarFoo.ping()")
+check(Foo.callUpcall(myBarFoo, fooBar), "override;Bar::Foo2::Foo2Bar()")
+
+myFoo = myBarFoo.makeFoo()
+check(myFoo.pong(), "Foo::pong();Foo::ping()")
+check(Foo.callPong(myFoo), "Foo::pong();Foo::ping()")
+check(myFoo.upcall(FooBar.new()), "Bar::Foo2::Foo2Bar()")
+
+myFoo2 = Foo.new().makeFoo()
+check(myFoo2.pong(), "Foo::pong();Foo::ping()")
+check(Foo.callPong(myFoo2), "Foo::pong();Foo::ping()")
+check(myFoo2.upcall(FooBar.new()), "Bar::Foo2::Foo2Bar()")
--- /dev/null
+#!/usr/bin/env ruby
+#
+# Put description here
+#
+#
+#
+#
+#
+
+require 'swig_assert'
+
+require 'li_boost_array'
+
+include Li_boost_array
+
+
+def failed(a, b, msg)
+ raise RuntimeError, "#{msg} #{a} #{b}"
+end
+
+def compare_sequences(a, b)
+ if a.size != b.size
+ failed(a, b, "different sizes")
+ end
+ for i in 0..a.size-1
+ failed(a, b, "elements are different:") if a[i] != b[i]
+ end
+end
+
+def compare_containers(rubyarray, swigarray)
+ compare_sequences(rubyarray, swigarray)
+end
+
+ps = [0, 1, 2, 3, 4, 5]
+
+ai = ArrayInt6.new(ps)
+
+compare_containers(ps, ai)
+
+# Modify content
+for i in 0..ps.size-1
+ ps[i] = ps[i] * 10
+ ai[i] = ai[i] * 10
+end
+compare_containers(ps, ai)
+
+# Empty
+ai = ArrayInt6.new()
+
+# Check return
+compare_containers(arrayOutVal(), [-2, -1, 0, 0, 1, 2])
+compare_containers(arrayOutConstRef(), [-2, -1, 0, 0, 1, 2])
+#compare_containers(arrayOutRef(), [-2, -1, 0, 0, 1, 2])
+#compare_containers(arrayOutPtr(), [-2, -1, 0, 0, 1, 2])
+
+# Check passing arguments
+ai = arrayInVal([9, 8, 7, 6, 5, 4])
+compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+ai = arrayInConstRef([9, 8, 7, 6, 5, 4])
+compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+#ai = ArrayInt6.new([9, 8, 7, 6, 5, 4])
+#arrayInRef(ai)
+#compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
+#ai = ArrayInt6.new([9, 8, 7, 6, 5, 4])
+#arrayInPtr(ai)
+#compare_containers(ai, [90, 80, 70, 60, 50, 40])
+
--- /dev/null
+require 'li_boost_shared_ptr_bits'
+require 'swig_gc'
+
+v = Li_boost_shared_ptr_bits::VectorIntHolder.new()
+v.push(Li_boost_shared_ptr_bits::IntHolder.new(11))
+v.push(Li_boost_shared_ptr_bits::IntHolder.new(22))
+v.push(Li_boost_shared_ptr_bits::IntHolder.new(33))
+
+sum = Li_boost_shared_ptr_bits::sum(v)
+if (sum != 66)
+ raise RuntimeError, "sum is wrong"
+end
+
+hidden = Li_boost_shared_ptr_bits::HiddenDestructor.create()
+GC.track_class = Li_boost_shared_ptr_bits::HiddenPrivateDestructor
+GC.stats if $VERBOSE
+hidden = nil
+GC.start
+
+hiddenPrivate = Li_boost_shared_ptr_bits::HiddenPrivateDestructor.create()
+if (Li_boost_shared_ptr_bits::HiddenPrivateDestructor.DeleteCount != 0)
+ # GC doesn't always run
+# raise RuntimeError, "Count should be zero"
+end
+
+GC.stats if $VERBOSE
+hiddenPrivate = nil
+GC.start
+if (Li_boost_shared_ptr_bits::HiddenPrivateDestructor.DeleteCount != 1)
+ # GC doesn't always run
+# raise RuntimeError, "Count should be one"
+end
--- /dev/null
+require 'li_boost_shared_ptr'
+require 'swig_gc'
+
+#debug = $VERBOSE
+debug = false
+
+# simple shared_ptr usage - created in C++
+
+
+class Li_boost_shared_ptr_runme
+
+ def main(debug)
+ if (debug)
+ puts "Started"
+ end
+
+ Li_boost_shared_ptr::debug_shared = debug
+
+ # Change loop count to run for a long time to monitor memory
+ loopCount = 1 # 5000
+ 1.upto(loopCount) do
+ self.runtest()
+ end
+
+ # Expect 1 instance - the one global variable (GlobalValue)
+ GC.track_class = Li_boost_shared_ptr::Klass
+ invokeGC("Final GC")
+
+# Actual count is 3 due to memory leaks calling rb_raise in the call to Li_boost_shared_ptr::valuetest(nil)
+# as setjmp/longjmp are used thereby failing to call destructors of Klass instances on the stack in _wrap_valuetest
+# This is a generic problem in Ruby wrappers, not shared_ptr specific
+# expectedCount = 1
+ expectedCount = 3
+ actualCount = Li_boost_shared_ptr::Klass.getTotal_count()
+ if (actualCount != expectedCount)
+# raise RuntimeError, "GC failed to run (li_boost_shared_ptr). Expected count: #{expectedCount} Actual count: #{actualCount}"
+ puts "GC failed to run (li_boost_shared_ptr). Expected count: #{expectedCount} Actual count: #{actualCount}"
+ end
+
+ wrapper_count = Li_boost_shared_ptr::shared_ptr_wrapper_count()
+ if (wrapper_count != Li_boost_shared_ptr.NOT_COUNTING)
+ # Expect 1 instance - the one global variable (GlobalSmartValue)
+ if (wrapper_count != 1)
+ raise RuntimeError, "shared_ptr wrapper count=#{wrapper_count}"
+ end
+ end
+
+ if (debug)
+ puts "Finished"
+ end
+ end
+
+ def invokeGC(debug_msg)
+ puts "invokeGC #{debug_msg} start" if $VERBOSE
+ GC.stats if $VERBOSE
+ GC.start
+ puts "invokeGC #{debug_msg} end" if $VERBOSE
+ end
+
+ def runtest
+ # simple shared_ptr usage - created in C++
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ val = k.getValue()
+ self.verifyValue("me oh my", val)
+ self.verifyCount(1, k)
+
+ # simple shared_ptr usage - not created in C++
+ k = Li_boost_shared_ptr::factorycreate()
+ val = k.getValue()
+ self.verifyValue("factorycreate", val)
+ self.verifyCount(1, k)
+
+ # pass by shared_ptr
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ kret = Li_boost_shared_ptr::smartpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointertest", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by shared_ptr pointer
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ kret = Li_boost_shared_ptr::smartpointerpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointerpointertest", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by shared_ptr reference
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ kret = Li_boost_shared_ptr::smartpointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointerreftest", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by shared_ptr pointer reference
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ kret = Li_boost_shared_ptr::smartpointerpointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointerpointerreftest", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # const pass by shared_ptr
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ kret = Li_boost_shared_ptr::constsmartpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # const pass by shared_ptr pointer
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ kret = Li_boost_shared_ptr::constsmartpointerpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # const pass by shared_ptr reference
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ kret = Li_boost_shared_ptr::constsmartpointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by value
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ kret = Li_boost_shared_ptr::valuetest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my valuetest", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # pass by pointer
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ kret = Li_boost_shared_ptr::pointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my pointertest", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # pass by reference
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ kret = Li_boost_shared_ptr::reftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my reftest", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # pass by pointer reference
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ kret = Li_boost_shared_ptr::pointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my pointerreftest", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # null tests
+ k = nil
+
+ if (Li_boost_shared_ptr::smartpointertest(k) != nil)
+ raise RuntimeError, "return was not null"
+ end
+
+ if (Li_boost_shared_ptr::smartpointerpointertest(k) != nil)
+ raise RuntimeError, "return was not null"
+ end
+
+ if (Li_boost_shared_ptr::smartpointerreftest(k) != nil)
+ raise RuntimeError, "return was not null"
+ end
+
+ if (Li_boost_shared_ptr::smartpointerpointerreftest(k) != nil)
+ raise RuntimeError, "return was not null"
+ end
+
+ if (Li_boost_shared_ptr::nullsmartpointerpointertest(nil) != "null pointer")
+ raise RuntimeError, "not null smartpointer pointer"
+ end
+
+ begin
+ Li_boost_shared_ptr::valuetest(k)
+ raise RuntimeError, "Failed to catch null pointer"
+ rescue ArgumentError
+ end
+
+ if (Li_boost_shared_ptr::pointertest(k) != nil)
+ raise RuntimeError, "return was not null"
+ end
+
+ begin
+ Li_boost_shared_ptr::reftest(k)
+ raise RuntimeError, "Failed to catch null pointer"
+ rescue ArgumentError
+ end
+
+ # $owner
+ k = Li_boost_shared_ptr::pointerownertest()
+ val = k.getValue()
+ self.verifyValue("pointerownertest", val)
+ self.verifyCount(1, k)
+ k = Li_boost_shared_ptr::smartpointerpointerownertest()
+ val = k.getValue()
+ self.verifyValue("smartpointerpointerownertest", val)
+ self.verifyCount(1, k)
+
+ # //////////////////////////////// Derived class //////////////////////
+ # derived pass by shared_ptr
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::derivedsmartptrtest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my derivedsmartptrtest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # derived pass by shared_ptr pointer
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::derivedsmartptrpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my derivedsmartptrpointertest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # derived pass by shared_ptr ref
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::derivedsmartptrreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my derivedsmartptrreftest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # derived pass by shared_ptr pointer ref
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::derivedsmartptrpointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # derived pass by pointer
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::derivedpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my derivedpointertest-Derived", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # derived pass by ref
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::derivedreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my derivedreftest-Derived", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # //////////////////////////////// Derived and base class mixed ///////
+ # pass by shared_ptr (mixed)
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::smartpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointertest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by shared_ptr pointer (mixed)
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::smartpointerpointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointerpointertest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by shared_ptr reference (mixed)
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::smartpointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointerreftest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by shared_ptr pointer reference (mixed)
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::smartpointerpointerreftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my smartpointerpointerreftest-Derived", val)
+ self.verifyCount(2, k)
+ self.verifyCount(2, kret)
+
+ # pass by value (mixed)
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::valuetest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my valuetest", val) # note slicing
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # pass by pointer (mixed)
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::pointertest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my pointertest-Derived", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # pass by ref (mixed)
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ kret = Li_boost_shared_ptr::reftest(k)
+ val = kret.getValue()
+ self.verifyValue("me oh my reftest-Derived", val)
+ self.verifyCount(1, k)
+ self.verifyCount(1, kret)
+
+ # //////////////////////////////// Overloading tests //////////////////
+ # Base class
+ k = Li_boost_shared_ptr::Klass.new("me oh my")
+ self.verifyValue(Li_boost_shared_ptr::overload_rawbyval(k), "rawbyval")
+ self.verifyValue(Li_boost_shared_ptr::overload_rawbyref(k), "rawbyref")
+ self.verifyValue(Li_boost_shared_ptr::overload_rawbyptr(k), "rawbyptr")
+ self.verifyValue(
+ Li_boost_shared_ptr::overload_rawbyptrref(k), "rawbyptrref")
+
+ self.verifyValue(
+ Li_boost_shared_ptr::overload_smartbyval(k), "smartbyval")
+ self.verifyValue(
+ Li_boost_shared_ptr::overload_smartbyref(k), "smartbyref")
+ self.verifyValue(
+ Li_boost_shared_ptr::overload_smartbyptr(k), "smartbyptr")
+ self.verifyValue(
+ Li_boost_shared_ptr::overload_smartbyptrref(k), "smartbyptrref")
+
+ # Derived class
+ k = Li_boost_shared_ptr::KlassDerived.new("me oh my")
+ self.verifyValue(Li_boost_shared_ptr::overload_rawbyval(k), "rawbyval")
+ self.verifyValue(Li_boost_shared_ptr::overload_rawbyref(k), "rawbyref")
+ self.verifyValue(Li_boost_shared_ptr::overload_rawbyptr(k), "rawbyptr")
+ self.verifyValue(
+ Li_boost_shared_ptr::overload_rawbyptrref(k), "rawbyptrref")
+
+ self.verifyValue(
+ Li_boost_shared_ptr::overload_smartbyval(k), "smartbyval")
+ self.verifyValue(
+ Li_boost_shared_ptr::overload_smartbyref(k), "smartbyref")
+ self.verifyValue(
+ Li_boost_shared_ptr::overload_smartbyptr(k), "smartbyptr")
+ self.verifyValue(
+ Li_boost_shared_ptr::overload_smartbyptrref(k), "smartbyptrref")
+
+ # 3rd derived class
+ k = Li_boost_shared_ptr::Klass3rdDerived.new("me oh my")
+ val = k.getValue()
+ self.verifyValue("me oh my-3rdDerived", val)
+ self.verifyCount(1, k)
+ val = Li_boost_shared_ptr::test3rdupcast(k)
+ self.verifyValue("me oh my-3rdDerived", val)
+ self.verifyCount(1, k)
+
+ # //////////////////////////////// Member variables ///////////////////
+ # smart pointer by value
+ m = Li_boost_shared_ptr::MemberVariables.new()
+ k = Li_boost_shared_ptr::Klass.new("smart member value")
+ m.SmartMemberValue = k
+ val = k.getValue()
+ self.verifyValue("smart member value", val)
+ self.verifyCount(2, k)
+
+ kmember = m.SmartMemberValue
+ val = kmember.getValue()
+ self.verifyValue("smart member value", val)
+ self.verifyCount(3, kmember)
+ self.verifyCount(3, k)
+
+ GC.track_class = Li_boost_shared_ptr::MemberVariables
+ m = nil
+ invokeGC("m = nil (A)")
+
+ self.verifyCount(2, kmember)
+ self.verifyCount(2, k)
+
+ # smart pointer by pointer
+ m = Li_boost_shared_ptr::MemberVariables.new()
+ k = Li_boost_shared_ptr::Klass.new("smart member pointer")
+ m.SmartMemberPointer = k
+ val = k.getValue()
+ self.verifyValue("smart member pointer", val)
+ self.verifyCount(1, k)
+
+ kmember = m.SmartMemberPointer
+ val = kmember.getValue()
+ self.verifyValue("smart member pointer", val)
+ self.verifyCount(2, kmember)
+ self.verifyCount(2, k)
+
+ m = nil
+ invokeGC("m = nil (B)")
+
+ self.verifyCount(2, kmember)
+ self.verifyCount(2, k)
+
+ # smart pointer by reference
+ m = Li_boost_shared_ptr::MemberVariables.new()
+ k = Li_boost_shared_ptr::Klass.new("smart member reference")
+ m.SmartMemberReference = k
+ val = k.getValue()
+ self.verifyValue("smart member reference", val)
+ self.verifyCount(2, k)
+
+ kmember = m.SmartMemberReference
+ val = kmember.getValue()
+ self.verifyValue("smart member reference", val)
+ self.verifyCount(3, kmember)
+ self.verifyCount(3, k)
+
+ # The C++ reference refers to SmartMemberValue...
+ kmemberVal = m.SmartMemberValue
+ val = kmember.getValue()
+ self.verifyValue("smart member reference", val)
+ self.verifyCount(4, kmemberVal)
+ self.verifyCount(4, kmember)
+ self.verifyCount(4, k)
+
+ m = nil
+ invokeGC("m = nil (C)")
+
+
+ self.verifyCount(3, kmemberVal)
+ self.verifyCount(3, kmember)
+ self.verifyCount(3, k)
+
+ # plain by value
+ m = Li_boost_shared_ptr::MemberVariables.new()
+ k = Li_boost_shared_ptr::Klass.new("plain member value")
+ m.MemberValue = k
+ val = k.getValue()
+ self.verifyValue("plain member value", val)
+ self.verifyCount(1, k)
+
+ kmember = m.MemberValue
+ val = kmember.getValue()
+ self.verifyValue("plain member value", val)
+ self.verifyCount(1, kmember)
+ self.verifyCount(1, k)
+
+ m = nil
+ invokeGC("m = nil (D)")
+
+ self.verifyCount(1, kmember)
+ self.verifyCount(1, k)
+
+ # plain by pointer
+ m = Li_boost_shared_ptr::MemberVariables.new()
+ k = Li_boost_shared_ptr::Klass.new("plain member pointer")
+ m.MemberPointer = k
+ val = k.getValue()
+ self.verifyValue("plain member pointer", val)
+ self.verifyCount(1, k)
+
+ kmember = m.MemberPointer
+ val = kmember.getValue()
+ self.verifyValue("plain member pointer", val)
+ self.verifyCount(1, kmember)
+ self.verifyCount(1, k)
+
+ m = nil
+ invokeGC("m = nil (E)")
+
+ self.verifyCount(1, kmember)
+ self.verifyCount(1, k)
+
+ # plain by reference
+ m = Li_boost_shared_ptr::MemberVariables.new()
+ k = Li_boost_shared_ptr::Klass.new("plain member reference")
+ m.MemberReference = k
+ val = k.getValue()
+ self.verifyValue("plain member reference", val)
+ self.verifyCount(1, k)
+
+ kmember = m.MemberReference
+ val = kmember.getValue()
+ self.verifyValue("plain member reference", val)
+ self.verifyCount(1, kmember)
+ self.verifyCount(1, k)
+
+ m = nil
+ invokeGC("m = nil (F)")
+
+ self.verifyCount(1, kmember)
+ self.verifyCount(1, k)
+
+ # null member variables
+ m = Li_boost_shared_ptr::MemberVariables.new()
+
+ # shared_ptr by value
+ k = m.SmartMemberValue
+ if (k != nil)
+ raise RuntimeError, "expected null"
+ end
+ m.SmartMemberValue = nil
+ k = m.SmartMemberValue
+ if (k != nil)
+ raise RuntimeError, "expected null"
+ end
+ self.verifyCount(0, k)
+
+ # plain by value
+ begin
+ m.MemberValue = nil
+ raise RuntimeError, "Failed to catch null pointer"
+ rescue ArgumentError
+ end
+
+ # ////////////////////////////////// Global variables /////////////////
+ # smart pointer
+ kglobal = Li_boost_shared_ptr.GlobalSmartValue
+ if (kglobal != nil)
+ raise RuntimeError, "expected null"
+ end
+
+ k = Li_boost_shared_ptr::Klass.new("smart global value")
+ Li_boost_shared_ptr.GlobalSmartValue = k
+ self.verifyCount(2, k)
+
+ kglobal = Li_boost_shared_ptr.GlobalSmartValue
+ val = kglobal.getValue()
+ self.verifyValue("smart global value", val)
+ self.verifyCount(3, kglobal)
+ self.verifyCount(3, k)
+ self.verifyValue(
+ "smart global value", Li_boost_shared_ptr.GlobalSmartValue.getValue())
+ Li_boost_shared_ptr.GlobalSmartValue = nil
+
+ # plain value
+ k = Li_boost_shared_ptr::Klass.new("global value")
+ Li_boost_shared_ptr.GlobalValue = k
+ self.verifyCount(1, k)
+
+ kglobal = Li_boost_shared_ptr.GlobalValue
+ val = kglobal.getValue()
+ self.verifyValue("global value", val)
+ self.verifyCount(1, kglobal)
+ self.verifyCount(1, k)
+ self.verifyValue(
+ "global value", Li_boost_shared_ptr.GlobalValue.getValue())
+
+ begin
+ Li_boost_shared_ptr.GlobalValue = nil
+ raise RuntimeError, "Failed to catch null pointer"
+ rescue ArgumentError
+ end
+
+ # plain pointer
+ kglobal = Li_boost_shared_ptr.GlobalPointer
+ if (kglobal != nil)
+ raise RuntimeError, "expected null"
+ end
+
+ k = Li_boost_shared_ptr::Klass.new("global pointer")
+ Li_boost_shared_ptr.GlobalPointer = k
+ self.verifyCount(1, k)
+
+ kglobal = Li_boost_shared_ptr.GlobalPointer
+ val = kglobal.getValue()
+ self.verifyValue("global pointer", val)
+ self.verifyCount(1, kglobal)
+ self.verifyCount(1, k)
+ Li_boost_shared_ptr.GlobalPointer = nil
+
+ # plain reference
+
+ k = Li_boost_shared_ptr::Klass.new("global reference")
+ Li_boost_shared_ptr.GlobalReference = k
+ self.verifyCount(1, k)
+
+ kglobal = Li_boost_shared_ptr.GlobalReference
+ val = kglobal.getValue()
+ self.verifyValue("global reference", val)
+ self.verifyCount(1, kglobal)
+ self.verifyCount(1, k)
+
+ begin
+ Li_boost_shared_ptr.GlobalReference = nil
+ raise RuntimeError, "Failed to catch null pointer"
+ rescue ArgumentError
+ end
+
+ # ////////////////////////////////// Templates ////////////////////////
+ pid = Li_boost_shared_ptr::PairIntDouble.new(10, 20.2)
+ if (pid.baseVal1 != 20 or pid.baseVal2 != 40.4)
+ raise RuntimeError, "Base values wrong"
+ end
+ if (pid.val1 != 10 or pid.val2 != 20.2)
+ raise RuntimeError, "Derived Values wrong"
+ end
+ end
+
+ def verifyValue(expected, got)
+ if (expected != got)
+ raise RuntimeError, "verify value failed. Expected: #{expected} Got: #{got}"
+ end
+ end
+
+ def verifyCount(expected, k)
+ got = Li_boost_shared_ptr::use_count(k)
+ if (expected != got)
+ puts "skipped verifyCount expect/got: #{expected}/#{got}"
+# raise RuntimeError, "verify use_count failed. Expected: #{expected} Got: #{got}"
+ end
+ end
+end
+
+runme = Li_boost_shared_ptr_runme.new()
+runme.main(debug)
--- /dev/null
+require 'li_boost_shared_ptr_template'
+
+begin
+ b = Li_boost_shared_ptr_template::BaseINTEGER.new()
+ d = Li_boost_shared_ptr_template::DerivedINTEGER.new()
+ if (b.bar() != 1)
+ raise RuntimeError("test 1")
+ end
+ if (d.bar() != 2)
+ raise RuntimeError("test 2")
+ end
+ if (Li_boost_shared_ptr_template.bar_getter(b) != 1)
+ raise RuntimeError("test 3")
+ end
+# Needs fixing as it does for Python
+# if (Li_boost_shared_ptr_template.bar_getter(d) != 2)
+# raise RuntimeError("test 4")
+# end
+end
+
+begin
+ b = Li_boost_shared_ptr_template::BaseDefaultInt.new()
+ d = Li_boost_shared_ptr_template::DerivedDefaultInt.new()
+ d2 = Li_boost_shared_ptr_template::DerivedDefaultInt2.new()
+ if (b.bar2() != 3)
+ raise RuntimeError("test 5")
+ end
+ if (d.bar2() != 4)
+ raise RuntimeError("test 6")
+ end
+ if (d2.bar2() != 4)
+ raise RuntimeError("test 6")
+ end
+ if (Li_boost_shared_ptr_template.bar2_getter(b) != 3)
+ raise RuntimeError("test 7")
+ end
+# Needs fixing as it does for Python
+# if (Li_boost_shared_ptr_template.bar2_getter(d) != 4)
+# raise RuntimeError("test 8")
+# end
+# if (Li_boost_shared_ptr_template.bar2_getter(d2) != 4)
+# raise RuntimeError("test 8")
+# end
+end
+
--- /dev/null
+#!/usr/bin/env ruby
+#
+# Put description here
+#
+#
+#
+#
+#
+
+require 'swig_assert'
+
+require 'li_carrays_cpp'
+
+include Li_carrays_cpp
+
+#
+# Testing for %array_functions(int,intArray)
+#
+ary = new_intArray(2)
+intArray_setitem(ary, 0, 0)
+intArray_setitem(ary, 1, 1)
+intArray_getitem(ary, 0)
+intArray_getitem(ary, 1)
+delete_intArray(ary)
+
+#
+# Testing for %array_class(double, doubleArray)
+#
+ary = DoubleArray.new(2)
+ary[0] = 0.0
+ary[1] = 1.0
+ary[0]
+ary[1]
+ptr = ary.cast
+ary2 = DoubleArray.frompointer(ptr)
+
"iv.slice(1,2).to_s" => "12",
"iv[0,-2]" => nil,
"iv[0,3].to_s" => "012",
- "iv[0,10].to_s" => "012",
+ "iv[0,10].to_s" => "0123",
"iv[1..2].to_s" => '12',
"iv[1..3].to_s" => '123',
"iv[1..4].to_s" => '123',
"iv[1..-2].to_s" => '12',
- "iv[2..-3]" => nil,
+ "iv[2..-3].to_s" => '',
}.each do |k,v|
swig_assert( "#{k} == #{v.inspect}", binding )
end
iv.delete_if { |x| x == 0 || x == 3 || x == 6 }
swig_assert_equal(iv.to_s, '1245', binding)
+iv[1,2] = [-2, -4]
+swig_assert_equal(iv.to_s, '1-2-45', binding)
+
+iv = IntVector.new([0,1,2,3])
+iv[0,1] = [-1, -2]
+swig_assert_equal(iv.to_s, '-1-2123', binding)
+
+iv = IntVector.new([1,2,3,4])
+iv[1,3] = [6,7,8,9]
+#__setitem__ needs fixing
+#swig_assert_equal(iv.to_s, '16789', binding)
+
+iv = IntVector.new([1,2,3,4])
+
+swig_assert_equal(iv[0], 1, binding)
+swig_assert_equal(iv[3], 4, binding)
+swig_assert_equal(iv[4], nil, binding)
+swig_assert_equal(iv[-5], nil, binding)
+
+iv[-1] = 9
+iv[-4] = 6
+swig_assert_equal(iv.to_s, '6239', binding)
+
+begin
+ iv[-5] = 99
+ raise "exception missed"
+rescue IndexError
+end
+
+iv[6] = 5
+swig_assert_equal(iv.to_s, '6239555', binding)
+
+def failed(a, b, msg)
+ a = 'nil' if a == nil
+ b = 'nil' if b == nil
+ raise RuntimeError, "#{msg}: #{a} ... #{b}"
+end
+
+def compare_sequences(a, b)
+ if a != nil && b != nil
+ if a.size != b.size
+ failed(a, b, "different sizes")
+ end
+ for i in 0..a.size-1
+ failed(a, b, "elements are different") if a[i] != b[i]
+ end
+ else
+ unless a == nil && b == nil
+ failed(a, b, "only one of the sequences is nil")
+ end
+ end
+end
+
+def compare_expanded_sequences(a, b)
+ # a can contain nil elements which indicate additional elements
+ # b won't contain nil for additional elements
+ if a != nil && b != nil
+ if a.size != b.size
+ failed(a, b, "different sizes")
+ end
+ for i in 0..a.size-1
+ failed(a, b, "elements are different") if a[i] != b[i] && a[i] != nil
+ end
+ else
+ unless a == nil && b == nil
+ failed(a, b, "only one of the sequences is nil")
+ end
+ end
+end
+
+def check_slice(i, length)
+ aa = [1,2,3,4]
+ iv = IntVector.new(aa)
+
+ aa_slice = aa[i, length]
+ iv_slice = iv[i, length]
+ compare_sequences(aa_slice, iv_slice)
+
+ aa_slice = aa.slice(i, length)
+ iv_slice = iv.slice(i, length)
+ compare_sequences(aa_slice, iv_slice)
+end
+
+def check_range(i, j)
+ aa = [1,2,3,4]
+ iv = IntVector.new(aa)
+
+ aa_range = aa[i..j]
+ iv_range = iv[i..j]
+ compare_sequences(aa_range, iv_range)
+
+ aa_range = aa[Range.new(i, j, true)]
+ iv_range = iv[Range.new(i, j, true)]
+ compare_sequences(aa_range, iv_range)
+end
+
+def set_slice(i, length, expect_nil_expanded_elements)
+ aa = [1,2,3,4]
+ iv = IntVector.new(aa)
+ aa_new = [8, 9]
+ iv_new = IntVector.new(aa_new)
+
+ aa[i, length] = aa_new
+ iv[i, length] = iv_new
+ if expect_nil_expanded_elements
+ compare_expanded_sequences(aa, iv)
+ else
+ compare_sequences(aa, iv)
+ end
+end
+
+for i in -5..5
+ for length in -5..5
+ check_slice(i, length)
+ end
+end
+
+for i in -5..5
+ for j in -5..5
+ check_range(i, j)
+ end
+end
+
+for i in -4..4
+ for length in 0..4
+ set_slice(i, length, false)
+ end
+end
+
+for i in [5, 6]
+ for length in 0..5
+ set_slice(i, length, true)
+ end
+end
+
dv = DoubleVector.new(10)
--- /dev/null
+#!/usr/bin/env ruby
+#
+# Put description here
+#
+#
+#
+#
+#
+
+require 'swig_assert'
+
+require 'overload_bool'
+
+include Overload_bool
+
+# Overloading bool, int, string
+if overloaded(true) != "bool"
+ raise RuntimeError, "wrong!"
+end
+if overloaded(false) != "bool"
+ raise RuntimeError, "wrong!"
+end
+
+if overloaded(0) != "int"
+ raise RuntimeError, "wrong!"
+end
+if overloaded(1) != "int"
+ raise RuntimeError, "wrong!"
+end
+if overloaded(2) != "int"
+ raise RuntimeError, "wrong!"
+end
+
+if overloaded("1234") != "string"
+ raise RuntimeError, "wrong!"
+end
+
+# Test bool masquerading as integer
+# Not possible
+
+# Test int masquerading as bool
+if boolfunction(0) != "false"
+ raise RuntimeError, "wrong!"
+end
+if boolfunction(1) != "true"
+ raise RuntimeError, "wrong!"
+end
+if boolfunction(2) != "true"
+ raise RuntimeError, "wrong!"
+end
+
+#############################################
+
+# Overloading bool, int, string
+if overloaded_ref(true) != "bool"
+ raise RuntimeError, "wrong!"
+end
+if overloaded_ref(false) != "bool"
+ raise RuntimeError, "wrong!"
+end
+
+if overloaded_ref(0) != "int"
+ raise RuntimeError, "wrong!"
+end
+if overloaded_ref(1) != "int"
+ raise RuntimeError, "wrong!"
+end
+if overloaded_ref(2) != "int"
+ raise RuntimeError, "wrong!"
+end
+
+if overloaded_ref("1234") != "string"
+ raise RuntimeError, "wrong!"
+end
+
+# Test bool masquerading as integer
+# Not possible
+
+# Test int masquerading as bool
+if boolfunction_ref(0) != "false"
+ raise RuntimeError, "wrong!"
+end
+if boolfunction_ref(1) != "true"
+ raise RuntimeError, "wrong!"
+end
+if boolfunction_ref(2) != "true"
+ raise RuntimeError, "wrong!"
+end
--- /dev/null
+#!/usr/bin/env ruby
+#
+# Put description here
+#
+#
+#
+#
+#
+
+require 'swig_assert'
+
+require 'overload_extend2'
+
+f = Overload_extend2::Foo.new
+
+raise RuntimeError if f.test(3) != 1
+raise RuntimeError if f.test("hello") != 2
+raise RuntimeError if f.test(3.5,2.5) != 3
require 'swig_assert'
-require 'overload_extend'
+require 'overload_extend_c'
-f = Overload_extend::Foo.new
+f = Overload_extend_c::Foo.new
raise RuntimeError if f.test(3) != 1
raise RuntimeError if f.test("hello") != 2
raise RuntimeError if f.test(3.5,2.5) != 6
+
--- /dev/null
+#!/usr/bin/env ruby
+#
+# The Subversion bindings use this manually written proxy class approach
+# to the Ruby bindings. Note that in C the struct svn_fs_t is an
+# opaque pointer and the Ruby FileSystem proxy class is hand written around it.
+# This testcase tests this and the C close function and subsequent error
+# handling.
+
+require 'swig_assert'
+require 'ruby_manual_proxy'
+
+module Svn
+ module Fs
+ module_function
+ def create(path)
+ f = Ruby_manual_proxy::svn_fs_create(path)
+ return f
+ end
+
+ FileSystem = SWIG::TYPE_p_svn_fs_t
+ class FileSystem
+ class << self
+ def create(*args)
+ Fs.create(*args)
+ end
+ end
+ def path
+ Ruby_manual_proxy::svn_fs_path(self)
+ end
+ end
+ end
+end
+
+f = Svn::Fs::FileSystem.create("/tmp/myfile")
+path = f.path
+f.close
+begin
+ # regression in swig-3.0.8 meant ObjectPreviouslyDeleted error was thrown instead
+ path = f.path
+ raise RuntimeError.new("IOError (1) not thrown")
+rescue IOError
+end
+
+file = nil
+begin
+ path = Ruby_manual_proxy::svn_fs_path(file)
+ raise RuntimeError.new("IOError (2) not thrown")
+rescue IOError
+end
--- /dev/null
+#!/usr/bin/env ruby
+#
+# Put description here
+#
+#
+#
+#
+#
+
+require 'ruby_minherit_shared_ptr'
+
+md = Ruby_minherit_shared_ptr::MultiDerived.new(11, 22)
+
+if md.Base1Func != 11 then
+ raise RuntimeError
+end
+if md.Interface1Func != 22 then
+ raise RuntimeError
+end
+if Ruby_minherit_shared_ptr.BaseCheck(md) != 11 then
+ raise RuntimeError
+end
+if Ruby_minherit_shared_ptr.InterfaceCheck(md) != 22 then
+ raise RuntimeError
+end
+if Ruby_minherit_shared_ptr.DerivedCheck(md) != 33 then
+ raise RuntimeError
+end
# msg - optional additional message to print
#
def swig_assert_equal( a, b, scope = nil, msg = nil )
+ a = 'nil' if a == nil
+ b = 'nil' if b == nil
begin
check = "#{a} == #{b}"
if scope.kind_of? Binding
--- /dev/null
+%module ruby_manual_proxy
+
+
+%typemap(in, numinputs=0) SWIGTYPE ** ($*1_ltype temp) "$1 = &temp;";
+
+%typemap(argout) SWIGTYPE **OUTPARAM {
+ $result = SWIG_Ruby_AppendOutput($result, SWIG_NewPointerObj(*$1, $*1_descriptor, 0));
+}
+
+%apply SWIGTYPE **OUTPARAM {
+ svn_fs_t **
+};
+
+%typemap(check) svn_fs_t * {
+ if (!$1) {
+ svn_swig_rb_raise_svn_fs_already_close();
+ }
+}
+
+%{
+typedef struct svn_fs_t {
+ char path[256];
+} svn_fs_t;
+
+void svn_fs_create(svn_fs_t **fs_p, const char *path) {
+ svn_fs_t *fs = (svn_fs_t *)malloc(sizeof(svn_fs_t));
+ strncpy(fs->path, path, 256);
+ *fs_p = fs;
+}
+const char *svn_fs_path(svn_fs_t *fs) {
+ return fs->path;
+}
+%}
+
+typedef struct svn_fs_t svn_fs_t;
+void svn_fs_create(svn_fs_t **fs_p, const char *path);
+const char *svn_fs_path(svn_fs_t *fs);
+
+%{
+static void svn_swig_rb_raise_svn_fs_already_close(void) {
+ rb_raise(rb_eIOError, "already closed");
+}
+
+static VALUE svn_fs_swig_rb_close(VALUE self) {
+ if (!DATA_PTR(self)) {
+ svn_swig_rb_raise_svn_fs_already_close();
+ }
+
+ DATA_PTR(self) = NULL;
+
+ return Qnil;
+}
+
+static VALUE svn_fs_swig_rb_closed(VALUE self) {
+ return DATA_PTR(self) ? Qfalse : Qtrue;
+}
+%}
+
+%insert("init") %{
+ {
+ VALUE cSvnfs;
+ cSvnfs = rb_const_get(_mSWIG, rb_intern("TYPE_p_svn_fs_t"));
+ rb_define_method(cSvnfs, "close",
+ VALUEFUNC(svn_fs_swig_rb_close), 0);
+ }
+%}
--- /dev/null
+// Test ruby_minherit (multiple inheritance support) and shared_ptr
+%module(ruby_minherit="1") ruby_minherit_shared_ptr
+
+%include <boost_shared_ptr.i>
+%shared_ptr(Interface1)
+%shared_ptr(Base1)
+%shared_ptr(MultiDerived)
+
+%inline %{
+#include <boost/shared_ptr.hpp>
+class Interface1 {
+public:
+ virtual int Interface1Func() const = 0;
+};
+
+class Base1 {
+ int val;
+public:
+ Base1(int a = 0) : val(a) {}
+ virtual int Base1Func() const { return val; }
+};
+
+class MultiDerived : public Base1, public Interface1 {
+ int multi;
+public:
+ MultiDerived(int v1, int v2) : Base1(v1), multi(v2) {}
+ virtual int Interface1Func() const { return multi; }
+};
+
+int BaseCheck(const Base1& b) {
+ return b.Base1Func();
+}
+int InterfaceCheck(const Interface1& i) {
+ return i.Interface1Func();
+}
+int DerivedCheck(const MultiDerived& m) {
+ return m.Interface1Func() + m.Base1Func();
+}
+%}
(check-range signed-int-identity signed-int-min signed-int-max)
(check-range unsigned-int-identity 0 unsigned-int-max)
(check-range signed-long-identity signed-long-min signed-long-max)
- (check-range unsigned-long-identity 0 unsigned-long-max)
- ;;; long long not implemented in Guile and MzScheme.
(check-range signed-long-long-identity signed-long-long-min signed-long-long-max)
- (check-range unsigned-long-long-identity 0 unsigned-long-long-max)
+
+ ;;; unsigned (long) long is broken in guile 1.8 on Mac OS X, skip test
+ (if (or (>= (string->number (major-version)) 2)
+ (not (equal? (utsname:sysname (uname)) "Darwin")))
+ (begin
+ (check-range unsigned-long-identity 0 unsigned-long-max)
+ (check-range unsigned-long-long-identity 0 unsigned-long-long-max))
+ )
+
)
(exit 0)
--- /dev/null
+(define f (new-Foo))
+
+(if (not (= (Foo-test f 3) 1))
+ (error "test integer bad"))
+
+(if (not (= (Foo-test f "hello") 2))
+ (error "test string bad"))
+
+(if (not (= (Foo-test f 3.5 2.5) 6.0))
+ (error "test reals bad"))
+
+(exit 0)
--- /dev/null
+#######################################################################
+# Makefile for scilab test-suite
+#######################################################################
+
+LANGUAGE = scilab
+SCILAB = @SCILAB@
+SCILAB_OPT = @SCILABOPT@
+SCRIPTSUFFIX = _runme.sci
+
+srcdir = @srcdir@
+top_srcdir = ../@top_srcdir@
+top_builddir = ../@top_builddir@
+
+C_TEST_CASES += \
+ scilab_consts \
+ scilab_enums \
+ scilab_identifier_name \
+
+CPP_TEST_CASES += \
+ inout \
+ primitive_types \
+ scilab_li_matrix \
+ scilab_multivalue \
+ scilab_pointer_conversion_functions \
+
+CPP_STD_TEST_CASES += \
+ li_std_container_typemaps \
+ li_std_string_extra \
+
+include $(srcdir)/../common.mk
+
+# Overriden variables
+SRCDIR = ../$(srcdir)/
+
+# Local variables
+TEST_DIR = $*.dir
+RUNME_SCRIPT = $(SCRIPTPREFIX)$*$(SCRIPTSUFFIX)
+SRC_RUNME_SCRIPT = $(srcdir)/$(RUNME_SCRIPT)
+
+# Hide too long identifier warnings
+SWIGOPT += -w720
+
+# Rules for the different types of tests
+%.cpptest:
+ $(setup)
+ +(cd $(TEST_DIR) && $(swig_and_compile_cpp))
+ cd $(TEST_DIR) && $(run_testcase)
+
+%.ctest:
+ $(setup)
+ +(cd $(TEST_DIR) && $(swig_and_compile_c))
+ cd $(TEST_DIR) && $(run_testcase)
+
+%.multicpptest:
+ $(setup)
+ +(cd $(TEST_DIR) && $(swig_and_compile_multi_cpp))
+ cd $(TEST_DIR) && $(run_testcase)
+
+# Copies files and creates directories needed for the test case
+setup = \
+ if [ ! -d $(TEST_DIR) ]; then \
+ mkdir $(TEST_DIR); \
+ fi; \
+ if [ -f $(SRC_RUNME_SCRIPT) ]; then \
+ echo "$(ACTION)ing $(LANGUAGE) testcase $* (with run test)" ; \
+ if [ ! -f $(TEST_DIR) ]; then \
+ cp $(SRC_RUNME_SCRIPT) $(TEST_DIR); \
+ fi; \
+ if [ ! -f $(TEST_DIR)/swigtest.start ]; then \
+ cp $(srcdir)/swigtest.start $(TEST_DIR); \
+ fi; \
+ if [ ! -f $(TEST_DIR)/swigtest.quit ]; then \
+ cp $(srcdir)/swigtest.quit $(TEST_DIR); \
+ fi; \
+ else \
+ echo "$(ACTION)ing $(LANGUAGE) testcase $*" ; \
+ fi; \
+
+# Runs the testcase. A testcase is only run if
+# a file is found which has _runme.sci appended after the testcase name.
+run_testcase = \
+ if [ -f $(RUNME_SCRIPT) ]; then ( \
+ env LD_LIBRARY_PATH=$(srcdir):$$LD_LIBRARY_PATH $(RUNTOOL) $(SCILAB) $(SCILAB_OPT) -f $(RUNME_SCRIPT); ) \
+ fi
+
+# Clean: remove the generated files
+%.clean:
+ @rm -rf $(TEST_DIR)
+
+clean:
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ D = new_D();
+catch
+ swigtesterror();
+end
+if A_do_x(D) <> 1 then swigtesterror(); end
+
+try
+ delete_D(D);
+catch
+ swigtesterror();
+end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ Spam = new_Spam()
+catch
+ swigtesterror();
+end
+
+if Foo_blah(Spam)<>0 then swigtesterror; end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ // This call must fail because the constructor does not exist
+ Spam = new_Spam()
+ swigtesterror();
+catch
+end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+// These calls must fail
+ierr = execstr('abstract_foo_meth(1)', 'errcatch');
+if ierr == 0 then swigtesterror(); end
+
+ierr = execstr('abstract_bar_meth(1)', 'errcatch');
+if ierr == 0 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ a = new_A_UF();
+catch
+ swigtesterror();
+end
+
+try
+ delete_A_UF(a);
+catch
+ swigtesterror();
+end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ e = new_Engine();
+catch
+ swigtesterror();
+end
+
+try
+ a = new_A();
+catch
+ swigtesterror();
+end
+
+// TODO: test write method
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ d = new_D();
+catch
+ swigtesterror();
+end
+
+try
+ delete_D(d);
+catch
+ swigtesterror();
+end
+
+try
+ e = new_E();
+catch
+ swigtesterror();
+end
+
+try
+ delete_E(e);
+catch
+ swigtesterror();
+end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ baseInt = new_BaseInt();
+catch
+ swigtesterror();
+end
+
+try
+ delete_BaseInt(baseInt);
+catch
+ swigtesterror();
+end
+
+try
+ derivedInt = new_DerivedInt();
+catch
+ swigtesterror();
+end
+
+try
+ delete_DerivedInt(derivedInt);
+catch
+ swigtesterror();
+end
+
+try
+ bottomInt = new_BottomInt();
+catch
+ swigtesterror();
+end
+
+try
+ delete_BottomInt(bottomInt);
+catch
+ swigtesterror();
+end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ foo = new_Foo();
+catch
+ swigtesterror();
+end
+
+try
+ foo2 = Foo_blah(foo);
+catch
+ swigtesterror();
+end
+
+try
+ delete_Foo(foo);
+catch
+ swigtesterror();
+end
+
+try
+ delete_Foo(foo2);
+catch
+ swigtesterror();
+end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+if UP_get()<>1 then swigtesterror(); end
+if typeof(UP_get())<>"constant" then pause; end
+
+if DOWN_get()<>2 then swigtesterror(); end
+if typeof(DOWN_get())<>"constant" then pause; end
+
+if LEFT_get()<>3 then swigtesterror(); end
+if typeof(LEFT_get())<>"constant" then pause; end
+
+if RIGHT_get()<>4 then swigtesterror(); end
+if typeof(RIGHT_get())<>"constant" then pause; end
+
+// TODO: move is a Scilab function...
+//result = move(UP_get());
+//result = move(DOWN_get());
+//result = move(LEFT_get());
+//result = move(RIGHT_get());
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+// TODO: add tests here
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+// Class Klass
+try
+ klass = new_Klass("allprotected_klass")
+catch
+ swigtesterror(lasterror());
+end
+
+checkequal(Klass_getName(klass), "allprotected_klass", "Klass_getName(new_Klass(""allprotected_klass""))");
+
+// Class PubBase
+try
+ pubBase = new_PubBase("allprotected_PubBase");
+catch
+ swigtesterror(lasterror());
+end
+
+checkequal(PubBase_virtualMethod(pubBase), "PublicBase", "PubBase_virtualMethod(pubBase)");
+
+class = PubBase_instanceMethod(pubBase, klass);
+checkequal(Klass_getName(class), "allprotected_klass", "Klass_getName(PubBase_instanceMethod(pubBase, klass))");
+
+class = PubBase_instanceOverload(pubBase, klass);
+checkequal(Klass_getName(class), "allprotected_klass", "Klass_getName(PubBase_instanceOverloaded(pubBase, klass))");
+
+class = PubBase_instanceOverload(pubBase, klass, "allprotected_klass2");
+checkequal(Klass_getName(class), "allprotected_klass2", "Klass_getName(PubBase_instanceOverloaded(pubBase, klass, ""allprotected_klass2""))");
+
+class = PubBase_staticMethod(klass);
+checkequal(Klass_getName(class), "allprotected_klass", "Klass_getName(PubBase_staticMethod(klass))");
+
+class = PubBase_staticOverloaded(klass);
+checkequal(Klass_getName(class), "allprotected_klass", "Klass_getName(PubBase_staticOverloaded(klass))");
+
+
+class = PubBase_staticOverloaded(klass, "allprotected_klass3");
+checkequal(Klass_getName(class), "allprotected_klass3", "Klass_getName(PubBase_staticOverloaded(klass, ""allprotected_klass3""))");
+
+checkequal(PubBase_EnumVal1_get(), 0, "PubBase_EnumVal1_get()");
+checkequal(PubBase_EnumVal2_get(), 1, "(PubBase_EnumVal2_get()");
+
+
+PubBase_instanceMemb_set(pubBase, 12);
+checkequal(PubBase_instanceMemb_get(pubBase), 12, "PubBase_instanceMemb_get(pubBase)");
+
+checkequal(PubBase_staticConstM_get(), 20, "PubBase_staticConstM_get()");
+checkequal(PubBase_staticMember_get(), 10, "PubBase_staticMember_get()")
+
+PubBase_stringMember_set(pubBase, "dummy");
+checkequal(PubBase_stringMember_get(pubBase), "dummy", "PubBase_stringMember_get()");
+
+// TODO does not work (wrong ENUM mapping?)
+//PubBase_anEnum_get(PubBase)
+//PubBase_anEnum_set(PubBase, ???)
+
+
+// Class ProcBase
+try
+// Constructor is propected and must not be defined here
+ ProcBase = new_ProctectedBase("allprotected_ProcBase");
+ swigtesterror();
+catch
+end
+
+checkequal(ProcBase_EnumVal1_get(), 0, "ProcBase_EnumVal1_get()");
+checkequal(ProcBase_EnumVal2_get(), 1, "ProcBase_EnumVal2_get()");
+
+try
+ delete_Klass(klass);
+catch
+ swigtesterror();
+end
+try
+ delete_PubBase(pubBase);
+catch
+ swigtesterror();
+end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ foo = new_Foo();
+catch
+ swigtesterror();
+end
+
+checkequal(Foo_x_get(foo), 0, "Foo_x_get()");
+
+checkequal(Foo_y_get(foo), 0, "Foo_y_get()");
+
+checkequal(Foo_z_get(foo), 0, "Foo_y_get()");
+
+checkequal(Foo_f_get(foo), 0, "Foo_f_get()");
+
+checkequal(Foo_seq_get(foo), 0, "Foo_seq_get()");
+
+try
+ Foo_x_set(foo, 5);
+catch
+ swigtesterror();
+end
+checkequal(Foo_x_get(foo), 5, "Foo_x_get()");
+
+try
+ Foo_y_set(foo, 5);
+catch
+ swigtesterror();
+end
+checkequal(Foo_y_get(foo), 5, "Foo_y_get()");
+
+try
+ Foo_f_set(foo, 1);
+catch
+ swigtesterror();
+end
+checkequal(Foo_f_get(foo), 1, "Foo_f_get()");
+
+try
+ Foo_z_set(foo, 13);
+catch
+ swigtesterror();
+end
+checkequal(Foo_z_get(foo), 13, "Foo_z_get()");
+
+try
+ Foo_seq_set(foo, 3);
+catch
+ swigtesterror();
+end
+checkequal(Foo_seq_get(foo), 3, "Foo_seq_get()");
+
+try
+ delete_Foo(foo);
+catch
+ swigtesterror();
+end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+smallnum = -127;
+checkequal(CharValFunction(smallnum), smallnum, "CharValFunction(smallnum)");
+checkequal(CCharValFunction(smallnum), smallnum, "CCharValFunction(smallnum)");
+checkequal(CCharRefFunction(smallnum), smallnum, "CCharRefFunction(smallnum)");
+
+try
+ globalchar_set(smallnum);
+catch
+ swigtesterror();
+end
+checkequal(globalchar_get(), smallnum, "globalchar_get()");
+checkequal(globalconstchar_get(), -110, "globalconstchar_get()");
+
+try
+ dirTest = new_DirTest();
+catch
+ swigtesterror();
+end
+
+checkequal(DirTest_CharValFunction(dirTest, smallnum), smallnum, "DirTest_CharValFunction(dirTest, smallnum)");
+checkequal(DirTest_CCharValFunction(dirTest, smallnum), smallnum, "DirTest_CCharValFunction(dirTest, smallnum)");
+checkequal(DirTest_CCharRefFunction(dirTest, smallnum), smallnum, "DirTest_CCharRefFunction(dirTest, smallnum)");
+
+// TODO Too long identifiers
+//if dirTest_memberchar_get(dirTest) <> -111 then swigtesterror(); end
+//try
+// dirTest_memberchar_set(dirTest, smallnum)
+//catch
+// swigtesterror();
+//end
+//if dirTest_memberchar_get(dirTest) <> smallnum then swigtesterror(); end
+
+//if dirTest_memberconstchar_get(dirTest) <> -112 then swigtesterror(); end
+
+try
+ delete_DirTest(dirTest);
+catch
+ swigtesterror();
+end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+testString = "Scilab test string";
+
+checkequal(UCharFunction(testString), testString, "UCharFunction(testString)");
+checkequal(SCharFunction(testString), testString, "SCharFunction(testString)");
+checkequal(CUCharFunction(testString), testString, "CUCharFunction(testString)");
+checkequal(CSCharFunction(testString), testString, "CSCharFunction(testString)");
+//checkequal(CharFunction(testString), testString, "CharFunction(testString)");
+//checkequal(CCharFunction(testString), testString, "CCharFunction(testString)");
+
+try
+ tNum = new_TNum();
+catch
+ swigtesterror();
+end
+//TNumber_DigitsMemberA_get()
+//TNumber_DigitsMemberA_set
+//TNumber_DigitsMemberB_get()
+//TNumber_DigitsMemberB_set
+try
+ delete_TNum(tNum);
+catch
+ swigtesterror();
+end
+
+try
+ dirTest = new_DirTest();
+catch
+ swigtesterror();
+end
+
+checkequal(DirTest_UCharFunction(dirTest, testString), testString, "DirTest_UCharFunction");
+checkequal(DirTest_SCharFunction(dirTest, testString), testString, "DirTest_SCharFunction(dirTest, testString)");
+checkequal(DirTest_CUCharFunction(dirTest, testString), testString, "DirTest_CUCharFunction(dirTest, testString)");
+checkequal(DirTest_CSCharFunction(dirTest, testString), testString, "DirTest_CSharFunction(dirTest, testString)");
+//checkequal(DirTest_CharFunction(dirTest, testString), testString, "DirTest_CharFunction(dirTest, testString)");
+//checkequal(DirTest_CCharFunction(dirTest, testString), testString, "DirTest_CCharFunction(dirTest, testString)");
+try
+ delete_DirTest(dirTest);
+catch
+ swigtesterror();
+end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+f = new_Foo();
+Foo_data_set(f, [0:7]);
+checkequal(Foo_data_get(f), [0:7], "Foo_data_get()");
+
+Foo_text_set(f, "abcdefgh");
+checkequal(Foo_text_get(f), "abcdefgh", "Foo_text_get()");
+delete_Foo(f);
+
+m = new_MyBuff();
+MyBuff_x_set(m, [0:11]);
+checkequal(MyBuff_x_get(m), [0:11], "MyBuff_x_get()");
+delete_MyBuff(m);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+// bool
+checkequal(arr_bool([%T %F %F %T %F %T %T %T], 8), 5, "arr_bool");
+
+// char
+checkequal(arr_char(["charptr"], 7), 756, "arr_char");
+
+// signed char
+checkequal(arr_schar([1, 2, 3, 4], 4), 10, "arr_schar");
+checkequal(arr_schar(int8([1, 2, 3, 4]), 4), 10, "arr_schar");
+
+// unsigned char
+checkequal(arr_uchar([1, 2, 3, 4], 4), 10, "arr_uchar");
+checkequal(arr_uchar(uint8([1, 2, 3, 4]), 4), 10, "arr_uchar");
+
+// short
+checkequal(arr_short([1, 2, 3, 4], 4), 10, "arr_short");
+checkequal(arr_short(int16([1, 2, 3, 4]), 4), 10, "arr_short");
+
+// unsigned short
+checkequal(arr_ushort([1, 2, 3, 4], 4), 10, "arr_ushort");
+checkequal(arr_ushort(uint16([1, 2, 3, 4]), 4), 10, "arr_ushort");
+
+// int
+checkequal(arr_int([1, 2, 3, 4], 4), 10, "arr_int");
+checkequal(arr_int(int32([1, 2, 3, 4]), 4), 10, "arr_int");
+
+// unsigned int
+checkequal(arr_uint([1, 2, 3, 4], 4), 10, "");
+checkequal(arr_uint(uint32([1, 2, 3, 4]), 4), 10, "");
+
+// long
+checkequal(arr_long([1, 2, 3, 4], 4), 10, "arr_long");
+checkequal(arr_long(int32([1, 2, 3, 4]), 4), 10, "arr_long");
+
+// unsigned long
+checkequal(arr_ulong([1, 2, 3, 4], 4), 10, "arr_ulong");
+checkequal(arr_ulong(uint32([1, 2, 3, 4]), 4), 10, "arr_ulong");
+
+// long long
+// No equivalent in Scilab 5
+
+// unsigned long long
+// No equivalent in Scilab 5
+
+// float
+a = [1, 2, 3, 4];
+checkequal(arr_float(a, 4), 10, "arr_float");
+
+// double
+a = [1, 2, 3, 4];
+checkequal(arr_double(a, 4), 10, "arr_double");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+function testArray(arrayName, arraySetFunc, arrayGetFunc, in_values, ..
+ expected_out_values)
+ try
+ arraySetFunc(in_values);
+ catch
+ swigtesterror("error in " + arrayName + "_set()");
+ end
+ try
+ checkequal(arrayGetFunc(), expected_out_values, arrayName + "_get()");
+ catch
+ swigtesterror("error in " + arrayName + "_get()");
+ end
+endfunction
+
+m = [-10, 20];
+um = [10, 20];
+testArray("array_c", array_c_set, array_c_get, ['ab'], ['ab']);
+testArray("array_sc", array_sc_set, array_sc_get, m, m);
+testArray("array_sc", array_sc_set, array_sc_get, int8(m), m);
+testArray("array_uc", array_uc_set, array_uc_get, uint8(um), um);
+testArray("array_s", array_s_set, array_s_get, m, m);
+testArray("array_s", array_s_set, array_s_get, int16(m), m);
+testArray("array_us", array_us_set, array_us_get, uint16(um), um);
+testArray("array_i", array_i_set, array_i_get, m, m);
+testArray("array_i", array_i_set, array_i_get, int32(m), m);
+testArray("array_ui", array_ui_set, array_ui_get, uint32(um), um);
+testArray("array_l", array_l_set, array_l_get, m, m);
+testArray("array_l", array_l_set, array_l_get, int32(m), m);
+testArray("array_ul", array_ul_set, array_ul_get, uint32(um), um);
+testArray("array_f", array_f_set, array_f_get, [-2.5, 2.5], [-2.5, 2.5]);
+testArray("array_d", array_d_set, array_d_get, [-10.5, 20.4], [-10.5, 20.4]);
+
+checkequal(array_const_i_get(), [10, 20], "array_const_i_get()");
+
+ierr = execstr('array_i_set([0:10]', 'errcatch');
+if ierr == 0 then swigtesterror("Overflow error expected"); end
+
+checkequal(BeginString_FIX44a_get(), "FIX.a.a", "BeginString_FIX44a_get()");
+checkequal(BeginString_FIX44b_get(), "FIX.b.b", "BeginString_FIX44b_get()");
+checkequal(BeginString_FIX44c_get(), "FIX.c.c", "BeginString_FIX44c_get()");
+checkequal(BeginString_FIX44d_get(), "FIX.d.d", "BeginString_FIX44d_get()");
+BeginString_FIX44b_set(strcat(["12","\0","45"]));
+checkequal(BeginString_FIX44b_get(), "12\045", "BeginString_FIX44b_get()");
+checkequal(BeginString_FIX44d_get(), "FIX.d.d", "BeginString_FIX44d_get()");
+checkequal(BeginString_FIX44e_get(), "FIX.e.e", "BeginString_FIX44e_get()");
+checkequal(BeginString_FIX44f_get(), "FIX.f.f", "BeginString_FIX44f_get()");
+
+checkequal(test_a("hello","hi","chello","chi"), "hi", "test_a()");
+
+checkequal(test_b("1234567","hi"), "1234567", "test_b()");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+a = [1, 2, 3, 4; 5, 6, 7, 8;]
+
+//try
+// array_d_set(a);
+//catch
+// swigtesterror();
+//end
+//if array_d_get() <> a then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+function checkBool(bool_val, expected_bool_val)
+ if typeof(bool_val) <> "boolean" then swigtesterror(); end
+ if bool_val <> expected_bool_val then swigtesterror(); end
+endfunction
+
+checkBool(constbool_get(), %f);
+
+checkBool(bool1_get(), %t);
+checkBool(bool2_get(), %f);
+
+checkBool(bo(%t), %t);
+checkBool(bo(%f), %f);
+
+bs = new_BoolSt();
+checkBool(BoolSt_m_bool1_get(bs), %t);
+checkBool(BoolSt_m_bool2_get(bs), %f);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+if CHAR_CONSTANT_get() <> "x" then swigtesterror(); end
+if STRING_CONSTANT_get() <> "xyzzy" then swigtesterror(); end
+if ESC_CONST_get() <> ascii(1) then swigtesterror(); end
+if ia_get() <> ascii('a') then swigtesterror(); end
+if ib_get() <> ascii('b') then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+p = test("test");
+if strcmp(p, "test") <> 0 then swigtesterror(); end
+
+p = test_pconst("test");
+if strcmp(p, "test_pconst") <> 0 then swigtesterror(); end
+
+f = new_Foo();
+p = Foo_test(f, "test");
+if strcmp(p,"test") <> 0 then swigtesterror(); end
+
+p = Foo_test_pconst(f, "test");
+if strcmp(p,"test_pconst") <> 0 then swigtesterror(); end
+
+p = Foo_test_constm(f, "test");
+if strcmp(p,"test_constmethod") <> 0 then swigtesterror(); end
+
+p = Foo_test_pconstm(f, "test");
+if strcmp(p,"test_pconstmethod") <> 0 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+
+f1 = new_Foo1(3);
+f11 = new_Foo1(f1);
+
+checkequal(Foo1_x_get(f1), Foo1_x_get(f11), "Foo1_x_get(f1) <> Foo1_x_get(f11)");
+
+delete_Foo1(f1);
+delete_Foo1(f11);
+
+f8 = new_Foo8();
+try
+ f81 = new_Foo8(f8);
+ swigtesterror("Foo(f8) called.");
+catch
+end
+
+bi = new_Bari(5);
+bc = new_Bari(bi);
+
+checkequal(Bari_x_get(bi), Bari_x_get(bc), "Bar_x_get(bi) <> Bar_x_get(bc)");
+
+delete_Bari(bi);
+delete_Bari(bc);
+
+bd = new_Bard(5);
+try
+ bc = Bard(bd);
+ swigtesterror("Bard(bd) called.");
+catch
+end
+
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+exec("swigtest.start", -1);
+
+f = new_Foo(4);
+checkequal(Foo_num_get(f), 4, "Foo_num_get(f)");
+Foo_num_set(f, -17);
+checkequal(Foo_num_get(f), -17, "Foo_num_get(f)");
+
+b = new_Bar();
+Bar_fptr_set(b, f);
+
+fptr = Bar_fptr_get(b);
+checkequal(Foo_num_get(fptr), -17, "Foo_num_get(ftr)");
+
+checkequal(Bar_test(b, -3, fptr), -5, "Bar_test(b, -3, fptr)");
+
+fref = Bar_fref_get(b);
+checkequal(Foo_num_get(fref), -4, "Foo_num_get(fref)");
+
+checkequal(Bar_test(b, 12, fref), 23, "Bar_test(b, 12, fref)");
+
+f2 = new_Foo(23);
+Bar_fref_set(b, f2);
+
+fref = Bar_fref_get(b);
+checkequal(Foo_num_get(fref), 23, "Foo_num_get(fref)");
+
+fval = Bar_fval_get(b);
+checkequal(Bar_test(b, 3, fval), 33, "Bar_test(b, 3, fval)");
+
+Bar_fval_set(b, new_Foo(-15));
+
+fval = Bar_fval_get(b);
+checkequal(Foo_num_get(fval), -15, "Foo_num_get(fval)");
+checkequal(Bar_test(b, 3, fval), -27, "Bar_test(b, 3, fval)");
+
+f3 = Bar_testFoo(b, 12, fref);
+checkequal(Foo_num_get(f3), 32, "Foo_num_get(f3)");
+
+
+// Test globals
+f4 = new_Foo(6);
+Bar_global_fptr_set(f4);
+checkequal(Foo_num_get(Bar_global_fptr_get()), 6, "Foo_num_get(Bar_global_fptr_get())");
+
+checkequal(Foo_num_get(Bar_global_fref_get()), 23, "Foo_num_get(Bar_global_fref_get())");
+
+checkequal(Foo_num_get(Bar_global_fval_get()), 3, "Foo_num_get(Bar_global_fval_get())");
+
+
+// Test member function pointers
+func1_ptr = get_func1_ptr();
+func2_ptr = get_func2_ptr();
+
+Foo_num_set(f, 4);
+checkequal(Foo_func1(f, 2), 16, "Foo_func1(f, 2)");
+checkequal(Foo_func2(f, 2), -8, "Foo_func2(f, 2)");
+
+Foo_func_ptr_set(f, func1_ptr);
+checkequal(test_func_ptr(f, 2), 16, "Foo_test_func_ptr(f, 2)");
+
+Foo_func_ptr_set(f, func2_ptr);
+checkequal(test_func_ptr(f, 2), -8, "Foo_test_func_ptr(f, 2)");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+f = new_Foo();
+
+if Foo_hola_get(f) <> Hello_get() then swigtesterror("Foo_hola_get() <> ""Hello"""); end
+
+Foo_hola_set(f, Hi_get());
+if Foo_hola_get(f) <> Hi_get() then swigtesterror("Foo_hola_get() <> ""Hi"""); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+checkequal(anonymous(), 7771, "anonymous()");
+checkequal(anonymous(1234), 1234, "anonymous(1234)");
+
+checkequal(booltest(), %T, "booltest()");
+checkequal(booltest(%T), %T, "booltest(%T)");
+checkequal(booltest(%F), %F, "booltest(%T)");
+
+ec = new_EnumClass();
+checkequal(EnumClass_blah(ec), %T, "EnumClass_blah(ec)");
+
+checkequal(casts1(), [], "casts1()");
+checkequal(casts1("Ciao"), "Ciao", "casts1(""Ciao"")");
+checkequal(casts2(), "Hello", "casts2()");
+checkequal(chartest1(), 'x', "chartest1()");
+checkequal(chartest2(), '', "chartest2()");
+checkequal(chartest1('y'), 'y', "chartest1(''y'')");
+checkequal(reftest1(), 42, "reftest1()");
+checkequal(reftest1(400), 400, "reftest1(400)");
+checkequal(reftest2(), "hello", "reftest2()");
+
+// Rename
+f = new_Foo();
+Foo_newname(f);
+Foo_newname(f, 10);
+Foo_renamed3arg(f, 10, 10.0);
+Foo_renamed2arg(f, 10);
+Foo_renamed1arg(f);
+delete_Foo(f);
+
+// Static functions
+checkequal(Statics_staticmethod(), 10+20+30, "Statics_staticmethod()");
+checkequal(Statics_staticmethod(100), 100+20+30, "Statics_staticmethod(100)");
+checkequal(Statics_staticmethod(100, 200, 300), 100+200+300, "Statics_staticmethod(100, 200, 300)");
+
+tricky = new_Tricky();
+checkequal(Tricky_privatedefault(tricky), 200, "Tricky_privatedefault(tricky)");
+checkequal(Tricky_protectedint(tricky), 2000, "Tricky_protectedint(tricky)");
+checkequal(Tricky_protecteddouble(tricky), 987.654, "Tricky_protecteddouble(tricky)");
+checkequal(Tricky_functiondefault(tricky), 500, "Tricky_functiondefault(tricky)");
+checkequal(Tricky_contrived(tricky), 'X', "Tricky_contrived(tricky)");
+delete_Tricky(tricky);
+
+// Default argument is a constructor
+k = constructorcall();
+checkequal(Klass_val_get(k), -1, "Klass_constructorcall()");
+delete_Klass(k);
+k = constructorcall(new_Klass(2222));
+checkequal(Klass_val_get(k), 2222, "Klass_constructorcall(new Klass(2222)");
+delete_Klass(k);
+k = constructorcall(new_Klass());
+checkequal(Klass_val_get(k), -1, "Klass_constructorcall(new_Klass()");
+delete_Klass(k);
+
+// Const methods
+cm = new_ConstMethods();
+checkequal(ConstMethods_coo(cm), 20, "ConstMethods_coo()");
+checkequal(ConstMethods_coo(cm, 1.0), 20, "ConstMethods_coo(1.0)");
+
+// C linkage (extern "C")
+checkequal(cfunc1(1), 2, "cfunc1(1)");
+checkequal(cfunc2(1), 3, "cfunc2(1)");
+checkequal(cfunc3(1), 4, "cfunc3(1)");
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+exec("swigtest.start", -1);
+
+a = new_A();
+delete_A(a);
+
+aa = new_AA();
+delete_AA(aa);
+
+try
+ b = new_B();
+ swigtestswigtesterror("new_BB created.")
+catch
+end
+
+del_b = delete_B;
+
+try
+ bb = new_BB();
+ swigtesterror("new_BB created.")
+catch
+
+end
+
+del_bb = delete_BB;
+
+try
+ c = new_C();
+ swigtesterror("new_C created.")
+catch
+end
+
+del_c = delete_C;
+
+cc = new_CC();
+delete_CC(cc);
+
+try
+ d = new_D();
+ swigtesterror("new_D created")
+catch
+end
+
+del_d = delete_D;
+
+try
+ dd = new_DD();
+ swigtesterror("new_DD created")
+catch
+end
+
+dd = delete_DD;
+
+try
+ ad = new_AD();
+ swigtesterror("new_AD created")
+catch
+end
+
+del_ad = delete_AD;
+
+exec("swigtest.start", -1);
+
+e = new_E();
+delete_E(e);
+
+ee = new_EE();
+delete_EE(ee);
+
+try
+ eb = new_EB();
+ swigtesterror("new_EB created")
+catch
+end
+
+del_eb = delete_EB;
+
+f = new_F();
+
+try
+ del_f = delete_F;
+ swigtesterror("delete_F created")
+catch
+end
+
+F_destroy(f);
+
+g = new_G();
+
+try
+ del_g = delete_G;
+ swigtesterror("delete_G created")
+catch
+end
+
+G_destroy(g);
+
+gg = new_GG();
+delete_GG(gg);
+
+hh = new_HH(1,1);
+
+exec("swigtest.quit", -1);
+
+
--- /dev/null
+exec("swigtest.start", -1);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+if typeof(CSP_ITERATION_FWD_get()) <> "constant" then swigtesterror(); end
+if typeof(CSP_ITERATION_BWD_get()) <> "constant" then swigtesterror(); end
+if typeof(ABCDE_get()) <> "constant" then swigtesterror(); end
+if typeof(FGHJI_get()) <> "constant" then swigtesterror(); end
+
+try
+ bar1(CSP_ITERATION_FWD_get())
+ bar1(CSP_ITERATION_BWD_get())
+ bar1(1)
+ bar1(int32(1))
+
+ bar2(ABCDE_get())
+ bar2(FGHJI_get())
+ bar2(1)
+ bar2(int32(1))
+
+ bar3(ABCDE_get())
+ bar3(FGHJI_get())
+ bar3(1)
+ bar3(int32(1))
+catch
+ swigtesterror()
+end
+
+if typeof(enumInstance_get()) <> "constant" then swigtesterror(); end
+if enumInstance_get() <> 2 then swigtesterror(); end
+
+if typeof(Slap_get()) <> "constant" then swigtesterror(); end
+if Slap_get() <> 10 then swigtesterror(); end
+
+if typeof(Mine_get()) <> "constant" then swigtesterror(); end
+if Mine_get() <> 11 then swigtesterror(); end
+
+if typeof(Thigh_get()) <> "constant" then swigtesterror(); end
+if Thigh_get() <> 12 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+checkequal(call1(ADD_BY_VALUE_get(), 10, 11), 21, "ADD_BY_VALUE");
+checkequal(call2(ADD_BY_POINTER_get(), 12, 13), 25, "ADD_BY_POINTER");
+checkequal(call3(ADD_BY_REFERENCE_get(), 14, 15), 29, "ADD_BY_REFERENCE");
+checkequal(call1(ADD_BY_VALUE_C_get(), 2, 3), 5, "ADD_BY_VALUE_C");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+if add(7, 9) <> 16 then swigtesterror(); end
+if do_op(7, 9, funcvar_get()) <> 16 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+b_set("hello");
+checkequal(b_get(), "hello", "b_get()");
+
+sa = new_A();
+A_x_set(sa, 5);
+checkequal(A_x_get(sa), 5, "A_x_get(sa)");
+
+a_set(sa);
+checkequal(A_x_get(a_get()), 5, "A_x_get(a)");
+
+ap_set(sa);
+A_x_set(sa, 14);
+checkequal(A_x_get(ap_get()), 14, "A_x_get(ap)");
+delete_A(sa);
+
+sa2 = new_A();
+cap_set(sa2);
+A_x_set(sa2, 16);
+checkequal(A_x_get(cap_get()), 16, "A_x_get(cap)");
+
+checkequal(A_x_get(ar_get()), 5, "A_x_get(ar)");
+ar_set(sa2);
+checkequal(A_x_get(ar_get()), 16, "A_x_get(ar)");
+delete_A(sa2);
+
+x_set(11);
+checkequal(x_get(), 11, "x_get()");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ a = new_A();
+catch
+ printf("did not find A\ntherefore, I did not include ""testdir/subdir1/hello.i""\n");
+ swigtesterror();
+end
+
+try
+ b = new_B();
+catch
+ printf("did not find B\ntherefore, I did not include ""testdir/subdir2/hello.i""\n");
+ swigtesterror();
+end
+
+if importtest1(5) <> 15 then swigtesterror(); end
+if importtest2("black") <> "white" then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+a = new_Foo();
+b = new_Bar();
+c = new_Spam();
+
+checkequal(do_blah(a), "Foo::blah", "do_blah(a)");
+checkequal(do_blah(b), "Bar::blah", "do_blah(b)");
+checkequal(do_blah(c), "Spam::blah", "do_blah(c)");
+
+delete_Foo(a);
+delete_Bar(b);
+delete_Spam(c);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+a = AddOne1(10);
+if a <> 11 then swigtesterror(); end
+
+[a, b, c] = AddOne3(1, 2, 3);
+if a <> 2 then swigtesterror(); end
+if b <> 3 then swigtesterror(); end
+if c <> 4 then swigtesterror(); end
+
+a = AddOne1r(20);
+if a <> 21 then swigtesterror(); end
+
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+// Negative values
+checkequal(signed_char_identity(-1), -1, "signed_char_identity(-1)");
+checkequal(signed_short_identity(-1), -1, "signed_short_identity(-1)");
+checkequal(signed_int_identity(-1), -1, "signed_int_identity(-1)");
+checkequal(signed_long_identity(-1), -1, "signed_long_identity(-1)");
+
+// Overflow errors
+ierr = execstr('signed_char_identity(2^8)', 'errcatch');
+checkequal(ierr, 20007, 'signed_char_identity(2^8)');
+ierr = execstr('signed_short_identity(2^16)', 'errcatch');
+checkequal(ierr, 20007, 'signed_short_identity(2^16)');
+ierr = execstr('signed_int_identity(2^32)', 'errcatch');
+checkequal(ierr, 20007, 'signed_int_identity(2^32)');
+ierr = execstr('signed_long_identity(2^64)', 'errcatch');
+checkequal(ierr, 20007, 'signed_long_identity(2^64)');
+
+// Value errors
+ierr = execstr('signed_char_identity(100.2)', 'errcatch');
+checkequal(ierr, 20009, 'signed_char_identity(100.2)');
+ierr = execstr('signed_short_identity(100.2)', 'errcatch');
+checkequal(ierr, 20009, 'signed_short_identity(100.2)');
+ierr = execstr('signed_int_identity(100.2)', 'errcatch');
+checkequal(ierr, 20009, 'signed_int_identity(100.2)');
+ierr = execstr('signed_long_identity(100.2)', 'errcatch');
+checkequal(ierr, 20009, 'signed_long_identity(100.2)');
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+d = new_intArray(10);
+
+intArray_setitem(d, 0, 7);
+
+intArray_setitem(d, 5, intArray_getitem(d, 0) + 3);
+
+checkequal(intArray_getitem(d, 5) + intArray_getitem(d, 0), 17, "d(5) + d(0) <> 17");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+d = new_intArray(10);
+
+intArray_setitem(d, 0, 7);
+
+intArray_setitem(d, 5, intArray_getitem(d, 0) + 3);
+
+checkequal(intArray_getitem(d, 5) + intArray_getitem(d, 0), 17, "d(5) + d(0) <> 17");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+p = new_intp();
+intp_assign(p, 3);
+checkequal(intp_value(p), 3, "intp_value(p)");
+delete_intp(p);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+p = new_intp();
+intp_assign(p, 3);
+checkequal(intp_value(p), 3, "intp_value(p)");
+delete_intp(p);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ x = fmod(M_PI_get(), M_1_PI_get())
+catch
+ swigtesterror();
+end
+
+exec("swigtest.quit", -1);
\ No newline at end of file
--- /dev/null
+// test STL containers typemaps
+
+exec("swigtest.start", -1);
+
+function checkerror(ierr, cmd)
+ if ierr <> 0 then swigtesterror("error " + string(ierr) + " in """ + cmd + """"); end
+endfunction
+
+// test container of pointers returned from fonction (expected a list)
+function [classAPtr_list, classAPtr1, classAPtr2] = testCreateContainerPtr(container, value1, value2)
+ classAPtr1 = new_ClassA(value1);
+ classAPtr2 = new_ClassA(value2);
+ func = msprintf("ret_ClassAPtr_%s", container);
+ cmd = msprintf("classAPtr_list = %s(classAPtr1, classAPtr2);", func);
+ ierr = execstr(cmd, "errcatch");
+ if ierr <> 0 then swigtesterror("error in " + cmd); end
+ if ~exists('classAPtr_list') | (size(classAPtr_list) <> 2) then
+ swigtesterror(func);
+ end
+
+ checkequal(ClassA_a_get(classAPtr_list(1)), value1, "ClassA_a_get(classAPtr_list(1))");
+ checkequal(ClassA_a_get(classAPtr_list(2)), value2, "ClassA_a_get(classAPtr_list(2))");
+endfunction
+
+// test a given container of pointer
+// -container: type of container: "vector", "set"...
+// -value1, value2: values to store in container
+// -expected_accumulate_value: expected value of an accumulation function
+// computed on the container
+function testContainerPtr(container, value1, value2, expected_accumulate_value)
+ // test container of pointers returned from flonction (expected a list)
+ [classAPtr_list, classAPtr1, classAPtr2] = testCreateContainerPtr(container, value1, value2);
+
+ // test container passed as value of function
+ func = msprintf("val_ClassAPtr_%s", container);
+ cmd = msprintf("classAPtr = %s(classAPtr_list);", func);
+ ierr = execstr(cmd, "errcatch");
+ checkerror(ierr, cmd);
+ checkequal(ClassA_a_get(classAPtr), expected_accumulate_value, func);
+
+ // recreate a container
+ [classAPtr_list, classAPtr1, classAPtr2] = testCreateContainerPtr(container, value1, value2);
+
+ // test container passed as reference of function
+ func = msprintf("ref_ClassAPtr_%s", container);
+ cmd = msprintf("classAPtr = %s(classAPtr_list);", func);
+ ierr = execstr(cmd, "errcatch");
+ checkerror(ierr, cmd);
+ checkequal(ClassA_a_get(classAPtr), expected_accumulate_value, func);
+endfunction
+
+// test a given container of a given primitive type
+// -container: type of container: "vector", "set"...
+// -value_type: type of element stored in container: "int", ...
+// -value1, value2: values to store in container
+// -expected_accumulate_value: expected value of an accumulation function
+// computed on the container
+function testContainerType(container, value_type, value1, value2, ..
+ expected_returned_container, expected_accumulate_value)
+ // test container of basic type returned from fonction
+ func = msprintf("ret_%s_%s", value_type, container);
+ if value_type == "string" then
+ cmd = msprintf("c = %s(''%s'', ''%s'');", func, value1, value2);
+ elseif value_type == "bool" then
+ cmd = msprintf("c = %s(%s, %s);", func, "%"+string(value1), "%"+string(value2));
+ else
+ cmd = msprintf("c = %s(%d, %d);", func, value1, value2);
+ end
+ ierr = execstr(cmd, "errcatch");
+ checkerror(ierr, cmd);
+ checkequal(c, expected_returned_container, func);
+
+ // test container passed as value of function
+ func = msprintf("val_%s_%s", value_type, container);
+ cmd = msprintf("s = %s(c);", func);
+ ierr = execstr(cmd, "errcatch");
+ checkerror(ierr, cmd);
+ checkequal(s, expected_accumulate_value, func);
+
+ // test container passed as reference of function
+ func = msprintf("ref_%s_%s", value_type, container);
+ cmd = msprintf("s = %s(c);", func);
+ ierr = execstr(cmd, "errcatch");
+ checkerror(ierr, cmd);
+ checkequal(s, expected_accumulate_value, func);
+endfunction
+
+// test a given container of different types
+// -container: type of container: "vector", "set"...
+function testContainer(container)
+ testContainerType(container, "int", 1, 2, [1, 2], 3);
+ testContainerType(container, "double", 2., 3., [2., 3.], 5.);
+ testContainerType(container, "float", 2., 3., [2., 3.], 5.);
+ testContainerType(container, "string", "a", "b", ["a", "b"], "ab");
+ testContainerType(container, "bool", %F, %T, [%F, %T], %T);
+ testContainerPtr("vector", 1, 3, 4);
+endfunction
+
+
+testContainer("vector");
+testContainer("list");
+testContainer("deque");
+testContainer("set");
+testContainer("multiset");
+
+exec("swigtest.quit", -1);
+
+
--- /dev/null
+exec("swigtest.start", -1);
+
+// Test constructors for std::deque<int>
+intDeque = new_IntDeque();
+intDeque2 = new_IntDeque(3);
+intDeque3 = new_IntDeque(4, 42);
+//intDeque4 = new_IntDeque(intDeque3);
+
+// Test constructors for std::deque<double>
+doubleDeque = new_DoubleDeque();
+doubleDeque2 = new_DoubleDeque(3);
+doubleDeque3 = new_DoubleDeque(4, 42.0);
+//doubleDeque4 = new_DoubleDeque(doubleDeque3);
+
+// Test constructors for std::deque<Real>
+realDeque = new_RealDeque();
+realDeque2 = new_RealDeque(3);
+realDeque3 = new_RealDeque(4, 42.0);
+//realDeque4 = new_RealDeque(realDeque3);
+
+// average() should return the average of all values in a std::deque<int>
+IntDeque_push_back(intDeque, 2);
+IntDeque_push_back(intDeque, 4);
+IntDeque_push_back(intDeque, 6);
+avg = average(intDeque);
+checkequal(avg, 4.0, "average(intDeque)");
+
+// half shoud return a deque with elements half of the input elements
+RealDeque_clear(realDeque);
+RealDeque_push_front(realDeque, 2.0);
+RealDeque_push_front(realDeque, 4.0);
+halfDeque = half(realDeque);
+checkequal(halfDeque, [2., 1.], "half(realDeque)");
+
+// same for halve_in_place
+//DoubleDeque_clear(doubleDeque);
+//DoubleDeque_push_front(doubleDeque, 2.0);
+//DoubleDeque_push_front(doubleDeque, 4.0);
+//halfDeque2 = halve_in_place(doubleDeque);
+//checkequal(halfDeque2, [2., 1.], "halve_in_place(doubleDeque)");
+
+delete_IntDeque(intDeque);
+delete_DoubleDeque(doubleDeque);
+delete_RealDeque(realDeque);
+
+exec("swigtest.quit", -1);
+
+
+
--- /dev/null
+exec('swigtest.start', -1);
+
+function checkException(cmd, expected_ierr, expected_error_msg)
+ ierr = execstr(cmd, 'errcatch');
+ checkequal(ierr, expected_ierr, cmd + ': ierr');
+ checkequal(lasterror(), 'SWIG/Scilab: ' + expected_error_msg, cmd + ': msg');
+endfunction
+
+t = new_Test();
+
+checkException('Test_throw_bad_exception(t)', 20010, 'SystemError: std::bad_exception');
+
+checkException('Test_throw_domain_error(t)', 20009, 'ValueError: oops');
+
+checkException('Test_throw_exception(t)', 20010, 'SystemError: std::exception');
+
+checkException('Test_throw_invalid_argum(t)', 20009, 'ValueError: oops');
+
+checkException('Test_throw_length_error(t)', 20004, 'IndexError: oops');
+
+checkException('Test_throw_logic_error(t)', 20003, 'RuntimeError: oops');
+
+checkException('Test_throw_out_of_range(t)', 20004, 'IndexError: oops');
+
+checkException('Test_throw_overflow_erro(t)', 20007, 'OverflowError: oops');
+
+checkException('Test_throw_range_error(t)', 20007, 'OverflowError: oops');
+
+checkException('Test_throw_runtime_error(t)', 20003, 'RuntimeError: oops');
+
+delete_Test(t);
+
+exec('swigtest.quit', -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+function checkPair(pair, expected_first, expected_second, func)
+ checkequal(IntPair_first_get(pair), expected_first, func + ": first");;
+ checkequal(IntPair_second_get(pair), expected_second, func + ": second");;
+endfunction
+
+intPair = makeIntPair(7, 6);
+checkPair(intPair, 7, 6, "makeIntPair()");
+
+intPairPtr = makeIntPairPtr(7, 6);
+checkPair(intPairPtr, 7, 6, "makeIntPairPtr()");
+
+intPairRef = makeIntPairRef(7, 6);
+checkPair(intPairRef, 7, 6, "makeIntPairRef()");
+
+intPairConstRef = makeIntPairConstRef(7, 6);
+checkPair(intPairConstRef, 7, 6, "makeIntPairConstRef()");
+
+// call fns
+checkequal(product1(intPair), 42, "product1(intPair)");
+checkequal(product2(intPair), 42, "product2(intPair)");
+checkequal(product3(intPair), 42, "product3(intPair)")
+
+// also use the pointer version
+checkequal(product1(intPairPtr), 42, "product1(intPairPtr)");
+checkequal(product2(intPairPtr), 42, "product2(intPairPtr)");
+checkequal(product3(intPairPtr), 42, "product3(intPairPtr)");
+
+// or the other types
+checkequal(product1(intPairRef), 42, "product1(intPairRef)");
+checkequal(product2(intPairRef), 42, "product2(intPairRef)");
+checkequal(product3(intPairRef), 42, "product3(intPairRef)");
+checkequal(product1(intPairConstRef), 42, "product3(intPairConstRef)");
+checkequal(product2(intPairConstRef), 42, "product2(intPairConstRef)");
+checkequal(product3(intPairConstRef), 42, "product1(intPairConstRef)");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+x = "hello";
+
+// li_std_string tests
+
+// Function tests
+
+checkequal(test_ccvalue(x), x, "test_ccvalue()");
+checkequal(test_cvalue(x), x, "test_cvalue(x)");
+checkequal(test_value(x), x, "test_value()");
+
+checkequal(test_const_reference(x), x, "test_const_reference(x)");
+checkequal(test_reference_input(x), x, "test_reference_input(x)");
+checkequal(test_reference_inout(x), x+x, "test_reference_inout(x)");
+
+//checkequal(test_reference_out(), "test_reference_out message", "test_reference_out()");
+//checkequal(test_const_pointer_out(), "x", "test_const_pointer_out()");
+
+s = "initial string";
+
+// Global variable tests
+
+checkequal(GlobalString2_get(), "global string 2", "GlobalString2_get()");
+GlobalString2_set(s);
+checkequal(GlobalString2_get(), s, "GlobalString2_get()");
+
+checkequal(ConstGlobalString_get(), "const global string", "ConstGlobalString_get()");
+
+// Member variable tests
+
+myStructure = new_Structure();
+checkequal(Structure_Str2_get(myStructure), "member string 2", "Structure_Str2_get(myStructure)");
+
+Structure_Str2_set(myStructure, s);
+checkequal(Structure_Str2_get(myStructure), s, "Structure_Str2_get(myStructure)");
+
+checkequal(Structure_ConstStr_get(myStructure), "const member string", "Structure_ConstStr_get(myStructure)");
+
+checkequal(Structure_StaticStr2_get(), "static member string 2", "Structure_StaticStr2_get()");
+
+Structure_StaticStr2_set(s);
+checkequal(Structure_StaticStr2_get(), s, "Structure_StaticStr2_get()");
+
+checkequal(Structure_ConstStati_get(), "const static member string", "Structure_ConstStaticStr_get()");
+
+
+checkequal(stdstring_empty(), "", "stdstring_empty()");
+checkequal(c_empty(), "", "c_empty()");
+
+
+// li_std_string_extra tests
+
+//checkequal(test_value_basic1(x), x, "");
+//checkequal(test_value_basic2(x), x, "");
+//checkequal(test_value_basic3(x), x, "");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+// TODO: support for STL vectors operator =
+iv = new_DoubleVector();
+//for i=1:4
+// iv(i) = i;
+//end
+//x = average(iv);
+
+//if x <> 2.5 then swigtesterror(); end
+exit
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+
+// double
+checkequal(in_double(22.22), 22.22, "in_double");
+checkequal(inr_double(22.22), 22.22, "inr_double");
+checkequal(out_double(22.22), 22.22, "out_double");
+checkequal(outr_double(22.22), 22.22, "outr_double");
+checkequal(inout_double(22.22), 22.22, "inout_double");
+checkequal(inoutr_double(22.22), 22.22, "inoutr_double");
+
+// signed char
+checkequal(in_schar(22), 22, "in_schar");
+checkequal(inr_schar(22), 22, "inr_schar");
+checkequal(out_schar(22), 22, "out_schar");
+checkequal(outr_schar(22), 22, "outr_schar");
+checkequal(inout_schar(22), 22, "inout_schar");
+checkequal(inoutr_schar(22), 22, "inoutr_schar");
+
+// unsigned char
+checkequal(in_uchar(uint8(22)), 22, "in_uchar");
+checkequal(inr_uchar(uint8(22)), 22, "inr_uchar");
+checkequal(out_uchar(uint8(22)), 22, "out_uchar");
+checkequal(outr_uchar(uint8(22)), 22, "outr_uchar");
+checkequal(inout_uchar(uint8(22)), 22, "inout_uchar");
+checkequal(inoutr_uchar(uint8(22)), 22, "inoutr_uchar");
+
+// short
+checkequal(in_short(22), 22, "in_short");
+checkequal(inr_short(22), 22, "inr_short");
+checkequal(out_short(22), 22, "out_short");
+checkequal(outr_short(22), 22, "outr_short");
+checkequal(inout_short(22), 22, "inout_short");
+checkequal(inoutr_short(22), 22, "inoutr_short");
+
+// unsigned short
+checkequal(in_ushort(uint16(22)), 22, "in_ushort");
+checkequal(inr_ushort(uint16(22)), 22, "in_ushort");
+checkequal(out_ushort(uint16(22)), 22, "out_ushort");
+checkequal(outr_ushort(uint16(22)), 22, "outr_ushort");
+checkequal(inout_ushort(uint16(22)), 22, "inout_ushort");
+checkequal(inoutr_ushort(uint16(22)), 22, "inoutr_ushort");
+
+// int
+checkequal(in_int(22), 22, "in_int");
+checkequal(inr_int(22), 22, "inr_int");
+checkequal(out_int(22), 22, "out_int");
+checkequal(outr_int(22), 22, "outr_int");
+checkequal(inout_int(22), 22, "inout_int");
+checkequal(inoutr_int(22), 22, "inoutr_int");
+
+// unsigned int
+checkequal(in_uint(uint32(22)), 22, "in_uint");
+checkequal(inr_uint(uint32(22)), 22, "inr_uint");
+checkequal(out_uint(uint32(22)), 22, "out_uint");
+checkequal(outr_uint(uint32(22)), 22, "outr_uint");
+checkequal(inout_uint(uint32(22)), 22, "inout_uint");
+checkequal(inoutr_uint(uint32(22)), 22, "inoutr_uint");
+
+// long
+checkequal(in_long(22), 22, "in_long");
+checkequal(inr_long(22), 22, "inr_long");
+checkequal(out_long(22), 22, "out_long");
+checkequal(outr_long(22), 22, "outr_long");
+checkequal(inout_long(22), 22, "inout_long");
+checkequal(inoutr_long(22), 22, "inoutr_long");
+
+// unsigned long
+checkequal(in_ulong(uint32(22)), 22, "in_ulong");
+checkequal(inr_ulong(uint32(22)), 22, "inr_ulong");
+checkequal(out_ulong(uint32(22)), 22, "out_ulong");
+checkequal(outr_ulong(uint32(22)), 22, "outr_ulong");
+checkequal(inout_ulong(uint32(22)), 22, "inout_ulong");
+checkequal(inoutr_ulong(uint32(22)), 22, "inoutr_ulong");
+
+// bool
+checkequal(in_bool(%t), %t, "in_bool");
+checkequal(inr_bool(%f), %f, "inr_bool");
+checkequal(out_bool(%t), %t, "out_bool");
+checkequal(outr_bool(%f), %f, "outr_bool");
+checkequal(inout_bool(%t), %t, "inout_bool");
+checkequal(inoutr_bool(%f), %f, "inoutr_bool");
+
+// float
+checkequal(in_float(2.5), 2.5, "in_float");
+checkequal(inr_float(2.5), 2.5, "inr_float");
+checkequal(out_float(2.5), 2.5, "out_float");
+checkequal(outr_float(2.5), 2.5, "outr_float");
+checkequal(inout_float(2.5), 2.5, "inout_float");
+checkequal(inoutr_float(2.5), 2.5, "inoutr_float");
+
+// long long
+// Not supported in Scilab 5.5
+//checkequal(in_longlong(22), 22, "in_longlong");
+//checkequal(inr_longlong(22), 22, "inr_longlong");
+//checkequal(out_longlong(22), 22, "out_longlong");
+//checkequal(outr_longlong(22), 22, "outr_longlong");
+//checkequal(inout_longlong(22), 22, "inout_longlong");
+//checkequal(inoutr_longlong(22), 22, "inoutr_longlong");
+
+// unsigned long long
+// Not supported in Scilab 5.5
+//checkequal(in_ulonglong(uint64(22)), 22, "in_ulonglong");
+//checkequal(inr_ulonglong(uint64(22)), 22, "inr_ulonglong");
+//checkequal(out_ulonglong(uint64(22)), 22, "out_ulonglong");
+//checkequal(outr_ulonglong(uint64(22)), 22, "outr_ulonglong");
+//checkequal(inout_ulonglong(uint64(22)), 22, "inout_ulonglong");
+//checkequal(inoutr_ulonglong(uint64(22)), 22, "inoutr_ulonglong");
+
+// the others
+//a,b = inoutr_int2(1, 2);
+//checkequal(a<>1 || b<>2), "");
+//f,i = out_foo(10)
+//checkequal(f.a, 10 || i, 20), "");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+s = new_Square(10);
+
+// Functions
+checkequal(do_op(s, areapt()), 100.0, "Square area");
+checkequal(do_op(s, perimeterpt()), 40.0, "Square perimeter");
+
+// Variables
+checkequal(do_op(s, areavar_get()), 100.0, "Square area");
+areavar_set(perimeterpt());
+checkequal(do_op(s, areavar_get()), 40.0, "Square perimeter");
+
+// Constants
+checkequal(do_op(s, AREAPT_get()), 100.0, "Square area");
+checkequal(do_op(s, PERIMPT_get()), 40.0, "Square perimeter");
+
+delete_Square(s);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ foo_2();
+catch
+ swigtesterror();
+end
+if bar_2_get() <> 17 then swigtesterror(); end
+if Baz_2_get() <> 47 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ outer = new_Outer();
+ setValues(outer, 10);
+
+ inner1 = Outer_inner1_get(outer);
+ inner2 = Outer_inner2_get(outer);
+ inner3 = Outer_inner3_get(outer);
+ inner4 = Outer_inner4_get(outer);
+catch
+ swigtesterror();
+end
+
+checkequal(Outer_inner1_val_get(inner1), 10, "Outer_inner1_val_get(inner1)");
+checkequal(Outer_inner1_val_get(inner2), 20, "Outer_inner1_val_get(inner2)");
+checkequal(Outer_inner1_val_get(inner3), 20, "Outer_inner1_val_get(inner3)");
+checkequal(Outer_inner1_val_get(inner4), 40, "Outer_inner1_val_get(inner4)");
+
+try
+ inside1 = Outer_inside1_get(outer);
+ inside2 = Outer_inside2_get(outer);
+ inside3 = Outer_inside3_get(outer);
+ inside4 = Outer_inside4_get(outer);
+catch
+ swigtesterror();
+end
+
+checkequal(Named_val_get(inside1), 100, "Named_val_get(inside1)");
+checkequal(Named_val_get(inside2), 200, "Named_val_get(inside2)");
+checkequal(Named_val_get(inside3), 200, "Named_val_get(inside3)");
+checkequal(Named_val_get(inside4), 400, "Named_val_get(inside4)");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ x = makeFoo();
+catch
+ swigtesterror();
+end
+if fooCount() <> 1 then swigtesterror(); end
+
+try
+ y = makeFoo();
+catch
+ swigtesterror();
+end
+if fooCount() <> 2 then swigtesterror(); end
+
+try
+ delete_Foo(x);
+catch
+ swigtesterror();
+end
+if fooCount() <> 1 then swigtesterror(); end
+
+try
+ delete_Foo(y);
+catch
+ swigtesterror();
+end
+if fooCount() <> 0 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+p = getnull();
+checkequal(SWIG_this(p), 0, "SWIG_this(p)");
+checkequal(func(p), %T, "func(p)");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+function checktrue(value, msg)
+ checkequal(value, %T, msg)
+endfunction
+
+a = new_Op();
+b = new_Op(5);
+c = new_Op(b);
+d = new_Op(2);
+dd = new_Op();
+
+// Assignment operator
+Op_Equal(dd, d);
+
+// Comparison operator
+checktrue(Op_NotEqual(a, b), "Op_NotEqual(a, b)");
+checktrue(Op_EqualEqual(b, c), "Op_EqualEqual(b, c)");
+checktrue(Op_NotEqual(a, d), "Op_NotEqual(a, d)");
+checktrue(Op_EqualEqual(d, dd), "Op_EqualEqual(d, dd)");
+
+checktrue(Op_LessThan(a, b), "Op_LessThan(a, b)");
+checktrue(Op_LessThanEqual(a, b), "Op_LessThanEqual(a, b)");
+checktrue(Op_LessThanEqual(b, c), "Op_LessThanEqual(b, c)");
+checktrue(Op_GreaterThanEqual(b, c), "Op_GreaterThanEqual(b, c)");
+checktrue(Op_GreaterThan(b, d), "Op_GreaterThan(b, d)");
+checktrue(Op_GreaterThanEqual(b, d), "Op_GreaterThanEqual(b, d)");
+
+delete_Op(a);
+delete_Op(b);
+delete_Op(c);
+delete_Op(d);
+delete_Op(dd);
+
+f = new_Op(1);
+g = new_Op(1);
+
+expop = new_Op();
+
+op = Op_Plus(f, g);
+Op_i_set(expop, 2);
+checktrue(Op_EqualEqual(op, expop), "Op_Plus(f, g) <> Op(2)");
+delete_Op(op);
+
+op = Op_Minus(f, g);
+Op_i_set(expop, 0);
+checktrue(Op_EqualEqual(op, expop), "Op_Minus(f, g) <> Op(0)");
+delete_Op(op);
+
+op = Op_Multiply(f, g);
+Op_i_set(expop, 1);
+checktrue(Op_EqualEqual(op, expop), "Op_Multiply(f, g) <> Op(1)");
+delete_Op(op);
+
+op = Op_Divide(f, g);
+Op_i_set(expop, 1);
+checktrue(Op_EqualEqual(op, expop), "Op_Divide(f, g) <> Op(1)");
+delete_Op(op);
+
+// Unary operator
+op = Op_PlusPlusPrefix(new_Op(3));
+Op_i_set(expop, 4);
+checktrue(Op_EqualEqual(op, expop), "Op_PlusPlusPrefix(op) <> Op(4)");
+
+// Square bracket operator
+checkequal(Op_IndexIntoConst(op, uint32(0)), 4, "Op_IndexIntoConst(op, 0) <> 4");
+checkequal(Op_IndexIntoConst(op, uint32(1)), 0, "Op_IndexIntoConst(op, 1) <> 0");
+
+// Functor
+i = new_Op(3);
+checkequal(Op_Functor(i), 3, "Op_Functor(i)");
+checkequal(Op_Functor(i, 1), 4, "Op_Functor(i, 1)");
+
+delete_Op(f);
+delete_Op(g);
+
+delete_Op(i);
+
+delete_Op(expop);
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+exec("swigtest.start", -1);
+
+// Functions
+
+checkequal(foo(int32([1, 2, 3])), "foo:int[SIZE]", "foo(int[SIZE])");
+checkequal(foo([1, 2, 3]), "foo:double[SIZE]", "foo(double[SIZE])");
+checkequal(foo(["1" "2" "3"]), "foo:char *[SIZE]", "foo(char *[SIZE])");
+
+// Class methods
+
+s = new_Spam();
+checkequal(Spam_foo(s, int32([1, 2, 3])), "foo:int[SIZE]", "Spam::foo(int[SIZE])");
+checkequal(Spam_foo(s, [1, 2, 3]), "foo:double[SIZE]", "Spam::foo(double[SIZE])");
+checkequal(Spam_foo(s, ["1" "2" "3"]), "foo:char *[SIZE]", "Spam::foo(char *[SIZE])");
+delete_Spam(s);
+
+// Static class methods
+
+checkequal(Spam_bar(int32([1, 2, 3])), "bar:int[SIZE]", "Spam::bar(int[SIZE])");
+checkequal(Spam_bar([1, 2, 3]), "bar:double[SIZE]", "Spam::bar(double[SIZE])");
+checkequal(Spam_bar("hello"), "bar:char *[SIZE]", "Spam::bar(char *[SIZE])");
+
+// Constructors
+
+s = new_Spam();
+checkequal(Spam_type_get(s), "none", "Spam::Spam()");
+delete_Spam(s);
+
+s = new_Spam(int32([1, 2, 3]));
+checkequal(Spam_type_get(s), "int[SIZE]", "Spam::Spam(int[SIZE])");
+delete_Spam(s);
+
+s = new_Spam([1, 2, 3]);
+checkequal(Spam_type_get(s), "double[SIZE]", "Spam::Spam(double[SIZE])");
+delete_Spam(s);
+
+s = new_Spam(["1" "2" "3"]);
+checkequal(Spam_type_get(s), "char *[SIZE]", "Spam::Spam(char *[SIZE])");
+delete_Spam(s);
+
+
+a = new_ClassA();
+b = ClassA_method1(a, [1 2 3]);
+
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+NULL = SWIG_ptr(0);
+p = new_Pop(NULL);
+p = new_Pop(NULL, %T);
+
+checkequal(Pop_hip(p, %T), 701, "Pop_hip(%T)");
+checkequal(Pop_hip(p, NULL), 702, "Pop_hip(NULL)");
+
+checkequal(Pop_hop(p, %T), 801, "Pop_hop(%T)");
+checkequal(Pop_hop(p, NULL), 805, "Pop_hop(NULL)");
+
+checkequal(Pop_pop(p, %T), 901, "Pop_pop(%T)");
+checkequal(Pop_pop(p, NULL), 904, "Pop_pop(NULL)");
+checkequal(Pop_pop(p), 905, "Pop_pop()");
+
+checkequal(Pop_bop(p, NULL), 1001, "Pop_bop(NULL)");
+
+checkequal(Pop_bip(p, NULL), 2002, "Pop_bip(%T)");
+
+checkequal(muzak(%T), 3001, "muzak(%T)");
+checkequal(muzak(NULL), 3002, "muzak(%T)");
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+exec("swigtest.start", -1);
+
+f = new_Foo();
+g = new_Foo(f);
+
+delete_Foo(f);
+delete_Foo(g);
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ x = new_Foo();
+catch
+ swigtesterror();
+end
+if Foo_test(x, 1) <> 1 then swigtesterror(); end
+if Foo_test(x, "Hello swig!") <> 2 then swigtesterror(); end
+if Foo_test(x, 2, 3) <> 3 then swigtesterror(); end
+if Foo_test(x, x) <> 30 then swigtesterror(); end
+if Foo_test(x, x, 4) <> 24 then swigtesterror(); end
+if Foo_test(x, x, 4, 5) <> 9 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+//try
+// x = new_Foo();
+//catch
+// swigtesterror();
+//end
+//if Foo_test(x) <> 0 then swigtesterror(); end
+//if Foo_test(x, 1) <> 1 then swigtesterror(); end
+//if Foo_test(x, 2, 3) <> 5 then swigtesterror(); end
+//if Foo_test(x, "Hello, swig!") <> 2 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+//try
+// x = new_Foo();
+//catch
+// swigtesterror();
+//end
+//if Foo_test(x) <> 0 then swigtesterror(); end
+//if Foo_test(x, 1) <> 1 then swigtesterror(); end
+//if Foo_test(x, 2, 3) <> 5 then swigtesterror(); end
+//if Foo_test(x, "Hello, swig!") <> 2 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+nums = new_Nums();
+
+// In overloading in Scilab, double has priority over all other numeric types
+checkequal(Nums_over(nums, 0), "double", "Nums_over(nums, 0)");
+
+// Just checkequal if the following are accepted without exceptions being thrown
+Nums_doublebounce(nums, %inf);
+Nums_doublebounce(nums, -%inf);
+Nums_doublebounce(nums, %nan);
+
+delete_Nums(nums);
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+exec("swigtest.start", -1);
+
+derived = new_Derived();
+
+checkequal(test(derived), 0, "test(derived)");
+checkequal(test2(derived), 1, "test2(derived)");
+
+delete_Derived(derived);
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+exec("swigtest.start", -1);
+
+f = new_Foo();
+b = new_Bar();
+v = malloc_void(32);
+
+// Functions
+
+checkequal(foo(int32(3)), "foo:int", "foo(int)");
+checkequal(foo(3), "foo:double", "foo(double)");
+checkequal(foo("hello"), "foo:char *", "foo(char* )");
+checkequal(foo(f), "foo:Foo *", "foo(Foo *)");
+checkequal(foo(b), "foo:Bar *", "foo(Bar *)");
+checkequal(foo(v), "foo:void *", "foo(void *)");
+
+// Class methods
+
+s = new_Spam();
+checkequal(Spam_foo(s, int32(3)), "foo:int", "Spam::foo(int)");
+checkequal(Spam_foo(s, 3), "foo:double", "Spam::foo(double)");
+checkequal(Spam_foo(s, "hello"), "foo:char *", "Spam::foo(char *)");
+checkequal(Spam_foo(s, f), "foo:Foo *", "Spam::foo(Foo *)");
+checkequal(Spam_foo(s, b), "foo:Bar *", "Spam::foo(Bar *)");
+checkequal(Spam_foo(s, v), "foo:void *", "Spam::foo(void *)");
+delete_Spam(s);
+
+// Static class methods
+
+checkequal(Spam_bar(int32(3)), "bar:int", "Spam::bar(int)");
+checkequal(Spam_bar(3.1), "bar:double", "Spam::bar(double)");
+checkequal(Spam_bar("hello"), "bar:char *", "Spam::bar(char *)");
+checkequal(Spam_bar(f), "bar:Foo *", "Spam::bar(Foo *)");
+checkequal(Spam_bar(b), "bar:Bar *", "Spam::bar(Bar *)");
+checkequal(Spam_bar(v), "bar:void *", "Spam::bar(void *)");
+
+// Constructors
+
+s = new_Spam();
+checkequal(Spam_type_get(s), "none", "Spam::Spam()");
+delete_Spam(s);
+
+s = new_Spam(int32(3));
+checkequal(Spam_type_get(s), "int", "Spam::Spam(int)");
+delete_Spam(s);
+
+s = new_Spam(3.1);
+checkequal(Spam_type_get(s), "double", "Spam::Spam(double)");
+delete_Spam(s);
+
+s = new_Spam("hello");
+checkequal(Spam_type_get(s), "char *", "Spam::Spam(char *)");
+delete_Spam(s);
+
+s = new_Spam(f);
+checkequal(Spam_type_get(s), "Foo *", "Spam::Spam(Foo *)");
+delete_Spam(s);
+
+s = new_Spam(b);
+checkequal(Spam_type_get(s), "Bar *", "Spam::Spam(Bar *)");
+delete_Spam(s);
+
+s = new_Spam(v);
+checkequal(Spam_type_get(s), "void *", "Spam::Spam(void *)");
+delete_Spam(s);
+
+delete_Foo(f);
+delete_Bar(b);
+free_void(v);
+
+a = new_ClassA();
+b = ClassA_method1(a, 1);
+delete_ClassA(a);
+
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+f = new_Foo();
+b = new_Bar();
+
+checkequal(spam(f), 1, "spam(f)");
+checkequal(spam(b), 2, "spam(b)");
+
+delete_Foo(f);
+delete_Bar(b);
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+exec("swigtest.start", -1);
+
+checkequal(CONST_INT1_get(), 10, "CONST_INT1");
+checkequal(CONST_DOUBLE3_get(), 12.3, "CONST_DOUBLE3");
+checkequal(CONST_BOOL1_get(), %T, "CONST_BOOL1");
+checkequal(CONST_CHAR_get(), 'x', "CONST_CHAR");
+checkequal(CONST_STRING1_get(), "const string", "CONST_STRING1");
+
+// Test global constants can be seen within functions
+function test_global()
+ global CONST_INT1
+ global CONST_DOUBLE3
+ global CONST_BOOL1
+ global CONST_CHAR
+ global CONST_STRING1
+
+ checkequal(CONST_INT1_get(), 10, "CONST_INT1");
+ checkequal(CONST_DOUBLE3_get(), 12.3, "CONST_DOUBLE3");
+ checkequal(CONST_BOOL1_get(), %T, "CONST_BOOL1");
+ checkequal(CONST_CHAR_get(), 'x', "CONST_CHAR");
+ checkequal(CONST_STRING1_get(), "const string", "CONST_STRING1");
+endfunction
+
+test_global();
+
+
+// Test assignement in enums
+checkequal(kValue_get(), 4, "kValue");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+if endif_get() <> 1 then swigtesterror(); end
+if define_get() <> 1 then swigtesterror(); end
+if defined_get() <> 1 then swigtesterror(); end
+if 2 * one_get() <> two_get() then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+checkequal(ref_int(3), 3, "ref_int() test fails.");
+checkequal(ref_uint(uint32(3)), 3, "ref_uint() test fails.");
+
+checkequal(ref_short(3), 3, "ref_short() test fails.");
+checkequal(ref_ushort(uint16(3)), 3, "ref_ushort() test fails.");
+
+checkequal(ref_long(3), 3, "ref_long() test fails.");
+checkequal(ref_ulong(uint32(3)), 3, "ref_ulong() test fails.");
+
+checkequal(ref_schar(3), 3, "ref_schar() test fails.");
+checkequal(ref_uchar(uint8(3)), 3, "ref_uchar() test fails.");
+
+checkequal(ref_float(3), 3, "ref_float() test fails.");
+checkequal(ref_double(3), 3, "ref_double() test fails.");
+
+checkequal(ref_bool(%T), %T, "ref_bool() test fails.");
+
+checkequal(ref_char('x'), 'x', "ref_char() test fails.");
+
+checkequal(ref_over(0), 0, "ref_over() test fails.");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+// Check passing by value
+
+checkequal(val_double(42), 42, "val_double() test fails.");
+checkequal(val_float(42), 42, "val_float() test fails.");
+
+checkequal(val_char('a'), 'a', "val_char() test fails.");
+checkequal(val_schar(42), 42, "val_schar() test fails.");
+checkequal(val_schar(int8(42)), 42, "val_schar() test fails.");
+checkequal(val_uchar(uint8(42)), 42, "val_uchar() test fails.");
+
+checkequal(val_short(42), 42, "val_short() test fails.");
+checkequal(val_short(int16(42)), 42, "val_short() test fails.");
+checkequal(val_ushort(uint16(42)), 42, "val_ushort() test fails.");
+
+checkequal(val_int(42), 42, "val_int() test fails.");
+checkequal(val_int(int32(42)), 42, "val_int() test fails.");
+checkequal(val_uint(uint32(42)), 42, "val_uint() test fails.");
+
+checkequal(val_long(42), 42, "val_long() test fails.");
+checkequal(val_long(int32(42)), 42, "val_long() test fails.");
+checkequal(val_ulong(uint32(42)), 42, "val_long() test fails.");
+
+checkequal(val_bool(%t), %t, "val_bool() test fails.");
+
+// longlong is not supported in Scilab 5.x
+//checkequal(val_llong(42), 42, "val_llong() test fails.");
+//checkequal(val_llong(int64(42)), 42, "val_llong() test fails.");
+//checkequal(val_ullong(uint64(42)), 42, "val_ullong() test fails.");
+
+// Check passing by reference
+checkequal(ref_char('a'), 'a', "ref_char() test fails.");
+checkequal(ref_schar(42), 42, "ref_schar() test fails.");
+checkequal(ref_schar(int8(42)), 42, "ref_schar() test fails.");
+checkequal(ref_uchar(uint8(42)), 42, "ref_uchar() test fails.");
+
+checkequal(ref_short(42), 42, "ref_short() test fails.")
+checkequal(ref_short(int16(42)), 42, "ref_short() test fails.")
+checkequal(ref_ushort(uint16(42)), 42, "ref_ushort() test fails.")
+
+checkequal(ref_int(42), 42, "ref_int() test fails.");
+checkequal(ref_int(int32(42)), 42, "ref_int() test fails.");
+checkequal(ref_uint(uint32(42)), 42, "ref_uint() test fails.");
+
+checkequal(ref_long(42), 42, "ref_long() test fails.");
+checkequal(ref_long(int32(42)), 42, "ref_long() test fails.");
+checkequal(ref_ulong(uint32(42)), 42, "ref_ulong() test fails.");
+
+checkequal(ref_bool(%t), %t, "ref_bool() test fails.");
+
+// long long is not supported in Scilab 5.x
+//checkequal(ref_llong(42), 42, "ref_llong() test fails.");
+//checkequal(ref_llong(int64(42)), 42, "ref_llong() test fails.");
+//checkequal(ref_ullong(uint64(42)), 42, "ref_ullong() test fails.");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ a = get_test();
+catch
+ swigtesterror();
+end
+
+// Test default values
+checkequal(test_myInt_get(a), 100, "test_myInt_get() test fails.");
+checkequal(test_myShort_get(a), 200, "test_myShort_get() test fails.");
+
+// Write new values
+try
+ test_myInt_set(a, 42)
+ test_myShort_set(a, 12)
+catch
+ swigtesterror();
+end
+
+// Read new values
+checkequal(test_myInt_get(a), 42, "test_myInt_get() test fails.");
+checkequal(test_myShort_get(a), 12, "test_myShort_get() test fails.");
+
+// Destroy pointer
+delete_test(a);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+foo_ptr = Foo_ptr_getPtr();
+foo = Foo_ptr___deref__(foo_ptr);
+checkequal(Foo_getVal(foo), 17, "Foo_getVal(p)");
+
+foo_ptr = Foo_ptr_getConstPtr();
+foo = Foo_ptr___deref__(foo_ptr);
+checkequal(Foo_getVal(foo), 17, "Foo_getVal(p)");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+checkequal(ICONST0_get(), 42, "ICONST0_get()");
+checkequal(FCONST0_get(), 2.1828, "FCONST0_get()");
+checkequal(CCONST0_get(), "x", "CCONST0_get()");
+//checkequal(CCONST0_2_get(), "\n", "CCONST0_2_get()");
+checkequal(SCONST0_get(), "Hello World", "SCONST0_get()");
+checkequal(SCONST0_2_get(), """Hello World""", "SCONST0_2_get()");
+checkequal(EXPR0_get(), 48.5484, "EXPR0_get()");
+checkequal(iconst0_get(), 37, "iconst0_get()");
+checkequal(fconst0_get(), 42.2, "fconst0_get()");
+
+checkequal(UNSIGNED0_get(), hex2dec("5FFF"), "UNSIGNED0_get()");
+checkequal(LONG0_get(), hex2dec("3FFF0000"), "LONG0_get()");
+checkequal(ULONG0_get(), hex2dec("5FF0000"), "ULONG0_get()");
+
+if isdef('BAR0') then swigtesterror("BAR0"); end
+
+checkequal(ICONST1, int32(42), "ICONST1");
+checkequal(FCONST1, 2.1828, "FCONST1");
+checkequal(CCONST1, "x", "CCONST1");
+//checkequal(CCONST1_2, "\n", "CCONST1_2");
+checkequal(SCONST1, "Hello World", "SCONST1");
+checkequal(SCONST1_2, """Hello World""", "SCONST1_2");
+checkequal(EXPR1, 48.5484, "EXPR1");
+checkequal(iconst1, int32(37), "iconst1");
+checkequal(fconst1, 42.2, "fconst1");
+
+checkequal(UNSIGNED1, uint32(hex2dec("5FFF")), "UNSIGNED1");
+checkequal(LONG1, int32(hex2dec("3FFF0000")), "LONG1");
+checkequal(ULONG1, uint32(hex2dec("5FF0000")), "ULONG1");
+
+if isdef('BAR1') then swigtesterror("BAR1"); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+function checkEnum(enum_val, expected_enum_val)
+ if typeof(enum_val) <> "constant" then swigtesterror(); end
+ if enum_val <> expected_enum_val then swigtesterror(); end
+endfunction
+
+checkEnum(ENUM_1, 0);
+checkEnum(ENUM_2, 1);
+
+checkEnum(ENUM_EXPLICIT_1_1, 5);
+checkEnum(ENUM_EXPLICIT_1_2, 6);
+
+checkEnum(ENUM_EXPLICIT_2_1, 0);
+checkEnum(ENUM_EXPLICIT_2_2, 10);
+
+checkEnum(ENUM_EXPLICIT_3_1, 2);
+checkEnum(ENUM_EXPLICIT_3_2, 5);
+checkEnum(ENUM_EXPLICIT_3_3, 8);
+
+checkEnum(TYPEDEF_ENUM_1_1, 21);
+checkEnum(TYPEDEF_ENUM_1_2, 22);
+
+checkEnum(TYPEDEF_ENUM_2_1, 31);
+checkEnum(TYPEDEF_ENUM_2_2, 32);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+
+// Test truncating variables, constants, functions identifier names
+// not truncated
+gvar_identifier_name_set(-101);
+checkequal(gvar_identifier_name_get(), -101, "gvar_identifier_name_get()");
+checkequal(CONS_IDENTIFIER_NAME_get(), -11, "CONS_IDENTIFIER_NAME_get()");
+checkequal(function_identifier_name(), -21, "function_identifier_name()");
+
+// truncated
+too_long_gvar_identi_set(101);
+checkequal(too_long_gvar_identi_get(), 101, "too_long_variable_id_get()");
+checkequal(TOO_LONG_CONST_IDENT_get(), 11, "TOO_LONG_CONST_IDENT_get()");
+checkequal(too_long_function_identi(), 21, "too_long_function_identi()");
+
+// Test truncating when %scilabconst mode is activated
+checkequal(SC_CONST_IDENTIFIER_NAME, int32(-12), "SC_TOO_LONG_IDENTIF");
+checkequal(SC_TOO_LONG_CONST_IDENTI, int32(14), "SC_TOO_LONG_IDENTIF");
+
+// Test truncating in the case of struct
+st = new_st();
+st_m_identifier_name_set(st, 15);
+checkequal(st_m_identifier_name_get(st), 15, "st_m_identifier_name_get(st)");
+st_too_long_member_i_set(st, 25);
+checkequal(st_too_long_member_i_get(st), 25, "st_too_long_member_i_get(st)");
+delete_st(st);
+
+exec("swigtest.quit", -1);
--- /dev/null
+// test matrix.i library
+
+exec("swigtest.start", -1);
+
+// test matrix passed as output argument from fonction
+function test_outMatrix(func, valueType, expectedOutMatrix)
+ funcName = msprintf("out%s%s", valueType, func);
+ cmd = msprintf("outMatrix = %s();", funcName);
+ ierr = execstr(cmd, "errcatch");
+ if ierr <> 0 then
+ swigtesterror(msprintf("Error %d in %s", ierr, funcName));
+ end
+ checkequal(outMatrix, expectedOutMatrix, funcName);
+endfunction
+
+// test matrix passed as input argument of fonction
+function test_inMatrix(func, valueType, inMatrix, expectedInValue)
+ funcName = msprintf("in%s%s", valueType, func);
+ cmd = msprintf("inValue = %s(inMatrix);", funcName);
+ ierr = execstr(cmd, "errcatch");
+ if ierr <> 0 then
+ swigtesterror(msprintf("Error %d in %s", ierr, funcName));
+ end
+ checkequal(inValue, expectedInValue, funcName);
+endfunction
+
+// test matrixes passed as input and output arguments of fonction
+function test_inoutMatrix(func, valueType, inoutMatrix, expectedInoutMatrix)
+ funcName = msprintf("inout%s%s", valueType, func);
+ cmd = msprintf("inoutMatrix = %s(inoutMatrix);", funcName);
+ ierr = execstr(cmd, "errcatch");
+ if ierr <> 0 then
+ swigtesterror(msprintf("Error %d in %s", ierr, funcName));
+ end
+ checkequal(inoutMatrix, expectedInoutMatrix, funcName);
+endfunction
+
+function test_matrix_typemaps(valueType, ..
+ expectedOutMatrixDims, expectedOutMatrixSize, ..
+ expectedInValue, ..
+ expectedInoutMatrixDims, expectedInoutMatrixSize)
+
+ test_outMatrix("MatrixDims", valueType, expectedOutMatrixDims);
+ test_outMatrix("MatrixSize", valueType, expectedOutMatrixSize);
+ matrixDims = expectedOutMatrixDims;
+ matrixSize = expectedOutMatrixSize;
+ test_inMatrix("MatrixDims", valueType, matrixDims, expectedInValue);
+ test_inMatrix("MatrixSize", valueType, matrixSize, expectedInValue);
+ test_inoutMatrix("MatrixDims", valueType, matrixDims, expectedInoutMatrixDims);
+ test_inoutMatrix("MatrixSize", valueType, matrixSize, expectedInoutMatrixSize);
+endfunction
+
+
+m = [0 3; 1 4; 2 5];
+v = [0 1 2 3 4 5];
+test_matrix_typemaps("Int", m, v, sum(m), m .* m, v .* v);
+test_matrix_typemaps("Double", m, v, sum(m), m .* m, v .* v);
+
+m = ["A" "D"; "B" "E"; "C" "F"];
+v = ["A" "B" "C" "D" "E" "F"];
+test_matrix_typemaps("CharPtr", m, v, strcat(m), m + m, v + v);
+
+m = [%T %F; %F %T; %T %F];
+v = [%T %F %T %F %T %F];
+test_matrix_typemaps("Bool", m, v, %T, ~m, ~v);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+// OUTPUT
+
+[a, b] = output2();
+checkequal(a, 1, "[a, b] = output2(): a");
+checkequal(b, 2, "[a, b] = output2(): b");
+
+[ret, a, b] = output2Ret();
+checkequal(ret, 3, "[a, b] = output2Ret(): b");
+checkequal(a, 1, "[a, b] = output2Ret(): a");
+checkequal(b, 2, "[a, b] = output2Ret(): b");
+
+[c, d] = output2Input2(1, 2);
+checkequal(c, 2, "[c, d] = output2Input2(1, 2): c");
+checkequal(d, 4, "[c, d] = output2Input2(1, 2): d");
+
+[ret, c, d] = output2Input2Ret(1, 2);
+checkequal(ret, 6, "[ret, c, d] = output2Input2Ret(1, 2): ret");
+checkequal(c, 2, "[ret, c, d] = output2Input2Ret(1, 2): c");
+checkequal(d, 4, "[ret, c, d = output2Input2Ret(1, 2): d");
+
+[ret, a, b, c] = output3Input1Ret(10);
+checkequal(ret, 10, "[ret, a, b, c] = output3Input1Ret(10): ret");
+checkequal(a, 11, "[ret, a, b, c] = output3Input1Ret(10): a");
+checkequal(b, 12, "[ret, a, b, c] = output3Input1Ret(10): b");
+checkequal(c, 13, "[ret, a, b, c] = output3Input1Ret(10): c");
+
+[ret, a, b, c] = output3Input3Ret(10, 20, 30);
+checkequal(ret, 66, "[ret, a, b, c] = output3Input1Ret(10, 20, 30): ret");
+checkequal(a, 11, "[ret, a, b, c] = output3Input1Ret(10, 20, 30): a");
+checkequal(b, 22, "[ret, a, b, c] = output3Input1Ret(10, 20, 30): b");
+checkequal(c, 33, "[ret, a, b, c] = output3Input1Ret(10, 20, 30): c");
+
+
+// INOUT
+
+[a, b] = inout2(1, 2);
+checkequal(a, 2, "[a, b] = output2(1, 2): a");
+checkequal(b, 4, "[a, b] = output2(1, 2): b");
+
+[ret, a, b] = inout2Ret(1, 2);
+checkequal(ret, 6, "[a, b] = inout2Ret(1, 2): b");
+checkequal(a, 2, "[a, b] = inout2Ret(1, 2): a");
+checkequal(b, 4, "[a, b] = inout2Ret(1, 2): b");
+
+[c, d] = inout2Input2(1, 2, 1, 1);
+checkequal(c, 2, "[c, d] = inout2Input2(1, 2): c");
+checkequal(d, 3, "[c, d] = inout2Input2(1, 2): d");
+
+[ret, c, d] = inout2Input2Ret(1, 2, 1, 1);
+checkequal(ret, 5, "[c, d] = inout2Input2Ret(1, 2): ret");
+checkequal(c, 2, "[c, d] = inout2Input2Ret(1, 2): c");
+checkequal(d, 3, "[c, d] = inout2Input2Ret(1, 4): d");
+
+[ret, a, b, c] = inout3Input1Ret(10, 1, 2, 3);
+checkequal(ret, 10, "[ret, a, b, c] = output3Input1Ret(ret, 1, 2, 3): ret");
+checkequal(a, 11, "[ret, a, b, c] = output3Input1Ret(ret, 1, 2, 3): a");
+checkequal(b, 12, "[ret, a, b, c] = output3Input1Ret(ret, 1, 2, 3): b");
+checkequal(c, 13, "[ret, a, b, c] = output3Input1Ret(ret, 1, 2, 3): c");
+
+[ret, a, b, c] = inout3Input3Ret(10, 1, 20, 2, 30, 3);
+checkequal(ret, 66, "[ret, a, b, c] = output3Input1Ret(10, 20, 30): ret");
+checkequal(a, 11, "[ret, a, b, c] = inout3Input1Ret(10, 1, 20, 2, 30, 3): a");
+checkequal(b, 22, "[ret, a, b, c] = inout3Input1Ret(10, 1, 20, 2, 30, 3): b");
+checkequal(c, 33, "[ret, a, b, c] = inout3Input1Ret(10, 1, 20, 2, 30, 3): c");
+
+
+// CLASS
+
+a = new_ClassA();
+
+[ret, c, d] = ClassA_output2Input2Ret(a, 1, 2);
+checkequal(ret, 6, "[ret, c, d] = ClassA_output2Input2Ret(a, 1, 2): ret");
+checkequal(c, 2, "[c, d] = ClassA_output2Input2Ret(a, 1, 2): c");
+checkequal(d, 4, "[c, d] = ClassA_output2Input2Ret(a, 1, 2): d");
+
+[ret, c, d] = ClassA_inout2Input2Ret(a, 1, 2, 1, 1);
+checkequal(ret, 5, "[ret, c, d] = ClassA_inout2Input2Ret(a, 1, 2): ret");
+checkequal(c, 2, "[c, d] = ClassA_inout2Input2(a, 1, 2): c");
+checkequal(d, 3, "[c, d] = ClassA_inout2Input2(a, 1, 2): d");
+
+delete_ClassA(a);
+
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+exec("swigtest.start", -1);
+
+// Test on NULL
+null = getNull();
+checkequal(SWIG_this(null), 0, "SWIG_this(null)");
+
+null = SWIG_ptr(0);
+checkequal(isNull(null), %T, "func(null)");
+
+// Test on variable
+expected_foo_addr = getFooAddress();
+foo_addr = SWIG_this(pfoo_get());
+checkequal(foo_addr, expected_foo_addr, "SWIG_this(pfoo_get())");
+
+pfoo = SWIG_ptr(foo_addr);
+checkequal(equalFooPointer(pfoo), %T, "equalFooPointer(pfoo)");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ initArray();
+catch
+ swigtesterror();
+end
+
+if x_get() <> int32([0,1,2,3,4,5,6,7,8,9]) then swigtesterror(); end
+if y_get() <> [0/7,1/7,2/7,3/7,4/7,5/7,6/7] then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+s = 2000;
+s = test1(s+1);
+s = test2(s+1);
+s = test3(s+1);
+s = test4(s+1);
+if s <> 2004 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+exec("swigtest.start", -1);
+
+f = new_Foo();
+b = new_Bar(f);
+
+Bar_x_set(b, 3);
+if Bar_x_get(b) <> 3 then swigtesterror(); end
+
+fp = Bar___deref__(b);
+Bar_x_set(b, 4);
+if Bar_x_get(b) <> 4 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ x = add(3, 4);
+catch
+ swigtesterror();
+end
+if x <> 7 then swigtesterror(); end
+
+try
+ y = subtract(3,4);
+catch
+ swigtesterror();
+end
+if y <> -1 then swigtesterror(); end
+
+try
+ z = mul(3,4);
+catch
+ swigtesterror();
+end
+if z <> 12 then swigtesterror(); end
+
+try
+ w = divide(3,4);
+catch
+ swigtesterror();
+end
+if w <> 0 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+if StructC_x_get(instanceC1_get()) <> 10 then swigtesterror(); end
+
+if StructD_x_get(instanceD1_get()) <> 10 then swigtesterror(); end
+
+if StructD_x_get(instanceD2_get()) <> 20 then swigtesterror(); end
+
+if StructD_x_get(instanceD3_get()) <> 30 then swigtesterror(); end
+
+if StructE_x_get(instanceE1_get()) <> 1 then swigtesterror(); end
+
+if StructF_x_get(instanceF1_get()) <> 1 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
\ No newline at end of file
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ a = new_Bar();
+ Bar_x_set(a,100);
+catch
+ swigtesterror();
+end
+if Bar_x_get(a) <> 100 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+foo = new_Foo();
+Foo_x_set(foo, 1);
+if Foo_x_get(foo) <> 1 then swigtesterror(); end
+
+bar = new_Bar();
+Bar_a_set(bar, foo);
+a = Bar_a_get(bar);
+if Foo_x_get(a) <> 1 then swigtesterror(); end
+
+Bar_b_set(bar, foo);
+b = Bar_b_get(bar);
+if Foo_x_get(b) <> 1 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+// Exit from Scilab
+exit
--- /dev/null
+lines(0);
+warning('off');
+ilib_verbose(0);
+
+// Get test name (used in swigtest.quit file)
+[units, typ, names] = file(1);
+swigtestname = strsubst(fileparts(names, "fname"), "_runme", "");
+
+// Does the library exists? If not then exit!
+libname = "lib" + swigtestname + getdynlibext();
+if ~isfile(libname) then
+ mfprintf(0, "*** LIBRARY NOT FOUND: %s ***\n", libname);
+ exit(1)
+end
+
+// Load library
+try
+ exec("loader.sce", -1);
+catch
+ mfprintf(0, "*** LOADER EXECUTION FAILED ***\n");
+ exit(1)
+end
+
+// Module initialization
+try
+ moduleInit = sprintf("%s_Init()", swigtestname);
+ execstr(moduleInit);
+catch
+ mfprintf(0, "*** MODULE INIT FAILED ***\n");
+ exit(1)
+end
+
+// Error management function
+function swigtesterror(msg)
+ [lines, names] = where();
+ if size(lines, '*') > 0
+ mfprintf(0, "*** TEST FAILED (at line %d) ***\n", lines($));
+ if argn(2) >= 1 then disp(msg); end
+ else
+ mfprintf(0, "*** TEST FAILED ***\n");
+ end;
+ exit(1)
+endfunction
+
+// Check equal function
+function checkequal(returned, expected, message)
+ if typeof(returned) <> typeof(expected) then
+ returned_type_msg = ["returned type:"; typeof(returned)];
+ expected_type_msg = ["expected type:"; typeof(expected)];
+ swigtesterror([message; returned_type_msg; expected_type_msg]);
+ end
+ if ~isequal(returned, expected) then
+ returned_value_msg = ["returned value:"; string(returned)];
+ expected_value_msg = ["expected value:"; string(expected)];
+ swigtesterror([message; returned_value_msg; expected_value_msg]);
+ end
+endfunction
--- /dev/null
+exec("swigtest.start", -1);
+
+ri = new_RectangleInt();
+pi = RectangleInt_getPoint(ri);
+x = PointInt_getX(pi);
+delete_RectangleInt(ri);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+p1 = new_pairii(2, 3);
+p2 = new_pairii(p1);
+
+checkequal(pairii_first_get(p2), 2, "pairii_first(p2) test fails.");
+checkequal(pairii_second_get(p2), 3, "pairii_second(p2) test fails.");
+
+p3 = new_pairdd(0.5, 2.5);
+p4 = new_pairdd(p3);
+
+checkequal(pairdd_first_get(p4), 0.5, "pairdd_first(p4) test fails.");
+checkequal(pairdd_second_get(p4), 2.5, "pairdd_second(p4) test fails.");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+i = new_iFoo();
+checkequal(iFoo_blah_test(i, 4), 4, "iFoo_blah_test(i, 4) test fails");
+checkequal(iFoo_spam_test(i, 5), 5, "iFoo_spam_test(i, 5) test fails");
+checkequal(iFoo_groki_test(i, 6), 6, "iFoo_groki_test(i, 6) test fails");
+delete_iFoo(i);
+
+d = new_dFoo();
+checkequal(dFoo_blah_test(d, 4), 4, "dFoo_blah_test(d, 4) test fails");
+checkequal(dFoo_spam(d, 5), 5, "dFoo_spam_test(d, 5) test fails");
+checkequal(dFoo_grok_test(d, 6), 6, "dFoo_groki_test(d, 6) test fails");
+delete_dFoo(d);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+checkequal(foo_i_test_get(), 0, "foo_i_test_get() test fails.");
+checkequal(foo_d_test_get(), 0, "foo_i_test_get() test fails.");
+
+checkequal(Foo_bar_double(0), 1, "Foo_bar_double() test fails");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+function checkException(cmd, expected_error_msg)
+ ierr = execstr(cmd, 'errcatch');
+ checkequal(ierr, 20000, cmd + ': ierr');
+ checkequal(lasterror(), 'SWIG/Scilab: ' + expected_error_msg, cmd + ': msg');
+endfunction
+
+foo = new_Foo();
+
+checkException('Foo_test_int(foo)', 'Exception (int) occured: 37');
+
+checkException('Foo_test_msg(foo)', 'Exception (char const *) occured: Dead');
+
+checkException('Foo_test_multi(foo, 1)', 'Exception (int) occured: 37');
+
+checkException('Foo_test_multi(foo, 2)', 'Exception (char const *) occured: Dead');
+
+checkException('Foo_test_cls(foo)', 'Exception (CError) occured.');
+
+delete_Foo(foo);
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ x = new_LineObj();
+ LineObj_numpoints_set(x, 100);
+catch
+ swigtesterror();
+end
+if LineObj_numpoints_get(x) <> 100 then swigtesterror(); end
+
+if MS_NOOVERRIDE_get() <> -1111 then swigtesterror(); end
+
+try
+ y = make_a();
+ A_t_a_set(y, 200);
+catch
+ swigtesterror();
+end
+if A_t_a_get(y) <> 200 then swigtesterror(); end
+
+try
+ A_t_b_set(y, 300);
+catch
+ swigtesterror();
+end
+if A_t_b_get(y) <> 300 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ x = new_LineObj();
+ LineObj_numpoints_set(x, 100);
+catch
+ swigtesterror();
+end
+if LineObj_numpoints_get(x) <> 100 then swigtesterror(); end
+
+if MS_NOOVERRIDE_get() <> -1111 then swigtesterror(); end
+
+try
+ y = make_a();
+ A_t_a_set(y, 200);
+catch
+ swigtesterror();
+end
+if A_t_a_get(y) <> 200 then swigtesterror(); end
+
+try
+ A_t_b_set(y, 300);
+catch
+ swigtesterror();
+end
+if A_t_b_get(y) <> 300 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+// Some lines are commented out because of too long identifiers...
+
+exec("swigtest.start", -1);
+
+event = new_SDL_Event();
+
+for i=1:2
+ evAvailable = SDL_PollEvent(event);
+ evType = SDL_Event_type_get(event);
+
+ if evType==1 then
+ specEvent = SDL_Event_active_get(event);
+ _type = SDL_ActiveEvent_type_get(specEvent);
+
+ if _type <> evType then swigtesterror(); end
+
+ gain = SDL_ActiveEvent_gain_get(specEvent);
+ //state = SDL_ActiveEvent_state_get(specEvent);
+ end
+
+ if evType==2 then
+ specEvent = SDL_Event_key_get(event);
+ //_type = SDL_KeyboardEvent_type_get(specEvent);
+
+ //if _type <> evType then swigtesterror(); end
+
+ //_which = SDL_KeyboardEvent_which_get(specEvent);
+ //state = SDL_KeyboardEvent_state_get(specEvent);
+ end
+
+end
+
+delete_SDL_Event(event);
+
+exec("swigtest.quit", -1);
\ No newline at end of file
--- /dev/null
+exec("swigtest.start", -1);
+
+try
+ small = new_SmallStruct();
+ SmallStruct_jill_set(small, 200);
+
+ big = new_BigStruct();
+ BigStruct_jack_set(big, 300);
+
+ Jill = SmallStruct_jill_get(small);
+catch
+ swigtesterror();
+end
+if Jill <> 200 then swigtesterror(); end
+
+try
+ Jack = BigStruct_jack_get(big);
+catch
+ swigtesterror();
+end
+if Jack <> 300 then swigtesterror(); end
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+checkequal(vararg_over1("Hello"), "Hello", "vararg_over1(""Hello"")");
+
+checkequal(vararg_over1(2), "2", "vararg_over1(2)");
+
+checkequal(vararg_over2("Hello"), "Hello", "vararg_over1(""Hello"")");
+
+checkequal(vararg_over2(2, 2.2), "2 2.2", "vararg_over2(2, 2.2)")
+
+checkequal(vararg_over3("Hello"), "Hello", "vararg_over3(""Hello"")");
+
+checkequal(vararg_over3(2, 2.2, "hey"), "2 2.2 hey", "vararg_over3(2, 2.2, ""hey"")");
+
+checkequal(vararg_over4("Hello"), "Hello", "vararg_over4(""Hello"")");
+
+checkequal(vararg_over4(123), "123", "vararg_over4(123)");
+
+checkequal(vararg_over4("Hello", 123), "Hello", "vararg_over4(""Hello"", 123)");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+checkequal(test("Hello"), "Hello", "test(""Hello"")");
+
+f = new_Foo("Greetings");
+checkequal(Foo_str_get(f), "Greetings", "new_Foo(""Greetings"")");
+
+checkequal(Foo_test(f, "Hello"), "Hello", "Foo_test(f)");
+delete_Foo(f);
+
+checkequal(Foo_statictest("Hello", 1), "Hello", "Foo_statictest(""Hello"", 1)");
+
+checkequal(test_def("Hello", 1), "Hello", "test_def(""Hello"", 1)");
+
+checkequal(test_def("Hello"), "Hello", "test_def(""Hello"")");
+
+exec("swigtest.quit", -1);
--- /dev/null
+exec("swigtest.start", -1);
+
+globalfunc();
+
+f = new_Foo();
+Foo_memberfunc(f);
+
+Foo_staticmemberfunc();
+
+v1 = vfunc1(f);
+checkequal(SWIG_this(v1), SWIG_this(f), "vfunc1(f) <> f");
+
+v2 = vfunc2(f);
+checkequal(SWIG_this(v2), SWIG_this(f), "vfunc2(f) <> f");
+
+v3 = vfunc3(v1);
+checkequal(SWIG_this(v3), SWIG_this(f), "vfunc3(f) <> f");
+
+Foo_memberfunc(v3);
+
+exec("swigtest.quit", -1);
+
--- /dev/null
+%module scilab_consts
+
+/* Default mode: constants are wrapped as getter functions */
+%scilabconst(0);
+
+#define ICONST0 42
+#define FCONST0 2.1828
+#define CCONST0 'x'
+#define CCONST0_2 '\n'
+#define SCONST0 "Hello World"
+#define SCONST0_2 "\"Hello World\""
+
+/* Constants with type */
+#define UNSIGNED0 0x5FFFU
+#define LONG0 0x3FFF0000L
+#define ULONG0 0x5FF0000UL
+
+/* Expressions should work too */
+#define EXPR0 ICONST0 + 3*FCONST0
+
+/* This shouldn't do anything, bar is not defined */
+#define BAR0 bar
+
+/* SWIG directive %constant produces constants too */
+%constant int iconst0 = 37;
+%constant double fconst0 = 42.2;
+
+
+/* Alternative mode: constants are wrapped as variables */
+%scilabconst(1);
+
+#define ICONST1 42
+#define FCONST1 2.1828
+#define CCONST1 'x'
+#define CCONST1_2 '\n'
+#define SCONST1 "Hello World"
+#define SCONST1_2 "\"Hello World\""
+
+/* Constants with type */
+#define UNSIGNED1 0x5FFFU
+#define LONG1 0x3FFF0000L
+#define ULONG1 0x5FF0000UL
+
+/* Expressions should work too */
+#define EXPR1 ICONST1 + 3*FCONST1
+
+/* This shouldn't do anything, bar is not defined */
+#define BAR1 bar
+
+/* SWIG directive %constant produces constants too */
+%constant int iconst1 = 37;
+%constant double fconst1 = 42.2;
--- /dev/null
+%module scilab_enums
+
+%scilabconst(1);
+
+%inline %{
+
+enum ENUM {
+ ENUM_1,
+ ENUM_2
+};
+
+enum ENUM_EXPLICIT_1 {
+ ENUM_EXPLICIT_1_1 = 5,
+ ENUM_EXPLICIT_1_2
+};
+
+enum ENUM_EXPLICIT_2 {
+ ENUM_EXPLICIT_2_1,
+ ENUM_EXPLICIT_2_2 = 10
+};
+
+enum ENUM_EXPLICIT_3 {
+ ENUM_EXPLICIT_3_1 = 2,
+ ENUM_EXPLICIT_3_2 = 5,
+ ENUM_EXPLICIT_3_3 = 8
+};
+
+typedef enum {
+ TYPEDEF_ENUM_1_1 = 21,
+ TYPEDEF_ENUM_1_2 = 22
+} TYPEDEF_ENUM_1;
+
+typedef enum TYPEDEF_ENUM_2 {
+ TYPEDEF_ENUM_2_1 = 31,
+ TYPEDEF_ENUM_2_2 = 32
+} TYPEDEF_ENUM_2;
+
+%}
--- /dev/null
+%module scilab_identifier_name
+
+//
+// Test long identifier name (> 24 characters) truncating
+//
+
+// Test truncating variables, constants, functions identifier names
+
+%inline %{
+// these identifier names wont be truncated
+int gvar_identifier_name = -1;
+#define CONS_IDENTIFIER_NAME -11
+int function_identifier_name() { return -21; };
+
+// these identifier names will be truncated
+int too_long_gvar_identifier_name_1 = 1;
+int too_long_gvar_identifier_name_2 = 2;
+
+#define TOO_LONG_CONST_IDENTIFIER_NAME_1 11
+
+int too_long_function_identifier_name_1() { return 21; };
+%}
+
+// Test truncating when %scilabconst mode is activated
+%scilabconst(1);
+
+%inline %{
+#define SC_CONST_IDENTIFIER_NAME -12;
+
+#define SC_TOO_LONG_CONST_IDENTIFIER_NAME_1 13
+#define SC_TOO_LONG_CONST_IDENTIFIER_NAME_2 14
+%}
+%scilabconst(0);
+
+// Test truncating in the case of struct
+%inline %{
+struct st {
+ int m_identifier_name;
+ int too_long_member_identifier_name;
+};
+
+%}
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+%module scilab_li_matrix
+
+%include "matrix.i"
+
+%define %use_matrix_apply(TYPE...)
+%apply (TYPE *IN, int IN_ROWCOUNT, int IN_COLCOUNT) { (TYPE *matrix, int nbRow, int nbCol) }
+%apply (TYPE **OUT, int *OUT_ROWCOUNT, int *OUT_COLCOUNT) { (TYPE **matrixRes, int *nbRowRes, int *nbColRes) }
+%apply (TYPE *IN, int IN_SIZE) { (TYPE *matrix, int size) }
+%apply (TYPE **OUT, int *OUT_SIZE) { (TYPE **matrixRes, int *sizeRes) }
+%enddef
+
+%use_matrix_apply(int);
+%use_matrix_apply(double);
+%use_matrix_apply(char *);
+%use_matrix_apply(bool);
+
+%inline %{
+
+/*
+ * (T *matrixIn, int matrixInSize) pattern functions
+ */
+
+template<typename T> T inMatrixSize(T *matrix, int size) {
+ T sum = 0;
+ int i;
+ for (i = 0; i < size; i++)
+ sum += matrix[i];
+ return sum;
+}
+
+template<typename T> void outMatrixSize(T **matrixRes, int *sizeRes) {
+ int size;
+ int i;
+ *sizeRes = 6;
+ *matrixRes = (T*) malloc(*sizeRes * sizeof(T));
+ for (i = 0; i < *sizeRes; i++)
+ (*matrixRes)[i] = i;
+}
+
+template<typename T> void inoutMatrixSize(T *matrix, int size, T **matrixRes, int *sizeRes) {
+ int i;
+ *sizeRes = size;
+ *matrixRes = (T*) malloc(size * sizeof(T));
+ for (i = 0; i < size; i++) {
+ (*matrixRes)[i] = matrix[i] * matrix[i];
+ }
+}
+
+/*
+ * (char **matrixIn, int matrixInSize) pattern functions
+ */
+
+template<> char* inMatrixSize(char **matrix, int size) {
+ char *s = (char *) calloc(size + 1, sizeof(char));
+ int i;
+ for (i = 0; i < size; i++)
+ strcat(s, matrix[i]);
+ return s;
+}
+
+template<> void outMatrixSize(char ***matrixRes, int *sizeRes) {
+ char *s;
+ int i;
+ *sizeRes = 6;
+ *matrixRes = (char **) malloc(*sizeRes * sizeof(char *));
+ for (i = 0; i < *sizeRes; i++) {
+ s = (char *) malloc(sizeof(char)+1);
+ sprintf(s, "%c", char(65 + i));
+ (*matrixRes)[i] = s;
+ }
+}
+
+template<> void inoutMatrixSize(char **matrix, int size,
+ char ***matrixRes, int *sizeRes) {
+ int i;
+ char *s;
+ *sizeRes = size;
+ *matrixRes = (char **) malloc(*sizeRes * sizeof(char* ));
+ for (i = 0; i < *sizeRes; i++) {
+ s = (char *) malloc((2 * strlen(matrix[i]) + 1) * sizeof(char));
+ sprintf(s, "%s%s", matrix[i], matrix[i]);
+ (*matrixRes)[i] = s;
+ }
+}
+
+/*
+ * (bool **matrixIn, int matrixInSize) pattern functions
+ */
+
+template<> bool inMatrixSize(bool *matrix, int size) {
+ bool b = true;
+ int i;
+ b = matrix[0];
+ for (i = 1; i < size; i++)
+ b = b ^ matrix[i];
+ return b;
+}
+
+template<> void outMatrixSize(bool **matrixRes, int *sizeRes) {
+ int i;
+ *sizeRes = 6;
+ *matrixRes = (bool*) malloc(*sizeRes * sizeof(bool));
+ for (i = 0; i < *sizeRes; i++) {
+ (*matrixRes)[i] = i % 2 == 0;
+ }
+}
+
+template<> void inoutMatrixSize(bool *matrix, int size,
+ bool **matrixRes, int *sizeRes) {
+ int i;
+ *sizeRes = size;
+ *matrixRes = (bool*) malloc(*sizeRes * sizeof(bool));
+ for (i = 0; i < *sizeRes; i++) {
+ (*matrixRes)[i] = matrix[i] == 1 ? 0 : 1;
+ }
+}
+
+/*
+ * (T *matrixIn, int matrixInRowCount, int matrixInColCount) pattern functions
+ */
+
+template<typename T> T inMatrixDims(T *matrix, int nbRow, int nbCol) {
+ return inMatrixSize(matrix, nbRow * nbCol);
+}
+
+template<typename T> void outMatrixDims(T **matrixRes, int *nbRowRes, int *nbColRes) {
+ int size = 0;
+ outMatrixSize(matrixRes, &size);
+ *nbRowRes = 3;
+ *nbColRes = 2;
+}
+
+template<typename T> void inoutMatrixDims(T *matrix, int nbRow, int nbCol,
+ T **matrixRes, int *nbRowRes, int *nbColRes) {
+ *nbRowRes = nbRow;
+ *nbColRes = nbCol;
+ int sizeRes = 0;
+ inoutMatrixSize(matrix, nbRow * nbCol, matrixRes, &sizeRes);
+}
+
+%}
+
+%define %instantiate_matrix_template_functions(NAME, TYPE...)
+%template(in ## NAME ## MatrixDims) inMatrixDims<TYPE>;
+%template(out ## NAME ## MatrixDims) outMatrixDims<TYPE>;
+%template(inout ## NAME ## MatrixDims) inoutMatrixDims<TYPE>;
+%template(in ## NAME ## MatrixSize) inMatrixSize<TYPE>;
+%template(out ## NAME ## MatrixSize) outMatrixSize<TYPE>;
+%template(inout ## NAME ## MatrixSize) inoutMatrixSize<TYPE>;
+%enddef
+
+%instantiate_matrix_template_functions(Int, int);
+%instantiate_matrix_template_functions(Double, double);
+%instantiate_matrix_template_functions(CharPtr, char *);
+%instantiate_matrix_template_functions(Bool, bool);
+
+
+
+
+
+
--- /dev/null
+%module scilab_multivalue
+
+
+
+void output2(int *OUTPUT, int *OUTPUT);
+int output2Ret(int *OUTPUT, int *OUTPUT);
+void output2Input2(int a, int b, int *OUTPUT, int *OUTPUT);
+int output2Input2Ret(int a, int b, int *OUTPUT, int *OUTPUT);
+int output3Input1Ret(int a, int *OUTPUT, int *OUTPUT, int *OUTPUT);
+int output3Input3Ret(int x, int *OUTPUT, int y, int *OUTPUT, int z, int *OUTPUT);
+
+void inout2(int *INOUT, int *INOUT);
+int inout2Ret(int *INOUT, int *INOUT);
+void inout2Input2(int a, int b, int *INOUT, int *INOUT);
+int inout2Input2Ret(int a, int b, int *INOUT, int *INOUT);
+int inout3Input1Ret(int a, int *INOUT, int *INOUT, int *INOUT);
+int inout3Input3Ret(int x, int *INOUT, int y, int *INOUT, int z, int *INOUT);
+
+class ClassA {
+public:
+ ClassA() {};
+ int output2Input2Ret(int a, int b, int *OUTPUT, int *OUTPUT);
+ int inout2Input2Ret(int a, int b, int *INOUT, int *INOUT);
+};
+
+%{
+
+// Test return of multiple values with OUTPUT
+
+void output2(int *a, int *b) {
+ *a = 1;
+ *b = 2;
+}
+
+int output2Ret(int *a, int *b) {
+ *a = 1;
+ *b = 2;
+ return *a + *b;
+}
+
+void output2Input2(int a, int b, int *c, int *d) {
+ *c = a + 1;
+ *d = b + 2;
+}
+
+int output2Input2Ret(int a, int b, int *c, int *d) {
+ *c = a + 1;
+ *d = b + 2;
+ return *c + *d;
+}
+
+int output3Input1Ret(int x, int *a, int *b, int *c) {
+ *a = x + 1;
+ *b = x + 2;
+ *c = x + 3;
+ return x;
+}
+
+int output3Input3Ret(int x, int *a, int y, int *b, int z, int *c) {
+ *a = x + 1;
+ *b = y + 2;
+ *c = z + 3;
+ return *a + *b + *c;
+}
+
+
+// Test return of multiple values with INOUT
+
+void inout2(int *a, int *b) {
+ *a = *a + 1;
+ *b = *a + 2;
+}
+
+int inout2Ret(int *a, int *b) {
+ *a = *a + 1;
+ *b = *a + 2;
+ return *a + *b;
+}
+
+void inout2Input2(int a, int b, int *c, int *d) {
+ *c = *c + a;
+ *d = *d + b;
+}
+
+int inout2Input2Ret(int a, int b, int *c, int *d) {
+ *c = *c + a;
+ *d = *d + b;
+ return *c + *d;
+}
+
+int inout3Input1Ret(int x, int *a, int *b, int *c) {
+ *a = *a + x;
+ *b = *b + x;
+ *c = *c + x;
+ return x;
+}
+
+int inout3Input3Ret(int x, int *a, int y, int *b, int z, int *c) {
+ *a = *a + x;
+ *b = *b + y;
+ *c = *c + z;
+ return *a + *b + *c;
+}
+
+// Test return multiples from class methods
+
+class ClassA {
+public:
+ ClassA() {};
+ int output2Input2Ret(int a, int b, int *c, int *d) {
+ *c = a + 1;
+ *d = b + 2;
+ return *c + *d;
+ }
+ int inout2Input2Ret(int a, int b, int *c, int *d) {
+ *c = *c + a;
+ *d = *d + b;
+ return *c + *d;
+ }
+};
+
+
+%}
--- /dev/null
+%module scilab_pointer_conversion_functions
+
+%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) pfoo; /* Setting a pointer/reference variable may leak memory. */
+
+%inline %{
+
+void* getNull() { return NULL; }
+bool isNull(void *p) { return p == NULL; }
+
+int foo = 3;
+int *pfoo = &foo;
+
+double getFooAddress() { return (double) (unsigned long) pfoo; }
+bool equalFooPointer(void *p) { return p == pfoo; }
+
+%}
+
+
%module sizeof_pointer
+
%inline %{
#define NO_PROBLEM sizeof(char)
#define STAR_PROBLEM sizeof(char*)
#define STAR_STAR_PROBLEM sizeof(char**)
-typedef struct SizeofPointerTest {
+typedef struct SizePtrTst {
unsigned char array1[NO_PROBLEM];
unsigned char array2[STAR_PROBLEM];
unsigned char array3[STAR_STAR_PROBLEM];
-} SizeofPointerTest;
+} SizePtrTst;
%}
Foo() : x(0), xp(&x), y(0), yp(&y), access(0) { }
int getx() const { return x; }
void setx(int x_) { x = x_; }
- static void stat() {}
+ static void statMethod() {}
};
%}
--- /dev/null
+%module smart_pointer_ignore
+
+
+%ignore Derived;
+
+%inline %{
+class Base {
+ public:
+ void base() {}
+};
+
+class Derived : public Base {
+ public:
+ void derived() {}
+};
+
+template <class T>
+class Ptr {
+public:
+ Ptr(T *t) : ptr(t) {}
+ T * operator->() const { return ptr; }
+private:
+ T *ptr;
+};
+%}
+
+%template(DerivedPtr) Ptr<Derived>;
+
+%inline %{
+Ptr<Derived> makeDerived() {
+ return Ptr<Derived>(new Derived());
+}
+%}
%inline %{
class ItkLevelSetNodeUS2 {
+ int x;
};
%}
--- /dev/null
+%module smart_pointer_template_defaults_overload
+
+// SF Bug #1363
+// Problem with method overloading when some methods are added by %extend and others are real methods
+// and using template default parameters with smart pointers.
+
+%warnfilter(SWIGWARN_LANG_OVERLOAD_IGNORED) Wrap::operator->;
+%warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) Container::rubout;
+
+%include <std_string.i>
+%include <std_map.i>
+
+%inline %{
+template <typename T>
+class Wrap {
+T *ptr;
+public:
+ Wrap(T *p) : ptr(p) {}
+ T const* operator->(void) const { return ptr; }
+ T* operator->(void) { return ptr; }
+};
+%}
+
+%template(StringDoubleMap) std::map<std::string, double>; // erase is generated okay
+%template(WrappedMap) Wrap< std::map<std::string, double> >; // erase wrappers lead to compile error
+
+// Above only affects some languages depending on how std::map is implemented.
+// Below is a cutdown language independent demonstration of the bug
+
+%extend Container {
+ void rubout(int, int) {}
+}
+
+%inline %{
+template<typename T, typename X = T> class Container {
+public:
+ int rubout() { return 0; }
+ void rubout(T const &element) {}
+ static Container* factory() { return new Container(); }
+ static Container* factory(bool b) { return new Container(); }
+ static void staticstuff(bool) {}
+#ifdef SWIG
+ %extend {
+ void rubout(bool) {}
+ }
+#endif
+};
+%}
+
+%extend Container {
+ void rubout(int) {}
+}
+
+%template(ContainerInt) Container<double>;
+%template(WrapContainerInt) Wrap< Container<double> >;
+
%template(QueryInterfaceObjct) Objct::QueryInterface<Objct>;
#endif
-}; // namespace
+} // namespace
%}
--- /dev/null
+%module special_variable_attributes
+
+// Special variable expansion and special variable macros, aka embedded typemaps - expansion tests
+// Tests these are expanded within typemap attributes.
+// Also tests that these are expanded when used together, so that the special variables
+// can be used as the type passed to the special variable macro.
+// C# is used for testing as it is one of the few languages that uses a lot of typemap attributes.
+// Attributes in both 'in' and 'out' typemaps are needed, that is,
+// typemaps targeting both parameters and return values respectively).
+
+#ifdef SWIGCSHARP
+// Check special variable expansion in typemap attributes.
+// This changes return by reference into return by value.
+// Takes advantage of the fact that 'int' is a valid type in both C and C#.
+// This is not a realistic use, just a way to test the variable expansion in the 'out' attribute.
+%typemap(ctype, out="$*1_ltype") int& getNumber1 "_not_used_"
+%typemap(imtype, out="$*1_ltype") int& getNumber1 "_not_used_"
+%typemap(cstype, out="$*1_ltype") int& getNumber1 "_not_used_"
+%typemap(out) int& getNumber1 "$result = *$1;"
+%typemap(csout, excode=SWIGEXCODE) int & getNumber1 {
+ int ret = $imcall;$excode
+ return ret;
+ }
+#endif
+
+%inline %{
+int& getNumber1() {
+ static int num = 111;
+ return num;
+}
+%}
+
+#ifdef SWIGCSHARP
+// Check special variable macro expansion in typemap attributes.
+// This changes return by reference into return by value.
+%typemap(ctype, out="$typemap(ctype, int)") int& getNumber2 "_not_used_"
+%typemap(imtype, out="$typemap(imtype, int)") int& getNumber2 "_not_used_"
+%typemap(cstype, out="$typemap(cstype, int)") int& getNumber2 "_not_used_"
+%typemap(out) int& getNumber2 "$result = *$1;"
+%typemap(csout, excode=SWIGEXCODE) int & getNumber2 {
+ int ret = $imcall;$excode
+ return ret;
+ }
+#endif
+
+%inline %{
+int& getNumber2() {
+ static int num = 222;
+ return num;
+}
+%}
+
+
+#ifdef SWIGCSHARP
+// Check special variable macro expansion and special variable expansion in typemap attributes.
+// This changes return by reference into return by value.
+%typemap(ctype, out="$typemap(ctype, $*1_ltype)") int& getNumber3 "_not_used_"
+%typemap(imtype, out="$typemap(imtype, $*1_ltype)") int& getNumber3 "_not_used_"
+%typemap(cstype, out="$typemap(cstype, $*1_ltype)") int& getNumber3 "_not_used_"
+%typemap(out) int& getNumber3 "$result = *$1;"
+%typemap(csout, excode=SWIGEXCODE) int & getNumber3 {
+ int ret = $imcall;$excode
+ return ret;
+ }
+#endif
+
+%inline %{
+int& getNumber3() {
+ static int num = 333;
+ return num;
+}
+%}
+
+#ifdef SWIGCSHARP
+// Check special variable macro expansion in typemap attributes.
+%typemap(csin,
+ pre=" $typemap(cstype, int) $csinput_scaled = 11;"
+ ) int num1
+%{$csinput * $csinput_scaled %}
+#endif
+
+%inline %{
+int bounceNumber1(int num1) {
+ return num1;
+}
+%}
+
+#ifdef SWIGCSHARP
+// Check special variable expansion in typemap attributes.
+%typemap(csin,
+ pre=" $1_type $csinput_scaled = 22;"
+ ) int num2
+%{$csinput * $csinput_scaled %}
+#endif
+
+%inline %{
+int bounceNumber2(int num2) {
+ return num2;
+}
+%}
+
+#ifdef SWIGCSHARP
+// Check special variable and special variable macro expansion in typemap attributes.
+%typemap(csin,
+ pre=" $typemap(cstype, $1_type) $csinput_scaled = 33;"
+ ) int num3
+%{$csinput * $csinput_scaled %}
+#endif
+
+%inline %{
+int bounceNumber3(int num3) {
+ return num3;
+}
+%}
+
+/////////////////////////////////
+//// Multi-argument typemaps ////
+/////////////////////////////////
+
+// Test expansion of special variables
+#ifdef SWIGCSHARP
+%typemap(ctype) (int intvar, char charvar) "double"
+%typemap(imtype) (int intvar, char charvar) "double"
+%typemap(cstype) (int intvar, char charvar) "double"
+%typemap(in) (int intvar, char charvar)
+%{
+ // split double value a.b into two numbers, a and b*100
+ $1 = (int)$input;
+ $2 = (char)(($input - $1 + 0.005) * 100);
+%}
+%typemap(csin,
+ pre=" $1_type $csinput_$1_type = 50;\n" // $1_type should expand to int
+ " $2_type $csinput_$2_type = 'A';" // $2_type should expand to char
+ ) (int intvar, char charvar)
+%{$csinput + ($csinput_int - 50 + $csinput_char - 'A') + ($csinput_$1_type - 50 + $csinput_$2_type - 'A')%}
+#endif
+
+%inline %{
+int multi1(int intvar, char charvar) {
+ return intvar + charvar;
+}
+%}
+
+#ifdef SWIGCSHARP
+%typemap(csin,
+ pre=" $typemap(cstype, int) $csinput_$typemap(cstype, int) = 50;\n" // also should expand to int
+ " $typemap(cstype, char) $csinput_$typemap(cstype, char) = 'A';" // also should expand to char
+ ) (int intvar, char charvar)
+%{55 + $csinput + ($csinput_int - 50 + $csinput_char - 'A') + ($csinput_$typemap(cstype, int) - 50 + $csinput_$typemap(cstype, char) - 'A')%}
+#endif
+
+%inline %{
+int multi2(int intvar, char charvar) {
+ return intvar + charvar;
+}
+%}
+
+#ifdef SWIGCSHARP
+%typemap(csin,
+ pre=" $typemap(cstype, $1_type) $csinput_$typemap(cstype, $1_type) = 50;\n" // also should expand to int
+ " $typemap(cstype, $2_type) $csinput_$typemap(cstype, $2_type) = 'A';" // also should expand to char
+ ) (int intvar, char charvar)
+%{77 + $csinput + ($csinput_int - 50 + $csinput_char - 'A') + ($csinput_$typemap(cstype, $1_type) - 50 + $csinput_$typemap(cstype, $2_type) - 'A')%}
+#endif
+
+%inline %{
+int multi3(int intvar, char charvar) {
+ return intvar + charvar;
+}
+%}
#if defined(SWIGCSHARP)
%typemap(cscode) Space::RenameMe %{
- public static NewName factory(String s) {
+ public static NewName factory(System.String s) {
//below should expand to:
//return new NewName( new Name(s) );
return new $typemap(cstype, Space::RenameMe)( new $typemap(cstype, Name)(s) );
struct Foo
{
- Foo(int i) {
+ int x;
+ Foo(int i) : x(i) {
}
};
--- /dev/null
+%module string_constants
+// Test unusual string constants
+
+%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK);
+
+#if defined(SWIGCSHARP)
+%csconst(1);
+%csconstvalue("\"AEIOU\\n\"") SS1;
+%csconstvalue("\"AEIOU\\n\"") SS2;
+#endif
+#if defined(SWIGJAVA)
+%javaconst(1);
+#endif
+%inline %{
+#define SS1 "ÆÎOU\n"
+#define AA1 "A\rB\nC"
+#define EE1 "\124\125\126"
+#define XX1 "\x57\x58\x59"
+#define ZS1 "\0"
+#define ES1 ""
+%}
+%constant SS2="ÆÎOU\n";
+%constant AA2="A\rB\nC";
+%constant EE2="\124\125\126";
+%constant XX2="\x57\x58\x59";
+%constant ZS2="\0";
+%constant ES2="";
+
+%inline %{
+static const char *SS3 = "ÆÎOU\n";
+static const char *AA3 = "A\rB\nC";
+static const char *EE3 = "\124\125\126";
+static const char *XX3 = "\x57\x58\x59";
+static const char *ZS3 = "\0";
+static const char *ES3 = "";
+struct things {
+ const char * defarguments1(const char *SS4 = "ÆÎOU\n") { return SS4; }
+ const char * defarguments2(const char *AA4 = "A\rB\nC") { return AA4; }
+ const char * defarguments3(const char *EE4 = "\124\125\126") { return EE4; }
+ const char * defarguments4(const char *XX4 = "\x57\x58\x59") { return XX4; }
+ const char * defarguments5(const char *ZS4 = "\0") { return ZS4; }
+ const char * defarguments6(const char *ES4 = "") { return ES4; }
+};
+%}
--- /dev/null
+%module string_simple
+
+%newobject copy_string;
+
+%inline %{
+#include <string.h>
+const char* copy_string(const char* str) {
+ size_t len = strlen(str);
+ char* newstring = (char*) malloc(len + 1);
+ strcpy(newstring, str);
+ return newstring;
+}
+%}
%inline %{
-// Named types
+/* Named types */
struct StructA {
int x;
} instanceA1;
LANGUAGE = tcl
TCLSH = tclsh
-SCRIPTSUFFIX = _runme.tcl
+SCRIPTSUFFIX = _runme.tcl
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
# none!
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.tcl appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(TCLSH) $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(TCLSH) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
# Clean
%.clean:
-
+ @exit 0
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile tcl_clean
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' tcl_clean
--- /dev/null
+
+if [ catch { load ./cpp11_strongly_typed_enumerations[info sharedlibextension] cpp11_strongly_typed_enumerations} err_msg ] {
+ puts stderr "Could not load shared object:\n$err_msg"
+}
+
+proc enumCheck {actual expected} {
+ if {$actual != $expected} {
+ error "Enum value mismatch. Expected $expected. Actual: $actual"
+ }
+ return [expr $expected + 1]
+}
+
+#set val 0
+#set val [enumCheck $Enum1_Val1 $val]
+#set val [enumCheck $Enum1_Val2 $val]
+
+set val 0
+set val [enumCheck $Enum1_Val1 $val]
+set val [enumCheck $Enum1_Val2 $val]
+set val [enumCheck $Enum1_Val3 13]
+set val [enumCheck $Enum1_Val4 $val]
+set val [enumCheck $Enum1_Val5a 13]
+set val [enumCheck $Enum1_Val6a $val]
+
+set val 0
+set val [enumCheck $Enum2_Val1 $val]
+set val [enumCheck $Enum2_Val2 $val]
+set val [enumCheck $Enum2_Val3 23]
+set val [enumCheck $Enum2_Val4 $val]
+set val [enumCheck $Enum2_Val5b 23]
+set val [enumCheck $Enum2_Val6b $val]
+
+set val 0
+set val [enumCheck $Val1 $val]
+set val [enumCheck $Val2 $val]
+set val [enumCheck $Val3 43]
+set val [enumCheck $Val4 $val]
+
+set val 0
+set val [enumCheck $Enum5_Val1 $val]
+set val [enumCheck $Enum5_Val2 $val]
+set val [enumCheck $Enum5_Val3 53]
+set val [enumCheck $Enum5_Val4 $val]
+
+set val 0
+set val [enumCheck $Enum6_Val1 $val]
+set val [enumCheck $Enum6_Val2 $val]
+set val [enumCheck $Enum6_Val3 63]
+set val [enumCheck $Enum6_Val4 $val]
+
+set val 0
+set val [enumCheck $Enum7td_Val1 $val]
+set val [enumCheck $Enum7td_Val2 $val]
+set val [enumCheck $Enum7td_Val3 73]
+set val [enumCheck $Enum7td_Val4 $val]
+
+set val 0
+set val [enumCheck $Enum8_Val1 $val]
+set val [enumCheck $Enum8_Val2 $val]
+set val [enumCheck $Enum8_Val3 83]
+set val [enumCheck $Enum8_Val4 $val]
+
+set val 0
+set val [enumCheck $Enum10_Val1 $val]
+set val [enumCheck $Enum10_Val2 $val]
+set val [enumCheck $Enum10_Val3 103]
+set val [enumCheck $Enum10_Val4 $val]
+
+set val 0
+set val [enumCheck $Class1_Enum12_Val1 1121]
+set val [enumCheck $Class1_Enum12_Val2 1122]
+set val [enumCheck $Class1_Enum12_Val3 $val]
+set val [enumCheck $Class1_Enum12_Val4 $val]
+set val [enumCheck $Class1_Enum12_Val5c 1121]
+set val [enumCheck $Class1_Enum12_Val6c $val]
+
+set val 0
+set val [enumCheck $Class1_Val1 1131]
+set val [enumCheck $Class1_Val2 1132]
+set val [enumCheck $Class1_Val3 $val]
+set val [enumCheck $Class1_Val4 $val]
+set val [enumCheck $Class1_Val5d 1131]
+set val [enumCheck $Class1_Val6d $val]
+
+set val 0
+set val [enumCheck $Class1_Enum14_Val1 1141]
+set val [enumCheck $Class1_Enum14_Val2 1142]
+set val [enumCheck $Class1_Enum14_Val3 $val]
+set val [enumCheck $Class1_Enum14_Val4 $val]
+set val [enumCheck $Class1_Enum14_Val5e 1141]
+set val [enumCheck $Class1_Enum14_Val6e $val]
+
+# Requires nested class support to work
+#set val 0
+#set val [enumCheck $Class1_Struct1_Enum12_Val1 3121]
+#set val [enumCheck $Class1_Struct1_Enum12_Val2 3122]
+#set val [enumCheck $Class1_Struct1_Enum12_Val3 $val]
+#set val [enumCheck $Class1_Struct1_Enum12_Val4 $val]
+#set val [enumCheck $Class1_Struct1_Enum12_Val5f 3121]
+#set val [enumCheck $Class1_Struct1_Enum12_Val6f $val]
+#
+#set val 0
+#set val [enumCheck $Class1_Struct1_Val1 3131]
+#set val [enumCheck $Class1_Struct1_Val2 3132]
+#set val [enumCheck $Class1_Struct1_Val3 $val]
+#set val [enumCheck $Class1_Struct1_Val4 $val]
+#
+#set val 0
+#set val [enumCheck $Class1_Struct1_Enum14_Val1 3141]
+#set val [enumCheck $Class1_Struct1_Enum14_Val2 3142]
+#set val [enumCheck $Class1_Struct1_Enum14_Val3 $val]
+#set val [enumCheck $Class1_Struct1_Enum14_Val4 $val]
+#set val [enumCheck $Class1_Struct1_Enum14_Val5g 3141]
+#set val [enumCheck $Class1_Struct1_Enum14_Val6g $val]
+
+set val 0
+set val [enumCheck $Class2_Enum12_Val1 2121]
+set val [enumCheck $Class2_Enum12_Val2 2122]
+set val [enumCheck $Class2_Enum12_Val3 $val]
+set val [enumCheck $Class2_Enum12_Val4 $val]
+set val [enumCheck $Class2_Enum12_Val5h 2121]
+set val [enumCheck $Class2_Enum12_Val6h $val]
+
+set val 0
+set val [enumCheck $Class2_Val1 2131]
+set val [enumCheck $Class2_Val2 2132]
+set val [enumCheck $Class2_Val3 $val]
+set val [enumCheck $Class2_Val4 $val]
+set val [enumCheck $Class2_Val5i 2131]
+set val [enumCheck $Class2_Val6i $val]
+
+set val 0
+set val [enumCheck $Class2_Enum14_Val1 2141]
+set val [enumCheck $Class2_Enum14_Val2 2142]
+set val [enumCheck $Class2_Enum14_Val3 $val]
+set val [enumCheck $Class2_Enum14_Val4 $val]
+set val [enumCheck $Class2_Enum14_Val5j 2141]
+set val [enumCheck $Class2_Enum14_Val6j $val]
+
+# Requires nested class support to work
+#set val 0
+#set val [enumCheck $Class2_Struct1_Enum12_Val1 4121]
+#set val [enumCheck $Class2_Struct1_Enum12_Val2 4122]
+#set val [enumCheck $Class2_Struct1_Enum12_Val3 $val]
+#set val [enumCheck $Class2_Struct1_Enum12_Val4 $val]
+#set val [enumCheck $Class2_Struct1_Enum12_Val5k 4121]
+#set val [enumCheck $Class2_Struct1_Enum12_Val6k $val]
+#
+#set val 0
+#set val [enumCheck $Class2_Struct1_Val1 4131]
+#set val [enumCheck $Class2_Struct1_Val2 4132]
+#set val [enumCheck $Class2_Struct1_Val3 $val]
+#set val [enumCheck $Class2_Struct1_Val4 $val]
+#set val [enumCheck $Class2_Struct1_Val5l 4131]
+#set val [enumCheck $Class2_Struct1_Val6l $val]
+#
+#set val 0
+#set val [enumCheck $Class2_Struct1_Enum14_Val1 4141]
+#set val [enumCheck $Class2_Struct1_Enum14_Val2 4142]
+#set val [enumCheck $Class2_Struct1_Enum14_Val3 $val]
+#set val [enumCheck $Class2_Struct1_Enum14_Val4 $val]
+#set val [enumCheck $Class2_Struct1_Enum14_Val5m 4141]
+#set val [enumCheck $Class2_Struct1_Enum14_Val6m $val]
+
+set class1 [Class1]
+enumCheck [$class1 class1Test1 $Enum1_Val5a] 13
+enumCheck [$class1 class1Test2 $Class1_Enum12_Val5c] 1121
+#enumCheck [$class1 class1Test3 $Class1_Struct1_Enum12_Val5f] 3121
+
+enumCheck [globalTest1 $Enum1_Val5a] 13
+enumCheck [globalTest2 $Class1_Enum12_Val5c] 1121
+#enumCheck [globalTest3 $Class1_Struct1_Enum12_Val5f] 3121
public:
Point<T>& getPoint() {return point;}
void setPoint(Point<T>& value) {point = value;}
+
+ static int static_noargs() { return 0; }
+ static int static_onearg(int i) { return i; }
private:
Point<T> point;
X(const T& t = T()) {}
X(double a, const T& t = T(0)) {}
T meth(double a, const T& t = T(0)) { return t; }
- const T& meth(const T& t = T(0)) { return t; }
+ const T& meth(const T& t = T(0)) { static T tt; tt = t; return tt; }
};
template <typename TT> class Y : private X<TT> {
--- /dev/null
+%module template_default_arg_overloaded
+
+// Github issue #529
+
+%include <std_string.i>
+
+%inline %{
+#include <string>
+
+namespace lsst {
+namespace daf {
+namespace bass {
+
+class PropertyList {
+public:
+ PropertyList(void) {};
+
+ virtual ~PropertyList(void) {};
+
+ template <typename T> int set(std::string const& name1, T const& value1, bool inPlace1=true) { return 1; }
+
+ int set(std::string const& name2, PropertyList const& value2, bool inPlace2=true) { return 2; }
+
+ template <typename T> int set(std::string const& name3, T const& value3, std::string const& comment3, bool inPlace3=true) { return 3; }
+};
+
+}}} // namespace lsst::daf::bass
+
+// As above but in global namespace
+class PropertyListGlobal {
+public:
+ PropertyListGlobal(void) {};
+
+ virtual ~PropertyListGlobal(void) {};
+
+ template <typename T> int set(std::string const& name1, T const& value1, bool inPlace1=true) { return 1; }
+
+ int set(std::string const& name2, PropertyListGlobal const& value2, bool inPlace2=true) { return 2; }
+
+ template <typename T> int set(std::string const& name3, T const& value3, std::string const& comment3, bool inPlace3=true) { return 3; }
+};
+
+%}
+
+%template(setInt) lsst::daf::bass::PropertyList::set<int>;
+%template(setIntGlobal) PropertyListGlobal::set<int>;
+
+
+// Global functions
+%inline %{
+template<typename T> int goopGlobal(T i1, bool b1 = true) { return 1; }
+int goopGlobal(short s2 = 0) { return 2; }
+template<typename T> int goopGlobal(const char *s3, bool b3 = true) { return 3; }
+%}
+
+// Global functions in a namespace
+%inline %{
+namespace lsst {
+template<typename T> int goop(T i1, bool b1 = true) { return 1; }
+int goop(short s2 = 0) { return 2; }
+template<typename T> int goop(const char *s3, bool b3 = true) { return 3; }
+}
+%}
+
+%template(GoopIntGlobal) goopGlobal<int>;
+%template(GoopInt) lsst::goop<int>;
+
--- /dev/null
+%module template_default_arg_overloaded_extend
+
+%inline %{
+namespace gaia2 {
+
+struct Filter {};
+struct SearchPoint {};
+struct DataSet {};
+
+template <typename SearchPointType, typename DataSetType>
+class BaseSearchSpace {};
+
+template <typename SearchPointType, typename DataSetType>
+class BaseResultSet {
+public:
+ const char *over(int i = 0) {
+ return "over(int)";
+ }
+};
+}
+%}
+
+// Specialized template extend
+%extend gaia2::BaseResultSet<gaia2::SearchPoint, gaia2::DataSet> {
+ int go_get_method(int n, gaia2::SearchPoint, int offset = -1) {
+ return offset;
+ }
+ const char *over(gaia2::SearchPoint, int x = 0) {
+ return "over(giai2::SearchPoint, int)";
+ }
+}
+
+// Generic extend for all template instantiations
+%extend gaia2::BaseResultSet {
+ int go_get_template(int n, SearchPointType sss, int offset = -2) {
+ return offset;
+ }
+ const char *over(bool b, SearchPointType, int x = 0) {
+ return "over(bool, SearchPointType, int)";
+ }
+}
+
+%template(ResultSet) gaia2::BaseResultSet<gaia2::SearchPoint, gaia2::DataSet>;
+
%template(FooAnotherType) Space::Foo<Space::AnotherType>;
%template() Space::ATemplate<>;
+
+
+// Github issue #280 segfault
+%inline %{
+namespace Teuchos {
+ class Describable {};
+}
+namespace KokkosClassic {
+ namespace DefaultNode {
+ struct DefaultNodeType {};
+ }
+}
+
+namespace Tpetra {
+ template <class LocalOrdinal = int,
+ class GlobalOrdinal = LocalOrdinal,
+ class Node = KokkosClassic::DefaultNode::DefaultNodeType>
+ class Map : public Teuchos::Describable {
+ public:
+ typedef LocalOrdinal local_ordinal_type;
+ typedef GlobalOrdinal global_ordinal_type;
+ typedef Node node_type;
+ void test_func(LocalOrdinal, GlobalOrdinal, Node) {}
+ };
+}
+%}
+
+#ifdef SWIGJAVA
+// Fixes still required for other languages
+%template(MapDefaults) Tpetra::Map<>;
+#endif
+
+%inline %{
+namespace Details {
+ template < class LO = ::Tpetra::Map<>::local_ordinal_type,
+ class GO = typename ::Tpetra::Map<LO>::global_ordinal_type,
+ class NT = typename ::Tpetra::Map<LO, GO>::node_type >
+ class Transfer : public Teuchos::Describable {
+ public:
+ void transfer_func(LO, GO, NT) {}
+ };
+}
+%}
+
+// Below is not resolving correctly yet
+//%template(TransferDefaults) Details::Transfer<>;
--- /dev/null
+%module template_keyword_in_type
+
+%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) YYY;
+
+%inline %{
+ template<typename T> struct XXX;
+
+ template<typename T> struct XXX {
+ template<typename TT> struct YYY {
+ typedef TT type;
+ };
+ int xxx(int h) { return h; }
+ };
+
+#if defined(SWIG) || defined(__clang__)
+ // gcc doesn't parse this (tested with gcc-4.8)
+ template<typename X> void testXXX1(::template XXX<int>::template YYY<int>::type xx) {}
+#else
+ template<typename X> void testXXX1(:: XXX<int>::template YYY<int>::type xx) {}
+#endif
+ template<typename X> void testXXX2(XXX<int>::YYY<int>::type xx) {}
+ template<typename X> void testXXX3(::XXX<int>::template YYY<int>::type) {}
+%}
+
+%inline %{
+typedef double Val;
+template<typename T> struct ListBucket {
+};
+namespace Alloc {
+ template<typename T> struct rebind {
+ typedef int other;
+ };
+}
+
+template<typename X> void other1(typename Alloc::template rebind<ListBucket<Val> >::other) {}
+#if !defined(__SUNPRO_CC)
+template<typename X> void other2(typename Alloc::template rebind< ::template ListBucket<Val> >::other) {}
+#else
+template<typename X> void other2(typename Alloc::template rebind< :: ListBucket<Val> >::other) {}
+#endif
+template<typename X> void other3(Alloc::template rebind<int>) {}
+%}
template<class _POP1, class _POP2 = POP>
class Operator
{
+ int x;
};
}
%module template_nested
-// Test nested templates - that is template classes and template methods within a class.
+#if !defined(SWIGCSHARP) && !defined(SWIGJAVA)
+%feature ("flatnested");
+#endif
-%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) ns::OuterClass::Inner1;
-%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) ns::OuterClass::Inner2;
-%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) ns::OuterTemplate::NestedInnerTemplate1;
-%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) ns::OuterTemplate::NestedInnerTemplate2;
-%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) ns::OuterTemplate::NestedInnerTemplate3;
-%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) ns::OuterTemplate::NestedStruct;
+// Test nested templates - that is template classes and template methods within a class.
namespace ns {
template <class T> struct ForwardTemplate;
template <class T> struct NormalTemplate {
void tmethod(T t) {}
};
+}
+%}
+%template(T_NormalTemplateNormalClass) ns::NormalTemplate<ns::NormalClass>;
+%template(T_NormalTemplateInt) ns::NormalTemplate<int>;
+%template(T_NormalTemplateDouble) ns::NormalTemplate<double>;
+%inline %{
+namespace ns {
class OuterClass {
public:
template <class T> struct Inner1 {
};
};
Inner2<int> useInner2(const Inner2<int>& inner) { return inner; }
+ Inner2<NormalClass> useInner2Again(const Inner2<NormalClass>& inner) { return inner; }
+#ifdef SWIG
+ %template(T_OuterClassInner1Double) Inner1<double>;
+#endif
int iii;
};
struct ABC {
NestedStruct useNestedStruct(const NestedStruct& inner) { return inner; }
};
}
-
%}
-%template(T_NormalTemplateNormalClass) ns::NormalTemplate<ns::NormalClass>;
+#if !defined(SWIGSCILAB)
+%extend ns::OuterClass {
+ %template(T_OuterClassInner2Double) Inner2<double>;
+}
+
%template(T_OuterTMethodNormalClass) ns::OuterClass::InnerTMethod<ns::NormalClass>;
%template(T_TemplateFuncs1Int) ns::TemplateFuncs::templateMethod1<int>;
%template(T_TemplateFuncs2Double) ns::TemplateFuncs::templateMethod2<double>;
%template(T_NestedOuterTemplateDouble) ns::OuterTemplate<double>;
+%template(T_OuterClassInner1Int) ns::OuterClass::Inner1<int>;
+%template(T_OuterClassInner2NormalClass) ns::OuterClass::Inner2<ns::NormalClass>;
+%template(T_OuterClassInner2Int) ns::OuterClass::Inner2<int>;
+
+#else
+%extend ns::OuterClass {
+ %template(T_OutClsIn2Dbl) Inner2<double>;
+}
+
+%template(T_OutClsIn1Int) ns::OuterClass::Inner1<int>;
+%template(T_OutClsIn2NormCls) ns::OuterClass::Inner2<ns::NormalClass>;
+%template(T_OutClsIn2Int) ns::OuterClass::Inner2<int>;
+#endif
{
struct OpaqueStruct
{
+ int x;
};
}
--- /dev/null
+%module template_private_assignment
+
+/*
+swig-devel mailing list report problem explained 2014-01-07
+A setter for the global variable deleted_bits is generated because there is no template
+instantiation for the template and hence SWIG does not find the private assignment operator.
+SwigValueWrapper is probably on by default for templates that are not instantiated for the
+same reason.
+The solution is probably to add an instantiation of the template as soon as one is parsed,
+that is an implicit empty %template().
+*/
+
+%inline %{
+template<typename T, typename U> struct DeletedBits {
+// DeletedBits& operator=(const DeletedBits&) = delete;
+private:
+ DeletedBits& operator=(const DeletedBits&);
+};
+
+DeletedBits<int, double> deleted_bits;
+%}
+
+// This works around the problem
+//%template() DeletedBits<int, double>;
template<typename t_item, typename t2> class list_impl_t {};
template<typename t_item, template<typename> class t_alloc = pfc::alloc_fast >
- class list_t : public list_impl_t<t_item,pfc::array_t<t_item,t_alloc> > {
+ class list_tt : public list_impl_t<t_item,pfc::array_t<t_item,t_alloc> > {
public:
t_item item;
// typename t_alloc<t_item>::alloc_type allotype; // SWIG can't handle this yet
%}
%template(ListImplFastBool) list_impl_t<bool, pfc::array_t<bool, pfc::alloc_fast> >;
-%template(ListFastBool) list_t<bool, pfc::alloc_fast>;
+%template(ListFastBool) list_tt<bool, pfc::alloc_fast>;
%template(ListImplFastDouble) list_impl_t<double, pfc::array_t<double, pfc::alloc_fast> >;
-%template(ListDefaultDouble) list_t<double>;
+%template(ListDefaultDouble) list_tt<double>;
--- /dev/null
+%module template_templated_constructors
+
+%inline %{
+namespace ConstructSpace {
+
+class TConstructor1 {
+public:
+ template<typename T> TConstructor1(T val) {}
+ ~TConstructor1() {}
+};
+
+class TConstructor2 {
+public:
+ TConstructor2() {}
+ template<typename T> TConstructor2(T val) {}
+ ~TConstructor2() {}
+};
+
+template<typename T> class TClass1 {
+public:
+ template<typename Y> TClass1(Y t) {}
+};
+
+template<typename T> class TClass2 {
+public:
+ TClass2() {}
+ template<typename Y> TClass2(Y t) {}
+};
+
+}
+%}
+
+%extend ConstructSpace::TConstructor1 {
+ %template(TConstructor1) TConstructor1<int>;
+}
+
+%template(TConstructor2) ConstructSpace::TConstructor2::TConstructor2<int>;
+
+%template(TClass1Int) ConstructSpace::TClass1<int>;
+%extend ConstructSpace::TClass1<int> {
+ %template(TClass1Int) TClass1<double>;
+}
+
+%template(TClass2Int) ConstructSpace::TClass2<int>;
+%extend ConstructSpace::TClass2<int> {
+ %template(TClass2Int) TClass2<double>;
+}
typedef std::string String;
namespace Type {
- template <class T> class TypedInterfaceObject {};
+ template <class T> class TypedInterfaceObject {
+ public:
+ virtual ~TypedInterfaceObject() {}
+ };
template <class T> class TypedCollectionInterfaceObject : public TypedInterfaceObject<T> {
public:
/** Method add() appends an element to the collection */
inline virtual void add(const T & elt) {}
+ virtual ~PersistentCollection() {}
};
}
%}
--- /dev/null
+%module template_typedef_typedef
+
+// Github issue #50
+// The Object2::getBlabla2 and Object1::getBlabla1 functions were not resolving to the correct template types
+
+%inline%{
+
+class Factory;
+class Base {
+public:
+ typedef Factory ABCD;
+
+};
+
+namespace TT{
+ template <typename T>
+ class Object2:public T {
+ public:
+ void getBlabla2(typename T::ABCD::CC2 c) {
+ };
+ };
+ template <typename T>
+ class Object1:public T {
+ public:
+ void getBlabla1(typename T::ABCD::CC1 c) {
+ };
+ };
+}
+
+class Factory {
+ public:
+ typedef TT::Object1<Base> CC1;
+ typedef TT::Object2<Base> CC2;
+ void getBlabla4(CC2 c) {
+ };
+ void getBlabla3(CC1 c) {
+ };
+};
+%}
+
+%template(Object1Base) TT::Object1<Base>;
+%template(Object2Base) TT::Object2<Base>;
+
/* do nothing */
}
-%typemap(out) Integer1
-{
- /* do nothing */
-}
+#ifdef SWIGCSHARP
+%typemap(out) Integer1 { /* do nothing */ $result = 0; }
+#else
+%typemap(out) Integer1 { /* do nothing */ }
+#endif
%typemap(in) Integer2
{
/* do nothing */
}
-%typemap(out) Integer2
-{
- /* do nothing */
-}
+#ifdef SWIGCSHARP
+%typemap(out) Integer2 { /* do nothing */ $result = 0; }
+#else
+%typemap(out) Integer2 { /* do nothing */ }
+#endif
%{
typedef int Integer1;
}
using namespace Outer1::Space1;
using Outer1::Space1::Thing1;
+#ifdef __clang__
+namespace Outer1 {
+ namespace Space1 {
+ template<typename T> class Thing1 {};
+ }
+}
+#else
template<typename T> class Thing1 {};
+#endif
void useit1(Thing1<int> t) {}
void useit1a(Outer1::Space1::Thing1<int> t) {}
void useit1b(::Outer1::Space1::Thing1<int> t) {}
}
using namespace Outer2;
using Space2::Thing2;
+#ifdef __clang__
+namespace Outer2 {
+ namespace Space2 {
+ template<typename T> class Thing2 {};
+ }
+}
+#else
template<typename T> class Thing2 {};
+#endif
void useit2(Thing2<int> t) {}
void useit2a(Outer2::Space2::Thing2<int> t) {}
void useit2b(::Outer2::Space2::Thing2<int> t) {}
using namespace Outer3;
using namespace Space3;
using Middle3::Thing3;
+#ifdef __clang__
+namespace Outer3 {
+ namespace Space3 {
+ namespace Middle3 {
+ template<typename T> class Thing3 {};
+ }
+ }
+}
+#else
template<typename T> class Thing3 {};
+#endif
void useit3(Thing3<int> t) {}
void useit3a(Outer3::Space3::Middle3::Thing3<int> t) {}
void useit3b(::Outer3::Space3::Middle3::Thing3<int> t) {}
}
using namespace Outer4::Space4;
using Middle4::Thing4;
+#ifdef __clang__
+namespace Outer4 {
+ namespace Space4 {
+ namespace Middle4 {
+ template<typename T> class Thing4 {};
+ }
+ }
+}
+#else
template<typename T> class Thing4 {};
+#endif
void useit4(Thing4<int> t) {}
void useit4a(Outer4::Space4::Middle4::Thing4<int> t) {}
void useit4b(::Outer4::Space4::Middle4::Thing4<int> t) {}
using namespace ::Outer5::Space5;
using namespace Middle5;
using More5::Thing5;
+#ifdef __clang__
+namespace Outer5 {
+ namespace Space5 {
+ namespace Middle5 {
+ namespace More5 {
+ template<typename T> class Thing5 {};
+ }
+ }
+ }
+}
+#else
template<typename T> class Thing5 {};
+#endif
void useit5(Thing5<int> t) {}
void useit5a(Outer5::Space5::Middle5::More5::Thing5<int> t) {}
void useit5b(::Outer5::Space5::Middle5::More5::Thing5<int> t) {}
}
}
using namespace Outer7::Space7;
+#ifdef __clang__
+namespace Outer7 {
+ namespace Space7 {
+ namespace Middle7 {
+ template<typename T> class Thing7 {};
+ }
+ }
+}
+#else
template<typename T> class Middle7::Thing7 {};
+#endif
using Middle7::Thing7;
void useit7(Thing7<int> t) {}
void useit7a(Outer7::Space7::Middle7::Thing7<int> t) {}
--- /dev/null
+/* File : go_subdir_import_c.i */
+%module go_subdir_import_c
+
+%inline %{
+class ObjC {
+ public:
+ virtual int getInt() const {
+ return 18;
+ }
+};
+%}
+
return 1;
}
};
+
+#ifdef SWIGPYTHON_BUILTIN
+bool is_python_builtin() { return true; }
+#else
+bool is_python_builtin() { return false; }
+#endif
%}
%inline %{
-class Error {
+class CError {
};
-void test_is_Error(Error *r) {}
+void test_is_Error(CError *r) {}
namespace Namespace {
- typedef Error ErrorTypedef;
- typedef const Error& ErrorRef;
- typedef const Error* ErrorPtr;
+ typedef CError ErrorTypedef;
+ typedef const CError& ErrorRef;
+ typedef const CError* ErrorPtr;
typedef int IntArray[10];
enum EnumTest { enum1, enum2 };
}
void test_msg() throw(const char *) {
throw "Dead";
}
- void test_cls() throw(Error) {
- throw Error();
+ void test_cls() throw(CError) {
+ throw CError();
}
- void test_cls_ptr() throw(Error *) {
- static Error StaticError;
+ void test_cls_ptr() throw(CError *) {
+ static CError StaticError;
throw &StaticError;
}
- void test_cls_ref() throw(Error &) {
- static Error StaticError;
+ void test_cls_ref() throw(CError &) {
+ static CError StaticError;
throw StaticError;
}
void test_cls_td() throw(Namespace::ErrorTypedef) {
- throw Error();
+ throw CError();
}
void test_cls_ptr_td() throw(Namespace::ErrorPtr) {
- static Error StaticError;
+ static CError StaticError;
throw &StaticError;
}
void test_cls_ref_td() throw(Namespace::ErrorRef) {
- static Error StaticError;
+ static CError StaticError;
throw StaticError;
}
void test_array() throw(Namespace::IntArray) {
void test_enum() throw(Namespace::EnumTest) {
throw Namespace::enum2;
}
- void test_multi(int x) throw(int, const char *, Error) {
+ void test_multi(int x) throw(int, const char *, CError) {
if (x == 1) throw 37;
if (x == 2) throw "Dead";
- if (x == 3) throw Error();
+ if (x == 3) throw CError();
}
};
--- /dev/null
+%module typedef_struct_cpp
+
+%include "typedef_struct.i"
--- /dev/null
+%module typedef_typedef
+
+// Check C::Bar::Foo resolves to A::Foo in typemap search
+
+%typemap(in) SWIGTYPE, int "__wrong_in_typemap__will_not_compile__"
+
+%typemap(in) A::Foo {
+ $1 = 1234; /* A::Foo in typemap */
+}
+
+%inline %{
+ struct A
+ {
+ typedef int Foo;
+ };
+
+ struct C
+ {
+ typedef A Bar;
+ };
+
+ struct B
+ {
+ C::Bar::Foo getValue(C::Bar::Foo intvalue) {
+ return intvalue;
+ }
+ };
+%}
+
+/*
+
+ An issue can be the steps resolution.
+ 1) C::Bar is A. So C::Bar::Foo should be first resolved as A::Foo.
+ 2) Then A::Foo should be resolved int.
+ If the first step is skipped the typemap is not applied.
+
+*/
typedef SomeType myarray[3];
typedef const SomeType myconstarray[4];
typedef volatile SomeType ** mycrazyarray[5];
- typedef volatile SomeType (mycrazyfunc)(SomeType);
- typedef volatile SomeType (*mycrazyfuncptr)(SomeType);
+ extern "C" {
+ typedef volatile SomeType (mycrazyfunc)(SomeType);
+ typedef volatile SomeType (*mycrazyfuncptr)(SomeType);
+ }
%}
CLEAR_SWIGTYPE_TYPEMAPS;
/* Correct typemap for $symname: $type */
}
%inline %{
- void func1a(myarray x) {};
- void func1b(volatile myarray x) {};
+ void func1a(myarray x) {}
+ void func1b(volatile myarray x) {}
%}
CLEAR_SWIGTYPE_TYPEMAPS;
/* Correct typemap for $symname: $type */
}
%inline %{
- void func2a(const myarray x) {};
- void func2b(const myconstarray x) {};
- void func2c(const volatile myconstarray x) {};
+ void func2a(const myarray x) {}
+ void func2b(const myconstarray x) {}
+ void func2c(const volatile myconstarray x) {}
%}
CLEAR_SWIGTYPE_TYPEMAPS;
/* Correct typemap for $symname: $type */
}
%inline %{
- void func3a(const mycrazyarray x, const mycrazyarray y[7]) {};
+ void func3a(const mycrazyarray x, const mycrazyarray y[7]) {}
%}
CLEAR_SWIGTYPE_TYPEMAPS;
/* Correct typemap for $symname: $type */
}
%inline %{
- void func4a(mycrazyfunc *const x, const mycrazyfuncptr y) {};
+ void func4a(mycrazyfunc *const x, const mycrazyfuncptr y) {}
%}
// Can't use the %typemap(directorout) MyType & = SWIGTYPE & approach as non-director languages don't define any directorout typemaps
%typemap(directorout) MyType &Class1::foo2, MyType &foo1 %{ /* special start */ $input = 0; /* special end */ %}
-#ifdef SWIGPHP
-%typemap(directorout, warning="PHP directorout typemaps need fixing") MyType &Class1::foo2, MyType &foo1 %{ /* special start */ /*$input = 0;*/ /* special end */ %}
-/* Patch to make $input work same as other languages. Then $input needs changing to &$input in most (maybe all) typemaps.
---- a/Source/Modules/php.cxx
-+++ b/Source/Modules/php.cxx
-@@ -2631,8 +2631,7 @@ done:
- if (!is_void) {
- tm = Swig_typemap_lookup("directorout", n, Swig_cresult_name(), w);
- if (tm != 0) {
-- static const String *amp_result = NewStringf("&%s", Swig_cresult_name());
-- Replaceall(tm, "$input", amp_result);
-+ Replaceall(tm, "$input", Swig_cresult_name());
- char temp[24];
- sprintf(temp, "%d", idx);
- Replaceall(tm, "$argnum", temp);
-*/
-#endif
-
#ifdef SWIGCSHARP
%typemap(csdirectorout) MyType & %{ WILL_NOT_COMPILE %}
#ifdef SWIGD
%typemap(ddirectorout) MyType & %{ WILL_NOT_COMPILE %}
%typemap(ddirectorout) MyType &USEME = SWIGTYPE &;
-%typemap(ddirectorout) MyType &Class1::foo2, MyType &foo1 %{ /* special start */ $typemap(ddirectorout, MyType &USEME) /* special end */ %}
+%typemap(ddirectorout, nativepointer="cast(void*)$dcall") MyType &Class1::foo2, MyType &foo1 %{ /* special start */ $typemap(ddirectorout, MyType &USEME) /* special end */ %}
#endif
#ifdef SWIGJAVA
$9 = &temp9;
$10 = &temp10; // the code generated for this was arg20 = &temp10; and arg20 does not exist.
int $10_ptr = 0; // Was arg20_ptr
+ (void)$10_ptr;
}
%inline %{
(void)c;
(void)d;
(void)e;
+ (void)f;
}
{ /* Test locals */
basetemp.member = 0;
startemp = &basetemp;
temp = &startemp;
amptemp = &temp;
+ (void)amptemp;
}
{ /* Test descriptors */
void *desc = $descriptor;
%}
#endif
+// For Javascript V8 we can not use '0' for out typemaps
+#if defined(SWIG_JAVASCRIPT_V8)
+%header %{
+#define OUT_NULL_VALUE SWIGV8_NULL()
+%}
+#else
+%header %{
+#define OUT_NULL_VALUE 0
+%}
+#endif
+
// Scripting languages use varin/varout for variables (except non-static member variables where in/out are used ???)
%typemap(varin) int "this_will_not_compile_varin "
%typemap(varout) int "this_will_not_compile_varout"
%typemap(varin) int globul "/*int globul varin */ TYPEMAP_VARIABLES_FAIL"
-%typemap(varout) int globul "/*int globul varout*/ $result=0;"
+%typemap(varout) int globul "/*int globul varout*/ $result=OUT_NULL_VALUE;"
%typemap(varin) int Space::nspace "/*int nspace varin */ TYPEMAP_VARIABLES_FAIL"
-%typemap(varout) int Space::nspace "/*int nspace varout*/ $result=0;"
+%typemap(varout) int Space::nspace "/*int nspace varout*/ $result=OUT_NULL_VALUE;"
//%typemap(varin) int member "/*int member varin */"
-//%typemap(varout) int member "/*int member varout*/ $result=0;"
+//%typemap(varout) int member "/*int member varout*/ $result=OUT_NULL_VALUE;"
%typemap(varin) int Space::Struct::smember "/*int smember varin */ TYPEMAP_VARIABLES_FAIL"
-%typemap(varout) int Space::Struct::smember "/*int smember varout*/ $result=0;"
+%typemap(varout) int Space::Struct::smember "/*int smember varout*/ $result=OUT_NULL_VALUE;"
// Statically typed languages use in/out for variables
%typemap(in) int "this_will_not_compile_in "
%typemap(out) int "this_will_not_compile_out"
%typemap(in) int globul "/*int globul in */ $1=0;"
-%typemap(out) int globul "/*int globul out*/ $result=0;"
+%typemap(out) int globul "/*int globul out*/ $result=OUT_NULL_VALUE;"
%typemap(in) int Space::nspace "/*int nspace in */ $1=0;"
-%typemap(out) int Space::nspace "/*int nspace out*/ $result=0;"
+%typemap(out) int Space::nspace "/*int nspace out*/ $result=OUT_NULL_VALUE;"
%typemap(in) int member "/*int member in */ $1=0;"
#ifdef SWIGTCL
%typemap(out) int member "/*int member out*/"
#else
-%typemap(out) int member "/*int member out*/ $result=0;"
+%typemap(out) int member "/*int member out*/ $result=OUT_NULL_VALUE;"
#endif
%typemap(in) int Space::Struct::smember "/*int smember in */ $1=0;"
-%typemap(out) int Space::Struct::smember "/*int smember out*/ $result=0;"
+%typemap(out) int Space::Struct::smember "/*int smember out*/ $result=OUT_NULL_VALUE;"
%typemap(javain) int "this_will_not_compile_javain "
%typemap(javaout) int "this_will_not_compile_javaout"
%typemap(javain) int Space::Struct::smember "/*int smember in */ $javainput"
%typemap(javaout) int Space::Struct::smember "/*int smember out*/ { return $jnicall; }"
+#if defined(SWIGSCILAB)
+%clear int globul;
+%clear int Space::nspace;
+%clear int Space::Struct::smember;
+%ignore Space::Struct::member;
+%typemap(varin) int globul "TYPEMAP_VARIABLES_FAIL";
+%typemap(varout, noblock=1, fragment=SWIG_From_frag(int)) int globul "if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, SWIG_From_int($result)))) return SWIG_ERROR;";
+%typemap(varin) int Space::nspace "TYPEMAP_VARIABLES_FAIL";
+%typemap(varout, noblock=1, fragment=SWIG_From_frag(int)) int Space::nspace "if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, SWIG_From_int($result)))) return SWIG_ERROR;";
+%typemap(varin) int Space::Struct::smember "TYPEMAP_VARIABLES_FAIL";
+%typemap(varout, noblock=1, fragment=SWIG_From_frag(int)) int Space::Struct::smember "if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, SWIG_From_int($result)))) return SWIG_ERROR;";
+#endif
+
%inline %{
int globul;
};
}
+#ifdef SWIGCSHARP
+#define TYPEMAP_OUT_INIT $result = 0;
+#else
+#define TYPEMAP_OUT_INIT
+#endif
// Test obscure bug where named typemaps where not being applied when symbol name contained a number
%typemap(out) double "_typemap_for_double_no_compile_"
-%typemap(out) double ABCD::meth "$1 = 0.0;"
-%typemap(out) double ABCD::m1 "$1 = 0.0;"
-%typemap(out) double ABCD::_x2 "$1 = 0.0;"
-%typemap(out) double ABCD::y_ "$1 = 0.0;"
-%typemap(out) double ABCD::_3 "$1 = 0.0;"
+%typemap(out) double ABCD::meth {$1 = 0.0; TYPEMAP_OUT_INIT}
+%typemap(out) double ABCD::m1 {$1 = 0.0; TYPEMAP_OUT_INIT}
+%typemap(out) double ABCD::_x2 {$1 = 0.0; TYPEMAP_OUT_INIT}
+%typemap(out) double ABCD::y_ {$1 = 0.0; TYPEMAP_OUT_INIT}
+%typemap(out) double ABCD::_3 {$1 = 0.0; TYPEMAP_OUT_INIT}
%inline %{
struct ABCD {
double meth() { return 0.0; }
LANGUAGE = uffi
UFFI = @UFFIBIN@
SCRIPTSUFFIX = _runme.lisp
+
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
# Overridden variables here
# no C++ tests for now
CPP_TEST_CASES =
-#C_TEST_CASES +=
+#C_TEST_CASES +=
# Custom tests - tests with additional commandline options
# none!
# Rules for the different types of tests
-%.cpptest:
+%.cpptest:
$(setup)
+$(swig_and_compile_cpp)
$(run_testcase)
+$(swig_and_compile_c)
$(run_testcase)
-%.multicpptest:
+%.multicpptest:
$(setup)
+$(swig_and_compile_multi_cpp)
$(run_testcase)
# Runs the testcase. A testcase is only run if
# a file is found which has _runme.lisp appended after the testcase name.
run_testcase = \
- if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
- env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(UFFI) -batch -s $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
+ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
+ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(UFFI) -batch -s $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \
fi
# Clean: (does nothing, we dont generate extra uffi code)
%.clean:
-
+ @exit 0
clean:
- $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile uffi_clean
-
+ $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' uffi_clean
--- /dev/null
+%module unicode_strings
+
+%include <std_string.i>
+
+%begin %{
+#define SWIG_PYTHON_2_UNICODE
+%}
+
+%inline %{
+
+const char* non_utf8_c_str(void) {
+ return "h\xe9llo w\xc3\xb6rld";
+}
+
+std::string non_utf8_std_string(void) {
+ return std::string("h\xe9llo w\xc3\xb6rld");
+}
+
+char *charstring(char *s) {
+ return s;
+}
+
+%}
/* Must undefine small to work on Windows. small is defined as a
char in rpcndr.h */
#ifdef small
-#undef small
+#undef small
#endif
%}
SmallStruct small;
} uni;
int number;
-} EmbeddedUnionTest;
+}
+#if !defined(SWIGSCILAB)
+EmbeddedUnionTest;
+#else
+EmbedUnionTst;
+#endif
%}
+
}
using namespace Outer1::Space1;
using Outer1::Space1::Thing1;
+#ifdef __clang__
+namespace Outer1 {
+ namespace Space1 {
+ class Thing1 {};
+ }
+}
+#else
class Thing1 {};
+#endif
void useit1(Thing1 t) {}
void useit1a(Outer1::Space1::Thing1 t) {}
void useit1b(::Outer1::Space1::Thing1 t) {}
}
using namespace Outer2;
using Space2::Thing2;
+using namespace Outer1::Space1;
+using Outer1::Space1::Thing1;
+#ifdef __clang__
+namespace Outer2 {
+ namespace Space2 {
+ class Thing2 {};
+ }
+}
+#else
class Thing2 {};
+#endif
void useit2(Thing2 t) {}
void useit2a(Outer2::Space2::Thing2 t) {}
void useit2b(::Outer2::Space2::Thing2 t) {}
using namespace Outer3;
using namespace Space3;
using Middle3::Thing3;
+#ifdef __clang__
+namespace Outer3 {
+ namespace Space3 {
+ namespace Middle3 {
+ class Thing3 {};
+ }
+ }
+}
+#else
class Thing3 {};
+#endif
void useit3(Thing3 t) {}
void useit3a(Outer3::Space3::Middle3::Thing3 t) {}
void useit3b(::Outer3::Space3::Middle3::Thing3 t) {}
}
using namespace Outer4::Space4;
using Middle4::Thing4;
+#ifdef __clang__
+namespace Outer4 {
+ namespace Space4 {
+ namespace Middle4 {
+ class Thing4 {};
+ }
+ }
+}
+#else
class Thing4 {};
+#endif
void useit4(Thing4 t) {}
void useit4a(Outer4::Space4::Middle4::Thing4 t) {}
void useit4b(::Outer4::Space4::Middle4::Thing4 t) {}
using namespace ::Outer5::Space5;
using namespace Middle5;
using More5::Thing5;
+#ifdef __clang__
+namespace Outer5 {
+ namespace Space5 {
+ namespace Middle5 {
+ namespace More5 {
+ class Thing5 {};
+ }
+ }
+ }
+}
+#else
class Thing5 {};
+#endif
void useit5(Thing5 t) {}
void useit5a(Outer5::Space5::Middle5::More5::Thing5 t) {}
void useit5b(::Outer5::Space5::Middle5::More5::Thing5 t) {}
}
}
using namespace Outer7::Space7;
+#ifdef __clang__
+namespace Outer7 {
+ namespace Space7 {
+ namespace Middle7 {
+ class Thing7 {};
+ }
+ }
+}
+#else
class Middle7::Thing7 {};
+#endif
using Middle7::Thing7;
void useit7(Thing7 t) {}
void useit7a(Outer7::Space7::Middle7::Thing7 t) {}
int x;
int blah(int xx) { return xx; }
virtual int vmethod(int xx) { return xx; }
+ virtual ~Foo() {}
};
class FooBar : public Foo {
%module varargs_overload
%inline %{
+#include <stdio.h>
+
const char *vararg_over1(const char *fmt, ...) {
return fmt;
}
{
public:
int dummy() { return 0; }
+ virtual ~SimpleNonVirtual() {}
};
class SimpleReturnClass
void *vfunc2(Foo *f) { return f; }
Foo *vfunc3(void *f) { return (Foo *) f; }
Foo *vfunc4(Foo *f) { return f; }
-
%}
-
// test the -Wallkw option
-%warnfilter(SWIGWARN_PARSE_KEYWORD) clone; // 'clone' is a php keyword, renamed as 'c_clone'
+%warnfilter(SWIGWARN_PARSE_KEYWORD) clone; // 'clone' is a PHP keyword, renaming to 'c_clone'
%warnfilter(SWIGWARN_PARSE_KEYWORD) delegate; // 'delegate' is a C# keyword, renaming to '_delegate'
%warnfilter(SWIGWARN_PARSE_KEYWORD) pass; // 'pass' is a python keyword, renaming to '_pass'
%warnfilter(SWIGWARN_PARSE_KEYWORD) alias; // 'alias' is a D keyword, renaming to '_alias'
# Examples/xml/Makefile
+srcdir = @srcdir@
top_srcdir = @top_srcdir@
+top_builddir = @top_builddir@
+
+SWIGEXE = $(top_builddir)/swig
+SWIG_LIB_DIR = $(top_srcdir)/Lib
+SWIG_LIB_SET = @SWIG_LIB_SET@
+SWIGINVOKE = $(SWIG_LIB_SET) $(SWIGTOOL) $(SWIGEXE)
cleanup = tail +2 \
| sed -e 's/ident="ID[0-9A-F]*"//g' \
example_xml.i \
gnarly.i
-chk-swiglib = $(top_srcdir)/Lib
-
check:
for f in $(all-dot-i-files) ; do \
base=`basename $$f .i` ; \
xml=$$base.xml ; \
- SWIG_LIB=$(chk-swiglib) $(top_srcdir)/swig -xml $$xml $$f ; \
- cat $$xml | $(cleanup) | diff -c $$base.expected-xml - ; \
+ $(SWIGINVOKE) -xml $$xml ${srcdir}/$$f ; \
+ cat $$xml | $(cleanup) | diff -c ${srcdir}/$$base.expected-xml - ; \
done
clean:
# from here on, non-developers beware!
%.expected-xml : %.i
- SWIG_LIB=$(top_srcdir)/Lib $(top_srcdir)/swig -xml tmp-file $^
+ $(SWIGINVOKE) -xml tmp-file $^
cat tmp-file | $(cleanup) > $@
rm -f tmp-file
enum SWIGTYPE "(cl::setq ACL_ffresult $body)";
%typemap(lout) void "$body";
#ifdef __cplusplus
-%typemap(lout) SWIGTYPE[ANY], SWIGTYPE *,
- SWIGTYPE &
+%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)))
%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
+%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)) %}
%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
long, signed long, unsigned long,
float, double, long double, char *, void *, void,
enum SWIGTYPE, SWIGTYPE *, SWIGTYPE[],
- SWIGTYPE[ANY], SWIGTYPE &, const SWIGTYPE "$1_ltype";
+ SWIGTYPE[ANY], SWIGTYPE &, SWIGTYPE &&, const SWIGTYPE "$1_ltype";
%typemap(ctype) SWIGTYPE "$&1_type";
%typemap(in) bool "$1 = (bool)$input;";
long, signed long, unsigned long,
float, double, long double, char *, void *, void,
enum SWIGTYPE, SWIGTYPE *, SWIGTYPE[],
- SWIGTYPE[ANY], SWIGTYPE & "$1 = $input;";
+ 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
int, signed int, unsigned int,
long, signed long, unsigned long,
enum SWIGTYPE { $1 = 1; };
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &,
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&,
SWIGTYPE[], SWIGTYPE[ANY],
SWIGTYPE { $1 = 1; };
long, signed long, unsigned long,
float, double, long double, char *, void *,
enum SWIGTYPE, SWIGTYPE *,
- SWIGTYPE[ANY], SWIGTYPE & "$result = $1;";
+ SWIGTYPE[ANY], SWIGTYPE &, SWIGTYPE && "$result = $1;";
#ifdef __cplusplus
%typemap(out) SWIGTYPE "$result = new $1_ltype($1);";
#else
/* Array reference typemaps */
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
/*
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
+ 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 separete languagekw.swg
+ 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 <php/phpkw.swg>
%include <pike/pikekw.swg>
%include <python/pythonkw.swg>
-%include <ocaml/ocamlkw.swg>
+%include <r/rkw.swg>
%include <ruby/rubykw.swg>
%include <tcl/tclkw.swg>
-%include <perl5/perlkw.swg>
#endif //__Lib_allkw_swg__
%{
static TYPE *new_##NAME(int nelements) { %}
#ifdef __cplusplus
-%{ return new TYPE[nelements]; %}
+%{ return new TYPE[nelements](); %}
#else
%{ return (TYPE *) calloc(nelements,sizeof(TYPE)); %}
#endif
#ifdef __cplusplus
NAME(int nelements) {
- return new TYPE[nelements];
+ return new TYPE[nelements]();
}
~NAME() {
delete [] self;
$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);
+
+#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;
+ }
+
#else
%echo "cdata.i module not supported."
#endif
long, signed long, unsigned long,
float, double, long double, char *, void *, void,
enum SWIGTYPE, SWIGTYPE *,
- SWIGTYPE[ANY], SWIGTYPE & "$1_ltype";
+ SWIGTYPE[ANY], SWIGTYPE &, SWIGTYPE && "$1_ltype";
%typemap(ctype) SWIGTYPE "$&1_type";
%typemap(in) bool "$1 = (bool)$input;";
long, signed long, unsigned long,
float, double, long double, char *, void *, void,
enum SWIGTYPE, SWIGTYPE *,
- SWIGTYPE[ANY], SWIGTYPE & "$1 = $input;";
+ SWIGTYPE[ANY], SWIGTYPE &, SWIGTYPE && "$1 = $input;";
%typemap(in) SWIGTYPE "$1 = *$input;";
%typemap(out) void "";
long, signed long, unsigned long,
float, double, long double, char *, void *,
enum SWIGTYPE, SWIGTYPE *,
- SWIGTYPE[ANY], SWIGTYPE & "$result = $1;";
+ SWIGTYPE[ANY], SWIGTYPE &, SWIGTYPE && "$result = $1;";
#ifdef __cplusplus
%typemap(out) SWIGTYPE "$result = new $1_type($1);";
#else
int, signed int, unsigned int,
long, signed long, unsigned long,
enum SWIGTYPE { $1 = 1; };
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &,
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&,
SWIGTYPE[ANY], SWIGTYPE { $1 = 1; };
/* This maps C/C++ types to Lisp classes for overload dispatch */
/* Array reference typemaps */
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
/* enum SWIGTYPE */
%apply int { enum SWIGTYPE };
%apply const int& { const enum SWIGTYPE& };
+%apply const int& { const enum SWIGTYPE&& };
%typemap(varin) enum SWIGTYPE
{
%typemap(freearg) char * "if ($1 != NULL) { free ($1); }"
/* Pointers, references, and arrays */
-%typemap(in,closcode="(slot-ref $input 'swig-this)") SWIGTYPE *, SWIGTYPE [], SWIGTYPE & {
+%typemap(in,closcode="(slot-ref $input 'swig-this)") SWIGTYPE *, SWIGTYPE [], SWIGTYPE &, SWIGTYPE && {
$1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, $disown);
}
$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");
}
$1 = SWIG_MustGetPtr($input, NULL, 1, 0);
}
-%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
+%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);
$result = SWIG_NewPointerObj($1, $descriptor, $owner);
}
$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];
%typemap(constcode) char *
"static const char *$result = $value;"
-%typemap(constcode) SWIGTYPE *, SWIGTYPE &, SWIGTYPE []
+%typemap(constcode) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE []
"static const void *$result = (void*) $value;"
/* ------------------------------------------------------------
$1 = C_swig_is_string ($input);
}
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
void *ptr;
$1 = !SWIG_ConvertPtr($input, &ptr, $1_descriptor, 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;
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
* ------------------------------------------------------------ */
/* Array reference typemaps */
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
swig_module_info *ret = 0;
C_word sym;
- /* lookup the type pointer... it is stored in it's own symbol table */
+ /* 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);
C_word pointer;
static C_word *space = 0;
- /* type pointer is stored in it's own symbol table */
+ /* 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);
%typemap(ctype) CTYPE INPUT[] "CTYPE*"
%typemap(cstype) CTYPE INPUT[] "CSTYPE[]"
-%typemap(imtype, inattributes="[In, MarshalAs(UnmanagedType.LPArray)]") 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(ctype) CTYPE OUTPUT[] "CTYPE*"
%typemap(cstype) CTYPE OUTPUT[] "CSTYPE[]"
-%typemap(imtype, inattributes="[Out, MarshalAs(UnmanagedType.LPArray)]") 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(ctype) CTYPE INOUT[] "CTYPE*"
%typemap(cstype) CTYPE INOUT[] "CSTYPE[]"
-%typemap(imtype, inattributes="[In, Out, MarshalAs(UnmanagedType.LPArray)]") 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;"
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[] "IntPtr"
+%typemap(imtype) CTYPE FIXED[] "global::System.IntPtr"
%typemap(cstype) CTYPE FIXED[] "CSTYPE[]"
%typemap(csin,
pre= " fixed ( CSTYPE* swig_ptrTo_$csinput = $csinput ) {",
terminator=" }")
- CTYPE FIXED[] "(IntPtr)swig_ptrTo_$csinput"
+ CTYPE FIXED[] "(global::System.IntPtr)swig_ptrTo_$csinput"
%typemap(in) CTYPE FIXED[] "$1 = $input;"
%typemap(freearg) CTYPE FIXED[] ""
CSHARP_ARRAYS_FIXED(unsigned long long, ulong)
CSHARP_ARRAYS_FIXED(float, float)
CSHARP_ARRAYS_FIXED(double, double)
+CSHARP_ARRAYS_FIXED(bool, bool)
-// Users can provide their own SWIG_INTRUSIVE_PTR_TYPEMAPS or SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP macros before including this file to change the\r
-// visibility of the constructor and getCPtr method if desired to public if using multiple modules.\r
-#ifndef SWIG_INTRUSIVE_PTR_TYPEMAPS\r
-#define SWIG_INTRUSIVE_PTR_TYPEMAPS(CONST, TYPE...) SWIG_INTRUSIVE_PTR_TYPEMAPS_IMPLEMENTATION(internal, internal, CONST, TYPE)\r
-#endif\r
-#ifndef SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP\r
-#define SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP(CONST, TYPE...) SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP_IMPLEMENTATION(internal, internal, CONST, TYPE)\r
-#endif\r
-\r
-%include <intrusive_ptr.i>\r
-\r
-// Language specific macro implementing all the customisations for handling the smart pointer\r
-%define SWIG_INTRUSIVE_PTR_TYPEMAPS_IMPLEMENTATION(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, CONST, TYPE...)\r
-\r
-// %naturalvar is as documented for member variables\r
-%naturalvar TYPE;\r
-%naturalvar SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >;\r
-\r
-// destructor wrapper customisation\r
-%feature("unref") TYPE "(void)arg1; delete smartarg1;"\r
-\r
-// Typemap customisations...\r
-\r
-%typemap(in, canthrow=1) CONST TYPE ($&1_type argp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{\r
- // plain value\r
- argp = (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0;\r
- if (!argp) {\r
- SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null $1_type", 0);\r
- return $null;\r
- }\r
- $1 = *argp; \r
-%}\r
-%typemap(out, fragment="SWIG_intrusive_deleter") CONST TYPE %{ \r
- //plain value(out)\r
- $1_ltype* resultp = new $1_ltype(($1_ltype &)$1);\r
- intrusive_ptr_add_ref(resultp);\r
- *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(resultp, SWIG_intrusive_deleter< CONST TYPE >()); \r
-%}\r
-\r
-%typemap(in, canthrow=1) CONST TYPE * (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{\r
- // plain pointer\r
- smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input;\r
- $1 = (TYPE *)(smartarg ? smartarg->get() : 0); \r
-%}\r
-%typemap(out, fragment="SWIG_intrusive_deleter,SWIG_null_deleter") CONST TYPE * %{\r
- //plain pointer(out)\r
- #if ($owner)\r
- if ($1) {\r
- intrusive_ptr_add_ref($1);\r
- *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1, SWIG_intrusive_deleter< CONST TYPE >()); \r
- } else {\r
- *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0;\r
- }\r
- #else\r
- *(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;\r
- #endif\r
-%}\r
-\r
-%typemap(in, canthrow=1) CONST TYPE & (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{\r
- // plain reference\r
- $1 = ($1_ltype)((*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0);\r
- if(!$1) {\r
- SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "$1_type reference is null", 0);\r
- return $null;\r
- } \r
-%}\r
-%typemap(out, fragment="SWIG_intrusive_deleter,SWIG_null_deleter") CONST TYPE & %{ \r
- //plain reference(out)\r
- #if ($owner)\r
- if ($1) {\r
- intrusive_ptr_add_ref($1);\r
- *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1, SWIG_intrusive_deleter< CONST TYPE >()); \r
- } else {\r
- *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0;\r
- } \r
- #else\r
- *(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;\r
- #endif\r
-%}\r
-\r
-%typemap(in) TYPE *CONST& ($*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{ \r
- // plain pointer by reference\r
- temp = ($*1_ltype)((*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0);\r
- $1 = &temp; \r
-%}\r
-%typemap(out, fragment="SWIG_intrusive_deleter,SWIG_null_deleter") TYPE *CONST& %{ \r
- // plain pointer by reference(out)\r
- #if ($owner)\r
- if (*$1) {\r
- intrusive_ptr_add_ref(*$1);\r
- *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1, SWIG_intrusive_deleter< CONST TYPE >()); \r
- } else {\r
- *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0;\r
- } \r
- #else\r
- *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_0);\r
- #endif\r
-%}\r
-\r
-%typemap(in) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * smartarg) %{ \r
- // intrusive_ptr by value\r
- smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >**)&$input;\r
- if (smartarg) {\r
- $1 = SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >(smartarg->get(), true); \r
- }\r
-%}\r
-%typemap(out, fragment="SWIG_intrusive_deleter") SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > %{ \r
- if ($1) {\r
- intrusive_ptr_add_ref($1.get());\r
- *(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 >());\r
- } else {\r
- *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0; \r
- }\r
-%}\r
-\r
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast ($&1_type smartarg) %{\r
- // shared_ptr by value\r
- smartarg = *($&1_ltype*)&$input; \r
- if (smartarg) $1 = *smartarg; \r
-%}\r
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > ANY_TYPE_SWIGSharedPtrUpcast %{ \r
- *($&1_ltype*)&$result = $1 ? new $1_ltype($1) : 0; \r
-%}\r
-\r
-%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) %{ \r
- // intrusive_ptr by reference\r
- if ( $input ) {\r
- smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >**)&$input; \r
- temp = SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >(smartarg->get(), true);\r
- $1 = &temp;\r
- } else {\r
- $1 = &tempnull;\r
- }\r
-%}\r
-%typemap(memberin) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > & %{\r
- delete &($1);\r
- if ($self) {\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > * temp = new SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >(*$input);\r
- $1 = *temp;\r
- }\r
-%}\r
-%typemap(out, fragment="SWIG_intrusive_deleter") SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > & %{ \r
- if (*$1) {\r
- intrusive_ptr_add_ref($1->get());\r
- *(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 >());\r
- } else {\r
- *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0;\r
- }\r
-%} \r
-\r
-%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) %{ \r
- // intrusive_ptr by pointer\r
- if ( $input ) {\r
- smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >**)&$input; \r
- temp = SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >(smartarg->get(), true);\r
- $1 = &temp; \r
- } else {\r
- $1 = &tempnull;\r
- }\r
-%}\r
-%typemap(memberin) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > * %{\r
- delete $1;\r
- if ($self) $1 = new SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >(*$input);\r
-%}\r
-%typemap(out, fragment="SWIG_intrusive_deleter") SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > * %{ \r
- if ($1 && *$1) {\r
- intrusive_ptr_add_ref($1->get());\r
- *(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 >());\r
- } else {\r
- *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0;\r
- }\r
- if ($owner) delete $1; \r
-%}\r
-\r
-%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) %{ \r
- // intrusive_ptr by pointer reference\r
- smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >**)&$input;\r
- if ($input) {\r
- temp = SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >(smartarg->get(), true);\r
- }\r
- tempp = &temp;\r
- $1 = &tempp;\r
-%}\r
-%typemap(memberin) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& %{\r
- if ($self) $1 = *$input;\r
-%}\r
-%typemap(out, fragment="SWIG_intrusive_deleter") SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& %{ \r
- if (*$1 && **$1) {\r
- intrusive_ptr_add_ref((*$1)->get());\r
- *(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 >());\r
- } else {\r
- *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = 0;\r
- }\r
-%} \r
-\r
-// various missing typemaps - If ever used (unlikely) ensure compilation error rather than runtime bug\r
-%typemap(in) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{\r
-#error "typemaps for $1_type not available"\r
-%}\r
-%typemap(out) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{\r
-#error "typemaps for $1_type not available"\r
-%}\r
-\r
-\r
-%typemap (ctype) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >,\r
- SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > &,\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *,\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& "void *"\r
-%typemap (imtype, out="IntPtr") SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >, \r
- SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > &,\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *,\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& "HandleRef"\r
-%typemap (cstype) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >,\r
- SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > &,\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *,\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& "$typemap(cstype, TYPE)"\r
-%typemap(csin) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >,\r
- SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > &,\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *,\r
- SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& "$typemap(cstype, TYPE).getCPtr($csinput)"\r
-\r
-%typemap(csout, excode=SWIGEXCODE) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > {\r
- IntPtr cPtr = $imcall;\r
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode\r
- return ret; \r
- }\r
-%typemap(csout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {\r
- IntPtr cPtr = $imcall;\r
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode\r
- return ret;\r
- }\r
-%typemap(csout, excode=SWIGEXCODE) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > & {\r
- IntPtr cPtr = $imcall;\r
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode\r
- return ret; \r
- }\r
-%typemap(csout, excode=SWIGEXCODE) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > * {\r
- IntPtr cPtr = $imcall;\r
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode\r
- return ret; \r
- }\r
-%typemap(csout, excode=SWIGEXCODE) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > *& {\r
- IntPtr cPtr = $imcall;\r
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode\r
- return ret; \r
- }\r
-%typemap(csvarout, excode=SWIGEXCODE2) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE > %{\r
- get {\r
- $typemap(cstype, TYPE) ret = new $typemap(cstype, TYPE)($imcall, true);$excode\r
- return ret;\r
- } %}\r
-%typemap(csvarout, excode=SWIGEXCODE2) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >& %{\r
- get {\r
- $typemap(cstype, TYPE) ret = new $typemap(cstype, TYPE)($imcall, true);$excode\r
- return ret;\r
- } %}\r
-%typemap(csvarout, excode=SWIGEXCODE2) SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >* %{\r
- get {\r
- $typemap(cstype, TYPE) ret = new $typemap(cstype, TYPE)($imcall, true);$excode\r
- return ret;\r
- } %}\r
-\r
-\r
-%typemap(csout, excode=SWIGEXCODE) CONST TYPE {\r
- $typemap(cstype, TYPE) ret = new $typemap(cstype, TYPE)($imcall, true);$excode\r
- return ret;\r
- }\r
-%typemap(csout, excode=SWIGEXCODE) CONST TYPE & {\r
- $typemap(cstype, TYPE) ret = new $typemap(cstype, TYPE)($imcall, true);$excode\r
- return ret;\r
- }\r
-%typemap(csout, excode=SWIGEXCODE) CONST TYPE * {\r
- IntPtr cPtr = $imcall;\r
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode\r
- return ret;\r
- }\r
-%typemap(csout, excode=SWIGEXCODE) TYPE *CONST& {\r
- IntPtr cPtr = $imcall;\r
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode\r
- return ret;\r
- }\r
-\r
-// Base proxy classes\r
-%typemap(csbody) TYPE %{\r
- private HandleRef swigCPtr;\r
- private bool swigCMemOwnBase;\r
-\r
- PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) {\r
- swigCMemOwnBase = cMemoryOwn;\r
- swigCPtr = new HandleRef(this, cPtr);\r
- }\r
-\r
- CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {\r
- return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;\r
- }\r
-%}\r
-\r
-// Derived proxy classes\r
-%typemap(csbody_derived) TYPE %{\r
- private HandleRef swigCPtr;\r
- private bool swigCMemOwnDerived;\r
-\r
- PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGSmartPtrUpcast(cPtr), true) {\r
- swigCMemOwnDerived = cMemoryOwn;\r
- swigCPtr = new HandleRef(this, cPtr);\r
- }\r
-\r
- CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {\r
- return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;\r
- }\r
-%}\r
-\r
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") TYPE {\r
- lock(this) {\r
- if (swigCPtr.Handle != IntPtr.Zero) {\r
- if (swigCMemOwnBase) {\r
- swigCMemOwnBase = false;\r
- $imcall;\r
- }\r
- swigCPtr = new HandleRef(null, IntPtr.Zero);\r
- }\r
- GC.SuppressFinalize(this);\r
- }\r
- }\r
-\r
-%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") TYPE {\r
- lock(this) {\r
- if (swigCPtr.Handle != IntPtr.Zero) {\r
- if (swigCMemOwnDerived) {\r
- swigCMemOwnDerived = false;\r
- $imcall;\r
- }\r
- swigCPtr = new HandleRef(null, IntPtr.Zero);\r
- }\r
- GC.SuppressFinalize(this);\r
- base.Dispose();\r
- }\r
- }\r
-\r
-// CONST version needed ???? also for C#\r
-%typemap(imtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > swigSharedPtrUpcast "HandleRef"\r
-%typemap(imtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast "HandleRef"\r
-\r
-\r
-%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;\r
-%template() SWIG_INTRUSIVE_PTR_QNAMESPACE::intrusive_ptr< CONST TYPE >;\r
-%enddef\r
-\r
-\r
-/////////////////////////////////////////////////////////////////////\r
-\r
-\r
-%include <shared_ptr.i>\r
-\r
-%define SWIG_INTRUSIVE_PTR_TYPEMAPS_NO_WRAP_IMPLEMENTATION(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, CONST, TYPE...)\r
-\r
-%naturalvar TYPE;\r
-%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;\r
-\r
-// destructor mods\r
-%feature("unref") TYPE "(void)arg1; delete smartarg1;"\r
-\r
-\r
-// plain value\r
-%typemap(in, canthrow=1) CONST TYPE ($&1_type argp = 0) %{\r
- argp = (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0;\r
- if (!argp) {\r
- SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null $1_type", 0);\r
- return $null;\r
- }\r
- $1 = *argp; %}\r
-%typemap(out) CONST TYPE \r
-%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)); %}\r
-\r
-// plain pointer\r
-%typemap(in) CONST TYPE * (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{\r
- smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input;\r
- $1 = (TYPE *)(smartarg ? smartarg->get() : 0); %}\r
-%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * %{\r
- *(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;\r
-%}\r
-\r
-// plain reference\r
-%typemap(in, canthrow=1) CONST TYPE & %{\r
- $1 = ($1_ltype)((*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0);\r
- if (!$1) {\r
- SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "$1_type reference is null", 0);\r
- return $null;\r
- } %}\r
-%typemap(out, fragment="SWIG_null_deleter") CONST TYPE &\r
-%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner); %}\r
-\r
-// plain pointer by reference\r
-%typemap(in) TYPE *CONST& ($*1_ltype temp = 0)\r
-%{ temp = ($*1_ltype)((*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0);\r
- $1 = &temp; %}\r
-%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST&\r
-%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner); %}\r
-\r
-%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast ($&1_type smartarg) %{\r
- // shared_ptr by value\r
- smartarg = *($&1_ltype*)&$input; \r
- if (smartarg) $1 = *smartarg; \r
-%}\r
-%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > ANY_TYPE_SWIGSharedPtrUpcast %{ \r
- *($&1_ltype*)&$result = $1 ? new $1_ltype($1) : 0; \r
-%}\r
-\r
-// various missing typemaps - If ever used (unlikely) ensure compilation error rather than runtime bug\r
-%typemap(in) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{\r
-#error "typemaps for $1_type not available"\r
-%}\r
-%typemap(out) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{\r
-#error "typemaps for $1_type not available"\r
-%}\r
-\r
-\r
-%typemap (ctype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "void *"\r
-%typemap (imtype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "void *"\r
-%typemap (cstype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "$typemap(cstype, TYPE)"\r
-%typemap (csin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > "$typemap(cstype, TYPE).getCPtr($csinput)"\r
-%typemap(csout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {\r
- IntPtr cPtr = $imcall;\r
- return (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);\r
- }\r
-\r
-%typemap(csout, excode=SWIGEXCODE) CONST TYPE {\r
- return new $typemap(cstype, TYPE)($imcall, true);\r
- }\r
-%typemap(csout, excode=SWIGEXCODE) CONST TYPE & {\r
- return new $typemap(cstype, TYPE)($imcall, true);\r
- }\r
-%typemap(csout, excode=SWIGEXCODE) CONST TYPE * {\r
- IntPtr cPtr = $imcall;\r
- return (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);\r
- }\r
-%typemap(csout, excode=SWIGEXCODE) TYPE *CONST& {\r
- IntPtr cPtr = $imcall;\r
- return (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);\r
- }\r
-\r
-// Base proxy classes\r
-%typemap(csbody) TYPE %{\r
- private HandleRef swigCPtr;\r
- private bool swigCMemOwnBase;\r
-\r
- PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) {\r
- swigCMemOwnBase = cMemoryOwn;\r
- swigCPtr = new HandleRef(this, cPtr);\r
- }\r
-\r
- CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {\r
- return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;\r
- }\r
-%}\r
-\r
-// Derived proxy classes\r
-%typemap(csbody_derived) TYPE %{\r
- private HandleRef swigCPtr;\r
- private bool swigCMemOwnDerived;\r
-\r
- PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGSmartPtrUpcast(cPtr), true) {\r
- swigCMemOwnDerived = cMemoryOwn;\r
- swigCPtr = new HandleRef(this, cPtr);\r
- }\r
-\r
- CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {\r
- return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;\r
- }\r
-%}\r
-\r
-%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") TYPE {\r
- lock(this) {\r
- if (swigCPtr.Handle != IntPtr.Zero) {\r
- if (swigCMemOwnBase) {\r
- swigCMemOwnBase = false;\r
- $imcall;\r
- }\r
- swigCPtr = new HandleRef(null, IntPtr.Zero);\r
- }\r
- GC.SuppressFinalize(this);\r
- }\r
- }\r
-\r
-%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") TYPE {\r
- lock(this) {\r
- if (swigCPtr.Handle != IntPtr.Zero) {\r
- if (swigCMemOwnDerived) {\r
- swigCMemOwnDerived = false;\r
- $imcall;\r
- }\r
- swigCPtr = new HandleRef(null, IntPtr.Zero);\r
- }\r
- GC.SuppressFinalize(this);\r
- base.Dispose();\r
- }\r
- }\r
-\r
-\r
-// CONST version needed ???? also for C#\r
-%typemap(imtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > swigSharedPtrUpcast "HandleRef"\r
-%typemap(imtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast "HandleRef"\r
-\r
-\r
-%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;\r
-%enddef\r
-\r
+// 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
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 >,
+%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 > *& "HandleRef"
+ 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).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
+ 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 > & {
- IntPtr cPtr = $imcall;
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+ 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 > * {
- IntPtr cPtr = $imcall;
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+ 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 > *& {
- IntPtr cPtr = $imcall;
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+ global::System.IntPtr cPtr = $imcall;
+ $typemap(cstype, TYPE) ret = (cPtr == global::System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
return ret;
}
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
+ 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& {
- IntPtr cPtr = $imcall;
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+ 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 {
- IntPtr cPtr = $imcall;
- $csclassname ret = (cPtr == IntPtr.Zero) ? null : new $csclassname(cPtr, true);$excode
+ 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 {
- IntPtr cPtr = $imcall;
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+ 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 {
- IntPtr cPtr = $imcall;
- $typemap(cstype, TYPE) ret = (cPtr == IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+ 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 HandleRef swigCPtr;
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
private bool swigCMemOwnBase;
- PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) {
+ PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwnBase = cMemoryOwn;
- swigCPtr = new HandleRef(this, cPtr);
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {
- return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ 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 HandleRef swigCPtr;
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
private bool swigCMemOwnDerived;
- PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGSmartPtrUpcast(cPtr), true) {
+ PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGSmartPtrUpcast(cPtr), true) {
swigCMemOwnDerived = cMemoryOwn;
- swigCPtr = new HandleRef(this, cPtr);
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {
- return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ 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 != IntPtr.Zero) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwnBase) {
swigCMemOwnBase = false;
$imcall;
}
- swigCPtr = new HandleRef(null, IntPtr.Zero);
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
- GC.SuppressFinalize(this);
+ global::System.GC.SuppressFinalize(this);
}
}
%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") TYPE {
lock(this) {
- if (swigCPtr.Handle != IntPtr.Zero) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwnDerived) {
swigCMemOwnDerived = false;
$imcall;
}
- swigCPtr = new HandleRef(null, IntPtr.Zero);
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
- GC.SuppressFinalize(this);
+ global::System.GC.SuppressFinalize(this);
base.Dispose();
}
}
* 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";
- register const unsigned char *u = (unsigned char *) ptr;
- register const unsigned char *eu = u + sz;
+ const unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register unsigned char uu = *u;
+ unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
%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;
+ unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register char d = *(c++);
- register unsigned char uu;
+ char d = *(c++);
+ unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = ((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
/* Non primitive types */
%typemap(ctype) SWIGTYPE "void *"
-%typemap(imtype, out="IntPtr") SWIGTYPE "HandleRef"
+%typemap(imtype, out="global::System.IntPtr") SWIGTYPE "global::System.Runtime.InteropServices.HandleRef"
%typemap(cstype) SWIGTYPE "$&csclassname"
%typemap(ctype) SWIGTYPE [] "void *"
-%typemap(imtype, out="IntPtr") SWIGTYPE [] "HandleRef"
+%typemap(imtype, out="global::System.IntPtr") SWIGTYPE [] "global::System.Runtime.InteropServices.HandleRef"
%typemap(cstype) SWIGTYPE [] "$csclassname"
%typemap(ctype) SWIGTYPE * "void *"
-%typemap(imtype, out="IntPtr") SWIGTYPE * "HandleRef"
+%typemap(imtype, out="global::System.IntPtr") SWIGTYPE * "global::System.Runtime.InteropServices.HandleRef"
%typemap(cstype) SWIGTYPE * "$csclassname"
%typemap(ctype) SWIGTYPE & "void *"
-%typemap(imtype, out="IntPtr") SWIGTYPE & "HandleRef"
+%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(directorin) int "$input = $1;"
%typemap(directorin) unsigned int "$input = $1;"
%typemap(directorin) long "$input = $1;"
-%typemap(directorin) unsigned 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;"
#endif
%typemap(directorin) SWIGTYPE
-%{ $input = (void *)&$1; %}
-%typemap(csdirectorin) SWIGTYPE "new $&csclassname($iminput, false)"
+%{ $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 */
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];
$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; %}
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 == IntPtr.Zero) ? null : new $csclassname($iminput, false)"
+%typemap(csdirectorin) SWIGTYPE *, SWIGTYPE (CLASS::*) "($iminput == global::System.IntPtr.Zero) ? null : new $csclassname($iminput, false)"
%typemap(csdirectorin) SWIGTYPE & "new $csclassname($iminput, false)"
-%typemap(csdirectorout) SWIGTYPE *, SWIGTYPE (CLASS::*), SWIGTYPE & "$csclassname.getCPtr($cscall).Handle"
+%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; %}
SWIGTYPE,
SWIGTYPE *,
SWIGTYPE &,
+ SWIGTYPE &&,
SWIGTYPE *const&,
SWIGTYPE [],
SWIGTYPE (CLASS::*)
SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, error_msg);
return $null; %}
-%typemap(throws, canthrow=1) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [ANY]
+%typemap(throws, canthrow=1) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE *, SWIGTYPE [ANY]
%{ (void)$1;
SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "C++ $1_type exception thrown");
return $null; %}
"$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 *, 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
$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 [] {
- IntPtr cPtr = $imcall;
- $csclassname ret = (cPtr == IntPtr.Zero) ? null : new $csclassname(cPtr, $owner);$excode
+ 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::*) {
/* Properties */
-%typemap(csvarin, excode=SWIGEXCODE2) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
+%typemap(csvarin, excode=SWIGEXCODE2) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
set {
$imcall;$excode
} %}
$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 {
- IntPtr cPtr = $imcall;
- $csclassname ret = (cPtr == IntPtr.Zero) ? null : new $csclassname(cPtr, $owner);$excode
+ global::System.IntPtr cPtr = $imcall;
+ $csclassname ret = (cPtr == global::System.IntPtr.Zero) ? null : new $csclassname(cPtr, $owner);$excode
return ret;
} %}
/* Pointer reference typemaps */
%typemap(ctype) SWIGTYPE *const& "void *"
-%typemap(imtype, out="IntPtr") SWIGTYPE *const& "HandleRef"
+%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& {
- IntPtr cPtr = $imcall;
- $*csclassname ret = (cPtr == IntPtr.Zero) ? null : new $*csclassname(cPtr, $owner);$excode
+ 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)
%typemap(out) SWIGTYPE *const&
%{ $result = (void *)*$1; %}
-/* Marshal C/C++ pointer to IntPtr */
+/* Marshal C/C++ pointer to global::System.IntPtr */
%typemap(ctype) void *VOID_INT_PTR "void *"
-%typemap(imtype) void *VOID_INT_PTR "IntPtr"
-%typemap(cstype) void *VOID_INT_PTR "IntPtr"
+%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 {
- IntPtr ret = $imcall;$excode
+ global::System.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::*) ""
+%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 HandleRef swigCPtr;
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) {
+ PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
- swigCPtr = new HandleRef(this, cPtr);
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {
- return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ 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 HandleRef swigCPtr;
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
- PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclazznameSWIGUpcast(cPtr), cMemoryOwn) {
- swigCPtr = new HandleRef(this, cPtr);
+ 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 HandleRef getCPtr($csclassname obj) {
- return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ 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 [] %{
- private HandleRef swigCPtr;
+%typemap(csbody) TYPE *, TYPE &, TYPE &&, TYPE [] %{
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
- PTRCTOR_VISIBILITY $csclassname(IntPtr cPtr, bool futureUse) {
- swigCPtr = new HandleRef(this, cPtr);
+ PTRCTOR_VISIBILITY $csclassname(global::System.IntPtr cPtr, bool futureUse) {
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
DEFAULTCTOR_VISIBILITY $csclassname() {
- swigCPtr = new HandleRef(null, IntPtr.Zero);
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
- CPTR_VISIBILITY static HandleRef getCPtr($csclassname obj) {
- return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ 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") SWIGTYPE {
lock(this) {
- if (swigCPtr.Handle != IntPtr.Zero) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
$imcall;
}
- swigCPtr = new HandleRef(null, IntPtr.Zero);
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
- GC.SuppressFinalize(this);
+ global::System.GC.SuppressFinalize(this);
}
}
%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") SWIGTYPE {
lock(this) {
- if (swigCPtr.Handle != IntPtr.Zero) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
$imcall;
}
- swigCPtr = new HandleRef(null, IntPtr.Zero);
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
- GC.SuppressFinalize(this);
+ global::System.GC.SuppressFinalize(this);
base.Dispose();
}
}
%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 };
/* Array reference typemaps */
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
/*
// Alternative char * typemaps.
%pragma(csharp) imclasscode=%{
- public class SWIGStringMarshal : IDisposable {
- public readonly HandleRef swigCPtr;
+ public class SWIGStringMarshal : global::System.IDisposable {
+ public readonly global::System.Runtime.InteropServices.HandleRef swigCPtr;
public SWIGStringMarshal(string str) {
- swigCPtr = new HandleRef(this, System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(str));
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, global::System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(str));
}
public virtual void Dispose() {
- System.Runtime.InteropServices.Marshal.FreeHGlobal(swigCPtr.Handle);
- GC.SuppressFinalize(this);
+ global::System.Runtime.InteropServices.Marshal.FreeHGlobal(swigCPtr.Handle);
+ global::System.GC.SuppressFinalize(this);
}
}
%}
-%typemap(imtype, out="IntPtr") char *, char[ANY], char[] "HandleRef"
+%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 = System.Runtime.InteropServices.Marshal.PtrToStringAnsi($imcall);$excode
+ string ret = global::System.Runtime.InteropServices.Marshal.PtrToStringAnsi($imcall);$excode
return ret;
}
%typemap(csvarin, excode=SWIGEXCODE2) char *, char[ANY], char[] %{
} %}
%typemap(csvarout, excode=SWIGEXCODE2) char *, char[ANY], char[] %{
get {
- string ret = System.Runtime.InteropServices.Marshal.PtrToStringAnsi($imcall);$excode
+ string ret = global::System.Runtime.InteropServices.Marshal.PtrToStringAnsi($imcall);$excode
return ret;
} %}
*/
static ExceptionArgumentDelegate argumentNullDelegate = new ExceptionArgumentDelegate(SetPendingArgumentNullException);
static ExceptionArgumentDelegate argumentOutOfRangeDelegate = new ExceptionArgumentDelegate(SetPendingArgumentOutOfRangeException);
- [DllImport("$dllimport", EntryPoint="SWIGRegisterExceptionCallbacks_$module")]
+ [global::System.Runtime.InteropServices.DllImport("$dllimport", EntryPoint="SWIGRegisterExceptionCallbacks_$module")]
public static extern void SWIGRegisterExceptionCallbacks_$module(
ExceptionDelegate applicationDelegate,
ExceptionDelegate arithmeticDelegate,
ExceptionDelegate overflowDelegate,
ExceptionDelegate systemExceptionDelegate);
- [DllImport("$dllimport", EntryPoint="SWIGRegisterExceptionArgumentCallbacks_$module")]
+ [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 System.ApplicationException(message, SWIGPendingException.Retrieve()));
+ SWIGPendingException.Set(new global::System.ApplicationException(message, SWIGPendingException.Retrieve()));
}
static void SetPendingArithmeticException(string message) {
- SWIGPendingException.Set(new System.ArithmeticException(message, SWIGPendingException.Retrieve()));
+ SWIGPendingException.Set(new global::System.ArithmeticException(message, SWIGPendingException.Retrieve()));
}
static void SetPendingDivideByZeroException(string message) {
- SWIGPendingException.Set(new System.DivideByZeroException(message, SWIGPendingException.Retrieve()));
+ SWIGPendingException.Set(new global::System.DivideByZeroException(message, SWIGPendingException.Retrieve()));
}
static void SetPendingIndexOutOfRangeException(string message) {
- SWIGPendingException.Set(new System.IndexOutOfRangeException(message, SWIGPendingException.Retrieve()));
+ SWIGPendingException.Set(new global::System.IndexOutOfRangeException(message, SWIGPendingException.Retrieve()));
}
static void SetPendingInvalidCastException(string message) {
- SWIGPendingException.Set(new System.InvalidCastException(message, SWIGPendingException.Retrieve()));
+ SWIGPendingException.Set(new global::System.InvalidCastException(message, SWIGPendingException.Retrieve()));
}
static void SetPendingInvalidOperationException(string message) {
- SWIGPendingException.Set(new System.InvalidOperationException(message, SWIGPendingException.Retrieve()));
+ SWIGPendingException.Set(new global::System.InvalidOperationException(message, SWIGPendingException.Retrieve()));
}
static void SetPendingIOException(string message) {
- SWIGPendingException.Set(new System.IO.IOException(message, SWIGPendingException.Retrieve()));
+ SWIGPendingException.Set(new global::System.IO.IOException(message, SWIGPendingException.Retrieve()));
}
static void SetPendingNullReferenceException(string message) {
- SWIGPendingException.Set(new System.NullReferenceException(message, SWIGPendingException.Retrieve()));
+ SWIGPendingException.Set(new global::System.NullReferenceException(message, SWIGPendingException.Retrieve()));
}
static void SetPendingOutOfMemoryException(string message) {
- SWIGPendingException.Set(new System.OutOfMemoryException(message, SWIGPendingException.Retrieve()));
+ SWIGPendingException.Set(new global::System.OutOfMemoryException(message, SWIGPendingException.Retrieve()));
}
static void SetPendingOverflowException(string message) {
- SWIGPendingException.Set(new System.OverflowException(message, SWIGPendingException.Retrieve()));
+ SWIGPendingException.Set(new global::System.OverflowException(message, SWIGPendingException.Retrieve()));
}
static void SetPendingSystemException(string message) {
- SWIGPendingException.Set(new System.SystemException(message, SWIGPendingException.Retrieve()));
+ SWIGPendingException.Set(new global::System.SystemException(message, SWIGPendingException.Retrieve()));
}
static void SetPendingArgumentException(string message, string paramName) {
- SWIGPendingException.Set(new System.ArgumentException(message, paramName, SWIGPendingException.Retrieve()));
+ SWIGPendingException.Set(new global::System.ArgumentException(message, paramName, SWIGPendingException.Retrieve()));
}
static void SetPendingArgumentNullException(string message, string paramName) {
- Exception e = SWIGPendingException.Retrieve();
+ global::System.Exception e = SWIGPendingException.Retrieve();
if (e != null) message = message + " Inner Exception: " + e.Message;
- SWIGPendingException.Set(new System.ArgumentNullException(paramName, message));
+ SWIGPendingException.Set(new global::System.ArgumentNullException(paramName, message));
}
static void SetPendingArgumentOutOfRangeException(string message, string paramName) {
- Exception e = SWIGPendingException.Retrieve();
+ global::System.Exception e = SWIGPendingException.Retrieve();
if (e != null) message = message + " Inner Exception: " + e.Message;
- SWIGPendingException.Set(new System.ArgumentOutOfRangeException(paramName, message));
+ SWIGPendingException.Set(new global::System.ArgumentOutOfRangeException(paramName, message));
}
static SWIGExceptionHelper() {
protected static SWIGExceptionHelper swigExceptionHelper = new SWIGExceptionHelper();
public class SWIGPendingException {
- [ThreadStatic]
- private static Exception pendingException = null;
+ [global::System.ThreadStatic]
+ private static global::System.Exception pendingException = null;
private static int numExceptionsPending = 0;
public static bool Pending {
}
}
- public static void Set(Exception e) {
+ public static void Set(global::System.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);
+ 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 Exception Retrieve() {
- Exception e = null;
+ public static global::System.Exception Retrieve() {
+ global::System.Exception e = null;
if (numExceptionsPending > 0) {
if (pendingException != null) {
e = pendingException;
public delegate string SWIGStringDelegate(string message);
static SWIGStringDelegate stringDelegate = new SWIGStringDelegate(CreateString);
- [DllImport("$dllimport", EntryPoint="SWIGRegisterStringCallback_$module")]
+ [global::System.Runtime.InteropServices.DllImport("$dllimport", EntryPoint="SWIGRegisterStringCallback_$module")]
public static extern void SWIGRegisterStringCallback_$module(SWIGStringDelegate stringDelegate);
static string CreateString(string cString) {
/* 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(volatile);
CSHARPKW(while);
+CSHARPCLASSKW(delete);
#undef CSHARPKW
/* -----------------------------------------------------------------------------
* director.swg
*
- * This file contains support for director classes so that C# proxy
+ * 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>
+#include <exception>
namespace Swig {
/* Director base class - not currently used in C# directors */
};
/* Base class for director exceptions */
- class DirectorException {
+ class DirectorException : public std::exception {
protected:
std::string swig_msg;
public:
- DirectorException(const char* msg) : swig_msg(msg) {
+ 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() throw() {
}
- virtual ~DirectorException() {
+
+ const char *what() const throw() {
+ return swig_msg.c_str();
}
};
/* Pure virtual method exception */
- class DirectorPureVirtualException : public Swig::DirectorException {
+ class DirectorPureVirtualException : public DirectorException {
public:
- DirectorPureVirtualException(const char* msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
+ DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
}
};
}
-#endif /* __cplusplus */
-
-
%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
%{ temp = ($*1_ltype)$input;
$1 = &temp; %}
-%typemap(out) const enum SWIGTYPE & %{ $result = *$1; %}
+%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 = $1;"
+%typemap(directorin) const enum SWIGTYPE & "$input = (int)$1;"
%typemap(csdirectorin) const enum SWIGTYPE & "($*csclassname)$iminput"
%typemap(csdirectorout) const enum SWIGTYPE & "(int)$cscall"
%typemap(cstype) enum SWIGTYPE "$csclassname"
%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
-%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+%typemap(out) enum SWIGTYPE %{ $result = (int)$1; %}
%typemap(directorout) enum SWIGTYPE %{ $result = ($1_ltype)$input; %}
-%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(directorin) enum SWIGTYPE "$input = (int)$1;"
%typemap(csdirectorin) enum SWIGTYPE "($csclassname)$iminput"
%typemap(csdirectorout) enum SWIGTYPE "(int)$cscall"
%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
%{ temp = ($*1_ltype)$input;
$1 = &temp; %}
-%typemap(out) const enum SWIGTYPE & %{ $result = *$1; %}
+%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 = $1;"
+%typemap(directorin) const enum SWIGTYPE & "$input = (int)$1;"
%typemap(csdirectorin) const enum SWIGTYPE & "$iminput"
%typemap(csdirectorout) const enum SWIGTYPE & "$cscall"
%typemap(cstype) enum SWIGTYPE "int"
%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
-%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+%typemap(out) enum SWIGTYPE %{ $result = (int)$1; %}
%typemap(directorout) enum SWIGTYPE %{ $result = ($1_ltype)$input; %}
-%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(directorin) enum SWIGTYPE "$input = (int)$1;"
%typemap(csdirectorin) enum SWIGTYPE "$iminput"
%typemap(csdirectorout) enum SWIGTYPE "$cscall"
%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
%{ temp = ($*1_ltype)$input;
$1 = &temp; %}
-%typemap(out) const enum SWIGTYPE & %{ $result = *$1; %}
+%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 = $1;"
+%typemap(directorin) const enum SWIGTYPE & "$input = (int)$1;"
%typemap(csdirectorin) const enum SWIGTYPE & "$*csclassname.swigToEnum($iminput)"
%typemap(csdirectorout) const enum SWIGTYPE & "$cscall.swigValue"
%typemap(cstype) enum SWIGTYPE "$csclassname"
%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
-%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+%typemap(out) enum SWIGTYPE %{ $result = (int)$1; %}
%typemap(directorout) enum SWIGTYPE %{ $result = ($1_ltype)$input; %}
-%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(directorin) enum SWIGTYPE "$input = (int)$1;"
%typemap(csdirectorin) enum SWIGTYPE "$csclassname.swigToEnum($iminput)"
%typemap(csdirectorout) enum SWIGTYPE "$cscall.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);
+ throw new global::System.ArgumentOutOfRangeException("No enum $csclassname with value " + swigValue);
}
public override string ToString() {
--- /dev/null
+/*
+ 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 {};
+}
* %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
+ * 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!
/* 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(csinterfaces) std::map< K, T, C > "global::System.IDisposable \n , global::System.Collections.Generic.IDictionary<$typemap(cstype, K), $typemap(cstype, T)>\n";
%typemap(cscode) std::map<K, T, C > %{
public $typemap(cstype, T) this[$typemap(cstype, K) key] {
}
}
-#if !SWIG_DOTNET_1
-
- public System.Collections.Generic.ICollection<$typemap(cstype, K)> Keys {
+ public global::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)>();
+ 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) {
- IntPtr iter = create_iterator_begin();
+ global::System.IntPtr iter = create_iterator_begin();
for (int i = 0; i < size; i++) {
keys.Add(get_next_key(iter));
}
}
}
- public System.Collections.Generic.ICollection<$typemap(cstype, T)> Values {
+ public global::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) {
+ 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(System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> item) {
+ public void Add(global::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) {
+ public bool Remove(global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> item) {
if (Contains(item)) {
return Remove(item.Key);
} else {
}
}
- public bool Contains(System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> item) {
+ public bool Contains(global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> item) {
if (this[item.Key] == item.Value) {
return true;
} else {
}
}
- public void CopyTo(System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>[] array) {
+ public void CopyTo(global::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) {
+ public void CopyTo(global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>[] array, int arrayIndex) {
if (array == null)
- throw new ArgumentNullException("array");
+ throw new global::System.ArgumentNullException("array");
if (arrayIndex < 0)
- throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
+ throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (array.Rank > 1)
- throw new ArgumentException("Multi dimensional array.", "array");
+ throw new global::System.ArgumentException("Multi dimensional array.", "array");
if (arrayIndex+this.Count > array.Length)
- throw new ArgumentException("Number of elements to copy is too large.");
+ throw new global::System.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);
+ 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 System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>(currentKey, this[currentKey]), arrayIndex+i);
+ array.SetValue(new global::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() {
+ 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);
}
- System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
+ global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() {
return new $csclassnameEnumerator(this);
}
/// 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)>>
+ 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 System.Collections.Generic.IList<$typemap(cstype, K)> keyCollection;
+ 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 System.Collections.Generic.List<$typemap(cstype, K)>(collection.Keys);
+ keyCollection = new global::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 {
+ public global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> Current {
get {
if (currentIndex == -1)
- throw new InvalidOperationException("Enumeration not started.");
+ throw new global::System.InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
- throw new InvalidOperationException("Enumeration finished.");
+ throw new global::System.InvalidOperationException("Enumeration finished.");
if (currentObject == null)
- throw new InvalidOperationException("Collection modified.");
- return (System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>)currentObject;
+ 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 System.Collections.IEnumerator.Current {
+ object global::System.Collections.IEnumerator.Current {
get {
return Current;
}
if (moveOkay) {
currentIndex++;
$typemap(cstype, K) currentKey = keyCollection[currentIndex];
- currentObject = new System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>(currentKey, collectionRef[currentKey]);
+ currentObject = new global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>(currentKey, collectionRef[currentKey]);
} else {
currentObject = null;
}
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
- throw new InvalidOperationException("Collection modified.");
+ throw new global::System.InvalidOperationException("Collection modified.");
}
}
currentObject = null;
}
}
-#endif
%}
* 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
// 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(csinterfaces) std::vector< CTYPE > "global::System.IDisposable, global::System.Collections.IEnumerable\n , global::System.Collections.Generic.CSINTERFACE<$typemap(cstype, CTYPE)>\n";
%typemap(cscode) std::vector< CTYPE > %{
- public $csclassname(System.Collections.ICollection c) : this() {
+ public $csclassname(global::System.Collections.ICollection c) : this() {
if (c == null)
- throw new ArgumentNullException("c");
+ throw new global::System.ArgumentNullException("c");
foreach ($typemap(cstype, CTYPE) element in c) {
this.Add(element);
}
}
set {
if (value < size())
- throw new ArgumentOutOfRangeException("Capacity");
+ throw new global::System.ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
}
}
-#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");
+ throw new global::System.ArgumentNullException("array");
if (index < 0)
- throw new ArgumentOutOfRangeException("index", "Value is less than zero");
+ throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
- throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
+ throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
- throw new ArgumentOutOfRangeException("count", "Value is less than zero");
+ throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
- throw new ArgumentException("Multi dimensional array.", "array");
+ throw new global::System.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.");
+ 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);
}
-#if !SWIG_DOTNET_1
- System.Collections.Generic.IEnumerator<$typemap(cstype, CTYPE)> System.Collections.Generic.IEnumerable<$typemap(cstype, CTYPE)>.GetEnumerator() {
+ global::System.Collections.Generic.IEnumerator<$typemap(cstype, CTYPE)> global::System.Collections.Generic.IEnumerable<$typemap(cstype, CTYPE)>.GetEnumerator() {
return new $csclassnameEnumerator(this);
}
-#endif
- System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
+ global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() {
return new $csclassnameEnumerator(this);
}
/// 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
+ public sealed class $csclassnameEnumerator : global::System.Collections.IEnumerator
+ , global::System.Collections.Generic.IEnumerator<$typemap(cstype, CTYPE)>
{
private $csclassname collectionRef;
private int currentIndex;
public $typemap(cstype, CTYPE) Current {
get {
if (currentIndex == -1)
- throw new InvalidOperationException("Enumeration not started.");
+ throw new global::System.InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
- throw new InvalidOperationException("Enumeration finished.");
+ throw new global::System.InvalidOperationException("Enumeration finished.");
if (currentObject == null)
- throw new InvalidOperationException("Collection modified.");
+ throw new global::System.InvalidOperationException("Collection modified.");
return ($typemap(cstype, CTYPE))currentObject;
}
}
// Type-unsafe IEnumerator.Current
- object System.Collections.IEnumerator.Current {
+ object global::System.Collections.IEnumerator.Current {
get {
return Current;
}
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
- throw new InvalidOperationException("Collection modified.");
+ throw new global::System.InvalidOperationException("Collection modified.");
}
}
-#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
-#endif
}
%}
else
throw std::out_of_range("index");
}
- const_reference getitem(int index) throw (std::out_of_range) {
+ CONST_REFERENCE getitem(int index) throw (std::out_of_range) {
if (index>=0 && index<(int)$self->size())
return (*$self)[index];
else
// wstring
%typemap(ctype, out="void *") wstring "wchar_t *"
-%typemap(imtype, inattributes="[MarshalAs(UnmanagedType.LPWStr)]") wstring "string"
+%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"
// const wstring &
%typemap(ctype, out="void *") const wstring & "wchar_t *"
-%typemap(imtype, inattributes="[MarshalAs(UnmanagedType.LPWStr)]") const wstring & "string"
+%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"
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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
+
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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 ""
%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(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"
%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(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"
%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(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"
%pragma(csharp) imclasscode=%{
protected class SWIGWStringHelper {
- public delegate string SWIGWStringDelegate(IntPtr message);
+ public delegate string SWIGWStringDelegate(global::System.IntPtr message);
static SWIGWStringDelegate wstringDelegate = new SWIGWStringDelegate(CreateWString);
- [DllImport("$dllimport", EntryPoint="SWIGRegisterWStringCallback_$module")]
+ [global::System.Runtime.InteropServices.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 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() {
// wchar_t *
%typemap(ctype) wchar_t * "wchar_t *"
-%typemap(imtype, inattributes="[MarshalAs(UnmanagedType.LPWStr)]", out="IntPtr" ) wchar_t * "string"
+%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 = System.Runtime.InteropServices.Marshal.PtrToStringUni($imcall);$excode
+ string ret = global::System.Runtime.InteropServices.Marshal.PtrToStringUni($imcall);$excode
return ret;
}
%typemap(csvarin, excode=SWIGEXCODE2) wchar_t * %{
swigCMemOwn = ownCObject;
}
-public static void* swigGetCPtr($dclassname obj) {
+public static void* swigGetCPtr(typeof(this) obj) {
return (obj is null) ? null : obj.swigCPtr;
}
%}
swigCMemOwn = ownCObject;
}
-public static void* swigGetCPtr($dclassname obj) {
+public static void* swigGetCPtr(typeof(this) obj) {
return (obj is null) ? null : obj.swigCPtr;
}
%}
%{
static TYPE *new_##NAME(int nelements) { %}
#ifdef __cplusplus
-%{ return new TYPE[nelements]; %}
+%{ return new TYPE[nelements](); %}
#else
%{ return (TYPE *) calloc(nelements,sizeof(TYPE)); %}
#endif
%extend NAME {
#ifdef __cplusplus
NAME(int nelements) {
- return new TYPE[nelements];
+ return new TYPE[nelements]();
}
~NAME() {
delete [] self;
swigCMemOwn = ownCObject;
}
-public static void* swigGetCPtr($dclassname obj) {
+public static void* swigGetCPtr(typeof(this) obj) {
return (obj is null) ? null : obj.swigCPtr;
}
swigCPtr = cObject;
}
-public static void* swigGetCPtr($dclassname obj) {
+public static void* swigGetCPtr(typeof(this) obj) {
return (obj is null) ? null : obj.swigCPtr;
}
swigCPtr = null;
}
-public static void* swigGetCPtr($dclassname obj) {
+public static void* swigGetCPtr(typeof(this) obj) {
return (obj is null) ? null : obj.swigCPtr;
}
swigCPtr = null;
}
-package static char* swigGetCMemberPtr($dclassname obj) {
+package static char* swigGetCMemberPtr(typeof(this) obj) {
return (obj is null) ? null : obj.swigCPtr;
}
%typecheck(SWIG_TYPECHECK_POINTER) enum SWIGTYPE ""
%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
-%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+%typemap(out) enum SWIGTYPE %{ $result = (int)$1; %}
%typemap(directorout) enum SWIGTYPE %{ $result = ($1_ltype)$input; %}
-%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(directorin) enum SWIGTYPE "$input = (int)$1;"
%typemap(ddirectorin) enum SWIGTYPE "cast($dclassname)$winput"
%typemap(ddirectorout) enum SWIGTYPE "cast(int)$dcall"
%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
%{ temp = ($*1_ltype)$input;
$1 = &temp; %}
-%typemap(out) const enum SWIGTYPE & %{ $result = *$1; %}
+%typemap(out) const enum SWIGTYPE & %{ $result = (int)*$1; %}
-%typemap(directorin) const enum SWIGTYPE & "$input = $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; %}
SWIG_DIllegalArgumentException,
SWIG_DIllegalElementException,
SWIG_DIOException,
- SWIG_DNoSuchElementException,
+ SWIG_DNoSuchElementException
} SWIG_DExceptionCodes;
typedef void (* SWIG_DExceptionCallback_t)(const char *);
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;
+ return m_sPendingException.val !is null;
}
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);
+ 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;
- 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;
- }
- }
- }
+ auto e = m_sPendingException.val;
+ m_sPendingException.val = null;
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;
}
static void setException(const char* message) {
- auto exception = new object.Exception(std.conv.to!string(message).idup);
- exception.next = SwigPendingException.retrieve();
+ auto exception = new object.Exception(std.conv.to!string(message));
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;
+ 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;
- 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;
- }
- }
- }
+ auto e = m_sPendingException;
+ m_sPendingException = null;
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;
}
* methods can be called from C++.
* ----------------------------------------------------------------------------- */
-#ifdef __cplusplus
-
#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 {
+ 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) {
}
- const std::string& what() const {
- return swig_msg;
+
+ virtual ~DirectorException() throw() {
}
- virtual ~DirectorException() {
+
+ 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 thorugh the director layer.
- class DirectorPureVirtualException : public Swig::DirectorException {
+ // 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) {
+ DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempted to invoke pure virtual method ") + msg) {
}
};
}
-#endif /* __cplusplus */
/* 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;
+ const unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register unsigned char uu = *u;
+ unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
%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;
+ unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register char d = *(c++);
- register unsigned char uu;
+ char d = *(c++);
+ unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = ((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
#endif
%typemap(directorin) SWIGTYPE
- "$input = (void *)&$1;"
+ "$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");
}
$result = *($&1_ltype)$input; %}
-%typemap(ddirectorin) SWIGTYPE "new $&dclassname($winput, false)"
+%typemap(ddirectorin) SWIGTYPE "new $&dclassname($winput, true)"
%typemap(ddirectorout) SWIGTYPE "$&dclassname.swigGetCPtr($dcall)"
%typemap(din) SWIGTYPE "$&dclassname.swigGetCPtr($dinput)"
return $self->capacity() - $self->size();
}
- const_reference remove() throw (std::out_of_range) {
+ CONST_REFERENCE remove() throw (std::out_of_range) {
if ($self->empty()) {
throw std::out_of_range("Tried to remove last element from empty vector.");
}
return value;
}
- const_reference remove(size_type index) throw (std::out_of_range) {
+ 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.");
}
// 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) {
+ 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 pv;
}
- const_reference remove() throw (std::out_of_range) {
+ CONST_REFERENCE remove() throw (std::out_of_range) {
if ($self->empty()) {
throw std::out_of_range("Tried to remove last element from empty vector.");
}
return value;
}
- const_reference remove(size_type index) throw (std::out_of_range) {
+ 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.");
}
// 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) {
+ 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.");
}
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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
#ifdef SWIGPHP
%{
#include "zend_exceptions.h"
-#define SWIG_exception(code, msg) { zend_throw_exception(NULL, (char*)msg, code TSRMLS_CC); }
+#define SWIG_exception(code, msg) zend_throw_exception(NULL, (char*)msg, code TSRMLS_CC)
%}
#endif
%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 void JvFree (void *ptr);
-extern jint JvCreateJavaVM (void* vm_args);
+extern jint JvCreateJavaVM (JvVMInitArgs* vm_args);
extern java::lang::Thread* JvAttachCurrentThread (jstring name, java::lang::ThreadGroup* group);
%{
typedef struct SWIGCDATA {
char *data;
- int len;
+ intgo 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;
+%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
+ }
+ }
%}
/* -----------------------------------------------------------------------------
* 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) 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"
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(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,
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 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,
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 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,
double
%{ $result = ($1_ltype)$input; %}
-%typemap(directorout) const bool &,
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) const bool &,
const char &,
const signed char &,
const unsigned char &,
const float &,
const double &
%{
- $result = ($1_ltype)_swig_goallocate(sizeof($*1_ltype));
- *$result = *($1_ltype)&$input;
+ $result = new $*1_ltype($input);
+ swig_acquire_pointer(&swig_mem, $result);
%}
/* 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(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) const size_t &
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) const size_t &
%{
- $result = ($1_ltype)_swig_goallocate(sizeof($*1_ltype));
- *$result = *($1_ltype)$input;
+ $result = new $*1_ltype($input);
+ swig_acquire_pointer(&swig_mem, $result);
%}
/* Member pointers. */
%typemap(out) SWIGTYPE (CLASS::*)
%{
- $result = _swig_goallocate(sizeof($1_ltype));
- *($&1_ltype)$result = $1;
+ 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 = _swig_goallocate(sizeof($1_ltype));
- *($&1_ltype)$result = $input;
+ $result = new $1_ltype($input);
+ swig_acquire_pointer(&swig_mem, $result);
%}
/* Pointers. */
%{ $1 = *($&1_ltype)&$input; %}
%typemap(out) SWIGTYPE *
-%{ *($&1_ltype)&$result = $1; %}
+%{ *($&1_ltype)&$result = ($1_ltype)$1; %}
+
+%typemap(goout) SWIGTYPE * ""
%typemap(directorin) SWIGTYPE *
-%{ $input = ($1_ltype)$1; %}
+%{ *($&1_ltype)&$input = ($1_ltype)$1; %}
+
+%typemap(godirectorin) SWIGTYPE * ""
%typemap(directorout) SWIGTYPE *
-%{ $result = ($1_ltype)$input; %}
+%{ $result = *($&1_ltype)&$input; %}
%apply SWIGTYPE * { SWIGTYPE *const }
%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++
%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(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[],
- signed char *, signed char *&, signed char[ANY], signed char[],
- unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
-"string"
+ char *, char *&, char[ANY], char[] "string"
/* Needed to avoid confusion with the way the go module handles
references. */
%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[]
+ char *, char[ANY], char[]
%{
- $input = _swig_makegostring((char*)$1, $1 ? strlen((char*)$1) : 0);
+ $1 = ($1_ltype)malloc($input.n + 1);
+ memcpy($1, $input.p, $input.n);
+ $1[$input.n] = '\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[]
+%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 */
$2 = ($2_ltype)$input.n;
%}
-%typemap(out) (char *STRING, size_t LENGTH)
-%{ $result = _swig_makegostring((char*)$1, (size_t)$2); %}
+%typemap(out,fragment="AllocateString") (char *STRING, size_t LENGTH)
+%{ $result = Swig_AllocateString((char*)$1, (size_t)$2); %}
-%typemap(directorin) (char *STRING, size_t LENGTH)
-%{ $input = _swig_makegostring((char*)$1, $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)
%{
%typemap(out) enum SWIGTYPE
%{ $result = (intgo)$1; %}
+%typemap(goout) enum SWIGTYPE ""
+
%typemap(directorin) enum SWIGTYPE
-%{ $input = ($1_ltype)$1; %}
+%{ $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 = &e;
+ $input = ($1_ltype)&e;
%}
+%typemap(godirectorin) enum SWIGTYPE & ""
+
%typemap(directorout) enum SWIGTYPE &
%{
$*1_ltype f = ($*1_ltype)*$input;
}
#endif
+%typemap(goout) SWIGTYPE ""
+
%typemap(directorin) SWIGTYPE
-%{ $input = ($&1_ltype)&$1; %}
+%{ $input = new $1_ltype((const $1_ltype &)$1); %}
+
+%typemap(godirectorin) SWIGTYPE ""
%typemap(directorout) SWIGTYPE
%{ $result = *($&1_ltype)$input; %}
%typemap(throws) char *
%{ _swig_gopanic($1); %}
-%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY]
+%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
+ 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 */
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 &
""
SWIGTYPE,
SWIGTYPE *,
SWIGTYPE &,
+ SWIGTYPE &&,
SWIGTYPE *const&,
SWIGTYPE [],
SWIGTYPE (CLASS::*)
* 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>
%}
+#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) %{
%}
+#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. */
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 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 char *_swig_topofstack() {
+ if (_cgo_topofstack) {
+ return _cgo_topofstack();
+ } else {
+ return 0;
+ }
}
static void _swig_gopanic(const char *p) {
struct {
const char *p;
- } a;
+ } 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"
-#ifdef _64BIT
-#define SWIG_PARM_SIZE 8
-#else
-#define SWIG_PARM_SIZE 4
-#endif
+#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. */
#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
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)
+#ifdef __cplusplus
+extern "C" {
+#endif
#define SWIG_GCC_VERSION \
- (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC__PATH_LEVEL__)
+ (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#if SWIG_GCC_VERSION < 40700
#define SwigDoCgocall()
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
-#define _swig_goallocate _cgo_allocate
-#define _swig_gopanic _cgo_panic
-
%}
#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);
return ret;
}
+%}
+
+#endif
+
+%insert(runtime) %{
+
#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
+%go_import("unsafe", _ "runtime/cgo")
+#if !SWIGGO_CGO
+%insert(go_header) %{
+var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
%}
+#endif
#else
-%insert(go_header) %{
+%go_import("syscall", "unsafe")
-import "syscall"
-import "unsafe"
+%insert(go_header) %{
type _ syscall.Sockaddr
+%}
+
+#endif
+
+%insert(go_header) %{
+
type _ unsafe.Pointer
%}
-#endif
+/* 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. */
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)
+}
+
+%}
--- /dev/null
+/* ------------------------------------------------------------
+ * 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
+}
+%}
%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); %}
+%{
+ $result.assign($input.p, $input.n);
+ free($input.p);
+%}
+
+%typemap(out,fragment="AllocateString") string
+%{ $result = Swig_AllocateString($1.data(), $1.length()); %}
-%typemap(out) string
-%{ $result = _swig_makegostring($1.data(), $1.length()); %}
+%typemap(goout,fragment="CopyString") string
+%{ $result = swigCopyString($1) %}
-%typemap(directorin) string
-%{ $input = _swig_makegostring($1.data(), $1.length()); %}
+%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 = &$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) const string &
-%{ $result = _swig_makegostring((*$1).data(), (*$1).length()); %}
+%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(directorin) const string &
-%{ $input = _swig_makegostring($1.data(), $1.length()); %}
+%typemap(godirectorin,fragment="CopyString") const string &
+%{ $result = swigCopyString($input) %}
}
%rename(add) push_back;
void push_back(const value_type& x);
%extend {
- const_reference get(int i) throw (std::out_of_range) {
+ bool get(int i) throw (std::out_of_range) {
int size = int(self->size());
if (i>=0 && i<size)
return (*self)[i];
%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(out) TYPE *OUTPUT, TYPE &OUTPUT ""
+%typemap(goout) TYPE *INPUT, TYPE &INPUT ""
+
%typemap(freearg) TYPE *OUTPUT, TYPE &OUTPUT ""
%typemap(argout) TYPE *OUTPUT, TYPE &OUTPUT
%typemap(out) TYPE *INOUT, TYPE &INOUT ""
+%typemap(goout) TYPE *INOUT, TYPE &INOUT ""
+
%typemap(freearg) TYPE *INOUT, TYPE &INOUT ""
%typemap(argout) TYPE *INOUT, TYPE &INOUT ""
co:
co RCS/*.i* RCS/*.swg*
-
#endif
#if SCM_MAJOR_VERSION >= 2
-// scm_c_define_gsubr takes a different parameter type
-// depending on the guile version
+/* scm_c_define_gsubr takes a different parameter type depending on the guile version */
typedef scm_t_subr swig_guile_proc;
#else
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));
+ 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 {
SWIGINTERN void
SWIG_Guile_SetModule(swig_module_info *swig_module)
{
- SCM module;
- SCM variable;
-
- module = SWIG_Guile_Init();
-
+ 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));
namespace std {
template<class K, class T> class map {
- %typemap(in) map<K,T> (std::map<K,T>* m) {
+ %typemap(in) map<K,T> {
if (scm_is_null($input)) {
- $1 = std::map<K,T >();
+ $1 = std::map< K, T >();
} else if (scm_is_pair($input)) {
- $1 = std::map<K,T >();
+ $1 = std::map< K, T >();
SCM alist = $input;
while (!scm_is_null(alist)) {
K* k;
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) {
+ %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 >();
+ temp = std::map< K, T >();
$1 = &temp;
} else if (scm_is_pair($input)) {
- temp = std::map<K,T >();
+ temp = std::map< K, T >();
$1 = &temp;
SCM alist = $input;
while (!scm_is_null(alist)) {
}
%typemap(out) map<K,T> {
SCM alist = SCM_EOL;
- for (std::map<K,T >::reverse_iterator i=$i.rbegin();
- i!=$i.rend(); ++i) {
+ 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);
}
} else {
/* wrapped map? */
- std::map<K,T >* m;
+ std::map< K, T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0)
$1 = 1;
}
} else {
/* wrapped map? */
- std::map<K,T >* m;
+ std::map< K, T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0)
$1 = 1;
typedef K key_type;
typedef T mapped_type;
map();
- map(const map<K,T> &);
+ 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);
+ std::map< K, T >::iterator i = self->find(key);
if (i != self->end())
return i->second;
else
(*self)[key] = x;
}
void __delitem__(const K& key) throw (std::out_of_range) {
- std::map<K,T >::iterator i = self->find(key);
+ 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);
+ 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) {
+ 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);
%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) {
+ %typemap(in) map<K,T> {
if (scm_is_null($input)) {
- $1 = std::map<K,T >();
+ $1 = std::map< K, T >();
} else if (scm_is_pair($input)) {
- $1 = std::map<K,T >();
+ $1 = std::map< K, T >();
SCM alist = $input;
while (!scm_is_null(alist)) {
T* x;
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) {
+ %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 >();
+ temp = std::map< K, T >();
$1 = &temp;
} else if (scm_is_pair($input)) {
- temp = std::map<K,T >();
+ temp = std::map< K, T >();
$1 = &temp;
SCM alist = $input;
while (!scm_is_null(alist)) {
}
%typemap(out) map<K,T> {
SCM alist = SCM_EOL;
- for (std::map<K,T >::reverse_iterator i=$1.rbegin();
- i!=$1.rend(); ++i) {
+ 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);
}
} else {
// wrapped map?
- std::map<K,T >* m;
+ std::map< K, T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0)
$1 = 1;
}
} else {
// wrapped map?
- std::map<K,T >* m;
+ std::map< K, T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0)
$1 = 1;
%rename("has-key?") has_key;
public:
map();
- map(const map<K,T> &);
+ 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);
+ std::map< K, T >::iterator i = self->find(key);
if (i != self->end())
return i->second;
else
(*self)[key] = x;
}
void __delitem__(K key) throw (std::out_of_range) {
- std::map<K,T >::iterator i = self->find(key);
+ 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);
+ 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) {
+ 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);
}
%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) {
+ %typemap(in) map<K,T> {
if (scm_is_null($input)) {
- $1 = std::map<K,T >();
+ $1 = std::map< K, T >();
} else if (scm_is_pair($input)) {
- $1 = std::map<K,T >();
+ $1 = std::map< K, T >();
SCM alist = $input;
while (!scm_is_null(alist)) {
K* k;
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) {
+ %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 >();
+ temp = std::map< K, T >();
$1 = &temp;
} else if (scm_is_pair($input)) {
- temp = std::map<K,T >();
+ temp = std::map< K, T >();
$1 = &temp;
SCM alist = $input;
while (!scm_is_null(alist)) {
}
%typemap(out) map<K,T> {
SCM alist = SCM_EOL;
- for (std::map<K,T >::reverse_iterator i=$1.rbegin();
- i!=$1.rend(); ++i) {
+ 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);
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) {
}
} else {
// wrapped map?
- std::map<K,T >* m;
+ std::map< K, T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0)
$1 = 1;
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) {
}
} else {
// wrapped map?
- std::map<K,T >* m;
+ std::map< K, T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0)
$1 = 1;
%rename("has-key?") has_key;
public:
map();
- map(const map<K,T> &);
+ 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);
+ std::map< K, T >::iterator i = self->find(key);
if (i != self->end())
return i->second;
else
(*self)[key] = x;
}
void __delitem__(const K& key) throw (std::out_of_range) {
- std::map<K,T >::iterator i = self->find(key);
+ 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);
+ 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) {
+ 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);
%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) {
+ %typemap(in) map<K,T> {
if (scm_is_null($input)) {
- $1 = std::map<K,T >();
+ $1 = std::map< K, T >();
} else if (scm_is_pair($input)) {
- $1 = std::map<K,T >();
+ $1 = std::map< K, T >();
SCM alist = $input;
while (!scm_is_null(alist)) {
SCM entry, key, val;
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) {
+ %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 >();
+ temp = std::map< K, T >();
$1 = &temp;
} else if (scm_is_pair($input)) {
- temp = std::map<K,T >();
+ temp = std::map< K, T >();
$1 = &temp;
SCM alist = $input;
while (!scm_is_null(alist)) {
}
%typemap(out) map<K,T> {
SCM alist = SCM_EOL;
- for (std::map<K,T >::reverse_iterator i=$1.rbegin();
- i!=$1.rend(); ++i) {
+ 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);
}
} else {
// wrapped map?
- std::map<K,T >* m;
+ std::map< K, T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0)
$1 = 1;
}
} else {
// wrapped map?
- std::map<K,T >* m;
+ std::map< K, T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0)
$1 = 1;
%rename("has-key?") has_key;
public:
map();
- map(const map<K,T> &);
+ 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);
+ std::map< K, T >::iterator i = self->find(key);
if (i != self->end())
return i->second;
else
(*self)[key] = x;
}
void __delitem__(K key) throw (std::out_of_range) {
- std::map<K,T >::iterator i = self->find(key);
+ 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);
+ 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) {
+ 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);
}
}
} else {
/* wrapped pair? */
- std::pair<T,U >* m;
+ std::pair< T, U >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0)
$1 = 1;
}
} else {
/* wrapped pair? */
- std::pair<T,U >* m;
+ std::pair< T, U >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0)
$1 = 1;
}
} else {
/* wrapped pair? */
- std::pair<T,U >* m;
+ std::pair< T, U >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0)
$1 = 1;
}
} else {
/* wrapped pair? */
- std::pair<T,U >* m;
+ std::pair< T, U >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0)
$1 = 1;
}
} else {
/* wrapped pair? */
- std::pair<T,U >* m;
+ std::pair< T, U >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0)
$1 = 1;
}
} else {
/* wrapped pair? */
- std::pair<T,U >* m;
+ std::pair< T, U >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0)
$1 = 1;
}
} else {
/* wrapped pair? */
- std::pair<T,U >* m;
+ std::pair< T, U >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0)
$1 = 1;
}
} else {
/* wrapped pair? */
- std::pair<T,U >* m;
+ std::pair< T, U >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0)
$1 = 1;
%typemap(in) vector<T> {
if (scm_is_vector($input)) {
unsigned long size = scm_c_vector_length($input);
- $1 = std::vector<T >(size);
+ $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 >();
+ $1 = std::vector< T >();
} else if (scm_is_pair($input)) {
SCM head, tail;
- $1 = std::vector<T >();
+ $1 = std::vector< T >();
tail = $input;
while (!scm_is_null(tail)) {
head = SCM_CAR(tail);
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);
+ 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));
$argnum, 0));
}
} else if (scm_is_null($input)) {
- temp = std::vector<T >();
+ temp = std::vector< T >();
$1 = &temp;
} else if (scm_is_pair($input)) {
- temp = std::vector<T >();
+ temp = std::vector< T >();
$1 = &temp;
SCM head, tail;
tail = $input;
$1 = 0;
} else {
/* wrapped vector? */
- std::vector<T >* v;
+ std::vector< T >* v;
if (SWIG_ConvertPtr($input,(void **) &v,
$&1_descriptor, 0) != -1)
$1 = 1;
$1 = 0;
} else {
/* wrapped vector? */
- std::vector<T >* v;
+ std::vector< T >* v;
if (SWIG_ConvertPtr($input,(void **) &v,
$1_descriptor, 0) != -1)
$1 = 1;
%typemap(in) vector<T> {
if (scm_is_vector($input)) {
unsigned long size = scm_c_vector_length($input);
- $1 = std::vector<T >(size);
+ $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))
} else if (scm_is_pair($input)) {
SCM v = scm_vector($input);
unsigned long size = scm_c_vector_length(v);
- $1 = std::vector<T >(size);
+ $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))
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);
+ 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));
scm_wrong_type_arg(FUNC_NAME, $argnum, $input);
}
} else if (scm_is_null($input)) {
- temp = std::vector<T >();
+ 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);
+ 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));
$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;
}
$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;
+ std::vector< T >* v;
$1 = (SWIG_ConvertPtr($input,(void **) &v,
$&1_descriptor, 0) != -1) ? 1 : 0;
}
$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;
}
$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;
+ std::vector< T >* v;
$1 = (SWIG_ConvertPtr($input,(void **) &v,
$1_descriptor, 0) != -1) ? 1 : 0;
}
/* Pointers */
-%typemap(in) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
+%typemap(in) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
$1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
}
-%typemap(freearg) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] "";
+%typemap(freearg) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] "";
%typemap(in) void * {
$1 = ($1_ltype)SWIG_MustGetPtr($input, NULL, $argnum, 0);
$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);
}
$1 = SWIG_MustGetPtr($input, NULL, 1, 0);
}
-%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
+%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
$result = SWIG_NewPointerObj ($1, $descriptor, $owner);
}
$result = SWIG_NewPointerObj((void *) &$1, $1_descriptor, 0);
}
+%typemap(varout) SWIGTYPE && {
+ $result = SWIG_NewPointerObj((void *) &$1, $1_descriptor, 0);
+}
+
%typemap(throws) SWIGTYPE {
$<ype temp = new $ltype($1);
scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
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),
}
* (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(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($1), SCM_UNDEFINED));
+ scm_listify(scm_from_long((int)$1), SCM_UNDEFINED));
}
/* The SIMPLE_MAP_WITH_EXPR macro below defines the whole set of
$1 = scm_is_string($input) ? 1 : 0;
}
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
void *ptr;
int res = SWIG_ConvertPtr($input, &ptr, $1_descriptor, 0);
$1 = SWIG_CheckState(res);
/* Array reference typemaps */
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
/* 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);
extern uintmax_t wcstoumax (const wchar_t *nptr, wchar_t **endptr, int base);
#endif
-#endif /* SWIGWORDSIZE32 */
+#endif /* SWIGWORDSIZE64 */
#ifdef __cplusplus
}
#ifdef __cplusplus
%{ *carr = new CTYPE[sz]; %}
#else
-%{ *carr = (CTYPE*) calloc(sz, sizeof(CTYPE)); %}
+%{ *carr = (CTYPE*) malloc(sz * sizeof(CTYPE)); %}
#endif
%{ if (!*carr) {
SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
#ifdef __cplusplus
$1 = new $*1_ltype[sz];
#else
- $1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));
+ $1 = ($1_ltype) malloc(sz * sizeof($*1_ltype));
#endif
if (!$1) {
SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
#ifdef __cplusplus
$1 = new $*1_ltype[sz];
#else
- $1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));
+ $1 = ($1_ltype) malloc(sz * sizeof($*1_ltype));
#endif
if (!$1) {
SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
// Base proxy classes
%typemap(javabody) TYPE %{
- private long swigCPtr;
+ private transient long swigCPtr;
private boolean swigCMemOwnBase;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
// Derived proxy classes
%typemap(javabody_derived) TYPE %{
- private long swigCPtr;
+ private transient long swigCPtr;
private boolean swigCMemOwnDerived;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
// Base proxy classes
%typemap(javabody) TYPE %{
- private long swigCPtr;
+ private transient long swigCPtr;
private boolean swigCMemOwnBase;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
// Derived proxy classes
%typemap(javabody_derived) TYPE %{
- private long swigCPtr;
+ private transient long swigCPtr;
private boolean swigCMemOwnDerived;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
// Base proxy classes
%typemap(javabody) TYPE %{
- private long swigCPtr;
- private boolean swigCMemOwn;
+ private transient long swigCPtr;
+ private transient boolean swigCMemOwn;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
// Derived proxy classes
%typemap(javabody_derived) TYPE %{
- private long swigCPtr;
+ private transient long swigCPtr;
private boolean swigCMemOwnDerived;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
/* -----------------------------------------------------------------------------
* director.swg
*
- * This file contains support for director classes that proxy
- * method calls from C++ to Java extensions.
+ * This file contains support for director classes so that Java proxy
+ * methods can be called from C++.
* ----------------------------------------------------------------------------- */
-#ifdef __cplusplus
-
-#if defined(DEBUG_DIRECTOR_OWNED)
+#if defined(DEBUG_DIRECTOR_OWNED) || defined(DEBUG_DIRECTOR_EXCEPTION)
#include <iostream>
#endif
+#include <exception>
+
namespace Swig {
+
/* Java object wrapper */
class JObjectWrapper {
public:
}
/* Java proxy releases ownership of C++ object, C++ object is now
- responsible for destruction (creates NewGlobalRef to pin Java
- proxy) */
+ 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_) {
jthis_ = jenv->NewWeakGlobalRef(jself);
weak_global_ = true;
}
- } else { /* Java releases ownership of C++ object's lifetime */
+ } else {
+ /* Java releases ownership of C++ object's lifetime */
if (weak_global_) {
jenv->DeleteWeakGlobalRef((jweak)jthis_);
jthis_ = jenv->NewGlobalRef(jself);
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 */
#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
+ // 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
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
jenv->CallVoidMethod(jobj, disconn_meth);
}
}
- jenv->DeleteLocalRef(jobj);
}
public:
swig_self_.java_change_ownership(jenv, jself, take_or_release);
}
};
-}
-#endif /* __cplusplus */
+ // 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;
+ }
+}
%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.
%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
/* 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;
+ const unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register unsigned char uu = *u;
+ unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
%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;
+ unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register char d = *(c++);
- register unsigned char uu;
+ char d = *(c++);
+ unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = ((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
%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"
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];
+ 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);
}
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];
+ 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);
}
}
%typemap(directorin, descriptor="Ljava/lang/String;", noblock=1) char * {
- $input = 0;
+ $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); }
sz = JCALL1(GetArrayLength, jenv, ba);
$1 = &temp;
temp = 0;
- for(i=0; i<sz; i++) {
- temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
+ 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);
}
sz = JCALL1(GetArrayLength, jenv, ba);
$result = &temp;
temp = 0;
- for(i=0; i<sz; i++) {
- temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
+ 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(directorin,descriptor="L$packagepath/$&javaclassname;") SWIGTYPE
%{ $input = 0;
- *(($&1_ltype*)&$input) = &$1; %}
-%typemap(javadirectorin) SWIGTYPE "new $&javaclassname($jniinput, false)"
+ *(($&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 */
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::*) {
}
%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; %}
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(javadirectorout) SWIGTYPE *, SWIGTYPE (CLASS::*), SWIGTYPE & "$javaclassname.getCPtr($javacall)"
+%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; %}
$input = JCALL1(NewStringUTF, jenv, (const char *)$1);
if (!$input) return $null;
}
+ Swig::LocalRefGuard $1_refguard(jenv, $input);
}
%typemap(argout) char[ANY], char[] ""
SWIGTYPE,
SWIGTYPE *,
SWIGTYPE &,
+ SWIGTYPE &&,
SWIGTYPE *const&,
SWIGTYPE [],
SWIGTYPE (CLASS::*)
SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
return $null; %}
-%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY]
+%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY]
%{ (void)$1;
SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
return $null; %}
jobjectArray
"$javainput"
%typemap(javain) SWIGTYPE "$&javaclassname.getCPtr($javainput)"
-%typemap(javain) SWIGTYPE *, SWIGTYPE &, 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
%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);
%{ *($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::*) ""
+%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_PROXY(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...)
// Base proxy classes
%typemap(javabody) TYPE %{
- private long swigCPtr;
- protected boolean swigCMemOwn;
+ private transient long swigCPtr;
+ protected transient boolean swigCMemOwn;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
// Derived proxy classes
%typemap(javabody_derived) TYPE %{
- private long swigCPtr;
+ private transient long swigCPtr;
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
super($imclassname.$javaclazznameSWIGUpcast(cPtr), cMemoryOwn);
%define SWIG_JAVABODY_TYPEWRAPPER(PTRCTOR_VISIBILITY, DEFAULTCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...)
// Typewrapper classes
-%typemap(javabody) TYPE *, TYPE &, TYPE [] %{
- private long swigCPtr;
+%typemap(javabody) TYPE *, TYPE &, TYPE &&, TYPE [] %{
+ private transient long swigCPtr;
- PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean futureUse) {
+ PTRCTOR_VISIBILITY $javaclassname(long cPtr, @SuppressWarnings("unused") boolean futureUse) {
swigCPtr = cPtr;
}
%typemap(javabody) TYPE (CLASS::*) %{
private String swigCMemberPtr;
- PTRCTOR_VISIBILITY $javaclassname(String cMemberPtr, boolean futureUse) {
+ PTRCTOR_VISIBILITY $javaclassname(String cMemberPtr, @SuppressWarnings("unused") boolean futureUse) {
swigCMemberPtr = cMemberPtr;
}
/* Array reference typemaps */
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
%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);
+ $1 = ($1_ltype) JCALL2(GetByteArrayElements, jenv, $input, 0);
+ $2 = ($2_type) JCALL1(GetArrayLength, jenv, $input);
} else {
$1 = 0;
$2 = 0;
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);
+ jbyteArray jb = (jenv)->NewByteArray((jsize)$2);
+ (jenv)->SetByteArrayRegion(jb, 0, (jsize)$2, (jbyte *)$1);
$input = jb;
}
%typemap(directorargout) (char *STRING, size_t LENGTH)
-%{(jenv)->GetByteArrayRegion($input, 0, $2, (jbyte *)$1); %}
+%{(jenv)->GetByteArrayRegion($input, 0, (jsize)$2, (jbyte *)$1);
+(jenv)->DeleteLocalRef($input);%}
+%typemap(javadirectorin, descriptor="[B") (char *STRING, size_t LENGTH) "$jniinput"
%apply (char *STRING, size_t LENGTH) { (char *STRING, int LENGTH) }
/* java keywords */
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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");
+ }
+ }
+ };
+}
+
--- /dev/null
+/*
+ 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 {};
+}
%typemap(directorout) string
%{ if(!$input) {
- SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
+ if (!jenv->ExceptionCheck()) {
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
+ }
return $null;
}
const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0);
jenv->ReleaseStringUTFChars($input, $1_pstr); %}
%typemap(directorin,descriptor="Ljava/lang/String;") string
-%{ $input = jenv->NewStringUTF($1.c_str()); %}
+%{ $input = jenv->NewStringUTF($1.c_str());
+ Swig::LocalRefGuard $1_refguard(jenv, $input); %}
%typemap(out) string
%{ $result = jenv->NewStringUTF($1.c_str()); %}
jenv->ReleaseStringUTFChars($input, $1_pstr); %}
%typemap(directorin,descriptor="Ljava/lang/String;") const string &
-%{ $input = jenv->NewStringUTF($1.c_str()); %}
+%{ $input = jenv->NewStringUTF($1.c_str());
+ Swig::LocalRefGuard $1_refguard(jenv, $input); %}
%typemap(out) const string &
%{ $result = jenv->NewStringUTF($1->c_str()); %}
%rename(add) push_back;
void push_back(const value_type& x);
%extend {
- const_reference get(int i) throw (std::out_of_range) {
+ bool get(int i) throw (std::out_of_range) {
int size = int(self->size());
if (i>=0 && i<size)
return (*self)[i];
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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
+
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];
+ 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;
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];
+ 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;
#ifdef __cplusplus
$1 = new char*[size+1];
#else
- $1 = (char **)calloc(size+1, sizeof(char *));
+ $1 = (char **)malloc((size+1) * sizeof(char *));
#endif
for (i = 0; i<size; i++) {
jstring j_string = (jstring)JCALL2(GetObjectArrayElement, jenv, $input, i);
#ifdef __cplusplus
$1[i] = new char [strlen(c_string)+1];
#else
- $1[i] = (char *)calloc(strlen(c_string)+1, sizeof(const char *));
+ $1[i] = (char *)malloc((strlen(c_string)+1) * sizeof(const char *));
#endif
strcpy($1[i], c_string);
JCALL2(ReleaseStringUTFChars, jenv, j_string, c_string);
%typemap(freearg) char **STRING_ARRAY {
int i;
- for (i=0; i<size$argnum-1; i++)
+ for (i=0; i<size$argnum; i++)
#ifdef __cplusplus
delete[] $1[i];
delete[] $1;
%typemap(out) char **STRING_ARRAY {
if ($1) {
int i;
- int len=0;
+ jsize len=0;
jstring temp_string;
const jclass clazz = JCALL1(FindClass, jenv, "java/lang/String");
* 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:
/* 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 ""
+
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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);
+}
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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);
--- /dev/null
+%include <typemaps/cdata.swg>
--- /dev/null
+#ifdef __cplusplus
+%include <std_complex.i>
+#else
+%include <ccomplex.i>
+#endif
+
--- /dev/null
+%include <typemaps/exception.swg>
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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>
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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");
+ 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");
+%}
--- /dev/null
+/*
+ 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)
--- /dev/null
+/*
+
+ 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.
+
+
+*/
--- /dev/null
+%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);
+ }
+
+ 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;
+}
+%}
--- /dev/null
+%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
+%}
--- /dev/null
+#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_
--- /dev/null
+/* ------------------------------------------------------------
+ * 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;
+}
+}
--- /dev/null
+/* ----------------------------------------------------------------------------
+ * Errors and exceptions
+ *
+ * ---------------------------------------------------------------------------*/
+
+#define SWIG_Error(code, msg) SWIG_JSC_exception(context, exception, code, msg)
+#define SWIG_exception(code, msg) SWIG_JSC_exception(context, exception, code, msg)
+#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;
+}
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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 */
--- /dev/null
+/* ------------------------------------------------------------
+ * 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)
+%}
--- /dev/null
+/* ------------------------------------------------------------
+ * 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>
--- /dev/null
+%include <std_except.i>
+
+%apply size_t { std::size_t };
+%apply const size_t& { const std::size_t& };
+
--- /dev/null
+/*
+ * 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>);
--- /dev/null
+%include <std/_std_deque.i>
--- /dev/null
+%include <typemaps/std_except.swg>
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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
+
+}
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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
+
+}
--- /dev/null
+%include <typemaps/std_string.swg>
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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
+
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * stl.i
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <std_string.i>
+%include <std_vector.i>
+%include <std_map.i>
+%include <std_pair.i>
+
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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>
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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;
+}
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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);
--- /dev/null
+%include <typemaps/cdata.swg>
--- /dev/null
+#ifdef __cplusplus
+%include <std_complex.i>
+#else
+%include <ccomplex.i>
+#endif
+
--- /dev/null
+%include <typemaps/exception.swg>
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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>
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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");
+ 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);
+%}
--- /dev/null
+/*
+ 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)
--- /dev/null
+/*
+
+ 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.
+
+
+*/
--- /dev/null
+%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);
+ }
+}
+
+%} // v8_helper_functions
--- /dev/null
+%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
+%}
--- /dev/null
+#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_
--- /dev/null
+/* ------------------------------------------------------------
+ * 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;
+}
+}
+
--- /dev/null
+/* ---------------------------------------------------------------------------
+ * 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) SWIGV8_ErrorHandler.error(code, msg)
+#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);
+}
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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"
+
--- /dev/null
+
+/* ------------------------------------------------------------
+ * 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();
+ }
+}
+}
--- /dev/null
+/* ------------------------------------------------------------
+ * 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>
--- /dev/null
+%include <std_except.i>
+
+%apply size_t { std::size_t };
+%apply const size_t& { const std::size_t& };
+
--- /dev/null
+/*
+ * 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>);
--- /dev/null
+%include <std/_std_deque.i>
--- /dev/null
+%include <typemaps/std_except.swg>
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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
+
+}
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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
+
+}
--- /dev/null
+%include <typemaps/std_string.swg>
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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
+
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * stl.i
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <std_string.i>
+%include <std_vector.i>
+%include <std_map.i>
+%include <std_pair.i>
+
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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>
* includes
* ----------------------------------------------------------------------------- */
-%include <luatypemaps.swg> /* The typemaps */
+%include <luatypemaps.swg> /* The typemaps */
%include <luaruntime.swg> /* The runtime stuff */
+%include <luakw.swg> /* Warnings for Lua keywords */
//%include <typemaps/swigmacros.swg>
/* -----------------------------------------------------------------------------
%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}
+%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_BINARY, (char *)"$symname", sizeof($type), 0, (void *)&$value, &$1_descriptor}
+ { SWIG_LUA_CONSTTAB_BINARY("$symname", sizeof($type),&$value, $1_descriptor) }
/* -----------------------------------------------------------------------------
// char is changed to a string
%typemap(throws) char
-%{lua_pushfstring(L,"%c",$1);SWIG_fail;%}
+%{lua_pushlstring(L,&$1,1);SWIG_fail;%}
/*
Throwing object is a serious problem:
}
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 */
--- /dev/null
+/*
+ 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
# 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
* ----------------------------------------------------------------------------- */
# 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
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;
swig_type_info **ptype;
} swig_lua_const_info;
-typedef struct {
- const char *name;
- lua_CFunction method;
-} swig_lua_method;
+#endif
typedef struct {
const char *name;
lua_CFunction setmethod;
} swig_lua_attribute;
-// Can be used to create namespaces. Currently used to
-// wrap class static methods/variables/constants
-typedef struct {
+
+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;
+ 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_namespace *cls_static;
+ swig_lua_method *metatable; /* 0 for -eluac */
struct swig_lua_class **bases;
const char **base_names;
} swig_lua_class;
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)))
+/*#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_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);
}
SWIGRUNTIME void
-SWIG_Lua_SetModule(lua_State* L, swig_module_info *module) {
+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);
/* 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)
+SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L)
{
/* there should be 1 param passed in: the new value */
#ifndef SWIGLUA_IGNORE_SET_IMMUTABLE
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;
-}
+#ifdef SWIG_LUA_ELUA_EMULATE
-/* the module.set method used for setting linked data */
-SWIGINTERN int SWIG_Lua_module_set(lua_State* L)
+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)
{
-/* 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
+ int i, table_parsed, parsed_tables_array, target_table;
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
+ 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++)
{
- /* 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;
+ 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);
}
-#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA)
- else {
- return 0; // Exits stoically if an invalid key is initialized.
+ 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);
}
-#endif
+ assert(lua_gettop(L) == pairs_start + 2);
+ lua_rawset(L,target_table);
}
- 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;
+ lua_pop(L,1); /* Removing parsed tables storage */
+ assert(lua_gettop(L) == target_table);
}
-#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)
+SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L)
{
- 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
+ lua_pushnil(L);
+ lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
}
-/* ending the register */
-SWIGINTERN void SWIG_Lua_module_end(lua_State* L)
-{
- lua_pop(L,1); /* tidy stack (remove module) */
-}
+SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L);
-/* 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)
+SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L)
{
- 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) */
+ 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);
}
- lua_pop(L,1); /* tidy stack (remove meta) */
+ assert(lua_gettop(L) == 2);
+ return 1;
+
+fail:
+ lua_error(L);
+ return 0;
}
-#endif
-/* adding a function module */
-SWIGINTERN void SWIG_Lua_module_add_function(lua_State* L,const char* name,lua_CFunction fn)
+SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L)
{
- SWIG_Lua_add_function(L,name,fn);
+ 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
+ * global variable support code: namespaces and modules (which are the same thing)
* ----------------------------------------------------------------------------- */
-SWIGINTERN int SWIG_Lua_namespace_get(lua_State* L)
+SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L)
{
/* there should be 2 params passed in
(1) table (not the meta table)
return 0;
}
-SWIGINTERN int SWIG_Lua_namespace_set(lua_State* L)
+SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L)
{
/* there should be 3 params passed in
(1) table (not the meta table)
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;
}
-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
+#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)
+SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns)
{
- int i = 0;
+ int i;
+ /* There must be namespace table (not metatable) at the top of the stack */
assert(lua_istable(L,-1));
- /* There must be table at the top of the stack */
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_class_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod);
+ SWIG_Lua_add_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);
return 0;
}
-/* helper function. creates namespace table and add it to module table */
-SWIGINTERN int SWIG_Lua_namespace_register(lua_State* L, swig_lua_namespace* ns)
+/* Register all classes in the namespace */
+SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns)
{
- assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table */
+ 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_pushstring(L, ns->name);
lua_newtable(L); /* namespace itself */
lua_newtable(L); /* metatable for namespace */
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 */
- return 0;
+
+ /* 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
* ----------------------------------------------------------------------------- */
-/* the class.get method, performs the lookup of class attributes */
-SWIGINTERN int SWIG_Lua_class_get(lua_State* L)
+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,2); /* key */
+ 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,1); /* the userdata */
+ 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 */
- return 1;
+ 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 .get table */
+ SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
assert(lua_istable(L,-1)); /* just in case */
- lua_pushvalue(L,2); /* key */
+ 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 */
- return 1;
+ if(ret)
+ *ret = 1;
+ return SWIG_OK;
}
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 */
+ /* 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.set method, performs the lookup of class attributes */
-SWIGINTERN int SWIG_Lua_class_set(lua_State* L)
+/* 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
-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 */
+ 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,2); /* key */
+ 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,1); /* userdata */
- lua_pushvalue(L,3); /* value */
+ lua_pushvalue(L,substack_start+1); /* userdata */
+ lua_pushvalue(L,substack_start+3); /* value */
lua_call(L,2,0);
- return 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*/
}
- 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_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 1;
+ 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)
+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;
+ 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 */
}
/* the class.__tostring method called by the interpreter and print */
-SWIGINTERN int SWIG_Lua_class_tostring(lua_State* L)
+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 */
- unsigned long userData = (unsigned long)lua_touserdata(L,1); /* get the userdata address for later */
+ 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");
- const char* className = lua_tostring(L, -1);
-
- char output[256];
- sprintf(output, "<%s userdata: %lX>", className, userData);
-
- lua_pushstring(L, (const char*)output);
+ 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)
+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;
+ swig_lua_userdata *usr;
assert(lua_isuserdata(L,-1)); /* just in case */
usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */
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)
+/* 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)
{
- /* 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;
+ 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 class registry (or creates it) */
-SWIGINTERN void SWIG_Lua_get_class_registry(lua_State* L)
+/* 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");
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);
+ SWIG_Lua_create_class_registry(L);
/* 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)
+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_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_class_variable(lua_State* L,const char* name,lua_CFunction getFn,lua_CFunction setFn)
+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 */
}
/* 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)
+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 */
SWIG_Lua_add_class_static_details(L,clss->bases[i]);
}
- SWIG_Lua_add_namespace_details(L, &clss->cls_static);
+ 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_details(lua_State* L,swig_lua_class* clss)
+SWIGINTERN void SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss)
{
int i;
- /* call all the base classes first: we can then override these later: */
+ 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_add_class_details(L,clss->bases[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++;
}
- /* add fns */
+ 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_class_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod);
+ 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].method);
+ SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func);
}
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);
+ /* 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
}
-/* 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.
+/* 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.
*/
-SWIGINTERN void SWIG_Lua_init_base_class(lua_State* L,swig_lua_class* clss)
+
+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)
{
- int i=0;
- swig_module_info* module=SWIG_GetModule(L);
- for(i=0;clss->base_names[i];i++)
+ /* 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++)
{
- 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;
+ 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)
+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 */
+ 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_namespace_register(L,clss->cls_static, 1);
- 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
(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);
+ SWIG_Lua_add_function(L,"__call", clss->constructor);
lua_pop(L,1);
}
/* clear stack */
lua_pop(L,1);
+ assert( lua_gettop(L) == begin );
}
-/* performs the entire class registration process */
-SWIGINTERN void SWIG_Lua_class_register(lua_State* L,swig_lua_class* clss)
+/* 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)
{
- SWIG_Lua_class_register_static(L,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->name); /* get the name */
+ 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->name);
+ 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");
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) */
+ assert(lua_gettop(L) == begin);
- SWIG_Lua_get_class_metatable(L,clss->name);
- SWIG_Lua_add_class_details(L,clss); /* recursive adding of details (atts & ops) */
+#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)
+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);
+ SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname);
if (lua_istable(L,-1))
{
lua_setmetatable(L,-2);
}
/* pushes a new object into the lua stack */
-SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State* L,void* ptr,swig_type_info *type, int own)
+SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own)
{
- swig_lua_userdata* usr;
+ swig_lua_userdata *usr;
if (!ptr){
lua_pushnil(L);
return;
usr->type=type;
usr->own=own;
#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
- _SWIG_Lua_AddMetatable(L,type); /* add metatable */
+ 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)
+SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags)
{
- swig_lua_userdata* usr;
+ 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 */
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;
+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);
}
/* 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)
+SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type)
{
- swig_lua_rawdata* raw;
+ 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 */
+ 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)
+SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type)
{
- swig_lua_rawdata* raw;
+ 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 */
/* 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;
+ swig_lua_userdata *usr;
if (lua_isuserdata(L,tp))
{
usr=(swig_lua_userdata*)lua_touserdata(L,tp); /* get data */
}
/* lua callable function to get the userdata's type */
-SWIGRUNTIME int SWIG_Lua_type(lua_State* L)
+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[]) {
+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_pushinteger(L,(lua_Number)constants[i].lvalue);
lua_rawset(L,-3);
break;
case SWIG_LUA_FLOAT:
break;
case SWIG_LUA_CHAR:
lua_pushstring(L,constants[i].name);
- lua_pushfstring(L,"%c",(char)constants[i].lvalue);
+ {
+ char c = constants[i].lvalue;
+ lua_pushlstring(L,&c,1);
+ }
lua_rawset(L,-3);
break;
case SWIG_LUA_STRING:
#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()
+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) {
+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 (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 initalisation */
+ /* 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))
+#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_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);
- }
+ SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_class_equal);
#endif
#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata));
}
}
- /* additional registration structs & classes in lua */
+#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_class_register(L,(swig_lua_class*)(swig_types[i]->clientdata));
+ SWIG_Lua_elua_class_register_instance(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);
+#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)
// 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)
%{$1 = (lua_tostring(L, $input))[0];%}
%typemap(out) char
-%{ lua_pushfstring(L,"%c",$1); SWIG_arg++;%}
+%{ 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_pushfstring(L,"%c",*$1); SWIG_arg++;%}
+%{ lua_pushlstring(L, $1, 1); SWIG_arg++;%}
// pointers and references
// under SWIG rules, it is ok, to have a pass in a lua nil,
}
%}
+%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
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&,
+ enum SWIGTYPE, const enum SWIGTYPE&, const enum SWIGTYPE &&,
float, double, const float &, const double&
{
$1 = lua_isnumber(L,$input);
}
}
+%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)) {
// Array reference typemaps
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
for array handling
*/
%define SWIG_TYPEMAP_NUM_ARR(NAME,TYPE)
-%{SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE);%}
+%{SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)%}
// fixed size array's
%typemap(in) TYPE INPUT[ANY]
{
wchar_t* p;
if (str==0 || len<1) return 0;
- p=(wchar *)malloc((len+1)*sizeof(wchar_t));
+ p=(wchar_t *)malloc((len+1)*sizeof(wchar_t));
if (p==0) return 0;
- if (mbstowcs(p, str, len)==-1)
+ if (mbstowcs(p, str, len)==(size_t)-1)
{
free(p);
return 0;
%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 *)"
//SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
RETURN $null;
} %}
-%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE (CLASS::*) %{ *($&1_ltype)&$result = $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 *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE (CLASS::*) %{ *($&1_ltype)&$result = $1; %}
/* Default array handling */
SWIGTYPE,
SWIGTYPE *,
SWIGTYPE &,
+ SWIGTYPE &&,
SWIGTYPE [],
SWIGTYPE (CLASS::*)
""
enum SWIGTYPE
"$input"
%typemap(m3in) SWIGTYPE "$&*1_type.getCPtr($input)"
-%typemap(m3in) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "$1_basetype.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) 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 (CLASS::*) %{
+%typemap(m3varin) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
PROCEDURE Set$var (value: $vartype) =
BEGIN
$imcall;
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;
} %}
/* 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(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 (CLASS::*) ""
-%typemap(m3ptrconstructormodifiers) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "internal"
+%typemap(m3interfaces_derived) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(m3ptrconstructormodifiers) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "internal"
%typemap(m3finalize) SWIGTYPE %{
~$1_basetype() {
base.Dispose();
}
-%typemap(m3getcptr) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
+%typemap(m3getcptr) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
internal static IntPtr getCPtr($1_basetype obj) {
RETURN (obj == null) ? IntPtr.Zero : obj.swigCPtr;
}
/* Array reference typemaps */
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
co:
co RCS/*.i* RCS/*.swg*
-
$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;
$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 &, const SWIGTYPE & {
+%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 &, const SWIGTYPE & {
+%typemap(out) SWIGTYPE &, SWIGTYPE && {
$result = SWIG_NewPointerObj ($1, $descriptor, $owner);
}
$1 = (SCHEME_STRINGP($input)) ? 1 : 0;
}
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
void *ptr;
if (SWIG_ConvertPtr($input, (void **) &ptr, $1_descriptor, 0)) {
$1 = 0;
/* Array reference typemaps */
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
/* -----------------------------------------------------------------------------
* director.swg
*
- * This file contains support for director classes that proxy
- * method calls from C++ to Ocaml extensions.
- *
+ * This file contains support for director classes so that Ocaml proxy
+ * methods can be called from C++.
* ----------------------------------------------------------------------------- */
-#ifdef __cplusplus
-
#include <string>
+#include <exception>
# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
namespace Swig {
/* base class for director exceptions */
- class DirectorException {
+ class DirectorException : public std::exception {
protected:
std::string swig_msg;
+
public:
- DirectorException(const char* msg="") {
+ DirectorException(const char *msg="") : swig_msg(msg) {
}
- const char *getMessage() const {
- return swig_msg.c_str();
+
+ virtual ~DirectorException() throw() {
+ }
+
+ const char *what() const throw() {
+ return swig_msg.c_str();
}
- virtual ~DirectorException() {}
};
- /* type mismatch in the return value from a python method call */
- class DirectorTypeMismatchException : public Swig::DirectorException {
+ /* type mismatch in the return value from a Ocaml method call */
+ class DirectorTypeMismatchException : public DirectorException {
public:
- DirectorTypeMismatchException(const char* msg="") {
+ DirectorTypeMismatchException(const char *msg="") : DirectorException(msg) {
}
};
- /* any python exception that occurs during a director method call */
- class DirectorMethodException : public Swig::DirectorException {};
+ /* 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 Swig::DirectorException {
+ class DirectorPureVirtualException : public DirectorException {
public:
- DirectorPureVirtualException(const char* msg="") {
+ DirectorPureVirtualException(const char *msg="") : DirectorException(msg) {
}
static void raise(const char *msg) {
#define MUTEX_INIT(var) CRITICAL_SECTION var
#else
#include <pthread.h>
-#define MUTEX_INIT(var) pthread_mutex_t var = PTHREAD_MUTEX_INITIALIZER
+#define MUTEX_INIT(var) pthread_mutex_t var = PTHREAD_MUTEX_INITIALIZER
#endif
#endif
mutable bool swig_disown_flag;
public:
- /* wrap a ocaml object, optionally taking ownership */
+ /* 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.
+ 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 {
+ 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) {
+ /* 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 */
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 int caml_array_len( CAML_VALUE arr );
SWIGSTATIC CAML_VALUE caml_val_char( char c );
SWIGSTATIC CAML_VALUE caml_val_uchar( unsigned char c );
#ifdef __cplusplus
}
#endif
-
-/* mzschemedec.swg ends here */
}
}
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
void *ptr;
$1 = !caml_ptr_val_internal($input, &ptr,$descriptor);
}
$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");
}
}
+%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");
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)) ;
}
%apply SWIGTYPE { const SWIGTYPE & };
+%apply SWIGTYPE { const SWIGTYPE && };
#endif
/* Array reference typemaps */
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
}
}
%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));
+ 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 {
%variable_fail(res, "$type", "$name");
}
if (!argp) {
- %argument_nullref("$type", $symname, $argnum);
+ %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));
+ 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
%variable_fail(res, "$type", "$name");
}
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
- if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+ 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 > *);
+/* -----------------------------------------------------------------------------
+ * 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 {
}
};
- SWIGINTERN rtdir_map* get_rtdir_map() {
+ SWIGINTERN rtdir_map *get_rtdir_map() {
static swig_module_info *module = 0;
if (!module)
module = SWIG_GetModule(0);
}
SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d) {
- rtdir_map* rm = get_rtdir_map();
+ rtdir_map *rm = get_rtdir_map();
if (rm)
(*rm)[vptr] = d;
}
SWIGINTERNINLINE void erase_rtdir(void *vptr) {
- rtdir_map* rm = get_rtdir_map();
+ rtdir_map *rm = get_rtdir_map();
if (rm)
(*rm).erase(vptr);
}
SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
- rtdir_map* rm = get_rtdir_map();
+ rtdir_map *rm = get_rtdir_map();
if (!rm)
return 0;
rtdir_map::const_iterator pos = rm->find(vptr);
* ----------------------------------------------------------------------------- */
%{
+#include <climits>
#include <iostream>
%}
// The Octave C++ Wrap
-%insert(header) %{
-#include <stdexcept>
-%}
+%fragment("<stdexcept>");
%include <std_except.i>
// long long
-%fragment(SWIG_From_frag(long long),"header") {
+%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_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_OK;
}
+%#endif
}
-%fragment(SWIG_From_frag(unsigned long long),"header") {
+%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_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_OK;
}
+%#endif
}
// double
return octave_value_list();
}
- bool dispatch_unary_op(const std::string &symbol, octave_value &ret) {
- member_value_pair *m = find_member(symbol, false);
+ 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(as_value());
- octave_value_list argout(member_invoke(m, args, 1));
+ 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) {
- member_value_pair *m = find_member(symbol, false);
+ 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(as_value());
+ args.append(nc_this->as_value());
args.append(make_value_hack(rhs));
- octave_value_list argout(member_invoke(m, args, 1));
+ 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) {
- member_value_pair *m = find_member(symbol, false);
+ 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(as_value());
+ args.append(nc_this->as_value());
args.append(rhs);
- octave_value_list argout(member_invoke(m, args, 1));
+ octave_value_list argout(nc_this->member_invoke(m, args, 1));
if (argout.length() >= 1)
ret = argout(0);
return true;
}
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);
+ 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()) {
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) {
+ 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())
- return types[0].second.ptr;
+ 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)
- return types[j].second.ptr;
+ 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;
- int newmemory = 0;
- void *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
- assert(!newmemory); // newmemory handling not yet implemented
- return vptr;
+ 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 0;
+ return res;
}
bool is_owned() const {
}
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 ret;
+ if (!dispatch_unary_op("__str__", ret)) {
+ 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()) {
+ if (!ret.is_string()) {
error("__str__ method did not return a string");
return std::string();
}
- return outarg(0).string_value();
+ 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(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();
}
#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;
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 octave_value();
}
- void print(std::ostream &os, bool pr_as_read_syntax = false) const {
+#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;
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(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(); }
{ 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
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 {
return true;
}
- void print(std::ostream &os, bool pr_as_read_syntax = false) const {
+#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);
}
}
#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;
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");
- static octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
+ 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();
}
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;
+ return ost->cast(ptr, type, own, flags);
}
SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
#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>
#include <octave/toplev.h>
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\
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_this")) {
return octave_value_list();
}
- if (!SWIG_Octave_InstallFunction(me, "subclass")) {
+ if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
return octave_value_list();
}
-// Include fundamental fragemt definitions
+// Include fundamental fragment definitions
%include <typemaps/fragments.swg>
// Look for user fragments file.
-%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>
-*/
-
fragment=SWIG_From_frag(Type),
fragment="StdTraits") {
namespace swig {
- template <> struct traits<Type > {
+ template <> struct traits< Type > {
typedef value_category category;
static const char* type_name() { return #Type; }
- };
- template <> struct traits_asval<Type > {
+ };
+ template <> struct traits_asval< Type > {
typedef Type value_type;
- static int asval(octave_value obj, value_type *val) {
+ static int asval(octave_value obj, value_type *val) {
return SWIG_AsVal(Type)(obj, val);
}
};
- template <> struct traits_from<Type > {
+ template <> struct traits_from< Type > {
typedef Type value_type;
static octave_value from(const value_type& val) {
return SWIG_From(Type)(val);
fragment=SWIG_From_frag(int),
fragment="StdTraits") {
namespace swig {
- template <> struct traits_asval<Type > {
+ template <> struct traits_asval< Type > {
typedef Type value_type;
- static int asval(octave_value obj, value_type *val) {
+ static int asval(octave_value obj, value_type *val) {
return SWIG_AsVal(int)(obj, (int *)val);
}
};
- template <> struct traits_from<Type > {
+ template <> struct traits_from< Type > {
typedef Type value_type;
static octave_value from(const value_type& val) {
return SWIG_From(int)((int)val);
--- /dev/null
+#define SWIG_SHARED_PTR_NAMESPACE std
+%include <boost_shared_ptr.i>
# ---------------------------------------------------------------
# SWIG Perl5 Makefile
-#
+#
# This file can be used to build various Perl5 extensions with SWIG.
# By default this file is set up for dynamic loading, but it can
# be easily customized for static extensions by modifying various
# script and should already reflect your machine.
#----------------------------------------------------------------
-SRCS =
-CXXSRCS =
-OBJCSRCS =
-OBJS =
-INTERFACE =
+SRCS =
+CXXSRCS =
+OBJCSRCS =
+OBJS =
+INTERFACE =
WRAPFILE = $(INTERFACE:.i=_wrap.c)
WRAPOBJ = $(INTERFACE:.i=_wrap.o)
TARGET = module@SO@ # Use this kind of target for dynamic loading
CC = @CC@
CXX = @CXX@
-OBJC = @CC@ -Wno-import # -Wno-import needed for gcc
-CFLAGS =
+OBJC = @CC@ -Wno-import # -Wno-import needed for gcc
+CFLAGS =
INCLUDES =
LIBS =
# SWIGOPT = SWIG compiler options
# SWIGCC = Compiler used to compile the wrapper file
-SWIG = $(exec_prefix)/bin/swig
-SWIGOPT = -perl5
-SWIGCC = $(CC)
+SWIG = $(exec_prefix)/bin/swig
+SWIGOPT = -perl5
+SWIGCC = $(CC)
-# SWIG Library files. Uncomment this to staticly rebuild Perl
-#SWIGLIB = -static -lperlmain.i
+# SWIG Library files. Uncomment this to statically rebuild Perl
+#SWIGLIBS = -static -lperlmain.i
# Rules for creating .o files from source.
# need to provide additional link libraries (this is not always required).
#DLL_LIBS = -L/usr/local/lib/gcc-lib/sparc-sun-solaris2.5.1/2.7.2 \
- -L/usr/local/lib -lg++ -lstdc++ -lgcc
-
-# X11 installation (possibly needed if using Perl-Tk)
-
-XLIB = @XLIBSW@
-XINCLUDE = @XINCLUDES@
+ -L/usr/local/lib -lg++ -lstdc++ -lgcc
# Perl installation
PERL_INCLUDE = -I@PERL5EXT@
-PERL_LIB = -L@PERL5EXT@ -lperl
+PERL_LIB = -L@PERL5EXT@ -lperl
PERL_FLAGS = -Dbool=char -Dexplicit=
-# Tcl installation. If using Tk you might need this
-
-TCL_INCLUDE = @TCLINCLUDE@
-TCL_LIB = @TCLLIB@
-
# Build libraries (needed for static builds)
LIBM = @LIBM@
LIBC = @LIBC@
SYSLIBS = $(LIBM) $(LIBC) @LIBS@
-# Build options (uncomment only one these)
+# Build options
-#TK_LIB = $(TCL_LIB) -ltcl -ltk $(XLIB)
BUILD_LIBS = $(LIBS) # Dynamic loading
-#BUILD_LIBS = $(PERL_LIB) $(TK_LIB) $(LIBS) $(SYSLIBS) # Static linking
# Compilation rules for non-SWIG components
$(SWIGCC) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(PERL_INCLUDE) $(PERL_FLAGS) $(WRAPFILE)
$(WRAPFILE) : $(INTERFACE)
- $(SWIG) $(SWIGOPT) -o $(WRAPFILE) $(SWIGLIB) $(INTERFACE)
+ $(SWIG) $(SWIGOPT) -o $(WRAPFILE) $(SWIGLIBS) $(INTERFACE)
$(TARGET): $(WRAPOBJ) $(ALLOBJS)
$(BUILD) $(WRAPOBJ) $(ALLOBJS) $(BUILD_LIBS) -o $(TARGET)
clean:
rm -f $(COBJS) $(CXXOBJS) $(OBJCOBJS) $(WRAPOBJ) $(WRAPFILE) $(TARGET)
-
-
-
-
-
-
# 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.
'LIBS' => [''], # Custom libraries (if any)
'OBJECT' => '$module_wrap.o' # Object files
);
-
-
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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
+
#ifdef stat
#undef stat
#endif
+#ifdef seed
+ #undef seed
+#endif
#ifdef bool
/* Leave if macro is from C99 stdbool.h */
%init %{
-#ifdef __cplusplus
+#if defined(__cplusplus) && ! defined(XSPROTO)
extern "C"
#endif
XS(SWIG_init) {
dXSARGS;
int i;
+ (void)items;
SWIG_InitializeModule(0);
SWIG_From_dec(long)(long value)
{
SV *sv;
- if (value >= IV_MIN && value <= IV_MAX)
+ if (IVSIZE >= sizeof(value) || (value >= IV_MIN && value <= IV_MAX))
sv = newSViv(value);
else
sv = newSVpvf("%ld", value);
}
%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 (v <= LONG_MAX) {
+ 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 (v >= LONG_MIN && v <= LONG_MAX) {
+ if (IVSIZE <= sizeof(*val) || (v >= LONG_MIN && v <= LONG_MAX)) {
if(val) *val = v;
return SWIG_OK;
}
SWIG_From_dec(unsigned long)(unsigned long value)
{
SV *sv;
- if (value <= UV_MAX)
+ if (UVSIZE >= sizeof(value) || value <= UV_MAX)
sv = newSVuv(value);
else
sv = newSVpvf("%lu", value);
}
%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 (v <= ULONG_MAX) {
+ 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 && v <= ULONG_MAX) {
+ if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULONG_MAX)) {
if (val) *val = v;
return SWIG_OK;
}
/* long long */
%fragment(SWIG_From_frag(long long),"header",
- fragment=SWIG_From_frag(long),
- fragment="<limits.h>",
+ fragment="SWIG_LongLongAvailable",
fragment="<stdio.h>") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE SV *
SWIG_From_dec(long long)(long long value)
{
SV *sv;
- if (value >= IV_MIN && value <= IV_MAX)
+ 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
}
return sv_2mortal(sv);
}
+%#endif
}
%fragment(SWIG_AsVal_frag(long long),"header",
- fragment="<limits.h>",
+ 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);
- if (v < LLONG_MAX) {
+ /* 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 (v >= LLONG_MIN && v <= LLONG_MAX) {
+ if (IVSIZE <= sizeof(*val) || (v >= LLONG_MIN && v <= LLONG_MAX)) {
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="<limits.h>",
+ 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 (value <= UV_MAX)
+ if (UVSIZE >= sizeof(value) || value <= UV_MAX)
sv = newSVuv((UV)(value));
else {
//sv = newSVpvf("%llu", value); doesn't work in non 64bit Perl
}
return sv_2mortal(sv);
}
+%#endif
}
%fragment(SWIG_AsVal_frag(unsigned long long),"header",
- fragment="<limits.h>",
+ 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 && v <= ULLONG_MAX) {
+ if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULLONG_MAX)) {
if (val) *val = v;
return SWIG_OK;
} else {
}
return SWIG_TypeError;
}
+%#endif
}
/* double */
#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)
# ifdef PERL_OBJECT
# define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
-static void SWIG_Perl_croak_null(CPerlObj *pPerl)
+static void SWIGUNUSED SWIG_Perl_croak_null(CPerlObj *pPerl)
# else
-static void SWIG_croak_null()
+static void SWIGUNUSED SWIG_croak_null()
# endif
{
SV *err = get_sv("@", GV_ADD);
/* 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;
}
{
#define SWIG_FROM_CALL_ARGS SWIG_PERL_CALL_ARGS_1
-/* Include fundamental fragemt definitions */
+/* Include fundamental fragment definitions */
%include <typemaps/fragments.swg>
/* Look for user fragments file. */
* Unified typemap section
* ------------------------------------------------------------ */
-/* No director supported in Perl */
-#ifdef SWIG_DIRECTOR_TYPEMAPS
-#undef SWIG_DIRECTOR_TYPEMAPS
+/* director support in Perl is experimental */
+#ifndef SWIG_DIRECTOR_TYPEMAPS
+#define SWIG_DIRECTOR_TYPEMAPS
#endif
%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));";
%apply size_t { std::size_t };
+%fragment("<string>");
%{
-#include <string>
-
double SwigSvToNumber(SV* sv) {
return SvIOK(sv) ? double(SvIVX(sv)) : SvNVX(sv);
}
%{
#include <list>
-#include <algorithm>
-#include <stdexcept>
%}
+%fragment("<algorithm>");
+%fragment("<stdexcept>");
// exported class
}
}
%typemap(out) list<T> {
- std::list<T>::const_iterator i;
+ std::list< T >::const_iterator i;
unsigned int j;
int len = $1.size();
SV **svs = new SV*[len];
%typecheck(SWIG_TYPECHECK_LIST) list<T> {
{
/* wrapped list? */
- std::list<T >* v;
+ std::list< T >* v;
if (SWIG_ConvertPtr($input,(void **) &v,
$1_&descriptor,0) != -1) {
$1 = 1;
const list<T>* {
{
/* wrapped list? */
- std::list<T >* v;
+ std::list< T >* v;
if (SWIG_ConvertPtr($input,(void **) &v,
$1_descriptor,0) != -1) {
$1 = 1;
}
}
%typemap(out) list<T> {
- std::list<T>::const_iterator i;
+ std::list< T >::const_iterator i;
unsigned int j;
int len = $1.size();
SV **svs = new SV*[len];
%typecheck(SWIG_TYPECHECK_LIST) list<T> {
{
/* wrapped list? */
- std::list<T >* v;
+ std::list< T >* v;
if (SWIG_ConvertPtr($input,(void **) &v,
$1_&descriptor,0) != -1) {
$1 = 1;
const list<T>* {
{
/* wrapped list? */
- std::list<T >* v;
+ std::list< T >* v;
if (SWIG_ConvertPtr($input,(void **) &v,
$1_descriptor,0) != -1) {
$1 = 1;
%{
#include <map>
-#include <algorithm>
-#include <stdexcept>
%}
+%fragment("<algorithm>");
+%fragment("<stdexcept>");
// exported class
void clear();
%extend {
const T& get(const K& key) throw (std::out_of_range) {
- std::map<K,T >::iterator i = self->find(key);
+ std::map< K, T >::iterator i = self->find(key);
if (i != self->end())
return i->second;
else
(*self)[key] = x;
}
void del(const K& key) throw (std::out_of_range) {
- std::map<K,T >::iterator i = self->find(key);
+ 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);
+ std::map< K, T >::iterator i = self->find(key);
return i != self->end();
}
}
%{
#include <vector>
-#include <algorithm>
-#include <stdexcept>
%}
+%fragment("<algorithm>");
+%fragment("<stdexcept>");
// exported class
%typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
{
/* wrapped vector? */
- std::vector<T >* v;
+ std::vector< T >* v;
if (SWIG_ConvertPtr($input,(void **) &v,
$&1_descriptor,0) != -1) {
$1 = 1;
const vector<T>* {
{
/* wrapped vector? */
- std::vector<T >* v;
+ std::vector< T >* v;
if (SWIG_ConvertPtr($input,(void **) &v,
$1_descriptor,0) != -1) {
$1 = 1;
%typecheck(SWIG_TYPECHECK_VECTOR) vector<T *> {
{
/* wrapped vector? */
- std::vector<T *>* v;
+ std::vector< T *>* v;
int res = SWIG_ConvertPtr($input,(void **) &v, $&1_descriptor,0);
if (SWIG_IsOK(res)) {
$1 = 1;
%typecheck(SWIG_TYPECHECK_VECTOR) const vector<T *>&,const vector<T *>* {
{
/* wrapped vector? */
- std::vector<T *> *v;
+ std::vector< T *> *v;
int res = SWIG_ConvertPtr($input,%as_voidptrptr(&v), $1_descriptor,0);
if (SWIG_IsOK(res)) {
$1 = 1;
%typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
{
/* wrapped vector? */
- std::vector<T >* v;
+ std::vector< T >* v;
if (SWIG_ConvertPtr($input,(void **) &v,
$&1_descriptor,0) != -1) {
$1 = 1;
const vector<T>* {
{
/* wrapped vector? */
- std::vector<T >* v;
+ std::vector< T >* v;
if (SWIG_ConvertPtr($input,(void **) &v,
$1_descriptor,0) != -1) {
$1 = 1;
signed char,
bool,
enum SWIGTYPE
- "SWIG_LONG_CONSTANT($symname, $value);";
+ "SWIG_LONG_CONSTANT($symname, ($1_type)$value);";
%typemap(consttab) float,
double
%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);
- 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;
/* -----------------------------------------------------------------------------
* director.swg
*
- * This file contains support for director classes that proxy
- * method calls from C++ to PHP extensions.
+ * 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_
-#ifdef __cplusplus
-
#include <string>
+#include <exception>
#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() {}
+ struct GCItem {
+ virtual ~GCItem() {
+ }
- virtual int get_own() const
- {
+ virtual int get_own() const {
return 0;
}
};
- struct GCItem_var
- {
- GCItem_var(GCItem *item = 0) : _item(item)
- {
+ struct GCItem_var {
+ GCItem_var(GCItem *item = 0) : _item(item) {
}
- GCItem_var& operator=(GCItem *item)
- {
+ GCItem_var& operator=(GCItem *item) {
GCItem *tmp = _item;
_item = item;
delete tmp;
return *this;
}
- ~GCItem_var()
- {
+ ~GCItem_var() {
delete _item;
}
- GCItem * operator->() const
- {
+ GCItem * operator->() const {
return _item;
}
GCItem *_item;
};
- struct GCItem_Object : GCItem
- {
- GCItem_Object(int own) : _own(own)
- {
+ struct GCItem_Object : GCItem {
+ GCItem_Object(int own) : _own(own) {
}
- virtual ~GCItem_Object()
- {
+ virtual ~GCItem_Object() {
}
- int get_own() const
- {
+ int get_own() const {
return _own;
}
};
template <typename Type>
- struct GCItem_T : GCItem
- {
- GCItem_T(Type *ptr) : _ptr(ptr)
- {
+ struct GCItem_T : GCItem {
+ GCItem_T(Type *ptr) : _ptr(ptr) {
}
- virtual ~GCItem_T()
- {
+ virtual ~GCItem_T() {
delete _ptr;
}
class Director {
protected:
zval *swig_self;
- typedef std::map<void*, GCItem_var> swig_ownership_map;
+ 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
+#endif
public:
- Director(zval* self TSRMLS_DC) : swig_self(self) {
+ 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);
+ static bool swig_is_overridden_method(char *cname, char *lc_fname TSRMLS_DC) {
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) {
+ 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
}
template <typename Type>
- void swig_acquire_ownership(Type *vptr) const
- {
+ void swig_acquire_ownership(Type *vptr) const {
if (vptr) {
swig_owner[vptr] = new GCItem_T<Type>(vptr);
}
};
/* base class for director exceptions */
- class DirectorException {
+ 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 (strlen(msg)) {
+ DirectorException(int code, const char *hdr, const char *msg TSRMLS_DC) : swig_msg(hdr) {
+ if (msg[0]) {
swig_msg += " ";
swig_msg += msg;
}
SWIG_ErrorMsg() = swig_msg.c_str();
}
- static void raise(int code, const char *hdr, const char* msg TSRMLS_DC)
- {
+ 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 Swig::DirectorException
- {
+ class DirectorPureVirtualException : public DirectorException {
public:
- DirectorPureVirtualException(const char* msg TSRMLS_DC)
- : DirectorException(E_ERROR, "SWIG director pure virtual method called", msg TSRMLS_CC)
- {
+ 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)
- {
+ 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
+ class DirectorMethodException : public DirectorException
{
public:
- DirectorMethodException(const char* msg TSRMLS_DC)
- : DirectorException(E_ERROR, "SWIG director method error", msg TSRMLS_CC)
- {
+ DirectorMethodException(const char *msg TSRMLS_DC)
+ : DirectorException(E_ERROR, "SWIG director method error", msg TSRMLS_CC) {
}
- static void raise(const char *msg TSRMLS_DC)
- {
+ static void raise(const char *msg TSRMLS_DC) {
throw DirectorMethodException(msg TSRMLS_CC);
}
};
// so use a macro to insert TSRMLS_CC so any ZTS context gets passed.
#define DirectorMethodException() DirectorMethodException("" TSRMLS_CC)
-#endif /* __cplusplus */
-
#endif
zval *z_var;
MAKE_STD_ZVAL(z_var);
z_var->type = IS_LONG;
- z_var->value.lval = $1;
+ z_var->value.lval = (long)$1;
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
}
sizeof(zval *), NULL);
}
-%typemap(varinit) SWIGTYPE, SWIGTYPE &
+%typemap(varinit) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&
{
zval *z_var;
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 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
if (s1)
$1 = estrdup(s1);
else
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);
+ if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
+ if (s1)
+ strncpy($1, s1, $1_dim0);
}
}
}
-%typemap(varin) SWIGTYPE *, SWIGTYPE &
+%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) {
+ 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");
}
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 == 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;
+ (*z_var)->value.str.len = strlen($1) + 1;
} else {
(*z_var)->value.str.val = 0;
(*z_var)->value.str.len = 0;
zval **z_var;
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
- if($1)
+ if($1)
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
}
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((s1 == NULL) || strcmp(s1, $1)) {
if($1) {
(*z_var)->value.str.val = estrdup($1);
- (*z_var)->value.str.len = strlen($1)+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 &
+%typemap(varout) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&
{
zval **z_var;
%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");
+ /* 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;
}
- $result = *tmp;
}
%typemap(in) SWIGTYPE *,
}
}
+%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) {
%typemap(argout) SWIGTYPE *,
SWIGTYPE [],
- SWIGTYPE&;
+ SWIGTYPE &,
+ SWIGTYPE &&;
%typemap(in) void *
{
force=0;
if (arg1==NULL) {
#ifdef __cplusplus
- ptr=new $*1_ltype;
+ ptr=new $*1_ltype();
#else
ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
#endif
signed char,
unsigned char,
bool,
- size_t,
- enum SWIGTYPE
+ 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) {
const signed char &,
const unsigned char &,
const bool &,
- const size_t &,
- const enum SWIGTYPE &
+ 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) {
ZVAL_LONG($input,$1);
}
+%typemap(directorin) enum SWIGTYPE
+{
+ ZVAL_LONG($input, (long)$1_name);
+}
+
%typemap(directorin) char *, char []
{
if(!$1) {
%typemap(out) SWIGTYPE *,
SWIGTYPE [],
- SWIGTYPE &
+ SWIGTYPE &,
+ SWIGTYPE &&
%{
SWIG_SetPointerZval(return_value, (void *)$1, $1_descriptor, $owner);
%}
%typemap(directorin) SWIGTYPE *,
SWIGTYPE [],
- SWIGTYPE &
+ SWIGTYPE &,
+ SWIGTYPE &&
%{
SWIG_SetPointerZval($input, (void *)&$1, $1_descriptor, ($owner)|2);
%}
%typemap(directorin) SWIGTYPE
{
- SWIG_SetPointerZval($input, SWIG_as_voidptr(&$1), $&1_descriptor, 2);
+ SWIG_SetPointerZval($input, SWIG_as_voidptr(new $1_ltype((const $1_ltype &)$1)), $&1_descriptor, 1|2);
}
%typemap(out) void "";
SWIGTYPE *,
SWIGTYPE [],
SWIGTYPE &,
+ SWIGTYPE &&,
SWIGTYPE *const&
{
void *tmp;
return;
}
-%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY] %{
+%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;
/* Array reference typemaps */
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
* phpkw.swg
* ----------------------------------------------------------------------------- */
-#define PHPKW(x) %keywordwarn("'" `x` "' is a PHP keyword, renamed as 'c_" `x` "'",sourcefmt="%(lower)s",rename="c_%s") `x`
+/* Keyword (case insensitive) */
+#define PHPKW(x) %keywordwarn("'" `x` "' is a PHP keyword, renaming to '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`
+/* 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`
-#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`
+/* 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
-/*
- From
+/* 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
- http://aspn.activestate.com/ASPN/docs/PHP/reserved.html
- http://php.net/manual/en/reserved.keywords.php
+#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`
- 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,
+/* 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."
*/
-/* case insensitive */
+/* 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(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 PHP5.3
+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 PHP5.3
+PHPKW(namespace); // As of PHP 5.3
PHPKW(new);
PHPKW(or);
PHPKW(print); // "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);
-// 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__);
+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 */
-/* Type 1: case insensitive */
-PHPBN1(__sleep);
-PHPBN1(__wakeup);
-PHPBN1(not);
-PHPBN1(parent);
-PHPBN1(virtual);
-PHPBN1(NULL);
-PHPBN1(TRUE);
-PHPBN1(FALSE);
+/* Predefined case-insensitive constants */
+/* These *MUST* be listed in lower case here */
+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);
+/* "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);
-PHPBN2(PHP_INT_MAX);
-PHPBN2(PHP_INT_SIZE);
+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_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);
-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_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 */
+/* "Standard Predefined Constants" from http://php.net/manual/en/reserved.constants.php */
PHPBN2(EXTR_OVERWRITE);
PHPBN2(EXTR_SKIP);
PHPBN2(EXTR_PREFIX_SAME);
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(TRAP_BRKPT);
PHPBN2(TRAP_TRACE);
-/* Class names reserved by PHP */
-/* case insensitive */
+/* 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);
-PHPCN(directory);
-/* Added in PHP5 (this list apparently depends which extensions you load by default). */
-PHPCN(parent);
-PHPCN(self);
+/* Added in PHP5. */
PHPCN(exception);
+PHPCN(errorexception); // As of PHP 5.1
PHPCN(php_user_filter);
-PHPCN(errorexception);
+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(datetime);
/* Built-in PHP functions (incomplete). */
-PHPFN(cos);
-PHPFN(sin);
-PHPFN(tan);
+/* 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(sinh);
-PHPFN(tanh);
+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(ceil);
-PHPFN(floor);
-PHPFN(fmod);
-PHPFN(min);
-PHPFN(max);
+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
%define %pass_by_ref( TYPE, CONVERT_IN, CONVERT_OUT )
-%typemap(in) TYPE *REF ($*1_ltype tmp),
+%typemap(in, byref=1) TYPE *REF ($*1_ltype tmp),
TYPE &REF ($*1_ltype tmp)
%{
/* First Check for SWIG wrapped type */
# 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
if (!(expr) ) { zend_printf("Contract Assert Failed %s\n",msg ); } else
/* Standard SWIG API */
-#define SWIG_GetModule(clientdata) SWIG_Php_GetModule(clientdata)
+#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
}
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);
+ zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval*), NULL);
}
return;
}
}
static char const_name[] = "swig_runtime_data_type_pointer";
-static swig_module_info *SWIG_Php_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
+static swig_module_info *SWIG_Php_GetModule() {
zval *pointer;
swig_module_info *ret = 0;
TSRMLS_FETCH();
%}
%typemap(directorout) string %{
- convert_to_string_ex($input);
- $result.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
+ convert_to_string_ex(&$input);
+ $result.assign(Z_STRVAL_P($input), Z_STRLEN_P($input));
%}
%typemap(out) string %{
%}
%typemap(directorout) string & ($*1_ltype *temp) %{
- convert_to_string_ex($input);
- temp = new $*1_ltype(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
+ convert_to_string_ex(&$input);
+ temp = new $*1_ltype(Z_STRVAL_P($input), Z_STRLEN_P($input));
swig_acquire_ownership(temp);
$result = temp;
%}
self->pop_back();
return x;
}
- const_reference get(int i) throw (std::out_of_range) {
+ bool get(int i) throw (std::out_of_range) {
int size = int(self->size());
if (i>=0 && i<size)
return (*self)[i];
zval *o;
MAKE_STD_ZVAL(o);
ZVAL_BOOL(o,temp$argnum);
- t_output_helper( &$result, o );
+ t_output_helper( &$result, o TSRMLS_CC );
}
%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
%{
zval *o;
MAKE_STD_ZVAL(o);
ZVAL_DOUBLE(o,temp$argnum);
- t_output_helper( &$result, o );
+ t_output_helper( &$result, o TSRMLS_CC );
}
%typemap(in) TYPE *REFERENCE (TYPE dvalue), TYPE &REFERENCE (TYPE dvalue)
%{
zval *o;
MAKE_STD_ZVAL(o);
ZVAL_LONG(o,temp$argnum);
- t_output_helper( &$result, o );
+ t_output_helper( &$result, o TSRMLS_CC );
}
%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
%{
sprintf(temp, "%lld", (long long)temp$argnum);
ZVAL_STRING(o, temp, 1);
}
- t_output_helper( &$result, o );
+ t_output_helper( &$result, o TSRMLS_CC );
}
%typemap(in) TYPE *REFERENCE (long long lvalue)
%{
sprintf(temp, "%llu", (unsigned long long)temp$argnum);
ZVAL_STRING(o, temp, 1);
}
- t_output_helper( &$result, o );
+ t_output_helper( &$result, o TSRMLS_CC );
}
%typemap(in) TYPE *REFERENCE (unsigned long long lvalue)
%{
%}
%typemap(in,numinputs=0) char OUTPUT[ANY] ( char temp[$1_dim0] )
"$1 = temp;";
-%typemap(argout) char OUTPUT[ANY]
+%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 );
+ t_output_helper( &$result, o TSRMLS_CC );
}
%typemap(in,numinputs=0) void **OUTPUT (int force),
force=0;
if (arg1==NULL) {
#ifdef __cplusplus
- ptr=new $*1_ltype;
+ ptr=new $*1_ltype();
#else
ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
#endif
%}
%typemap(directorout) TYPE
%{
- CONVERT_IN($result,$1_ltype,$input);
+ CONVERT_IN($result,$1_ltype,&$input);
%}
%typemap(directorout) const TYPE & ($*1_ltype temp)
%{
- CONVERT_IN(temp,$*1_ltype,$input);
+ CONVERT_IN(temp,$*1_ltype,&$input);
$result = &temp;
%}
%enddef
%fragment("t_output_helper","header") %{
static void
-t_output_helper( zval **target, zval *o) {
+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 );
FREE_ZVAL(o);
return;
}
- zval *tmp;
ALLOC_INIT_ZVAL(tmp);
*tmp = **target;
zval_copy_ctor(tmp);
%typemap(in) SWIGTYPE *,
SWIGTYPE &,
+ SWIGTYPE &&,
SWIGTYPE []
"SWIG_ConvertPtr($input.u.object, (void **) &$1, $1_descriptor, 1);"
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),
+ const enum SWIGTYPE && ($*1_ltype temp)
{
if ($input.type != T_INT)
Pike_error("Bad argument: Expected an integer.\n");
%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));";
+%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 "";
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),
+ const enum SWIGTYPE && ($*1_ltype temp)
"push_int(*($1));";
%typemap(out, pikedesc="tFloat") const float &, const double & "push_float(*($1));";
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 &,
+ enum SWIGTYPE, enum SWIGTYPE &, SWIGTYPE &&,
bool, const bool &
{
$1 = ($input.type == T_INT) ? 1 : 0;
$1 = ($input.type == T_STRING) ? 1 : 0;
}
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
void *ptr;
if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $1_descriptor, 0) == -1) {
$1 = 0;
/* Array reference typemaps */
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
/* const pointers */
%apply SWIGTYPE * { SWIGTYPE *const }
%echo "pointer.i is deprecated. Use cpointer.i instead."
-%echo "See http://www.swig.org/Doc1.3/Library.html"
+%echo "See http://www.swig.org/Doc3.0/Library.html"
# ---------------------------------------------------------------
# SWIG Python Makefile
-#
+#
# This file can be used to build various Python extensions with SWIG.
# By default this file is set up for dynamic loading, but it can
# be easily customized for static extensions by modifying various
# script and should already reflect your machine.
#----------------------------------------------------------------
-SRCS =
-CXXSRCS =
-OBJCSRCS =
-OBJS =
-INTERFACE =
+SRCS =
+CXXSRCS =
+OBJCSRCS =
+OBJS =
+INTERFACE =
WRAPFILE = $(INTERFACE:.i=_wrap.c)
WRAPOBJ = $(INTERFACE:.i=_wrap.o)
TARGET = module@SO@ # Use this kind of target for dynamic loading
CC = @CC@
CXX = @CXX@
-OBJC = @CC@ -Wno-import # -Wno-import needed for gcc
-CFLAGS =
+OBJC = @CC@ -Wno-import # -Wno-import needed for gcc
+CFLAGS =
INCLUDES =
LIBS =
# SWIGOPT = SWIG compiler options
# SWIGCC = Compiler used to compile the wrapper file
-SWIG = $(exec_prefix)/bin/swig
-SWIGOPT = -python
-SWIGCC = $(CC)
+SWIG = $(exec_prefix)/bin/swig
+SWIGOPT = -python
+SWIGCC = $(CC)
# SWIG Library files. Uncomment if rebuilding the Python interpreter
-#SWIGLIB = -lembed.i
+#SWIGLIBS = -lembed.i
# Rules for creating .o files from source.
# need to provide additional link libraries (this is not always required).
#DLL_LIBS = -L/usr/local/lib/gcc-lib/sparc-sun-solaris2.5.1/2.7.2 \
- -L/usr/local/lib -lg++ -lstdc++ -lgcc
-
-# X11 installation (needed if rebuilding Python + tkinter)
-
-XLIB = @XLIBSW@
-XINCLUDE = @XINCLUDES@
+ -L/usr/local/lib -lg++ -lstdc++ -lgcc
# Python installation
-PY_INCLUDE = -DHAVE_CONFIG_H @PYINCLUDE@
+PY_INCLUDE = -DHAVE_CONFIG_H @PYINCLUDE@
PY_LIB = @PYLIB@
-# Tcl installation. Needed if rebuilding Python with tkinter.
-
-TCL_INCLUDE = @TCLINCLUDE@
-TCL_LIB = @TCLLIB@
-
# Build libraries (needed for static builds)
LIBM = @LIBM@
LIBC = @LIBC@
SYSLIBS = $(LIBM) $(LIBC) @LIBS@
-# Build options (uncomment only one these)
+# Build options
-#TKINTER = $(TCL_LIB) -ltk -ltcl $(XLIB)
BUILD_LIBS = $(LIBS) # Dynamic loading
-#BUILD_LIBS = $(PY_LIB) @PYLINK@ $(TKINTER) $(LIBS) $(SYSLIBS)
# Compilation rules for non-SWIG components
# Convert the wrapper file into an object file
$(WRAPOBJ) : $(WRAPFILE)
- $(SWIGCC) -c $(CCSHARED) $(CFLAGS) $(WRAPFILE) $(INCLUDES) $(PY_INCLUDE)
+ $(SWIGCC) -c $(CCSHARED) $(CFLAGS) $(WRAPFILE) $(INCLUDES) $(PY_INCLUDE)
$(WRAPFILE) : $(INTERFACE)
- $(SWIG) $(SWIGOPT) -o $(WRAPFILE) $(SWIGLIB) $(INTERFACE)
+ $(SWIG) $(SWIGOPT) -o $(WRAPFILE) $(SWIGLIBS) $(INTERFACE)
$(TARGET): $(WRAPOBJ) $(ALLOBJS)
$(BUILD) $(WRAPOBJ) $(ALLOBJS) $(BUILD_LIBS) -o $(TARGET)
clean:
rm -f $(COBJS) $(CXXOBJS) $(OBJCOBJS) $(WRAPOBJ) $(WRAPFILE) $(TARGET)
-
-
-
-
cstring.i Various forms of C character string handling
cwstring.i Various forms of C wchar_t string handling
embed.i embedding the Python interpreter in something else
-embed15.i embedding the Python interpreter in something else
file.i FILE C type
implicit.i Allow the use of implicit C++ constructors
wchar.i wchar_t C type
%variable_fail(res, "$type", "$name");
}
if (!argp) {
- %argument_nullref("$type", $symname, $argnum);
+ %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 > *);
%variable_fail(res, "$type", "$name");
}
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
- if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+ 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 > *);
wrapper##_closure(PyObject *a) { \
SwigPyObject *sobj; \
sobj = (SwigPyObject *)a; \
+ Py_XDECREF(sobj->dict); \
if (sobj->own) { \
- PyObject *o = wrapper(a, NULL); \
+ PyObject *o; \
+ PyObject *val = 0, *type = 0, *tb = 0; \
+ PyErr_Fetch(&val, &type, &tb); \
+ o = wrapper(a, NULL); \
+ if (!o) { \
+ PyObject *deallocname = PyString_FromString(#wrapper); \
+ PyErr_WriteUnraisable(deallocname); \
+ Py_DECREF(deallocname); \
+ } \
+ PyErr_Restore(val, type, tb); \
Py_XDECREF(o); \
} \
if (PyType_IS_GC(a->ob_type)) { \
#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
-wrapper##_closure(PyObject *callable_object, PyObject *args, PyObject *) { \
+wrapper##_closure(PyObject *callable_object, PyObject *args, PyObject *) { \
return wrapper(callable_object, args); \
}
return result; \
}
-#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
+#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject * \
wrapper##_closure(PyObject *a, Py_ssize_t b) { \
PyObject *arg, *result; \
0, /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
- 0, /* tp_version */
+ 0, /* tp_version_tag */
+#endif
+#if PY_VERSION_HEX >= 0x03040000
+ 0, /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
- 0,0,0,0 /* tp_alloc -> tp_next */
+ 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;
/* -----------------------------------------------------------------------------
* director.swg
*
- * This file contains support for director classes that proxy
- * method calls from C++ to Python extensions.
+ * 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_
-#ifdef __cplusplus
-
#include <string>
#include <iostream>
#include <exception>
/*
- 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;
+ SWIGINTERN std::map<void *, Director *>& get_rtdir_map() {
+ static std::map<void *, Director *> rtdir_map;
return rtdir_map;
}
}
SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
- std::map<void*,Director*>::const_iterator pos = get_rtdir_map().find(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)
+# 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
struct swig_type_info;
}
-namespace Swig {
+namespace Swig {
/* memory handler */
- struct GCItem
- {
+ struct GCItem {
virtual ~GCItem() {}
- virtual int get_own() const
- {
+ virtual int get_own() const {
return 0;
}
};
- struct GCItem_var
- {
- GCItem_var(GCItem *item = 0) : _item(item)
- {
+ struct GCItem_var {
+ GCItem_var(GCItem *item = 0) : _item(item) {
}
- GCItem_var& operator=(GCItem *item)
- {
+ GCItem_var& operator=(GCItem *item) {
GCItem *tmp = _item;
_item = item;
delete tmp;
return *this;
}
- ~GCItem_var()
- {
+ ~GCItem_var() {
delete _item;
}
-
- GCItem * operator->() const
- {
+
+ GCItem * operator->() const {
return _item;
}
-
+
private:
GCItem *_item;
};
-
- struct GCItem_Object : GCItem
- {
- GCItem_Object(int own) : _own(own)
- {
+
+ struct GCItem_Object : GCItem {
+ GCItem_Object(int own) : _own(own) {
}
-
- virtual ~GCItem_Object()
- {
+
+ virtual ~GCItem_Object() {
}
- int get_own() const
- {
+ 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()
- {
+ 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()
- {
+ 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 {
+ 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 (strlen(msg)) {
+ 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, getMessage());
+ PyErr_SetString(error, what());
}
- SWIG_PYTHON_THREAD_END_BLOCK;
+ SWIG_PYTHON_THREAD_END_BLOCK;
}
- const char *getMessage() const
- {
- return swig_msg.c_str();
+ virtual ~DirectorException() throw() {
}
- static void raise(PyObject *error, const char *msg)
- {
+ /* 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)
- {
+ static void raise(const char *msg) {
raise(PyExc_RuntimeError, msg);
}
};
/* unknown exception handler */
- class UnknownExceptionHandler
- {
+ class UnknownExceptionHandler {
#ifdef SWIG_DIRECTOR_UEH
- static void handler() {
+ static void handler() {
try {
throw;
} catch (DirectorException& e) {
std::cerr << "SWIG Director exception caught:" << std::endl
- << e.getMessage() << 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
}
public:
-
+
std::unexpected_handler old;
- UnknownExceptionHandler(std::unexpected_handler nh = handler)
- {
+ UnknownExceptionHandler(std::unexpected_handler nh = handler) {
old = std::set_unexpected(nh);
}
- ~UnknownExceptionHandler()
- {
+ ~UnknownExceptionHandler() {
std::set_unexpected(old);
}
#endif
};
/* type mismatch in the return value from a python method call */
- class DirectorTypeMismatchException : public Swig::DirectorException {
+ class DirectorTypeMismatchException : public DirectorException {
public:
- DirectorTypeMismatchException(PyObject *error, const char* msg="")
- : Swig::DirectorException(error, "SWIG director type mismatch", msg)
- {
+ DirectorTypeMismatchException(PyObject *error, const char *msg="")
+ : DirectorException(error, "SWIG director type mismatch", msg) {
}
- DirectorTypeMismatchException(const char* msg="")
- : Swig::DirectorException(PyExc_TypeError, "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)
- {
+ static void raise(PyObject *error, const char *msg) {
throw DirectorTypeMismatchException(error, msg);
}
- static void raise(const char *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 {
+ class DirectorMethodException : public DirectorException {
public:
- DirectorMethodException(const char* msg = "")
- : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg)
- {
- }
+ DirectorMethodException(const char *msg = "")
+ : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) {
+ }
- static void raise(const char *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
- {
+ class DirectorPureVirtualException : public DirectorException {
public:
- DirectorPureVirtualException(const char* msg = "")
- : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg)
- {
+ DirectorPureVirtualException(const char *msg = "")
+ : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) {
}
- static void raise(const char *msg)
- {
+ static void raise(const char *msg) {
throw DirectorPureVirtualException(msg);
}
};
#ifdef __THREAD__
# include "pythread.h"
- class Guard
- {
- PyThread_type_lock & mutex_;
-
+ class Guard {
+ PyThread_type_lock &mutex_;
+
public:
- Guard(PyThread_type_lock & mutex) : mutex_(mutex)
- {
+ Guard(PyThread_type_lock & mutex) : mutex_(mutex) {
PyThread_acquire_lock(mutex_, WAIT_LOCK);
}
-
- ~Guard()
- {
+
+ ~Guard() {
PyThread_release_lock(mutex_);
}
};
# define SWIG_GUARD(mutex) Guard _guard(mutex)
#else
-# define SWIG_GUARD(mutex)
+# define SWIG_GUARD(mutex)
#endif
/* director base class */
class Director {
private:
/* pointer to the wrapped python object */
- PyObject* swig_self;
+ 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 {
+ void swig_decref() const {
if (swig_disown_flag) {
- SWIG_PYTHON_THREAD_BEGIN_BLOCK;
- Py_DECREF(swig_self);
- SWIG_PYTHON_THREAD_END_BLOCK;
+ 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();
+ /* wrap a python object. */
+ Director(PyObject *self) : swig_self(self), swig_disown_flag(false) {
}
-
/* discard our reference at destruction */
virtual ~Director() {
- swig_decref();
+ swig_decref();
}
-
/* return a pointer to the wrapped python object */
- PyObject *swig_get_self() const {
- return swig_self;
+ 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) {
+ /* 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();
- }
+ swig_incref();
+ }
}
/* increase the reference count of the wrapped python object */
- void swig_incref() const {
+ void swig_incref() const {
if (swig_disown_flag) {
- Py_INCREF(swig_self);
+ Py_INCREF(swig_self);
}
}
/* methods to implement pseudo protected director members */
- virtual bool swig_get_inner(const char* /* swig_protected_method_name */) const {
+ 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 {
+
+ 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;
+ typedef std::map<void *, GCItem_var> swig_ownership_map;
mutable swig_ownership_map swig_owner;
#ifdef __THREAD__
static PyThread_type_lock swig_mutex_own;
public:
template <typename Type>
- void swig_acquire_ownership_array(Type *vptr) const
- {
+ 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
- {
+ 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
- {
+ 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 swig_release_ownership(void *vptr) const {
int own = 0;
if (vptr) {
SWIG_GUARD(swig_mutex_own);
}
template <typename Type>
- static PyObject* swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args))
- {
+ 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));
d->swig_disown();
return PyWeakref_NewProxy(pyobj, NULL);
}
-
};
#ifdef __THREAD__
#endif
}
-#endif /* __cplusplus */
-
-
#endif
//
// 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 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.
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.
+As far as I know, this module is C++ safe.
%}
-#else
-%echo "embed.i : Using Python 1.5"
#endif
%wrapper %{
#endif
#include <config.c>
-#undef _PyImport_Inittab
+#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];
+struct _inittab SWIG_Import_Inittab[1000];
static int swig_num_modules = 0;
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 */
+/* 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++;
- }
+ i++;
+ }
#ifdef SWIGMODINIT
- SWIGMODINIT
+ SWIGMODINIT
#endif
/* Add SWIG builtin function */
swig_add_module(SWIG_name, SWIG_init);
}
%}
-
-
-
-
+++ /dev/null
-/* -----------------------------------------------------------------------------
- * 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);
-}
-
-%}
-
-
-
-
%define %pythonabc(Type, Abc)
%feature("python:abc", #Abc) Type;
%enddef
-%pythoncode {import collections};
+%pythoncode %{import collections%}
%pythonabc(std::vector, collections.MutableSequence);
%pythonabc(std::list, collections.MutableSequence);
%pythonabc(std::map, collections.MutableMapping);
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
the complex Constructor method, and the Real and Imag complex
accessor methods.
- See the std_complex.i and ccomplex.i for concret examples.
+ See the std_complex.i and ccomplex.i for concrete examples.
*/
/* the common from converter */
/**** The PySequence C++ Wrap ***/
-%insert(header) %{
-#include <stdexcept>
-%}
+%fragment("<stdexcept>");
%include <std_except.i>
return pos;
}
+ template <class Sequence>
+ inline void
+ erase(Sequence* seq, const typename Sequence::iterator& position) {
+ seq->erase(position);
+ }
+
template <class Sequence, class Difference>
inline Sequence*
getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
template <class T>
struct SwigPySequence_Ref
{
- SwigPySequence_Ref(PyObject* seq, int index)
+ SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
: _seq(seq), _index(index)
{
}
return swig::as<T>(item, true);
} catch (std::exception& e) {
char msg[1024];
- sprintf(msg, "in sequence element %d ", _index);
+ sprintf(msg, "in sequence element %d ", (int)_index);
if (!PyErr_Occurred()) {
::%type_error(swig::type_name<T>());
}
private:
PyObject* _seq;
- int _index;
+ Py_ssize_t _index;
};
template <class T>
typedef Reference reference;
typedef T value_type;
typedef T* pointer;
- typedef int difference_type;
+ typedef Py_ssize_t difference_type;
SwigPySequence_InputIterator()
{
}
- SwigPySequence_InputIterator(PyObject* seq, int index)
+ SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
: _seq(seq), _index(index)
{
}
difference_type _index;
};
+ // STL container wrapper around a Python sequence
template <class T>
struct SwigPySequence_Cont
{
typedef const SwigPySequence_Ref<T> const_reference;
typedef T value_type;
typedef T* pointer;
- typedef int difference_type;
- typedef int size_type;
+ 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;
bool check(bool set_err = true) const
{
- int s = size();
- for (int i = 0; i < s; ++i) {
+ 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", i);
+ sprintf(msg, "in sequence element %d", (int)i);
SWIG_Error(SWIG_RuntimeError, msg);
}
return false;
#if defined(SWIGPYTHON_BUILTIN)
%feature("python:slot", "tp_iter", functype="getiterfunc") iterator;
#else
- %pythoncode {def __iter__(self): return self.iterator()}
+ %pythoncode %{def __iter__(self):
+ return self.iterator()%}
#endif
}
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)
#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)) {
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) {
+ 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);
}
}
#endif
- void __delitem__(difference_type i) throw (std::out_of_range) {
- self->erase(swig::getpos(self,i));
+ 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::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-
- }
+ }
%enddef
-%define %swig_sequence_methods(Sequence...)
+%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) {
*(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_val(Sequence...)
+%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) {
*(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
%#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) {
+ 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;
%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 "$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)";
}
#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
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
- PyErr_SetString(PyExc_NameError,"Unknown C global variable");
+ PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
- PyErr_SetString(PyExc_NameError,"Unknown C global variable");
+ PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
0, /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
- 0, /* tp_version */
+ 0, /* tp_version_tag */
+#endif
+#if PY_VERSION_HEX >= 0x03040000
+ 0, /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
- 0,0,0,0 /* tp_alloc -> tp_next */
+ 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;
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: "))) {
+ if (!c) continue;
+ c = strstr(c, "swig_ptr: ");
+ if (c) {
int j;
swig_const_info *ci = 0;
const char *name = c + 10;
PyObject *public_interface, *public_symbol;
PyObject *this_descr;
PyObject *thisown_descr;
+ PyObject *self = 0;
int i;
(void)builtin_pytype;
(void)builtin_basetype;
(void)tuple;
(void)static_getset;
+ (void)self;
/* metatype is used to implement static member variables. */
metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
#else
m = Py_InitModule((char *) SWIG_name, SwigMethods);
#endif
+
md = d = PyModule_GetDict(m);
(void)md;
%feature("python:slot", "tp_iternext", functype="iternextfunc") SwigPyIterator::__next__;
#else
%extend SwigPyIterator {
- %pythoncode {def __iter__(self): return self}
+ %pythoncode %{def __iter__(self):
+ return self%}
}
#endif
%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);
+#if defined(SWIGPYTHON_PY3)
+%pybinoperator(__truediv__, *::operator/, binaryfunc, nb_divide);
+#else
+%pybinoperator(__div__, *::operator/, binaryfunc, nb_divide);
+#endif
%pybinoperator(__mod__, *::operator%, binaryfunc, nb_remainder);
%pybinoperator(__lshift__, *::operator<<, binaryfunc, nb_lshift);
%pybinoperator(__rshift__, *::operator>>, binaryfunc, nb_rshift);
%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~;
They translate the inplace C++ operators (+=, -=, ...) into the
corresponding python equivalents(__iadd__,__isub__), etc,
- disabling the ownership of the input 'self' pointer, and assigning
+ disabling the ownership of the input 'this' pointer, and assigning
it to the returning object:
- %feature("del") *::Operator;
- %feature("new") *::Operator;
+ %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:
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+=;
+ %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)
%pyinplaceoper(__iadd__ , *::operator +=, binaryfunc, nb_inplace_add);
%pyinplaceoper(__isub__ , *::operator -=, binaryfunc, nb_inplace_subtract);
%pyinplaceoper(__imul__ , *::operator *=, binaryfunc, nb_inplace_multiply);
+#if defined(SWIGPYTHON_PY3)
+%pyinplaceoper(__itruediv__ , *::operator /=, binaryfunc, nb_inplace_divide);
+#else
%pyinplaceoper(__idiv__ , *::operator /=, binaryfunc, nb_inplace_divide);
+#endif
%pyinplaceoper(__imod__ , *::operator %=, binaryfunc, nb_inplace_remainder);
%pyinplaceoper(__iand__ , *::operator &=, binaryfunc, nb_inplace_and);
%pyinplaceoper(__ior__ , *::operator |=, binaryfunc, nb_inplace_or);
}
}
+#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
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 */
/* long */
%fragment(SWIG_From_frag(long),"header") {
- %define_as(SWIG_From_dec(long), PyLong_FromLong)
+ %define_as(SWIG_From_dec(long), PyInt_FromLong)
}
%fragment(SWIG_AsVal_frag(long),"header",
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 if (PyLong_Check(obj)) {
+ } 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
SWIG_From_dec(unsigned long)(unsigned long value)
{
return (value > LONG_MAX) ?
- PyLong_FromUnsignedLong(value) : PyLong_FromLong(%numeric_cast(value,long));
+ PyLong_FromUnsignedLong(value) : PyInt_FromLong(%numeric_cast(value,long));
}
}
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
+ return SWIG_OverflowError;
}
}
%#ifdef SWIG_PYTHON_CAST_MODE
/* long long */
%fragment(SWIG_From_frag(long long),"header",
- fragment=SWIG_From_frag(long),
- fragment="<limits.h>") {
+ 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) : PyLong_FromLong(%numeric_cast(value,long));
+ 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="<limits.h>") {
+ fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_dec(long long)(PyObject *obj, long long *val)
{
return SWIG_OK;
} else {
PyErr_Clear();
+ res = SWIG_OverflowError;
}
} else {
long v;
%#endif
return res;
}
+%#endif
}
/* unsigned long long */
%fragment(SWIG_From_frag(unsigned long long),"header",
- fragment=SWIG_From_frag(long long),
- fragment="<limits.h>") {
+ 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) : PyLong_FromLong(%numeric_cast(value,long));
+ 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="<limits.h>") {
+ fragment="SWIG_LongLongAvailable") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_dec(unsigned long long)(PyObject *obj, unsigned long long *val)
{
return SWIG_OK;
} else {
PyErr_Clear();
+ res = SWIG_OverflowError;
}
} else {
unsigned long v;
%#endif
return res;
}
+%#endif
}
/* double */
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 = PyInt_AsLong(obj);
return SWIG_OK;
+%#endif
} else if (PyLong_Check(obj)) {
double v = PyLong_AsDouble(obj);
if (!PyErr_Occurred()) {
/* Unpack the argument tuple */
-SWIGINTERN int
+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 (!PyTuple_Check(args)) {
if (min <= 1 && max >= 1) {
- register int i;
+ Py_ssize_t i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
- register Py_ssize_t l = PyTuple_GET_SIZE(args);
+ 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);
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
- register int i;
+ Py_ssize_t i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
#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)
{
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);
+ /* 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));
+ 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)
next = tmp;
#endif
if (!SwigPyObject_Check(next)) {
+ PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
sobj->next = next;
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 *)"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"},
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
#endif
-#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
+#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 */
0, /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
- 0, /* tp_version */
+ 0, /* tp_version_tag */
+#endif
+#if PY_VERSION_HEX >= 0x03040000
+ 0, /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
- 0,0,0,0 /* tp_alloc -> tp_next */
+ 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;
0, /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
- 0, /* tp_version */
+ 0, /* tp_version_tag */
+#endif
+#if PY_VERSION_HEX >= 0x03040000
+ 0, /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
- 0,0,0,0 /* tp_alloc -> tp_next */
+ 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;
}
} else {
#if PY_VERSION_HEX >= 0x03000000
- inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
+ 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;
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;
-#ifdef SWIGPYTHON_BUILTIN
- newobj->dict = 0;
-#endif
return (PyObject*) newobj;
}
return SWIG_Py_Void();
{
PyObject *dict;
if (!PyModule_Check(m)) {
- PyErr_SetString(PyExc_TypeError,
- "PyModule_AddObject() needs module as first arg");
+ 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");
+ PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
return SWIG_ERROR;
}
//
#ifdef SWIG_PYTHON_BACKWARD_COMP
+%fragment("<string>");
%{
-#include <string>
-
PyObject* SwigInt_FromBool(bool b) {
return PyInt_FromLong(b ? 1L : 0L);
}
#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)
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
return SWIG_RuntimeError;
}
obj = PyUnicode_AsUTF8String(obj);
- PyBytes_AsStringAndSize(obj, &cstr, &len);
if(alloc) *alloc = SWIG_NEWOBJ;
+%#endif
+ PyBytes_AsStringAndSize(obj, &cstr, &len);
%#else
PyString_AsStringAndSize(obj, &cstr, &len);
%#endif
%#else
if (*alloc == SWIG_NEWOBJ)
%#endif
- {
- *cptr = %new_copy_array(cstr, len + 1, char);
- *alloc = SWIG_NEWOBJ;
- }
- else {
+ {
+ *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
+%#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
+%#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;
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));
+%#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,int));
+ return PyString_FromStringAndSize(carray, %numeric_cast(size, Py_ssize_t));
%#endif
}
} else {
}
}
-
/*
Warnings for Python keywords
- http://www.fnorb.org/docs/1.2/Fnorb-Guide/node62.html
+ https://docs.python.org/2/reference/lexical_analysis.html#keywords
*/
PYTHONKW(and);
+PYTHONKW(as);
PYTHONKW(assert);
PYTHONKW(break);
PYTHONKW(class);
PYTHONKW(return);
PYTHONKW(try);
PYTHONKW(while);
+PYTHONKW(with);
PYTHONKW(yield);
/*
built-in functions
- http://www.zvon.org/other/python/doc21/lib/built-in-funcs.html
+ https://docs.python.org/2/library/functions.html
*/
PYTHONBN(abs);
/*
'self' is also a bad Name
*/
-PYTHONBN(self);
+PYTHONKW(self);
#undef PYTHONBN
#undef PYTHONKW
/* ------------------------------------------------------------
* Fragment section
* ------------------------------------------------------------ */
-/* bool is dangerous in Python, change precedence */
+#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 fragemt definitions */
+/* Include fundamental fragment definitions */
%include <typemaps/fragments.swg>
/* Look for user fragments file. */
/* Consttab, needed for callbacks, it should be removed later */
-%typemap(consttab) SWIGTYPE ((*)(ANY))
+%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 */
#define %clearpythonappend %feature("pythonappend","")
-
/* ------------------------------------------------------------------------- */
/*
%extend_smart_pointer extend the smart pointer support.
{
PyObject *tmp = 0;
int isunicode = PyUnicode_Check(obj);
-%#if PY_VERSION_HEX < 0x03000000
+%#if PY_VERSION_HEX < 0x03000000 && !defined(SWIG_PYTHON_STRICT_UNICODE_WCHAR)
if (!isunicode && PyString_Check(obj)) {
obj = tmp = PyUnicode_FromObject(obj);
isunicode = 1;
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));
+ return PyUnicode_FromWideChar(carray, %numeric_cast(size, Py_ssize_t));
}
} else {
return SWIG_Py_Void();
--- /dev/null
+/*
+ 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 && jj == size) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->begin(), self->end(), sequence->begin());
+ return sequence;
+ } else if (step == -1 && 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 && jj == size) {
+ std::copy(is.begin(), is.end(), self->begin());
+ } else if (step == -1 && 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>
+
--- /dev/null
+/*
+ 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 {};
+}
fragment=SWIG_From_frag(Type),
fragment="StdTraits") {
namespace swig {
- template <> struct traits<Type > {
+ template <> struct traits< Type > {
typedef value_category category;
static const char* type_name() { return #Type; }
- };
- template <> struct traits_asval<Type > {
+ };
+ template <> struct traits_asval< Type > {
typedef Type value_type;
- static int asval(PyObject *obj, value_type *val) {
+ static int asval(PyObject *obj, value_type *val) {
return SWIG_AsVal(Type)(obj, val);
}
};
- template <> struct traits_from<Type > {
+ template <> struct traits_from< Type > {
typedef Type value_type;
static PyObject *from(const value_type& val) {
return SWIG_From(Type)(val);
fragment=SWIG_From_frag(int),
fragment="StdTraits") {
namespace swig {
- template <> struct traits_asval<Type > {
+ template <> struct traits_asval< Type > {
typedef Type value_type;
- static int asval(PyObject *obj, value_type *val) {
+ static int asval(PyObject *obj, value_type *val) {
return SWIG_AsVal(int)(obj, (int *)val);
}
};
- template <> struct traits_from<Type > {
+ template <> struct traits_from< Type > {
typedef Type value_type;
static PyObject *from(const value_type& val) {
return SWIG_From(int)((int)val);
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;
+ 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");
+ PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
SWIG_PYTHON_THREAD_END_BLOCK;
return NULL;
}
#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()}
+ %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
PyObject* keys() {
Map::size_type size = self->size();
- int pysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
+ 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");
+ 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) {
+ for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
PyList_SET_ITEM(keyList, j, swig::from(i->first));
}
SWIG_PYTHON_THREAD_END_BLOCK;
PyObject* values() {
Map::size_type size = self->size();
- int pysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
+ 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");
+ 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) {
+ for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
PyList_SET_ITEM(valList, j, swig::from(i->second));
}
SWIG_PYTHON_THREAD_END_BLOCK;
PyObject* items() {
Map::size_type size = self->size();
- int pysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
+ 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");
+ 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) {
+ for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
PyList_SET_ITEM(itemList, j, swig::from(*i));
}
SWIG_PYTHON_THREAD_END_BLOCK;
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;
+ 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");
+ PyErr_SetString(PyExc_OverflowError, "multimap size not valid in python");
SWIG_PYTHON_THREAD_END_BLOCK;
return NULL;
}
%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))
+%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
+ 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}
+ if not (index % 2):
+ self.first = val
+ else:
+ self.second = val%}
}
#endif
%enddef
--- /dev/null
+/*
+ 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_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;
+ res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<unordered_map_type>(),0);
+ 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>
--- /dev/null
+/*
+ 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_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;
+ res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<unordered_multimap_type>(),0);
+ 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>
+
--- /dev/null
+/*
+ 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_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>
--- /dev/null
+/*
+ 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_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>
%variable_fail(res, "$type", "$name");
}
if (!argp) {
- %argument_nullref("$type", $symname, $argnum);
+ %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 > *);
%variable_fail(res, "$type", "$name");
}
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
- if (!argp) { %argument_nullref("$type", $symname, $argnum); }
+ 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 > *);
setAs('ExternalReference', 'character',
function(from) {if (!is.null(from$"__str__")) from$"__str__"()})
-setMethod('print', 'ExternalReference',
-function(x) {print(as(x, "character"))})
+suppressMessages(suppressWarnings(setMethod('print', 'ExternalReference',
+function(x) {print(as(x, "character"))})))
%}
}
-%fragment(SWIG_From_frag(long long),"header") {
+%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_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") {
}
-%fragment(SWIG_From_frag(unsigned long long),"header") {
+%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_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") {
}
}
-# This is modified from the R header files
+//# This is modified from the R header files
%fragment("SWIG_FromCharPtrAndSize","header")
{
*/
#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
RKW(NA_complex_);
RKW(NA_character_);
+RSWIGKW(self);
+
#undef RKW
+#undef RSWIGKW
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)));
%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 &
%{ $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 &
+%typemap(scoercein) SWIGTYPE, SWIGTYPE *, SWIGTYPE *const, SWIGTYPE &, SWIGTYPE &&
%{ if (inherits($input, "ExternalReference")) $input = slot($input,"ref") %}
/*
%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(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) SEXP %{ %}
-#%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 &
- %{ $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) ; %}
+%typemap(scoerceout) SWIGTYPE *const
+ %{ $result <- new("$R_class", ref=$result) ; %}
/* Override the SWIGTYPE * above. */
if(!isGeneric("copyToC"))
setGeneric("copyToC",
- function(value, obj = RSWIG_createNewRef(class(value)))
+ function(value, obj = SWIG_createNewRef(class(value)))
standardGeneric("copyToC"
))
}
-#######################################################################
\ No newline at end of file
+#######################################################################
fragment=SWIG_From_frag(Type),
fragment="StdTraits") {
namespace swig {
- template <> struct traits<Type > {
+ template <> struct traits< Type > {
typedef value_category category;
static const char* type_name() { return #Type; }
- };
- template <> struct traits_asval<Type > {
+ };
+ template <> struct traits_asval< Type > {
typedef Type value_type;
- static int asval(SEXP obj, value_type *val) {
+ static int asval(SEXP obj, value_type *val) {
return SWIG_AsVal(Type)(obj, val);
}
};
- template <> struct traits_from<Type > {
+ template <> struct traits_from< Type > {
typedef Type value_type;
static SEXP from(const value_type& val) {
return SWIG_From(Type)(val);
fragment=SWIG_From_frag(int),
fragment="StdTraits") {
namespace swig {
- template <> struct traits_asval<Type > {
+ template <> struct traits_asval< Type > {
typedef Type value_type;
- static int asval(SEXP obj, value_type *val) {
+ static int asval(SEXP obj, value_type *val) {
return SWIG_AsVal(int)(obj, (int *)val);
}
};
- template <> struct traits_from<Type > {
+ template <> struct traits_from< Type > {
typedef Type value_type;
static SEXP from(const value_type& val) {
return SWIG_From(int)((int)val);
return(result);
}
};
- // vectors of unsigned int
+ // 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) {
+ 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++)
return(result);
}
};
- // vectors of int
+
+ // vectors of 32bit int
template <>
struct traits_from_ptr<std::vector<int> > {
static SEXP from (std::vector<int > *val, int owner = 0) {
}
};
+ // 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> > {
}
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> > > {
}
UNPROTECT(1);
return(result);
- //return SWIG_R_NewPointerObj(val, type_info< std::vector<T > >(), owner);
}
};
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) {
}
};
+ // 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) {
}
};
+#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) {
}
};
+ 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;
- Rprintf("my asptr\n");
- int res = SWIG_R_ConvertPtr(obj, (void**)&p, type_info< std::vector<T> >(), 0);
+ int res = SWIG_R_ConvertPtr(obj, (void**)&p, type_info< std::vector<T> >(), 0);
if (SWIG_IsOK(res)) {
if (val) *val = p;
}
// 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) {
+ 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()));
}
};
+
template <>
struct traits_from_ptr<std::vector<std::vector<int> > > {
static SEXP from (std::vector< std::vector<int > > *val, int owner = 0) {
}
};
+ /////////////////////////////////////////////////////////////////
+
// R side
template <>
struct traits_asptr < std::vector< std::vector<unsigned int> > > {
%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&
+%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> const, std::vector<double> const& "";
+%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>)
-%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& "";
+
+// 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> const, std::vector<bool> const&
+%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> const, std::vector<bool> const& "$input = as.logical($input);";
+%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> const, std::vector<int> const&
+%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> const, std::vector<int> const& "$input = as.integer($input);";
+%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>);
-%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);";
+#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> > const, std::vector<std::vector<int> >const&
+%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> > "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("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> > const, std::vector<std::vector<float> >const&
+%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> > "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("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> > const, std::vector<std::vector<double> >const&
+%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> > "list"
-%typemap("scoercein") std::vector< std::vector<double> >, std::vector<std::vector<double> > const, std::vector<std::vector<double> >const&
+%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> > const, std::vector<std::vector<bool> >const&
+%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> > "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);";
+%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<bool>,
- std::vector<bool> *,
- std::vector<bool> &,
+ 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<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<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
# 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)
--- /dev/null
+%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, $<ype));
+ if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $<ype);
+}
+%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, $<ype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
+ if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $<ype);
+}
+%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
/* -----------------------------------------------------------------------------
* director.swg
*
- * This file contains support for director classes that proxy
- * method calls from C++ to Ruby extensions.
+ * This file contains support for director classes so that Ruby proxy
+ * methods can be called from C++.
* ----------------------------------------------------------------------------- */
/*
#endif
#endif
-#ifdef __cplusplus
-
#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()
- {
+ struct GCItem {
+ virtual ~GCItem() {
}
- virtual ruby_owntype get_own() const
- {
- return 0;
+ 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)
- {
+
+ struct GCItem_var {
+ GCItem_var(GCItem *item = 0) : _item(item) {
}
- GCItem_var& operator=(GCItem *item)
- {
+ GCItem_var& operator=(GCItem *item) {
GCItem *tmp = _item;
_item = item;
delete tmp;
return *this;
}
-
- ~GCItem_var()
- {
+
+ ~GCItem_var() {
delete _item;
}
-
- GCItem * operator->() const
- {
+
+ GCItem *operator->() const {
return _item;
}
-
+
private:
GCItem *_item;
};
template <typename Type>
- struct GCItem_T : GCItem
- {
- GCItem_T(Type *ptr) : _ptr(ptr)
- {
+ struct GCItem_T : GCItem {
+ GCItem_T(Type *ptr) : _ptr(ptr) {
}
-
- virtual ~GCItem_T()
- {
+
+ virtual ~GCItem_T() {
delete _ptr;
}
-
+
private:
Type *_ptr;
};
- struct GCItem_Object : GCItem
- {
- GCItem_Object(ruby_owntype own) : _own(own)
- {
+ struct GCItem_Object : GCItem {
+ GCItem_Object(swig_ruby_owntype own) : _own(own) {
}
-
- virtual ~GCItem_Object()
- {
+
+ virtual ~GCItem_Object() {
}
- ruby_owntype get_own() const
- {
+ swig_ruby_owntype get_own() const {
return _own;
}
-
+
private:
- ruby_owntype _own;
+ swig_ruby_owntype _own;
};
-
template <typename Type>
- struct GCArray_T : GCItem
- {
- GCArray_T(Type *ptr) : _ptr(ptr)
- {
+ struct GCArray_T : GCItem {
+ GCArray_T(Type *ptr) : _ptr(ptr) {
}
-
- virtual ~GCArray_T()
- {
+
+ virtual ~GCArray_T() {
delete[] _ptr;
}
-
+
private:
Type *_ptr;
};
int argc;
VALUE *argv;
};
-
+
/* Base class for director exceptions */
- class DirectorException {
+ 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 (strlen(msg)) {
+ 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;
}
swig_error = error;
}
}
+
public:
- VALUE getType() const {
- return CLASS_OF(swig_error);
+ virtual ~DirectorException() throw() {
}
+
+ VALUE getType() const {
+ return CLASS_OF(swig_error);
+ }
+
VALUE getError() const {
return swig_error;
}
- const std::string& getMessage() const
- {
+
+ /* Deprecated, use what() instead */
+ const std::string& getMessage() const {
return swig_msg;
}
-
- virtual ~DirectorException() {}
+
+ const char *what() const throw() {
+ return swig_msg.c_str();
+ }
};
-
- /* unknown exception handler */
- class UnknownExceptionHandler
- {
+ /* 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;
+ << 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 << 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:
+
+ public:
std::unexpected_handler old;
- UnknownExceptionHandler(std::unexpected_handler nh = handler)
- {
+ UnknownExceptionHandler(std::unexpected_handler nh = handler) {
old = std::set_unexpected(nh);
}
- ~UnknownExceptionHandler()
- {
+ ~UnknownExceptionHandler() {
std::set_unexpected(old);
}
#endif
/* Type mismatch in the return value from a Ruby method call */
- class DirectorTypeMismatchException : public Swig::DirectorException {
+ class DirectorTypeMismatchException : public DirectorException {
public:
DirectorTypeMismatchException(VALUE error, const char *msg="")
- : Swig::DirectorException(error, "SWIG director type mismatch", msg)
- {
+ : DirectorException(error, "SWIG director type mismatch", msg) {
}
DirectorTypeMismatchException(const char *msg="")
- : Swig::DirectorException(rb_eTypeError, "SWIG director type mismatch", msg)
- {
+ : DirectorException(rb_eTypeError, "SWIG director type mismatch", msg) {
}
static void raise(VALUE error, const char *msg) {
};
/* Any Ruby exception that occurs during a director method call */
- class DirectorMethodException : public Swig::DirectorException {
+ class DirectorMethodException : public DirectorException {
public:
- DirectorMethodException(VALUE error)
- : Swig::DirectorException(error) {
+ DirectorMethodException(VALUE error)
+ : DirectorException(error) {
}
- DirectorMethodException(const char* msg = "")
- : Swig::DirectorException(rb_eRuntimeError, "SWIG director method error.", msg) {
+ DirectorMethodException(const char *msg = "")
+ : DirectorException(rb_eRuntimeError, "SWIG director method error.", msg) {
}
-
- static void raise(VALUE error)
- {
+
+ static void raise(VALUE error) {
throw DirectorMethodException(error);
- }
+ }
};
/* Attempted to call a pure virtual method via a director method */
- class DirectorPureVirtualException : public Swig::DirectorException
+ class DirectorPureVirtualException : public DirectorException
{
public:
- DirectorPureVirtualException(const char* msg = "")
- : DirectorException(rb_eRuntimeError, "SWIG director pure virtual method called", msg)
- {
+ DirectorPureVirtualException(const char *msg = "")
+ : DirectorException(rb_eRuntimeError, "SWIG director pure virtual method called", msg) {
}
- static void raise(const char *msg)
- {
+ static void raise(const char *msg) {
throw DirectorPureVirtualException(msg);
}
};
# define SWIG_MUTEX_INIT(var) var
# else
# include <pthread.h>
-# define SWIG_MUTEX_INIT(var) var = PTHREAD_MUTEX_INITIALIZER
+# define SWIG_MUTEX_INIT(var) var = PTHREAD_MUTEX_INITIALIZER
# endif
#endif
#ifdef __PTHREAD__
- struct Guard
- {
+ struct Guard {
pthread_mutex_t *_mutex;
-
- Guard(pthread_mutex_t &mutex) : _mutex(&mutex)
- {
+
+ Guard(pthread_mutex_t &mutex) : _mutex(&mutex) {
pthread_mutex_lock(_mutex);
}
-
- ~Guard()
- {
+
+ ~Guard() {
pthread_mutex_unlock(_mutex);
}
};
# define SWIG_GUARD(mutex) Guard _guard(mutex)
#else
-# define SWIG_GUARD(mutex)
+# define SWIG_GUARD(mutex)
#endif
/* director base class */
mutable bool swig_disown_flag;
public:
- /* wrap a Ruby object, optionally taking ownership */
+ /* wrap a Ruby object. */
Director(VALUE self) : swig_self(self), swig_disown_flag(false) {
}
}
/* return a pointer to the wrapped Ruby object */
- VALUE swig_get_self() const {
- return swig_self;
+ 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) {
+ /* 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;
+ typedef std::map<void *, GCItem_var> swig_ownership_map;
mutable swig_ownership_map swig_owner;
#ifdef __PTHREAD__
static pthread_mutex_t swig_mutex_own;
public:
template <typename Type>
- void swig_acquire_ownership_array(Type *vptr) const
- {
+ 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
- {
+ 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) {
+ 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);
}
}
-
- ruby_owntype swig_release_ownership(void *vptr) const
- {
- ruby_owntype own = 0;
+
+ 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 = iter->second->get_own();
+ own.datafree = iter->second->get_own().datafree;
swig_owner.erase(iter);
}
}
};
}
-#endif /* __cplusplus */
-
-
extern "C" {
#endif
-// Ruby 1.9 changed the file name of this header
+/* Ruby 1.9 changed the file name of this header */
#ifdef HAVE_RUBY_IO_H
#include "ruby/io.h"
#else
%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) {
}
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();
if (BUILTIN_TYPE(obj) == T_NONE)
return;
if (_hash != Qnil) {
- VALUE val = rb_hash_aref(s_references._hash, obj);
+ VALUE val = rb_hash_aref(_hash, obj);
unsigned n = FIXNUM_P(val) ? NUM2UINT(val) : 1;
--n;
if (n)
- rb_hash_aset(s_references._hash, obj, INT2NUM(n));
+ rb_hash_aset(_hash, obj, INT2NUM(n));
else
- rb_hash_delete(s_references._hash, obj);
+ rb_hash_delete(_hash, obj);
}
}
};
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
/**** The RubySequence C++ Wrap ***/
-%insert(header) %{
-#include <stdexcept>
-%}
+%fragment("<stdexcept>");
%include <std_except.i>
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);
+ 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) {
* 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.
* It can be used by RubySequence_InputIterator to make it work with STL
* algorithms.
- *
*/
template <class T>
struct RubySequence_ArrowProxy
/**
* 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
/**
* 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
/**
* Macros used to typemap an STL iterator -> SWIGIterator conversion.
- *
*/
%define %swig_sequence_iterator(Sequence...)
#if defined(SWIG_EXPORT_ITERATOR_METHODS)
/**
* Macro used to define common Ruby printing methods for STL container
- *
*/
%define %swig_sequence_printing_methods(Sequence...)
/**
* Macro used to add common methods to all STL sequence-type containers
- *
*/
-%define %swig_sequence_methods_common(Sequence...)
+%define %swig_sequence_methods_non_resizable_common(Sequence...)
%swig_container_methods(%arg(Sequence))
%swig_sequence_iterator(%arg(Sequence))
%swig_sequence_printing_methods(%arg(Sequence))
%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 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;
+ VALUE r = Qnil;
+ try {
+ r = swig::from< const Sequence* >( swig::getslice(self, i, j) );
+ }
+ catch( std::out_of_range ) {
}
+ return r;
+ }
Sequence* each()
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* r = new Sequence();
Sequence::const_iterator i = $self->begin();
Sequence::const_iterator e = $self->end();
for ( ; i != e; ++i )
}
return r;
}
-
-
- VALUE __delete2__(const value_type& i) {
- VALUE r = Qnil;
- 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
- *
+ * STL sequence containers
*/
%define %swig_sequence_back_inserters( Sequence... )
%extend {
if ( !rb_block_given_p() )
rb_raise( rb_eArgError, "no block given" );
- Sequence* r = new Sequence;
+ Sequence* r = new Sequence();
std::remove_copy_if( $self->begin(), $self->end(),
std::back_inserter(*r),
swig::yield< Sequence::value_type >() );
}
%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));
-
+%define %swig_sequence_methods_non_resizable_accessors(Sequence...)
%extend {
VALUE at(difference_type i) const {
try {
r = swig::from< Sequence::value_type >( *(swig::cgetpos(self, i)) );
}
- catch( std::out_of_range )
- {
- }
+ catch( std::out_of_range ) {
+ }
return r;
}
- VALUE __getitem__(difference_type i, difference_type j) const {
- if ( j <= 0 ) return Qnil;
+ 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 ) i = len - i;
- j += i; if ( static_cast<std::size_t>(j) >= len ) j = len-1;
+ 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 )
- {
- }
+ catch( std::out_of_range ) {
+ }
return r;
}
try {
r = swig::from< Sequence::value_type >( *(swig::cgetpos(self, i)) );
}
- catch( std::out_of_range )
- {
- }
+ 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 __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" );
+ }
- 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?");
int len = $self->size();
int s = NUM2INT( start );
- if ( s < 0 ) s = len + s;
- else if ( s >= len ) return Qnil;
+ 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 ( e < s ) return Qnil; //std::swap( s, 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)
+ VALUE __setitem__(difference_type i, const value_type& x) throw (std::invalid_argument, std::out_of_range)
{
- 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;
+ 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 j, const Sequence& v)
- throw (std::invalid_argument) {
+ VALUE __setitem__(difference_type i, difference_type length, const Sequence& v) throw (std::invalid_argument) {
- if ( j <= 0 ) return Qnil;
+ if ( length < 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;
+ 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);
+ 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()
return $self;
}
-
}
%enddef
%fragment(SWIG_From_frag(long long),"header",
fragment=SWIG_From_frag(long),
- fragment="<limits.h>") {
+ 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_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
}
return SWIG_TypeError;
}
+%#endif
}
/* unsigned long long */
%fragment(SWIG_From_frag(unsigned long long),"header",
- fragment=SWIG_From_frag(long long),
- fragment="<limits.h>") {
+ 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_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
}
return SWIG_TypeError;
}
+%#endif
}
/* double */
#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
+#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)
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);
+ rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
free((void *) klass_name);
}
}
/* Acquire a pointer value */
-typedef void (*ruby_owntype)(void*);
+typedef struct {
+ void (*datafree)(void *);
+ int own;
+} swig_ruby_owntype;
-SWIGRUNTIME ruby_owntype
-SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+ swig_ruby_owntype oldown = {0, 0};
if (obj) {
- ruby_owntype oldown = RDATA(obj)->dfree;
- RDATA(obj)->dfree = own;
- return oldown;
- } else {
- return 0;
+ 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, ruby_owntype *own)
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
{
char *c;
swig_cast_info *tc;
/* Grab the pointer */
if (NIL_P(obj)) {
- *ptr = 0;
+ if (ptr)
+ *ptr = 0;
return SWIG_OK;
} else {
if (TYPE(obj) != T_DATA) {
Data_Get_Struct(obj, void, vptr);
}
- if (own) *own = RDATA(obj)->dfree;
+ 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
/* The object has already been deleted */
return SWIG_ObjectPreviouslyDeletedError;
}
- *ptr = vptr;
- return SWIG_OK;
}
}
if ((c = SWIG_MangleStr(obj)) == NULL) {
if (!tc) {
return SWIG_ERROR;
} else {
- int newmemory = 0;
- *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
- assert(!newmemory); /* newmemory handling not yet implemented */
+ 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 {
- *ptr = vptr;
+ if (ptr)
+ *ptr = vptr;
}
return SWIG_OK;
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)
# error sizeof(void*) is not the same as long or long long
#endif
-
-/* Global Ruby hash table to store Trackings from C/C++
+/* Global hash table to store Trackings from C/C++
structs to Ruby Objects.
*/
-static VALUE swig_ruby_trackings = Qnil;
+static st_table* swig_ruby_trackings = NULL;
-/* Global variable that stores a reference to the ruby
- hash table delete function. */
-static ID swig_ruby_hash_delete;
+static VALUE swig_ruby_trackings_count(ANYARGS) {
+ return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
-/* Setup a Ruby hash table to store Trackings */
+
+/* Setup a hash table to store Trackings */
SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
- /* Create a ruby hash table to store Trackings from C++
+ /* Create a hash table to store Trackings from C++
objects to Ruby objects. */
/* Try to see if some other .so has already created a
This is done to allow multiple DSOs to share the same
tracking table.
*/
- ID trackings_id = rb_intern( "@__trackings__" );
+ 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);
- swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
+ trackings_value = 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.*/
+ /* 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);
+ }
- /* Convert the Ruby number to a Ruby object */
- return NUM2SWIG(reference);
+ 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) {
- /* 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);
+ 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) {
- /* 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. */
+ VALUE value;
+
+ if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+ return value;
+ } else {
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
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);
+ /* 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
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
}
#undef SWIG_TYPECHECK_BOOL
%define SWIG_TYPECHECK_BOOL 10000 %enddef
-/* Include fundamental fragemt definitions */
+/* Include fundamental fragment definitions */
%include <typemaps/fragments.swg>
/* Look for user fragments file. */
* utility methods for wchar_t strings
* ------------------------------------------------------------ */
-%fragment("SWIG_AsWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor") {
+%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)
{
}
}
-%fragment("SWIG_FromWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor") {
+%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)
{
--- /dev/null
+/*
+ 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>
+
fragment=SWIG_From_frag(Type),
fragment="StdTraits") {
namespace swig {
- template <> struct traits<Type > {
+ template <> struct traits< Type > {
typedef value_category category;
static const char* type_name() { return #Type; }
- };
- template <> struct traits_asval<Type > {
+ };
+ template <> struct traits_asval< Type > {
typedef Type value_type;
- static int asval(VALUE obj, value_type *val) {
+ static int asval(VALUE obj, value_type *val) {
return SWIG_AsVal(Type)(obj, val);
}
};
- template <> struct traits_from<Type > {
+ template <> struct traits_from< Type > {
typedef Type value_type;
static VALUE from(const value_type& val) {
return SWIG_From(Type)(val);
fragment=SWIG_From_frag(int),
fragment="StdTraits") {
namespace swig {
- template <> struct traits_asval<Type > {
+ template <> struct traits_asval< Type > {
typedef Type value_type;
- static int asval(VALUE obj, value_type *val) {
+ static int asval(VALUE obj, value_type *val) {
return SWIG_AsVal(int)(obj, (int *)val);
}
};
- template <> struct traits_from<Type > {
+ template <> struct traits_from< Type > {
typedef Type value_type;
static VALUE from(const value_type& val) {
return SWIG_From(int)((int)val);
--- /dev/null
+#define SWIG_SHARED_PTR_NAMESPACE std
+%include <boost_shared_ptr.i>
--- /dev/null
+%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, $<ype));
+ if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $<ype);
+}
+%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, $<ype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
+ if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $<ype);
+}
+%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
+
--- /dev/null
+%define %array_class(TYPE,NAME)
+ %array_class_wrap(TYPE,NAME,__paren__,__paren_asgn__)
+%enddef
+
+%include <typemaps/carrays.swg>
--- /dev/null
+%include <typemaps/cmalloc.swg>
--- /dev/null
+%include <typemaps/cpointer.swg>
--- /dev/null
+%include <typemaps/exception.swg>
+
+
+%insert("runtime") {
+ %define_as(SWIG_exception(code, msg), SWIG_Scilab_Error(code, msg);)
+}
--- /dev/null
+/*
+ * Matrix typemaps
+ *
+ */
+
+%include <scimatrixdouble.swg>
+%include <scimatrixint.swg>
+%include <scimatrixchar.swg>
+%include <scimatrixbool.swg>
+
+
--- /dev/null
+/* --------------------------------------------------------------------------
+ *
+ * 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 *);
+
--- /dev/null
+/*
+ * 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)) {
+ int i;
+ 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;
+}
+}
--- /dev/null
+/*
+ * 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;
+}
+}
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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;
+ }
+ }
+ };
+}
+}
--- /dev/null
+/*
+ * 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;
+}
+}
--- /dev/null
+/*
+ * 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;
+}
+}
--- /dev/null
+/*
+ * 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");
+}
--- /dev/null
+/*
+ * 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;
+}
+}
--- /dev/null
+/*
+ * 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;
+}
+}
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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;
+ };
+}
--- /dev/null
+%include <typemaps/swigmacros.swg>
+%include <typemaps/fragments.swg>
+%include <scimacros.swg>
+%include <sciruntime.swg>
+%include <scitypemaps.swg>
+
--- /dev/null
+/*
+ * 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;
+}
+
+}
+
--- /dev/null
+/*
+ * 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;
+}
+}
+
--- /dev/null
+/*
+ * 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;
+}
+}
+
--- /dev/null
+ #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)
--- /dev/null
+/*
+ * 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);
+}
--- /dev/null
+/*
+ * 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);
+}
+
--- /dev/null
+/*
+ * 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);
+}
--- /dev/null
+/*
+ * 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);
+}
+
--- /dev/null
+// 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);
+}
+}
+
--- /dev/null
+/*
+ * 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)
+}
+
+/*
+ * 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)
+}
+// 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())
+}
--- /dev/null
+%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>
+
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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;
+}
+
+/* Pointer conversion functions */
+
+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_tlist) {
+ 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_tlist) {
+ 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) {
+ SciErr sciErr;
+
+ if (descriptor) {
+ int *piTListAddr = NULL;
+ const char *pstString;
+
+ sciErr = createTList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, 3, &piTListAddr);
+ if (sciErr.iErr) {
+ printError(&sciErr, 0);
+ return SWIG_ERROR;
+ }
+
+ pstString = SWIG_TypeName(descriptor);
+ sciErr = createMatrixOfStringInList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, piTListAddr, 1, 1, 1, &pstString);
+ if (sciErr.iErr) {
+ printError(&sciErr, 0);
+ return SWIG_ERROR;
+ }
+
+ sciErr = createPointerInList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, piTListAddr, 2, descriptor);
+ if (sciErr.iErr) {
+ printError(&sciErr, 0);
+ return SWIG_ERROR;
+ }
+
+
+ sciErr = createPointerInList(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + iVarOut, piTListAddr, 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;
+}
+
+
+/* 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);
+}
+
+/*
+ * 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) {
+ double dValue = 0;
+ 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));
+ }
+ else {
+ return SWIG_ERROR;
+ }
+}
--- /dev/null
+%insert(runtime) "swigrun.swg";
+%insert(runtime) "swigerrors.swg";
+
+#define %scilabcode %insert("scilab")
+
+%insert(runtime) "scirun.swg";
+
+%init %{
+#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"
+
+%init %{
+#ifdef __cplusplus
+extern "C"
+#endif
+int <module>_Init(SWIG_GatewayParameters) {
+ SWIG_InitializeModule(NULL);
+ SWIG_CreateScilabVariables(pvApiCtx);
+%}
--- /dev/null
+/*
+ *
+ * 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);
+
--- /dev/null
+/*
+ *
+ * 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 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;
+}
+}
--- /dev/null
+/*
+ *
+ * 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;
+}
+}
+
--- /dev/null
+/*
+ *
+ * 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;
+}
+}
+
--- /dev/null
+/*
+ *
+ * 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;
+}
+}
--- /dev/null
+/*
+ *
+ * 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;
+}
+}
--- /dev/null
+/*
+ *char
+ * 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(itemValue.size() + 1);
+ strcpy(pChar, itemValue.c_str());
+ pSequence[iItemIndex] = pChar;
+ return SWIG_OK;
+}
+}
+
--- /dev/null
+/*
+ * 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;
+}
+}
+
--- /dev/null
+/*
+ * 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;
+}
+}
--- /dev/null
+%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;
+ 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 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)
+
--- /dev/null
+// 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
+
+/* Scilab equivalent for C integers can be sci_ints or sci_matrix */
+%define %scilab_typecheck_integer(PRECEDENCE, INTTYPE, TYPE)
+%typecheck(PRECEDENCE) TYPE {
+ int *piAddrVar = NULL;
+ SciErr sciErr = getVarAddressFromPosition(pvApiCtx, $input, &piAddrVar);
+ if (sciErr.iErr) {
+ printError(&sciErr, 0);
+ return SWIG_ERROR;
+ }
+ $1 = isIntegerType(pvApiCtx, piAddrVar);
+ if ($1 == 1) {
+ int iPrec = 0;
+ sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec);
+ if (sciErr.iErr) {
+ printError(&sciErr, 0);
+ return SWIG_ERROR;
+ }
+ $1 = (iPrec == INTTYPE) ? 1 : 0;
+ }
+ else {
+ $1 = isDoubleType(pvApiCtx, piAddrVar);
+ }
+}
+%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>
--- /dev/null
+/*
+ * 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;
+}
+}
--- /dev/null
+/*
+ * 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;
+}
+}
+
--- /dev/null
+/*
+ * 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;
+}
+}
--- /dev/null
+/*
+ * 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;
+}
+}
--- /dev/null
+%include <std/std_alloc.i>
+
--- /dev/null
+/*
+ * 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>
+
+
--- /dev/null
+%include <std/std_char_traits.i>
--- /dev/null
+%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);
+
--- /dev/null
+%include <scicontainer.swg>
+%include <std/std_container.i>
+
--- /dev/null
+/*
+ *
+ * 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>
--- /dev/null
+%include <typemaps/std_except.swg>
--- /dev/null
+/*
+ *
+ * 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>
--- /dev/null
+//
+// 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
+
+}
--- /dev/null
+/*
+ *
+ * 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>
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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
+
+}
--- /dev/null
+/*
+ *
+ * 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>
+
--- /dev/null
+/*
+ * 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>
--- /dev/null
+/*
+ *
+ * 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>
--- /dev/null
+/* 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>
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * 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);
+
+
+
+
+
deque();
deque(unsigned int size, const T& value=T());
- deque(const deque<T> &);
+ deque(const deque< T > &);
~deque();
void assign(unsigned int n, const T& value);
- void swap(deque<T> &x);
+ void swap(deque< T > &x);
unsigned int size() const;
unsigned int max_size() const;
void resize(unsigned int n, T c = T());
throw std::out_of_range("deque index out of range");
}
}
- std::deque<T> getslice(int i, int j) {
+ 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::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) {
+ 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;
--- /dev/null
+//
+// 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);
+ };
+}
+
%include <std_alloc.i>
%include <std_char_traits.i>
-
-%{
-#include <string>
-%}
+%fragment("<string>");
namespace std
{
#ifdef %swig_basic_string
// Add swig/language extra methods
- %swig_basic_string(std::basic_string<_CharT, _Traits, _Alloc >);
+ %swig_basic_string(std::basic_string< _CharT, _Traits, _Alloc >);
#endif
#ifdef SWIG_EXPORT_ITERATOR_METHODS
%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);
+ 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);
+ 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__() {
+ std::basic_string< _CharT,_Traits,_Alloc > __str__() {
return *self;
}
// Common code for supporting the C++ std namespace
//
-%{
-#include <string>
-#include <stdexcept>
-#include <stddef.h>
-%}
+%fragment("<string>");
+%fragment("<stdexcept>");
+%fragment("<stddef.h>");
%fragment("StdIteratorTraits","header",fragment="<stddef.h>") %{
#endif
%}
-%fragment("StdTraitsCommon","header") %{
-namespace swig {
+%fragment("StdTraitsCommon","header",fragment="<string>") %{
+namespace swig {
template <class Type>
struct noconst_traits {
typedef Type noconst_type;
/*
type categories
*/
- struct pointer_category { };
+ struct pointer_category { };
struct value_category { };
/*
return traits<typename noconst_traits<Type >::noconst_type >::type_name();
}
- template <class Type>
+ 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;
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>
+ template <class Type, class Category>
struct traits_as { };
-
- template <class Type, class Category>
+
+ 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 > {
+ template <> struct traits< Type > {
typedef pointer_category category;
static const char* type_name() { return #Type; }
};
%define %typemap_traits(Code,Type...)
%typemaps_asvalfrom(%arg(Code),
- %arg(swig::asval<Type >),
+ %arg(swig::asval< Type >),
%arg(swig::from),
%arg(SWIG_Traits_frag(Type)),
%arg(SWIG_Traits_frag(Type)),
bool operator == (const Type& v) {
return *self == v;
}
-
+
bool operator != (const Type& v) {
return *self != v;
- }
+ }
}
%enddef
bool operator > (const Type& v) {
return *self > v;
}
-
+
bool operator < (const Type& v) {
return *self < v;
}
#include <algorithm>
%}
-// Common container methods
+// Common non-resizable container methods
+
+%define %std_container_methods_non_resizable(container...)
-%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;
%enddef
+// Common container methods
+
+%define %std_container_methods(container...)
+ %std_container_methods_non_resizable(%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 first, iterator last) { return $self->erase(first, last); }
}
#endif
-
+
%enddef
+%define %std_sequence_methods_non_resizable(sequence)
+
+ %std_container_methods_non_resizable(%arg(sequence))
+
+ 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);
+ 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 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
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))
+
+ 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);
+ void push_back(value_type x);
value_type front() const;
value_type back() const;
-
- void assign(size_type n, value_type x);
+ 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
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);
+%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
namespace std {
- template<class _Tp, class _Alloc = allocator<_Tp> >
+ template<class _Tp, class _Alloc = allocator< _Tp > >
class deque {
public:
typedef size_t size_type;
%traits_swigtype(_Tp);
- %fragment(SWIG_Traits_frag(std::deque<_Tp, _Alloc >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %swig_deque_methods(std::deque< _Tp, _Alloc >);
#endif
%std_deque_methods(deque);
};
template<class _Tp, class _Alloc >
- class deque<_Tp*, _Alloc > {
+ class deque< _Tp*, _Alloc > {
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
%traits_swigtype(_Tp);
- %fragment(SWIG_Traits_frag(std::deque<_Tp*, _Alloc >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %swig_deque_methods_val(std::deque< _Tp*, _Alloc >);
#endif
- %std_deque_methods_val(std::deque<_Tp*, _Alloc >);
+ %std_deque_methods_val(std::deque< _Tp*, _Alloc >);
};
}
// 27.4.5.1 basic_ios constructors
basic_ios();
private:
- ios_base(const ios_base&);
+ basic_ios(const basic_ios&);
- ios_base&
- operator=(const ios_base&);
+ 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
}
namespace std {
- template<class _Tp, class _Alloc = allocator<_Tp> >
+ template<class _Tp, class _Alloc = allocator< _Tp > >
class list {
public:
typedef size_t size_type;
%traits_swigtype(_Tp);
- %fragment(SWIG_Traits_frag(std::list<_Tp, _Alloc >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %swig_list_methods(std::list< _Tp, _Alloc >);
#endif
%std_list_methods(list);
};
template<class _Tp, class _Alloc >
- class list<_Tp*, _Alloc> {
+ class list< _Tp*, _Alloc> {
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
%traits_swigtype(_Tp);
- %fragment(SWIG_Traits_frag(std::list<_Tp*, _Alloc >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %swig_list_methods_val(std::list< _Tp*, _Alloc >);
#endif
%std_list_methods_val(list);
}
%define %std_extequal_list(...)
-%extend std::list<__VA_ARGS__ > {
+%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 merge(std::list< __VA_ARGS__ >& x){ self->merge(x); }
void unique() { self->unique(); }
void sort() { self->sort(); }
}
%{
#include <map>
-#include <algorithm>
-#include <stdexcept>
%}
+%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 _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 std::pair< const _Key, _Tp > value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
}
}
- %fragment(SWIG_Traits_frag(std::map<_Key, _Tp, _Compare, _Alloc >), "header",
- fragment=SWIG_Traits_frag(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 > > {
+ 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 >);
+ %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 >);
+ %swig_map_methods(std::map< _Key, _Tp, _Compare, _Alloc >);
#endif
%std_map_methods(map);
//
-// std::map
+// std::multimap
//
%include <std_map.i>
namespace std {
- template<class _Key, class _Tp, class _Compare = std::less<_Key >,
- class _Alloc = allocator<std::pair<const _Key, _Tp > > >
+ 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 std::pair< const _Key, _Tp > value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
}
}
- %fragment(SWIG_Traits_frag(std::multimap<_Key, _Tp, _Compare, _Alloc >), "header",
- fragment=SWIG_Traits_frag(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 > > {
+ 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 >);
+ %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 >);
+ %swig_multimap_methods(std::multimap< _Key, _Tp, _Compare, _Alloc >);
#endif
%std_multimap_methods(multimap);
//
-// std::set
+// std::multiset
//
%include <std_set.i>
//multiset
- template <class _Key, class _Compare = std::less<_Key>,
- class _Alloc = allocator<_Key> >
+ template <class _Key, class _Compare = std::less< _Key >,
+ class _Alloc = allocator< _Key > >
class multiset {
public:
typedef size_t size_type;
%traits_swigtype(_Key);
- %fragment(SWIG_Traits_frag(std::multiset<_Key, _Compare, _Alloc >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %swig_multiset_methods(std::multiset< _Key, _Compare, _Alloc >);
#endif
%std_multiset_methods(multiset);
%traits_swigtype(T);
%traits_swigtype(U);
- %fragment(SWIG_Traits_frag(std::pair<T,U >), "header",
+ %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 > > {
+ 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 >);
+ %typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair< T, U >);
#else
- %typemap_traits(SWIG_TYPECHECK_PAIR, std::pair<T,U >);
+ %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);
+ 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 >)
+ %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*> {
+ 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(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* > > {
+ 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* >);
+ %typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair< T, U* >);
pair();
pair(T __a, U* __b);
#ifdef %swig_pair_methods
// Add swig/language extra methods
- %swig_pair_methods(std::pair<T,U*>)
+ %swig_pair_methods(std::pair< T, U* >)
#endif
};
- template <class T, class U > struct pair<T*, U> {
+ 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(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 > > {
+ 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 >);
+ %typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair< T*, U >);
pair();
pair(T* __a, U __b);
#ifdef %swig_pair_methods
// Add swig/language extra methods
- %swig_pair_methods(std::pair<T*,U >)
+ %swig_pair_methods(std::pair< T*, U >)
#endif
};
- template <class T, class U > struct pair<T*, U*> {
+ 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(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* > > {
+ 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* >);
+ %typemap_traits(SWIG_TYPECHECK_PAIR, std::pair< T*, U* >);
pair();
pair(T* __a, U* __b);
#ifdef %swig_pair_methods
// Add swig/language extra methods
- %swig_pair_methods(std::pair<T*,U*>)
+ %swig_pair_methods(std::pair< T*, U* >)
#endif
};
namespace std {
- template<class _Tp, class _Sequence = std::deque<_Tp> >
+ template<class _Tp, class _Sequence = std::deque< _Tp > >
class queue {
public:
typedef size_t size_type;
%traits_swigtype(_Tp);
- %fragment(SWIG_Traits_frag(std::queue<_Tp, _Sequence >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %swig_queue_methods(std::queue< _Tp, _Sequence >);
#endif
%std_queue_methods(queue);
};
template<class _Tp, class _Sequence >
- class queue<_Tp*, _Sequence > {
+ class queue< _Tp*, _Sequence > {
public:
typedef size_t size_type;
typedef _Tp value_type;
%traits_swigtype(_Tp);
- %fragment(SWIG_Traits_frag(std::queue<_Tp*, _Sequence >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %swig_queue_methods_val(std::queue< _Tp*, _Sequence >);
#endif
- %std_queue_methods_val(std::queue<_Tp*, _Sequence >);
+ %std_queue_methods_val(std::queue< _Tp*, _Sequence >);
};
}
namespace std {
- template <class _Key, class _Compare = std::less<_Key>,
- class _Alloc = allocator<_Key> >
+ template <class _Key, class _Compare = std::less< _Key >,
+ class _Alloc = allocator< _Key > >
class set {
public:
typedef size_t size_type;
%traits_swigtype(_Key);
- %fragment(SWIG_Traits_frag(std::set<_Key, _Compare, _Alloc >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %swig_set_methods(std::set< _Key, _Compare, _Alloc >);
#endif
%std_set_methods(set);
namespace std {
- template<class _Tp, class _Sequence = std::deque<_Tp> >
+ template<class _Tp, class _Sequence = std::deque< _Tp > >
class stack {
public:
typedef size_t size_type;
%traits_swigtype(_Tp);
- %fragment(SWIG_Traits_frag(std::stack<_Tp, _Sequence >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %swig_stack_methods(std::stack< _Tp, _Sequence >);
#endif
%std_stack_methods(stack);
};
template<class _Tp, class _Sequence >
- class stack<_Tp*, _Sequence > {
+ class stack< _Tp*, _Sequence > {
public:
typedef size_t size_type;
typedef _Sequence::value_type value_type;
%traits_swigtype(_Tp);
- %fragment(SWIG_Traits_frag(std::stack<_Tp*, _Sequence >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %swig_stack_methods_val(std::stack< _Tp*, _Sequence >);
#endif
- %std_stack_methods_val(std::stack<_Tp*, _Sequence >);
+ %std_stack_methods_val(std::stack< _Tp*, _Sequence >);
};
}
--- /dev/null
+//
+// 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);
+ };
+
+}
--- /dev/null
+//
+// 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);
+ };
+}
--- /dev/null
+//
+// 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);
+ };
+}
--- /dev/null
+//
+// 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);
+ };
+}
%traits_swigtype(_Tp);
%traits_enum(_Tp);
- %fragment(SWIG_Traits_frag(std::vector<_Tp, _Alloc >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %swig_vector_methods(std::vector< _Tp, _Alloc >);
#endif
%std_vector_methods(vector);
// a 'const SWIGTYPE*&' can be defined
// ***
template<class _Tp, class _Alloc >
- class vector<_Tp*, _Alloc > {
+ class vector< _Tp*, _Alloc > {
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
%traits_swigtype(_Tp);
- %fragment(SWIG_Traits_frag(std::vector<_Tp*, _Alloc >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %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 > {
+ class vector< _Tp const *, _Alloc > {
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
%traits_swigtype(_Tp);
- %fragment(SWIG_Traits_frag(std::vector<_Tp const*, _Alloc >), "header",
+ %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 > > {
+ 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 >);
+ %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 >);
+ %swig_vector_methods_val(std::vector< _Tp const*, _Alloc >);
#endif
%std_vector_methods_val(vector);
* User Directives
* ----------------------------------------------------------------------------- */
-/* Deprecated SWIG directives */
+/* Deprecated SWIG-1.1 directives */
#define %disabledoc %warn "104:%disabledoc is deprecated"
#define %enabledoc %warn "105:%enabledoc is deprecated"
#define %nocallback %feature("callback","0")
#define %clearcallback %feature("callback","")
-/* the %nestedworkaround directive */
+/* 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")
%rename("$ignore", %$isenumitem, %$classname="MyClass") "";
- we use the prefix '%$' to avoid clashings with other swig
+ we use the prefix '%$' to avoid clashes with other swig
macros/directives.
*/
%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 %$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
* ----------------------------------------------------------------------------- */
/* 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
}
/* -----------------------------------------------------------------------------
- * 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
* ----------------------------------------------------------------------------- */
#include <limits.h>
#endif
#if (__WORDSIZE == 64) || (LONG_MAX != INT_MAX)
-# error "SWIG wrapped code invalid in 64 bit architecture, regenarete code using -DSWIGWORDSIZE64"
+# error "SWIG wrapped code invalid in 64 bit architecture, regenerate code using -DSWIGWORDSIZE64"
#endif
%}
#endif
#include <limits.h>
#endif
#if (__WORDSIZE == 32) || (LONG_MAX == INT_MAX)
-# error "SWIG wrapped code invalid in 32 bit architecture, regenarete code using -DSWIGWORDSIZE32"
+# error "SWIG wrapped code invalid in 32 bit architecture, regenerate code using -DSWIGWORDSIZE32"
#endif
%}
#endif
* 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
+ * 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
SWIG_InitializeModule(void *clientdata) {
size_t i;
swig_module_info *module_head, *iter;
- int found, init;
+ int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* 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;
+ /* Our module is already in the list, so there's nothing more to do. */
+ return;
}
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 */
+ /* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
#endif
/* exporting methods */
-#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
-# ifndef GCC_HASCLASSVISIBILITY
-# define GCC_HASCLASSVISIBILITY
+#if defined(__GNUC__)
+# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+# ifndef GCC_HASCLASSVISIBILITY
+# define GCC_HASCLASSVISIBILITY
+# endif
# endif
#endif
# 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
swig_module_info *iter = start;
do {
if (iter->size) {
- register size_t l = 0;
- register size_t r = iter->size - 1;
+ size_t l = 0;
+ size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
- register size_t i = (l + r) >> 1;
+ size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
- register int compare = strcmp(name, iname);
+ int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
- register size_t i = 0;
+ 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];
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;
+ const unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register unsigned char uu = *u;
+ unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
*/
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;
+ unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register char d = *(c++);
- register unsigned char uu;
+ char d = *(c++);
+ unsigned char uu;
if ((d >= '0') && (d <= '9'))
- uu = ((d - '0') << 4);
+ uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
- uu = ((d - ('a'-10)) << 4);
+ uu = (unsigned char)((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
- uu |= (d - '0');
+ uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
- uu |= (d - ('a'-10));
+ uu |= (unsigned char)(d - ('a'-10));
else
return (char *) 0;
*u = uu;
%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_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
+%define SWIGWARN_CPP11_ALIAS_TEMPLATE 342 %enddef
+%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_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
/* 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
%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_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_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
# ---------------------------------------------------------------
-# SWIG Tcl/Tk Makefile
-#
+# SWIG Tcl Makefile
+#
# This file can be used to build various Tcl extensions with SWIG.
# By default this file is set up for dynamic loading, but it can
# be easily customized for static extensions by modifying various
-# portions of the file.
+# portions of the file.
#
# SRCS = C source files
# CXXSRCS = C++ source files
# application.
#----------------------------------------------------------------
-SRCS =
-CXXSRCS =
-OBJCSRCS =
-OBJS =
-INTERFACE =
+SRCS =
+CXXSRCS =
+OBJCSRCS =
+OBJS =
+INTERFACE =
WRAPFILE = $(INTERFACE:.i=_wrap.c)
WRAPOBJ = $(INTERFACE:.i=_wrap.o)
TARGET = module@SO@ # Use this kind of target for dynamic loading
CC = @CC@
CXX = @CXX@
-OBJC = @CC@ -Wno-import # -Wno-import needed for gcc
-CFLAGS =
+OBJC = @CC@ -Wno-import # -Wno-import needed for gcc
+CFLAGS =
INCLUDES =
LIBS =
# SWIGOPT = SWIG compiler options
# SWIGCC = Compiler used to compile the wrapper file
-SWIG = $(exec_prefix)/bin/swig
+SWIG = $(exec_prefix)/bin/swig
SWIGOPT = -tcl # use -tcl8 for Tcl 8.0
-SWIGCC = $(CC)
+SWIGCC = $(CC)
-# SWIG Library files. Uncomment one of these for rebuilding tclsh or wish
-#SWIGLIB = -ltclsh.i
-#SWIGLIB = -lwish.i
+# SWIG Library files. Uncomment if rebuilding tclsh
+#SWIGLIBS = -ltclsh.i
# Rules for creating .o files from source.
# need to provide additional link libraries (this is not always required).
#DLL_LIBS = -L/usr/local/lib/gcc-lib/sparc-sun-solaris2.5.1/2.7.2 \
- -L/usr/local/lib -lg++ -lstdc++ -lgcc
-
-# X11 installation (needed to rebuild Tk extensions)
+ -L/usr/local/lib -lg++ -lstdc++ -lgcc
-XLIB = @XLIBSW@
-XINCLUDE = @XINCLUDES@
-
-# Tcl installation (where is Tcl/Tk located)
+# Tcl installation (where is Tcl located)
TCL_INCLUDE = @TCLINCLUDE@
TCL_LIB = @TCLLIB@
LIBC = @LIBC@
SYSLIBS = $(LIBM) $(LIBC) @LIBS@
-# Build options (uncomment only one these)
+# Build options (uncomment only one of these)
BUILD_LIBS = $(LIBS) # Dynamic loading
-#BUILD_LIBS = $(TCL_LIB) -ltcl $(LIBS) $(SYSLIBS) # tclsh
-#BUILD_LIBS = $(TCL_LIB) -ltk -ltcl $(XLIB) $(LIBS) $(SYSLIBS) # wish
+#BUILD_LIBS = $(TCL_LIB) -ltcl $(LIBS) $(SYSLIBS) # tclsh
# Compilation rules for non-SWIG components
# Convert the wrapper file into an object file
$(WRAPOBJ) : $(WRAPFILE)
- $(SWIGCC) -c $(CCSHARED) $(CFLAGS) $(WRAPFILE) $(INCLUDES) $(TCL_INCLUDE)
+ $(SWIGCC) -c $(CCSHARED) $(CFLAGS) $(WRAPFILE) $(INCLUDES) $(TCL_INCLUDE)
$(WRAPFILE) : $(INTERFACE)
- $(SWIG) $(SWIGOPT) -o $(WRAPFILE) $(SWIGLIB) $(INTERFACE)
+ $(SWIG) $(SWIGOPT) -o $(WRAPFILE) $(SWIGLIBS) $(INTERFACE)
$(TARGET): $(WRAPOBJ) $(ALLOBJS)
$(BUILD) $(WRAPOBJ) $(ALLOBJS) $(BUILD_LIBS) -o $(TARGET)
clean:
rm -f $(COBJS) $(CXXOBJS) $(OBJCOBJS) $(WRAPOBJ) $(WRAPFILE) $(TARGET)
-
-
-
-
//
// SWIG typemaps for std::map
-// Luigi Ballabio
-// Jan. 2003
//
// Common implementation
%{
#include <map>
-#include <algorithm>
-#include <stdexcept>
%}
+%fragment("<algorithm>");
+%fragment("<stdexcept>");
// exported class
// is returned
// ------------------------------------------------------------------------
+%fragment("<string>");
+%fragment("<stdexcept>");
+%fragment("<algorithm>");
%{
#include <vector>
-#include <algorithm>
-#include <stdexcept>
-#include <string>
Tcl_Obj* SwigString_FromString(const std::string &s) {
return Tcl_NewStringObj(s.data(), (int)s.length());
%fragment(SWIG_From_frag(long long),"header",
fragment=SWIG_From_frag(long),
- fragment="<limits.h>",
+ fragment="SWIG_LongLongAvailable",
fragment="<stdio.h>") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE Tcl_Obj*
SWIG_From_dec(long long)(long long value)
{
return Tcl_NewStringObj(temp,-1);
}
}
+%#endif
}
%fragment(SWIG_AsVal_frag(long long),"header",
- fragment="<limits.h>",
+ fragment="SWIG_LongLongAvailable",
fragment="<stdlib.h>") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_dec(long long)(Tcl_Obj *obj, long long *val)
{
}
return SWIG_TypeError;
}
+%#endif
}
/* unsigned long long */
%fragment(SWIG_From_frag(unsigned long long),"header",
fragment=SWIG_From_frag(long long),
- fragment="<limits.h>",
+ fragment="SWIG_LongLongAvailable",
fragment="<stdio.h>") {
+%#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE Tcl_Obj*
SWIG_From_dec(unsigned long long)(unsigned long long value)
{
return Tcl_NewStringObj(temp,-1);
}
}
+%#endif
}
%fragment(SWIG_AsVal_frag(unsigned long long),"header",
fragment=SWIG_AsVal_frag(unsigned long),
- fragment="<limits.h>",
+ 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)
{
}
return SWIG_TypeError;
}
+%#endif
}
/* double */
#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
#if 1
// Old 1.3.25 typemaps needed to avoid premature object deletion
-%typemap(out,noblock=1) SWIGTYPE *INSTANCE, SWIGTYPE &INSTANCE, SWIGTYPE INSTANCE[] {
+%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 * = 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;
};
%}
+ 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 compileable code, use at your peril!
+// Does not always generate compilable code, use at your peril!
//
//#define SWIG_ATTRIBUTE_TEMPLATE
%ignore Class::GetMethod();
%ignore Class::GetMethod() const;
%newobject Class::AttributeName;
- %typemap(newfree) const AttributeType &AttributeName "delete $1;// my newfree override"
+ %typemap(newfree) const AttributeType &AttributeName "delete $1;"
%extend Class {
AttributeType AttributeName;
}
* ------------------------------------------------------------ */
%apply int { enum SWIGTYPE };
-%apply const int& { const 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) {
+%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);
}
}
*/
-%{
-#include <stdexcept>
-%}
+
+%fragment("<stdexcept>");
+
%define SWIG_CATCH_STDEXCEPT
/* catching std::exception */
catch (std::invalid_argument& e) {
#endif
%}
-%fragment("<stddef.h>", "header") %{
- #include <stddef.h>
+%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, but a function in namespace std for C++11. */
# if defined(isfinite)
# define SWIG_isfinite(X) (isfinite(X))
+# elif defined __cplusplus && __cplusplus >= 201103L
+# define SWIG_isfinite(X) (std::isfinite(X))
# elif defined(_MSC_VER)
# define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)
/* 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)
/* size_t */
-%fragment(SWIG_From_frag(size_t),"header",fragment=SWIG_From_frag(unsigned long)) {
+%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)
{
- return SWIG_From(unsigned long)(%numeric_cast(value, unsigned long));
+%#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(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)
{
- unsigned long v;
- int res = SWIG_AsVal(unsigned long)(obj, val ? &v : 0);
- if (SWIG_IsOK(res) && val) *val = %numeric_cast(v, size_t);
+ 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(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)
{
- return SWIG_From(long)(%numeric_cast(value,long));
+%#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(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)
{
- long v;
- int res = SWIG_AsVal(long)(obj, val ? &v : 0);
- if (SWIG_IsOK(res) && val) *val = %numeric_cast(v, ptrdiff_t);
+ 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;
}
}
%include <typemaps/std_strings.swg>
-%{
-#include <string>
-%}
-
+%fragment("<string>");
+
namespace std
{
%naturalvar string;
%{
#include <cwchar>
-#include <string>
%}
+%fragment("<string>");
namespace std
{
}
}
+%fragment("SWIG_strnlen","header",fragment="SWIG_FromCharPtrAndSize") {
+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,
+ char, Char, SWIG_AsCharPtrAndSize, SWIG_FromCharPtrAndSize,
+ strlen, SWIG_strnlen,
"<limits.h>", CHAR_MIN, CHAR_MAX)
SWIG_AsCharPtrAndSize,
SWIG_FromCharPtrAndSize,
SWIG_CharPtrLen,
+ SWIG_CharBufLen,
SWIG_AsCharPtr,
SWIG_FromCharPtr,
SWIG_AsCharArray,
}
%typemap(freearg) const Char (&)[ANY] "";
-%typemap(out,fragment=#SWIG_FromCharPtrAndSize)
+%typemap(out,fragment=#SWIG_FromCharPtrAndSize,fragment=#SWIG_CharBufLen)
Char [ANY], const Char[ANY]
{
- size_t size = $1_dim0;
%#ifndef SWIG_PRESERVE_CARRAY_SIZE
- while (size && ($1[size - 1] == '\0')) --size;
+ size_t size = SWIG_CharBufLen($1, $1_dim0);
+%#else
+ size_t size = $1_dim0;
%#endif
%set_output(SWIG_FromCharPtrAndSize($1, size));
}
/* varout */
-%typemap(varout,noblock=1,fragment=#SWIG_FromCharPtrAndSize)
+%typemap(varout,fragment=#SWIG_CharBufLen)
Char [ANY], const Char [ANY] {
- size_t size = $1_dim0;
%#ifndef SWIG_PRESERVE_CARRAY_SIZE
- while (size && ($1[size - 1] == '\0')) --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_FromCharPtrAndSize)
+%typemap(constcode,fragment=#SWIG_CharBufLen)
Char [ANY], const Char [ANY]
{
- size_t size = $value_dim0;
%#ifndef SWIG_PRESERVE_CARRAY_SIZE
- while (size && ($value[size - 1] == '\0')) --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_FromCharPtrAndSize)
+%typemap(directorin,fragment=#SWIG_CharBufLen)
Char [ANY], const Char [ANY]
{
- size_t size = $1_dim0;
%#ifndef SWIG_PRESERVE_CARRAY_SIZE
- while (size && ($1[size - 1] == '\0')) --size;
+ size_t size = SWIG_CharBufLen($1, $1_dim0);
+%#else
+ size_t size = $1_dim0;
%#endif
$input = SWIG_FromCharPtrAndSize($1, size);
}
/* throws */
-%typemap(throws,fragment=#SWIG_FromCharPtrAndSize)
+%typemap(throws,fragment=#SWIG_CharBufLen)
Char [ANY], const Char[ANY]
{
- size_t size = $1_dim0;
%#ifndef SWIG_PRESERVE_CARRAY_SIZE
- while (size && ($1[size - 1] == '\0')) --size;
+ size_t size = SWIG_CharBufLen($1, $1_dim0);
+%#else
+ size_t size = $1_dim0;
%#endif
%raise(SWIG_FromCharPtrAndSize($1, size), "$type", 0);
}
* --- 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)
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;
+ /* 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));
SWIG_AsCharPtrAndSize,
SWIG_FromCharPtrAndSize,
SWIG_CharPtrLen,
+ SWIG_CharBufLen,
SWIG_As##CharName##Ptr,
SWIG_From##CharName##Ptr,
SWIG_As##CharName##Array,
SWIG_DeleteCharArray)
%enddef
-
+#endif
/* ------------------------------------------------------------
* String typemaps and fragments, with default allocators
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)
SWIG_AsCharPtrAndSize,
SWIG_FromCharPtrAndSize,
SWIG_CharPtrLen,
+ SWIG_CharBufLen,
SWIG_NewCopyCharArray,
SWIG_DeleteCharArray,
FragLimits, CHAR_MIN, CHAR_MAX)
SWIG_AsCharPtrAndSize,
SWIG_FromCharPtrAndSize,
SWIG_CharPtrLen,
+ SWIG_CharBufLen,
SWIG_NewCopyCharArray,
SWIG_DeleteCharArray,
FragLimits, CHAR_MIN, CHAR_MAX)
* ----------------------------------------------------------------------------- */
/*
This file implements the internal macros of the 'SWIG API', which
- are useful to implement all the SWIG target languges.
+ are useful to implement all the SWIG target languages.
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
+ %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
}
#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) {
* ----------------------------------------------------------------------------- */
/* Pointers, references */
-%typemap(out,noblock=1) SWIGTYPE *, SWIGTYPE &, SWIGTYPE[] {
+%typemap(out,noblock=1) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE[] {
%set_output(SWIG_NewPointerObj(%as_voidptr($1), $descriptor, $owner | %newpointer_flags));
}
%typemap(memberin) SWIGTYPE [ANY] {
if ($input) {
size_t ii = 0;
- for (; ii < (size_t)$1_dim0; ++ii) $1[ii] = $input[ii];
+ 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[ii] = $input[ii];
+ for (; ii < (size_t)$1_dim0; ++ii) *($1_basetype *)&$1[ii] = *(($1_basetype *)$input + ii);
} else {
%variable_nullref("$type","$name");
}
%variable_fail(res, "$type", "$name");
} else if (inp) {
size_t ii = 0;
- for (; ii < (size_t)$1_dim0; ++ii) $1[ii] = inp[ii];
+ for (; ii < (size_t)$1_dim0; ++ii) *($1_basetype *)&$1[ii] = *(($1_basetype *)inp + ii);
} else {
%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;
%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));
$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);
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;
}
%typemap(directorin,noblock=1) SWIGTYPE {
- $input = SWIG_NewPointerObj(%as_voidptr(&$1), $&descriptor, %newpointer_flags);
+ $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) {
}
}
+%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 [] {
+%typemap(constcode,noblock=1) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
%set_constant("$symname", SWIG_NewPointerObj(%as_voidptr($value),$descriptor,%newpointer_flags));
}
%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");
}
%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)
and then include this file.
Typically you will create a 'mytypemaps.swg' file in each target
- languge, where you will have the following sections:
+ language, where you will have the following sections:
=== mytypemaps.swg ===
// Common code for supporting the STD C++ namespace
//
-%{
-#include <string>
-#include <stdexcept>
-%}
+%fragment("<string>");
+%fragment("<stdexcept>");
-%fragment("Traits","header")
+%fragment("Traits","header",fragment="<string>")
{
namespace swig {
/*
}
}
+%fragment("SWIG_wcsnlen","header",fragment="SWIG_FromWCharPtrAndSize") {
+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,
+ wchar_t, WChar, SWIG_AsWCharPtrAndSize, SWIG_FromWCharPtrAndSize,
+ wcslen, SWIG_wcsnlen,
"<wchar.h>", WCHAR_MIN, WCHAR_MAX)
srcdir = @srcdir@
datarootdir = @datarootdir@
-##############################################################################
+#####################################################################
+# Make options - override these to see more output
+#####################################################################
+
+RUNPIPE = \>/dev/null
+FLAGS = -k -s
+
+#####################################################################
# Compiler and system configuration
-##############################################################################
+#####################################################################
SHELL = /bin/sh
-SWIG_LIB = @swig_lib@
+SWIG_LIB_INSTALL = @SWIG_LIB_INSTALL@
BIN_DIR = @bindir@
ENABLE_CCACHE = @ENABLE_CCACHE@
TARGET_NOEXE= swig
SOURCE = Source
CCACHE = CCache
DOCS = Doc/Manual
-RUNPIPE = \>/dev/null
+HAVE_CXX11_COMPILER = @HAVE_CXX11_COMPILER@
swig: libfiles source ccache
# Documentation
#####################################################################
-docs: docs-main docs-ccache
+docs: docs-main
docs-main:
@echo making docs
@test -d $(DOCS) || exit 0; cd $(DOCS) && $(MAKE) all clean-baks
-docs-ccache:
- test -z "$(ENABLE_CCACHE)" || (cd $(CCACHE) && $(MAKE) docs)
-
#####################################################################
# All the languages SWIG speaks (when it wants to)
#####################################################################
skip-cffi = test -n "@SKIP_CFFI@"
skip-uffi = test -n "@SKIP_UFFI@"
skip-r = test -n "@SKIP_R@"
+skip-scilab = test -n "@SKIP_SCILAB@"
skip-go = test -n "@SKIP_GO@"
skip-d = test -n "@SKIP_D@"
+skip-javascript = test -n "@SKIP_JAVASCRIPT@"
# Additional dependencies for some tests
skip-gcj = test -n "@SKIP_GCJ@"
skip-android = test -n "@SKIP_ANDROID@"
+# Special errors test-case
+skip-errors = test -n ""
+
+check-%-enabled:
+ @if $(skip-$*); then \
+ echo skipping $* version; \
+ exit 1; \
+ fi
+
#####################################################################
# CHECK
#####################################################################
ACTION = check
NOSKIP =
-chk-set-swiglib = SWIG_LIB=@ROOT_DIR@/Lib
-chk-set-swig = SWIG=@ROOT_DIR@/$(TARGET)
-chk-set-env = $(chk-set-swiglib) $(chk-set-swig)
-
check-aliveness:
test -x ./$(TARGET)
./$(TARGET) -version
@$(skip-cffi) || ./$(TARGET) -cffi -help
@$(skip-lua) || ./$(TARGET) -lua -help
@$(skip-r) || ./$(TARGET) -r -help
+ @$(skip-scilab) || ./$(TARGET) -scilab -help
@$(skip-go) || ./$(TARGET) -go -help
@$(skip-d) || ./$(TARGET) -d -help
+ @$(skip-javascript) || ./$(TARGET) -javascript -help
check-ccache:
test -z "$(ENABLE_CCACHE)" || (cd $(CCACHE) && $(MAKE) check)
check-perl5-version \
check-python-version \
check-java-version \
+ check-javascript-version \
check-android-version \
check-guile-version \
check-mzscheme-version \
check-uffi-version \
check-cffi-version \
check-r-version \
+ check-scilab-version \
check-go-version \
check-d-version
echo skipping $* version; \
else \
echo showing $* version; \
- (cd Examples && $(MAKE) -s $*_version) \
+ (cd Examples && $(MAKE) $(FLAGS) $*_version) \
fi
# Checks examples for compilation (does not run them)
check-uffi-examples \
check-cffi-examples \
check-r-examples \
+ check-scilab-examples \
check-go-examples \
- check-d-examples
+ check-d-examples \
+ check-javascript-examples
tcl_examples :=$(shell sed '/^\#/d' $(srcdir)/Examples/tcl/check.list)
perl5_examples :=$(shell sed '/^\#/d' $(srcdir)/Examples/perl5/check.list)
uffi_examples :=
cffi_examples :=
r_examples :=$(shell sed '/^\#/d' $(srcdir)/Examples/r/check.list)
+scilab_examples :=$(shell sed '/^\#/d' $(srcdir)/Examples/scilab/check.list)
go_examples :=$(shell sed '/^\#/d' $(srcdir)/Examples/go/check.list)
d_examples :=$(shell sed '/^\#/d' $(srcdir)/Examples/d/check.list)
+javascript_examples:=$(shell sed '/^\#/d' $(srcdir)/Examples/javascript/check.list)
# all examples
check-%-examples :
elif test -z "$($(strip $*_examples))"; then \
echo empty $* $(ACTION); \
else \
- $(MAKE) -k -s $($*_examples:=.actionexample) LANGUAGE=$* ACTION=$(ACTION); \
+ $(MAKE) $(FLAGS) $($*_examples:=.actionexample) LANGUAGE=$* ACTION=$(ACTION); \
fi
# individual example
%.actionexample:
+ @cd Examples && $(MAKE) Makefile
@echo $(ACTION)ing Examples/$(LANGUAGE)/$*
- @(cd Examples/$(LANGUAGE)/$* && $(MAKE) -s $(chk-set-env) $(ACTION) RUNPIPE=$(RUNPIPE))
+ @(cd Examples/$(LANGUAGE)/$* && $(MAKE) $(FLAGS) $(ACTION) RUNPIPE=$(RUNPIPE))
# gcj individual example
java.actionexample:
+ @cd Examples && $(MAKE) Makefile
@if $(skip-gcj); then \
- echo "skipping Examples/$(LANGUAGE)/java $(ACTION) (gcj test)"; \
- else \
+ echo "skipping Examples/$(LANGUAGE)/java $(ACTION) (gcj test)"; \
+ else \
echo $(ACTION)ing Examples/$(LANGUAGE)/java; \
- (cd Examples/$(LANGUAGE)/java && $(MAKE) -s $(chk-set-env) $(ACTION)) \
+ (cd Examples/$(LANGUAGE)/java && $(MAKE) $(FLAGS) $(ACTION) RUNPIPE=$(RUNPIPE)) \
fi
# Checks testcases in the test-suite excluding those which are known to be broken
check-test-suite: \
+ check-errors-test-suite \
check-tcl-test-suite \
check-perl5-test-suite \
check-python-test-suite \
check-cffi-test-suite \
check-chicken-test-suite \
check-r-test-suite \
+ check-scilab-test-suite \
check-go-test-suite \
- check-d-test-suite
+ check-d-test-suite \
+ check-javascript-test-suite
check-%-test-suite:
@if test -z "$(skip-$*)"; then \
echo warning: cannot $(ACTION) $* test-suite "(no dir $$dir)";\
else \
echo $(ACTION)ing $* test-suite; \
- (cd $$dir && $(MAKE) -k -s $(ACTION)) \
+ (cd $$dir && $(MAKE) $(FLAGS) $(ACTION) HAVE_CXX11_COMPILER=$(HAVE_CXX11_COMPILER)) \
|| passed=false; \
fi; \
test $$passed = true
# Partial test-suite check - it only invokes SWIG, ie no compilation and no runtime testing
partialcheck-test-suite:
- @$(MAKE) -k -s check-test-suite ACTION=partialcheck NOSKIP=1
+ @$(MAKE) $(FLAGS) check-test-suite ACTION=partialcheck NOSKIP=1
partialcheck-%-test-suite:
- @$(MAKE) -k -s check-$*-test-suite ACTION=partialcheck NOSKIP=1
+ @$(MAKE) $(FLAGS) check-$*-test-suite ACTION=partialcheck NOSKIP=1
check: check-aliveness check-ccache check-versions check-examples check-test-suite
all-cffi-test-suite \
all-chicken-test-suite \
all-r-test-suite \
+ all-scilab-test-suite \
all-go-test-suite \
- all-d-test-suite
+ all-d-test-suite \
+ all-javascript-test-suite
all-%-test-suite:
- @$(MAKE) -k -s check-$*-test-suite ACTION=all
+ @$(MAKE) $(FLAGS) check-$*-test-suite ACTION=all
# Run known-to-be-broken testcases in the test-suite
broken-test-suite: \
broken-cffi-test-suite \
broken-chicken-test-suite \
broken-r-test-suite \
+ broken-scilab-test-suite \
broken-go-test-suite \
- broken-d-test-suite
+ broken-d-test-suite \
+ broken-javascript-test-suite
broken-%-test-suite:
- @$(MAKE) -k -s check-$*-test-suite ACTION=broken
+ @$(MAKE) $(FLAGS) check-$*-test-suite ACTION=broken
#####################################################################
# CLEAN
clean-source:
@echo cleaning Source
- @cd $(SOURCE) && $(MAKE) -s clean
+ @cd $(SOURCE) && $(MAKE) $(FLAGS) clean
@rm -f $(TARGET)
clean-examples:
- @$(MAKE) -k -s check-examples ACTION=clean
+ @$(MAKE) $(FLAGS) check-examples ACTION=clean
clean-test-suite:
- @$(MAKE) -k -s check-test-suite ACTION=clean NOSKIP=1
+ @$(MAKE) $(FLAGS) check-test-suite ACTION=clean NOSKIP=1
clean-%-examples:
- @$(MAKE) -k -s check-$*-examples ACTION=clean
+ @$(MAKE) $(FLAGS) check-$*-examples ACTION=clean
clean-%-test-suite:
- @$(MAKE) -k -s check-$*-test-suite ACTION=clean NOSKIP=1
+ @$(MAKE) $(FLAGS) check-$*-test-suite ACTION=clean NOSKIP=1
clean-ccache:
- test -z "$(ENABLE_CCACHE)" || (cd $(CCACHE) && $(MAKE) -s clean)
+ test -z "$(ENABLE_CCACHE)" || (cd $(CCACHE) && $(MAKE) $(FLAGS) clean)
#####################################################################
# DISTCLEAN - clean what configure built
#####################################################################
-DISTCLEAN-DEAD = config.status config.log config.cache swig.spec Makefile mkmf.log libtool preinst-swig Lib/ocaml/swigp4.ml
+DISTCLEAN-DEAD = config.status config.log config.cache swig.spec Makefile mkmf.log preinst-swig
-distclean-helper: distclean-test-suite distclean-examples distclean-dead
+distclean-helper: distclean-test-suite distclean-examples distclean-tools distclean-dead
distclean: distclean-source distclean-ccache distclean-helper
distclean-source:
@echo distcleaning Source
- @cd $(SOURCE) && $(MAKE) -s distclean
+ @cd $(SOURCE) && $(MAKE) $(FLAGS) distclean
@rm -f $(TARGET)
distclean-test-suite:
@echo distcleaning Examples/test-suite
- @$(MAKE) -k -s check-test-suite ACTION=distclean NOSKIP=1
+ @$(MAKE) $(FLAGS) check-test-suite ACTION=distclean NOSKIP=1
distclean-examples:
@echo distcleaning Examples
- @$(MAKE) -k -s clean-examples
- @cd Examples && $(MAKE) -k -s distclean
+ @$(MAKE) $(FLAGS) clean-examples
+ @cd Examples && $(MAKE) $(FLAGS) distclean
+ @if test "x$(srcdir)" != "x."; then \
+ for mkfile in `cd $(srcdir) && find Examples/ -type f -name Makefile`; do \
+ rm -f "$$mkfile"; \
+ done; \
+ fi
distclean-ccache:
- @test -z "$(ENABLE_CCACHE)" || (cd $(CCACHE) && $(MAKE) -s distclean)
+ @test -z "$(ENABLE_CCACHE)" || (cd $(CCACHE) && $(MAKE) $(FLAGS) distclean)
+
+distclean-tools:
+ @echo distcleaning Tools
+ @cd Tools/javascript && $(MAKE) $(FLAGS) distclean
distclean-dead:
rm -f $(DISTCLEAN-DEAD)
maintainer-clean:
@echo maintainer-cleaning source
- @cd $(SOURCE) && $(MAKE) -k -s maintainer-clean
+ @cd $(SOURCE) && $(MAKE) $(FLAGS) maintainer-clean
@echo maintainer-cleaning CCache
- @test -z "$(ENABLE_CCACHE)" || (cd $(CCACHE) && $(MAKE) -s maintainer-clean)
+ @test -z "$(ENABLE_CCACHE)" || (cd $(CCACHE) && $(MAKE) $(FLAGS) maintainer-clean)
@echo maintainer-cleaning docs
- @cd $(DOCS) && $(MAKE) -k -s maintainer-clean
+ @test -d $(DOCS) || exit 0; cd $(DOCS) && $(MAKE) $(FLAGS) maintainer-clean
@echo maintainer-cleaning Lib files
@rm -f $(srcdir)/Lib/swigwarn.swg
@echo distcleaning
- @$(MAKE) -k -s distclean-helper
+ @$(MAKE) $(FLAGS) distclean-helper
+
+check-maintainer-clean: maintainer-clean
+ @if test "x$(srcdir)" = "x."; then \
+ echo "skipping maintainer-clean check (in-source-tree build)"; \
+ exit 0; \
+ fi; \
+ for file in `find . -type f`; do \
+ echo "file missed by maintainer-clean: $$file"; \
+ done; \
+ test "x$$file" = x && echo "all files cleaned by maintainer-clean"
#####################################################################
# Update the Lib/swigwarn.swg file
@$(INSTALL_PROGRAM) $(TARGET) $(DESTDIR)$(BIN_DIR)/`echo $(TARGET_NOEXE) | sed '$(transform)'`@EXEEXT@
lib-languages = gcj typemaps tcl perl5 python guile java mzscheme ruby php ocaml octave \
- pike chicken csharp modula3 allegrocl clisp lua cffi uffi r go d
+ pike chicken csharp modula3 allegrocl clisp lua cffi uffi r go d javascript javascript/jsc \
+ javascript/v8 scilab
lib-modules = std
-install-lib:
+install-lib:
@echo "Installing the SWIG library"
- @$(MKINSTDIRS) $(DESTDIR)$(SWIG_LIB)
+ @$(MKINSTDIRS) $(DESTDIR)$(SWIG_LIB_INSTALL)
@for file in $(srcdir)/Lib/*.i $(srcdir)/Lib/*.swg ; do \
i=`basename $$file` ; \
- echo "Installing $(DESTDIR)$(SWIG_LIB)/$$i"; \
- $(INSTALL_DATA) $$file $(DESTDIR)$(SWIG_LIB)/$$i; \
+ echo "Installing $(DESTDIR)$(SWIG_LIB_INSTALL)/$$i"; \
+ $(INSTALL_DATA) $$file $(DESTDIR)$(SWIG_LIB_INSTALL)/$$i; \
done;
@for lang in $(lib-languages) $(lib-modules); \
do \
echo "Installing language specific files for $$lang"; \
- dst=$(DESTDIR)$(SWIG_LIB)/$$lang; \
+ dst=$(DESTDIR)$(SWIG_LIB_INSTALL)/$$lang; \
$(MKINSTDIRS) $$dst; \
(doti="`cd $(srcdir)/Lib/$$lang && ls *.i 2>/dev/null || echo ''`"; \
dotswg="`cd $(srcdir)/Lib/$$lang && ls *.swg 2>/dev/null || echo ''`"; \
done
install-ccache:
- @test -z "$(ENABLE_CCACHE)" || (cd $(CCACHE) && $(MAKE) -s install)
+ @test -z "$(ENABLE_CCACHE)" || (cd $(CCACHE) && $(MAKE) install)
#####################################################################
uninstall-lib:
@echo "Uninstalling the SWIG library"
- rm -rf $(DESTDIR)$(SWIG_LIB)/
+ rm -rf $(DESTDIR)$(SWIG_LIB_INSTALL)/
uninstall-ccache:
test -z "$(ENABLE_CCACHE)" || (cd $(CCACHE) && $(MAKE) uninstall)
srpm = @PACKAGE_NAME@-@PACKAGE_VERSION@
dist:
- @echo "not implemented - use Tools/makedist.py instead."
- false
+ @echo "'make dist' not implemented - use Tools/mkdist.py instead - e.g.:"
+ @echo "Tools/mkdist.py @VERSION@ master"
+ @false
srcrpm:
rm -fr $(srpm) $(srpm).src.rpm
SWIG (Simplified Wrapper and Interface Generator)
-Version: 2.0.12 (9 Feb 2014)
+Version: 3.0.10 (12 Jun 2016)
Tagline: SWIG is a compiler that integrates C and C++ with languages
including Perl, Python, Tcl, Ruby, PHP, Java, C#, D, Go, Lua,
- Octave, R, Scheme (Guile, MzScheme/Racket, CHICKEN), Ocaml,
- Modula-3, Common Lisp (CLISP, Allegro CL, CFFI, UFFI) and Pike.
- SWIG can also export its parse tree into Lisp s-expressions and
- XML.
+ Octave, R, Scheme (Guile, MzScheme/Racket, CHICKEN), Scilab,
+ Ocaml, Modula-3, Common Lisp (CLISP, Allegro CL, CFFI, UFFI)
+ and Pike. SWIG can also export its parse tree into XML and
+ Lisp s-expressions.
SWIG reads annotated C/C++ header files and creates wrapper code (glue
code) in order to make the corresponding C/C++ libraries available to
Installation
============
Please read the Doc/Manual/Preface.html#Preface_installation for
-full installation instructions for Windows, Unix and Mac OS X.
-The INSTALL file has generic build and installation instructions for
-Unix users.
+full installation instructions for Windows, Unix and Mac OS X
+using the release tarball/zip file. The INSTALL file has generic
+build and installation instructions for Unix users.
+Users wishing to build and install code from Github should
+visit http://swig.org/svn.html to obtain the more detailed
+instructions required for building code obtained from Github - extra
+steps are required compared to building from the release tarball.
Testing
=======
Release Notes
=============
+Detailed release notes are available with the release and are also
+published on the SWIG web site at http://swig.org/release.html.
+
+SWIG-3.0.10 summary:
+- Regression fixes for smart pointers and importing Python modules.
+
+SWIG-3.0.9 summary:
+- Add support for Python's implicit namespace packages.
+- Fixes to support Go 1.6.
+- C++11 std::array support added for Java.
+- Improved C++ multiple inheritance support for Java/C# wrappers.
+- Various other minor fixes and improvements for C#, D, Go, Java,
+ Javascript, Lua, Python, R, Ruby, Scilab.
+
+SWIG-3.0.8 summary:
+- pdf documentation enhancements.
+- Various Python 3.5 issues fixed.
+- std::array support added for Ruby and Python.
+- shared_ptr support added for Ruby.
+- Minor improvements for CFFI, Go, Java, Perl, Python, Ruby.
+
+SWIG-3.0.7 summary:
+- Add support for Octave-4.0.0.
+- Remove potential Android security exploit in generated Java classes.
+- Minor new features and bug fixes.
+
+SWIG-3.0.6 summary:
+- Stability and regression fixes.
+- Fixed parsing of C++ corner cases.
+- Language improvements and bug fixes for C#, Go, Java, Lua, Python, R.
+
+SWIG-3.0.5 summary:
+- Added support for Scilab.
+- Important Python regression fix when wrapping C++ default arguments.
+- Minor improvements for C#, Go, Octave, PHP and Python.
+
+SWIG-3.0.4 summary:
+- Python regression fix when wrapping C++ default arguments.
+- Improved error messages.
+
+SWIG-3.0.3 summary:
+- Add support for C++11 strongly typed enumerations.
+- Numerous bug fixes and minor enhancements for C#, D, Go, Java,
+ Javascript, PHP, Perl and Python wrappers.
+
+SWIG-3.0.2 summary:
+- Bug fix during install and a couple of other minor changes.
+
+SWIG-3.0.1 summary:
+- Javascript module added. This supports JavascriptCore (Safari/Webkit),
+ v8 (Chromium) and node.js currently.
+- A few notable regressions introduced in 3.0.0 have been fixed - in
+ Lua, nested classes and parsing of operator <<.
+- The usual round of bug fixes and minor improvements for:
+ C#, GCJ, Go, Java, Lua, PHP and Python.
+
+SWIG-3.0.0 summary:
+- This is a major new release focusing primarily on C++ improvements.
+- C++11 support added. Please see documentation for details of supported
+ features: http://www.swig.org/Doc3.0/CPlusPlus11.html
+- Nested class support added. This has been taken full advantage of in
+ Java and C#. Other languages can use the nested classes, but require
+ further work for a more natural integration into the target language.
+ We urge folk knowledgeable in the other target languages to step
+ forward and help with this effort.
+- Lua: improved metatables and support for %nspace.
+- Go 1.3 support added.
+- Python import improvements including relative imports.
+- Python 3.3 support completed.
+- Perl director support added.
+- C# .NET 2 support is now the minimum. Generated using statements are
+ replaced by fully qualified names.
+- Bug fixes and improvements to the following languages:
+ C#, Go, Guile, Java, Lua, Perl, PHP, Python, Octave, R, Ruby, Tcl
+- Various other bug fixes and improvements affecting all languages.
+- Note that this release contains some backwards incompatible changes
+ in some languages.
+- Full detailed release notes are in the changes file.
+
SWIG-2.0.12 summary:
- This is a maintenance release backporting some fixes from the pending
3.0.0 release.
exceptions into target language exceptions.
- Improved enum support, mapping to built-in Java 1.5 enums and C#
enums or the typesafe enum pattern for these two languages.
-- Python - much better STL suppport and support for std::wstring,
+- Python - much better STL support and support for std::wstring,
wchar_t and FILE *.
- Initial support for Modula3 and Allegro CL.
- 64 bit TCL support.
extern String *cparse_file;
extern int cparse_line;
extern int cparse_cplusplus;
+ extern int cparse_cplusplusout;
extern int cparse_start_line;
+ extern String *cparse_unknown_directive;
extern void Swig_cparse_cplusplus(int);
+ extern void Swig_cparse_cplusplusout(int);
extern void scanner_file(File *);
extern void scanner_next_token(int);
extern void skip_balanced(int startchar, int endchar);
+ extern String *get_raw_text_balanced(int startchar, int endchar);
extern void skip_decl(void);
extern void scanner_check_typedef(void);
extern void scanner_ignore_typedef(void);
/* util.c */
extern void Swig_cparse_replace_descriptor(String *s);
+ extern SwigType *Swig_cparse_smartptr(Node *n);
extern void cparse_normalize_void(Node *);
extern Parm *Swig_cparse_parm(String *s);
extern ParmList *Swig_cparse_parms(String *s, Node *file_line_node);
-
+ extern Node *new_node(const_String_or_char_ptr tag);
/* templ.c */
extern int Swig_cparse_template_expand(Node *n, String *rname, ParmList *tparms, Symtab *tscope);
/* C++ mode */
int cparse_cplusplus = 0;
+/* Generate C++ compatible code when wrapping C code */
+int cparse_cplusplusout = 0;
+
+/* To allow better error reporting */
+String *cparse_unknown_directive = 0;
+
/* Private vars */
static int scan_init = 0;
static int num_brace = 0;
cparse_cplusplus = v;
}
+/* -----------------------------------------------------------------------------
+ * Swig_cparse_cplusplusout()
+ * ----------------------------------------------------------------------------- */
+
+void Swig_cparse_cplusplusout(int v) {
+ cparse_cplusplusout = v;
+}
+
/* ----------------------------------------------------------------------------
* scanner_init()
*
return;
}
+/* -----------------------------------------------------------------------------
+ * get_raw_text_balanced()
+ *
+ * Returns raw text between 2 braces
+ * ----------------------------------------------------------------------------- */
+
+String *get_raw_text_balanced(int startchar, int endchar) {
+ return Scanner_get_raw_text_balanced(scan, startchar, endchar);
+}
+
/* ----------------------------------------------------------------------------
* void skip_decl(void)
*
* friend ostream& operator<<(ostream&, const char *s);
*
* or
- * friend ostream& operator<<(ostream&, const char *s) { };
+ * friend ostream& operator<<(ostream&, const char *s) { }
*
* ------------------------------------------------------------------------- */
return GREATERTHANOREQUALTO;
case SWIG_TOKEN_RSHIFT:
return RSHIFT;
+ case SWIG_TOKEN_ARROW:
+ return ARROW;
case SWIG_TOKEN_PERIOD:
return PERIOD;
case SWIG_TOKEN_MODULO:
case SWIG_TOKEN_STRING:
yylval.id = Swig_copy_string(Char(Scanner_text(scan)));
return STRING;
+
+ case SWIG_TOKEN_WSTRING:
+ yylval.id = Swig_copy_string(Char(Scanner_text(scan)));
+ return WSTRING;
case SWIG_TOKEN_CHAR:
yylval.str = NewString(Scanner_text(scan));
if (Len(yylval.str) == 0) {
Swig_error(cparse_file, cparse_line, "Empty character constant\n");
- Printf(stdout,"%d\n", Len(Scanner_text(scan)));
}
return CHARCONST;
-
+
+ case SWIG_TOKEN_WCHAR:
+ yylval.str = NewString(Scanner_text(scan));
+ if (Len(yylval.str) == 0) {
+ Swig_error(cparse_file, cparse_line, "Empty character constant\n");
+ }
+ return WCHARCONST;
+
/* Numbers */
case SWIG_TOKEN_INT:
return (PROTECTED);
if (strcmp(yytext, "friend") == 0)
return (FRIEND);
+ if (strcmp(yytext, "constexpr") == 0)
+ return (CONSTEXPR);
+ if (strcmp(yytext, "thread_local") == 0)
+ return (THREAD_LOCAL);
+ if (strcmp(yytext, "decltype") == 0)
+ return (DECLTYPE);
if (strcmp(yytext, "virtual") == 0)
return (VIRTUAL);
+ if (strcmp(yytext, "static_assert") == 0)
+ return (STATIC_ASSERT);
if (strcmp(yytext, "operator") == 0) {
int nexttok;
String *s = NewString("operator ");
*/
- nexttok = Scanner_token(scan);
+ do {
+ nexttok = Scanner_token(scan);
+ } while (nexttok == SWIG_TOKEN_ENDLINE || nexttok == SWIG_TOKEN_COMMENT);
+
if (Scanner_isoperator(nexttok)) {
/* One of the standard C/C++ symbolic operators */
Append(s,Scanner_text(scan));
yylval.str = s;
return OPERATOR;
}
+ } else if (nexttok == SWIG_TOKEN_STRING) {
+ /* Operator "" or user-defined string literal ""_suffix */
+ Append(s,"\"\"");
+ yylval.str = s;
+ return OPERATOR;
} else if (nexttok == SWIG_TOKEN_ID) {
/* We have an identifier. This could be any number of things. It could be a named version of
an operator (e.g., 'and_eq') or it could be a conversion operator. To deal with this, we're
Append(s," ");
}
Append(s,Scanner_text(scan));
+ } else if (nexttok == SWIG_TOKEN_ENDLINE) {
+ } else if (nexttok == SWIG_TOKEN_COMMENT) {
} else {
Append(s,Scanner_text(scan));
needspace = 0;
Setfile(cs,cparse_file);
Scanner_push(scan,cs);
Delete(cs);
- return COPERATOR;
+ return CONVERSIONOPERATOR;
}
}
if (termtoken)
}
if (strcmp(yytext, "throw") == 0)
return (THROW);
+ if (strcmp(yytext, "noexcept") == 0)
+ return (NOEXCEPT);
if (strcmp(yytext, "try") == 0)
return (yylex());
if (strcmp(yytext, "catch") == 0)
return (yylex());
if (strcmp(yytext, "explicit") == 0)
return (EXPLICIT);
+ if (strcmp(yytext, "auto") == 0)
+ return (AUTO);
if (strcmp(yytext, "export") == 0)
return (yylex());
if (strcmp(yytext, "typename") == 0)
yylval.intvalue = cparse_line;
return (TEMPLATE);
}
- if (strcmp(yytext, "delete") == 0) {
+ if (strcmp(yytext, "delete") == 0)
return (DELETE_KW);
- }
- if (strcmp(yytext, "using") == 0) {
+ if (strcmp(yytext, "default") == 0)
+ return (DEFAULT);
+ if (strcmp(yytext, "using") == 0)
return (USING);
- }
- if (strcmp(yytext, "namespace") == 0) {
+ if (strcmp(yytext, "namespace") == 0)
return (NAMESPACE);
- }
+ if (strcmp(yytext, "override") == 0)
+ return (OVERRIDE);
+ if (strcmp(yytext, "final") == 0)
+ return (FINAL);
} else {
if (strcmp(yytext, "class") == 0) {
Swig_warning(WARN_PARSE_CLASS_KEYWORD, cparse_file, cparse_line, "class keyword used, but not in C++ mode.\n");
if (strcmp(yytext, "inline") == 0)
return (yylex());
- /* SWIG directives */
} else {
+ Delete(cparse_unknown_directive);
+ cparse_unknown_directive = NULL;
+
+ /* SWIG directives */
if (strcmp(yytext, "%module") == 0)
return (MODULE);
if (strcmp(yytext, "%insert") == 0)
}
if (strcmp(yytext, "%warn") == 0)
return (WARN);
+
+ /* Note down the apparently unknown directive for error reporting. */
+ cparse_unknown_directive = NewString(yytext);
}
/* Have an unknown identifier, as a last step, we'll do a typedef lookup on it. */
-/* A Bison parser, made by GNU Bison 2.5. */
+/* A Bison parser, made by GNU Bison 3.0.4. */
/* Bison implementation for Yacc-like parsers in C
-
- Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
-
+
+ Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
-
+
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
#define YYBISON 1
/* Bison version. */
-#define YYBISON_VERSION "2.5"
+#define YYBISON_VERSION "3.0.4"
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
/* Pull parsers. */
#define YYPULL 1
-/* Using locations. */
-#define YYLSP_NEEDED 0
/* Copy the first part of user declarations. */
-
-/* Line 268 of yacc.c */
-#line 16 "parser.y"
-
+#line 25 "parser.y" /* yacc.c:339 */
#define yylex yylex
static Node *top = 0; /* Top of the generated parse tree */
static int unnamed = 0; /* Unnamed datatype counter */
-static Hash *extendhash = 0; /* Hash table of added methods */
static Hash *classes = 0; /* Hash table of classes */
static Hash *classes_typedefs = 0; /* Hash table of typedef classes: typedef struct X {...} Y; */
static Symtab *prev_symtab = 0;
static String *Classprefix = 0;
static String *Namespaceprefix = 0;
static int inclass = 0;
-static int nested_template = 0; /* template class/function definition within a class */
-static char *last_cpptype = 0;
+static Node *currentOuterClass = 0; /* for nested classes */
+static const char *last_cpptype = 0;
static int inherit_list = 0;
static Parm *template_parameters = 0;
static int extendmode = 0;
static int compact_default_args = 0;
static int template_reduce = 0;
static int cparse_externc = 0;
-
-static int max_class_levels = 0;
-static int class_level = 0;
-static Node **class_decl = NULL;
-
+int ignore_nested_classes = 0;
+int kwargs_supported = 0;
/* -----------------------------------------------------------------------------
* Assist Functions
* ----------------------------------------------------------------------------- */
(void)e;
}
-static Node *new_node(const_String_or_char_ptr tag) {
- Node *n = NewHash();
- set_nodeType(n,tag);
- Setfile(n,cparse_file);
- Setline(n,cparse_line);
- return n;
-}
-
/* Copies a node. Does not copy tree links or symbol table data (except for
sym:name) */
Delete(pl);
continue;
}
+ if (strcmp(ckey,"nested:outer") == 0) { /* don't copy outer classes links, they will be updated later */
+ Setattr(nn, key, k.item);
+ continue;
+ }
+ /* defaultargs will be patched back in later in update_defaultargs() */
+ if (strcmp(ckey,"defaultargs") == 0) {
+ Setattr(nn, "needs_defaultargs", "1");
+ continue;
+ }
/* Looks okay. Just copy the data using Copy */
ci = Copy(k.item);
Setattr(nn, key, ci);
static char *typemap_lang = 0; /* Current language setting */
static int cplus_mode = 0;
-static String *class_rename = 0;
/* C++ modes */
}
}
+static void set_access_mode(Node *n) {
+ if (cplus_mode == CPLUS_PUBLIC)
+ Setattr(n, "access", "public");
+ else if (cplus_mode == CPLUS_PROTECTED)
+ Setattr(n, "access", "protected");
+ else
+ Setattr(n, "access", "private");
+}
+
+static void restore_access_mode(Node *n) {
+ String *mode = Getattr(n, "access");
+ if (Strcmp(mode, "private") == 0)
+ cplus_mode = CPLUS_PRIVATE;
+ else if (Strcmp(mode, "protected") == 0)
+ cplus_mode = CPLUS_PROTECTED;
+ else
+ cplus_mode = CPLUS_PUBLIC;
+}
+
/* Generate the symbol table name for an object */
/* This is a bit of a mess. Need to clean up */
static String *add_oldname = 0;
String *decl;
String *wrn = 0;
- if (nested_template) {
- if (!(n && Equal(nodeType(n), "template"))) {
- return;
- }
- /* continue if template function, but not template class, declared within a class */
- }
-
if (inclass && n) {
cparse_normalize_void(n);
}
int isfriend = inclass && is_friend(n);
int iscdecl = Cmp(nodeType(n),"cdecl") == 0;
int only_csymbol = 0;
- if (extendmode) {
- Setattr(n,"isextension","1");
- }
if (inclass) {
String *name = Getattr(n, "name");
}
Delete(prefix);
}
-
- /*
- if (!Getattr(n,"parentNode") && class_level) set_parentNode(n,class_decl[class_level - 1]);
- */
- Setattr(n,"ismember","1");
}
}
+
+ if (!isfriend && (inclass || extendmode)) {
+ Setattr(n,"ismember","1");
+ }
+
+ if (extendmode) {
+ Setattr(n,"isextendmember","1");
+ }
+
if (!isfriend && inclass) {
if ((cplus_mode != CPLUS_PUBLIC)) {
only_csymbol = 1;
if ((Cmp(Getattr(n,"storage"),"virtual") == 0) && (Cmp(Getattr(n,"value"),"0") == 0)) {
only_csymbol = 0;
}
+ if (Cmp(nodeType(n),"destructor") == 0) {
+ /* Needed for "unref" feature */
+ only_csymbol = 0;
+ }
}
} else {
Setattr(n,"access", "public");
} else {
ty = type;
}
- if (!SwigType_ismutable(ty)) {
+ if (!SwigType_ismutable(ty) || (storage && Strstr(storage, "constexpr"))) {
SetFlag(n,"hasconsttype");
SetFlag(n,"feature:immutable");
}
n = nextSibling(n);
continue;
}
- if (only_csymbol || GetFlag(n,"feature:ignore")) {
+ if (cparse_cplusplus) {
+ String *value = Getattr(n, "value");
+ if (value && Strcmp(value, "delete") == 0) {
+ /* C++11 deleted definition / deleted function */
+ SetFlag(n,"deleted");
+ SetFlag(n,"feature:ignore");
+ }
+ }
+ if (only_csymbol || GetFlag(n,"feature:ignore") || strncmp(Char(symname),"$ignore",7) == 0) {
/* Only add to C symbol table and continue */
Swig_symbol_add(0, n);
- } else if (strncmp(Char(symname),"$ignore",7) == 0) {
- char *c = Char(symname)+7;
- SetFlag(n,"feature:ignore");
- if (strlen(c)) {
- SWIG_WARN_NODE_BEGIN(n);
- Swig_warning(0,Getfile(n), Getline(n), "%s\n",c+1);
- SWIG_WARN_NODE_END(n);
+ if (!only_csymbol && !GetFlag(n, "feature:ignore")) {
+ /* Print the warning attached to $ignore name, if any */
+ char *c = Char(symname) + 7;
+ if (strlen(c)) {
+ SWIG_WARN_NODE_BEGIN(n);
+ Swig_warning(0,Getfile(n), Getline(n), "%s\n",c+1);
+ SWIG_WARN_NODE_END(n);
+ }
+ /* If the symbol was ignored via "rename" and is visible, set also feature:ignore*/
+ SetFlag(n, "feature:ignore");
+ }
+ if (!GetFlag(n, "feature:ignore") && Strcmp(symname,"$ignore") == 0) {
+ /* Add feature:ignore if the symbol was explicitely ignored, regardless of visibility */
+ SetFlag(n, "feature:ignore");
}
- Swig_symbol_add(0, n);
} else {
Node *c;
if ((wrn) && (Len(wrn))) {
}
}
-/* Extension merge. This function is used to handle the %extend directive
- when it appears before a class definition. To handle this, the %extend
- actually needs to take precedence. Therefore, we will selectively nuke symbols
- from the current symbol table, replacing them with the added methods */
-
-static void merge_extensions(Node *cls, Node *am) {
- Node *n;
- Node *csym;
-
- n = firstChild(am);
- while (n) {
- String *symname;
- if (Strcmp(nodeType(n),"constructor") == 0) {
- symname = Getattr(n,"sym:name");
- if (symname) {
- if (Strcmp(symname,Getattr(n,"name")) == 0) {
- /* If the name and the sym:name of a constructor are the same,
- then it hasn't been renamed. However---the name of the class
- itself might have been renamed so we need to do a consistency
- check here */
- if (Getattr(cls,"sym:name")) {
- Setattr(n,"sym:name", Getattr(cls,"sym:name"));
- }
+/* Add in the "defaultargs" attribute for functions in instantiated templates.
+ * n should be any instantiated template (class or start of linked list of functions). */
+static void update_defaultargs(Node *n) {
+ if (n) {
+ Node *firstdefaultargs = n;
+ update_defaultargs(firstChild(n));
+ n = nextSibling(n);
+ /* recursively loop through nodes of all types, but all we really need are the overloaded functions */
+ while (n) {
+ update_defaultargs(firstChild(n));
+ if (!Getattr(n, "defaultargs")) {
+ if (Getattr(n, "needs_defaultargs")) {
+ Setattr(n, "defaultargs", firstdefaultargs);
+ Delattr(n, "needs_defaultargs");
+ } else {
+ firstdefaultargs = n;
}
- }
- }
-
- symname = Getattr(n,"sym:name");
- DohIncref(symname);
- if ((symname) && (!Getattr(n,"error"))) {
- /* Remove node from its symbol table */
- Swig_symbol_remove(n);
- csym = Swig_symbol_add(symname,n);
- if (csym != n) {
- /* Conflict with previous definition. Nuke previous definition */
- String *e = NewStringEmpty();
- String *en = NewStringEmpty();
- String *ec = NewStringEmpty();
- Printf(ec,"Identifier '%s' redefined by %%extend (ignored),",symname);
- Printf(en,"%%extend definition of '%s'.",symname);
- SWIG_WARN_NODE_BEGIN(n);
- Swig_warning(WARN_PARSE_REDEFINED,Getfile(csym),Getline(csym),"%s\n",ec);
- Swig_warning(WARN_PARSE_REDEFINED,Getfile(n),Getline(n),"%s\n",en);
- SWIG_WARN_NODE_END(n);
- Printf(e,"%s:%d:%s\n%s:%d:%s\n",Getfile(csym),Getline(csym),ec,
- Getfile(n),Getline(n),en);
- Setattr(csym,"error",e);
- Delete(e);
- Delete(en);
- Delete(ec);
- Swig_symbol_remove(csym); /* Remove class definition */
- Swig_symbol_add(symname,n); /* Insert extend definition */
+ } else {
+ /* Functions added in with %extend (for specialized template classes) will already have default args patched up */
+ assert(Getattr(n, "defaultargs") == firstdefaultargs);
}
- }
- n = nextSibling(n);
- }
-}
-
-static void append_previous_extension(Node *cls, Node *am) {
- Node *n, *ne;
- Node *pe = 0;
- Node *ae = 0;
-
- if (!am) return;
-
- n = firstChild(am);
- while (n) {
- ne = nextSibling(n);
- set_nextSibling(n,0);
- /* typemaps and fragments need to be prepended */
- if (((Cmp(nodeType(n),"typemap") == 0) || (Cmp(nodeType(n),"fragment") == 0))) {
- if (!pe) pe = new_node("extend");
- appendChild(pe, n);
- } else {
- if (!ae) ae = new_node("extend");
- appendChild(ae, n);
- }
- n = ne;
- }
- if (pe) prependChild(cls,pe);
- if (ae) appendChild(cls,ae);
-}
-
-
-/* Check for unused %extend. Special case, don't report unused
- extensions for templates */
-
-static void check_extensions() {
- Iterator ki;
-
- if (!extendhash) return;
- for (ki = First(extendhash); ki.key; ki = Next(ki)) {
- if (!Strchr(ki.key,'<')) {
- SWIG_WARN_NODE_BEGIN(ki.item);
- Swig_warning(WARN_PARSE_EXTEND_UNDEF,Getfile(ki.item), Getline(ki.item), "%%extend defined for an undeclared class %s.\n", SwigType_namestr(ki.key));
- SWIG_WARN_NODE_END(ki.item);
+ n = nextSibling(n);
}
}
}
return nname;
}
-static List *make_inherit_list(String *clsname, List *names) {
- int i, ilen;
- String *derived;
- List *bases = NewList();
-
- if (Namespaceprefix) derived = NewStringf("%s::%s", Namespaceprefix,clsname);
- else derived = NewString(clsname);
-
- ilen = Len(names);
- for (i = 0; i < ilen; i++) {
- Node *s;
- String *base;
- String *n = Getitem(names,i);
- /* Try to figure out where this symbol is */
- s = Swig_symbol_clookup(n,0);
- if (s) {
- while (s && (Strcmp(nodeType(s),"class") != 0)) {
- /* Not a class. Could be a typedef though. */
- String *storage = Getattr(s,"storage");
- if (storage && (Strcmp(storage,"typedef") == 0)) {
- String *nn = Getattr(s,"type");
- s = Swig_symbol_clookup(nn,Getattr(s,"sym:symtab"));
- } else {
- break;
- }
- }
- if (s && ((Strcmp(nodeType(s),"class") == 0) || (Strcmp(nodeType(s),"template") == 0))) {
- String *q = Swig_symbol_qualified(s);
- Append(bases,s);
- if (q) {
- base = NewStringf("%s::%s", q, Getattr(s,"name"));
- Delete(q);
- } else {
- base = NewString(Getattr(s,"name"));
- }
- } else {
- base = NewString(n);
- }
- } else {
- base = NewString(n);
- }
- if (base) {
- Swig_name_inherit(base,derived);
- Delete(base);
+/* Use typedef name as class name */
+
+static void add_typedef_name(Node *n, Node *declnode, String *oldName, Symtab *cscope, String *scpname) {
+ String *class_rename = 0;
+ SwigType *decl = Getattr(declnode, "decl");
+ if (!decl || !Len(decl)) {
+ String *cname;
+ String *tdscopename;
+ String *class_scope = Swig_symbol_qualifiedscopename(cscope);
+ String *name = Getattr(declnode, "name");
+ cname = Copy(name);
+ Setattr(n, "tdname", cname);
+ tdscopename = class_scope ? NewStringf("%s::%s", class_scope, name) : Copy(name);
+ class_rename = Getattr(n, "class_rename");
+ if (class_rename && (Strcmp(class_rename, oldName) == 0))
+ Setattr(n, "class_rename", NewString(name));
+ if (!classes_typedefs) classes_typedefs = NewHash();
+ if (!Equal(scpname, tdscopename) && !Getattr(classes_typedefs, tdscopename)) {
+ Setattr(classes_typedefs, tdscopename, n);
}
+ Setattr(n, "decl", decl);
+ Delete(class_scope);
+ Delete(cname);
+ Delete(tdscopename);
}
- return bases;
}
/* If the class name is qualified. We need to create or lookup namespace entries */
String *name = Getattr(kw,"name");
if (name && (Cmp(name,"noblock") == 0)) {
char *cstr = Char(inputcode);
- size_t len = Len(inputcode);
+ int len = Len(inputcode);
if (len && cstr[0] == '{') {
--len; ++cstr;
if (len && cstr[len - 1] == '}') { --len; }
return cname;
}
-
-
-/* Structures for handling code fragments built for nested classes */
-
-typedef struct Nested {
- String *code; /* Associated code fragment */
- int line; /* line number where it starts */
- const char *name; /* Name associated with this nested class */
- const char *kind; /* Kind of class */
- int unnamed; /* unnamed class */
- SwigType *type; /* Datatype associated with the name */
- struct Nested *next; /* Next code fragment in list */
-} Nested;
-
-/* Some internal variables for saving nested class information */
-
-static Nested *nested_list = 0;
-
-/* Add a function to the nested list */
-
-static void add_nested(Nested *n) {
- if (!nested_list) {
- nested_list = n;
- } else {
- Nested *n1 = nested_list;
- while (n1->next)
- n1 = n1->next;
- n1->next = n;
+/* look for simple typedef name in typedef list */
+static String *try_to_find_a_name_for_unnamed_structure(const char *storage, Node *decls) {
+ String *name = 0;
+ Node *n = decls;
+ if (storage && (strcmp(storage, "typedef") == 0)) {
+ for (; n; n = nextSibling(n)) {
+ if (!Len(Getattr(n, "decl"))) {
+ name = Copy(Getattr(n, "name"));
+ break;
+ }
+ }
}
+ return name;
}
-/* -----------------------------------------------------------------------------
- * nested_new_struct()
- *
- * Nested struct handling for C code only creates a global struct from the nested struct.
- *
- * Nested structure. This is a sick "hack". If we encounter
- * a nested structure, we're going to grab the text of its definition and
- * feed it back into the scanner. In the meantime, we need to grab
- * variable declaration information and generate the associated wrapper
- * code later. Yikes!
- *
- * This really only works in a limited sense. Since we use the
- * code attached to the nested class to generate both C code
- * it can't have any SWIG directives in it. It also needs to be parsable
- * by SWIG or this whole thing is going to puke.
- * ----------------------------------------------------------------------------- */
-
-static void nested_new_struct(const char *kind, String *struct_code, Node *cpp_opt_declarators) {
- String *name;
- String *decl;
-
- /* Create a new global struct declaration which is just a copy of the nested struct */
- Nested *nested = (Nested *) malloc(sizeof(Nested));
- Nested *n = nested;
-
- name = Getattr(cpp_opt_declarators, "name");
- decl = Getattr(cpp_opt_declarators, "decl");
-
- n->code = NewStringEmpty();
- Printv(n->code, "typedef ", kind, " ", struct_code, " $classname_", name, ";\n", NIL);
- n->name = Swig_copy_string(Char(name));
- n->line = cparse_start_line;
- n->type = NewStringEmpty();
- n->kind = kind;
- n->unnamed = 0;
- SwigType_push(n->type, decl);
- n->next = 0;
-
- /* Repeat for any multiple instances of the nested struct */
- {
- Node *p = cpp_opt_declarators;
- p = nextSibling(p);
- while (p) {
- Nested *nn = (Nested *) malloc(sizeof(Nested));
-
- name = Getattr(p, "name");
- decl = Getattr(p, "decl");
-
- nn->code = NewStringEmpty();
- Printv(nn->code, "typedef ", kind, " ", struct_code, " $classname_", name, ";\n", NIL);
- nn->name = Swig_copy_string(Char(name));
- nn->line = cparse_start_line;
- nn->type = NewStringEmpty();
- nn->kind = kind;
- nn->unnamed = 0;
- SwigType_push(nn->type, decl);
- nn->next = 0;
- n->next = nn;
- n = nn;
- p = nextSibling(p);
- }
+/* traverse copied tree segment, and update outer class links*/
+static void update_nested_classes(Node *n)
+{
+ Node *c = firstChild(n);
+ while (c) {
+ if (Getattr(c, "nested:outer"))
+ Setattr(c, "nested:outer", n);
+ update_nested_classes(c);
+ c = nextSibling(c);
}
-
- add_nested(nested);
}
/* -----------------------------------------------------------------------------
* nested_forward_declaration()
*
- * Nested struct handling for C++ code only.
- *
- * Treat the nested class/struct/union as a forward declaration until a proper
- * nested class solution is implemented.
+ * Nested struct handling for C++ code if the nested classes are disabled.
+ * Create the nested class/struct/union as a forward declaration.
* ----------------------------------------------------------------------------- */
static Node *nested_forward_declaration(const char *storage, const char *kind, String *sname, String *name, Node *cpp_opt_declarators) {
Node *nn = 0;
- int warned = 0;
if (sname) {
/* Add forward declaration of the nested type */
}
}
- if (nn && Equal(nodeType(nn), "classforward")) {
- Node *n = nn;
- if (GetFlag(n, "feature:nestedworkaround")) {
- Swig_symbol_remove(n);
- nn = 0;
- warned = 1;
+ if (!currentOuterClass || !GetFlag(currentOuterClass, "nested")) {
+ if (nn && Equal(nodeType(nn), "classforward")) {
+ Node *n = nn;
+ if (!GetFlag(n, "feature:ignore")) {
+ SWIG_WARN_NODE_BEGIN(n);
+ Swig_warning(WARN_PARSE_NAMED_NESTED_CLASS, cparse_file, cparse_line,"Nested %s not currently supported (%s ignored)\n", kind, sname ? sname : name);
+ SWIG_WARN_NODE_END(n);
+ }
} else {
- SWIG_WARN_NODE_BEGIN(n);
- Swig_warning(WARN_PARSE_NAMED_NESTED_CLASS, cparse_file, cparse_line,"Nested %s not currently supported (%s ignored)\n", kind, sname ? sname : name);
- SWIG_WARN_NODE_END(n);
- warned = 1;
+ Swig_warning(WARN_PARSE_UNNAMED_NESTED_CLASS, cparse_file, cparse_line, "Nested %s not currently supported (ignored).\n", kind);
}
}
- if (!warned)
- Swig_warning(WARN_PARSE_UNNAMED_NESTED_CLASS, cparse_file, cparse_line, "Nested %s not currently supported (ignored).\n", kind);
-
return nn;
}
-/* Strips C-style and C++-style comments from string in-place. */
-static void strip_comments(char *string) {
- int state = 0; /*
- * 0 - not in comment
- * 1 - in c-style comment
- * 2 - in c++-style comment
- * 3 - in string
- * 4 - after reading / not in comments
- * 5 - after reading * in c-style comments
- * 6 - after reading \ in strings
- */
- char * c = string;
- while (*c) {
- switch (state) {
- case 0:
- if (*c == '\"')
- state = 3;
- else if (*c == '/')
- state = 4;
- break;
- case 1:
- if (*c == '*')
- state = 5;
- *c = ' ';
- break;
- case 2:
- if (*c == '\n')
- state = 0;
- else
- *c = ' ';
- break;
- case 3:
- if (*c == '\"')
- state = 0;
- else if (*c == '\\')
- state = 6;
- break;
- case 4:
- if (*c == '/') {
- *(c-1) = ' ';
- *c = ' ';
- state = 2;
- } else if (*c == '*') {
- *(c-1) = ' ';
- *c = ' ';
- state = 1;
- } else
- state = 0;
- break;
- case 5:
- if (*c == '/')
- state = 0;
- else
- state = 1;
- *c = ' ';
- break;
- case 6:
- state = 3;
- break;
- }
- ++c;
- }
-}
-
-/* Dump all of the nested class declarations to the inline processor
- * However. We need to do a few name replacements and other munging
- * first. This function must be called before closing a class! */
-
-static Node *dump_nested(const char *parent) {
- Nested *n,*n1;
- Node *ret = 0;
- Node *last = 0;
- n = nested_list;
- if (!parent) {
- nested_list = 0;
- return 0;
- }
- while (n) {
- Node *retx;
- SwigType *nt;
- /* Token replace the name of the parent class */
- Replace(n->code, "$classname", parent, DOH_REPLACE_ANY);
-
- /* Fix up the name of the datatype (for building typedefs and other stuff) */
- Append(n->type,parent);
- Append(n->type,"_");
- Append(n->type,n->name);
-
- /* Add the appropriate declaration to the C++ processor */
- retx = new_node("cdecl");
- Setattr(retx,"name",n->name);
- nt = Copy(n->type);
- Setattr(retx,"type",nt);
- Delete(nt);
- Setattr(retx,"nested",parent);
- if (n->unnamed) {
- Setattr(retx,"unnamed","1");
- }
-
- add_symbols(retx);
- if (ret) {
- set_nextSibling(last, retx);
- Delete(retx);
- } else {
- ret = retx;
- }
- last = retx;
-
- /* Strip comments - further code may break in presence of comments. */
- strip_comments(Char(n->code));
-
- /* Make all SWIG created typedef structs/unions/classes unnamed else
- redefinition errors occur - nasty hack alert.*/
-
- {
- const char* types_array[3] = {"struct", "union", "class"};
- int i;
- for (i=0; i<3; i++) {
- char* code_ptr = Char(n->code);
- while (code_ptr) {
- /* Replace struct name (as in 'struct name {...}' ) with whitespace
- name will be between struct and opening brace */
-
- code_ptr = strstr(code_ptr, types_array[i]);
- if (code_ptr) {
- char *open_bracket_pos;
- code_ptr += strlen(types_array[i]);
- open_bracket_pos = strchr(code_ptr, '{');
- if (open_bracket_pos) {
- /* Make sure we don't have something like struct A a; */
- char* semi_colon_pos = strchr(code_ptr, ';');
- if (!(semi_colon_pos && (semi_colon_pos < open_bracket_pos)))
- while (code_ptr < open_bracket_pos)
- *code_ptr++ = ' ';
- }
- }
- }
- }
- }
-
- {
- /* Remove SWIG directive %constant which may be left in the SWIG created typedefs */
- char* code_ptr = Char(n->code);
- while (code_ptr) {
- code_ptr = strstr(code_ptr, "%constant");
- if (code_ptr) {
- char* directive_end_pos = strchr(code_ptr, ';');
- if (directive_end_pos) {
- while (code_ptr <= directive_end_pos)
- *code_ptr++ = ' ';
- }
- }
- }
- }
- {
- Node *newnode = new_node("insert");
- String *code = NewStringEmpty();
- Wrapper_pretty_print(n->code, code);
- Setattr(newnode,"code", code);
- Delete(code);
- set_nextSibling(last, newnode);
- Delete(newnode);
- last = newnode;
- }
-
- /* Dump the code to the scanner */
- start_inline(Char(Getattr(last, "code")),n->line);
-
- n1 = n->next;
- Delete(n->code);
- free(n);
- n = n1;
- }
- nested_list = 0;
- return ret;
-}
Node *Swig_cparse(File *f) {
scanner_file(f);
/* Printf(stdout, "single_new_feature: [%s] [%s] [%s] [%s] [%s] [%s]\n", featurename, val, declaratorid, t, ParmList_str_defaultargs(declaratorparms), qualifier); */
+ /* Warn about deprecated features */
+ if (strcmp(featurename, "nestedworkaround") == 0)
+ Swig_warning(WARN_DEPRECATED_NESTED_WORKAROUND, cparse_file, cparse_line, "The 'nestedworkaround' feature is deprecated.\n");
+
fname = NewStringf("feature:%s",featurename);
if (declaratorid) {
fixname = feature_identifier_fix(declaratorid);
/* check if a function declaration is a plain C object */
static int is_cfunction(Node *n) {
- if (!cparse_cplusplus || cparse_externc) return 1;
- if (Cmp(Getattr(n,"storage"),"externc") == 0) {
+ if (!cparse_cplusplus || cparse_externc)
+ return 1;
+ if (Swig_storage_isexternc(n)) {
return 1;
}
return 0;
if (compact_default_args
|| is_cfunction(function)
|| GetFlag(function,"feature:compactdefaultargs")
- || GetFlag(function,"feature:kwargs")) {
+ || (GetFlag(function,"feature:kwargs") && kwargs_supported)) {
ParmList *p = Getattr(function,"parms");
if (p)
Setattr(p,"compactdefargs", "1"); /* mark parameters for special handling */
}
/* -----------------------------------------------------------------------------
- * tag_nodes()
+ * mark_nodes_as_extend()
*
- * Used by the parser to mark subtypes with extra information.
+ * Used by the %extend to mark subtypes with "feature:extend".
+ * template instances declared within %extend are skipped
* ----------------------------------------------------------------------------- */
-static void tag_nodes(Node *n, const_String_or_char_ptr attrname, DOH *value) {
- while (n) {
- Setattr(n, attrname, value);
- tag_nodes(firstChild(n), attrname, value);
- n = nextSibling(n);
+static void mark_nodes_as_extend(Node *n) {
+ for (; n; n = nextSibling(n)) {
+ if (Getattr(n, "template") && Strcmp(nodeType(n), "class") == 0)
+ continue;
+ /* Fix me: extend is not a feature. Replace with isextendmember? */
+ Setattr(n, "feature:extend", "1");
+ mark_nodes_as_extend(firstChild(n));
}
}
+#line 1382 "y.tab.c" /* yacc.c:339 */
-/* Line 268 of yacc.c */
-#line 1703 "y.tab.c"
-
-/* Enabling traces. */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
+# ifndef YY_NULLPTR
+# if defined __cplusplus && 201103L <= __cplusplus
+# define YY_NULLPTR nullptr
+# else
+# define YY_NULLPTR 0
+# endif
+# endif
/* Enabling verbose error messages. */
#ifdef YYERROR_VERBOSE
# define YYERROR_VERBOSE 0
#endif
-/* Enabling the token table. */
-#ifndef YYTOKEN_TABLE
-# define YYTOKEN_TABLE 0
+/* In a future release of Bison, this section will be replaced
+ by #include "y.tab.h". */
+#ifndef YY_YY_Y_TAB_H_INCLUDED
+# define YY_YY_Y_TAB_H_INCLUDED
+/* Debug traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
#endif
-
-/* Tokens. */
+/* Token type. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
- /* Put the tokens into the symbol table, so that GDB and other debuggers
- know about them. */
- enum yytokentype {
- ID = 258,
- HBLOCK = 259,
- POUND = 260,
- STRING = 261,
- INCLUDE = 262,
- IMPORT = 263,
- INSERT = 264,
- CHARCONST = 265,
- NUM_INT = 266,
- NUM_FLOAT = 267,
- NUM_UNSIGNED = 268,
- NUM_LONG = 269,
- NUM_ULONG = 270,
- NUM_LONGLONG = 271,
- NUM_ULONGLONG = 272,
- NUM_BOOL = 273,
- TYPEDEF = 274,
- TYPE_INT = 275,
- TYPE_UNSIGNED = 276,
- TYPE_SHORT = 277,
- TYPE_LONG = 278,
- TYPE_FLOAT = 279,
- TYPE_DOUBLE = 280,
- TYPE_CHAR = 281,
- TYPE_WCHAR = 282,
- TYPE_VOID = 283,
- TYPE_SIGNED = 284,
- TYPE_BOOL = 285,
- TYPE_COMPLEX = 286,
- TYPE_TYPEDEF = 287,
- TYPE_RAW = 288,
- TYPE_NON_ISO_INT8 = 289,
- TYPE_NON_ISO_INT16 = 290,
- TYPE_NON_ISO_INT32 = 291,
- TYPE_NON_ISO_INT64 = 292,
- LPAREN = 293,
- RPAREN = 294,
- COMMA = 295,
- SEMI = 296,
- EXTERN = 297,
- INIT = 298,
- LBRACE = 299,
- RBRACE = 300,
- PERIOD = 301,
- CONST_QUAL = 302,
- VOLATILE = 303,
- REGISTER = 304,
- STRUCT = 305,
- UNION = 306,
- EQUAL = 307,
- SIZEOF = 308,
- MODULE = 309,
- LBRACKET = 310,
- RBRACKET = 311,
- BEGINFILE = 312,
- ENDOFFILE = 313,
- ILLEGAL = 314,
- CONSTANT = 315,
- NAME = 316,
- RENAME = 317,
- NAMEWARN = 318,
- EXTEND = 319,
- PRAGMA = 320,
- FEATURE = 321,
- VARARGS = 322,
- ENUM = 323,
- CLASS = 324,
- TYPENAME = 325,
- PRIVATE = 326,
- PUBLIC = 327,
- PROTECTED = 328,
- COLON = 329,
- STATIC = 330,
- VIRTUAL = 331,
- FRIEND = 332,
- THROW = 333,
- CATCH = 334,
- EXPLICIT = 335,
- USING = 336,
- NAMESPACE = 337,
- NATIVE = 338,
- INLINE = 339,
- TYPEMAP = 340,
- EXCEPT = 341,
- ECHO = 342,
- APPLY = 343,
- CLEAR = 344,
- SWIGTEMPLATE = 345,
- FRAGMENT = 346,
- WARN = 347,
- LESSTHAN = 348,
- GREATERTHAN = 349,
- DELETE_KW = 350,
- LESSTHANOREQUALTO = 351,
- GREATERTHANOREQUALTO = 352,
- EQUALTO = 353,
- NOTEQUALTO = 354,
- QUESTIONMARK = 355,
- TYPES = 356,
- PARMS = 357,
- NONID = 358,
- DSTAR = 359,
- DCNOT = 360,
- TEMPLATE = 361,
- OPERATOR = 362,
- COPERATOR = 363,
- PARSETYPE = 364,
- PARSEPARM = 365,
- PARSEPARMS = 366,
- CAST = 367,
- LOR = 368,
- LAND = 369,
- OR = 370,
- XOR = 371,
- AND = 372,
- RSHIFT = 373,
- LSHIFT = 374,
- MINUS = 375,
- PLUS = 376,
- MODULO = 377,
- SLASH = 378,
- STAR = 379,
- LNOT = 380,
- NOT = 381,
- UMINUS = 382,
- DCOLON = 383
- };
+ enum yytokentype
+ {
+ ID = 258,
+ HBLOCK = 259,
+ POUND = 260,
+ STRING = 261,
+ WSTRING = 262,
+ INCLUDE = 263,
+ IMPORT = 264,
+ INSERT = 265,
+ CHARCONST = 266,
+ WCHARCONST = 267,
+ NUM_INT = 268,
+ NUM_FLOAT = 269,
+ NUM_UNSIGNED = 270,
+ NUM_LONG = 271,
+ NUM_ULONG = 272,
+ NUM_LONGLONG = 273,
+ NUM_ULONGLONG = 274,
+ NUM_BOOL = 275,
+ TYPEDEF = 276,
+ TYPE_INT = 277,
+ TYPE_UNSIGNED = 278,
+ TYPE_SHORT = 279,
+ TYPE_LONG = 280,
+ TYPE_FLOAT = 281,
+ TYPE_DOUBLE = 282,
+ TYPE_CHAR = 283,
+ TYPE_WCHAR = 284,
+ TYPE_VOID = 285,
+ TYPE_SIGNED = 286,
+ TYPE_BOOL = 287,
+ TYPE_COMPLEX = 288,
+ TYPE_TYPEDEF = 289,
+ TYPE_RAW = 290,
+ TYPE_NON_ISO_INT8 = 291,
+ TYPE_NON_ISO_INT16 = 292,
+ TYPE_NON_ISO_INT32 = 293,
+ TYPE_NON_ISO_INT64 = 294,
+ LPAREN = 295,
+ RPAREN = 296,
+ COMMA = 297,
+ SEMI = 298,
+ EXTERN = 299,
+ INIT = 300,
+ LBRACE = 301,
+ RBRACE = 302,
+ PERIOD = 303,
+ CONST_QUAL = 304,
+ VOLATILE = 305,
+ REGISTER = 306,
+ STRUCT = 307,
+ UNION = 308,
+ EQUAL = 309,
+ SIZEOF = 310,
+ MODULE = 311,
+ LBRACKET = 312,
+ RBRACKET = 313,
+ BEGINFILE = 314,
+ ENDOFFILE = 315,
+ ILLEGAL = 316,
+ CONSTANT = 317,
+ NAME = 318,
+ RENAME = 319,
+ NAMEWARN = 320,
+ EXTEND = 321,
+ PRAGMA = 322,
+ FEATURE = 323,
+ VARARGS = 324,
+ ENUM = 325,
+ CLASS = 326,
+ TYPENAME = 327,
+ PRIVATE = 328,
+ PUBLIC = 329,
+ PROTECTED = 330,
+ COLON = 331,
+ STATIC = 332,
+ VIRTUAL = 333,
+ FRIEND = 334,
+ THROW = 335,
+ CATCH = 336,
+ EXPLICIT = 337,
+ STATIC_ASSERT = 338,
+ CONSTEXPR = 339,
+ THREAD_LOCAL = 340,
+ DECLTYPE = 341,
+ AUTO = 342,
+ NOEXCEPT = 343,
+ OVERRIDE = 344,
+ FINAL = 345,
+ USING = 346,
+ NAMESPACE = 347,
+ NATIVE = 348,
+ INLINE = 349,
+ TYPEMAP = 350,
+ EXCEPT = 351,
+ ECHO = 352,
+ APPLY = 353,
+ CLEAR = 354,
+ SWIGTEMPLATE = 355,
+ FRAGMENT = 356,
+ WARN = 357,
+ LESSTHAN = 358,
+ GREATERTHAN = 359,
+ DELETE_KW = 360,
+ DEFAULT = 361,
+ LESSTHANOREQUALTO = 362,
+ GREATERTHANOREQUALTO = 363,
+ EQUALTO = 364,
+ NOTEQUALTO = 365,
+ ARROW = 366,
+ QUESTIONMARK = 367,
+ TYPES = 368,
+ PARMS = 369,
+ NONID = 370,
+ DSTAR = 371,
+ DCNOT = 372,
+ TEMPLATE = 373,
+ OPERATOR = 374,
+ CONVERSIONOPERATOR = 375,
+ PARSETYPE = 376,
+ PARSEPARM = 377,
+ PARSEPARMS = 378,
+ CAST = 379,
+ LOR = 380,
+ LAND = 381,
+ OR = 382,
+ XOR = 383,
+ AND = 384,
+ LSHIFT = 385,
+ RSHIFT = 386,
+ PLUS = 387,
+ MINUS = 388,
+ STAR = 389,
+ SLASH = 390,
+ MODULO = 391,
+ UMINUS = 392,
+ NOT = 393,
+ LNOT = 394,
+ DCOLON = 395
+ };
#endif
/* Tokens. */
#define ID 258
#define HBLOCK 259
#define POUND 260
#define STRING 261
-#define INCLUDE 262
-#define IMPORT 263
-#define INSERT 264
-#define CHARCONST 265
-#define NUM_INT 266
-#define NUM_FLOAT 267
-#define NUM_UNSIGNED 268
-#define NUM_LONG 269
-#define NUM_ULONG 270
-#define NUM_LONGLONG 271
-#define NUM_ULONGLONG 272
-#define NUM_BOOL 273
-#define TYPEDEF 274
-#define TYPE_INT 275
-#define TYPE_UNSIGNED 276
-#define TYPE_SHORT 277
-#define TYPE_LONG 278
-#define TYPE_FLOAT 279
-#define TYPE_DOUBLE 280
-#define TYPE_CHAR 281
-#define TYPE_WCHAR 282
-#define TYPE_VOID 283
-#define TYPE_SIGNED 284
-#define TYPE_BOOL 285
-#define TYPE_COMPLEX 286
-#define TYPE_TYPEDEF 287
-#define TYPE_RAW 288
-#define TYPE_NON_ISO_INT8 289
-#define TYPE_NON_ISO_INT16 290
-#define TYPE_NON_ISO_INT32 291
-#define TYPE_NON_ISO_INT64 292
-#define LPAREN 293
-#define RPAREN 294
-#define COMMA 295
-#define SEMI 296
-#define EXTERN 297
-#define INIT 298
-#define LBRACE 299
-#define RBRACE 300
-#define PERIOD 301
-#define CONST_QUAL 302
-#define VOLATILE 303
-#define REGISTER 304
-#define STRUCT 305
-#define UNION 306
-#define EQUAL 307
-#define SIZEOF 308
-#define MODULE 309
-#define LBRACKET 310
-#define RBRACKET 311
-#define BEGINFILE 312
-#define ENDOFFILE 313
-#define ILLEGAL 314
-#define CONSTANT 315
-#define NAME 316
-#define RENAME 317
-#define NAMEWARN 318
-#define EXTEND 319
-#define PRAGMA 320
-#define FEATURE 321
-#define VARARGS 322
-#define ENUM 323
-#define CLASS 324
-#define TYPENAME 325
-#define PRIVATE 326
-#define PUBLIC 327
-#define PROTECTED 328
-#define COLON 329
-#define STATIC 330
-#define VIRTUAL 331
-#define FRIEND 332
-#define THROW 333
-#define CATCH 334
-#define EXPLICIT 335
-#define USING 336
-#define NAMESPACE 337
-#define NATIVE 338
-#define INLINE 339
-#define TYPEMAP 340
-#define EXCEPT 341
-#define ECHO 342
-#define APPLY 343
-#define CLEAR 344
-#define SWIGTEMPLATE 345
-#define FRAGMENT 346
-#define WARN 347
-#define LESSTHAN 348
-#define GREATERTHAN 349
-#define DELETE_KW 350
-#define LESSTHANOREQUALTO 351
-#define GREATERTHANOREQUALTO 352
-#define EQUALTO 353
-#define NOTEQUALTO 354
-#define QUESTIONMARK 355
-#define TYPES 356
-#define PARMS 357
-#define NONID 358
-#define DSTAR 359
-#define DCNOT 360
-#define TEMPLATE 361
-#define OPERATOR 362
-#define COPERATOR 363
-#define PARSETYPE 364
-#define PARSEPARM 365
-#define PARSEPARMS 366
-#define CAST 367
-#define LOR 368
-#define LAND 369
-#define OR 370
-#define XOR 371
-#define AND 372
-#define RSHIFT 373
-#define LSHIFT 374
-#define MINUS 375
-#define PLUS 376
-#define MODULO 377
-#define SLASH 378
-#define STAR 379
-#define LNOT 380
-#define NOT 381
-#define UMINUS 382
-#define DCOLON 383
-
-
-
-
+#define WSTRING 262
+#define INCLUDE 263
+#define IMPORT 264
+#define INSERT 265
+#define CHARCONST 266
+#define WCHARCONST 267
+#define NUM_INT 268
+#define NUM_FLOAT 269
+#define NUM_UNSIGNED 270
+#define NUM_LONG 271
+#define NUM_ULONG 272
+#define NUM_LONGLONG 273
+#define NUM_ULONGLONG 274
+#define NUM_BOOL 275
+#define TYPEDEF 276
+#define TYPE_INT 277
+#define TYPE_UNSIGNED 278
+#define TYPE_SHORT 279
+#define TYPE_LONG 280
+#define TYPE_FLOAT 281
+#define TYPE_DOUBLE 282
+#define TYPE_CHAR 283
+#define TYPE_WCHAR 284
+#define TYPE_VOID 285
+#define TYPE_SIGNED 286
+#define TYPE_BOOL 287
+#define TYPE_COMPLEX 288
+#define TYPE_TYPEDEF 289
+#define TYPE_RAW 290
+#define TYPE_NON_ISO_INT8 291
+#define TYPE_NON_ISO_INT16 292
+#define TYPE_NON_ISO_INT32 293
+#define TYPE_NON_ISO_INT64 294
+#define LPAREN 295
+#define RPAREN 296
+#define COMMA 297
+#define SEMI 298
+#define EXTERN 299
+#define INIT 300
+#define LBRACE 301
+#define RBRACE 302
+#define PERIOD 303
+#define CONST_QUAL 304
+#define VOLATILE 305
+#define REGISTER 306
+#define STRUCT 307
+#define UNION 308
+#define EQUAL 309
+#define SIZEOF 310
+#define MODULE 311
+#define LBRACKET 312
+#define RBRACKET 313
+#define BEGINFILE 314
+#define ENDOFFILE 315
+#define ILLEGAL 316
+#define CONSTANT 317
+#define NAME 318
+#define RENAME 319
+#define NAMEWARN 320
+#define EXTEND 321
+#define PRAGMA 322
+#define FEATURE 323
+#define VARARGS 324
+#define ENUM 325
+#define CLASS 326
+#define TYPENAME 327
+#define PRIVATE 328
+#define PUBLIC 329
+#define PROTECTED 330
+#define COLON 331
+#define STATIC 332
+#define VIRTUAL 333
+#define FRIEND 334
+#define THROW 335
+#define CATCH 336
+#define EXPLICIT 337
+#define STATIC_ASSERT 338
+#define CONSTEXPR 339
+#define THREAD_LOCAL 340
+#define DECLTYPE 341
+#define AUTO 342
+#define NOEXCEPT 343
+#define OVERRIDE 344
+#define FINAL 345
+#define USING 346
+#define NAMESPACE 347
+#define NATIVE 348
+#define INLINE 349
+#define TYPEMAP 350
+#define EXCEPT 351
+#define ECHO 352
+#define APPLY 353
+#define CLEAR 354
+#define SWIGTEMPLATE 355
+#define FRAGMENT 356
+#define WARN 357
+#define LESSTHAN 358
+#define GREATERTHAN 359
+#define DELETE_KW 360
+#define DEFAULT 361
+#define LESSTHANOREQUALTO 362
+#define GREATERTHANOREQUALTO 363
+#define EQUALTO 364
+#define NOTEQUALTO 365
+#define ARROW 366
+#define QUESTIONMARK 367
+#define TYPES 368
+#define PARMS 369
+#define NONID 370
+#define DSTAR 371
+#define DCNOT 372
+#define TEMPLATE 373
+#define OPERATOR 374
+#define CONVERSIONOPERATOR 375
+#define PARSETYPE 376
+#define PARSEPARM 377
+#define PARSEPARMS 378
+#define CAST 379
+#define LOR 380
+#define LAND 381
+#define OR 382
+#define XOR 383
+#define AND 384
+#define LSHIFT 385
+#define RSHIFT 386
+#define PLUS 387
+#define MINUS 388
+#define STAR 389
+#define SLASH 390
+#define MODULO 391
+#define UMINUS 392
+#define NOT 393
+#define LNOT 394
+#define DCOLON 395
+
+/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-{
-/* Line 293 of yacc.c */
-#line 1647 "parser.y"
+union YYSTYPE
+{
+#line 1341 "parser.y" /* yacc.c:355 */
- char *id;
+ const char *id;
List *bases;
struct Define {
String *val;
String *bitfield;
Parm *throws;
String *throwf;
+ String *nexcept;
} dtype;
struct {
- char *type;
+ const char *type;
String *filename;
int line;
} loc;
short have_parms;
ParmList *throws;
String *throwf;
+ String *nexcept;
} decl;
Parm *tparms;
struct {
int intvalue;
Node *node;
+#line 1747 "y.tab.c" /* yacc.c:355 */
+};
-
-/* Line 293 of yacc.c */
-#line 2040 "y.tab.c"
-} YYSTYPE;
+typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
#endif
-/* Copy the second part of user declarations. */
+extern YYSTYPE yylval;
+
+int yyparse (void);
+
+#endif /* !YY_YY_Y_TAB_H_INCLUDED */
+/* Copy the second part of user declarations. */
-/* Line 343 of yacc.c */
-#line 2052 "y.tab.c"
+#line 1764 "y.tab.c" /* yacc.c:358 */
#ifdef short
# undef short
#ifdef YYTYPE_INT8
typedef YYTYPE_INT8 yytype_int8;
-#elif (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
-typedef signed char yytype_int8;
#else
-typedef short int yytype_int8;
+typedef signed char yytype_int8;
#endif
#ifdef YYTYPE_UINT16
# define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
# define YYSIZE_T size_t
-# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
+# elif ! defined YYSIZE_T
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# else
# if defined YYENABLE_NLS && YYENABLE_NLS
# if ENABLE_NLS
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-# define YY_(msgid) dgettext ("bison-runtime", msgid)
+# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
# endif
# endif
# ifndef YY_
-# define YY_(msgid) msgid
+# define YY_(Msgid) Msgid
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__ \
+ && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
+ || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+# define YY_ATTRIBUTE(Spec) /* empty */
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
+#if !defined _Noreturn \
+ && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+# define _Noreturn __declspec (noreturn)
+# else
+# define _Noreturn YY_ATTRIBUTE ((__noreturn__))
# endif
#endif
/* Suppress unused-variable warnings by "using" E. */
#if ! defined lint || defined __GNUC__
-# define YYUSE(e) ((void) (e))
+# define YYUSE(E) ((void) (E))
#else
-# define YYUSE(e) /* empty */
+# define YYUSE(E) /* empty */
#endif
-/* Identity function, used to suppress warnings about constant conditions. */
-#ifndef lint
-# define YYID(n) (n)
-#else
-#if (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
-static int
-YYID (int yyi)
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized. */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+ _Pragma ("GCC diagnostic push") \
+ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+ _Pragma ("GCC diagnostic pop")
#else
-static int
-YYID (yyi)
- int yyi;
+# define YY_INITIAL_VALUE(Value) Value
#endif
-{
- return yyi;
-}
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
#if ! defined yyoverflow || YYERROR_VERBOSE
# define alloca _alloca
# else
# define YYSTACK_ALLOC alloca
-# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
+# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+ /* Use EXIT_SUCCESS as a witness for stdlib.h. */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# endif
# ifdef YYSTACK_ALLOC
- /* Pacify GCC's `empty if-body' warning. */
-# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
+ /* Pacify GCC's 'empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
# ifndef YYSTACK_ALLOC_MAXIMUM
/* The OS might guarantee only one guard page at the bottom of the stack,
and a page size can be as small as 4096 bytes. So we cannot safely
# endif
# if (defined __cplusplus && ! defined EXIT_SUCCESS \
&& ! ((defined YYMALLOC || defined malloc) \
- && (defined YYFREE || defined free)))
+ && (defined YYFREE || defined free)))
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# ifndef YYMALLOC
# define YYMALLOC malloc
-# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
+# if ! defined malloc && ! defined EXIT_SUCCESS
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE free
-# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
+# if ! defined free && ! defined EXIT_SUCCESS
void free (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
#if (! defined yyoverflow \
&& (! defined __cplusplus \
- || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
/* A type that is properly aligned for any stack member. */
union yyalloc
elements in the stack, and YYPTR gives the new location of the
stack. Advance YYPTR to a properly aligned location for the next
stack. */
-# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
- do \
- { \
- YYSIZE_T yynewbytes; \
- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
- Stack = &yyptr->Stack_alloc; \
- yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
- yyptr += yynewbytes / sizeof (*yyptr); \
- } \
- while (YYID (0))
+# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
+ do \
+ { \
+ YYSIZE_T yynewbytes; \
+ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
+ Stack = &yyptr->Stack_alloc; \
+ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+ yyptr += yynewbytes / sizeof (*yyptr); \
+ } \
+ while (0)
#endif
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from FROM to TO. The source and destination do
+/* Copy COUNT objects from SRC to DST. The source and destination do
not overlap. */
# ifndef YYCOPY
# if defined __GNUC__ && 1 < __GNUC__
-# define YYCOPY(To, From, Count) \
- __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+# define YYCOPY(Dst, Src, Count) \
+ __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
# else
-# define YYCOPY(To, From, Count) \
- do \
- { \
- YYSIZE_T yyi; \
- for (yyi = 0; yyi < (Count); yyi++) \
- (To)[yyi] = (From)[yyi]; \
- } \
- while (YYID (0))
+# define YYCOPY(Dst, Src, Count) \
+ do \
+ { \
+ YYSIZE_T yyi; \
+ for (yyi = 0; yyi < (Count); yyi++) \
+ (Dst)[yyi] = (Src)[yyi]; \
+ } \
+ while (0)
# endif
# endif
#endif /* !YYCOPY_NEEDED */
/* YYFINAL -- State number of the termination state. */
-#define YYFINAL 55
+#define YYFINAL 60
/* YYLAST -- Last index in YYTABLE. */
-#define YYLAST 3845
+#define YYLAST 5023
/* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS 129
+#define YYNTOKENS 141
/* YYNNTS -- Number of nonterminals. */
-#define YYNNTS 149
+#define YYNNTS 169
/* YYNRULES -- Number of rules. */
-#define YYNRULES 470
-/* YYNRULES -- Number of states. */
-#define YYNSTATES 912
+#define YYNRULES 574
+/* YYNSTATES -- Number of states. */
+#define YYNSTATES 1122
-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
+/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
+ by yylex, with out-of-bounds checking. */
#define YYUNDEFTOK 2
-#define YYMAXUTOK 383
+#define YYMAXUTOK 395
-#define YYTRANSLATE(YYX) \
+#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex, without out-of-bounds checking. */
static const yytype_uint8 yytranslate[] =
{
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
- 125, 126, 127, 128
+ 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
+ 135, 136, 137, 138, 139, 140
};
#if YYDEBUG
-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
- YYRHS. */
-static const yytype_uint16 yyprhs[] =
-{
- 0, 0, 3, 5, 9, 12, 16, 19, 25, 29,
- 32, 34, 36, 38, 40, 42, 44, 46, 49, 51,
- 53, 55, 57, 59, 61, 63, 65, 67, 69, 71,
- 73, 75, 77, 79, 81, 83, 85, 87, 89, 91,
- 92, 100, 106, 110, 116, 122, 126, 129, 132, 138,
- 141, 147, 150, 155, 157, 159, 167, 175, 181, 182,
- 190, 192, 194, 197, 200, 202, 208, 214, 220, 224,
- 229, 233, 241, 250, 256, 260, 262, 264, 268, 270,
- 275, 283, 290, 292, 294, 302, 312, 321, 332, 338,
- 346, 353, 362, 364, 366, 372, 377, 383, 391, 393,
- 397, 404, 411, 420, 422, 425, 429, 431, 434, 438,
- 445, 451, 461, 464, 466, 468, 470, 471, 478, 484,
- 486, 491, 493, 495, 498, 504, 511, 516, 524, 534,
- 541, 543, 545, 547, 549, 551, 553, 554, 564, 565,
- 575, 577, 581, 586, 587, 594, 598, 600, 602, 604,
- 606, 608, 610, 612, 615, 617, 619, 621, 625, 627,
- 631, 636, 637, 644, 645, 651, 657, 660, 661, 668,
- 670, 672, 673, 677, 679, 681, 683, 685, 687, 689,
- 691, 693, 697, 699, 701, 703, 705, 707, 709, 711,
- 713, 715, 722, 729, 737, 746, 755, 765, 773, 779,
- 782, 785, 788, 789, 797, 798, 805, 807, 809, 811,
- 813, 815, 817, 819, 821, 823, 825, 827, 830, 833,
- 836, 841, 844, 850, 852, 855, 857, 859, 861, 863,
- 865, 867, 869, 872, 874, 878, 880, 883, 891, 895,
- 897, 900, 902, 906, 908, 910, 912, 915, 921, 924,
- 927, 929, 932, 935, 937, 939, 941, 943, 946, 950,
- 952, 955, 959, 964, 970, 975, 977, 980, 984, 989,
- 995, 999, 1004, 1009, 1011, 1014, 1019, 1024, 1030, 1034,
- 1039, 1044, 1046, 1049, 1052, 1056, 1058, 1061, 1063, 1066,
- 1070, 1075, 1079, 1084, 1087, 1091, 1095, 1100, 1104, 1108,
- 1111, 1114, 1116, 1118, 1121, 1123, 1125, 1127, 1129, 1132,
- 1134, 1137, 1141, 1143, 1145, 1147, 1150, 1153, 1155, 1157,
- 1160, 1162, 1164, 1167, 1169, 1171, 1173, 1175, 1177, 1179,
- 1181, 1183, 1185, 1187, 1189, 1191, 1193, 1195, 1196, 1199,
- 1201, 1203, 1205, 1207, 1213, 1217, 1221, 1223, 1225, 1229,
- 1231, 1233, 1235, 1237, 1239, 1245, 1247, 1249, 1253, 1258,
- 1264, 1270, 1277, 1280, 1283, 1285, 1287, 1289, 1291, 1293,
- 1295, 1297, 1299, 1303, 1307, 1311, 1315, 1319, 1323, 1327,
- 1331, 1335, 1339, 1343, 1347, 1351, 1355, 1359, 1363, 1369,
- 1372, 1375, 1378, 1381, 1384, 1386, 1387, 1391, 1393, 1395,
- 1399, 1400, 1404, 1405, 1411, 1413, 1415, 1417, 1419, 1421,
- 1423, 1425, 1427, 1429, 1431, 1433, 1438, 1444, 1446, 1450,
- 1454, 1459, 1464, 1468, 1471, 1473, 1475, 1479, 1482, 1486,
- 1488, 1490, 1492, 1494, 1496, 1499, 1504, 1506, 1510, 1512,
- 1516, 1520, 1523, 1526, 1529, 1532, 1535, 1540, 1542, 1546,
- 1548, 1552, 1556, 1559, 1562, 1565, 1568, 1570, 1572, 1574,
- 1576, 1580, 1582, 1586, 1592, 1594, 1598, 1602, 1608, 1610,
- 1612
-};
-
-/* YYRHS -- A `-1'-separated list of the rules' RHS. */
-static const yytype_int16 yyrhs[] =
-{
- 130, 0, -1, 131, -1, 109, 215, 41, -1, 109,
- 1, -1, 110, 215, 41, -1, 110, 1, -1, 111,
- 38, 212, 39, 41, -1, 111, 1, 41, -1, 131,
- 132, -1, 277, -1, 133, -1, 170, -1, 178, -1,
- 41, -1, 1, -1, 177, -1, 1, 108, -1, 134,
- -1, 136, -1, 137, -1, 138, -1, 139, -1, 140,
- -1, 143, -1, 144, -1, 147, -1, 148, -1, 149,
- -1, 150, -1, 151, -1, 152, -1, 155, -1, 157,
- -1, 160, -1, 162, -1, 167, -1, 168, -1, 169,
- -1, -1, 64, 274, 267, 44, 135, 195, 45, -1,
- 88, 166, 44, 164, 45, -1, 89, 164, 41, -1,
- 60, 3, 52, 237, 41, -1, 60, 231, 223, 220,
- 41, -1, 60, 1, 41, -1, 87, 4, -1, 87,
- 272, -1, 86, 38, 3, 39, 44, -1, 86, 44,
- -1, 86, 38, 3, 39, 41, -1, 86, 41, -1,
- 272, 44, 215, 45, -1, 272, -1, 141, -1, 91,
- 38, 142, 40, 275, 39, 4, -1, 91, 38, 142,
- 40, 275, 39, 44, -1, 91, 38, 142, 39, 41,
- -1, -1, 146, 274, 272, 57, 145, 131, 58, -1,
- 7, -1, 8, -1, 84, 4, -1, 84, 44, -1,
- 4, -1, 9, 38, 265, 39, 272, -1, 9, 38,
- 265, 39, 4, -1, 9, 38, 265, 39, 44, -1,
- 54, 274, 265, -1, 61, 38, 265, 39, -1, 61,
- 38, 39, -1, 83, 38, 3, 39, 211, 3, 41,
- -1, 83, 38, 3, 39, 211, 231, 223, 41, -1,
- 65, 154, 3, 52, 153, -1, 65, 154, 3, -1,
- 272, -1, 4, -1, 38, 3, 39, -1, 277, -1,
- 156, 223, 265, 41, -1, 156, 38, 275, 39, 223,
- 259, 41, -1, 156, 38, 275, 39, 272, 41, -1,
- 62, -1, 63, -1, 66, 38, 265, 39, 223, 259,
- 158, -1, 66, 38, 265, 40, 276, 39, 223, 259,
- 41, -1, 66, 38, 265, 159, 39, 223, 259, 158,
- -1, 66, 38, 265, 40, 276, 159, 39, 223, 259,
- 41, -1, 66, 38, 265, 39, 158, -1, 66, 38,
- 265, 40, 276, 39, 41, -1, 66, 38, 265, 159,
- 39, 158, -1, 66, 38, 265, 40, 276, 159, 39,
- 41, -1, 273, -1, 41, -1, 102, 38, 212, 39,
- 41, -1, 40, 265, 52, 276, -1, 40, 265, 52,
- 276, 159, -1, 67, 38, 161, 39, 223, 259, 41,
- -1, 212, -1, 11, 40, 215, -1, 85, 38, 163,
- 39, 164, 273, -1, 85, 38, 163, 39, 164, 41,
- -1, 85, 38, 163, 39, 164, 52, 166, 41, -1,
- 275, -1, 166, 165, -1, 40, 166, 165, -1, 277,
- -1, 231, 222, -1, 38, 212, 39, -1, 38, 212,
- 39, 38, 212, 39, -1, 101, 38, 212, 39, 158,
- -1, 90, 38, 266, 39, 270, 93, 216, 94, 41,
- -1, 92, 272, -1, 172, -1, 176, -1, 175, -1,
- -1, 42, 272, 44, 171, 131, 45, -1, 211, 231,
- 223, 174, 173, -1, 41, -1, 40, 223, 174, 173,
- -1, 44, -1, 220, -1, 229, 220, -1, 78, 38,
- 212, 39, 220, -1, 229, 78, 38, 212, 39, 220,
- -1, 211, 68, 3, 41, -1, 211, 68, 239, 44,
- 241, 45, 41, -1, 211, 68, 239, 44, 241, 45,
- 223, 174, 173, -1, 211, 231, 38, 212, 39, 260,
- -1, 179, -1, 183, -1, 184, -1, 191, -1, 192,
- -1, 202, -1, -1, 211, 257, 267, 248, 44, 180,
- 195, 45, 182, -1, -1, 211, 257, 44, 181, 195,
- 45, 223, 174, 173, -1, 41, -1, 223, 174, 173,
- -1, 211, 257, 267, 41, -1, -1, 106, 93, 187,
- 94, 185, 186, -1, 106, 257, 267, -1, 172, -1,
- 179, -1, 199, -1, 184, -1, 183, -1, 201, -1,
- 188, -1, 189, 190, -1, 277, -1, 256, -1, 215,
- -1, 40, 189, 190, -1, 277, -1, 81, 267, 41,
- -1, 81, 82, 267, 41, -1, -1, 82, 267, 44,
- 193, 131, 45, -1, -1, 82, 44, 194, 131, 45,
- -1, 82, 3, 52, 267, 41, -1, 198, 195, -1,
- -1, 64, 44, 196, 195, 45, 195, -1, 144, -1,
- 277, -1, -1, 1, 197, 195, -1, 170, -1, 199,
- -1, 200, -1, 203, -1, 207, -1, 201, -1, 183,
- -1, 204, -1, 211, 267, 41, -1, 191, -1, 184,
- -1, 202, -1, 168, -1, 169, -1, 210, -1, 143,
- -1, 167, -1, 41, -1, 211, 231, 38, 212, 39,
- 260, -1, 126, 269, 38, 212, 39, 208, -1, 76,
- 126, 269, 38, 212, 39, 209, -1, 211, 108, 231,
- 228, 38, 212, 39, 209, -1, 211, 108, 231, 117,
- 38, 212, 39, 209, -1, 211, 108, 231, 228, 117,
- 38, 212, 39, 209, -1, 211, 108, 231, 38, 212,
- 39, 209, -1, 79, 38, 212, 39, 44, -1, 72,
- 74, -1, 71, 74, -1, 73, 74, -1, -1, 211,
- 257, 267, 248, 44, 205, 182, -1, -1, 211, 257,
- 248, 44, 206, 182, -1, 152, -1, 138, -1, 150,
- -1, 155, -1, 157, -1, 160, -1, 148, -1, 162,
- -1, 136, -1, 137, -1, 139, -1, 259, 41, -1,
- 259, 44, -1, 259, 41, -1, 259, 52, 237, 41,
- -1, 259, 44, -1, 211, 231, 74, 244, 41, -1,
- 42, -1, 42, 272, -1, 75, -1, 19, -1, 76,
- -1, 77, -1, 80, -1, 277, -1, 213, -1, 215,
- 214, -1, 277, -1, 40, 215, 214, -1, 277, -1,
- 232, 221, -1, 106, 93, 257, 94, 257, 267, 220,
- -1, 46, 46, 46, -1, 217, -1, 219, 218, -1,
- 277, -1, 40, 219, 218, -1, 277, -1, 215, -1,
- 245, -1, 52, 237, -1, 52, 237, 55, 244, 56,
- -1, 52, 44, -1, 74, 244, -1, 277, -1, 223,
- 220, -1, 226, 220, -1, 220, -1, 223, -1, 226,
- -1, 277, -1, 228, 224, -1, 228, 117, 224, -1,
- 225, -1, 117, 224, -1, 267, 104, 224, -1, 228,
- 267, 104, 224, -1, 228, 267, 104, 117, 224, -1,
- 267, 104, 117, 224, -1, 267, -1, 126, 267, -1,
- 38, 267, 39, -1, 38, 228, 224, 39, -1, 38,
- 267, 104, 224, 39, -1, 224, 55, 56, -1, 224,
- 55, 244, 56, -1, 224, 38, 212, 39, -1, 267,
- -1, 126, 267, -1, 38, 228, 225, 39, -1, 38,
- 117, 225, 39, -1, 38, 267, 104, 225, 39, -1,
- 225, 55, 56, -1, 225, 55, 244, 56, -1, 225,
- 38, 212, 39, -1, 228, -1, 228, 227, -1, 228,
- 117, -1, 228, 117, 227, -1, 227, -1, 117, 227,
- -1, 117, -1, 267, 104, -1, 228, 267, 104, -1,
- 228, 267, 104, 227, -1, 227, 55, 56, -1, 227,
- 55, 244, 56, -1, 55, 56, -1, 55, 244, 56,
- -1, 38, 226, 39, -1, 227, 38, 212, 39, -1,
- 38, 212, 39, -1, 124, 229, 228, -1, 124, 228,
- -1, 124, 229, -1, 124, -1, 230, -1, 230, 229,
- -1, 47, -1, 48, -1, 49, -1, 232, -1, 229,
- 233, -1, 233, -1, 233, 229, -1, 229, 233, 229,
- -1, 234, -1, 30, -1, 28, -1, 32, 264, -1,
- 68, 267, -1, 33, -1, 267, -1, 257, 267, -1,
- 235, -1, 236, -1, 236, 235, -1, 20, -1, 22,
- -1, 23, -1, 26, -1, 27, -1, 24, -1, 25,
- -1, 29, -1, 21, -1, 31, -1, 34, -1, 35,
- -1, 36, -1, 37, -1, -1, 238, 244, -1, 3,
- -1, 277, -1, 138, -1, 277, -1, 241, 40, 240,
- 242, 240, -1, 241, 40, 240, -1, 240, 242, 240,
- -1, 240, -1, 3, -1, 3, 52, 243, -1, 244,
- -1, 245, -1, 231, -1, 246, -1, 272, -1, 53,
- 38, 231, 221, 39, -1, 247, -1, 10, -1, 38,
- 244, 39, -1, 38, 244, 39, 244, -1, 38, 244,
- 228, 39, 244, -1, 38, 244, 117, 39, 244, -1,
- 38, 244, 228, 117, 39, 244, -1, 117, 244, -1,
- 124, 244, -1, 11, -1, 12, -1, 13, -1, 14,
- -1, 15, -1, 16, -1, 17, -1, 18, -1, 244,
- 121, 244, -1, 244, 120, 244, -1, 244, 124, 244,
- -1, 244, 123, 244, -1, 244, 122, 244, -1, 244,
- 117, 244, -1, 244, 115, 244, -1, 244, 116, 244,
- -1, 244, 119, 244, -1, 244, 118, 244, -1, 244,
- 114, 244, -1, 244, 113, 244, -1, 244, 98, 244,
- -1, 244, 99, 244, -1, 244, 97, 244, -1, 244,
- 96, 244, -1, 244, 100, 244, 74, 244, -1, 120,
- 244, -1, 121, 244, -1, 126, 244, -1, 125, 244,
- -1, 231, 38, -1, 249, -1, -1, 74, 250, 251,
- -1, 277, -1, 252, -1, 251, 40, 252, -1, -1,
- 258, 253, 267, -1, -1, 258, 255, 254, 258, 267,
- -1, 72, -1, 71, -1, 73, -1, 69, -1, 70,
- -1, 256, -1, 50, -1, 51, -1, 76, -1, 277,
- -1, 229, -1, 78, 38, 212, 39, -1, 229, 78,
- 38, 212, 39, -1, 277, -1, 259, 261, 41, -1,
- 259, 261, 44, -1, 38, 212, 39, 41, -1, 38,
- 212, 39, 44, -1, 52, 237, 41, -1, 74, 262,
- -1, 277, -1, 263, -1, 262, 40, 263, -1, 267,
- 38, -1, 93, 216, 94, -1, 277, -1, 3, -1,
- 272, -1, 265, -1, 277, -1, 269, 268, -1, 103,
- 128, 269, 268, -1, 269, -1, 103, 128, 269, -1,
- 107, -1, 103, 128, 107, -1, 128, 269, 268, -1,
- 128, 269, -1, 128, 107, -1, 105, 269, -1, 3,
- 264, -1, 3, 271, -1, 103, 128, 3, 271, -1,
- 3, -1, 103, 128, 3, -1, 107, -1, 103, 128,
- 107, -1, 128, 3, 271, -1, 128, 3, -1, 128,
- 107, -1, 105, 3, -1, 272, 6, -1, 6, -1,
- 272, -1, 44, -1, 4, -1, 38, 275, 39, -1,
- 277, -1, 265, 52, 276, -1, 265, 52, 276, 40,
- 275, -1, 265, -1, 265, 40, 275, -1, 265, 52,
- 141, -1, 265, 52, 141, 40, 275, -1, 272, -1,
- 246, -1, -1
-};
-
-/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
+ /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] =
{
- 0, 1802, 1802, 1815, 1819, 1822, 1825, 1828, 1831, 1836,
- 1841, 1846, 1847, 1848, 1849, 1850, 1856, 1872, 1882, 1883,
- 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893,
- 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1909,
- 1909, 1995, 2005, 2016, 2037, 2059, 2070, 2079, 2098, 2104,
- 2110, 2115, 2122, 2129, 2133, 2146, 2155, 2170, 2183, 2183,
- 2238, 2239, 2246, 2265, 2296, 2300, 2310, 2315, 2333, 2373,
- 2379, 2392, 2398, 2424, 2430, 2437, 2438, 2441, 2442, 2450,
- 2496, 2542, 2553, 2556, 2583, 2589, 2595, 2601, 2609, 2615,
- 2621, 2627, 2635, 2636, 2637, 2640, 2645, 2655, 2691, 2692,
- 2727, 2744, 2752, 2765, 2790, 2796, 2800, 2803, 2814, 2819,
- 2832, 2844, 3118, 3128, 3135, 3136, 3140, 3140, 3171, 3232,
- 3236, 3258, 3264, 3270, 3276, 3282, 3295, 3310, 3320, 3398,
- 3449, 3450, 3451, 3452, 3453, 3454, 3459, 3459, 3708, 3708,
- 3831, 3832, 3844, 3862, 3862, 4151, 4157, 4160, 4163, 4166,
- 4169, 4172, 4177, 4207, 4211, 4214, 4217, 4222, 4226, 4231,
- 4241, 4272, 4272, 4301, 4301, 4323, 4350, 4365, 4365, 4375,
- 4376, 4377, 4377, 4393, 4394, 4411, 4412, 4413, 4414, 4415,
- 4416, 4417, 4418, 4419, 4420, 4421, 4422, 4423, 4424, 4425,
- 4426, 4435, 4460, 4484, 4515, 4530, 4548, 4567, 4586, 4593,
- 4600, 4608, 4629, 4629, 4656, 4656, 4692, 4695, 4699, 4702,
- 4703, 4704, 4705, 4706, 4707, 4708, 4709, 4712, 4717, 4724,
- 4732, 4740, 4751, 4757, 4758, 4766, 4767, 4768, 4769, 4770,
- 4771, 4778, 4789, 4793, 4796, 4800, 4804, 4814, 4822, 4830,
- 4843, 4847, 4850, 4854, 4858, 4886, 4894, 4905, 4919, 4928,
- 4936, 4946, 4950, 4954, 4961, 4978, 4995, 5003, 5011, 5020,
- 5024, 5033, 5044, 5056, 5066, 5079, 5086, 5094, 5110, 5118,
- 5129, 5140, 5151, 5170, 5178, 5195, 5203, 5210, 5221, 5232,
- 5243, 5262, 5268, 5274, 5281, 5290, 5293, 5302, 5309, 5316,
- 5326, 5337, 5348, 5359, 5366, 5373, 5376, 5393, 5403, 5410,
- 5416, 5421, 5427, 5431, 5437, 5438, 5439, 5445, 5451, 5455,
- 5456, 5460, 5467, 5470, 5471, 5472, 5473, 5474, 5476, 5479,
- 5484, 5509, 5512, 5566, 5570, 5574, 5578, 5582, 5586, 5590,
- 5594, 5598, 5602, 5606, 5610, 5614, 5618, 5624, 5624, 5650,
- 5651, 5654, 5655, 5659, 5665, 5668, 5672, 5677, 5685, 5697,
- 5712, 5713, 5732, 5733, 5737, 5742, 5743, 5757, 5764, 5781,
- 5788, 5795, 5803, 5807, 5813, 5814, 5815, 5816, 5817, 5818,
- 5819, 5820, 5823, 5827, 5831, 5835, 5839, 5843, 5847, 5851,
- 5855, 5859, 5863, 5867, 5871, 5875, 5889, 5893, 5897, 5903,
- 5907, 5911, 5915, 5919, 5935, 5940, 5940, 5941, 5944, 5961,
- 5970, 5970, 5986, 5986, 6002, 6003, 6004, 6008, 6012, 6018,
- 6021, 6025, 6031, 6032, 6035, 6040, 6045, 6050, 6057, 6064,
- 6071, 6079, 6087, 6095, 6096, 6099, 6100, 6103, 6109, 6115,
- 6118, 6119, 6122, 6123, 6126, 6131, 6135, 6138, 6141, 6144,
- 6149, 6153, 6156, 6163, 6169, 6178, 6183, 6187, 6190, 6193,
- 6196, 6201, 6205, 6208, 6211, 6217, 6222, 6225, 6228, 6232,
- 6237, 6250, 6254, 6259, 6265, 6269, 6274, 6278, 6285, 6288,
- 6293
+ 0, 1506, 1506, 1518, 1522, 1525, 1528, 1531, 1534, 1539,
+ 1544, 1549, 1550, 1551, 1552, 1553, 1563, 1579, 1589, 1590,
+ 1591, 1592, 1593, 1594, 1595, 1596, 1597, 1598, 1599, 1600,
+ 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1616,
+ 1616, 1698, 1708, 1719, 1740, 1762, 1773, 1782, 1801, 1807,
+ 1813, 1818, 1825, 1832, 1836, 1849, 1858, 1873, 1886, 1886,
+ 1942, 1943, 1950, 1969, 2000, 2004, 2014, 2019, 2037, 2080,
+ 2086, 2099, 2105, 2131, 2137, 2144, 2145, 2148, 2149, 2156,
+ 2202, 2248, 2259, 2262, 2289, 2295, 2301, 2307, 2315, 2321,
+ 2327, 2333, 2341, 2342, 2343, 2346, 2351, 2361, 2397, 2398,
+ 2433, 2450, 2458, 2471, 2496, 2502, 2506, 2509, 2520, 2525,
+ 2538, 2550, 2848, 2858, 2865, 2866, 2870, 2870, 2895, 2901,
+ 2913, 2931, 2999, 3057, 3061, 3084, 3088, 3099, 3106, 3113,
+ 3120, 3129, 3130, 3131, 3135, 3136, 3137, 3148, 3153, 3158,
+ 3165, 3171, 3176, 3179, 3179, 3192, 3195, 3198, 3207, 3210,
+ 3217, 3239, 3268, 3366, 3418, 3419, 3420, 3421, 3422, 3423,
+ 3428, 3428, 3676, 3676, 3823, 3824, 3836, 3854, 3854, 4113,
+ 4119, 4125, 4128, 4131, 4134, 4137, 4140, 4143, 4148, 4184,
+ 4188, 4191, 4194, 4199, 4203, 4208, 4218, 4249, 4249, 4278,
+ 4278, 4300, 4327, 4344, 4349, 4344, 4357, 4358, 4359, 4359,
+ 4375, 4376, 4393, 4394, 4395, 4396, 4397, 4398, 4399, 4400,
+ 4401, 4402, 4403, 4404, 4405, 4406, 4407, 4408, 4409, 4418,
+ 4446, 4473, 4504, 4519, 4536, 4554, 4573, 4592, 4599, 4606,
+ 4613, 4621, 4629, 4632, 4636, 4639, 4640, 4641, 4642, 4643,
+ 4644, 4645, 4646, 4649, 4656, 4663, 4672, 4681, 4690, 4702,
+ 4705, 4708, 4709, 4713, 4715, 4723, 4735, 4736, 4737, 4738,
+ 4739, 4740, 4741, 4742, 4743, 4744, 4745, 4746, 4747, 4748,
+ 4749, 4750, 4751, 4752, 4753, 4754, 4761, 4772, 4776, 4779,
+ 4783, 4787, 4797, 4805, 4813, 4826, 4830, 4833, 4837, 4841,
+ 4869, 4877, 4889, 4904, 4914, 4923, 4934, 4938, 4942, 4949,
+ 4966, 4983, 4991, 4999, 5008, 5017, 5021, 5030, 5041, 5052,
+ 5064, 5074, 5088, 5096, 5105, 5114, 5118, 5127, 5138, 5149,
+ 5161, 5171, 5181, 5192, 5205, 5212, 5220, 5236, 5244, 5255,
+ 5266, 5277, 5296, 5304, 5321, 5329, 5336, 5343, 5354, 5365,
+ 5376, 5396, 5417, 5423, 5429, 5436, 5443, 5452, 5461, 5464,
+ 5473, 5482, 5489, 5496, 5503, 5513, 5524, 5535, 5546, 5553,
+ 5560, 5563, 5580, 5590, 5597, 5603, 5608, 5614, 5618, 5624,
+ 5625, 5626, 5632, 5638, 5642, 5643, 5647, 5654, 5657, 5658,
+ 5662, 5663, 5665, 5668, 5671, 5676, 5687, 5712, 5715, 5769,
+ 5773, 5777, 5781, 5785, 5789, 5793, 5797, 5801, 5805, 5809,
+ 5813, 5817, 5821, 5827, 5827, 5841, 5846, 5849, 5855, 5868,
+ 5882, 5883, 5886, 5887, 5891, 5897, 5900, 5904, 5909, 5917,
+ 5929, 5944, 5945, 5964, 5965, 5969, 5974, 5979, 5980, 5985,
+ 5998, 6013, 6020, 6037, 6044, 6051, 6058, 6066, 6074, 6078,
+ 6082, 6088, 6089, 6090, 6091, 6092, 6093, 6094, 6095, 6098,
+ 6102, 6106, 6110, 6114, 6118, 6122, 6126, 6130, 6134, 6138,
+ 6142, 6146, 6150, 6164, 6168, 6172, 6178, 6182, 6186, 6190,
+ 6194, 6210, 6215, 6218, 6223, 6228, 6228, 6229, 6232, 6249,
+ 6258, 6258, 6276, 6276, 6294, 6295, 6296, 6300, 6304, 6308,
+ 6312, 6318, 6321, 6325, 6331, 6332, 6335, 6338, 6341, 6344,
+ 6349, 6354, 6359, 6364, 6369, 6376, 6382, 6386, 6390, 6398,
+ 6406, 6414, 6423, 6432, 6439, 6448, 6449, 6452, 6453, 6454,
+ 6455, 6458, 6470, 6476, 6485, 6486, 6487, 6490, 6491, 6492,
+ 6495, 6496, 6499, 6504, 6508, 6511, 6514, 6517, 6520, 6525,
+ 6529, 6532, 6539, 6545, 6548, 6553, 6556, 6562, 6567, 6571,
+ 6574, 6577, 6580, 6585, 6589, 6592, 6595, 6601, 6604, 6607,
+ 6615, 6618, 6621, 6625, 6630, 6643, 6647, 6652, 6658, 6662,
+ 6667, 6671, 6678, 6681, 6686
};
#endif
-#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+#if YYDEBUG || YYERROR_VERBOSE || 0
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[] =
{
"$end", "error", "$undefined", "ID", "HBLOCK", "POUND", "STRING",
- "INCLUDE", "IMPORT", "INSERT", "CHARCONST", "NUM_INT", "NUM_FLOAT",
- "NUM_UNSIGNED", "NUM_LONG", "NUM_ULONG", "NUM_LONGLONG", "NUM_ULONGLONG",
- "NUM_BOOL", "TYPEDEF", "TYPE_INT", "TYPE_UNSIGNED", "TYPE_SHORT",
- "TYPE_LONG", "TYPE_FLOAT", "TYPE_DOUBLE", "TYPE_CHAR", "TYPE_WCHAR",
- "TYPE_VOID", "TYPE_SIGNED", "TYPE_BOOL", "TYPE_COMPLEX", "TYPE_TYPEDEF",
- "TYPE_RAW", "TYPE_NON_ISO_INT8", "TYPE_NON_ISO_INT16",
- "TYPE_NON_ISO_INT32", "TYPE_NON_ISO_INT64", "LPAREN", "RPAREN", "COMMA",
- "SEMI", "EXTERN", "INIT", "LBRACE", "RBRACE", "PERIOD", "CONST_QUAL",
- "VOLATILE", "REGISTER", "STRUCT", "UNION", "EQUAL", "SIZEOF", "MODULE",
- "LBRACKET", "RBRACKET", "BEGINFILE", "ENDOFFILE", "ILLEGAL", "CONSTANT",
- "NAME", "RENAME", "NAMEWARN", "EXTEND", "PRAGMA", "FEATURE", "VARARGS",
- "ENUM", "CLASS", "TYPENAME", "PRIVATE", "PUBLIC", "PROTECTED", "COLON",
- "STATIC", "VIRTUAL", "FRIEND", "THROW", "CATCH", "EXPLICIT", "USING",
- "NAMESPACE", "NATIVE", "INLINE", "TYPEMAP", "EXCEPT", "ECHO", "APPLY",
- "CLEAR", "SWIGTEMPLATE", "FRAGMENT", "WARN", "LESSTHAN", "GREATERTHAN",
- "DELETE_KW", "LESSTHANOREQUALTO", "GREATERTHANOREQUALTO", "EQUALTO",
- "NOTEQUALTO", "QUESTIONMARK", "TYPES", "PARMS", "NONID", "DSTAR",
- "DCNOT", "TEMPLATE", "OPERATOR", "COPERATOR", "PARSETYPE", "PARSEPARM",
- "PARSEPARMS", "CAST", "LOR", "LAND", "OR", "XOR", "AND", "RSHIFT",
- "LSHIFT", "MINUS", "PLUS", "MODULO", "SLASH", "STAR", "LNOT", "NOT",
- "UMINUS", "DCOLON", "$accept", "program", "interface", "declaration",
- "swig_directive", "extend_directive", "$@1", "apply_directive",
- "clear_directive", "constant_directive", "echo_directive",
- "except_directive", "stringtype", "fname", "fragment_directive",
- "include_directive", "$@2", "includetype", "inline_directive",
- "insert_directive", "module_directive", "name_directive",
- "native_directive", "pragma_directive", "pragma_arg", "pragma_lang",
- "rename_directive", "rename_namewarn", "feature_directive",
- "stringbracesemi", "featattr", "varargs_directive", "varargs_parms",
- "typemap_directive", "typemap_type", "tm_list", "tm_tail",
- "typemap_parm", "types_directive", "template_directive",
+ "WSTRING", "INCLUDE", "IMPORT", "INSERT", "CHARCONST", "WCHARCONST",
+ "NUM_INT", "NUM_FLOAT", "NUM_UNSIGNED", "NUM_LONG", "NUM_ULONG",
+ "NUM_LONGLONG", "NUM_ULONGLONG", "NUM_BOOL", "TYPEDEF", "TYPE_INT",
+ "TYPE_UNSIGNED", "TYPE_SHORT", "TYPE_LONG", "TYPE_FLOAT", "TYPE_DOUBLE",
+ "TYPE_CHAR", "TYPE_WCHAR", "TYPE_VOID", "TYPE_SIGNED", "TYPE_BOOL",
+ "TYPE_COMPLEX", "TYPE_TYPEDEF", "TYPE_RAW", "TYPE_NON_ISO_INT8",
+ "TYPE_NON_ISO_INT16", "TYPE_NON_ISO_INT32", "TYPE_NON_ISO_INT64",
+ "LPAREN", "RPAREN", "COMMA", "SEMI", "EXTERN", "INIT", "LBRACE",
+ "RBRACE", "PERIOD", "CONST_QUAL", "VOLATILE", "REGISTER", "STRUCT",
+ "UNION", "EQUAL", "SIZEOF", "MODULE", "LBRACKET", "RBRACKET",
+ "BEGINFILE", "ENDOFFILE", "ILLEGAL", "CONSTANT", "NAME", "RENAME",
+ "NAMEWARN", "EXTEND", "PRAGMA", "FEATURE", "VARARGS", "ENUM", "CLASS",
+ "TYPENAME", "PRIVATE", "PUBLIC", "PROTECTED", "COLON", "STATIC",
+ "VIRTUAL", "FRIEND", "THROW", "CATCH", "EXPLICIT", "STATIC_ASSERT",
+ "CONSTEXPR", "THREAD_LOCAL", "DECLTYPE", "AUTO", "NOEXCEPT", "OVERRIDE",
+ "FINAL", "USING", "NAMESPACE", "NATIVE", "INLINE", "TYPEMAP", "EXCEPT",
+ "ECHO", "APPLY", "CLEAR", "SWIGTEMPLATE", "FRAGMENT", "WARN", "LESSTHAN",
+ "GREATERTHAN", "DELETE_KW", "DEFAULT", "LESSTHANOREQUALTO",
+ "GREATERTHANOREQUALTO", "EQUALTO", "NOTEQUALTO", "ARROW", "QUESTIONMARK",
+ "TYPES", "PARMS", "NONID", "DSTAR", "DCNOT", "TEMPLATE", "OPERATOR",
+ "CONVERSIONOPERATOR", "PARSETYPE", "PARSEPARM", "PARSEPARMS", "CAST",
+ "LOR", "LAND", "OR", "XOR", "AND", "LSHIFT", "RSHIFT", "PLUS", "MINUS",
+ "STAR", "SLASH", "MODULO", "UMINUS", "NOT", "LNOT", "DCOLON", "$accept",
+ "program", "interface", "declaration", "swig_directive",
+ "extend_directive", "$@1", "apply_directive", "clear_directive",
+ "constant_directive", "echo_directive", "except_directive", "stringtype",
+ "fname", "fragment_directive", "include_directive", "$@2", "includetype",
+ "inline_directive", "insert_directive", "module_directive",
+ "name_directive", "native_directive", "pragma_directive", "pragma_arg",
+ "pragma_lang", "rename_directive", "rename_namewarn",
+ "feature_directive", "stringbracesemi", "featattr", "varargs_directive",
+ "varargs_parms", "typemap_directive", "typemap_type", "tm_list",
+ "tm_tail", "typemap_parm", "types_directive", "template_directive",
"warn_directive", "c_declaration", "$@3", "c_decl", "c_decl_tail",
- "initializer", "c_enum_forward_decl", "c_enum_decl",
- "c_constructor_decl", "cpp_declaration", "cpp_class_decl", "@4", "@5",
+ "initializer", "cpp_alternate_rettype", "cpp_lambda_decl",
+ "lambda_introducer", "lambda_body", "lambda_tail", "$@4", "c_enum_key",
+ "c_enum_inherit", "c_enum_forward_decl", "c_enum_decl",
+ "c_constructor_decl", "cpp_declaration", "cpp_class_decl", "@5", "@6",
"cpp_opt_declarators", "cpp_forward_class_decl", "cpp_template_decl",
- "$@6", "cpp_temp_possible", "template_parms", "templateparameters",
+ "$@7", "cpp_temp_possible", "template_parms", "templateparameters",
"templateparameter", "templateparameterstail", "cpp_using_decl",
- "cpp_namespace_decl", "$@7", "$@8", "cpp_members", "$@9", "$@10",
- "cpp_member", "cpp_constructor_decl", "cpp_destructor_decl",
- "cpp_conversion_operator", "cpp_catch_decl", "cpp_protection_decl",
- "cpp_nested", "@11", "@12", "cpp_swig_directive", "cpp_end", "cpp_vend",
- "anonymous_bitfield", "storage_class", "parms", "rawparms", "ptail",
- "parm", "valparms", "rawvalparms", "valptail", "valparm", "def_args",
- "parameter_declarator", "typemap_parameter_declarator", "declarator",
- "notso_direct_declarator", "direct_declarator", "abstract_declarator",
- "direct_abstract_declarator", "pointer", "type_qualifier",
- "type_qualifier_raw", "type", "rawtype", "type_right", "primitive_type",
- "primitive_type_list", "type_specifier", "definetype", "$@13", "ename",
+ "cpp_namespace_decl", "$@8", "$@9", "cpp_members", "$@10", "$@11",
+ "$@12", "cpp_member", "cpp_constructor_decl", "cpp_destructor_decl",
+ "cpp_conversion_operator", "cpp_catch_decl", "cpp_static_assert",
+ "cpp_protection_decl", "cpp_swig_directive", "cpp_end", "cpp_vend",
+ "anonymous_bitfield", "anon_bitfield_type", "extern_string",
+ "storage_class", "parms", "rawparms", "ptail", "parm", "valparms",
+ "rawvalparms", "valptail", "valparm", "def_args", "parameter_declarator",
+ "plain_declarator", "declarator", "notso_direct_declarator",
+ "direct_declarator", "abstract_declarator", "direct_abstract_declarator",
+ "pointer", "type_qualifier", "type_qualifier_raw", "type", "rawtype",
+ "type_right", "decltype", "primitive_type", "primitive_type_list",
+ "type_specifier", "definetype", "$@13", "default_delete",
+ "deleted_definition", "explicit_default", "ename",
"optional_constant_directive", "enumlist", "edecl", "etype", "expr",
- "valexpr", "exprnum", "exprcompound", "inherit", "raw_inherit", "$@14",
- "base_list", "base_specifier", "@15", "@16", "access_specifier",
- "templcpptype", "cpptype", "opt_virtual", "cpp_const", "ctor_end",
+ "valexpr", "exprnum", "exprcompound", "ellipsis", "variadic", "inherit",
+ "raw_inherit", "$@14", "base_list", "base_specifier", "@15", "@16",
+ "access_specifier", "templcpptype", "cpptype", "opt_virtual",
+ "virt_specifier_seq", "exception_specification", "cpp_const", "ctor_end",
"ctor_initializer", "mem_initializer_list", "mem_initializer",
- "template_decl", "idstring", "idstringopt", "idcolon", "idcolontail",
- "idtemplate", "idcolonnt", "idcolontailnt", "string", "stringbrace",
- "options", "kwargs", "stringnum", "empty", 0
+ "less_valparms_greater", "identifier", "idstring", "idstringopt",
+ "idcolon", "idcolontail", "idtemplate", "idtemplatetemplate",
+ "idcolonnt", "idcolontailnt", "string", "wstring", "stringbrace",
+ "options", "kwargs", "stringnum", "empty", YY_NULLPTR
};
#endif
# ifdef YYPRINT
-/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
- token YYLEX-NUM. */
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+ (internal) symbol number NUM (which must be that of a token). */
static const yytype_uint16 yytoknum[] =
{
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
- 375, 376, 377, 378, 379, 380, 381, 382, 383
+ 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
+ 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
+ 395
};
# endif
-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
-static const yytype_uint16 yyr1[] =
-{
- 0, 129, 130, 130, 130, 130, 130, 130, 130, 131,
- 131, 132, 132, 132, 132, 132, 132, 132, 133, 133,
- 133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
- 133, 133, 133, 133, 133, 133, 133, 133, 133, 135,
- 134, 136, 137, 138, 138, 138, 139, 139, 140, 140,
- 140, 140, 141, 142, 142, 143, 143, 143, 145, 144,
- 146, 146, 147, 147, 148, 148, 148, 148, 149, 150,
- 150, 151, 151, 152, 152, 153, 153, 154, 154, 155,
- 155, 155, 156, 156, 157, 157, 157, 157, 157, 157,
- 157, 157, 158, 158, 158, 159, 159, 160, 161, 161,
- 162, 162, 162, 163, 164, 165, 165, 166, 166, 166,
- 167, 168, 169, 170, 170, 170, 171, 170, 172, 173,
- 173, 173, 174, 174, 174, 174, 175, 176, 176, 177,
- 178, 178, 178, 178, 178, 178, 180, 179, 181, 179,
- 182, 182, 183, 185, 184, 184, 186, 186, 186, 186,
- 186, 186, 187, 188, 188, 189, 189, 190, 190, 191,
- 191, 193, 192, 194, 192, 192, 195, 196, 195, 195,
- 195, 197, 195, 198, 198, 198, 198, 198, 198, 198,
- 198, 198, 198, 198, 198, 198, 198, 198, 198, 198,
- 198, 199, 200, 200, 201, 201, 201, 201, 202, 203,
- 203, 203, 205, 204, 206, 204, 207, 207, 207, 207,
- 207, 207, 207, 207, 207, 207, 207, 208, 208, 209,
- 209, 209, 210, 211, 211, 211, 211, 211, 211, 211,
- 211, 212, 213, 213, 214, 214, 215, 215, 215, 216,
- 217, 217, 218, 218, 219, 219, 220, 220, 220, 220,
- 220, 221, 221, 221, 222, 222, 222, 223, 223, 223,
- 223, 223, 223, 223, 223, 224, 224, 224, 224, 224,
- 224, 224, 224, 225, 225, 225, 225, 225, 225, 225,
- 225, 226, 226, 226, 226, 226, 226, 226, 226, 226,
- 226, 227, 227, 227, 227, 227, 227, 227, 228, 228,
- 228, 228, 229, 229, 230, 230, 230, 231, 232, 232,
- 232, 232, 233, 233, 233, 233, 233, 233, 233, 233,
- 234, 235, 235, 236, 236, 236, 236, 236, 236, 236,
- 236, 236, 236, 236, 236, 236, 236, 238, 237, 239,
- 239, 240, 240, 241, 241, 241, 241, 242, 242, 243,
- 244, 244, 245, 245, 245, 245, 245, 245, 245, 245,
- 245, 245, 245, 245, 246, 246, 246, 246, 246, 246,
- 246, 246, 247, 247, 247, 247, 247, 247, 247, 247,
- 247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
- 247, 247, 247, 247, 248, 250, 249, 249, 251, 251,
- 253, 252, 254, 252, 255, 255, 255, 256, 256, 257,
- 257, 257, 258, 258, 259, 259, 259, 259, 260, 260,
- 260, 260, 260, 261, 261, 262, 262, 263, 264, 264,
- 265, 265, 266, 266, 267, 267, 267, 267, 267, 267,
- 268, 268, 268, 268, 269, 270, 270, 270, 270, 270,
- 270, 271, 271, 271, 271, 272, 272, 273, 273, 273,
- 274, 274, 275, 275, 275, 275, 275, 275, 276, 276,
- 277
-};
+#define YYPACT_NINF -904
-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
-static const yytype_uint8 yyr2[] =
-{
- 0, 2, 1, 3, 2, 3, 2, 5, 3, 2,
- 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
- 7, 5, 3, 5, 5, 3, 2, 2, 5, 2,
- 5, 2, 4, 1, 1, 7, 7, 5, 0, 7,
- 1, 1, 2, 2, 1, 5, 5, 5, 3, 4,
- 3, 7, 8, 5, 3, 1, 1, 3, 1, 4,
- 7, 6, 1, 1, 7, 9, 8, 10, 5, 7,
- 6, 8, 1, 1, 5, 4, 5, 7, 1, 3,
- 6, 6, 8, 1, 2, 3, 1, 2, 3, 6,
- 5, 9, 2, 1, 1, 1, 0, 6, 5, 1,
- 4, 1, 1, 2, 5, 6, 4, 7, 9, 6,
- 1, 1, 1, 1, 1, 1, 0, 9, 0, 9,
- 1, 3, 4, 0, 6, 3, 1, 1, 1, 1,
- 1, 1, 1, 2, 1, 1, 1, 3, 1, 3,
- 4, 0, 6, 0, 5, 5, 2, 0, 6, 1,
- 1, 0, 3, 1, 1, 1, 1, 1, 1, 1,
- 1, 3, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 6, 6, 7, 8, 8, 9, 7, 5, 2,
- 2, 2, 0, 7, 0, 6, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
- 4, 2, 5, 1, 2, 1, 1, 1, 1, 1,
- 1, 1, 2, 1, 3, 1, 2, 7, 3, 1,
- 2, 1, 3, 1, 1, 1, 2, 5, 2, 2,
- 1, 2, 2, 1, 1, 1, 1, 2, 3, 1,
- 2, 3, 4, 5, 4, 1, 2, 3, 4, 5,
- 3, 4, 4, 1, 2, 4, 4, 5, 3, 4,
- 4, 1, 2, 2, 3, 1, 2, 1, 2, 3,
- 4, 3, 4, 2, 3, 3, 4, 3, 3, 2,
- 2, 1, 1, 2, 1, 1, 1, 1, 2, 1,
- 2, 3, 1, 1, 1, 2, 2, 1, 1, 2,
- 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 0, 2, 1,
- 1, 1, 1, 5, 3, 3, 1, 1, 3, 1,
- 1, 1, 1, 1, 5, 1, 1, 3, 4, 5,
- 5, 6, 2, 2, 1, 1, 1, 1, 1, 1,
- 1, 1, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 5, 2,
- 2, 2, 2, 2, 1, 0, 3, 1, 1, 3,
- 0, 3, 0, 5, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 4, 5, 1, 3, 3,
- 4, 4, 3, 2, 1, 1, 3, 2, 3, 1,
- 1, 1, 1, 1, 2, 4, 1, 3, 1, 3,
- 3, 2, 2, 2, 2, 2, 4, 1, 3, 1,
- 3, 3, 2, 2, 2, 2, 1, 1, 1, 1,
- 3, 1, 3, 5, 1, 3, 3, 5, 1, 1,
- 0
-};
+#define yypact_value_is_default(Yystate) \
+ (!!((Yystate) == (-904)))
-/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
- Performed when YYTABLE doesn't specify something else to do. Zero
- means the default is an error. */
-static const yytype_uint16 yydefact[] =
+#define YYTABLE_NINF -575
+
+#define yytable_value_is_error(Yytable_value) \
+ 0
+
+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+ STATE-NUM. */
+static const yytype_int16 yypact[] =
{
- 470, 0, 0, 0, 0, 0, 10, 4, 470, 323,
- 331, 324, 325, 328, 329, 326, 327, 314, 330, 313,
- 332, 470, 317, 333, 334, 335, 336, 0, 304, 305,
- 306, 410, 411, 0, 407, 408, 0, 0, 438, 0,
- 0, 302, 470, 309, 312, 320, 321, 409, 0, 318,
- 436, 6, 0, 0, 470, 1, 15, 64, 60, 61,
- 0, 226, 14, 223, 470, 0, 0, 82, 83, 470,
- 470, 0, 0, 225, 227, 228, 0, 229, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 9, 11, 18, 19, 20, 21, 22, 23,
- 24, 25, 470, 26, 27, 28, 29, 30, 31, 32,
- 0, 33, 34, 35, 36, 37, 38, 12, 113, 115,
- 114, 16, 13, 130, 131, 132, 133, 134, 135, 0,
- 230, 470, 444, 429, 315, 0, 316, 0, 0, 3,
- 308, 303, 470, 337, 0, 0, 287, 301, 0, 253,
- 236, 470, 259, 470, 285, 281, 273, 250, 310, 322,
- 319, 0, 0, 434, 5, 8, 0, 231, 470, 233,
- 17, 0, 456, 224, 0, 0, 461, 0, 470, 0,
- 307, 0, 0, 0, 0, 78, 0, 470, 470, 0,
- 0, 470, 163, 0, 0, 62, 63, 0, 0, 51,
- 49, 46, 47, 470, 0, 470, 0, 470, 470, 0,
- 112, 470, 470, 0, 0, 0, 0, 0, 0, 273,
- 470, 0, 0, 356, 364, 365, 366, 367, 368, 369,
- 370, 371, 0, 0, 0, 0, 0, 0, 0, 0,
- 244, 0, 239, 470, 351, 307, 0, 350, 352, 355,
- 353, 241, 238, 439, 437, 0, 311, 470, 287, 0,
- 0, 281, 318, 248, 246, 0, 293, 0, 350, 249,
- 470, 0, 260, 286, 265, 299, 300, 274, 251, 470,
- 0, 252, 470, 0, 283, 257, 282, 265, 288, 443,
- 442, 441, 0, 0, 232, 235, 430, 0, 431, 455,
- 116, 464, 0, 68, 45, 337, 0, 470, 70, 0,
- 0, 0, 74, 0, 0, 0, 98, 0, 0, 159,
- 0, 470, 161, 0, 0, 103, 0, 0, 0, 107,
- 254, 255, 256, 42, 0, 104, 106, 432, 0, 433,
- 54, 0, 53, 0, 0, 152, 470, 156, 409, 154,
- 145, 0, 430, 0, 0, 0, 0, 0, 0, 0,
- 265, 0, 470, 0, 340, 470, 470, 138, 319, 0,
- 0, 362, 389, 390, 363, 392, 391, 428, 0, 240,
- 243, 393, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 435,
- 0, 287, 281, 318, 0, 273, 297, 295, 283, 0,
- 273, 288, 0, 338, 294, 281, 318, 266, 470, 0,
- 298, 0, 278, 0, 0, 291, 0, 258, 284, 289,
- 0, 261, 440, 7, 470, 0, 470, 0, 0, 460,
- 0, 0, 69, 39, 77, 0, 0, 0, 0, 0,
- 0, 0, 160, 0, 0, 470, 470, 0, 0, 108,
- 0, 470, 0, 0, 0, 0, 0, 143, 0, 153,
- 158, 58, 0, 0, 0, 0, 79, 0, 126, 470,
- 0, 318, 0, 0, 122, 470, 0, 142, 395, 0,
- 394, 397, 357, 0, 301, 0, 470, 470, 387, 386,
- 384, 385, 0, 383, 382, 378, 379, 377, 381, 380,
- 373, 372, 376, 375, 374, 0, 0, 288, 276, 275,
- 289, 0, 0, 0, 265, 267, 288, 0, 270, 0,
- 280, 279, 296, 292, 0, 262, 290, 264, 234, 66,
- 67, 65, 0, 465, 466, 469, 468, 462, 43, 44,
- 0, 76, 73, 75, 459, 93, 458, 0, 88, 470,
- 457, 92, 0, 468, 0, 0, 99, 470, 198, 165,
- 164, 0, 223, 0, 0, 50, 48, 470, 41, 105,
- 447, 0, 449, 0, 57, 0, 0, 110, 470, 470,
- 470, 470, 0, 0, 341, 346, 0, 342, 470, 470,
- 0, 119, 121, 118, 0, 123, 171, 190, 0, 0,
- 0, 0, 227, 0, 214, 215, 207, 216, 188, 169,
- 212, 208, 206, 209, 210, 211, 213, 189, 185, 186,
- 173, 179, 183, 182, 0, 0, 174, 175, 178, 184,
- 176, 180, 177, 187, 0, 230, 470, 136, 358, 0,
- 301, 300, 0, 0, 0, 242, 0, 470, 277, 247,
- 268, 0, 272, 271, 263, 117, 0, 0, 0, 470,
- 0, 414, 0, 417, 0, 0, 0, 0, 90, 470,
- 0, 162, 224, 470, 0, 101, 0, 100, 0, 0,
- 0, 445, 0, 470, 0, 52, 146, 147, 150, 149,
- 144, 148, 151, 0, 157, 0, 0, 81, 347, 470,
- 470, 0, 470, 337, 470, 129, 0, 470, 470, 0,
- 167, 200, 199, 201, 0, 0, 0, 166, 0, 0,
- 470, 318, 412, 396, 398, 400, 413, 0, 360, 359,
- 0, 354, 388, 237, 269, 467, 463, 40, 0, 470,
- 0, 84, 468, 95, 89, 470, 0, 0, 97, 71,
- 0, 0, 109, 454, 452, 453, 448, 450, 0, 55,
- 56, 0, 59, 80, 0, 345, 344, 127, 470, 0,
- 0, 0, 0, 424, 470, 0, 0, 172, 0, 0,
- 470, 470, 0, 470, 0, 0, 319, 181, 470, 405,
- 404, 406, 0, 402, 0, 361, 0, 0, 470, 96,
- 0, 91, 470, 86, 72, 102, 451, 446, 0, 348,
- 349, 470, 0, 0, 422, 423, 425, 0, 418, 419,
- 124, 120, 470, 0, 470, 0, 0, 470, 0, 0,
- 0, 0, 204, 0, 399, 401, 470, 0, 94, 415,
- 0, 85, 0, 111, 343, 128, 420, 421, 0, 427,
- 125, 0, 0, 470, 139, 0, 470, 470, 0, 470,
- 222, 0, 202, 0, 140, 137, 470, 416, 87, 426,
- 168, 470, 192, 0, 470, 0, 0, 470, 191, 205,
- 0, 403, 0, 193, 0, 217, 218, 197, 470, 470,
- 0, 203, 141, 219, 221, 337, 195, 194, 470, 0,
- 196, 220
+ 692, 4117, 4189, 300, 64, 3607, -904, -904, -904, -904,
+ -904, -904, -904, -904, -904, -904, -904, -904, -904, -904,
+ -904, -904, -904, -904, -904, -904, 110, -904, -904, -904,
+ -904, -904, 5, 117, 141, 129, -904, -904, -49, -20,
+ 132, 96, 176, 4834, 793, 1218, 793, -904, -904, -904,
+ 2093, -904, 96, 132, -904, -32, -904, 255, 266, 4551,
+ -904, 140, -904, -904, -904, 303, -904, -904, 37, 314,
+ 4261, 337, -904, -904, 314, 357, 364, 372, 475, -904,
+ -904, 380, 367, 356, 18, 519, 722, 431, 175, 479,
+ 406, 285, 4622, 4622, 487, 493, 529, 507, 407, -904,
+ -904, -904, -904, -904, -904, -904, -904, -904, -904, 314,
+ -904, -904, -904, -904, -904, -904, -904, 1580, -904, -904,
+ -904, -904, -904, -904, -904, -904, -904, -904, -904, -904,
+ -904, -904, -904, -904, -904, -904, -904, 39, 4693, -904,
+ 517, -904, -904, 536, 545, 96, 41, 384, 2135, -904,
+ -904, -904, 793, -904, 3279, 547, 77, 2269, 3073, 44,
+ 1338, 2275, 163, 96, -904, -904, 231, 159, 231, 306,
+ 1677, 486, -904, -904, -904, -904, -904, 113, 136, -904,
+ -904, -904, 556, -904, 562, -904, -904, 425, -904, -904,
+ 384, 198, 425, 425, -904, 580, 1698, -904, 98, 1184,
+ 96, 113, 113, -904, 425, 4479, -904, -904, 4551, -904,
+ -904, -904, -904, -904, 96, 27, -904, 139, 582, 113,
+ -904, -904, 425, 113, -904, -904, -904, 624, 4551, 590,
+ 1044, 597, 602, 425, 529, 624, 4551, 4551, 96, 529,
+ 2089, 484, 911, 425, 387, 530, -904, -904, 1698, 96,
+ 1786, 226, -904, 600, 604, 629, 113, -904, -904, -32,
+ 579, -904, -904, -904, -904, -904, -904, -904, -904, -904,
+ -904, -904, 3073, 169, 3073, 3073, 3073, 3073, 3073, 3073,
+ 3073, -904, 581, -904, 652, 661, 354, 3022, 8, -904,
+ -904, 624, 706, -904, -904, 3392, 1017, 1017, 697, 702,
+ 280, 617, 700, -904, -904, -904, 703, 3073, -904, -904,
+ -904, -904, 4265, -904, 3022, 711, 3392, 709, 96, 326,
+ 306, -904, 715, 326, 306, -904, 625, -904, -904, 4551,
+ 2403, -904, 4551, 2537, 723, 2409, 2543, 326, 306, 665,
+ 2223, -904, -904, -32, 734, 4551, -904, -904, -904, -904,
+ 741, 624, 96, -904, -904, 344, 743, -904, -904, 138,
+ 231, 483, -904, 744, 745, 746, 739, 623, 756, 758,
+ -904, 760, 762, -904, 4764, -904, 96, -904, 765, 779,
+ -904, 781, 790, 4622, -904, -904, -904, -904, -904, 4622,
+ -904, -904, -904, 791, -904, -904, 646, 217, 795, 730,
+ -904, 797, -904, 13, -904, -904, 112, 1354, 1354, 1354,
+ 351, 729, 807, 158, 806, 1090, 1124, 735, 2223, 747,
+ 24, 794, 268, -904, 3464, 1934, -904, 821, -904, 292,
+ -904, -904, -904, -904, 132, -904, 384, 2638, 4764, 827,
+ 1969, 2888, -904, -904, -904, -904, -904, -904, 2135, -904,
+ -904, -904, 3073, 3073, 3073, 3073, 3073, 3073, 3073, 3073,
+ 3073, 3073, 3073, 3073, 3073, 3073, 3073, 3073, 3073, -904,
+ 334, 334, 1683, 753, 578, -904, 586, -904, -904, 334,
+ 334, 601, 766, 1354, 1354, 3073, 3022, -904, 4551, 472,
+ 17, 828, -904, 4551, 2671, 835, -904, 843, -904, 4626,
+ 844, -904, 4713, 842, 847, 326, 306, 848, 326, 306,
+ 1813, 851, 855, 1126, 326, -904, -904, 562, 216, -904,
+ -904, 425, 1824, -904, 849, 863, -904, -904, -904, 494,
+ 1273, 2491, 866, 4551, 1698, 862, -904, 1044, 3709, 868,
+ -904, 363, 4622, 419, 869, 870, 602, 561, 876, 425,
+ 4551, 131, 822, 4551, -904, -904, -904, 1354, 1365, 1524,
+ 38, -904, 2357, 4904, 867, 4834, 439, -904, 879, 729,
+ 887, 191, 840, 850, 257, -904, 939, -904, 231, 853,
+ -904, -904, 886, -904, 96, 3073, 2805, 2939, 3207, 69,
+ 1218, 894, 652, 694, 694, 1977, 1977, 2509, 4050, 1969,
+ 2238, 2646, 2888, 1007, 1007, 728, 728, -904, -904, -904,
+ 766, -904, -904, -904, -904, 334, 627, 159, 4838, 904,
+ 632, 766, -904, 1524, 1524, 917, -904, 4850, 1524, -904,
+ -904, -904, -904, 1524, 912, 913, 915, 916, 1215, 326,
+ 306, 923, 925, 926, 326, -904, -904, -904, 624, 3811,
+ -904, 935, -904, 217, 938, -904, -904, 1968, -904, -904,
+ 624, -904, -904, -904, 941, -904, 1068, 624, -904, 928,
+ 35, 688, 1273, -904, 1068, -904, 943, -904, -904, 3913,
+ 53, 4764, 318, -904, -904, 4551, -904, -904, 854, -904,
+ 219, 881, -904, 946, 942, -904, 96, 2159, 797, -904,
+ 1068, 289, 1524, -904, -904, -904, 1934, -904, -904, -904,
+ -904, 453, -904, -904, 929, 767, 4551, 3073, -904, -904,
+ -904, -904, 1698, -904, -904, -904, -904, 231, -904, -904,
+ 953, -904, 805, -904, 1968, -904, 231, 3022, 3073, 3073,
+ 3207, 3534, 3073, 947, 961, 963, 966, -904, 3073, -904,
+ -904, -904, -904, 699, 326, -904, -904, 326, 326, 1524,
+ 1524, 959, 964, 965, 326, 1524, 970, 973, -904, 425,
+ 425, -904, -904, 978, 933, 955, 957, 873, 994, 113,
+ -904, -904, -904, -904, -904, -904, -904, -904, -904, -904,
+ -904, -904, -904, -904, -904, -904, -904, -904, -904, -904,
+ -904, 988, 1968, -904, -904, -904, -904, -904, -904, -904,
+ -904, 4332, 991, 4551, 415, -904, 131, -904, 1824, 1434,
+ 425, 998, -904, 1068, 997, -904, -904, 624, 1698, 25,
+ -904, 4622, -904, 1002, 215, 113, 291, -904, 2135, 188,
+ -904, 996, 37, 737, -904, -904, -904, -904, -904, -904,
+ -904, -904, 4404, -904, 4015, 1008, -904, 257, 4551, -904,
+ 468, -904, 113, 481, -904, 4551, 483, 999, 976, -904,
+ 1014, 2754, 1934, -904, 853, -904, -904, -904, 96, -904,
+ 1011, 1968, -904, 3022, 3022, 3022, 3073, 3073, -904, 4764,
+ 3245, -904, 326, 326, 1524, 1012, 1016, 326, 1524, 1524,
+ -904, -904, 1968, -904, -904, -904, -904, 113, -904, 1019,
+ -904, -904, 995, 1000, 1001, 4764, 1003, 1818, 1004, 247,
+ 1031, -904, -904, 624, 1033, -904, 1068, 1447, 131, -904,
+ 1030, -904, 1040, -904, -904, 219, -904, -904, 219, 982,
+ -904, -904, 4764, 4551, 1698, -904, -904, -904, 1046, -904,
+ -904, -904, 929, 1035, 929, 1618, 1050, 1051, 483, 96,
+ 511, -904, -904, -904, 257, -904, 1047, 853, 1642, 1053,
+ 3022, 3022, 1218, 326, 1524, 1524, 326, 326, -904, 1968,
+ 1069, 4551, 71, 3073, 3464, -904, 1065, -904, 1067, -904,
+ 1068, -904, -904, -904, -904, -904, 1070, 1044, 1024, 1068,
+ 1073, -904, 3073, 113, -904, 1934, 534, -904, 1077, 1081,
+ 1083, 461, -904, -904, -904, 1087, -904, -904, -904, 96,
+ -904, -904, 1934, 1642, 1096, 326, 326, 1097, 4551, 1104,
+ 4551, 1106, 1110, 16, 2905, 1111, -904, -904, 1117, -904,
+ 1118, -904, 51, -904, -904, 3022, 929, 257, -904, -904,
+ -904, 96, 1105, -904, -904, 1114, 1047, 257, -904, -904,
+ -904, 1113, 1068, 1127, 4551, 4551, 4551, 1129, -904, 767,
+ -904, -904, 4764, 468, -904, -904, 1119, 1136, -904, -904,
+ -904, 1968, 1068, -904, 333, 1068, 1134, 1153, 1155, 4551,
+ -904, 1151, -904, 1150, -904, -904, -904, 418, -904, -904,
+ 483, -904, 1068, 1068, 1068, 1163, 468, 1160, -904, -904,
+ 483, 1167, -904, -904, -904, 1068, -904, -904, 1168, -904,
+ -904, -904
};
-/* YYDEFGOTO[NTERM-NUM]. */
-static const yytype_int16 yydefgoto[] =
+ /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+ Performed when YYTABLE does not specify something else to do. Zero
+ means the default is an error. */
+static const yytype_uint16 yydefact[] =
{
- -1, 4, 5, 92, 93, 94, 550, 614, 615, 616,
- 617, 99, 340, 341, 618, 619, 590, 102, 103, 620,
- 105, 621, 107, 622, 552, 184, 623, 110, 624, 558,
- 448, 625, 315, 626, 324, 206, 335, 207, 627, 628,
- 629, 630, 436, 118, 603, 483, 119, 120, 121, 122,
- 123, 737, 486, 875, 631, 632, 588, 700, 344, 345,
- 346, 469, 633, 127, 455, 321, 634, 788, 719, 635,
- 636, 637, 638, 639, 640, 641, 890, 871, 642, 882,
- 893, 643, 644, 259, 167, 294, 168, 241, 242, 379,
- 243, 484, 150, 329, 151, 272, 152, 153, 154, 218,
- 40, 41, 244, 180, 43, 44, 45, 46, 264, 265,
- 363, 595, 596, 709, 819, 246, 268, 248, 249, 489,
- 490, 646, 733, 734, 802, 846, 803, 47, 48, 735,
- 894, 715, 782, 825, 826, 132, 301, 338, 49, 163,
- 50, 583, 691, 250, 561, 175, 302, 547, 169
+ 574, 0, 0, 0, 0, 0, 10, 4, 524, 389,
+ 397, 390, 391, 394, 395, 392, 393, 379, 396, 378,
+ 398, 381, 399, 400, 401, 402, 0, 369, 370, 371,
+ 492, 493, 145, 487, 488, 0, 525, 526, 0, 0,
+ 536, 0, 0, 0, 367, 574, 374, 384, 377, 386,
+ 387, 491, 0, 543, 382, 534, 6, 0, 0, 574,
+ 1, 15, 64, 60, 61, 0, 261, 14, 256, 574,
+ 0, 0, 82, 83, 574, 574, 0, 0, 260, 262,
+ 263, 0, 264, 265, 270, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
+ 11, 18, 19, 20, 21, 22, 23, 24, 25, 574,
+ 26, 27, 28, 29, 30, 31, 32, 0, 33, 34,
+ 35, 36, 37, 38, 12, 113, 118, 115, 114, 16,
+ 13, 154, 155, 156, 157, 158, 159, 257, 0, 275,
+ 0, 147, 146, 0, 0, 0, 0, 0, 574, 537,
+ 380, 3, 373, 368, 574, 0, 403, 0, 0, 536,
+ 352, 351, 366, 0, 298, 281, 574, 305, 574, 348,
+ 342, 332, 295, 375, 388, 383, 544, 0, 0, 532,
+ 5, 8, 0, 276, 574, 278, 17, 0, 558, 273,
+ 0, 255, 0, 0, 565, 0, 0, 372, 543, 0,
+ 0, 0, 0, 78, 0, 574, 268, 272, 574, 266,
+ 269, 267, 274, 271, 0, 0, 189, 543, 0, 0,
+ 62, 63, 0, 0, 51, 49, 46, 47, 574, 0,
+ 574, 0, 574, 574, 0, 112, 574, 574, 0, 0,
+ 0, 0, 0, 0, 0, 332, 259, 258, 0, 574,
+ 0, 574, 283, 0, 0, 0, 0, 538, 545, 535,
+ 0, 560, 429, 430, 441, 442, 443, 444, 445, 446,
+ 447, 448, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 289, 0, 284, 574, 422, 372, 0, 421, 423,
+ 427, 424, 428, 286, 376, 574, 352, 351, 0, 0,
+ 342, 382, 0, 293, 408, 409, 291, 0, 405, 406,
+ 407, 358, 0, 421, 294, 0, 574, 0, 0, 307,
+ 350, 324, 0, 306, 349, 364, 365, 333, 296, 574,
+ 0, 297, 574, 0, 0, 345, 344, 302, 343, 324,
+ 353, 542, 541, 540, 0, 0, 277, 280, 528, 527,
+ 0, 529, 0, 557, 116, 568, 0, 68, 45, 0,
+ 574, 403, 70, 0, 0, 0, 74, 0, 0, 0,
+ 98, 0, 0, 185, 0, 574, 0, 187, 0, 0,
+ 103, 0, 0, 0, 107, 299, 300, 301, 42, 0,
+ 104, 106, 530, 0, 531, 54, 0, 53, 0, 0,
+ 178, 574, 182, 491, 180, 169, 0, 0, 0, 0,
+ 527, 0, 0, 0, 0, 0, 0, 324, 0, 0,
+ 332, 574, 543, 411, 574, 574, 475, 0, 474, 383,
+ 477, 489, 490, 385, 0, 533, 0, 0, 0, 0,
+ 439, 438, 467, 466, 440, 468, 469, 523, 0, 285,
+ 288, 470, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 559,
+ 352, 351, 342, 382, 0, 332, 0, 362, 360, 345,
+ 344, 0, 332, 353, 0, 0, 404, 359, 574, 342,
+ 382, 0, 325, 574, 0, 0, 363, 0, 338, 0,
+ 0, 356, 0, 0, 0, 304, 347, 0, 303, 346,
+ 354, 0, 0, 0, 308, 539, 7, 574, 0, 170,
+ 574, 0, 0, 564, 0, 0, 69, 39, 77, 0,
+ 0, 0, 0, 0, 0, 0, 186, 574, 0, 0,
+ 574, 574, 0, 0, 108, 0, 574, 0, 0, 0,
+ 0, 0, 167, 0, 179, 184, 58, 0, 0, 0,
+ 0, 79, 0, 0, 0, 0, 0, 149, 0, 382,
+ 0, 501, 496, 497, 0, 127, 574, 502, 574, 574,
+ 162, 166, 0, 546, 0, 431, 0, 0, 366, 0,
+ 574, 0, 574, 464, 463, 461, 462, 0, 460, 459,
+ 455, 456, 454, 457, 458, 449, 450, 451, 452, 453,
+ 0, 353, 336, 335, 334, 354, 0, 315, 0, 0,
+ 0, 324, 326, 353, 0, 0, 329, 0, 0, 340,
+ 339, 361, 357, 0, 0, 0, 0, 0, 0, 309,
+ 355, 0, 0, 0, 311, 279, 66, 67, 65, 0,
+ 569, 570, 573, 572, 566, 44, 43, 0, 76, 73,
+ 75, 563, 93, 562, 0, 88, 574, 561, 92, 0,
+ 572, 0, 0, 99, 574, 227, 0, 190, 191, 0,
+ 256, 0, 0, 50, 48, 574, 41, 105, 0, 551,
+ 549, 0, 57, 0, 0, 110, 0, 574, 574, 574,
+ 574, 0, 0, 133, 132, 134, 574, 136, 131, 135,
+ 140, 0, 148, 150, 574, 574, 574, 0, 503, 499,
+ 498, 126, 0, 123, 125, 121, 128, 574, 129, 494,
+ 476, 478, 480, 495, 0, 160, 574, 432, 0, 0,
+ 366, 365, 0, 0, 0, 0, 0, 287, 0, 337,
+ 292, 341, 327, 0, 317, 331, 330, 316, 312, 0,
+ 0, 0, 0, 0, 310, 0, 0, 0, 117, 0,
+ 0, 198, 218, 0, 0, 0, 0, 262, 0, 0,
+ 240, 241, 233, 242, 216, 196, 238, 234, 232, 235,
+ 236, 237, 239, 217, 213, 214, 200, 208, 207, 211,
+ 210, 0, 0, 201, 202, 206, 212, 203, 204, 205,
+ 215, 0, 275, 574, 505, 506, 0, 508, 0, 0,
+ 0, 0, 90, 574, 0, 119, 188, 255, 0, 543,
+ 101, 0, 100, 0, 0, 0, 0, 547, 574, 0,
+ 52, 0, 256, 0, 171, 172, 176, 175, 168, 173,
+ 177, 174, 0, 183, 0, 0, 81, 0, 574, 141,
+ 0, 412, 417, 0, 413, 574, 403, 506, 574, 153,
+ 0, 0, 574, 130, 574, 485, 484, 486, 0, 482,
+ 0, 0, 282, 435, 434, 433, 0, 0, 425, 0,
+ 465, 328, 314, 313, 0, 0, 0, 318, 0, 0,
+ 571, 567, 0, 193, 230, 229, 231, 0, 228, 0,
+ 40, 192, 379, 378, 381, 0, 0, 0, 377, 382,
+ 0, 507, 84, 572, 95, 89, 574, 0, 0, 97,
+ 0, 71, 0, 109, 552, 550, 556, 555, 554, 0,
+ 55, 56, 0, 574, 0, 59, 80, 122, 0, 143,
+ 142, 139, 574, 418, 574, 0, 0, 0, 0, 0,
+ 0, 516, 500, 504, 0, 479, 574, 574, 0, 0,
+ 437, 436, 574, 319, 0, 0, 323, 322, 199, 0,
+ 0, 574, 0, 0, 574, 209, 0, 96, 0, 91,
+ 574, 86, 72, 102, 548, 553, 0, 574, 0, 574,
+ 0, 416, 0, 415, 151, 574, 0, 513, 0, 515,
+ 517, 0, 509, 510, 124, 0, 472, 481, 473, 0,
+ 164, 163, 574, 0, 0, 321, 320, 0, 574, 0,
+ 574, 0, 0, 0, 0, 0, 94, 85, 0, 111,
+ 0, 167, 0, 144, 419, 420, 574, 0, 511, 512,
+ 514, 0, 0, 521, 522, 0, 574, 0, 161, 426,
+ 194, 0, 574, 0, 574, 574, 574, 0, 249, 574,
+ 87, 120, 0, 0, 414, 152, 518, 0, 471, 483,
+ 165, 0, 574, 220, 0, 574, 0, 0, 0, 574,
+ 219, 0, 137, 0, 519, 195, 221, 0, 243, 245,
+ 0, 226, 574, 574, 574, 0, 0, 0, 246, 248,
+ 403, 0, 224, 223, 222, 574, 138, 520, 0, 244,
+ 225, 247
};
-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
- STATE-NUM. */
-#define YYPACT_NINF -782
-static const yytype_int16 yypact[] =
+ /* YYPGOTO[NTERM-NUM]. */
+static const yytype_int16 yypgoto[] =
{
- 717, 1945, 2069, 87, 80, 2674, -782, -782, -48, -782,
- -782, -782, -782, -782, -782, -782, -782, -782, -782, -782,
- -782, -48, -782, -782, -782, -782, -782, 77, -782, -782,
- -782, -782, -782, 176, -782, -782, -23, 177, -782, 250,
- 3576, 819, 877, 819, -782, -782, 3628, -782, 176, -782,
- 239, -782, 269, 288, 3321, -782, 85, -782, -782, -782,
- 179, -782, -782, 342, 346, 2193, 354, -782, -782, 346,
- 361, 375, 384, -782, -782, -782, 391, -782, 308, 192,
- 407, 152, 433, 316, 530, 3372, 3372, 449, 460, 342,
- 472, 380, -782, -782, -782, -782, -782, -782, -782, -782,
- -782, -782, 346, -782, -782, -782, -782, -782, -782, -782,
- 420, -782, -782, -782, -782, -782, -782, -782, -782, -782,
- -782, -782, -782, -782, -782, -782, -782, -782, -782, 3423,
- -782, 1758, -782, -782, -782, 310, -782, 50, 461, -782,
- 819, -782, 1475, 432, 1882, 2439, 37, 294, 176, -782,
- -782, 252, 137, 252, 340, 139, 412, -782, -782, -782,
- -782, 518, 59, -782, -782, -782, 499, -782, 503, -782,
- -782, 441, -782, 95, 441, 441, -782, 506, 180, 909,
- -782, 347, 176, 555, 563, -782, 441, 3270, 3321, 176,
- 539, 245, -782, 553, 598, -782, -782, 441, 611, -782,
- -782, -782, 617, 3321, 601, 161, 587, 593, 441, 342,
- 617, 3321, 3321, 176, 342, 97, 146, 441, 967, 548,
- 206, 927, 325, -782, -782, -782, -782, -782, -782, -782,
- -782, -782, 2439, 605, 2439, 2439, 2439, 2439, 2439, 2439,
- -782, 562, -782, 623, 627, 309, 1716, 25, -782, -782,
- 617, -782, -782, -782, 239, 575, -782, 2378, 121, 635,
- 645, 966, 583, -782, 639, 2439, -782, 3573, -782, 1716,
- 2378, 176, 404, 340, -782, -782, 565, -782, -782, 3321,
- 2006, -782, 3321, 2130, 37, 404, 340, 594, 1053, -782,
- -782, 239, 660, 3321, -782, -782, -782, 665, 617, -782,
- -782, 318, 667, -782, -782, -782, 274, 252, -782, 669,
- 671, 681, 675, 463, 685, 682, -782, 692, 691, -782,
- 176, -782, -782, 695, 697, -782, 700, 704, 3372, -782,
- -782, -782, -782, -782, 3372, -782, -782, -782, 706, -782,
- -782, 599, 154, 708, 655, -782, 718, -782, 53, -782,
- -782, 60, 396, 164, 164, 653, 734, 145, 738, 146,
- 677, 1053, 40, 743, -782, 2563, 1060, -782, 588, 1280,
- 3474, 1145, -782, -782, -782, -782, -782, -782, 1758, -782,
- -782, -782, 2439, 2439, 2439, 2439, 2439, 2439, 2439, 2439,
- 2439, 2439, 2439, 2439, 2439, 2439, 2439, 2439, 2439, -782,
- 461, 452, 1025, 678, 382, -782, -782, -782, 452, 592,
- 686, 164, 2439, 1716, -782, 969, 12, -782, 3321, 2254,
- -782, 758, -782, 3602, 762, -782, 3647, 404, 340, 972,
- 146, 404, -782, -782, 503, 381, -782, 441, 1407, -782,
- 763, 769, -782, -782, -782, 589, 402, 1356, 776, 3321,
- 909, 764, -782, 779, 2775, -782, 438, 3372, 508, 785,
- 757, 593, 212, 792, 441, 3321, 736, -782, 3321, -782,
- -782, -782, 164, 256, 146, 33, -782, 1068, -782, 775,
- 797, 653, 803, 425, -782, 319, 1651, -782, -782, 798,
- -782, -782, 2439, 2315, 2500, 10, 877, 623, 1082, 1082,
- 1310, 1310, 2541, 1267, 1162, 1519, 1219, 1145, 1044, 1044,
- 755, 755, -782, -782, -782, 176, 686, -782, -782, -782,
- 452, 633, 3676, 642, 686, -782, 146, 808, -782, 3721,
- -782, -782, -782, -782, 146, 404, 340, 404, -782, -782,
- -782, 617, 2876, -782, 813, -782, 154, 834, -782, -782,
- 1651, -782, -782, 617, -782, -782, -782, 810, -782, 715,
- 617, -782, 799, 122, 673, 402, -782, 715, -782, -782,
- -782, 2977, 342, 3525, 850, -782, -782, 3321, -782, -782,
- 299, 731, -782, 771, -782, 836, 838, -782, 584, 718,
- -782, 715, 100, 146, -782, 882, 51, -782, 1052, 3321,
- 909, -782, -782, -782, 848, -782, -782, -782, 849, 818,
- 826, 830, 780, 518, -782, -782, -782, -782, -782, -782,
- -782, -782, -782, -782, -782, -782, -782, -782, -782, -782,
- -782, -782, -782, -782, 860, 1651, -782, -782, -782, -782,
- -782, -782, -782, -782, 3168, 866, 837, -782, 1716, 2439,
- 2500, 1821, 2439, 878, 881, -782, 2439, 252, -782, -782,
- -782, 767, -782, -782, 404, -782, 441, 441, 876, 3321,
- 884, 846, 736, -782, 1407, 293, 441, 888, -782, 715,
- 890, -782, 617, 20, 909, -782, 3372, -782, 895, 933,
- 73, -782, 79, 1758, 257, -782, -782, -782, -782, -782,
- -782, -782, -782, 3219, -782, 3078, 897, -782, 887, 775,
- 775, 811, 3321, -782, 867, -782, 903, 1060, 3321, 1651,
- -782, -782, -782, -782, 518, 906, 909, -782, 3474, 248,
- 115, 904, -782, 908, -782, 824, -782, 1651, 1716, 1716,
- 2439, -782, 1345, -782, -782, -782, -782, -782, 907, 3321,
- 911, -782, 617, 913, -782, 715, 885, 736, -782, -782,
- 917, 918, -782, -782, 299, -782, 299, -782, 863, -782,
- -782, 961, -782, -782, 2439, -782, 882, -782, 1060, 915,
- 920, 176, 510, -782, 252, 425, 929, -782, 1651, 935,
- 3321, 1060, 203, 2563, 2439, 941, 588, -782, 837, -782,
- -782, -782, 176, -782, 926, 1716, 945, 948, 3321, -782,
- 950, -782, 715, -782, -782, -782, -782, -782, 952, -782,
- 1716, 775, 425, 532, -782, 957, -782, 962, -782, -782,
- -782, -782, 252, 963, 3321, 974, 425, 3321, 976, -22,
- 981, 1507, -782, 971, -782, -782, 837, 922, -782, -782,
- 997, -782, 996, -782, -782, -782, -782, -782, 176, -782,
- -782, 1651, 999, 715, -782, 1001, 3321, 3321, 1003, 1052,
- -782, 922, -782, 176, -782, -782, 1060, -782, -782, -782,
- -782, 715, -782, 610, 715, 1004, 1008, 3321, -782, -782,
- 922, -782, 425, -782, 634, -782, -782, -782, 715, 715,
- 1011, -782, -782, -782, -782, -782, -782, -782, 715, 1013,
- -782, -782
+ -904, -904, -344, -904, -904, -904, -904, 43, 47, -4,
+ 56, -904, 690, -904, 58, 62, -904, -904, -904, 67,
+ -904, 68, -904, 75, -904, -904, 79, -904, 82, -523,
+ -642, 83, -904, 93, -904, -351, 674, -79, 95, 101,
+ 115, 116, -904, 532, -811, -666, -904, -904, -904, -867,
+ -748, -904, -130, -904, -904, -904, -904, -904, 7, -904,
+ -904, 203, 11, 12, -904, -904, 293, -904, 681, 537,
+ 121, -904, -904, -904, -708, -904, -904, -904, -904, 541,
+ -904, 552, 124, 557, -904, -904, -904, -533, -904, -904,
+ -904, -2, 60, -904, 725, 22, 422, -904, 664, 796,
+ -34, -572, -531, -40, 1162, -133, -144, -57, 26, -37,
+ -904, -56, 33, -22, 698, -524, 1203, -904, -357, -904,
+ -154, -904, -904, -904, -903, -904, 254, -904, 1142, -118,
+ -489, -904, -904, 209, 839, -904, -904, -904, 396, -904,
+ -904, -904, -222, -33, 304, 707, -398, -573, 211, -904,
+ -904, 230, -15, 984, -97, -904, 951, -193, -124, 1107,
+ -904, -323, 701, -904, 606, 239, -202, -512, 0
};
-/* YYPGOTO[NTERM-NUM]. */
-static const yytype_int16 yypgoto[] =
+ /* YYDEFGOTO[NTERM-NUM]. */
+static const yytype_int16 yydefgoto[] =
{
- -782, -782, -284, -782, -782, -782, -782, 21, 28, 13,
- 39, -782, 604, -782, 41, 45, -782, -782, -782, 54,
- -782, 63, -782, 66, -782, -782, 78, -782, 102, -443,
- -530, 106, -782, 124, -782, -287, 591, -84, 125, 157,
- 182, 196, -782, 467, -749, -679, -782, -782, -782, -782,
- 469, -782, -782, -781, -2, 6, -782, -782, -782, -782,
- 590, 473, 214, -782, -782, -782, -531, -782, -782, -782,
- 477, -782, 478, 228, -782, -782, -782, -782, -782, -782,
- -460, -782, -3, -42, -782, 643, 96, 389, -782, 597,
- 710, -15, 600, -782, -71, 48, -172, -85, -126, -32,
- -26, -782, 689, 23, -36, -782, 1051, -782, -299, -782,
- -782, -631, -782, 326, -782, 916, -118, -416, -782, -670,
- -782, -782, -782, 305, -782, -782, -782, -205, -82, 259,
- -524, 241, -782, -782, 253, 1092, -123, -782, 761, 44,
- -107, -782, -157, 781, 542, 215, -183, -419, 0
+ -1, 4, 5, 99, 100, 101, 657, 780, 781, 782,
+ 783, 106, 395, 396, 784, 785, 699, 109, 110, 786,
+ 112, 787, 114, 788, 659, 202, 789, 117, 790, 665,
+ 532, 791, 369, 792, 379, 231, 390, 232, 793, 794,
+ 795, 796, 520, 125, 725, 574, 706, 126, 711, 860,
+ 951, 1000, 41, 566, 127, 128, 129, 130, 797, 881,
+ 734, 1021, 798, 799, 697, 848, 399, 400, 401, 554,
+ 800, 135, 540, 375, 801, 979, 1081, 902, 802, 803,
+ 804, 805, 806, 807, 808, 809, 1083, 1096, 810, 916,
+ 137, 811, 298, 183, 346, 184, 282, 283, 449, 284,
+ 575, 165, 384, 166, 319, 167, 168, 169, 244, 43,
+ 44, 285, 197, 46, 47, 48, 49, 50, 306, 307,
+ 348, 309, 310, 421, 862, 863, 952, 1044, 287, 313,
+ 289, 290, 1016, 1017, 427, 428, 579, 730, 731, 878,
+ 967, 879, 51, 52, 732, 577, 815, 1097, 869, 960,
+ 1009, 1010, 176, 53, 355, 393, 54, 179, 55, 259,
+ 691, 837, 291, 292, 668, 193, 356, 654, 185
};
-/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
- positive, shift that token. If negative, reduce the rule which
- number is the opposite. If YYTABLE_NINF, syntax error. */
-#define YYTABLE_NINF -471
+ /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
+ positive, shift that token. If negative, reduce the rule whose
+ number is the opposite. If YYTABLE_NINF, syntax error. */
static const yytype_int16 yytable[] =
{
- 6, 204, 129, 124, 140, 130, 440, 348, 133, 213,
- 155, 125, 166, 247, 325, 141, 867, 158, 97, 668,
- 273, 133, 545, 587, 42, 42, 95, 149, 564, 286,
- 254, 545, 356, 96, 677, 672, 831, 454, 785, 217,
- 8, 460, 157, 680, 98, 131, 100, 222, 297, 652,
- 101, 525, 303, 8, 289, 291, 255, 260, 309, 104,
- 795, 759, 8, 313, 176, -245, 299, 706, 106, 176,
- 185, 108, 525, 855, 714, 270, 764, 42, 775, 776,
- 55, 478, 766, 109, -339, 337, 404, 864, 53, 409,
- 889, 710, 144, -155, 358, 868, 711, 39, 52, 822,
- 352, 299, 176, 172, 727, 137, 299, 111, 307, 901,
- 261, 112, 836, 131, 256, 275, 526, 471, 8, -245,
- 331, 276, 678, 135, 8, 54, 843, 653, 299, 113,
- 114, 251, 273, 131, 330, 286, 278, 593, 281, 300,
- 36, 707, 8, 902, 38, 316, 317, -155, 8, 8,
- 366, 157, 542, 157, 245, 757, 195, 253, 428, 142,
- 299, 327, 115, 271, 8, 42, 290, 8, 295, 343,
- 574, 571, 260, 155, -431, 279, 144, 270, 133, 8,
- 765, 404, 409, 354, 357, 260, 767, 116, 787, 488,
- 854, 133, 280, 170, 144, 191, 196, 892, 465, 142,
- 36, 117, 306, 285, 38, 332, 804, 336, 339, 362,
- 42, 42, 349, 155, 353, 580, 144, 171, 36, 126,
- 364, 147, 38, 809, 36, 402, 42, 240, 38, 751,
- 149, 810, 305, 128, 42, 42, 192, 421, 415, 521,
- 424, 837, 36, 380, 420, 157, 38, 148, 36, 36,
- 461, 8, 38, 38, 543, 753, 284, 833, 545, 8,
- 247, 769, 172, 348, 36, 271, 285, 36, 38, 147,
- 138, 38, 271, 131, 354, 273, 286, 8, 146, 36,
- 42, 585, 428, 38, 182, 147, 793, 148, 852, 286,
- 148, 139, 441, 42, 306, 36, 8, 320, 399, 38,
- 521, 770, 42, 536, 143, 42, 705, 157, 347, 36,
- 164, 8, 8, 38, 813, 581, 42, 214, 515, 582,
- 838, 6, 794, 480, 562, 474, 145, 147, 8, 165,
- 880, 306, 427, 354, 754, 432, 431, 495, 131, 883,
- 485, 28, 29, 30, 161, 714, 470, 142, 172, -470,
- 296, 36, 133, 172, 198, 38, 252, 199, 437, 36,
- 200, 143, 133, 38, 144, 216, 157, 162, 491, 367,
- 438, 143, 147, 216, 148, 559, 527, 36, 282, 567,
- 147, 38, 148, 145, 174, 539, 308, 172, 42, 434,
- 189, 353, 181, 145, 536, 283, 36, 604, 147, 183,
- 38, 245, 591, -470, 689, 8, 554, 427, 172, 431,
- 216, 36, 36, 186, 780, 38, 38, 147, 147, 148,
- 279, 518, 187, 8, 897, 540, 146, 690, 36, 188,
- 31, 32, 38, 147, 295, 148, 6, 280, 906, 907,
- 306, 42, 418, 555, 296, 194, 556, 172, 910, 34,
- 35, 129, 124, 573, 130, 6, 130, 61, 215, 419,
- 125, 336, 275, 523, 155, 600, 601, 97, 651, 602,
- 605, 197, 42, 212, 240, 95, 263, 535, 537, 597,
- 572, 149, 96, 745, 746, 157, 645, 208, 42, 131,
- 257, 42, 594, 98, 679, 100, 157, 380, 209, 101,
- -470, -470, 446, 447, 557, 36, 725, 144, 104, 38,
- 211, 31, 32, 73, 74, 75, 288, 106, 77, 216,
- 108, 8, 523, 36, -470, 535, 147, 38, 148, 717,
- 34, 35, 109, 671, 201, 688, 172, 216, 292, 129,
- 124, 671, 130, 293, 147, 566, 148, 304, 125, 575,
- 645, 828, 576, 562, 829, 97, 111, 716, 311, 673,
- 112, 586, 730, 95, 347, 671, 312, 673, 129, 124,
- 96, 130, 671, 856, 661, 247, 857, 125, 113, 114,
- 319, 98, 664, 100, 97, 703, 698, 101, 130, 470,
- 6, 673, 95, 551, 699, 172, 104, 322, 673, 96,
- 42, 323, 761, 61, 755, 106, 909, 816, 108, 817,
- 98, 115, 100, 760, 326, 140, 101, 789, 275, 420,
- 109, 222, 42, 299, 651, 104, 572, 748, 333, 487,
- 279, 519, -470, 334, 106, 645, 116, 108, 463, 464,
- 778, 661, 743, 370, 111, 328, 736, 280, 112, 109,
- 117, 895, 361, 671, 896, 791, 377, 157, 366, 73,
- 74, 75, 488, 378, 77, 381, 113, 114, 126, 400,
- 779, 279, 658, 111, 406, 903, 786, 112, 904, 673,
- 418, 660, 128, 133, 407, 812, 905, 411, 280, 147,
- 91, 485, 42, 251, 412, 113, 114, 419, 429, 115,
- 366, 433, 129, 124, 435, 130, 439, 807, 442, 597,
- 597, 125, 675, 676, 783, 443, 245, 157, 97, 645,
- 444, 450, 594, 594, 116, 449, 95, 445, 115, 671,
- 491, 451, 452, 96, 456, 42, 457, 645, 117, 458,
- 554, 42, 172, 459, 98, 462, 100, 466, 835, 467,
- 101, 840, 485, 116, 179, 673, 126, 472, 468, 104,
- 839, 354, 28, 29, 30, 485, 850, 117, 106, 830,
- 128, 108, 42, 473, 205, 205, 876, 555, 157, 476,
- 556, 477, 517, 109, 157, 126, 671, 479, 645, 240,
- 520, 157, 862, 670, 136, 865, 491, 530, 736, 128,
- 876, 532, 578, 156, 548, 418, 744, 111, 568, 160,
- 549, 112, 673, 42, 8, 565, 42, 860, 221, 876,
- 569, 597, 419, 577, 885, 886, 1, 2, 3, 113,
- 114, 42, 157, 584, 594, 65, 598, 671, 557, 190,
- 193, 599, 647, 671, 173, 900, 736, 662, 669, 306,
- 485, 674, 777, 666, 554, 671, 172, 42, 671, 692,
- 42, 645, 115, 673, 693, 202, 28, 29, 30, 673,
- 210, 219, 671, 671, 667, 694, 157, 396, 397, 398,
- 8, 673, 671, 695, 673, 708, 718, 116, 8, 42,
- 42, 685, 721, 720, 556, 799, 800, 801, 673, 673,
- 722, 117, 686, 262, 723, 726, 724, 274, 673, 277,
- 42, -170, 8, 732, 36, 142, 287, 740, 38, 126,
- 741, 747, 749, 306, 750, 8, 811, 756, 216, 143,
- 8, 758, 144, 128, 762, 147, 763, 148, 773, 774,
- 219, 781, 784, 310, 790, 797, 806, 306, 798, 808,
- 318, 145, 298, 676, 823, 298, 298, 818, 814, 815,
- 306, 824, 298, 874, 8, 365, 156, 298, 832, 8,
- 8, 847, 8, 834, 350, 8, 355, 274, 298, 360,
- 36, 136, 219, 368, 38, 842, 848, 849, 36, 298,
- 342, 851, 38, 853, 146, 351, 298, 858, 298, 793,
- 859, 147, 216, 148, 142, 357, 156, 270, 861, 147,
- 270, 148, 36, 863, 866, 872, 38, 205, 403, 405,
- 869, 144, 410, 205, 144, 36, 216, 144, 8, 38,
- 36, 416, 417, 147, 38, 148, 877, 878, 881, 216,
- 884, 887, 544, 898, 216, 274, 147, 899, 148, 274,
- 908, 147, 579, 148, 911, 696, 8, 697, 589, 496,
- 267, 269, 704, 257, 36, 701, 702, 355, 38, 36,
- 36, 8, 36, 38, 38, 36, 38, 538, 216, 38,
- 144, 453, 768, 408, 359, 147, 408, 148, 497, 534,
- 712, 357, 148, 271, 655, 271, 654, 159, 271, 28,
- 29, 30, 821, 844, 713, 873, 357, 28, 29, 30,
- 888, 879, 143, 134, 405, 405, 687, 0, 475, 0,
- 274, 0, 274, 0, 0, 0, 481, 0, 36, 0,
- 670, 0, 38, 0, 145, 0, 0, 0, 482, 0,
- 0, 0, 408, 0, 0, 0, 205, 0, 369, 0,
- 371, 372, 373, 374, 375, 376, 36, 0, 0, 0,
- 38, 0, 0, 516, 394, 395, 396, 397, 398, 0,
- 430, 36, 405, 0, 0, 38, 524, 0, 0, 271,
- 0, 413, 0, 0, 0, 534, 0, 0, 0, 0,
- 274, 274, 0, 0, 271, 0, 423, 0, 0, 426,
- 392, 393, 394, 395, 396, 397, 398, 219, 0, 0,
- 0, 219, 0, 0, 0, 0, 541, 0, 298, 546,
- 0, 0, 0, 0, 0, 0, 553, 560, 563, 0,
- 0, 0, 0, 405, 219, 274, 0, 0, 274, 0,
- 0, 382, 383, 384, 385, 298, 0, 560, 0, 0,
- 0, 0, 0, 0, 592, 0, 0, 156, 382, 383,
- 384, 385, 684, 392, 393, 394, 395, 396, 397, 398,
- 0, 0, 0, 0, 0, 0, 657, 389, 390, 391,
- 392, 393, 394, 395, 396, 397, 398, 274, 0, 0,
- 0, 0, 0, 0, 0, 274, 0, 0, 498, 499,
- 500, 501, 502, 503, 504, 505, 506, 507, 508, 509,
- 510, 511, 512, 513, 514, 382, 383, 384, 385, 492,
- 0, 0, 0, 0, 0, 0, 219, 0, 522, 0,
- 0, 0, 0, 729, 0, 529, 391, 392, 393, 394,
- 395, 396, 397, 398, 0, 0, 560, 0, 0, 0,
- 0, 0, 0, 682, 274, 560, 0, 0, 0, 296,
- 0, 219, 172, 382, 383, 384, 385, 224, 225, 226,
- 227, 228, 229, 230, 231, 205, 382, 383, 384, 385,
- 386, 388, 389, 390, 391, 392, 393, 394, 395, 396,
- 397, 398, 771, 387, 388, 389, 390, 493, 392, 393,
- 394, 395, 396, 397, 494, 731, 382, 383, 648, 507,
- 514, 0, 0, 172, 0, 0, 0, 792, 224, 225,
- 226, 227, 228, 229, 230, 231, 0, 0, 392, 393,
- 394, 395, 396, 397, 398, 0, 219, 0, 0, 0,
- 0, 382, 383, 384, 385, 219, 0, 298, 298, 0,
- 0, 0, 0, 560, 0, 752, 0, 298, 387, 388,
- 389, 390, 391, 392, 393, 394, 395, 396, 397, 398,
- 0, 0, 219, 0, 0, 0, 0, 0, 8, 0,
- 0, 0, 0, 0, 0, 0, 0, 219, 0, 0,
- 219, 796, 0, 0, 0, 9, 10, 11, 12, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 257, 0, 0, 0, 219, 0, 0,
- 0, 27, 28, 29, 30, 31, 32, 0, 0, 0,
- 144, 0, 219, 0, 0, 0, 0, 0, 560, 0,
- 0, 0, 827, 33, 34, 35, 0, 0, 870, 0,
- 0, 0, 0, 0, 481, 0, 0, 0, 0, 0,
- 0, 0, 0, 845, 0, 738, 374, 0, 739, 0,
- 0, 0, 742, 0, 0, 0, 0, 0, 36, 0,
- 0, 37, 38, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 258, 0, 0, 0, 0, 0, 0, 147,
- 0, 0, 0, 382, 383, 384, 385, 386, 219, 0,
- 0, 0, 0, 0, 0, 382, 383, 384, 385, 827,
- 387, 388, 389, 390, 391, 392, 393, 394, 395, 396,
- 397, 398, 219, 0, 891, 390, 391, 392, 393, 394,
- 395, 396, 397, 398, 0, 0, 0, 0, 0, 0,
- 0, 219, 606, 0, -470, 57, 805, 0, 58, 59,
- 60, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 61, -470, -470, -470, -470, -470, -470, -470, -470, -470,
- -470, -470, -470, -470, -470, -470, -470, -470, -470, 0,
- 820, 0, 607, 63, 0, 0, -470, 0, -470, -470,
- -470, -470, -470, 0, 0, 0, 0, 0, 0, 0,
- 841, 65, 66, 67, 68, 608, 70, 71, 72, -470,
- -470, -470, 609, 610, 611, 0, 73, 612, 75, 0,
- 76, 77, 78, 0, 0, 0, 82, 0, 84, 85,
- 86, 87, 88, 89, 0, 0, 0, 0, 0, 0,
- 0, 0, 90, 0, -470, 0, 0, 91, -470, -470,
- 0, 8, 0, 0, 172, 0, 0, 0, 223, 224,
- 225, 226, 227, 228, 229, 230, 231, 613, 9, 10,
- 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
- 21, 22, 23, 24, 25, 26, 232, 0, 0, 0,
- 0, 0, 0, 0, 27, 28, 29, 30, 31, 32,
- 0, 233, 382, 383, 384, 385, 386, 0, 0, 0,
- 0, 0, 0, 0, 8, 0, 33, 34, 35, 387,
- 388, 389, 390, 391, 392, 393, 394, 395, 396, 397,
- 398, 9, 10, 11, 12, 13, 14, 15, 16, 17,
- 18, 19, 20, 21, 22, 23, 24, 25, 26, 0,
- 0, 36, 0, 0, 37, 38, 0, 0, 0, 0,
- 0, 31, 32, 0, 0, 234, 0, 0, 235, 236,
- 0, 0, 237, 238, 239, 8, 0, 0, 172, 33,
- 34, 35, 223, 224, 225, 226, 227, 228, 229, 230,
- 231, 0, 9, 10, 11, 12, 13, 14, 15, 16,
- 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
- 232, 0, 0, 0, 36, 0, 0, 0, 38, 28,
- 29, 30, 31, 32, 0, 233, 0, 0, 266, 0,
- 0, 0, 0, 0, 0, 147, 7, 0, 8, 0,
- 33, 34, 35, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 9, 10, 11, 12, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 0, 0, 36, 0, 0, 0, 38,
- 0, 27, 28, 29, 30, 31, 32, 0, 0, 234,
- 0, 0, 235, 236, 0, 0, 237, 238, 239, 8,
- 0, 0, 172, 33, 34, 35, 223, 224, 225, 226,
- 227, 228, 229, 230, 231, 0, 9, 10, 11, 12,
- 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
- 23, 24, 25, 26, 232, 0, 0, 0, 36, 0,
- 0, 37, 38, 28, 29, 30, 31, 32, 0, 233,
- 0, 0, 422, 0, 0, 0, 0, 0, 0, 0,
- 51, 0, 8, 0, 33, 34, 35, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
+ 6, 104, 308, 138, 525, 139, 676, 153, 249, 173,
+ 299, 164, 131, 229, 196, 403, 132, 133, 745, 671,
+ 380, 152, 258, 42, 57, 149, 880, 578, 695, 821,
+ 288, 538, 545, 652, 45, 45, 230, 230, 412, 708,
+ 857, 353, 652, 188, 8, 172, 947, 315, 102, 1001,
+ -290, 1003, 103, 341, 258, -181, 1066, 141, 622, 188,
+ 246, 105, 212, 107, 60, 238, 435, 108, 931, 194,
+ 373, 170, 111, 113, 194, 203, 142, 243, 564, 622,
+ 115, 374, 250, 147, 116, 177, 386, 118, 119, -529,
+ 350, 146, 45, 816, 911, 213, 357, 859, 120, 8,
+ 121, 824, 363, 320, 324, 251, 122, 367, 178, 194,
+ 742, 1030, -290, 338, 260, 294, 8, -181, 353, 182,
+ 123, 124, 189, 303, 247, 326, 134, 855, 148, 136,
+ 36, 37, 328, 623, 331, 661, 392, 188, 189, 8,
+ 418, 8, 868, 1074, 149, 1067, 414, 148, 293, 822,
+ 515, 299, 361, 1014, 702, 190, 360, 352, 140, 256,
+ 257, 8, 1072, 474, 476, 143, 172, 481, 172, 145,
+ 281, 556, 299, 969, 662, 1073, 649, 663, 727, 220,
+ 300, 286, 304, 305, 347, 36, 37, 45, 325, 144,
+ 385, 682, 940, 376, 978, 743, 679, 1031, 744, 329,
+ 1032, 148, 36, 37, 353, 162, 964, 308, 419, 438,
+ 425, 38, 27, 28, 29, 40, 330, 439, 8, 151,
+ 646, 221, 188, 353, 1106, 36, 37, 36, 37, 8,
+ 387, 717, 391, 394, 941, 148, 1075, 404, 45, 320,
+ 324, 45, 148, 338, 354, 664, 1080, 36, 37, 423,
+ 928, 430, 164, 38, 256, 342, 170, 40, 721, 402,
+ 186, 45, 647, 550, 407, 370, 409, 408, 371, 45,
+ 45, 1027, 162, 38, 474, 476, 481, 40, 506, 509,
+ 572, 573, 987, 8, 450, 156, 172, 918, 382, 226,
+ 985, 188, 162, 922, 8, 353, 398, 162, 180, 722,
+ 723, 58, 426, 724, 36, 37, 924, 158, 578, 181,
+ 546, -410, 170, 200, -410, 36, 37, 867, 537, 650,
+ 154, 472, 661, -254, 188, 1092, 524, 230, 45, 652,
+ 288, 403, 856, 230, 934, 581, 835, 157, -574, 1047,
+ 59, 38, 489, 187, -410, 40, 332, 693, 239, 45,
+ 616, 617, 496, 988, 192, 854, 1057, 8, 1116, 836,
+ 172, 830, 45, 333, 663, 45, 493, 517, 426, 36,
+ 37, 148, 831, 1095, 295, 6, 1098, 199, 45, 1099,
+ 36, 37, 590, 494, 66, 409, 521, 1100, 576, 497,
+ 8, 157, 500, 386, 154, 38, -574, 201, 522, 159,
+ 1024, 555, 155, 584, 204, 991, 479, 680, 156, 480,
+ 937, 157, 205, 320, 324, 338, 921, 1038, 163, 583,
+ 208, 567, 506, 509, 616, 172, 1042, 413, 8, 430,
+ 158, 188, 338, 210, 669, 334, 30, 31, 211, 559,
+ 78, 79, 80, 36, 37, 82, 223, 83, 84, 224,
+ 409, 209, 225, 640, 148, 33, 34, 45, -574, 30,
+ 31, 1108, 683, 589, 1109, 684, 1040, -543, -543, 38,
+ 281, 219, 1110, 159, 578, 8, 36, 37, 33, 34,
+ 160, 286, 713, 161, 568, 714, 230, 8, 162, 1084,
+ 666, -543, 163, 858, 674, 570, 868, 385, 658, 859,
+ 188, 1053, 38, 571, 572, 573, 40, 1054, 949, 957,
+ 237, 950, 316, 415, 36, 37, 416, 347, 700, 222,
+ 6, 45, 8, 954, 413, 318, 45, 233, 955, 157,
+ 304, 305, 317, 234, 104, 188, 138, 387, 139, 681,
+ 6, 139, 726, 712, 728, 131, 391, 236, 619, 132,
+ 133, 741, 1101, 625, 1012, 673, 164, 1013, 640, 206,
+ 207, 36, 37, 170, 8, 252, 45, 900, 901, 1112,
+ 1113, 1114, 694, 36, 37, 402, 172, 1048, 172, 733,
+ 1049, 102, 1120, 45, 253, 103, 45, 38, 304, 305,
+ 172, 40, 450, 254, 105, 302, 107, 344, 479, 38,
+ 108, 480, 340, 40, 345, 111, 113, 578, 36, 37,
+ 318, 214, 994, 115, 325, 995, 170, 116, 329, 612,
+ 118, 119, 318, 358, 578, 828, 329, 613, 377, 814,
+ 353, 120, 823, 121, 38, 330, 383, 814, 40, 122,
+ 388, 329, 614, 330, 389, 104, 418, 138, 431, 139,
+ 36, 37, 432, 123, 124, 909, 131, 812, 330, 134,
+ 132, 133, 136, 814, 530, 531, 817, 329, 749, 576,
+ 433, 867, 493, 752, 817, 104, 688, 138, 814, 139,
+ 689, 249, 872, 436, 330, 447, 131, 548, 549, 494,
+ 132, 133, 102, 873, 448, 852, 103, 139, 555, 6,
+ 817, 451, 882, 741, 845, 105, 172, 107, 846, 847,
+ 861, 108, 308, 469, 864, 817, 111, 113, 45, 152,
+ 288, 403, 102, 669, 115, 8, 103, 172, 116, 819,
+ 820, 118, 119, 483, 812, 105, 172, 107, 477, 493,
+ 891, 108, 120, 478, 121, 833, 111, 113, 484, 45,
+ 122, 488, 932, 1118, 115, 917, 494, 491, 116, 162,
+ 485, 118, 119, 495, 123, 124, 325, 496, 216, 191,
+ 134, 503, 120, 136, 121, 230, 870, 516, 251, 926,
+ 122, 510, 518, 980, 523, 526, 814, 528, 930, 30,
+ 31, 527, 227, 529, 123, 124, 917, 235, 533, 534,
+ 134, 535, 812, 136, 1008, 536, 541, 865, 33, 34,
+ 238, 36, 37, 1, 2, 3, 27, 28, 29, 251,
+ 542, 866, 543, 817, 462, 463, 464, 465, 466, 467,
+ 468, 544, 547, 972, 552, 576, 551, 38, 293, 553,
+ 943, 40, 27, 28, 29, 557, 45, 570, 558, 561,
+ 104, 562, 138, 386, 139, 571, 572, 573, 563, 982,
+ 281, 131, 466, 467, 468, 132, 133, 580, 961, 611,
+ 565, 286, 172, 920, 733, 591, 624, 425, 875, 876,
+ 877, 812, 615, 628, 629, 631, 997, 990, 351, 814,
+ 633, 45, 655, 351, 351, 634, 635, 102, 45, 641,
+ 351, 103, 812, 642, 419, 351, 656, 672, 675, 685,
+ 105, 678, 107, 696, 8, 1005, 108, 686, 948, 692,
+ 715, 111, 113, 351, 710, 956, 817, 716, 1022, 115,
+ 719, 729, 735, 116, 351, 397, 118, 119, 164, 720,
+ 406, 351, 746, 404, 351, 751, 1111, 120, 861, 121,
+ 861, 413, 864, 814, 864, 122, 308, 385, 755, 322,
+ 759, 760, 814, 761, 762, 402, 1018, 733, 576, 123,
+ 124, 765, 172, 766, 767, 134, 45, 769, 136, 812,
+ 770, 813, 818, 1022, 838, 576, 825, 839, 886, 840,
+ 817, 70, 150, 156, 834, 874, 171, 387, 170, 817,
+ 36, 37, 887, 175, 888, 172, 889, 894, 1033, 904,
+ 409, 907, 895, 896, 45, 158, 1091, 45, 898, 570,
+ 8, 899, 172, 170, 903, 814, 38, 571, 572, 573,
+ 40, 905, 814, 906, 908, 910, 215, 218, -197, 927,
+ 929, 1029, 861, 933, 1035, 814, 864, 8, 814, 318,
+ 942, 946, 959, 958, 198, 962, 1018, 154, 968, 981,
+ 974, 45, 817, 45, 975, 814, 814, 814, 245, 817,
+ 217, -252, 986, 992, 157, 820, -251, -253, 814, 983,
+ -250, 812, 817, 993, 154, 817, 996, 999, 1061, 1002,
+ 1063, 1006, 155, 8, 1007, 1015, 255, 45, 45, 45,
+ 1023, 157, 817, 817, 817, 301, 36, 37, 1036, 1028,
+ 1037, 321, 321, 1039, 327, 817, 1043, 27, 28, 29,
+ 1050, 339, 45, 1051, 1086, 1087, 1088, 8, 1041, 8,
+ 413, 1052, 38, 36, 37, 1055, 159, 1059, 504, 464,
+ 465, 466, 467, 468, 1060, 1062, 1064, 245, 570, 1105,
+ 1065, 364, 1069, 1077, 1082, 163, 571, 572, 573, 38,
+ 1070, 1071, 1078, 159, 413, 372, 413, 1093, 1085, 1089,
+ 160, 349, 507, 161, 643, 1102, 349, 349, 162, 36,
+ 37, 171, 163, 349, 1094, 365, 366, 8, 349, 405,
+ 188, 411, 321, 321, 1103, 417, 1104, 859, 1107, 420,
+ 150, 245, 429, 378, 1115, 38, 349, 381, 1117, 40,
+ 1119, 1121, 651, 36, 37, 36, 37, 349, 8, 648,
+ 687, 8, 351, 653, 410, 362, 1058, 349, 318, 844,
+ 660, 667, 670, 422, 698, 853, 998, 171, 849, 38,
+ 434, 38, 645, 40, 592, 40, 473, 475, 475, 850,
+ 351, 482, 667, 174, 851, 413, 747, 1046, 154, 701,
+ 939, 707, 318, 763, 318, 1079, 155, 490, 582, 492,
+ 965, 1019, 156, 36, 37, 157, 8, 661, 718, 188,
+ 1090, 1076, 0, 0, 0, 343, 321, 321, 832, 304,
+ 305, 321, 0, 0, 158, 0, 0, 0, 0, 312,
+ 314, 0, 0, 519, 36, 37, 0, 36, 37, 0,
+ 411, 0, 0, 359, 0, 0, 662, 0, 0, 663,
+ 0, 155, 0, 323, 0, 0, 0, 539, 0, 0,
+ 38, 0, 337, 38, 40, 0, 0, 159, 0, 0,
+ 0, 8, 0, 0, 160, 0, 0, 161, 0, 0,
+ 0, 0, 162, 318, 0, 0, 163, 8, 475, 475,
+ 475, 0, 36, 37, 560, 0, 321, 321, 8, 321,
+ 0, 188, 0, 667, 0, 569, 0, 0, 316, 0,
+ 0, 827, 0, 667, 0, 0, 317, 664, 38, 0,
+ 0, 0, 159, 0, 359, 157, 0, 0, 0, 241,
+ 0, 0, 242, 0, 323, 359, 337, 162, 0, 0,
+ 0, 163, 0, 155, 437, 0, 440, 441, 442, 443,
+ 444, 445, 446, 610, 0, 0, 0, 36, 37, 0,
+ 0, 0, 0, 0, 475, 475, 0, 8, 0, 0,
+ 621, 0, 0, 36, 37, 0, 0, 0, 0, 486,
+ 8, 0, 0, 38, 36, 37, 0, 40, 0, 0,
+ 0, 321, 0, 0, 321, 0, 0, 0, 0, 38,
+ 351, 351, 499, 159, 359, 502, 318, 925, 0, 0,
+ 38, 245, 155, 0, 159, 245, 0, 359, 171, 0,
+ 989, 241, 163, 0, 242, 155, 0, 505, 508, 162,
+ 0, 0, 514, 163, 0, 349, 0, 0, 475, 245,
+ 321, 0, 0, 321, 709, 349, 0, 667, 0, 923,
+ 0, 351, 0, 36, 37, 0, 0, 8, 0, 0,
+ 0, 690, 0, 349, 0, 736, 36, 37, 0, 0,
+ 0, 171, 0, 827, 0, 0, 0, 0, 0, 38,
+ 0, 0, 0, 159, 0, 0, 0, 0, 0, 0,
+ 241, 0, 38, 242, 413, 0, 159, 0, 162, 0,
+ 0, 0, 163, 241, 321, 321, 242, 505, 508, 321,
+ 514, 162, 0, 8, 321, 163, 0, 0, 0, 321,
+ 0, 0, 0, 0, 593, 594, 595, 596, 597, 598,
+ 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,
+ 609, 0, 0, 36, 37, 0, 0, 0, 0, 0,
+ 240, 8, 0, 245, 0, 0, 0, 618, 155, 667,
+ 0, 0, 0, 0, 0, 0, 627, 0, 0, 38,
+ 0, 0, 0, 40, 0, 8, 0, 841, 0, 0,
+ 0, 620, 0, 321, 0, 0, 0, 0, 359, 0,
+ 0, 1004, 318, 0, 0, 829, 155, 0, 0, 36,
+ 37, 0, 639, 245, 0, 644, 0, 0, 0, 0,
+ 8, 0, 359, 0, 0, 1020, 8, 0, 0, 0,
+ 155, 0, 0, 0, 0, 38, 0, 0, 0, 159,
+ 0, 8, 0, 0, 0, 0, 241, 36, 37, 242,
+ 321, 321, 0, 0, 162, 0, 321, 316, 163, 0,
+ 0, 620, 0, 295, 639, 334, 0, 737, 599, 602,
+ 607, 36, 37, 38, 157, 0, 0, 159, 359, 0,
+ 157, 0, 0, 0, 241, 0, 155, 242, 0, 0,
+ 0, 0, 162, 349, 349, 0, 163, 38, 0, 0,
+ 0, 159, 919, 0, 0, 0, 36, 37, 241, 0,
+ 245, 242, 36, 37, 0, 0, 162, 0, 0, 245,
+ 163, 0, 0, 0, 0, 753, 754, 36, 37, 8,
+ 757, 0, 38, 0, 0, 758, 40, 0, 38, 0,
+ 764, 0, 40, 335, 349, 0, 336, 0, 0, 479,
+ 0, 0, 480, 38, 0, 318, 8, 159, 935, 936,
+ 938, 8, 0, 0, 241, 0, 424, 242, 0, 966,
+ 188, 0, 162, 0, 155, 0, 163, 264, 265, 266,
+ 267, 268, 269, 270, 271, 321, 953, 0, 0, 321,
+ 321, 0, 0, 316, 0, 0, 0, 0, 984, 871,
+ 0, 636, 0, 0, 753, 0, 155, 0, 245, 0,
+ 157, 0, 0, 0, 0, 36, 37, 0, 245, 0,
+ 883, 884, 444, 0, 885, 0, 0, 0, 0, 0,
+ 890, 0, 0, 0, 0, 245, 0, 0, 0, 0,
+ 0, 38, 36, 37, 0, 159, 245, 36, 37, 0,
+ 1011, 0, 241, 0, 0, 242, 0, 0, 0, 245,
+ 162, 892, 893, 171, 163, 321, 321, 897, 38, 0,
+ 0, 0, 40, 38, 0, 569, 0, 159, 0, 637,
+ 0, 0, 638, 0, 241, 0, 0, 242, 171, 0,
+ 0, 318, 162, 0, 0, 0, 163, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 771,
+ 1056, -574, 62, 0, 245, 0, 63, 64, 65, 0,
+ 0, 0, 0, 27, 28, 29, 0, 953, 156, 66,
+ -574, -574, -574, -574, -574, -574, -574, -574, -574, -574,
+ -574, -574, 1011, -574, -574, -574, -574, -574, 0, 0,
+ 158, 772, 68, 0, 570, -574, 0, -574, -574, -574,
+ -574, -574, 571, 572, 573, 0, 0, 0, 970, 971,
+ 70, 71, 72, 73, 773, 75, 76, 77, -574, -574,
+ -574, 774, 775, 776, 0, 78, 777, 80, 0, 81,
+ 82, 778, 83, 84, -574, -574, 973, -574, -574, 85,
+ 976, 977, 0, 89, 0, 91, 92, 93, 94, 95,
+ 96, 0, 0, 0, 0, 0, 452, 453, 454, 455,
+ 0, 97, 0, -574, 452, 453, 98, -574, -574, 0,
+ 0, 0, 8, 0, 0, 188, 459, 460, 461, 462,
+ 463, 464, 465, 466, 467, 468, 779, 462, 463, 464,
+ 465, 466, 467, 468, 0, 9, 10, 11, 12, 13,
+ 14, 15, 16, 0, 18, 1034, 20, 0, 0, 22,
+ 23, 24, 25, 0, 0, 0, 1025, 1026, 8, 0,
+ 0, 188, 261, 0, 1045, 0, 262, 263, 264, 265,
+ 266, 267, 268, 269, 270, 271, 0, 9, 10, 11,
+ 12, 13, 14, 15, 16, 17, 18, 19, 20, 0,
+ 21, 22, 23, 24, 25, 272, 0, 0, 36, 37,
+ 66, 0, 0, 26, 27, 28, 29, 30, 31, 0,
+ 273, 0, 0, 0, 304, 305, 0, 0, 0, 0,
+ 0, 0, 0, 842, 38, 32, 33, 34, 40, 0,
+ 0, 0, 0, 0, 0, 407, 0, 0, 408, 0,
+ 0, 35, 0, 162, 36, 37, 8, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 78, 79, 80, 0,
+ 0, 82, 778, 83, 84, 0, 0, 0, 0, 0,
+ 38, 0, 0, 39, 40, 0, 0, 0, 0, 0,
+ 0, 274, 0, 413, 275, 0, 0, 276, 277, 278,
+ 0, 511, 8, 279, 280, 188, 261, 843, 8, 0,
+ 262, 263, 264, 265, 266, 267, 268, 269, 270, 271,
+ 0, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+ 18, 19, 20, 0, 21, 22, 23, 24, 25, 272,
+ 0, 0, 36, 37, 0, 316, 0, 0, 27, 28,
+ 29, 30, 31, 322, 273, 0, 0, 311, 0, 0,
+ 0, 0, 157, 0, 0, 0, 0, 0, 38, 32,
+ 33, 34, 40, 0, 0, 452, 453, 454, 455, 512,
+ 0, 0, 513, 0, 0, 35, 0, 0, 36, 37,
+ 8, 318, 0, 0, 36, 37, 460, 461, 462, 463,
+ 464, 465, 466, 467, 468, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 38, 0, 0, 0, 40, 0,
+ 38, 0, 0, 0, 40, 274, 0, 413, 275, 0,
+ 0, 276, 277, 278, 0, 636, 8, 279, 280, 188,
+ 261, 0, 8, 318, 262, 263, 264, 265, 266, 267,
+ 268, 269, 270, 271, 0, 9, 10, 11, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 0, 21, 22,
+ 23, 24, 25, 272, 0, 0, 36, 37, 0, 316,
+ 0, 0, 27, 28, 29, 30, 31, 504, 273, 0,
+ 0, 498, 0, 0, 0, 0, 157, 0, 0, 0,
+ 0, 0, 38, 32, 33, 34, 40, 0, 0, 0,
+ 0, 0, 0, 637, 0, 0, 638, 0, 0, 35,
+ 0, 0, 36, 37, 8, 318, 0, 188, 36, 37,
+ 0, 0, 0, 0, 264, 265, 266, 267, 268, 269,
+ 270, 271, 0, 0, 0, 0, 0, 0, 38, 0,
+ 0, 0, 40, 0, 38, 0, 0, 0, 40, 274,
+ 0, 0, 275, 0, 0, 276, 277, 278, 0, 0,
+ 8, 279, 280, 188, 261, 0, 8, 318, 262, 263,
+ 264, 265, 266, 267, 268, 269, 270, 271, 0, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
- 20, 21, 22, 23, 24, 25, 26, 0, 0, 36,
- 0, 0, 0, 38, 0, 27, 28, 29, 30, 31,
- 32, 0, 0, 234, 0, 0, 235, 236, 0, 0,
- 237, 238, 239, 8, 0, 0, 172, 33, 34, 35,
- 223, 224, 225, 226, 227, 228, 229, 230, 231, 0,
- 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
- 19, 20, 21, 22, 23, 24, 25, 26, 232, 0,
- 0, 0, 36, 0, 0, 37, 38, 28, 29, 30,
- 31, 32, 0, 233, 0, 0, 425, 0, 0, 0,
- 0, 0, 0, 0, 177, 0, 178, 0, 33, 34,
- 35, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 9, 10, 11, 12, 13, 14, 15,
- 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
- 26, 0, 0, 36, 0, 0, 0, 38, 0, 0,
- 28, 29, 30, 31, 32, 0, 0, 234, 0, 0,
- 235, 236, 0, 0, 237, 238, 239, 8, 0, 0,
- 172, 33, 34, 35, 223, 224, 225, 226, 227, 228,
- 229, 230, 231, 0, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
- 25, 26, 232, 0, 0, 0, 36, 0, 0, 0,
- 38, 28, 29, 30, 31, 32, 0, 233, 0, 0,
- 528, 0, 0, 0, 0, 0, 0, 0, 8, 0,
- 0, 172, 33, 34, 35, 223, 224, 225, 226, 227,
- 228, 229, 230, 231, 0, 9, 10, 11, 12, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 232, 649, 0, 0, 36, 0, 0,
- 0, 38, 28, 29, 30, 31, 32, 0, 233, 0,
- 0, 234, 0, 0, 235, 236, 0, 0, 237, 238,
- 239, 8, 0, 33, 34, 35, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 9, 10,
- 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
- 21, 22, 23, 24, 25, 26, 257, 0, 36, 0,
- 0, 0, 38, 0, 27, 28, 29, 30, 31, 32,
- 0, 0, 234, 144, 0, 235, 236, 0, 0, 237,
- 238, 239, 8, 0, 0, 172, 33, 34, 35, 223,
- 224, 225, 226, 227, 228, 229, 230, 231, 0, 9,
+ 20, 0, 21, 22, 23, 24, 25, 272, 0, 0,
+ 36, 37, 0, 316, 0, 748, 27, 28, 29, 30,
+ 31, 507, 273, 0, 0, 501, 304, 305, 0, 0,
+ 157, 0, 0, 0, 0, 0, 0, 32, 33, 34,
+ 0, 0, 0, 0, 0, 0, 452, 453, 454, 455,
+ 0, 456, 0, 35, 0, 0, 36, 37, 0, 0,
+ 0, 0, 36, 37, 457, 458, 459, 460, 461, 462,
+ 463, 464, 465, 466, 467, 468, 0, 0, 0, 0,
+ 0, 0, 38, 0, 0, 0, 40, 0, 38, 0,
+ 0, 0, 40, 274, 0, 0, 275, 0, 0, 276,
+ 277, 278, 0, 0, 8, 279, 280, 188, 261, 585,
+ 0, 318, 262, 263, 264, 265, 266, 267, 268, 269,
+ 270, 271, 0, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 0, 21, 22, 23, 24,
+ 25, 272, 0, 0, 0, 0, 0, 0, 0, 0,
+ 27, 28, 29, 30, 31, 0, 273, 0, 0, 626,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 32, 33, 34, 0, 452, 453, 454, 455, 0,
+ 456, 0, 0, 452, 453, 454, 455, 35, 0, 0,
+ 36, 37, 0, 457, 586, 459, 460, 587, 462, 463,
+ 464, 465, 588, 467, 468, 461, 462, 463, 464, 465,
+ 466, 467, 468, 0, 0, 0, 38, 0, 0, 0,
+ 40, 0, 0, 0, 0, 963, 0, 274, 0, 0,
+ 275, 0, 0, 276, 277, 278, 0, 0, 8, 279,
+ 280, 188, 261, 0, 0, 0, 262, 263, 264, 265,
+ 266, 267, 268, 269, 270, 271, 0, 9, 10, 11,
+ 12, 13, 14, 15, 16, 17, 18, 19, 20, 0,
+ 21, 22, 23, 24, 25, 272, 738, 0, 0, 0,
+ 0, 0, 0, 0, 27, 28, 29, 30, 31, 0,
+ 273, 452, 453, 454, 455, 0, 456, 0, 0, 0,
+ 0, 0, 0, 0, 0, 32, 33, 34, 0, 457,
+ 458, 459, 460, 461, 462, 463, 464, 465, 466, 467,
+ 468, 35, 0, 0, 36, 37, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 38, 0, 0, 0, 40, 0, 0, 0, 0, 0,
+ 0, 274, 0, 0, 275, 0, 0, 276, 277, 278,
+ 0, 0, 8, 279, 280, 188, 261, 0, 1068, 0,
+ 262, 263, 264, 265, 266, 267, 268, 269, 270, 271,
+ 0, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+ 18, 19, 20, 0, 21, 22, 23, 24, 25, 272,
+ 739, 0, 0, 0, 0, 0, 0, 0, 27, 28,
+ 29, 30, 31, 0, 273, 452, 453, 454, 455, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 32,
+ 33, 34, 452, 453, 454, 455, 0, 456, 462, 463,
+ 464, 465, 466, 467, 468, 35, 0, 0, 36, 37,
+ 457, 458, 459, 460, 461, 462, 463, 464, 465, 466,
+ 467, 468, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 38, 0, 0, 0, 40, 0,
+ 0, 0, 0, 0, 0, 274, 0, 0, 275, 0,
+ 0, 276, 277, 278, 0, 0, 8, 279, 280, 188,
+ 261, 0, 0, 0, 262, 263, 264, 265, 266, 267,
+ 268, 269, 270, 271, 0, 9, 10, 11, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 0, 21, 22,
+ 23, 24, 25, 272, 0, 0, 0, 0, 0, 0,
+ 0, 0, 27, 28, 29, 30, 31, 0, 273, 452,
+ 453, 454, 455, 0, 456, 0, 0, 0, 0, 0,
+ 0, 0, 0, 32, 33, 34, 0, 457, 458, 459,
+ 460, 461, 462, 463, 464, 465, 466, 467, 468, 35,
+ 0, 0, 36, 37, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 38, 0,
+ 0, 0, 40, 0, 0, 0, 0, 0, 0, 274,
+ 0, 0, 275, 0, 0, 276, 277, 278, 0, 0,
+ 8, 279, 280, 188, 261, 0, 0, 0, 262, 263,
+ 264, 265, 266, 267, 268, 269, 270, 271, 0, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
- 20, 21, 22, 23, 24, 25, 26, 232, 0, 0,
- 0, 36, 0, 0, 37, 38, 28, 29, 30, 31,
- 32, 0, 233, 0, 0, 401, 0, 0, 0, 0,
- 0, 0, 147, 8, 0, 0, 172, 33, 34, 35,
- 223, 224, 225, 226, 227, 228, 229, 230, 231, 0,
- 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
- 19, 20, 21, 22, 23, 24, 25, 26, 232, 0,
- 0, 0, 36, 0, 0, 0, 38, 28, 29, 30,
- 31, 32, 0, 233, 0, 0, 234, 0, 0, 235,
- 236, 0, 0, 237, 238, 239, 8, 0, 33, 34,
- 35, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 9, 10, 11, 12, 13, 14, 15,
- 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
- 26, 0, 0, 36, 0, 0, 0, 38, 0, 27,
- 28, 29, 30, 31, 32, 656, 0, 0, 0, 0,
- 235, 236, 0, 0, 650, 238, 239, 0, 0, 0,
- 0, 33, 34, 35, 0, 0, 0, 382, 383, 384,
- 385, 386, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 387, 388, 389, 390, 391, 392,
- 393, 394, 395, 396, 397, 398, 36, 0, 0, 37,
- 38, 0, 0, 0, -2, 56, 0, -470, 57, 0,
- 353, 58, 59, 60, 0, 0, 0, 147, 0, 0,
- 0, 0, 0, 61, -470, -470, -470, -470, -470, -470,
- -470, -470, -470, -470, -470, -470, -470, -470, -470, -470,
- -470, -470, 0, 0, 0, 62, 63, 0, 0, 0,
- 0, -470, -470, -470, -470, -470, 0, 0, 64, 0,
- 0, 0, 0, 0, 65, 66, 67, 68, 69, 70,
- 71, 72, -470, -470, -470, 0, 0, 0, 0, 73,
- 74, 75, 0, 76, 77, 78, 79, 80, 81, 82,
- 83, 84, 85, 86, 87, 88, 89, 0, 0, 0,
- 0, 0, 0, 0, 0, 90, 56, -470, -470, 57,
- 91, -470, 58, 59, 60, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 61, -470, -470, -470, -470, -470,
- -470, -470, -470, -470, -470, -470, -470, -470, -470, -470,
- -470, -470, -470, 0, 0, 0, 62, 63, 0, 0,
- 570, 0, -470, -470, -470, -470, -470, 0, 0, 64,
- 0, 0, 0, 0, 0, 65, 66, 67, 68, 69,
- 70, 71, 72, -470, -470, -470, 0, 0, 0, 0,
- 73, 74, 75, 0, 76, 77, 78, 79, 80, 81,
- 82, 83, 84, 85, 86, 87, 88, 89, 0, 0,
- 0, 0, 0, 0, 0, 0, 90, 56, -470, -470,
- 57, 91, -470, 58, 59, 60, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 61, -470, -470, -470, -470,
- -470, -470, -470, -470, -470, -470, -470, -470, -470, -470,
- -470, -470, -470, -470, 0, 0, 0, 62, 63, 0,
- 0, 665, 0, -470, -470, -470, -470, -470, 0, 0,
- 64, 0, 0, 0, 0, 0, 65, 66, 67, 68,
- 69, 70, 71, 72, -470, -470, -470, 0, 0, 0,
- 0, 73, 74, 75, 0, 76, 77, 78, 79, 80,
- 81, 82, 83, 84, 85, 86, 87, 88, 89, 0,
- 0, 0, 0, 0, 0, 0, 0, 90, 56, -470,
- -470, 57, 91, -470, 58, 59, 60, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 61, -470, -470, -470,
- -470, -470, -470, -470, -470, -470, -470, -470, -470, -470,
- -470, -470, -470, -470, -470, 0, 0, 0, 62, 63,
- 0, 0, 681, 0, -470, -470, -470, -470, -470, 0,
- 0, 64, 0, 0, 0, 0, 0, 65, 66, 67,
- 68, 69, 70, 71, 72, -470, -470, -470, 0, 0,
- 0, 0, 73, 74, 75, 0, 76, 77, 78, 79,
- 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
- 0, 0, 0, 0, 0, 0, 0, 0, 90, 56,
- -470, -470, 57, 91, -470, 58, 59, 60, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 61, -470, -470,
- -470, -470, -470, -470, -470, -470, -470, -470, -470, -470,
- -470, -470, -470, -470, -470, -470, 0, 0, 0, 62,
- 63, 0, 0, 0, 0, -470, -470, -470, -470, -470,
- 0, 0, 64, 0, 0, 0, 772, 0, 65, 66,
- 67, 68, 69, 70, 71, 72, -470, -470, -470, 0,
- 0, 0, 0, 73, 74, 75, 0, 76, 77, 78,
- 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
- 89, 8, 0, 0, 0, 0, 0, 0, 0, 90,
- 0, -470, 0, 0, 91, -470, 0, 0, 9, 10,
- 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
- 21, 22, 23, 24, 25, 26, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 28, 29, 30, 31, 32,
+ 20, 0, 21, 22, 23, 24, 25, 272, 0, 0,
+ 0, 0, 0, 0, 0, 0, 27, 28, 29, 30,
+ 31, 0, 273, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 32, 33, 34,
0, 0, 8, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 220, 34, 35, 9,
+ 0, 0, 0, 35, 0, 0, 36, 37, 0, 0,
+ 0, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+ 18, 19, 20, 0, 21, 22, 23, 24, 25, 295,
+ 0, 0, 38, 0, 0, 0, 40, 26, 27, 28,
+ 29, 30, 31, 0, 0, 0, 157, 0, 0, 276,
+ 277, 740, 0, 0, 0, 279, 280, 0, 0, 32,
+ 33, 34, 452, 453, 454, 455, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 35, 0, 0, 36, 37,
+ 457, 458, 459, 460, 461, 462, 463, 464, 465, 466,
+ 467, 468, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 38, 8, 0, 39, 40, 0,
+ 0, 0, 0, 0, 0, 296, 0, 0, 297, 0,
+ 0, 0, 0, 162, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 0, 21, 22, 23,
+ 24, 25, 295, 0, 0, 0, 0, 0, 0, 0,
+ 26, 27, 28, 29, 30, 31, 0, 0, 0, 157,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 32, 33, 34, 0, 0, 8, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 35, 0,
+ 0, 36, 37, 0, 0, 0, 9, 10, 11, 12,
+ 13, 14, 15, 16, 17, 18, 19, 20, 0, 21,
+ 22, 23, 24, 25, 0, 0, 0, 38, 0, 0,
+ 39, 40, 26, 27, 28, 29, 30, 31, 470, 0,
+ 0, 471, 0, 0, 0, 0, 162, 0, 0, 0,
+ 0, 0, 0, 0, 32, 33, 34, 8, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 35, 0, 0, 36, 37, 0, 9, 10, 11, 12,
+ 13, 14, 15, 16, 17, 18, 19, 20, 0, 21,
+ 22, 23, 24, 25, 0, 0, 0, 0, 0, 38,
+ 0, 0, 39, 40, 0, 0, 30, 31, 0, 0,
+ 407, 0, 0, 408, 0, 0, 0, 0, 162, 0,
+ 0, 0, 0, 0, 32, 33, 34, -2, 61, 0,
+ -574, 62, 0, 0, 0, 63, 64, 65, 0, 0,
+ 35, 0, 0, 36, 37, 0, 0, 0, 66, -574,
+ -574, -574, -574, -574, -574, -574, -574, -574, -574, -574,
+ -574, 0, -574, -574, -574, -574, -574, 0, 0, 38,
+ 67, 68, 0, 40, 0, 0, -574, -574, -574, -574,
+ -574, 0, 0, 69, 0, 0, 0, 0, 162, 70,
+ 71, 72, 73, 74, 75, 76, 77, -574, -574, -574,
+ 0, 0, 0, 0, 78, 79, 80, 0, 81, 82,
+ 0, 83, 84, -574, -574, 0, -574, -574, 85, 86,
+ 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
+ 61, 0, -574, 62, 0, 0, 0, 63, 64, 65,
+ 97, 0, -574, 0, 0, 98, -574, 0, 0, 0,
+ 66, -574, -574, -574, -574, -574, -574, -574, -574, -574,
+ -574, -574, -574, 0, -574, -574, -574, -574, -574, 0,
+ 0, 0, 67, 68, 0, 0, 677, 0, -574, -574,
+ -574, -574, -574, 0, 0, 69, 0, 0, 0, 0,
+ 0, 70, 71, 72, 73, 74, 75, 76, 77, -574,
+ -574, -574, 0, 0, 0, 0, 78, 79, 80, 0,
+ 81, 82, 0, 83, 84, -574, -574, 0, -574, -574,
+ 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
+ 95, 96, 61, 0, -574, 62, 0, 0, 0, 63,
+ 64, 65, 97, 0, -574, 0, 0, 98, -574, 0,
+ 0, 0, 66, -574, -574, -574, -574, -574, -574, -574,
+ -574, -574, -574, -574, -574, 0, -574, -574, -574, -574,
+ -574, 0, 0, 0, 67, 68, 0, 0, 768, 0,
+ -574, -574, -574, -574, -574, 0, 0, 69, 0, 0,
+ 0, 0, 0, 70, 71, 72, 73, 74, 75, 76,
+ 77, -574, -574, -574, 0, 0, 0, 0, 78, 79,
+ 80, 0, 81, 82, 0, 83, 84, -574, -574, 0,
+ -574, -574, 85, 86, 87, 88, 89, 90, 91, 92,
+ 93, 94, 95, 96, 61, 0, -574, 62, 0, 0,
+ 0, 63, 64, 65, 97, 0, -574, 0, 0, 98,
+ -574, 0, 0, 0, 66, -574, -574, -574, -574, -574,
+ -574, -574, -574, -574, -574, -574, -574, 0, -574, -574,
+ -574, -574, -574, 0, 0, 0, 67, 68, 0, 0,
+ 826, 0, -574, -574, -574, -574, -574, 0, 0, 69,
+ 0, 0, 0, 0, 0, 70, 71, 72, 73, 74,
+ 75, 76, 77, -574, -574, -574, 0, 0, 0, 0,
+ 78, 79, 80, 0, 81, 82, 0, 83, 84, -574,
+ -574, 0, -574, -574, 85, 86, 87, 88, 89, 90,
+ 91, 92, 93, 94, 95, 96, 61, 0, -574, 62,
+ 0, 0, 0, 63, 64, 65, 97, 0, -574, 0,
+ 0, 98, -574, 0, 0, 0, 66, -574, -574, -574,
+ -574, -574, -574, -574, -574, -574, -574, -574, -574, 0,
+ -574, -574, -574, -574, -574, 0, 0, 0, 67, 68,
+ 0, 0, 0, 0, -574, -574, -574, -574, -574, 0,
+ 0, 69, 0, 0, 0, 945, 0, 70, 71, 72,
+ 73, 74, 75, 76, 77, -574, -574, -574, 0, 0,
+ 0, 0, 78, 79, 80, 0, 81, 82, 0, 83,
+ 84, -574, -574, 0, -574, -574, 85, 86, 87, 88,
+ 89, 90, 91, 92, 93, 94, 95, 96, 7, 0,
+ 8, 0, 0, 0, 0, 0, 0, 0, 97, 0,
+ -574, 0, 0, 98, -574, 0, 0, 0, 0, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
- 20, 21, 22, 23, 24, 25, 26, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 28, 29, 30, 31,
- 32, 36, 0, 8, 0, 38, 728, 0, 0, 0,
- 0, 314, 0, 0, 0, 0, 0, 33, 34, 35,
- 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
- 19, 20, 21, 22, 23, 24, 25, 26, 0, 0,
- 0, 0, 0, 0, 0, 0, 27, 28, 29, 30,
- 31, 32, 36, 0, 8, 0, 38, 728, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 33, 34,
- 35, 9, 10, 11, 12, 13, 14, 15, 16, 17,
- 18, 19, 20, 21, 22, 23, 24, 25, 26, 0,
- 0, 0, 0, 0, 0, 0, 0, 27, 28, 29,
- 30, 31, 32, 36, 0, 8, 37, 38, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 33,
- 34, 35, 9, 10, 11, 12, 13, 14, 15, 16,
- 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
- 203, 0, 0, 0, 0, 0, 0, 0, 0, 28,
- 29, 30, 31, 32, 36, 0, 8, 37, 38, 0,
+ 20, 0, 21, 22, 23, 24, 25, 452, 453, 454,
+ 455, 0, 0, 0, 0, 26, 27, 28, 29, 30,
+ 31, 0, 0, 0, 0, 0, 458, 459, 460, 461,
+ 462, 463, 464, 465, 466, 467, 468, 32, 33, 34,
+ 56, 0, 8, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 35, 0, 0, 36, 37, 0, 0,
+ 0, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+ 18, 19, 20, 0, 21, 22, 23, 24, 25, 0,
+ 0, 0, 38, 0, 0, 39, 40, 26, 27, 28,
+ 29, 30, 31, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 32,
+ 33, 34, 195, 0, 8, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 35, 0, 0, 36, 37,
+ 0, 0, 0, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 0, 21, 22, 23, 24,
+ 25, 0, 0, 0, 38, 0, 0, 39, 40, 0,
+ 27, 28, 29, 30, 31, 0, 0, 0, 0, 0,
+ 0, 0, 0, 487, 0, 0, 0, 0, 0, 0,
+ 0, 32, 33, 34, 0, 8, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 35, 0, 0,
+ 36, 37, 0, 0, 9, 10, 11, 12, 13, 14,
+ 15, 16, 912, 18, 913, 20, 0, 914, 22, 23,
+ 24, 25, 452, 453, 454, 455, 38, 456, 0, 0,
+ 40, 27, 28, 29, 30, 31, 0, 0, 0, 0,
+ 457, 458, 459, 460, 461, 462, 463, 464, 465, 466,
+ 467, 468, 32, 33, 34, 0, 0, 8, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 35, 248,
+ 0, 36, 37, 0, 0, 0, 9, 10, 11, 12,
+ 13, 14, 15, 16, 17, 18, 19, 20, 0, 21,
+ 22, 23, 24, 25, 0, 0, 0, 38, 0, 0,
+ 0, 40, 915, 27, 28, 29, 30, 31, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 32, 33, 34, 0, 0, 0,
+ 0, 0, 8, 0, 0, 0, 0, 0, 0, 0,
+ 35, 944, 368, 36, 37, 0, 0, 0, 0, 0,
+ 0, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+ 18, 19, 20, 0, 21, 22, 23, 24, 25, 38,
+ 0, 0, 0, 40, 915, 0, 0, 26, 27, 28,
+ 29, 30, 31, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 32,
+ 33, 34, 0, 0, 8, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 35, 0, 0, 36, 37,
+ 0, 0, 0, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 0, 21, 22, 23, 24,
+ 25, 0, 0, 0, 38, 0, 0, 39, 40, 26,
+ 27, 28, 29, 30, 31, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 33, 34, 35, 9, 10, 11, 12, 13, 14, 15,
- 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
- 26, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 28, 29, 30, 31, 32, 36, 0, 8, 0, 38,
+ 0, 32, 33, 34, 0, 8, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 35, 0, 0,
+ 36, 37, 0, 0, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 0, 21, 22, 23,
+ 24, 25, 228, 0, 0, 0, 38, 0, 0, 39,
+ 40, 27, 28, 29, 30, 31, 0, 0, 0, 0,
+ 0, 0, 0, 0, 630, 0, 0, 0, 0, 0,
+ 0, 0, 32, 33, 34, 0, 8, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 35, 0,
+ 0, 36, 37, 0, 0, 9, 10, 11, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 0, 21, 22,
+ 23, 24, 25, 452, 453, 454, 455, 38, 456, 0,
+ 0, 40, 27, 28, 29, 30, 31, 0, 0, 0,
+ 0, 457, 458, 459, 460, 461, 462, 463, 464, 465,
+ 466, 467, 468, 32, 33, 34, 0, 8, 0, 0,
+ 0, 632, 0, 0, 0, 0, 0, 0, 0, 35,
+ 248, 0, 36, 37, 0, 0, 9, 10, 11, 12,
+ 13, 14, 15, 16, 17, 18, 19, 20, 0, 21,
+ 22, 23, 24, 25, 0, 0, 0, 0, 38, 0,
+ 0, 0, 40, 27, 28, 29, 30, 31, 0, 0,
+ 452, 453, 454, 455, 0, 456, 0, 0, 0, 0,
+ 0, 0, 0, 0, 32, 33, 34, 8, 457, 458,
+ 459, 460, 461, 462, 463, 464, 465, 466, 467, 468,
+ 35, 0, 0, 36, 37, 0, 9, 10, 11, 12,
+ 13, 14, 15, 16, 17, 18, 19, 20, 0, 21,
+ 22, 23, 24, 25, 0, 0, 0, 0, 0, 38,
+ 0, 0, 0, 40, 0, 0, 30, 31, 0, 0,
+ 0, 0, 0, 0, 0, 0, 750, 0, 0, 0,
+ 0, 0, 0, 0, 32, 33, 34, 8, 756, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 220, 34, 35, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
- 25, 26, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 28, 29, 30, 31, 32, 36, 0, 683, 0,
- 38, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 33, 34, 35, 9, 10, 11, 12, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 28, 29, 30, 31, 32, 36, 0, 8,
- 0, 38, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 33, 34, 35, 9, 10, 11, 12,
- 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
- 23, 24, 25, 26, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 31, 32, 36, 414,
- 0, 0, 38, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 33, 34, 35, 0, 9, 10,
- 11, 12, 13, 14, 15, 16, 0, 18, 531, 20,
- 0, 0, 23, 24, 25, 26, 0, 0, 0, 382,
- 383, 384, 385, 386, 0, 0, 0, 0, 0, 36,
- 0, 0, 0, 38, 0, 0, 387, 388, 389, 390,
- 391, 392, 393, 394, 395, 396, 397, 398, 382, 383,
- 384, 385, 386, 533, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 387, 388, 389, 390, 391,
- 392, 393, 394, 395, 396, 397, 398, 0, 0, 0,
- 0, 0, 659, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 382, 383, 384, 385, 386, 0, 0,
+ 35, 0, 0, 36, 37, 0, 9, 10, 11, 12,
+ 13, 14, 15, 16, 703, 18, 704, 20, 0, 705,
+ 22, 23, 24, 25, 0, 452, 453, 454, 455, 38,
+ 456, 0, 0, 40, 0, 0, 0, 452, 453, 454,
+ 455, 0, 456, 457, 458, 459, 460, 461, 462, 463,
+ 464, 465, 466, 467, 468, 457, 458, 459, 460, 461,
+ 462, 463, 464, 465, 466, 467, 468, 0, 0, 0,
+ 35, 0, 0, 36, 37, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 387, 388, 389, 390, 391, 392, 393, 394, 395, 396,
- 397, 398, 382, 383, 384, 385, 386, 663, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 387,
- 388, 389, 390, 391, 392, 393, 394, 395, 396, 397,
- 398, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 382, 383, 384,
- 385, 386, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 387, 388, 389, 390, 391, 392,
- 393, 394, 395, 396, 397, 398
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 38,
+ 0, 0, 0, 40
};
-#define yypact_value_is_default(yystate) \
- ((yystate) == (-782))
-
-#define yytable_value_is_error(yytable_value) \
- YYID (0)
-
static const yytype_int16 yycheck[] =
{
- 0, 85, 5, 5, 40, 5, 305, 212, 8, 91,
- 42, 5, 54, 131, 197, 41, 38, 43, 5, 550,
- 146, 21, 438, 466, 1, 2, 5, 42, 447, 155,
- 137, 447, 215, 5, 564, 559, 785, 321, 717, 110,
- 3, 328, 42, 567, 5, 93, 5, 129, 171, 39,
- 5, 39, 175, 3, 161, 162, 138, 142, 181, 5,
- 730, 41, 3, 186, 64, 40, 6, 591, 5, 69,
- 70, 5, 39, 822, 598, 38, 3, 54, 709, 710,
- 0, 41, 3, 5, 44, 208, 258, 836, 1, 261,
- 871, 40, 55, 40, 217, 117, 45, 1, 2, 778,
- 3, 6, 102, 6, 635, 128, 6, 5, 179, 890,
- 142, 5, 791, 93, 140, 147, 104, 57, 3, 94,
- 205, 147, 565, 46, 3, 38, 796, 117, 6, 5,
- 5, 131, 258, 93, 205, 261, 151, 104, 153, 44,
- 103, 41, 3, 892, 107, 187, 188, 94, 3, 3,
- 221, 151, 436, 153, 131, 679, 4, 107, 284, 38,
- 6, 203, 5, 126, 3, 142, 107, 3, 168, 211,
- 457, 455, 257, 205, 52, 38, 55, 38, 178, 3,
- 107, 353, 354, 215, 38, 270, 107, 5, 719, 74,
- 821, 191, 55, 108, 55, 3, 44, 876, 44, 38,
- 103, 5, 38, 155, 107, 205, 737, 207, 208, 3,
- 187, 188, 212, 245, 117, 3, 55, 38, 103, 5,
- 220, 124, 107, 753, 103, 257, 203, 131, 107, 672,
- 245, 755, 52, 5, 211, 212, 44, 279, 270, 411,
- 282, 38, 103, 243, 276, 245, 107, 126, 103, 103,
- 334, 3, 107, 107, 437, 674, 117, 788, 674, 3,
- 378, 4, 6, 468, 103, 126, 218, 103, 107, 124,
- 93, 107, 126, 93, 306, 401, 402, 3, 117, 103,
- 257, 464, 408, 107, 69, 124, 38, 126, 812, 415,
- 126, 41, 307, 270, 38, 103, 3, 52, 254, 107,
- 472, 44, 279, 429, 52, 282, 590, 307, 212, 103,
- 41, 3, 3, 107, 757, 103, 293, 102, 400, 107,
- 117, 321, 74, 365, 447, 357, 74, 124, 3, 41,
- 861, 38, 284, 365, 41, 291, 288, 369, 93, 863,
- 366, 47, 48, 49, 105, 869, 346, 38, 6, 40,
- 3, 103, 352, 6, 38, 107, 46, 41, 40, 103,
- 44, 52, 362, 107, 55, 117, 366, 128, 368, 44,
- 52, 52, 124, 117, 126, 446, 418, 103, 38, 450,
- 124, 107, 126, 74, 38, 4, 39, 6, 365, 293,
- 82, 117, 38, 74, 520, 55, 103, 78, 124, 38,
- 107, 378, 473, 94, 105, 3, 4, 359, 6, 361,
- 117, 103, 103, 38, 713, 107, 107, 124, 124, 126,
- 38, 39, 38, 3, 884, 44, 117, 128, 103, 38,
- 50, 51, 107, 124, 434, 126, 436, 55, 898, 899,
- 38, 418, 38, 41, 3, 38, 44, 6, 908, 69,
- 70, 454, 454, 456, 454, 455, 456, 19, 38, 55,
- 454, 461, 494, 415, 496, 40, 41, 454, 494, 44,
- 485, 38, 449, 93, 378, 454, 44, 429, 430, 479,
- 42, 496, 454, 666, 667, 485, 486, 38, 465, 93,
- 38, 468, 479, 454, 565, 454, 496, 497, 38, 454,
- 104, 105, 39, 40, 102, 103, 613, 55, 454, 107,
- 38, 50, 51, 75, 76, 77, 104, 454, 80, 117,
- 454, 3, 474, 103, 128, 477, 124, 107, 126, 600,
- 69, 70, 454, 559, 4, 577, 6, 117, 39, 542,
- 542, 567, 542, 40, 124, 449, 126, 41, 542, 41,
- 550, 41, 44, 676, 44, 542, 454, 599, 3, 559,
- 454, 465, 644, 542, 468, 591, 3, 567, 571, 571,
- 542, 571, 598, 41, 526, 693, 44, 571, 454, 454,
- 41, 542, 534, 542, 571, 588, 588, 542, 588, 589,
- 590, 591, 571, 4, 588, 6, 542, 44, 598, 571,
- 577, 3, 686, 19, 675, 542, 905, 764, 542, 766,
- 571, 454, 571, 684, 3, 651, 571, 724, 650, 651,
- 542, 703, 599, 6, 650, 571, 42, 669, 41, 41,
- 38, 39, 44, 40, 571, 635, 454, 571, 39, 40,
- 711, 593, 657, 38, 542, 44, 646, 55, 542, 571,
- 454, 41, 104, 679, 44, 726, 94, 657, 729, 75,
- 76, 77, 74, 40, 80, 38, 542, 542, 454, 94,
- 712, 38, 39, 571, 39, 41, 718, 571, 44, 679,
- 38, 39, 454, 683, 39, 756, 52, 104, 55, 124,
- 106, 717, 669, 693, 55, 571, 571, 55, 104, 542,
- 771, 41, 705, 705, 39, 705, 39, 749, 39, 709,
- 710, 705, 39, 40, 714, 44, 693, 717, 705, 719,
- 39, 39, 709, 710, 542, 40, 705, 52, 571, 755,
- 730, 39, 41, 705, 39, 712, 39, 737, 542, 39,
- 4, 718, 6, 39, 705, 39, 705, 39, 790, 94,
- 705, 793, 778, 571, 65, 755, 542, 104, 40, 705,
- 792, 793, 47, 48, 49, 791, 808, 571, 705, 784,
- 542, 705, 749, 39, 85, 86, 847, 41, 778, 41,
- 44, 104, 104, 705, 784, 571, 812, 44, 788, 693,
- 104, 791, 834, 78, 33, 837, 796, 39, 798, 571,
- 871, 39, 45, 42, 41, 38, 39, 705, 44, 48,
- 41, 705, 812, 790, 3, 39, 793, 832, 129, 890,
- 41, 821, 55, 38, 866, 867, 109, 110, 111, 705,
- 705, 808, 832, 41, 821, 60, 39, 863, 102, 78,
- 79, 38, 44, 869, 63, 887, 846, 39, 38, 38,
- 876, 52, 41, 40, 4, 881, 6, 834, 884, 128,
- 837, 861, 705, 863, 93, 84, 47, 48, 49, 869,
- 89, 110, 898, 899, 40, 39, 876, 122, 123, 124,
- 3, 881, 908, 45, 884, 3, 38, 705, 3, 866,
- 867, 41, 74, 44, 44, 71, 72, 73, 898, 899,
- 74, 705, 52, 142, 74, 45, 126, 146, 908, 148,
- 887, 45, 3, 76, 103, 38, 155, 39, 107, 705,
- 39, 45, 38, 38, 78, 3, 41, 39, 117, 52,
- 3, 41, 55, 705, 39, 124, 3, 126, 41, 52,
- 179, 74, 39, 182, 38, 41, 39, 38, 40, 38,
- 189, 74, 171, 40, 39, 174, 175, 94, 41, 41,
- 38, 41, 181, 41, 3, 38, 205, 186, 39, 3,
- 3, 45, 3, 38, 213, 3, 215, 216, 197, 218,
- 103, 220, 221, 222, 107, 44, 41, 39, 103, 208,
- 209, 41, 107, 41, 117, 214, 215, 40, 217, 38,
- 38, 124, 117, 126, 38, 38, 245, 38, 45, 124,
- 38, 126, 103, 39, 38, 44, 107, 328, 257, 258,
- 39, 55, 261, 334, 55, 103, 117, 55, 3, 107,
- 103, 270, 271, 124, 107, 126, 39, 41, 39, 117,
- 39, 38, 438, 39, 117, 284, 124, 39, 126, 288,
- 39, 124, 461, 126, 41, 588, 3, 588, 468, 370,
- 144, 145, 589, 38, 103, 588, 588, 306, 107, 103,
- 103, 3, 103, 107, 107, 103, 107, 434, 117, 107,
- 55, 320, 693, 117, 117, 124, 117, 126, 378, 117,
- 38, 38, 126, 126, 497, 126, 496, 46, 126, 47,
- 48, 49, 776, 798, 52, 846, 38, 47, 48, 49,
- 869, 858, 52, 21, 353, 354, 574, -1, 357, -1,
- 359, -1, 361, -1, -1, -1, 365, -1, 103, -1,
- 78, -1, 107, -1, 74, -1, -1, -1, 78, -1,
- -1, -1, 117, -1, -1, -1, 457, -1, 232, -1,
- 234, 235, 236, 237, 238, 239, 103, -1, -1, -1,
- 107, -1, -1, 402, 120, 121, 122, 123, 124, -1,
- 117, 103, 411, -1, -1, 107, 415, -1, -1, 126,
- -1, 265, -1, -1, -1, 117, -1, -1, -1, -1,
- 429, 430, -1, -1, 126, -1, 280, -1, -1, 283,
- 118, 119, 120, 121, 122, 123, 124, 446, -1, -1,
- -1, 450, -1, -1, -1, -1, 435, -1, 437, 438,
- -1, -1, -1, -1, -1, -1, 445, 446, 447, -1,
- -1, -1, -1, 472, 473, 474, -1, -1, 477, -1,
- -1, 96, 97, 98, 99, 464, -1, 466, -1, -1,
- -1, -1, -1, -1, 473, -1, -1, 496, 96, 97,
- 98, 99, 573, 118, 119, 120, 121, 122, 123, 124,
- -1, -1, -1, -1, -1, -1, 515, 115, 116, 117,
- 118, 119, 120, 121, 122, 123, 124, 526, -1, -1,
- -1, -1, -1, -1, -1, 534, -1, -1, 382, 383,
- 384, 385, 386, 387, 388, 389, 390, 391, 392, 393,
- 394, 395, 396, 397, 398, 96, 97, 98, 99, 39,
- -1, -1, -1, -1, -1, -1, 565, -1, 412, -1,
- -1, -1, -1, 644, -1, 419, 117, 118, 119, 120,
- 121, 122, 123, 124, -1, -1, 565, -1, -1, -1,
- -1, -1, -1, 572, 593, 574, -1, -1, -1, 3,
- -1, 600, 6, 96, 97, 98, 99, 11, 12, 13,
- 14, 15, 16, 17, 18, 686, 96, 97, 98, 99,
- 100, 114, 115, 116, 117, 118, 119, 120, 121, 122,
- 123, 124, 703, 113, 114, 115, 116, 117, 118, 119,
- 120, 121, 122, 123, 124, 644, 96, 97, 492, 493,
- 494, -1, -1, 6, -1, -1, -1, 728, 11, 12,
- 13, 14, 15, 16, 17, 18, -1, -1, 118, 119,
- 120, 121, 122, 123, 124, -1, 675, -1, -1, -1,
- -1, 96, 97, 98, 99, 684, -1, 666, 667, -1,
- -1, -1, -1, 672, -1, 674, -1, 676, 113, 114,
- 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
- -1, -1, 711, -1, -1, -1, -1, -1, 3, -1,
- -1, -1, -1, -1, -1, -1, -1, 726, -1, -1,
- 729, 730, -1, -1, -1, 20, 21, 22, 23, 24,
- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
- 35, 36, 37, 38, -1, -1, -1, 756, -1, -1,
- -1, 46, 47, 48, 49, 50, 51, -1, -1, -1,
- 55, -1, 771, -1, -1, -1, -1, -1, 757, -1,
- -1, -1, 781, 68, 69, 70, -1, -1, 41, -1,
- -1, -1, -1, -1, 793, -1, -1, -1, -1, -1,
- -1, -1, -1, 802, -1, 649, 650, -1, 652, -1,
- -1, -1, 656, -1, -1, -1, -1, -1, 103, -1,
- -1, 106, 107, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 117, -1, -1, -1, -1, -1, -1, 124,
- -1, -1, -1, 96, 97, 98, 99, 100, 847, -1,
- -1, -1, -1, -1, -1, 96, 97, 98, 99, 858,
- 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
- 123, 124, 871, -1, 873, 116, 117, 118, 119, 120,
- 121, 122, 123, 124, -1, -1, -1, -1, -1, -1,
- -1, 890, 1, -1, 3, 4, 740, -1, 7, 8,
- 9, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
- 29, 30, 31, 32, 33, 34, 35, 36, 37, -1,
- 774, -1, 41, 42, -1, -1, 45, -1, 47, 48,
- 49, 50, 51, -1, -1, -1, -1, -1, -1, -1,
- 794, 60, 61, 62, 63, 64, 65, 66, 67, 68,
- 69, 70, 71, 72, 73, -1, 75, 76, 77, -1,
- 79, 80, 81, -1, -1, -1, 85, -1, 87, 88,
- 89, 90, 91, 92, -1, -1, -1, -1, -1, -1,
- -1, -1, 101, -1, 103, -1, -1, 106, 107, 108,
- -1, 3, -1, -1, 6, -1, -1, -1, 10, 11,
- 12, 13, 14, 15, 16, 17, 18, 126, 20, 21,
- 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
- 32, 33, 34, 35, 36, 37, 38, -1, -1, -1,
- -1, -1, -1, -1, 46, 47, 48, 49, 50, 51,
- -1, 53, 96, 97, 98, 99, 100, -1, -1, -1,
- -1, -1, -1, -1, 3, -1, 68, 69, 70, 113,
- 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
- 124, 20, 21, 22, 23, 24, 25, 26, 27, 28,
- 29, 30, 31, 32, 33, 34, 35, 36, 37, -1,
- -1, 103, -1, -1, 106, 107, -1, -1, -1, -1,
- -1, 50, 51, -1, -1, 117, -1, -1, 120, 121,
- -1, -1, 124, 125, 126, 3, -1, -1, 6, 68,
- 69, 70, 10, 11, 12, 13, 14, 15, 16, 17,
- 18, -1, 20, 21, 22, 23, 24, 25, 26, 27,
- 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
- 38, -1, -1, -1, 103, -1, -1, -1, 107, 47,
- 48, 49, 50, 51, -1, 53, -1, -1, 56, -1,
- -1, -1, -1, -1, -1, 124, 1, -1, 3, -1,
- 68, 69, 70, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 20, 21, 22, 23, 24,
- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
- 35, 36, 37, -1, -1, 103, -1, -1, -1, 107,
- -1, 46, 47, 48, 49, 50, 51, -1, -1, 117,
- -1, -1, 120, 121, -1, -1, 124, 125, 126, 3,
- -1, -1, 6, 68, 69, 70, 10, 11, 12, 13,
- 14, 15, 16, 17, 18, -1, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 34, 35, 36, 37, 38, -1, -1, -1, 103, -1,
- -1, 106, 107, 47, 48, 49, 50, 51, -1, 53,
- -1, -1, 56, -1, -1, -1, -1, -1, -1, -1,
- 1, -1, 3, -1, 68, 69, 70, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 20,
- 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
- 31, 32, 33, 34, 35, 36, 37, -1, -1, 103,
- -1, -1, -1, 107, -1, 46, 47, 48, 49, 50,
- 51, -1, -1, 117, -1, -1, 120, 121, -1, -1,
- 124, 125, 126, 3, -1, -1, 6, 68, 69, 70,
- 10, 11, 12, 13, 14, 15, 16, 17, 18, -1,
- 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
- 30, 31, 32, 33, 34, 35, 36, 37, 38, -1,
- -1, -1, 103, -1, -1, 106, 107, 47, 48, 49,
- 50, 51, -1, 53, -1, -1, 56, -1, -1, -1,
- -1, -1, -1, -1, 1, -1, 3, -1, 68, 69,
- 70, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 20, 21, 22, 23, 24, 25, 26,
- 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
- 37, -1, -1, 103, -1, -1, -1, 107, -1, -1,
- 47, 48, 49, 50, 51, -1, -1, 117, -1, -1,
- 120, 121, -1, -1, 124, 125, 126, 3, -1, -1,
- 6, 68, 69, 70, 10, 11, 12, 13, 14, 15,
- 16, 17, 18, -1, 20, 21, 22, 23, 24, 25,
- 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
- 36, 37, 38, -1, -1, -1, 103, -1, -1, -1,
- 107, 47, 48, 49, 50, 51, -1, 53, -1, -1,
- 56, -1, -1, -1, -1, -1, -1, -1, 3, -1,
- -1, 6, 68, 69, 70, 10, 11, 12, 13, 14,
- 15, 16, 17, 18, -1, 20, 21, 22, 23, 24,
- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
- 35, 36, 37, 38, 39, -1, -1, 103, -1, -1,
- -1, 107, 47, 48, 49, 50, 51, -1, 53, -1,
- -1, 117, -1, -1, 120, 121, -1, -1, 124, 125,
- 126, 3, -1, 68, 69, 70, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 20, 21,
+ 0, 5, 156, 5, 361, 5, 537, 44, 138, 46,
+ 154, 45, 5, 92, 70, 237, 5, 5, 590, 531,
+ 222, 43, 146, 1, 2, 40, 734, 425, 551, 671,
+ 148, 375, 383, 522, 1, 2, 92, 93, 240, 563,
+ 706, 6, 531, 6, 3, 45, 857, 3, 5, 952,
+ 42, 954, 5, 177, 178, 42, 40, 52, 41, 6,
+ 21, 5, 44, 5, 0, 98, 259, 5, 43, 69,
+ 43, 45, 5, 5, 74, 75, 71, 117, 54, 41,
+ 5, 54, 138, 103, 5, 117, 230, 5, 5, 54,
+ 187, 140, 59, 666, 802, 77, 193, 46, 5, 3,
+ 5, 674, 199, 160, 161, 138, 5, 204, 140, 109,
+ 41, 40, 104, 170, 147, 152, 3, 104, 6, 59,
+ 5, 5, 85, 46, 85, 162, 5, 700, 103, 5,
+ 89, 90, 166, 116, 168, 4, 233, 6, 85, 3,
+ 116, 3, 715, 1046, 159, 129, 243, 103, 148, 672,
+ 343, 295, 54, 964, 116, 118, 196, 190, 48, 118,
+ 119, 3, 111, 296, 297, 48, 166, 300, 168, 40,
+ 148, 59, 316, 881, 43, 1042, 520, 46, 576, 4,
+ 154, 148, 105, 106, 184, 89, 90, 154, 162, 48,
+ 230, 542, 4, 54, 902, 126, 540, 126, 129, 40,
+ 129, 103, 89, 90, 6, 134, 872, 361, 248, 40,
+ 250, 115, 49, 50, 51, 119, 57, 48, 3, 43,
+ 4, 46, 6, 6, 1091, 89, 90, 89, 90, 3,
+ 230, 40, 232, 233, 46, 103, 1047, 237, 205, 296,
+ 297, 208, 103, 300, 46, 114, 1057, 89, 90, 249,
+ 823, 251, 286, 115, 118, 119, 230, 119, 1, 237,
+ 120, 228, 46, 46, 126, 205, 240, 129, 208, 236,
+ 237, 979, 134, 115, 407, 408, 409, 119, 335, 336,
+ 89, 90, 924, 3, 284, 54, 286, 811, 228, 4,
+ 43, 6, 134, 816, 3, 6, 236, 134, 43, 42,
+ 43, 1, 76, 46, 89, 90, 818, 76, 706, 43,
+ 389, 43, 286, 74, 46, 89, 90, 715, 374, 521,
+ 40, 295, 4, 76, 6, 1073, 360, 383, 295, 818,
+ 448, 553, 43, 389, 119, 43, 117, 57, 46, 1005,
+ 40, 115, 316, 40, 76, 119, 40, 549, 109, 316,
+ 483, 484, 326, 926, 40, 699, 1022, 3, 1106, 140,
+ 360, 43, 329, 57, 46, 332, 40, 345, 76, 89,
+ 90, 103, 54, 1081, 40, 375, 43, 40, 345, 46,
+ 89, 90, 438, 57, 21, 359, 42, 54, 425, 329,
+ 3, 57, 332, 537, 40, 115, 42, 40, 54, 119,
+ 972, 401, 48, 436, 40, 928, 126, 44, 54, 129,
+ 119, 57, 40, 470, 471, 472, 814, 990, 138, 434,
+ 40, 421, 479, 480, 557, 425, 999, 40, 3, 429,
+ 76, 6, 489, 77, 531, 48, 52, 53, 82, 413,
+ 77, 78, 79, 89, 90, 82, 40, 84, 85, 43,
+ 424, 84, 46, 510, 103, 71, 72, 424, 104, 52,
+ 53, 43, 43, 437, 46, 46, 997, 116, 117, 115,
+ 448, 40, 54, 119, 872, 3, 89, 90, 71, 72,
+ 126, 448, 43, 129, 424, 46, 542, 3, 134, 1062,
+ 530, 140, 138, 40, 534, 80, 1069, 537, 4, 46,
+ 6, 40, 115, 88, 89, 90, 119, 46, 40, 866,
+ 103, 43, 40, 126, 89, 90, 129, 517, 558, 40,
+ 520, 488, 3, 42, 40, 138, 493, 40, 47, 57,
+ 105, 106, 48, 40, 538, 6, 538, 537, 538, 541,
+ 540, 541, 576, 565, 578, 538, 546, 40, 488, 538,
+ 538, 588, 1085, 493, 43, 533, 590, 46, 615, 84,
+ 85, 89, 90, 537, 3, 48, 533, 769, 770, 1102,
+ 1103, 1104, 550, 89, 90, 553, 576, 43, 578, 579,
+ 46, 538, 1115, 550, 48, 538, 553, 115, 105, 106,
+ 590, 119, 592, 48, 538, 48, 538, 41, 126, 115,
+ 538, 129, 116, 119, 42, 538, 538, 1005, 89, 90,
+ 138, 92, 935, 538, 588, 938, 590, 538, 40, 41,
+ 538, 538, 138, 43, 1022, 681, 40, 41, 46, 666,
+ 6, 538, 672, 538, 115, 57, 46, 674, 119, 538,
+ 43, 40, 41, 57, 42, 649, 116, 649, 48, 649,
+ 89, 90, 48, 538, 538, 779, 649, 657, 57, 538,
+ 649, 649, 538, 700, 41, 42, 666, 40, 41, 706,
+ 41, 1069, 40, 41, 674, 679, 115, 679, 715, 679,
+ 119, 811, 722, 104, 57, 104, 679, 41, 42, 57,
+ 679, 679, 649, 727, 42, 697, 649, 697, 698, 699,
+ 700, 40, 736, 740, 697, 649, 706, 649, 697, 697,
+ 714, 649, 866, 7, 714, 715, 649, 649, 685, 741,
+ 838, 943, 679, 820, 649, 3, 679, 727, 649, 41,
+ 42, 649, 649, 116, 734, 679, 736, 679, 41, 40,
+ 41, 679, 649, 41, 649, 685, 679, 679, 48, 716,
+ 649, 40, 831, 1110, 679, 811, 57, 48, 679, 134,
+ 57, 679, 679, 48, 649, 649, 740, 741, 46, 68,
+ 649, 48, 679, 649, 679, 831, 716, 43, 811, 819,
+ 679, 116, 41, 907, 41, 41, 823, 41, 828, 52,
+ 53, 46, 91, 54, 679, 679, 852, 96, 42, 41,
+ 679, 41, 802, 679, 958, 43, 41, 40, 71, 72,
+ 843, 89, 90, 121, 122, 123, 49, 50, 51, 852,
+ 41, 54, 41, 823, 130, 131, 132, 133, 134, 135,
+ 136, 41, 41, 889, 104, 872, 41, 115, 838, 42,
+ 103, 119, 49, 50, 51, 116, 813, 80, 41, 43,
+ 854, 116, 854, 997, 854, 88, 89, 90, 111, 915,
+ 838, 854, 134, 135, 136, 854, 854, 46, 868, 116,
+ 76, 838, 872, 813, 874, 48, 48, 917, 73, 74,
+ 75, 881, 116, 48, 41, 41, 942, 927, 187, 926,
+ 48, 858, 43, 192, 193, 48, 48, 854, 865, 48,
+ 199, 854, 902, 48, 944, 204, 43, 41, 46, 40,
+ 854, 43, 854, 91, 3, 955, 854, 47, 858, 43,
+ 41, 854, 854, 222, 57, 865, 926, 40, 968, 854,
+ 90, 78, 46, 854, 233, 234, 854, 854, 972, 89,
+ 239, 240, 48, 943, 243, 41, 1100, 854, 952, 854,
+ 954, 40, 952, 990, 954, 854, 1110, 997, 41, 48,
+ 48, 48, 999, 48, 48, 943, 966, 967, 1005, 854,
+ 854, 48, 972, 48, 48, 854, 943, 42, 854, 979,
+ 42, 40, 54, 1023, 103, 1022, 43, 41, 41, 47,
+ 990, 62, 41, 54, 140, 42, 45, 997, 972, 999,
+ 89, 90, 41, 52, 41, 1005, 40, 48, 982, 76,
+ 984, 138, 48, 48, 981, 76, 1072, 984, 48, 80,
+ 3, 48, 1022, 997, 46, 1062, 115, 88, 89, 90,
+ 119, 76, 1069, 76, 40, 47, 85, 86, 47, 41,
+ 43, 981, 1046, 41, 984, 1082, 1046, 3, 1085, 138,
+ 54, 43, 76, 54, 70, 41, 1056, 40, 47, 40,
+ 48, 1028, 1062, 1030, 48, 1102, 1103, 1104, 117, 1069,
+ 86, 76, 41, 43, 57, 42, 76, 76, 1115, 76,
+ 76, 1081, 1082, 43, 40, 1085, 104, 41, 1028, 54,
+ 1030, 41, 48, 3, 43, 48, 145, 1064, 1065, 1066,
+ 47, 57, 1102, 1103, 1104, 154, 89, 90, 43, 40,
+ 43, 160, 161, 43, 163, 1115, 43, 49, 50, 51,
+ 43, 170, 1089, 42, 1064, 1065, 1066, 3, 104, 3,
+ 40, 48, 115, 89, 90, 48, 119, 41, 48, 132,
+ 133, 134, 135, 136, 47, 41, 40, 196, 80, 1089,
+ 40, 200, 41, 48, 41, 138, 88, 89, 90, 115,
+ 43, 43, 48, 119, 40, 214, 40, 48, 41, 40,
+ 126, 187, 48, 129, 48, 41, 192, 193, 134, 89,
+ 90, 230, 138, 199, 48, 201, 202, 3, 204, 238,
+ 6, 240, 241, 242, 41, 244, 41, 46, 48, 248,
+ 249, 250, 251, 219, 41, 115, 222, 223, 48, 119,
+ 43, 43, 522, 89, 90, 89, 90, 233, 3, 518,
+ 546, 3, 521, 522, 240, 41, 1023, 243, 138, 697,
+ 529, 530, 531, 249, 553, 698, 943, 286, 697, 115,
+ 256, 115, 517, 119, 448, 119, 295, 296, 297, 697,
+ 549, 300, 551, 50, 697, 40, 592, 1003, 40, 558,
+ 838, 563, 138, 48, 138, 1056, 48, 316, 429, 318,
+ 874, 967, 54, 89, 90, 57, 3, 4, 571, 6,
+ 1069, 1051, -1, -1, -1, 178, 335, 336, 682, 105,
+ 106, 340, -1, -1, 76, -1, -1, -1, -1, 157,
+ 158, -1, -1, 352, 89, 90, -1, 89, 90, -1,
+ 359, -1, -1, 40, -1, -1, 43, -1, -1, 46,
+ -1, 48, -1, 161, -1, -1, -1, 376, -1, -1,
+ 115, -1, 170, 115, 119, -1, -1, 119, -1, -1,
+ -1, 3, -1, -1, 126, -1, -1, 129, -1, -1,
+ -1, -1, 134, 138, -1, -1, 138, 3, 407, 408,
+ 409, -1, 89, 90, 413, -1, 415, 416, 3, 418,
+ -1, 6, -1, 672, -1, 424, -1, -1, 40, -1,
+ -1, 680, -1, 682, -1, -1, 48, 114, 115, -1,
+ -1, -1, 119, -1, 40, 57, -1, -1, -1, 126,
+ -1, -1, 129, -1, 242, 40, 244, 134, -1, -1,
+ -1, 138, -1, 48, 272, -1, 274, 275, 276, 277,
+ 278, 279, 280, 472, -1, -1, -1, 89, 90, -1,
+ -1, -1, -1, -1, 483, 484, -1, 3, -1, -1,
+ 489, -1, -1, 89, 90, -1, -1, -1, -1, 307,
+ 3, -1, -1, 115, 89, 90, -1, 119, -1, -1,
+ -1, 510, -1, -1, 513, -1, -1, -1, -1, 115,
+ 769, 770, 330, 119, 40, 333, 138, 43, -1, -1,
+ 115, 530, 48, -1, 119, 534, -1, 40, 537, -1,
+ 43, 126, 138, -1, 129, 48, -1, 335, 336, 134,
+ -1, -1, 340, 138, -1, 521, -1, -1, 557, 558,
+ 559, -1, -1, 562, 563, 531, -1, 816, -1, 818,
+ -1, 820, -1, 89, 90, -1, -1, 3, -1, -1,
+ -1, 547, -1, 549, -1, 584, 89, 90, -1, -1,
+ -1, 590, -1, 842, -1, -1, -1, -1, -1, 115,
+ -1, -1, -1, 119, -1, -1, -1, -1, -1, -1,
+ 126, -1, 115, 129, 40, -1, 119, -1, 134, -1,
+ -1, -1, 138, 126, 623, 624, 129, 415, 416, 628,
+ 418, 134, -1, 3, 633, 138, -1, -1, -1, 638,
+ -1, -1, -1, -1, 452, 453, 454, 455, 456, 457,
+ 458, 459, 460, 461, 462, 463, 464, 465, 466, 467,
+ 468, -1, -1, 89, 90, -1, -1, -1, -1, -1,
+ 40, 3, -1, 672, -1, -1, -1, 485, 48, 928,
+ -1, -1, -1, -1, -1, -1, 494, -1, -1, 115,
+ -1, -1, -1, 119, -1, 3, -1, 696, -1, -1,
+ -1, 489, -1, 702, -1, -1, -1, -1, 40, -1,
+ -1, 43, 138, -1, -1, 681, 48, -1, -1, 89,
+ 90, -1, 510, 722, -1, 513, -1, -1, -1, -1,
+ 3, -1, 40, -1, -1, 43, 3, -1, -1, -1,
+ 48, -1, -1, -1, -1, 115, -1, -1, -1, 119,
+ -1, 3, -1, -1, -1, -1, 126, 89, 90, 129,
+ 759, 760, -1, -1, 134, -1, 765, 40, 138, -1,
+ -1, 559, -1, 40, 562, 48, -1, 585, 586, 587,
+ 588, 89, 90, 115, 57, -1, -1, 119, 40, -1,
+ 57, -1, -1, -1, 126, -1, 48, 129, -1, -1,
+ -1, -1, 134, 769, 770, -1, 138, 115, -1, -1,
+ -1, 119, 811, -1, -1, -1, 89, 90, 126, -1,
+ 819, 129, 89, 90, -1, -1, 134, -1, -1, 828,
+ 138, -1, -1, -1, -1, 623, 624, 89, 90, 3,
+ 628, -1, 115, -1, -1, 633, 119, -1, 115, -1,
+ 638, -1, 119, 126, 820, -1, 129, -1, -1, 126,
+ -1, -1, 129, 115, -1, 138, 3, 119, 834, 835,
+ 836, 3, -1, -1, 126, -1, 40, 129, -1, 878,
+ 6, -1, 134, -1, 48, -1, 138, 13, 14, 15,
+ 16, 17, 18, 19, 20, 894, 862, -1, -1, 898,
+ 899, -1, -1, 40, -1, -1, -1, -1, 40, 717,
+ -1, 48, -1, -1, 702, -1, 48, -1, 917, -1,
+ 57, -1, -1, -1, -1, 89, 90, -1, 927, -1,
+ 738, 739, 740, -1, 742, -1, -1, -1, -1, -1,
+ 748, -1, -1, -1, -1, 944, -1, -1, -1, -1,
+ -1, 115, 89, 90, -1, 119, 955, 89, 90, -1,
+ 959, -1, 126, -1, -1, 129, -1, -1, -1, 968,
+ 134, 759, 760, 972, 138, 974, 975, 765, 115, -1,
+ -1, -1, 119, 115, -1, 984, -1, 119, -1, 126,
+ -1, -1, 129, -1, 126, -1, -1, 129, 997, -1,
+ -1, 138, 134, -1, -1, -1, 138, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 1,
+ 1019, 3, 4, -1, 1023, -1, 8, 9, 10, -1,
+ -1, -1, -1, 49, 50, 51, -1, 1003, 54, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
- 32, 33, 34, 35, 36, 37, 38, -1, 103, -1,
- -1, -1, 107, -1, 46, 47, 48, 49, 50, 51,
- -1, -1, 117, 55, -1, 120, 121, -1, -1, 124,
- 125, 126, 3, -1, -1, 6, 68, 69, 70, 10,
- 11, 12, 13, 14, 15, 16, 17, 18, -1, 20,
- 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
- 31, 32, 33, 34, 35, 36, 37, 38, -1, -1,
- -1, 103, -1, -1, 106, 107, 47, 48, 49, 50,
- 51, -1, 53, -1, -1, 117, -1, -1, -1, -1,
- -1, -1, 124, 3, -1, -1, 6, 68, 69, 70,
- 10, 11, 12, 13, 14, 15, 16, 17, 18, -1,
- 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
- 30, 31, 32, 33, 34, 35, 36, 37, 38, -1,
- -1, -1, 103, -1, -1, -1, 107, 47, 48, 49,
- 50, 51, -1, 53, -1, -1, 117, -1, -1, 120,
- 121, -1, -1, 124, 125, 126, 3, -1, 68, 69,
- 70, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 20, 21, 22, 23, 24, 25, 26,
- 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
- 37, -1, -1, 103, -1, -1, -1, 107, -1, 46,
- 47, 48, 49, 50, 51, 74, -1, -1, -1, -1,
- 120, 121, -1, -1, 124, 125, 126, -1, -1, -1,
- -1, 68, 69, 70, -1, -1, -1, 96, 97, 98,
- 99, 100, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 113, 114, 115, 116, 117, 118,
- 119, 120, 121, 122, 123, 124, 103, -1, -1, 106,
- 107, -1, -1, -1, 0, 1, -1, 3, 4, -1,
- 117, 7, 8, 9, -1, -1, -1, 124, -1, -1,
- -1, -1, -1, 19, 20, 21, 22, 23, 24, 25,
- 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
- 36, 37, -1, -1, -1, 41, 42, -1, -1, -1,
- -1, 47, 48, 49, 50, 51, -1, -1, 54, -1,
- -1, -1, -1, -1, 60, 61, 62, 63, 64, 65,
- 66, 67, 68, 69, 70, -1, -1, -1, -1, 75,
- 76, 77, -1, 79, 80, 81, 82, 83, 84, 85,
- 86, 87, 88, 89, 90, 91, 92, -1, -1, -1,
- -1, -1, -1, -1, -1, 101, 1, 103, 3, 4,
- 106, 107, 7, 8, 9, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 19, 20, 21, 22, 23, 24,
- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
- 35, 36, 37, -1, -1, -1, 41, 42, -1, -1,
- 45, -1, 47, 48, 49, 50, 51, -1, -1, 54,
- -1, -1, -1, -1, -1, 60, 61, 62, 63, 64,
- 65, 66, 67, 68, 69, 70, -1, -1, -1, -1,
- 75, 76, 77, -1, 79, 80, 81, 82, 83, 84,
- 85, 86, 87, 88, 89, 90, 91, 92, -1, -1,
- -1, -1, -1, -1, -1, -1, 101, 1, 103, 3,
- 4, 106, 107, 7, 8, 9, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 34, 35, 36, 37, -1, -1, -1, 41, 42, -1,
- -1, 45, -1, 47, 48, 49, 50, 51, -1, -1,
- 54, -1, -1, -1, -1, -1, 60, 61, 62, 63,
- 64, 65, 66, 67, 68, 69, 70, -1, -1, -1,
- -1, 75, 76, 77, -1, 79, 80, 81, 82, 83,
- 84, 85, 86, 87, 88, 89, 90, 91, 92, -1,
- -1, -1, -1, -1, -1, -1, -1, 101, 1, 103,
- 3, 4, 106, 107, 7, 8, 9, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 19, 20, 21, 22,
+ 32, 33, 1051, 35, 36, 37, 38, 39, -1, -1,
+ 76, 43, 44, -1, 80, 47, -1, 49, 50, 51,
+ 52, 53, 88, 89, 90, -1, -1, -1, 886, 887,
+ 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
+ 72, 73, 74, 75, -1, 77, 78, 79, -1, 81,
+ 82, 83, 84, 85, 86, 87, 894, 89, 90, 91,
+ 898, 899, -1, 95, -1, 97, 98, 99, 100, 101,
+ 102, -1, -1, -1, -1, -1, 107, 108, 109, 110,
+ -1, 113, -1, 115, 107, 108, 118, 119, 120, -1,
+ -1, -1, 3, -1, -1, 6, 127, 128, 129, 130,
+ 131, 132, 133, 134, 135, 136, 138, 130, 131, 132,
+ 133, 134, 135, 136, -1, 22, 23, 24, 25, 26,
+ 27, 28, 29, -1, 31, 983, 33, -1, -1, 36,
+ 37, 38, 39, -1, -1, -1, 974, 975, 3, -1,
+ -1, 6, 7, -1, 1002, -1, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, -1, 22, 23, 24,
+ 25, 26, 27, 28, 29, 30, 31, 32, 33, -1,
+ 35, 36, 37, 38, 39, 40, -1, -1, 89, 90,
+ 21, -1, -1, 48, 49, 50, 51, 52, 53, -1,
+ 55, -1, -1, -1, 105, 106, -1, -1, -1, -1,
+ -1, -1, -1, 44, 115, 70, 71, 72, 119, -1,
+ -1, -1, -1, -1, -1, 126, -1, -1, 129, -1,
+ -1, 86, -1, 134, 89, 90, 3, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 77, 78, 79, -1,
+ -1, 82, 83, 84, 85, -1, -1, -1, -1, -1,
+ 115, -1, -1, 118, 119, -1, -1, -1, -1, -1,
+ -1, 126, -1, 40, 129, -1, -1, 132, 133, 134,
+ -1, 48, 3, 138, 139, 6, 7, 118, 3, -1,
+ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+ -1, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+ 31, 32, 33, -1, 35, 36, 37, 38, 39, 40,
+ -1, -1, 89, 90, -1, 40, -1, -1, 49, 50,
+ 51, 52, 53, 48, 55, -1, -1, 58, -1, -1,
+ -1, -1, 57, -1, -1, -1, -1, -1, 115, 70,
+ 71, 72, 119, -1, -1, 107, 108, 109, 110, 126,
+ -1, -1, 129, -1, -1, 86, -1, -1, 89, 90,
+ 3, 138, -1, -1, 89, 90, 128, 129, 130, 131,
+ 132, 133, 134, 135, 136, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 115, -1, -1, -1, 119, -1,
+ 115, -1, -1, -1, 119, 126, -1, 40, 129, -1,
+ -1, 132, 133, 134, -1, 48, 3, 138, 139, 6,
+ 7, -1, 3, 138, 11, 12, 13, 14, 15, 16,
+ 17, 18, 19, 20, -1, 22, 23, 24, 25, 26,
+ 27, 28, 29, 30, 31, 32, 33, -1, 35, 36,
+ 37, 38, 39, 40, -1, -1, 89, 90, -1, 40,
+ -1, -1, 49, 50, 51, 52, 53, 48, 55, -1,
+ -1, 58, -1, -1, -1, -1, 57, -1, -1, -1,
+ -1, -1, 115, 70, 71, 72, 119, -1, -1, -1,
+ -1, -1, -1, 126, -1, -1, 129, -1, -1, 86,
+ -1, -1, 89, 90, 3, 138, -1, 6, 89, 90,
+ -1, -1, -1, -1, 13, 14, 15, 16, 17, 18,
+ 19, 20, -1, -1, -1, -1, -1, -1, 115, -1,
+ -1, -1, 119, -1, 115, -1, -1, -1, 119, 126,
+ -1, -1, 129, -1, -1, 132, 133, 134, -1, -1,
+ 3, 138, 139, 6, 7, -1, 3, 138, 11, 12,
+ 13, 14, 15, 16, 17, 18, 19, 20, -1, 22,
23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
- 33, 34, 35, 36, 37, -1, -1, -1, 41, 42,
- -1, -1, 45, -1, 47, 48, 49, 50, 51, -1,
- -1, 54, -1, -1, -1, -1, -1, 60, 61, 62,
- 63, 64, 65, 66, 67, 68, 69, 70, -1, -1,
- -1, -1, 75, 76, 77, -1, 79, 80, 81, 82,
- 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
- -1, -1, -1, -1, -1, -1, -1, -1, 101, 1,
- 103, 3, 4, 106, 107, 7, 8, 9, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 19, 20, 21,
- 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
- 32, 33, 34, 35, 36, 37, -1, -1, -1, 41,
- 42, -1, -1, -1, -1, 47, 48, 49, 50, 51,
- -1, -1, 54, -1, -1, -1, 58, -1, 60, 61,
- 62, 63, 64, 65, 66, 67, 68, 69, 70, -1,
- -1, -1, -1, 75, 76, 77, -1, 79, 80, 81,
- 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
- 92, 3, -1, -1, -1, -1, -1, -1, -1, 101,
- -1, 103, -1, -1, 106, 107, -1, -1, 20, 21,
- 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
- 32, 33, 34, 35, 36, 37, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 47, 48, 49, 50, 51,
+ 33, -1, 35, 36, 37, 38, 39, 40, -1, -1,
+ 89, 90, -1, 40, -1, 76, 49, 50, 51, 52,
+ 53, 48, 55, -1, -1, 58, 105, 106, -1, -1,
+ 57, -1, -1, -1, -1, -1, -1, 70, 71, 72,
+ -1, -1, -1, -1, -1, -1, 107, 108, 109, 110,
+ -1, 112, -1, 86, -1, -1, 89, 90, -1, -1,
+ -1, -1, 89, 90, 125, 126, 127, 128, 129, 130,
+ 131, 132, 133, 134, 135, 136, -1, -1, -1, -1,
+ -1, -1, 115, -1, -1, -1, 119, -1, 115, -1,
+ -1, -1, 119, 126, -1, -1, 129, -1, -1, 132,
+ 133, 134, -1, -1, 3, 138, 139, 6, 7, 41,
+ -1, 138, 11, 12, 13, 14, 15, 16, 17, 18,
+ 19, 20, -1, 22, 23, 24, 25, 26, 27, 28,
+ 29, 30, 31, 32, 33, -1, 35, 36, 37, 38,
+ 39, 40, -1, -1, -1, -1, -1, -1, -1, -1,
+ 49, 50, 51, 52, 53, -1, 55, -1, -1, 58,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 70, 71, 72, -1, 107, 108, 109, 110, -1,
+ 112, -1, -1, 107, 108, 109, 110, 86, -1, -1,
+ 89, 90, -1, 125, 126, 127, 128, 129, 130, 131,
+ 132, 133, 134, 135, 136, 129, 130, 131, 132, 133,
+ 134, 135, 136, -1, -1, -1, 115, -1, -1, -1,
+ 119, -1, -1, -1, -1, 41, -1, 126, -1, -1,
+ 129, -1, -1, 132, 133, 134, -1, -1, 3, 138,
+ 139, 6, 7, -1, -1, -1, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, -1, 22, 23, 24,
+ 25, 26, 27, 28, 29, 30, 31, 32, 33, -1,
+ 35, 36, 37, 38, 39, 40, 41, -1, -1, -1,
+ -1, -1, -1, -1, 49, 50, 51, 52, 53, -1,
+ 55, 107, 108, 109, 110, -1, 112, -1, -1, -1,
+ -1, -1, -1, -1, -1, 70, 71, 72, -1, 125,
+ 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
+ 136, 86, -1, -1, 89, 90, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 115, -1, -1, -1, 119, -1, -1, -1, -1, -1,
+ -1, 126, -1, -1, 129, -1, -1, 132, 133, 134,
+ -1, -1, 3, 138, 139, 6, 7, -1, 43, -1,
+ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+ -1, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+ 31, 32, 33, -1, 35, 36, 37, 38, 39, 40,
+ 41, -1, -1, -1, -1, -1, -1, -1, 49, 50,
+ 51, 52, 53, -1, 55, 107, 108, 109, 110, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
+ 71, 72, 107, 108, 109, 110, -1, 112, 130, 131,
+ 132, 133, 134, 135, 136, 86, -1, -1, 89, 90,
+ 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
+ 135, 136, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 115, -1, -1, -1, 119, -1,
+ -1, -1, -1, -1, -1, 126, -1, -1, 129, -1,
+ -1, 132, 133, 134, -1, -1, 3, 138, 139, 6,
+ 7, -1, -1, -1, 11, 12, 13, 14, 15, 16,
+ 17, 18, 19, 20, -1, 22, 23, 24, 25, 26,
+ 27, 28, 29, 30, 31, 32, 33, -1, 35, 36,
+ 37, 38, 39, 40, -1, -1, -1, -1, -1, -1,
+ -1, -1, 49, 50, 51, 52, 53, -1, 55, 107,
+ 108, 109, 110, -1, 112, -1, -1, -1, -1, -1,
+ -1, -1, -1, 70, 71, 72, -1, 125, 126, 127,
+ 128, 129, 130, 131, 132, 133, 134, 135, 136, 86,
+ -1, -1, 89, 90, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 115, -1,
+ -1, -1, 119, -1, -1, -1, -1, -1, -1, 126,
+ -1, -1, 129, -1, -1, 132, 133, 134, -1, -1,
+ 3, 138, 139, 6, 7, -1, -1, -1, 11, 12,
+ 13, 14, 15, 16, 17, 18, 19, 20, -1, 22,
+ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+ 33, -1, 35, 36, 37, 38, 39, 40, -1, -1,
+ -1, -1, -1, -1, -1, -1, 49, 50, 51, 52,
+ 53, -1, 55, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 70, 71, 72,
-1, -1, 3, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 68, 69, 70, 20,
+ -1, -1, -1, 86, -1, -1, 89, 90, -1, -1,
+ -1, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+ 31, 32, 33, -1, 35, 36, 37, 38, 39, 40,
+ -1, -1, 115, -1, -1, -1, 119, 48, 49, 50,
+ 51, 52, 53, -1, -1, -1, 57, -1, -1, 132,
+ 133, 134, -1, -1, -1, 138, 139, -1, -1, 70,
+ 71, 72, 107, 108, 109, 110, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
+ 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
+ 135, 136, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 115, 3, -1, 118, 119, -1,
+ -1, -1, -1, -1, -1, 126, -1, -1, 129, -1,
+ -1, -1, -1, 134, 22, 23, 24, 25, 26, 27,
+ 28, 29, 30, 31, 32, 33, -1, 35, 36, 37,
+ 38, 39, 40, -1, -1, -1, -1, -1, -1, -1,
+ 48, 49, 50, 51, 52, 53, -1, -1, -1, 57,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 70, 71, 72, -1, -1, 3, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
+ -1, 89, 90, -1, -1, -1, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, 33, -1, 35,
+ 36, 37, 38, 39, -1, -1, -1, 115, -1, -1,
+ 118, 119, 48, 49, 50, 51, 52, 53, 126, -1,
+ -1, 129, -1, -1, -1, -1, 134, -1, -1, -1,
+ -1, -1, -1, -1, 70, 71, 72, 3, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 86, -1, -1, 89, 90, -1, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, 33, -1, 35,
+ 36, 37, 38, 39, -1, -1, -1, -1, -1, 115,
+ -1, -1, 118, 119, -1, -1, 52, 53, -1, -1,
+ 126, -1, -1, 129, -1, -1, -1, -1, 134, -1,
+ -1, -1, -1, -1, 70, 71, 72, 0, 1, -1,
+ 3, 4, -1, -1, -1, 8, 9, 10, -1, -1,
+ 86, -1, -1, 89, 90, -1, -1, -1, 21, 22,
+ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+ 33, -1, 35, 36, 37, 38, 39, -1, -1, 115,
+ 43, 44, -1, 119, -1, -1, 49, 50, 51, 52,
+ 53, -1, -1, 56, -1, -1, -1, -1, 134, 62,
+ 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
+ -1, -1, -1, -1, 77, 78, 79, -1, 81, 82,
+ -1, 84, 85, 86, 87, -1, 89, 90, 91, 92,
+ 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
+ 1, -1, 3, 4, -1, -1, -1, 8, 9, 10,
+ 113, -1, 115, -1, -1, 118, 119, -1, -1, -1,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
- 31, 32, 33, 34, 35, 36, 37, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 47, 48, 49, 50,
- 51, 103, -1, 3, -1, 107, 108, -1, -1, -1,
- -1, 11, -1, -1, -1, -1, -1, 68, 69, 70,
- 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
- 30, 31, 32, 33, 34, 35, 36, 37, -1, -1,
- -1, -1, -1, -1, -1, -1, 46, 47, 48, 49,
- 50, 51, 103, -1, 3, -1, 107, 108, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
- 70, 20, 21, 22, 23, 24, 25, 26, 27, 28,
- 29, 30, 31, 32, 33, 34, 35, 36, 37, -1,
- -1, -1, -1, -1, -1, -1, -1, 46, 47, 48,
- 49, 50, 51, 103, -1, 3, 106, 107, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
- 69, 70, 20, 21, 22, 23, 24, 25, 26, 27,
- 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
- 38, -1, -1, -1, -1, -1, -1, -1, -1, 47,
- 48, 49, 50, 51, 103, -1, 3, 106, 107, -1,
+ 31, 32, 33, -1, 35, 36, 37, 38, 39, -1,
+ -1, -1, 43, 44, -1, -1, 47, -1, 49, 50,
+ 51, 52, 53, -1, -1, 56, -1, -1, -1, -1,
+ -1, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+ 71, 72, -1, -1, -1, -1, 77, 78, 79, -1,
+ 81, 82, -1, 84, 85, 86, 87, -1, 89, 90,
+ 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
+ 101, 102, 1, -1, 3, 4, -1, -1, -1, 8,
+ 9, 10, 113, -1, 115, -1, -1, 118, 119, -1,
+ -1, -1, 21, 22, 23, 24, 25, 26, 27, 28,
+ 29, 30, 31, 32, 33, -1, 35, 36, 37, 38,
+ 39, -1, -1, -1, 43, 44, -1, -1, 47, -1,
+ 49, 50, 51, 52, 53, -1, -1, 56, -1, -1,
+ -1, -1, -1, 62, 63, 64, 65, 66, 67, 68,
+ 69, 70, 71, 72, -1, -1, -1, -1, 77, 78,
+ 79, -1, 81, 82, -1, 84, 85, 86, 87, -1,
+ 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
+ 99, 100, 101, 102, 1, -1, 3, 4, -1, -1,
+ -1, 8, 9, 10, 113, -1, 115, -1, -1, 118,
+ 119, -1, -1, -1, 21, 22, 23, 24, 25, 26,
+ 27, 28, 29, 30, 31, 32, 33, -1, 35, 36,
+ 37, 38, 39, -1, -1, -1, 43, 44, -1, -1,
+ 47, -1, 49, 50, 51, 52, 53, -1, -1, 56,
+ -1, -1, -1, -1, -1, 62, 63, 64, 65, 66,
+ 67, 68, 69, 70, 71, 72, -1, -1, -1, -1,
+ 77, 78, 79, -1, 81, 82, -1, 84, 85, 86,
+ 87, -1, 89, 90, 91, 92, 93, 94, 95, 96,
+ 97, 98, 99, 100, 101, 102, 1, -1, 3, 4,
+ -1, -1, -1, 8, 9, 10, 113, -1, 115, -1,
+ -1, 118, 119, -1, -1, -1, 21, 22, 23, 24,
+ 25, 26, 27, 28, 29, 30, 31, 32, 33, -1,
+ 35, 36, 37, 38, 39, -1, -1, -1, 43, 44,
+ -1, -1, -1, -1, 49, 50, 51, 52, 53, -1,
+ -1, 56, -1, -1, -1, 60, -1, 62, 63, 64,
+ 65, 66, 67, 68, 69, 70, 71, 72, -1, -1,
+ -1, -1, 77, 78, 79, -1, 81, 82, -1, 84,
+ 85, 86, 87, -1, 89, 90, 91, 92, 93, 94,
+ 95, 96, 97, 98, 99, 100, 101, 102, 1, -1,
+ 3, -1, -1, -1, -1, -1, -1, -1, 113, -1,
+ 115, -1, -1, 118, 119, -1, -1, -1, -1, 22,
+ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+ 33, -1, 35, 36, 37, 38, 39, 107, 108, 109,
+ 110, -1, -1, -1, -1, 48, 49, 50, 51, 52,
+ 53, -1, -1, -1, -1, -1, 126, 127, 128, 129,
+ 130, 131, 132, 133, 134, 135, 136, 70, 71, 72,
+ 1, -1, 3, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 86, -1, -1, 89, 90, -1, -1,
+ -1, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+ 31, 32, 33, -1, 35, 36, 37, 38, 39, -1,
+ -1, -1, 115, -1, -1, 118, 119, 48, 49, 50,
+ 51, 52, 53, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
+ 71, 72, 1, -1, 3, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
+ -1, -1, -1, 22, 23, 24, 25, 26, 27, 28,
+ 29, 30, 31, 32, 33, -1, 35, 36, 37, 38,
+ 39, -1, -1, -1, 115, -1, -1, 118, 119, -1,
+ 49, 50, 51, 52, 53, -1, -1, -1, -1, -1,
+ -1, -1, -1, 58, -1, -1, -1, -1, -1, -1,
+ -1, 70, 71, 72, -1, 3, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
+ 89, 90, -1, -1, 22, 23, 24, 25, 26, 27,
+ 28, 29, 30, 31, 32, 33, -1, 35, 36, 37,
+ 38, 39, 107, 108, 109, 110, 115, 112, -1, -1,
+ 119, 49, 50, 51, 52, 53, -1, -1, -1, -1,
+ 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
+ 135, 136, 70, 71, 72, -1, -1, 3, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 86, 87,
+ -1, 89, 90, -1, -1, -1, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, 33, -1, 35,
+ 36, 37, 38, 39, -1, -1, -1, 115, -1, -1,
+ -1, 119, 120, 49, 50, 51, 52, 53, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 68, 69, 70, 20, 21, 22, 23, 24, 25, 26,
- 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
- 37, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 47, 48, 49, 50, 51, 103, -1, 3, -1, 107,
+ -1, -1, -1, -1, 70, 71, 72, -1, -1, -1,
+ -1, -1, 3, -1, -1, -1, -1, -1, -1, -1,
+ 86, 87, 13, 89, 90, -1, -1, -1, -1, -1,
+ -1, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+ 31, 32, 33, -1, 35, 36, 37, 38, 39, 115,
+ -1, -1, -1, 119, 120, -1, -1, 48, 49, 50,
+ 51, 52, 53, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
+ 71, 72, -1, -1, 3, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
+ -1, -1, -1, 22, 23, 24, 25, 26, 27, 28,
+ 29, 30, 31, 32, 33, -1, 35, 36, 37, 38,
+ 39, -1, -1, -1, 115, -1, -1, 118, 119, 48,
+ 49, 50, 51, 52, 53, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 68, 69, 70, 20, 21, 22, 23, 24, 25,
- 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
- 36, 37, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 47, 48, 49, 50, 51, 103, -1, 3, -1,
- 107, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 68, 69, 70, 20, 21, 22, 23, 24,
- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
- 35, 36, 37, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 47, 48, 49, 50, 51, 103, -1, 3,
- -1, 107, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 68, 69, 70, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
- 34, 35, 36, 37, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 50, 51, 103, 56,
- -1, -1, 107, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 68, 69, 70, -1, 20, 21,
- 22, 23, 24, 25, 26, 27, -1, 29, 56, 31,
- -1, -1, 34, 35, 36, 37, -1, -1, -1, 96,
- 97, 98, 99, 100, -1, -1, -1, -1, -1, 103,
- -1, -1, -1, 107, -1, -1, 113, 114, 115, 116,
- 117, 118, 119, 120, 121, 122, 123, 124, 96, 97,
- 98, 99, 100, 56, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 113, 114, 115, 116, 117,
- 118, 119, 120, 121, 122, 123, 124, -1, -1, -1,
- -1, -1, 56, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 96, 97, 98, 99, 100, -1, -1,
+ -1, 70, 71, 72, -1, 3, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
+ 89, 90, -1, -1, 22, 23, 24, 25, 26, 27,
+ 28, 29, 30, 31, 32, 33, -1, 35, 36, 37,
+ 38, 39, 40, -1, -1, -1, 115, -1, -1, 118,
+ 119, 49, 50, 51, 52, 53, -1, -1, -1, -1,
+ -1, -1, -1, -1, 58, -1, -1, -1, -1, -1,
+ -1, -1, 70, 71, 72, -1, 3, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
+ -1, 89, 90, -1, -1, 22, 23, 24, 25, 26,
+ 27, 28, 29, 30, 31, 32, 33, -1, 35, 36,
+ 37, 38, 39, 107, 108, 109, 110, 115, 112, -1,
+ -1, 119, 49, 50, 51, 52, 53, -1, -1, -1,
+ -1, 125, 126, 127, 128, 129, 130, 131, 132, 133,
+ 134, 135, 136, 70, 71, 72, -1, 3, -1, -1,
+ -1, 58, -1, -1, -1, -1, -1, -1, -1, 86,
+ 87, -1, 89, 90, -1, -1, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, 33, -1, 35,
+ 36, 37, 38, 39, -1, -1, -1, -1, 115, -1,
+ -1, -1, 119, 49, 50, 51, 52, 53, -1, -1,
+ 107, 108, 109, 110, -1, 112, -1, -1, -1, -1,
+ -1, -1, -1, -1, 70, 71, 72, 3, 125, 126,
+ 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
+ 86, -1, -1, 89, 90, -1, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, 33, -1, 35,
+ 36, 37, 38, 39, -1, -1, -1, -1, -1, 115,
+ -1, -1, -1, 119, -1, -1, 52, 53, -1, -1,
+ -1, -1, -1, -1, -1, -1, 58, -1, -1, -1,
+ -1, -1, -1, -1, 70, 71, 72, 3, 58, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
- 123, 124, 96, 97, 98, 99, 100, 56, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 113,
- 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
- 124, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 96, 97, 98,
- 99, 100, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 113, 114, 115, 116, 117, 118,
- 119, 120, 121, 122, 123, 124
+ 86, -1, -1, 89, 90, -1, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, 33, -1, 35,
+ 36, 37, 38, 39, -1, 107, 108, 109, 110, 115,
+ 112, -1, -1, 119, -1, -1, -1, 107, 108, 109,
+ 110, -1, 112, 125, 126, 127, 128, 129, 130, 131,
+ 132, 133, 134, 135, 136, 125, 126, 127, 128, 129,
+ 130, 131, 132, 133, 134, 135, 136, -1, -1, -1,
+ 86, -1, -1, 89, 90, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 115,
+ -1, -1, -1, 119
};
-/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
- symbol of state STATE-NUM. */
+ /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+ symbol of state STATE-NUM. */
static const yytype_uint16 yystos[] =
{
- 0, 109, 110, 111, 130, 131, 277, 1, 3, 20,
- 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
- 31, 32, 33, 34, 35, 36, 37, 46, 47, 48,
- 49, 50, 51, 68, 69, 70, 103, 106, 107, 215,
- 229, 230, 232, 233, 234, 235, 236, 256, 257, 267,
- 269, 1, 215, 1, 38, 0, 1, 4, 7, 8,
- 9, 19, 41, 42, 54, 60, 61, 62, 63, 64,
- 65, 66, 67, 75, 76, 77, 79, 80, 81, 82,
- 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
- 101, 106, 132, 133, 134, 136, 137, 138, 139, 140,
- 143, 144, 146, 147, 148, 149, 150, 151, 152, 155,
- 156, 157, 160, 162, 167, 168, 169, 170, 172, 175,
- 176, 177, 178, 179, 183, 184, 191, 192, 202, 211,
- 277, 93, 264, 277, 264, 46, 267, 128, 93, 41,
- 233, 229, 38, 52, 55, 74, 117, 124, 126, 220,
- 221, 223, 225, 226, 227, 228, 267, 277, 229, 235,
- 267, 105, 128, 268, 41, 41, 212, 213, 215, 277,
- 108, 38, 6, 272, 38, 274, 277, 1, 3, 231,
- 232, 38, 274, 38, 154, 277, 38, 38, 38, 82,
- 267, 3, 44, 267, 38, 4, 44, 38, 38, 41,
- 44, 4, 272, 38, 166, 231, 164, 166, 38, 38,
- 272, 38, 93, 257, 274, 38, 117, 223, 228, 267,
- 68, 231, 257, 10, 11, 12, 13, 14, 15, 16,
- 17, 18, 38, 53, 117, 120, 121, 124, 125, 126,
- 215, 216, 217, 219, 231, 232, 244, 245, 246, 247,
- 272, 277, 46, 107, 269, 257, 229, 38, 117, 212,
- 226, 228, 267, 44, 237, 238, 56, 244, 245, 244,
- 38, 126, 224, 227, 267, 228, 229, 267, 220, 38,
- 55, 220, 38, 55, 117, 224, 227, 267, 104, 269,
- 107, 269, 39, 40, 214, 277, 3, 265, 272, 6,
- 44, 265, 275, 265, 41, 52, 38, 223, 39, 265,
- 267, 3, 3, 265, 11, 161, 212, 212, 267, 41,
- 52, 194, 44, 3, 163, 275, 3, 212, 44, 222,
- 223, 226, 277, 41, 40, 165, 277, 265, 266, 277,
- 141, 142, 272, 212, 187, 188, 189, 215, 256, 277,
- 267, 272, 3, 117, 228, 267, 275, 38, 265, 117,
- 267, 104, 3, 239, 277, 38, 223, 44, 267, 244,
- 38, 244, 244, 244, 244, 244, 244, 94, 40, 218,
- 277, 38, 96, 97, 98, 99, 100, 113, 114, 115,
- 116, 117, 118, 119, 120, 121, 122, 123, 124, 268,
- 94, 117, 228, 267, 225, 267, 39, 39, 117, 225,
- 267, 104, 55, 244, 56, 228, 267, 267, 38, 55,
- 228, 212, 56, 244, 212, 56, 244, 224, 227, 104,
- 117, 224, 268, 41, 215, 39, 171, 40, 52, 39,
- 237, 220, 39, 44, 39, 52, 39, 40, 159, 40,
- 39, 39, 41, 267, 131, 193, 39, 39, 39, 39,
- 164, 166, 39, 39, 40, 44, 39, 94, 40, 190,
- 277, 57, 104, 39, 228, 267, 41, 104, 41, 44,
- 212, 267, 78, 174, 220, 229, 181, 41, 74, 248,
- 249, 277, 39, 117, 124, 228, 231, 219, 244, 244,
+ 0, 121, 122, 123, 142, 143, 309, 1, 3, 22,
+ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+ 33, 35, 36, 37, 38, 39, 48, 49, 50, 51,
+ 52, 53, 70, 71, 72, 86, 89, 90, 115, 118,
+ 119, 193, 236, 250, 251, 253, 254, 255, 256, 257,
+ 258, 283, 284, 294, 297, 299, 1, 236, 1, 40,
+ 0, 1, 4, 8, 9, 10, 21, 43, 44, 56,
+ 62, 63, 64, 65, 66, 67, 68, 69, 77, 78,
+ 79, 81, 82, 84, 85, 91, 92, 93, 94, 95,
+ 96, 97, 98, 99, 100, 101, 102, 113, 118, 144,
+ 145, 146, 148, 149, 150, 151, 152, 155, 156, 158,
+ 159, 160, 161, 162, 163, 164, 167, 168, 169, 172,
+ 174, 179, 180, 181, 182, 184, 188, 195, 196, 197,
+ 198, 199, 203, 204, 211, 212, 223, 231, 232, 309,
+ 48, 52, 71, 48, 48, 40, 140, 103, 103, 293,
+ 297, 43, 254, 250, 40, 48, 54, 57, 76, 119,
+ 126, 129, 134, 138, 241, 242, 244, 246, 247, 248,
+ 249, 297, 309, 250, 257, 297, 293, 117, 140, 298,
+ 43, 43, 233, 234, 236, 309, 120, 40, 6, 85,
+ 118, 303, 40, 306, 309, 1, 252, 253, 294, 40,
+ 306, 40, 166, 309, 40, 40, 84, 85, 40, 84,
+ 77, 82, 44, 77, 92, 297, 46, 294, 297, 40,
+ 4, 46, 40, 40, 43, 46, 4, 303, 40, 178,
+ 252, 176, 178, 40, 40, 303, 40, 103, 284, 306,
+ 40, 126, 129, 244, 249, 297, 21, 85, 87, 193,
+ 252, 284, 48, 48, 48, 297, 118, 119, 299, 300,
+ 284, 7, 11, 12, 13, 14, 15, 16, 17, 18,
+ 19, 20, 40, 55, 126, 129, 132, 133, 134, 138,
+ 139, 236, 237, 238, 240, 252, 253, 269, 270, 271,
+ 272, 303, 304, 309, 250, 40, 126, 129, 233, 247,
+ 249, 297, 48, 46, 105, 106, 259, 260, 261, 262,
+ 263, 58, 269, 270, 269, 3, 40, 48, 138, 245,
+ 248, 297, 48, 245, 248, 249, 250, 297, 241, 40,
+ 57, 241, 40, 57, 48, 126, 129, 245, 248, 297,
+ 116, 299, 119, 300, 41, 42, 235, 309, 261, 294,
+ 295, 303, 284, 6, 46, 295, 307, 295, 43, 40,
+ 244, 54, 41, 295, 297, 294, 294, 295, 13, 173,
+ 233, 233, 297, 43, 54, 214, 54, 46, 294, 175,
+ 307, 294, 233, 46, 243, 244, 247, 309, 43, 42,
+ 177, 309, 295, 296, 309, 153, 154, 303, 233, 207,
+ 208, 209, 236, 283, 309, 297, 303, 126, 129, 249,
+ 294, 297, 307, 40, 295, 126, 129, 297, 116, 244,
+ 297, 264, 294, 309, 40, 244, 76, 275, 276, 297,
+ 309, 48, 48, 41, 294, 298, 104, 269, 40, 48,
+ 269, 269, 269, 269, 269, 269, 269, 104, 42, 239,
+ 309, 40, 107, 108, 109, 110, 112, 125, 126, 127,
+ 128, 129, 130, 131, 132, 133, 134, 135, 136, 7,
+ 126, 129, 249, 297, 246, 297, 246, 41, 41, 126,
+ 129, 246, 297, 116, 48, 57, 269, 58, 40, 249,
+ 297, 48, 297, 40, 57, 48, 249, 233, 58, 269,
+ 233, 58, 269, 48, 48, 245, 248, 48, 245, 248,
+ 116, 48, 126, 129, 245, 298, 43, 236, 41, 297,
+ 183, 42, 54, 41, 241, 259, 41, 46, 41, 54,
+ 41, 42, 171, 42, 41, 41, 43, 252, 143, 297,
+ 213, 41, 41, 41, 41, 176, 178, 41, 41, 42,
+ 46, 41, 104, 42, 210, 309, 59, 116, 41, 249,
+ 297, 43, 116, 111, 54, 76, 194, 309, 233, 297,
+ 80, 88, 89, 90, 186, 241, 250, 286, 287, 277,
+ 46, 43, 275, 293, 284, 41, 126, 129, 134, 249,
+ 252, 48, 240, 269, 269, 269, 269, 269, 269, 269,
+ 269, 269, 269, 269, 269, 269, 269, 269, 269, 269,
+ 297, 116, 41, 41, 41, 116, 246, 246, 269, 233,
+ 245, 297, 41, 116, 48, 233, 58, 269, 48, 41,
+ 58, 41, 58, 48, 48, 48, 48, 126, 129, 245,
+ 248, 48, 48, 48, 245, 235, 4, 46, 303, 143,
+ 307, 153, 271, 303, 308, 43, 43, 147, 4, 165,
+ 303, 4, 43, 46, 114, 170, 244, 303, 305, 295,
+ 303, 308, 41, 236, 244, 46, 243, 47, 43, 143,
+ 44, 232, 176, 43, 46, 40, 47, 177, 115, 119,
+ 294, 301, 43, 307, 236, 170, 91, 205, 209, 157,
+ 244, 303, 116, 30, 32, 35, 187, 255, 256, 297,
+ 57, 189, 254, 43, 46, 41, 40, 40, 286, 90,
+ 89, 1, 42, 43, 46, 185, 241, 287, 241, 78,
+ 278, 279, 285, 309, 201, 46, 297, 269, 41, 41,
+ 134, 250, 41, 126, 129, 242, 48, 239, 76, 41,
+ 58, 41, 41, 245, 245, 41, 58, 245, 245, 48,
+ 48, 48, 48, 48, 245, 48, 48, 48, 47, 42,
+ 42, 1, 43, 66, 73, 74, 75, 78, 83, 138,
+ 148, 149, 150, 151, 155, 156, 160, 162, 164, 167,
+ 169, 172, 174, 179, 180, 181, 182, 199, 203, 204,
+ 211, 215, 219, 220, 221, 222, 223, 224, 225, 226,
+ 229, 232, 309, 40, 250, 287, 288, 309, 54, 41,
+ 42, 171, 170, 244, 288, 43, 47, 303, 252, 294,
+ 43, 54, 305, 233, 140, 117, 140, 302, 103, 41,
+ 47, 297, 44, 118, 184, 199, 203, 204, 206, 220,
+ 222, 224, 232, 210, 143, 288, 43, 186, 40, 46,
+ 190, 150, 265, 266, 309, 40, 54, 287, 288, 289,
+ 233, 269, 244, 241, 42, 73, 74, 75, 280, 282,
+ 215, 200, 241, 269, 269, 269, 41, 41, 41, 40,
+ 269, 41, 245, 245, 48, 48, 48, 245, 48, 48,
+ 307, 307, 218, 46, 76, 76, 76, 138, 40, 299,
+ 47, 215, 30, 32, 35, 120, 230, 252, 256, 297,
+ 233, 287, 170, 303, 308, 43, 244, 41, 288, 43,
+ 244, 43, 178, 41, 119, 294, 294, 119, 294, 237,
+ 4, 46, 54, 103, 87, 60, 43, 185, 233, 40,
+ 43, 191, 267, 294, 42, 47, 233, 259, 54, 76,
+ 290, 309, 41, 41, 186, 279, 297, 281, 47, 215,
+ 269, 269, 252, 245, 48, 48, 245, 245, 215, 216,
+ 299, 40, 252, 76, 40, 43, 41, 171, 288, 43,
+ 244, 170, 43, 43, 302, 302, 104, 252, 207, 41,
+ 192, 265, 54, 265, 43, 244, 41, 43, 261, 291,
+ 292, 297, 43, 46, 185, 48, 273, 274, 309, 285,
+ 43, 202, 244, 47, 242, 245, 245, 215, 40, 233,
+ 40, 126, 129, 249, 269, 233, 43, 43, 288, 43,
+ 243, 104, 288, 43, 268, 269, 267, 186, 43, 46,
+ 43, 42, 48, 40, 46, 48, 297, 186, 202, 41,
+ 47, 233, 41, 233, 40, 40, 40, 129, 43, 41,
+ 43, 43, 111, 190, 265, 185, 292, 48, 48, 274,
+ 185, 217, 41, 227, 288, 41, 233, 233, 233, 40,
+ 289, 252, 191, 48, 48, 215, 228, 288, 43, 46,
+ 54, 228, 41, 41, 41, 233, 190, 48, 43, 46,
+ 54, 261, 228, 228, 228, 41, 191, 48, 259, 43,
+ 228, 43
+};
+
+ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const yytype_uint16 yyr1[] =
+{
+ 0, 141, 142, 142, 142, 142, 142, 142, 142, 143,
+ 143, 144, 144, 144, 144, 144, 144, 144, 145, 145,
+ 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+ 145, 145, 145, 145, 145, 145, 145, 145, 145, 147,
+ 146, 148, 149, 150, 150, 150, 151, 151, 152, 152,
+ 152, 152, 153, 154, 154, 155, 155, 155, 157, 156,
+ 158, 158, 159, 159, 160, 160, 160, 160, 161, 162,
+ 162, 163, 163, 164, 164, 165, 165, 166, 166, 167,
+ 167, 167, 168, 168, 169, 169, 169, 169, 169, 169,
+ 169, 169, 170, 170, 170, 171, 171, 172, 173, 173,
+ 174, 174, 174, 175, 176, 177, 177, 178, 178, 178,
+ 179, 180, 181, 182, 182, 182, 183, 182, 182, 182,
+ 182, 184, 184, 185, 185, 185, 185, 186, 186, 186,
+ 186, 187, 187, 187, 187, 187, 187, 188, 188, 188,
+ 189, 190, 191, 192, 191, 193, 193, 193, 194, 194,
+ 195, 196, 196, 197, 198, 198, 198, 198, 198, 198,
+ 200, 199, 201, 199, 202, 202, 203, 205, 204, 204,
+ 204, 206, 206, 206, 206, 206, 206, 206, 207, 208,
+ 208, 209, 209, 210, 210, 211, 211, 213, 212, 214,
+ 212, 212, 215, 216, 217, 215, 215, 215, 218, 215,
+ 219, 219, 219, 219, 219, 219, 219, 219, 219, 219,
+ 219, 219, 219, 219, 219, 219, 219, 219, 219, 220,
+ 221, 221, 222, 222, 222, 222, 222, 223, 224, 225,
+ 225, 225, 226, 226, 226, 226, 226, 226, 226, 226,
+ 226, 226, 226, 227, 227, 227, 228, 228, 228, 229,
+ 230, 230, 230, 230, 230, 231, 232, 232, 232, 232,
+ 232, 232, 232, 232, 232, 232, 232, 232, 232, 232,
+ 232, 232, 232, 232, 232, 232, 233, 234, 234, 235,
+ 235, 236, 236, 236, 237, 238, 238, 239, 239, 240,
+ 240, 241, 241, 241, 241, 241, 242, 242, 242, 243,
+ 243, 243, 244, 244, 244, 244, 244, 244, 244, 244,
244, 244, 244, 244, 244, 244, 244, 244, 244, 244,
- 244, 244, 244, 244, 244, 257, 267, 104, 39, 39,
- 104, 225, 244, 224, 267, 39, 104, 212, 56, 244,
- 39, 56, 39, 56, 117, 224, 227, 224, 214, 4,
- 44, 272, 131, 275, 141, 246, 272, 276, 41, 41,
- 135, 4, 153, 272, 4, 41, 44, 102, 158, 223,
- 272, 273, 265, 272, 276, 39, 215, 223, 44, 41,
- 45, 131, 42, 211, 164, 41, 44, 38, 45, 165,
- 3, 103, 107, 270, 41, 275, 215, 158, 185, 189,
- 145, 223, 272, 104, 138, 240, 241, 277, 39, 38,
- 40, 41, 44, 173, 78, 220, 1, 41, 64, 71,
- 72, 73, 76, 126, 136, 137, 138, 139, 143, 144,
- 148, 150, 152, 155, 157, 160, 162, 167, 168, 169,
- 170, 183, 184, 191, 195, 198, 199, 200, 201, 202,
- 203, 204, 207, 210, 211, 277, 250, 44, 244, 39,
- 124, 229, 39, 117, 221, 218, 74, 267, 39, 56,
- 39, 224, 39, 56, 224, 45, 40, 40, 195, 38,
- 78, 229, 259, 277, 52, 39, 40, 159, 158, 223,
- 259, 45, 272, 3, 231, 41, 52, 273, 212, 105,
- 128, 271, 128, 93, 39, 45, 172, 179, 183, 184,
- 186, 199, 201, 211, 190, 131, 259, 41, 3, 242,
- 40, 45, 38, 52, 259, 260, 212, 223, 38, 197,
- 44, 74, 74, 74, 126, 269, 45, 195, 108, 231,
- 257, 267, 76, 251, 252, 258, 277, 180, 244, 244,
- 39, 39, 244, 220, 39, 275, 275, 45, 212, 38,
- 78, 158, 272, 276, 41, 223, 39, 259, 41, 41,
- 223, 166, 39, 3, 3, 107, 3, 107, 216, 4,
- 44, 231, 58, 41, 52, 240, 240, 41, 223, 212,
- 237, 74, 261, 277, 39, 174, 212, 195, 196, 269,
- 38, 223, 231, 38, 74, 248, 267, 41, 40, 71,
- 72, 73, 253, 255, 195, 244, 39, 212, 38, 159,
- 259, 41, 223, 158, 41, 41, 271, 271, 94, 243,
- 244, 242, 174, 39, 41, 262, 263, 267, 41, 44,
- 220, 173, 39, 195, 38, 212, 174, 38, 117, 228,
- 212, 244, 44, 248, 252, 267, 254, 45, 41, 39,
- 212, 41, 259, 41, 240, 173, 41, 44, 40, 38,
- 220, 45, 212, 39, 173, 212, 38, 38, 117, 39,
- 41, 206, 44, 258, 41, 182, 223, 39, 41, 263,
- 195, 39, 208, 259, 39, 212, 212, 38, 260, 182,
- 205, 267, 174, 209, 259, 41, 44, 209, 39, 39,
- 212, 182, 173, 41, 44, 52, 209, 209, 39, 237,
- 209, 41
+ 244, 244, 244, 244, 245, 245, 245, 245, 245, 245,
+ 245, 245, 246, 246, 246, 246, 246, 246, 246, 246,
+ 246, 246, 247, 247, 247, 247, 247, 247, 247, 247,
+ 247, 247, 247, 247, 247, 247, 248, 248, 248, 248,
+ 248, 248, 248, 249, 249, 249, 249, 250, 250, 251,
+ 251, 251, 252, 253, 253, 253, 253, 254, 254, 254,
+ 254, 254, 254, 254, 254, 255, 256, 257, 257, 258,
+ 258, 258, 258, 258, 258, 258, 258, 258, 258, 258,
+ 258, 258, 258, 260, 259, 259, 261, 261, 262, 263,
+ 264, 264, 265, 265, 266, 266, 266, 266, 267, 267,
+ 268, 269, 269, 270, 270, 270, 270, 270, 270, 270,
+ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
+ 270, 271, 271, 271, 271, 271, 271, 271, 271, 272,
+ 272, 272, 272, 272, 272, 272, 272, 272, 272, 272,
+ 272, 272, 272, 272, 272, 272, 272, 272, 272, 272,
+ 272, 273, 274, 274, 275, 277, 276, 276, 278, 278,
+ 280, 279, 281, 279, 282, 282, 282, 283, 283, 283,
+ 283, 284, 284, 284, 285, 285, 286, 286, 286, 286,
+ 287, 287, 287, 287, 287, 288, 288, 288, 288, 289,
+ 289, 289, 289, 289, 289, 290, 290, 291, 291, 291,
+ 291, 292, 292, 293, 294, 294, 294, 295, 295, 295,
+ 296, 296, 297, 297, 297, 297, 297, 297, 297, 298,
+ 298, 298, 298, 299, 299, 300, 300, 301, 301, 301,
+ 301, 301, 301, 302, 302, 302, 302, 303, 303, 304,
+ 304, 305, 305, 305, 306, 306, 307, 307, 307, 307,
+ 307, 307, 308, 308, 309
};
-#define yyerrok (yyerrstatus = 0)
-#define yyclearin (yychar = YYEMPTY)
-#define YYEMPTY (-2)
-#define YYEOF 0
-
-#define YYACCEPT goto yyacceptlab
-#define YYABORT goto yyabortlab
-#define YYERROR goto yyerrorlab
-
-
-/* Like YYERROR except do call yyerror. This remains here temporarily
- to ease the transition to the new meaning of YYERROR, for GCC.
- Once GCC version 2 has supplanted version 1, this can go. However,
- YYFAIL appears to be in use. Nevertheless, it is formally deprecated
- in Bison 2.4.2's NEWS entry, where a plan to phase it out is
- discussed. */
-
-#define YYFAIL goto yyerrlab
-#if defined YYFAIL
- /* This is here to suppress warnings from the GCC cpp's
- -Wunused-macros. Normally we don't worry about that warning, but
- some users do, and we want to make it easy for users to remove
- YYFAIL uses, which will produce warnings from Bison 2.5. */
-#endif
+ /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
+static const yytype_uint8 yyr2[] =
+{
+ 0, 2, 1, 3, 2, 3, 2, 5, 3, 2,
+ 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 7, 5, 3, 5, 5, 3, 2, 2, 5, 2,
+ 5, 2, 4, 1, 1, 7, 7, 5, 0, 7,
+ 1, 1, 2, 2, 1, 5, 5, 5, 3, 4,
+ 3, 7, 8, 5, 3, 1, 1, 3, 1, 4,
+ 7, 6, 1, 1, 7, 9, 8, 10, 5, 7,
+ 6, 8, 1, 1, 5, 4, 5, 7, 1, 3,
+ 6, 6, 8, 1, 2, 3, 1, 2, 3, 6,
+ 5, 9, 2, 1, 1, 1, 0, 6, 1, 6,
+ 10, 5, 7, 1, 4, 1, 1, 1, 2, 2,
+ 3, 1, 1, 1, 1, 1, 1, 11, 13, 7,
+ 1, 1, 1, 0, 3, 1, 2, 2, 2, 1,
+ 5, 8, 10, 6, 1, 1, 1, 1, 1, 1,
+ 0, 9, 0, 8, 1, 3, 4, 0, 6, 3,
+ 4, 1, 1, 1, 1, 1, 1, 1, 1, 2,
+ 1, 1, 1, 3, 1, 3, 4, 0, 6, 0,
+ 5, 5, 2, 0, 0, 7, 1, 1, 0, 3,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 6,
+ 6, 7, 8, 8, 8, 9, 7, 5, 2, 2,
+ 2, 2, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 2, 4, 2, 2, 4, 2, 5,
+ 1, 1, 1, 1, 1, 2, 1, 1, 2, 2,
+ 1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
+ 1, 2, 2, 2, 2, 1, 1, 2, 1, 3,
+ 1, 2, 7, 3, 1, 2, 1, 3, 1, 1,
+ 1, 2, 5, 2, 2, 1, 2, 2, 1, 1,
+ 1, 1, 2, 3, 3, 1, 2, 2, 3, 4,
+ 5, 4, 5, 6, 6, 4, 5, 5, 6, 7,
+ 8, 8, 7, 7, 1, 2, 3, 4, 5, 3,
+ 4, 4, 1, 2, 4, 4, 4, 5, 3, 4,
+ 4, 5, 1, 2, 2, 2, 3, 3, 1, 2,
+ 2, 1, 1, 2, 3, 4, 3, 4, 2, 3,
+ 3, 4, 3, 3, 2, 2, 1, 1, 2, 1,
+ 1, 1, 1, 2, 1, 2, 3, 1, 1, 1,
+ 2, 1, 1, 2, 1, 4, 1, 1, 2, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 0, 2, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 5, 3, 3, 1, 1, 3,
+ 1, 1, 1, 1, 1, 5, 8, 1, 1, 1,
+ 1, 3, 4, 5, 5, 5, 6, 6, 2, 2,
+ 2, 1, 1, 1, 1, 1, 1, 1, 1, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 5, 2, 2, 2, 2,
+ 2, 3, 1, 1, 1, 0, 3, 1, 1, 3,
+ 0, 4, 0, 6, 1, 1, 1, 1, 1, 4,
+ 4, 1, 1, 1, 1, 1, 1, 1, 2, 2,
+ 4, 1, 1, 2, 4, 1, 1, 2, 1, 3,
+ 3, 4, 4, 3, 4, 2, 1, 1, 3, 4,
+ 6, 2, 2, 3, 1, 1, 1, 1, 1, 1,
+ 1, 1, 2, 4, 1, 3, 1, 2, 3, 3,
+ 2, 2, 2, 1, 2, 1, 3, 2, 4, 1,
+ 3, 1, 3, 3, 2, 2, 2, 2, 1, 2,
+ 1, 1, 1, 1, 3, 1, 3, 5, 1, 3,
+ 3, 5, 1, 1, 0
+};
-#define YYRECOVERING() (!!yyerrstatus)
-#define YYBACKUP(Token, Value) \
-do \
- if (yychar == YYEMPTY && yylen == 1) \
- { \
- yychar = (Token); \
- yylval = (Value); \
- YYPOPSTACK (1); \
- goto yybackup; \
- } \
- else \
- { \
- yyerror (YY_("syntax error: cannot back up")); \
- YYERROR; \
- } \
-while (YYID (0))
-
-
-#define YYTERROR 1
-#define YYERRCODE 256
-
-
-/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
- If N is 0, then set CURRENT to the empty location which ends
- the previous symbol: RHS[0] (always defined). */
-
-#define YYRHSLOC(Rhs, K) ((Rhs)[K])
-#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N) \
- do \
- if (YYID (N)) \
- { \
- (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
- (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
- (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
- (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
- } \
- else \
- { \
- (Current).first_line = (Current).last_line = \
- YYRHSLOC (Rhs, 0).last_line; \
- (Current).first_column = (Current).last_column = \
- YYRHSLOC (Rhs, 0).last_column; \
- } \
- while (YYID (0))
-#endif
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (yychar = YYEMPTY)
+#define YYEMPTY (-2)
+#define YYEOF 0
+#define YYACCEPT goto yyacceptlab
+#define YYABORT goto yyabortlab
+#define YYERROR goto yyerrorlab
-/* This macro is provided for backward compatibility. */
-#ifndef YY_LOCATION_PRINT
-# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-#endif
+#define YYRECOVERING() (!!yyerrstatus)
+#define YYBACKUP(Token, Value) \
+do \
+ if (yychar == YYEMPTY) \
+ { \
+ yychar = (Token); \
+ yylval = (Value); \
+ YYPOPSTACK (yylen); \
+ yystate = *yyssp; \
+ goto yybackup; \
+ } \
+ else \
+ { \
+ yyerror (YY_("syntax error: cannot back up")); \
+ YYERROR; \
+ } \
+while (0)
+
+/* Error token number */
+#define YYTERROR 1
+#define YYERRCODE 256
-/* YYLEX -- calling `yylex' with the right arguments. */
-#ifdef YYLEX_PARAM
-# define YYLEX yylex (YYLEX_PARAM)
-#else
-# define YYLEX yylex ()
-#endif
/* Enable debugging if requested. */
#if YYDEBUG
# define YYFPRINTF fprintf
# endif
-# define YYDPRINTF(Args) \
-do { \
- if (yydebug) \
- YYFPRINTF Args; \
-} while (YYID (0))
+# define YYDPRINTF(Args) \
+do { \
+ if (yydebug) \
+ YYFPRINTF Args; \
+} while (0)
+
+/* This macro is provided for backward compatibility. */
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif
+
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
-do { \
- if (yydebug) \
- { \
- YYFPRINTF (stderr, "%s ", Title); \
- yy_symbol_print (stderr, \
- Type, Value); \
- YYFPRINTF (stderr, "\n"); \
- } \
-} while (YYID (0))
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
+do { \
+ if (yydebug) \
+ { \
+ YYFPRINTF (stderr, "%s ", Title); \
+ yy_symbol_print (stderr, \
+ Type, Value); \
+ YYFPRINTF (stderr, "\n"); \
+ } \
+} while (0)
-/*--------------------------------.
-| Print this symbol on YYOUTPUT. |
-`--------------------------------*/
+/*----------------------------------------.
+| Print this symbol's value on YYOUTPUT. |
+`----------------------------------------*/
-/*ARGSUSED*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
-#else
-static void
-yy_symbol_value_print (yyoutput, yytype, yyvaluep)
- FILE *yyoutput;
- int yytype;
- YYSTYPE const * const yyvaluep;
-#endif
{
+ FILE *yyo = yyoutput;
+ YYUSE (yyo);
if (!yyvaluep)
return;
# ifdef YYPRINT
if (yytype < YYNTOKENS)
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
-# else
- YYUSE (yyoutput);
# endif
- switch (yytype)
- {
- default:
- break;
- }
+ YYUSE (yytype);
}
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
-#else
-static void
-yy_symbol_print (yyoutput, yytype, yyvaluep)
- FILE *yyoutput;
- int yytype;
- YYSTYPE const * const yyvaluep;
-#endif
{
- if (yytype < YYNTOKENS)
- YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
- else
- YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+ YYFPRINTF (yyoutput, "%s %s (",
+ yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
yy_symbol_value_print (yyoutput, yytype, yyvaluep);
YYFPRINTF (yyoutput, ")");
| TOP (included). |
`------------------------------------------------------------------*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
static void
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
-#else
-static void
-yy_stack_print (yybottom, yytop)
- yytype_int16 *yybottom;
- yytype_int16 *yytop;
-#endif
{
YYFPRINTF (stderr, "Stack now");
for (; yybottom <= yytop; yybottom++)
YYFPRINTF (stderr, "\n");
}
-# define YY_STACK_PRINT(Bottom, Top) \
-do { \
- if (yydebug) \
- yy_stack_print ((Bottom), (Top)); \
-} while (YYID (0))
+# define YY_STACK_PRINT(Bottom, Top) \
+do { \
+ if (yydebug) \
+ yy_stack_print ((Bottom), (Top)); \
+} while (0)
/*------------------------------------------------.
| Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
static void
-yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
-#else
-static void
-yy_reduce_print (yyvsp, yyrule)
- YYSTYPE *yyvsp;
- int yyrule;
-#endif
+yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
{
+ unsigned long int yylno = yyrline[yyrule];
int yynrhs = yyr2[yyrule];
int yyi;
- unsigned long int yylno = yyrline[yyrule];
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
- yyrule - 1, yylno);
+ yyrule - 1, yylno);
/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)
{
YYFPRINTF (stderr, " $%d = ", yyi + 1);
- yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
- &(yyvsp[(yyi + 1) - (yynrhs)])
- );
+ yy_symbol_print (stderr,
+ yystos[yyssp[yyi + 1 - yynrhs]],
+ &(yyvsp[(yyi + 1) - (yynrhs)])
+ );
YYFPRINTF (stderr, "\n");
}
}
-# define YY_REDUCE_PRINT(Rule) \
-do { \
- if (yydebug) \
- yy_reduce_print (yyvsp, Rule); \
-} while (YYID (0))
+# define YY_REDUCE_PRINT(Rule) \
+do { \
+ if (yydebug) \
+ yy_reduce_print (yyssp, yyvsp, Rule); \
+} while (0)
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
/* YYINITDEPTH -- initial size of the parser's stacks. */
-#ifndef YYINITDEPTH
+#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif
# define yystrlen strlen
# else
/* Return the length of YYSTR. */
-#if (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
static YYSIZE_T
yystrlen (const char *yystr)
-#else
-static YYSIZE_T
-yystrlen (yystr)
- const char *yystr;
-#endif
{
YYSIZE_T yylen;
for (yylen = 0; yystr[yylen]; yylen++)
# else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
YYDEST. */
-#if (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
static char *
yystpcpy (char *yydest, const char *yysrc)
-#else
-static char *
-yystpcpy (yydest, yysrc)
- char *yydest;
- const char *yysrc;
-#endif
{
char *yyd = yydest;
const char *yys = yysrc;
char const *yyp = yystr;
for (;;)
- switch (*++yyp)
- {
- case '\'':
- case ',':
- goto do_not_strip_quotes;
-
- case '\\':
- if (*++yyp != '\\')
- goto do_not_strip_quotes;
- /* Fall through. */
- default:
- if (yyres)
- yyres[yyn] = *yyp;
- yyn++;
- break;
-
- case '"':
- if (yyres)
- yyres[yyn] = '\0';
- return yyn;
- }
+ switch (*++yyp)
+ {
+ case '\'':
+ case ',':
+ goto do_not_strip_quotes;
+
+ case '\\':
+ if (*++yyp != '\\')
+ goto do_not_strip_quotes;
+ /* Fall through. */
+ default:
+ if (yyres)
+ yyres[yyn] = *yyp;
+ yyn++;
+ break;
+
+ case '"':
+ if (yyres)
+ yyres[yyn] = '\0';
+ return yyn;
+ }
do_not_strip_quotes: ;
}
yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
yytype_int16 *yyssp, int yytoken)
{
- YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
+ YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
YYSIZE_T yysize = yysize0;
- YYSIZE_T yysize1;
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
/* Internationalized format string. */
- const char *yyformat = 0;
+ const char *yyformat = YY_NULLPTR;
/* Arguments of yyformat. */
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
/* Number of reported tokens (one for the "unexpected", one per
int yycount = 0;
/* There are many possibilities here to consider:
- - Assume YYFAIL is not used. It's too flawed to consider. See
- <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
- for details. YYERROR is fine as it does not invoke this
- function.
- If this state is a consistent state with a default action, then
the only way this function was invoked is if the default action
is an error action. In that case, don't check for expected
break;
}
yyarg[yycount++] = yytname[yyx];
- yysize1 = yysize + yytnamerr (0, yytname[yyx]);
- if (! (yysize <= yysize1
- && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
- return 2;
- yysize = yysize1;
+ {
+ YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+ if (! (yysize <= yysize1
+ && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+ return 2;
+ yysize = yysize1;
+ }
}
}
}
# undef YYCASE_
}
- yysize1 = yysize + yystrlen (yyformat);
- if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
- return 2;
- yysize = yysize1;
+ {
+ YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
+ if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+ return 2;
+ yysize = yysize1;
+ }
if (*yymsg_alloc < yysize)
{
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
-/*ARGSUSED*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
-#else
-static void
-yydestruct (yymsg, yytype, yyvaluep)
- const char *yymsg;
- int yytype;
- YYSTYPE *yyvaluep;
-#endif
{
YYUSE (yyvaluep);
-
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
- switch (yytype)
- {
-
- default:
- break;
- }
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ YYUSE (yytype);
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
}
-/* Prevent warnings from -Wmissing-prototypes. */
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
/* The lookahead symbol. */
/* The semantic value of the lookahead symbol. */
YYSTYPE yylval;
-
/* Number of syntax errors so far. */
int yynerrs;
| yyparse. |
`----------*/
-#ifdef YYPARSE_PARAM
-#if (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
-int
-yyparse (void *YYPARSE_PARAM)
-#else
-int
-yyparse (YYPARSE_PARAM)
- void *YYPARSE_PARAM;
-#endif
-#else /* ! YYPARSE_PARAM */
-#if (defined __STDC__ || defined __C99__FUNC__ \
- || defined __cplusplus || defined _MSC_VER)
int
yyparse (void)
-#else
-int
-yyparse ()
-
-#endif
-#endif
{
int yystate;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
/* The stacks and their tools:
- `yyss': related to states.
- `yyvs': related to semantic values.
+ 'yyss': related to states.
+ 'yyvs': related to semantic values.
- Refer to the stacks thru separate pointers, to allow yyoverflow
+ Refer to the stacks through separate pointers, to allow yyoverflow
to reallocate them elsewhere. */
/* The state stack. */
int yyn;
int yyresult;
/* Lookahead token as an internal (translated) token number. */
- int yytoken;
+ int yytoken = 0;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
Keep to zero when no symbol should be popped. */
int yylen = 0;
- yytoken = 0;
- yyss = yyssa;
- yyvs = yyvsa;
+ yyssp = yyss = yyssa;
+ yyvsp = yyvs = yyvsa;
yystacksize = YYINITDEPTH;
YYDPRINTF ((stderr, "Starting parse\n"));
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
-
- /* Initialize stack pointers.
- Waste one element of value and location stack
- so that they stay on the same level as the state stack.
- The wasted elements are never initialized. */
- yyssp = yyss;
- yyvsp = yyvs;
-
goto yysetstate;
/*------------------------------------------------------------.
#ifdef yyoverflow
{
- /* Give user a chance to reallocate the stack. Use copies of
- these so that the &'s don't force the real ones into
- memory. */
- YYSTYPE *yyvs1 = yyvs;
- yytype_int16 *yyss1 = yyss;
-
- /* Each stack pointer address is followed by the size of the
- data in use in that stack, in bytes. This used to be a
- conditional around just the two extra args, but that might
- be undefined if yyoverflow is a macro. */
- yyoverflow (YY_("memory exhausted"),
- &yyss1, yysize * sizeof (*yyssp),
- &yyvs1, yysize * sizeof (*yyvsp),
- &yystacksize);
-
- yyss = yyss1;
- yyvs = yyvs1;
+ /* Give user a chance to reallocate the stack. Use copies of
+ these so that the &'s don't force the real ones into
+ memory. */
+ YYSTYPE *yyvs1 = yyvs;
+ yytype_int16 *yyss1 = yyss;
+
+ /* Each stack pointer address is followed by the size of the
+ data in use in that stack, in bytes. This used to be a
+ conditional around just the two extra args, but that might
+ be undefined if yyoverflow is a macro. */
+ yyoverflow (YY_("memory exhausted"),
+ &yyss1, yysize * sizeof (*yyssp),
+ &yyvs1, yysize * sizeof (*yyvsp),
+ &yystacksize);
+
+ yyss = yyss1;
+ yyvs = yyvs1;
}
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
# else
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
- goto yyexhaustedlab;
+ goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
- yystacksize = YYMAXDEPTH;
+ yystacksize = YYMAXDEPTH;
{
- yytype_int16 *yyss1 = yyss;
- union yyalloc *yyptr =
- (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
- if (! yyptr)
- goto yyexhaustedlab;
- YYSTACK_RELOCATE (yyss_alloc, yyss);
- YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+ yytype_int16 *yyss1 = yyss;
+ union yyalloc *yyptr =
+ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+ if (! yyptr)
+ goto yyexhaustedlab;
+ YYSTACK_RELOCATE (yyss_alloc, yyss);
+ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE
- if (yyss1 != yyssa)
- YYSTACK_FREE (yyss1);
+ if (yyss1 != yyssa)
+ YYSTACK_FREE (yyss1);
}
# endif
#endif /* no yyoverflow */
yyvsp = yyvs + yysize - 1;
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
- (unsigned long int) yystacksize));
+ (unsigned long int) yystacksize));
if (yyss + yystacksize - 1 <= yyssp)
- YYABORT;
+ YYABORT;
}
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
- yychar = YYLEX;
+ yychar = yylex ();
}
if (yychar <= YYEOF)
yychar = YYEMPTY;
yystate = yyn;
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
goto yynewstate;
yylen = yyr2[yyn];
/* If YYLEN is nonzero, implement the default value of the action:
- `$$ = $1'.
+ '$$ = $1'.
Otherwise, the following line sets YYVAL to garbage.
This behavior is undocumented and Bison
switch (yyn)
{
case 2:
-
-/* Line 1806 of yacc.c */
-#line 1802 "parser.y"
+#line 1506 "parser.y" /* yacc.c:1646 */
{
if (!classes) classes = NewHash();
- Setattr((yyvsp[(1) - (1)].node),"classes",classes);
- Setattr((yyvsp[(1) - (1)].node),"name",ModuleName);
+ Setattr((yyvsp[0].node),"classes",classes);
+ Setattr((yyvsp[0].node),"name",ModuleName);
if ((!module_node) && ModuleName) {
module_node = new_node("module");
Setattr(module_node,"name",ModuleName);
}
- Setattr((yyvsp[(1) - (1)].node),"module",module_node);
- check_extensions();
- top = (yyvsp[(1) - (1)].node);
+ Setattr((yyvsp[0].node),"module",module_node);
+ top = (yyvsp[0].node);
}
+#line 4474 "y.tab.c" /* yacc.c:1646 */
break;
case 3:
-
-/* Line 1806 of yacc.c */
-#line 1815 "parser.y"
+#line 1518 "parser.y" /* yacc.c:1646 */
{
- top = Copy(Getattr((yyvsp[(2) - (3)].p),"type"));
- Delete((yyvsp[(2) - (3)].p));
+ top = Copy(Getattr((yyvsp[-1].p),"type"));
+ Delete((yyvsp[-1].p));
}
+#line 4483 "y.tab.c" /* yacc.c:1646 */
break;
case 4:
-
-/* Line 1806 of yacc.c */
-#line 1819 "parser.y"
+#line 1522 "parser.y" /* yacc.c:1646 */
{
top = 0;
}
+#line 4491 "y.tab.c" /* yacc.c:1646 */
break;
case 5:
-
-/* Line 1806 of yacc.c */
-#line 1822 "parser.y"
+#line 1525 "parser.y" /* yacc.c:1646 */
{
- top = (yyvsp[(2) - (3)].p);
+ top = (yyvsp[-1].p);
}
+#line 4499 "y.tab.c" /* yacc.c:1646 */
break;
case 6:
-
-/* Line 1806 of yacc.c */
-#line 1825 "parser.y"
+#line 1528 "parser.y" /* yacc.c:1646 */
{
top = 0;
}
+#line 4507 "y.tab.c" /* yacc.c:1646 */
break;
case 7:
-
-/* Line 1806 of yacc.c */
-#line 1828 "parser.y"
+#line 1531 "parser.y" /* yacc.c:1646 */
{
- top = (yyvsp[(3) - (5)].pl);
+ top = (yyvsp[-2].pl);
}
+#line 4515 "y.tab.c" /* yacc.c:1646 */
break;
case 8:
-
-/* Line 1806 of yacc.c */
-#line 1831 "parser.y"
+#line 1534 "parser.y" /* yacc.c:1646 */
{
top = 0;
}
+#line 4523 "y.tab.c" /* yacc.c:1646 */
break;
case 9:
-
-/* Line 1806 of yacc.c */
-#line 1836 "parser.y"
+#line 1539 "parser.y" /* yacc.c:1646 */
{
/* add declaration to end of linked list (the declaration isn't always a single declaration, sometimes it is a linked list itself) */
- appendChild((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node));
- (yyval.node) = (yyvsp[(1) - (2)].node);
+ appendChild((yyvsp[-1].node),(yyvsp[0].node));
+ (yyval.node) = (yyvsp[-1].node);
}
+#line 4533 "y.tab.c" /* yacc.c:1646 */
break;
case 10:
-
-/* Line 1806 of yacc.c */
-#line 1841 "parser.y"
+#line 1544 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("top");
}
+#line 4541 "y.tab.c" /* yacc.c:1646 */
break;
case 11:
-
-/* Line 1806 of yacc.c */
-#line 1846 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1549 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4547 "y.tab.c" /* yacc.c:1646 */
break;
case 12:
-
-/* Line 1806 of yacc.c */
-#line 1847 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1550 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4553 "y.tab.c" /* yacc.c:1646 */
break;
case 13:
-
-/* Line 1806 of yacc.c */
-#line 1848 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1551 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4559 "y.tab.c" /* yacc.c:1646 */
break;
case 14:
-
-/* Line 1806 of yacc.c */
-#line 1849 "parser.y"
+#line 1552 "parser.y" /* yacc.c:1646 */
{ (yyval.node) = 0; }
+#line 4565 "y.tab.c" /* yacc.c:1646 */
break;
case 15:
-
-/* Line 1806 of yacc.c */
-#line 1850 "parser.y"
+#line 1553 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = 0;
- Swig_error(cparse_file, cparse_line,"Syntax error in input(1).\n");
+ if (cparse_unknown_directive) {
+ Swig_error(cparse_file, cparse_line, "Unknown directive '%s'.\n", cparse_unknown_directive);
+ } else {
+ Swig_error(cparse_file, cparse_line, "Syntax error in input(1).\n");
+ }
exit(1);
}
+#line 4579 "y.tab.c" /* yacc.c:1646 */
break;
case 16:
-
-/* Line 1806 of yacc.c */
-#line 1856 "parser.y"
+#line 1563 "parser.y" /* yacc.c:1646 */
{
if ((yyval.node)) {
add_symbols((yyval.node));
}
- (yyval.node) = (yyvsp[(1) - (1)].node);
+ (yyval.node) = (yyvsp[0].node);
}
+#line 4590 "y.tab.c" /* yacc.c:1646 */
break;
case 17:
-
-/* Line 1806 of yacc.c */
-#line 1872 "parser.y"
+#line 1579 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = 0;
skip_decl();
}
+#line 4599 "y.tab.c" /* yacc.c:1646 */
break;
case 18:
-
-/* Line 1806 of yacc.c */
-#line 1882 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1589 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4605 "y.tab.c" /* yacc.c:1646 */
break;
case 19:
-
-/* Line 1806 of yacc.c */
-#line 1883 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1590 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4611 "y.tab.c" /* yacc.c:1646 */
break;
case 20:
-
-/* Line 1806 of yacc.c */
-#line 1884 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1591 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4617 "y.tab.c" /* yacc.c:1646 */
break;
case 21:
-
-/* Line 1806 of yacc.c */
-#line 1885 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1592 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4623 "y.tab.c" /* yacc.c:1646 */
break;
case 22:
-
-/* Line 1806 of yacc.c */
-#line 1886 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1593 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4629 "y.tab.c" /* yacc.c:1646 */
break;
case 23:
-
-/* Line 1806 of yacc.c */
-#line 1887 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1594 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4635 "y.tab.c" /* yacc.c:1646 */
break;
case 24:
-
-/* Line 1806 of yacc.c */
-#line 1888 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1595 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4641 "y.tab.c" /* yacc.c:1646 */
break;
case 25:
-
-/* Line 1806 of yacc.c */
-#line 1889 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1596 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4647 "y.tab.c" /* yacc.c:1646 */
break;
case 26:
-
-/* Line 1806 of yacc.c */
-#line 1890 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1597 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4653 "y.tab.c" /* yacc.c:1646 */
break;
case 27:
-
-/* Line 1806 of yacc.c */
-#line 1891 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1598 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4659 "y.tab.c" /* yacc.c:1646 */
break;
case 28:
-
-/* Line 1806 of yacc.c */
-#line 1892 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1599 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4665 "y.tab.c" /* yacc.c:1646 */
break;
case 29:
-
-/* Line 1806 of yacc.c */
-#line 1893 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1600 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4671 "y.tab.c" /* yacc.c:1646 */
break;
case 30:
-
-/* Line 1806 of yacc.c */
-#line 1894 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1601 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4677 "y.tab.c" /* yacc.c:1646 */
break;
case 31:
-
-/* Line 1806 of yacc.c */
-#line 1895 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1602 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4683 "y.tab.c" /* yacc.c:1646 */
break;
case 32:
-
-/* Line 1806 of yacc.c */
-#line 1896 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1603 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4689 "y.tab.c" /* yacc.c:1646 */
break;
case 33:
-
-/* Line 1806 of yacc.c */
-#line 1897 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1604 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4695 "y.tab.c" /* yacc.c:1646 */
break;
case 34:
-
-/* Line 1806 of yacc.c */
-#line 1898 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1605 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4701 "y.tab.c" /* yacc.c:1646 */
break;
case 35:
-
-/* Line 1806 of yacc.c */
-#line 1899 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1606 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4707 "y.tab.c" /* yacc.c:1646 */
break;
case 36:
-
-/* Line 1806 of yacc.c */
-#line 1900 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1607 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4713 "y.tab.c" /* yacc.c:1646 */
break;
case 37:
-
-/* Line 1806 of yacc.c */
-#line 1901 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1608 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4719 "y.tab.c" /* yacc.c:1646 */
break;
case 38:
-
-/* Line 1806 of yacc.c */
-#line 1902 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 1609 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 4725 "y.tab.c" /* yacc.c:1646 */
break;
case 39:
-
-/* Line 1806 of yacc.c */
-#line 1909 "parser.y"
+#line 1616 "parser.y" /* yacc.c:1646 */
{
Node *cls;
String *clsname;
+ extendmode = 1;
cplus_mode = CPLUS_PUBLIC;
if (!classes) classes = NewHash();
if (!classes_typedefs) classes_typedefs = NewHash();
- if (!extendhash) extendhash = NewHash();
- clsname = make_class_name((yyvsp[(3) - (4)].str));
+ clsname = make_class_name((yyvsp[-1].str));
cls = Getattr(classes,clsname);
if (!cls) {
cls = Getattr(classes_typedefs, clsname);
if (!cls) {
/* No previous definition. Create a new scope */
- Node *am = Getattr(extendhash,clsname);
+ Node *am = Getattr(Swig_extend_hash(),clsname);
if (!am) {
Swig_symbol_newscope();
- Swig_symbol_setscopename((yyvsp[(3) - (4)].str));
+ Swig_symbol_setscopename((yyvsp[-1].str));
prev_symtab = 0;
} else {
prev_symtab = Swig_symbol_setscope(Getattr(am,"symtab"));
Note that %extend before the class typedef never worked, only %extend after the class typdef. */
prev_symtab = Swig_symbol_setscope(Getattr(cls, "symtab"));
current_class = cls;
- extendmode = 1;
SWIG_WARN_NODE_BEGIN(cls);
- Swig_warning(WARN_PARSE_EXTEND_NAME, cparse_file, cparse_line, "Deprecated %%extend name used - the %s name '%s' should be used instead of the typedef name '%s'.\n", Getattr(cls, "kind"), SwigType_namestr(Getattr(cls, "name")), (yyvsp[(3) - (4)].str));
+ Swig_warning(WARN_PARSE_EXTEND_NAME, cparse_file, cparse_line, "Deprecated %%extend name used - the %s name '%s' should be used instead of the typedef name '%s'.\n", Getattr(cls, "kind"), SwigType_namestr(Getattr(cls, "name")), (yyvsp[-1].str));
SWIG_WARN_NODE_END(cls);
}
} else {
/* Previous class definition. Use its symbol table */
prev_symtab = Swig_symbol_setscope(Getattr(cls,"symtab"));
current_class = cls;
- extendmode = 1;
}
- Classprefix = NewString((yyvsp[(3) - (4)].str));
+ Classprefix = NewString((yyvsp[-1].str));
Namespaceprefix= Swig_symbol_qualifiedscopename(0);
Delete(clsname);
}
+#line 4771 "y.tab.c" /* yacc.c:1646 */
break;
case 40:
-
-/* Line 1806 of yacc.c */
-#line 1951 "parser.y"
+#line 1656 "parser.y" /* yacc.c:1646 */
{
String *clsname;
extendmode = 0;
Swig_symbol_setscope(prev_symtab);
}
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
- clsname = make_class_name((yyvsp[(3) - (7)].str));
+ clsname = make_class_name((yyvsp[-4].str));
Setattr((yyval.node),"name",clsname);
- /* Mark members as extend */
-
- tag_nodes((yyvsp[(6) - (7)].node),"feature:extend",(char*) "1");
+ mark_nodes_as_extend((yyvsp[-1].node));
if (current_class) {
/* We add the extension to the previously defined class */
- appendChild((yyval.node),(yyvsp[(6) - (7)].node));
+ appendChild((yyval.node),(yyvsp[-1].node));
appendChild(current_class,(yyval.node));
} else {
/* We store the extensions in the extensions hash */
- Node *am = Getattr(extendhash,clsname);
+ Node *am = Getattr(Swig_extend_hash(),clsname);
if (am) {
/* Append the members to the previous extend methods */
- appendChild(am,(yyvsp[(6) - (7)].node));
+ appendChild(am,(yyvsp[-1].node));
} else {
- appendChild((yyval.node),(yyvsp[(6) - (7)].node));
- Setattr(extendhash,clsname,(yyval.node));
+ appendChild((yyval.node),(yyvsp[-1].node));
+ Setattr(Swig_extend_hash(),clsname,(yyval.node));
}
}
current_class = 0;
(yyval.node) = 0;
}
+#line 4812 "y.tab.c" /* yacc.c:1646 */
break;
case 41:
-
-/* Line 1806 of yacc.c */
-#line 1995 "parser.y"
+#line 1698 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("apply");
- Setattr((yyval.node),"pattern",Getattr((yyvsp[(2) - (5)].p),"pattern"));
- appendChild((yyval.node),(yyvsp[(4) - (5)].p));
+ Setattr((yyval.node),"pattern",Getattr((yyvsp[-3].p),"pattern"));
+ appendChild((yyval.node),(yyvsp[-1].p));
}
+#line 4822 "y.tab.c" /* yacc.c:1646 */
break;
case 42:
-
-/* Line 1806 of yacc.c */
-#line 2005 "parser.y"
+#line 1708 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("clear");
- appendChild((yyval.node),(yyvsp[(2) - (3)].p));
+ appendChild((yyval.node),(yyvsp[-1].p));
}
+#line 4831 "y.tab.c" /* yacc.c:1646 */
break;
case 43:
-
-/* Line 1806 of yacc.c */
-#line 2016 "parser.y"
+#line 1719 "parser.y" /* yacc.c:1646 */
{
- if (((yyvsp[(4) - (5)].dtype).type != T_ERROR) && ((yyvsp[(4) - (5)].dtype).type != T_SYMBOL)) {
- SwigType *type = NewSwigType((yyvsp[(4) - (5)].dtype).type);
+ if (((yyvsp[-1].dtype).type != T_ERROR) && ((yyvsp[-1].dtype).type != T_SYMBOL)) {
+ SwigType *type = NewSwigType((yyvsp[-1].dtype).type);
(yyval.node) = new_node("constant");
- Setattr((yyval.node),"name",(yyvsp[(2) - (5)].id));
+ Setattr((yyval.node),"name",(yyvsp[-3].id));
Setattr((yyval.node),"type",type);
- Setattr((yyval.node),"value",(yyvsp[(4) - (5)].dtype).val);
- if ((yyvsp[(4) - (5)].dtype).rawval) Setattr((yyval.node),"rawval", (yyvsp[(4) - (5)].dtype).rawval);
+ Setattr((yyval.node),"value",(yyvsp[-1].dtype).val);
+ if ((yyvsp[-1].dtype).rawval) Setattr((yyval.node),"rawval", (yyvsp[-1].dtype).rawval);
Setattr((yyval.node),"storage","%constant");
SetFlag((yyval.node),"feature:immutable");
add_symbols((yyval.node));
Delete(type);
} else {
- if ((yyvsp[(4) - (5)].dtype).type == T_ERROR) {
+ if ((yyvsp[-1].dtype).type == T_ERROR) {
Swig_warning(WARN_PARSE_UNSUPPORTED_VALUE,cparse_file,cparse_line,"Unsupported constant value (ignored)\n");
}
(yyval.node) = 0;
}
}
+#line 4856 "y.tab.c" /* yacc.c:1646 */
break;
case 44:
-
-/* Line 1806 of yacc.c */
-#line 2037 "parser.y"
+#line 1740 "parser.y" /* yacc.c:1646 */
{
- if (((yyvsp[(4) - (5)].dtype).type != T_ERROR) && ((yyvsp[(4) - (5)].dtype).type != T_SYMBOL)) {
- SwigType_push((yyvsp[(2) - (5)].type),(yyvsp[(3) - (5)].decl).type);
+ if (((yyvsp[-1].dtype).type != T_ERROR) && ((yyvsp[-1].dtype).type != T_SYMBOL)) {
+ SwigType_push((yyvsp[-3].type),(yyvsp[-2].decl).type);
/* Sneaky callback function trick */
- if (SwigType_isfunction((yyvsp[(2) - (5)].type))) {
- SwigType_add_pointer((yyvsp[(2) - (5)].type));
+ if (SwigType_isfunction((yyvsp[-3].type))) {
+ SwigType_add_pointer((yyvsp[-3].type));
}
(yyval.node) = new_node("constant");
- Setattr((yyval.node),"name",(yyvsp[(3) - (5)].decl).id);
- Setattr((yyval.node),"type",(yyvsp[(2) - (5)].type));
- Setattr((yyval.node),"value",(yyvsp[(4) - (5)].dtype).val);
- if ((yyvsp[(4) - (5)].dtype).rawval) Setattr((yyval.node),"rawval", (yyvsp[(4) - (5)].dtype).rawval);
+ Setattr((yyval.node),"name",(yyvsp[-2].decl).id);
+ Setattr((yyval.node),"type",(yyvsp[-3].type));
+ Setattr((yyval.node),"value",(yyvsp[-1].dtype).val);
+ if ((yyvsp[-1].dtype).rawval) Setattr((yyval.node),"rawval", (yyvsp[-1].dtype).rawval);
Setattr((yyval.node),"storage","%constant");
SetFlag((yyval.node),"feature:immutable");
add_symbols((yyval.node));
} else {
- if ((yyvsp[(4) - (5)].dtype).type == T_ERROR) {
+ if ((yyvsp[-1].dtype).type == T_ERROR) {
Swig_warning(WARN_PARSE_UNSUPPORTED_VALUE,cparse_file,cparse_line,"Unsupported constant value\n");
}
(yyval.node) = 0;
}
}
+#line 4883 "y.tab.c" /* yacc.c:1646 */
break;
case 45:
-
-/* Line 1806 of yacc.c */
-#line 2059 "parser.y"
+#line 1762 "parser.y" /* yacc.c:1646 */
{
Swig_warning(WARN_PARSE_BAD_VALUE,cparse_file,cparse_line,"Bad constant value (ignored).\n");
(yyval.node) = 0;
}
+#line 4892 "y.tab.c" /* yacc.c:1646 */
break;
case 46:
-
-/* Line 1806 of yacc.c */
-#line 2070 "parser.y"
+#line 1773 "parser.y" /* yacc.c:1646 */
{
char temp[64];
- Replace((yyvsp[(2) - (2)].str),"$file",cparse_file, DOH_REPLACE_ANY);
+ Replace((yyvsp[0].str),"$file",cparse_file, DOH_REPLACE_ANY);
sprintf(temp,"%d", cparse_line);
- Replace((yyvsp[(2) - (2)].str),"$line",temp,DOH_REPLACE_ANY);
- Printf(stderr,"%s\n", (yyvsp[(2) - (2)].str));
- Delete((yyvsp[(2) - (2)].str));
+ Replace((yyvsp[0].str),"$line",temp,DOH_REPLACE_ANY);
+ Printf(stderr,"%s\n", (yyvsp[0].str));
+ Delete((yyvsp[0].str));
(yyval.node) = 0;
}
+#line 4906 "y.tab.c" /* yacc.c:1646 */
break;
case 47:
-
-/* Line 1806 of yacc.c */
-#line 2079 "parser.y"
+#line 1782 "parser.y" /* yacc.c:1646 */
{
char temp[64];
- String *s = NewString((yyvsp[(2) - (2)].id));
+ String *s = (yyvsp[0].str);
Replace(s,"$file",cparse_file, DOH_REPLACE_ANY);
sprintf(temp,"%d", cparse_line);
Replace(s,"$line",temp,DOH_REPLACE_ANY);
Delete(s);
(yyval.node) = 0;
}
+#line 4921 "y.tab.c" /* yacc.c:1646 */
break;
case 48:
-
-/* Line 1806 of yacc.c */
-#line 2098 "parser.y"
+#line 1801 "parser.y" /* yacc.c:1646 */
{
skip_balanced('{','}');
(yyval.node) = 0;
Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n");
}
+#line 4931 "y.tab.c" /* yacc.c:1646 */
break;
case 49:
-
-/* Line 1806 of yacc.c */
-#line 2104 "parser.y"
+#line 1807 "parser.y" /* yacc.c:1646 */
{
skip_balanced('{','}');
(yyval.node) = 0;
Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n");
}
+#line 4941 "y.tab.c" /* yacc.c:1646 */
break;
case 50:
-
-/* Line 1806 of yacc.c */
-#line 2110 "parser.y"
+#line 1813 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = 0;
Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n");
}
+#line 4950 "y.tab.c" /* yacc.c:1646 */
break;
case 51:
-
-/* Line 1806 of yacc.c */
-#line 2115 "parser.y"
+#line 1818 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = 0;
Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n");
}
+#line 4959 "y.tab.c" /* yacc.c:1646 */
break;
case 52:
-
-/* Line 1806 of yacc.c */
-#line 2122 "parser.y"
+#line 1825 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = NewHash();
- Setattr((yyval.node),"value",(yyvsp[(1) - (4)].id));
- Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (4)].p),"type"));
+ Setattr((yyval.node),"value",(yyvsp[-3].str));
+ Setattr((yyval.node),"type",Getattr((yyvsp[-1].p),"type"));
}
+#line 4969 "y.tab.c" /* yacc.c:1646 */
break;
case 53:
-
-/* Line 1806 of yacc.c */
-#line 2129 "parser.y"
+#line 1832 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = NewHash();
- Setattr((yyval.node),"value",(yyvsp[(1) - (1)].id));
+ Setattr((yyval.node),"value",(yyvsp[0].str));
}
+#line 4978 "y.tab.c" /* yacc.c:1646 */
break;
case 54:
-
-/* Line 1806 of yacc.c */
-#line 2133 "parser.y"
+#line 1836 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(1) - (1)].node);
+ (yyval.node) = (yyvsp[0].node);
}
+#line 4986 "y.tab.c" /* yacc.c:1646 */
break;
case 55:
-
-/* Line 1806 of yacc.c */
-#line 2146 "parser.y"
+#line 1849 "parser.y" /* yacc.c:1646 */
{
- Hash *p = (yyvsp[(5) - (7)].node);
+ Hash *p = (yyvsp[-2].node);
(yyval.node) = new_node("fragment");
- Setattr((yyval.node),"value",Getattr((yyvsp[(3) - (7)].node),"value"));
- Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (7)].node),"type"));
+ Setattr((yyval.node),"value",Getattr((yyvsp[-4].node),"value"));
+ Setattr((yyval.node),"type",Getattr((yyvsp[-4].node),"type"));
Setattr((yyval.node),"section",Getattr(p,"name"));
Setattr((yyval.node),"kwargs",nextSibling(p));
- Setattr((yyval.node),"code",(yyvsp[(7) - (7)].str));
+ Setattr((yyval.node),"code",(yyvsp[0].str));
}
+#line 5000 "y.tab.c" /* yacc.c:1646 */
break;
case 56:
-
-/* Line 1806 of yacc.c */
-#line 2155 "parser.y"
+#line 1858 "parser.y" /* yacc.c:1646 */
{
- Hash *p = (yyvsp[(5) - (7)].node);
+ Hash *p = (yyvsp[-2].node);
String *code;
skip_balanced('{','}');
(yyval.node) = new_node("fragment");
- Setattr((yyval.node),"value",Getattr((yyvsp[(3) - (7)].node),"value"));
- Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (7)].node),"type"));
+ Setattr((yyval.node),"value",Getattr((yyvsp[-4].node),"value"));
+ Setattr((yyval.node),"type",Getattr((yyvsp[-4].node),"type"));
Setattr((yyval.node),"section",Getattr(p,"name"));
Setattr((yyval.node),"kwargs",nextSibling(p));
Delitem(scanner_ccode,0);
Setattr((yyval.node),"code",code);
Delete(code);
}
+#line 5020 "y.tab.c" /* yacc.c:1646 */
break;
case 57:
-
-/* Line 1806 of yacc.c */
-#line 2170 "parser.y"
+#line 1873 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("fragment");
- Setattr((yyval.node),"value",Getattr((yyvsp[(3) - (5)].node),"value"));
- Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (5)].node),"type"));
+ Setattr((yyval.node),"value",Getattr((yyvsp[-2].node),"value"));
+ Setattr((yyval.node),"type",Getattr((yyvsp[-2].node),"type"));
Setattr((yyval.node),"emitonly","1");
}
+#line 5031 "y.tab.c" /* yacc.c:1646 */
break;
case 58:
-
-/* Line 1806 of yacc.c */
-#line 2183 "parser.y"
+#line 1886 "parser.y" /* yacc.c:1646 */
{
- (yyvsp[(1) - (4)].loc).filename = Copy(cparse_file);
- (yyvsp[(1) - (4)].loc).line = cparse_line;
- scanner_set_location(NewString((yyvsp[(3) - (4)].id)),1);
- if ((yyvsp[(2) - (4)].node)) {
- String *maininput = Getattr((yyvsp[(2) - (4)].node), "maininput");
+ (yyvsp[-3].loc).filename = Copy(cparse_file);
+ (yyvsp[-3].loc).line = cparse_line;
+ scanner_set_location((yyvsp[-1].str),1);
+ if ((yyvsp[-2].node)) {
+ String *maininput = Getattr((yyvsp[-2].node), "maininput");
if (maininput)
scanner_set_main_input_file(NewString(maininput));
}
}
+#line 5046 "y.tab.c" /* yacc.c:1646 */
break;
case 59:
-
-/* Line 1806 of yacc.c */
-#line 2192 "parser.y"
+#line 1895 "parser.y" /* yacc.c:1646 */
{
String *mname = 0;
- (yyval.node) = (yyvsp[(6) - (7)].node);
- scanner_set_location((yyvsp[(1) - (7)].loc).filename,(yyvsp[(1) - (7)].loc).line+1);
- if (strcmp((yyvsp[(1) - (7)].loc).type,"include") == 0) set_nodeType((yyval.node),"include");
- if (strcmp((yyvsp[(1) - (7)].loc).type,"import") == 0) {
- mname = (yyvsp[(2) - (7)].node) ? Getattr((yyvsp[(2) - (7)].node),"module") : 0;
+ (yyval.node) = (yyvsp[-1].node);
+ scanner_set_location((yyvsp[-6].loc).filename,(yyvsp[-6].loc).line+1);
+ if (strcmp((yyvsp[-6].loc).type,"include") == 0) set_nodeType((yyval.node),"include");
+ if (strcmp((yyvsp[-6].loc).type,"import") == 0) {
+ mname = (yyvsp[-5].node) ? Getattr((yyvsp[-5].node),"module") : 0;
set_nodeType((yyval.node),"import");
if (import_mode) --import_mode;
}
- Setattr((yyval.node),"name",(yyvsp[(3) - (7)].id));
+ Setattr((yyval.node),"name",(yyvsp[-4].str));
/* Search for the module (if any) */
{
Node *n = firstChild((yyval.node));
Node *nint = new_node("import");
Node *mnode = new_node("module");
Setattr(mnode,"name", mname);
+ Setattr(mnode,"options",(yyvsp[-5].node));
appendChild(nint,mnode);
Delete(mnode);
appendChild(nint,firstChild((yyval.node)));
Setattr((yyval.node),"module",mname);
}
}
- Setattr((yyval.node),"options",(yyvsp[(2) - (7)].node));
+ Setattr((yyval.node),"options",(yyvsp[-5].node));
}
+#line 5096 "y.tab.c" /* yacc.c:1646 */
break;
case 60:
-
-/* Line 1806 of yacc.c */
-#line 2238 "parser.y"
- { (yyval.loc).type = (char *) "include"; }
+#line 1942 "parser.y" /* yacc.c:1646 */
+ { (yyval.loc).type = "include"; }
+#line 5102 "y.tab.c" /* yacc.c:1646 */
break;
case 61:
-
-/* Line 1806 of yacc.c */
-#line 2239 "parser.y"
- { (yyval.loc).type = (char *) "import"; ++import_mode;}
+#line 1943 "parser.y" /* yacc.c:1646 */
+ { (yyval.loc).type = "import"; ++import_mode;}
+#line 5108 "y.tab.c" /* yacc.c:1646 */
break;
case 62:
-
-/* Line 1806 of yacc.c */
-#line 2246 "parser.y"
+#line 1950 "parser.y" /* yacc.c:1646 */
{
String *cpps;
if (Namespaceprefix) {
(yyval.node) = 0;
} else {
(yyval.node) = new_node("insert");
- Setattr((yyval.node),"code",(yyvsp[(2) - (2)].str));
+ Setattr((yyval.node),"code",(yyvsp[0].str));
/* Need to run through the preprocessor */
- Seek((yyvsp[(2) - (2)].str),0,SEEK_SET);
- Setline((yyvsp[(2) - (2)].str),cparse_start_line);
- Setfile((yyvsp[(2) - (2)].str),cparse_file);
- cpps = Preprocessor_parse((yyvsp[(2) - (2)].str));
+ Seek((yyvsp[0].str),0,SEEK_SET);
+ Setline((yyvsp[0].str),cparse_start_line);
+ Setfile((yyvsp[0].str),cparse_file);
+ cpps = Preprocessor_parse((yyvsp[0].str));
start_inline(Char(cpps), cparse_start_line);
- Delete((yyvsp[(2) - (2)].str));
+ Delete((yyvsp[0].str));
Delete(cpps);
}
}
+#line 5132 "y.tab.c" /* yacc.c:1646 */
break;
case 63:
-
-/* Line 1806 of yacc.c */
-#line 2265 "parser.y"
+#line 1969 "parser.y" /* yacc.c:1646 */
{
String *cpps;
int start_line = cparse_line;
Delete(cpps);
}
}
+#line 5158 "y.tab.c" /* yacc.c:1646 */
break;
case 64:
-
-/* Line 1806 of yacc.c */
-#line 2296 "parser.y"
+#line 2000 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("insert");
- Setattr((yyval.node),"code",(yyvsp[(1) - (1)].str));
+ Setattr((yyval.node),"code",(yyvsp[0].str));
}
+#line 5167 "y.tab.c" /* yacc.c:1646 */
break;
case 65:
-
-/* Line 1806 of yacc.c */
-#line 2300 "parser.y"
+#line 2004 "parser.y" /* yacc.c:1646 */
{
String *code = NewStringEmpty();
(yyval.node) = new_node("insert");
- Setattr((yyval.node),"section",(yyvsp[(3) - (5)].id));
+ Setattr((yyval.node),"section",(yyvsp[-2].id));
Setattr((yyval.node),"code",code);
- if (Swig_insert_file((yyvsp[(5) - (5)].id),code) < 0) {
- Swig_error(cparse_file, cparse_line, "Couldn't find '%s'.\n", (yyvsp[(5) - (5)].id));
+ if (Swig_insert_file((yyvsp[0].str),code) < 0) {
+ Swig_error(cparse_file, cparse_line, "Couldn't find '%s'.\n", (yyvsp[0].str));
(yyval.node) = 0;
}
}
+#line 5182 "y.tab.c" /* yacc.c:1646 */
break;
case 66:
-
-/* Line 1806 of yacc.c */
-#line 2310 "parser.y"
+#line 2014 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("insert");
- Setattr((yyval.node),"section",(yyvsp[(3) - (5)].id));
- Setattr((yyval.node),"code",(yyvsp[(5) - (5)].str));
+ Setattr((yyval.node),"section",(yyvsp[-2].id));
+ Setattr((yyval.node),"code",(yyvsp[0].str));
}
+#line 5192 "y.tab.c" /* yacc.c:1646 */
break;
case 67:
-
-/* Line 1806 of yacc.c */
-#line 2315 "parser.y"
+#line 2019 "parser.y" /* yacc.c:1646 */
{
String *code;
skip_balanced('{','}');
(yyval.node) = new_node("insert");
- Setattr((yyval.node),"section",(yyvsp[(3) - (5)].id));
+ Setattr((yyval.node),"section",(yyvsp[-2].id));
Delitem(scanner_ccode,0);
Delitem(scanner_ccode,DOH_END);
code = Copy(scanner_ccode);
Setattr((yyval.node),"code", code);
Delete(code);
}
+#line 5208 "y.tab.c" /* yacc.c:1646 */
break;
case 68:
-
-/* Line 1806 of yacc.c */
-#line 2333 "parser.y"
+#line 2037 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("module");
- if ((yyvsp[(2) - (3)].node)) {
- Setattr((yyval.node),"options",(yyvsp[(2) - (3)].node));
- if (Getattr((yyvsp[(2) - (3)].node),"directors")) {
+ if ((yyvsp[-1].node)) {
+ Setattr((yyval.node),"options",(yyvsp[-1].node));
+ if (Getattr((yyvsp[-1].node),"directors")) {
Wrapper_director_mode_set(1);
+ if (!cparse_cplusplus) {
+ Swig_error(cparse_file, cparse_line, "Directors are not supported for C code and require the -c++ option\n");
+ }
}
- if (Getattr((yyvsp[(2) - (3)].node),"dirprot")) {
+ if (Getattr((yyvsp[-1].node),"dirprot")) {
Wrapper_director_protected_mode_set(1);
}
- if (Getattr((yyvsp[(2) - (3)].node),"allprotected")) {
+ if (Getattr((yyvsp[-1].node),"allprotected")) {
Wrapper_all_protected_mode_set(1);
}
- if (Getattr((yyvsp[(2) - (3)].node),"templatereduce")) {
+ if (Getattr((yyvsp[-1].node),"templatereduce")) {
template_reduce = 1;
}
- if (Getattr((yyvsp[(2) - (3)].node),"notemplatereduce")) {
+ if (Getattr((yyvsp[-1].node),"notemplatereduce")) {
template_reduce = 0;
}
}
- if (!ModuleName) ModuleName = NewString((yyvsp[(3) - (3)].id));
+ if (!ModuleName) ModuleName = NewString((yyvsp[0].id));
if (!import_mode) {
/* first module included, we apply global
ModuleName, which can be modify by -module */
Delete(mname);
} else {
/* import mode, we just pass the idstring */
- Setattr((yyval.node),"name",(yyvsp[(3) - (3)].id));
+ Setattr((yyval.node),"name",(yyvsp[0].id));
}
if (!module_node) module_node = (yyval.node);
}
+#line 5249 "y.tab.c" /* yacc.c:1646 */
break;
case 69:
-
-/* Line 1806 of yacc.c */
-#line 2373 "parser.y"
+#line 2080 "parser.y" /* yacc.c:1646 */
{
Swig_warning(WARN_DEPRECATED_NAME,cparse_file,cparse_line, "%%name is deprecated. Use %%rename instead.\n");
Delete(yyrename);
- yyrename = NewString((yyvsp[(3) - (4)].id));
+ yyrename = NewString((yyvsp[-1].id));
(yyval.node) = 0;
}
+#line 5260 "y.tab.c" /* yacc.c:1646 */
break;
case 70:
-
-/* Line 1806 of yacc.c */
-#line 2379 "parser.y"
+#line 2086 "parser.y" /* yacc.c:1646 */
{
Swig_warning(WARN_DEPRECATED_NAME,cparse_file,cparse_line, "%%name is deprecated. Use %%rename instead.\n");
(yyval.node) = 0;
Swig_error(cparse_file,cparse_line,"Missing argument to %%name directive.\n");
}
+#line 5270 "y.tab.c" /* yacc.c:1646 */
break;
case 71:
-
-/* Line 1806 of yacc.c */
-#line 2392 "parser.y"
+#line 2099 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("native");
- Setattr((yyval.node),"name",(yyvsp[(3) - (7)].id));
- Setattr((yyval.node),"wrap:name",(yyvsp[(6) - (7)].id));
+ Setattr((yyval.node),"name",(yyvsp[-4].id));
+ Setattr((yyval.node),"wrap:name",(yyvsp[-1].id));
add_symbols((yyval.node));
}
+#line 5281 "y.tab.c" /* yacc.c:1646 */
break;
case 72:
-
-/* Line 1806 of yacc.c */
-#line 2398 "parser.y"
+#line 2105 "parser.y" /* yacc.c:1646 */
{
- if (!SwigType_isfunction((yyvsp[(7) - (8)].decl).type)) {
- Swig_error(cparse_file,cparse_line,"%%native declaration '%s' is not a function.\n", (yyvsp[(7) - (8)].decl).id);
+ if (!SwigType_isfunction((yyvsp[-1].decl).type)) {
+ Swig_error(cparse_file,cparse_line,"%%native declaration '%s' is not a function.\n", (yyvsp[-1].decl).id);
(yyval.node) = 0;
} else {
- Delete(SwigType_pop_function((yyvsp[(7) - (8)].decl).type));
+ Delete(SwigType_pop_function((yyvsp[-1].decl).type));
/* Need check for function here */
- SwigType_push((yyvsp[(6) - (8)].type),(yyvsp[(7) - (8)].decl).type);
+ SwigType_push((yyvsp[-2].type),(yyvsp[-1].decl).type);
(yyval.node) = new_node("native");
- Setattr((yyval.node),"name",(yyvsp[(3) - (8)].id));
- Setattr((yyval.node),"wrap:name",(yyvsp[(7) - (8)].decl).id);
- Setattr((yyval.node),"type",(yyvsp[(6) - (8)].type));
- Setattr((yyval.node),"parms",(yyvsp[(7) - (8)].decl).parms);
- Setattr((yyval.node),"decl",(yyvsp[(7) - (8)].decl).type);
+ Setattr((yyval.node),"name",(yyvsp[-5].id));
+ Setattr((yyval.node),"wrap:name",(yyvsp[-1].decl).id);
+ Setattr((yyval.node),"type",(yyvsp[-2].type));
+ Setattr((yyval.node),"parms",(yyvsp[-1].decl).parms);
+ Setattr((yyval.node),"decl",(yyvsp[-1].decl).type);
}
add_symbols((yyval.node));
}
+#line 5303 "y.tab.c" /* yacc.c:1646 */
break;
case 73:
-
-/* Line 1806 of yacc.c */
-#line 2424 "parser.y"
+#line 2131 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("pragma");
- Setattr((yyval.node),"lang",(yyvsp[(2) - (5)].id));
- Setattr((yyval.node),"name",(yyvsp[(3) - (5)].id));
- Setattr((yyval.node),"value",(yyvsp[(5) - (5)].str));
+ Setattr((yyval.node),"lang",(yyvsp[-3].id));
+ Setattr((yyval.node),"name",(yyvsp[-2].id));
+ Setattr((yyval.node),"value",(yyvsp[0].str));
}
+#line 5314 "y.tab.c" /* yacc.c:1646 */
break;
case 74:
-
-/* Line 1806 of yacc.c */
-#line 2430 "parser.y"
+#line 2137 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("pragma");
- Setattr((yyval.node),"lang",(yyvsp[(2) - (3)].id));
- Setattr((yyval.node),"name",(yyvsp[(3) - (3)].id));
+ Setattr((yyval.node),"lang",(yyvsp[-1].id));
+ Setattr((yyval.node),"name",(yyvsp[0].id));
}
+#line 5324 "y.tab.c" /* yacc.c:1646 */
break;
case 75:
-
-/* Line 1806 of yacc.c */
-#line 2437 "parser.y"
- { (yyval.str) = NewString((yyvsp[(1) - (1)].id)); }
+#line 2144 "parser.y" /* yacc.c:1646 */
+ { (yyval.str) = (yyvsp[0].str); }
+#line 5330 "y.tab.c" /* yacc.c:1646 */
break;
case 76:
-
-/* Line 1806 of yacc.c */
-#line 2438 "parser.y"
- { (yyval.str) = (yyvsp[(1) - (1)].str); }
+#line 2145 "parser.y" /* yacc.c:1646 */
+ { (yyval.str) = (yyvsp[0].str); }
+#line 5336 "y.tab.c" /* yacc.c:1646 */
break;
case 77:
-
-/* Line 1806 of yacc.c */
-#line 2441 "parser.y"
- { (yyval.id) = (yyvsp[(2) - (3)].id); }
+#line 2148 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = (yyvsp[-1].id); }
+#line 5342 "y.tab.c" /* yacc.c:1646 */
break;
case 78:
-
-/* Line 1806 of yacc.c */
-#line 2442 "parser.y"
+#line 2149 "parser.y" /* yacc.c:1646 */
{ (yyval.id) = (char *) "swig"; }
+#line 5348 "y.tab.c" /* yacc.c:1646 */
break;
case 79:
-
-/* Line 1806 of yacc.c */
-#line 2450 "parser.y"
+#line 2156 "parser.y" /* yacc.c:1646 */
{
- SwigType *t = (yyvsp[(2) - (4)].decl).type;
+ SwigType *t = (yyvsp[-2].decl).type;
Hash *kws = NewHash();
String *fixname;
- fixname = feature_identifier_fix((yyvsp[(2) - (4)].decl).id);
- Setattr(kws,"name",(yyvsp[(3) - (4)].id));
+ fixname = feature_identifier_fix((yyvsp[-2].decl).id);
+ Setattr(kws,"name",(yyvsp[-1].id));
if (!Len(t)) t = 0;
/* Special declarator check */
if (t) {
SwigType *decl = SwigType_pop_function(t);
if (SwigType_ispointer(t)) {
String *nname = NewStringf("*%s",fixname);
- if ((yyvsp[(1) - (4)].intvalue)) {
- Swig_name_rename_add(Namespaceprefix, nname,decl,kws,(yyvsp[(2) - (4)].decl).parms);
+ if ((yyvsp[-3].intvalue)) {
+ Swig_name_rename_add(Namespaceprefix, nname,decl,kws,(yyvsp[-2].decl).parms);
} else {
Swig_name_namewarn_add(Namespaceprefix,nname,decl,kws);
}
Delete(nname);
} else {
- if ((yyvsp[(1) - (4)].intvalue)) {
- Swig_name_rename_add(Namespaceprefix,(fixname),decl,kws,(yyvsp[(2) - (4)].decl).parms);
+ if ((yyvsp[-3].intvalue)) {
+ Swig_name_rename_add(Namespaceprefix,(fixname),decl,kws,(yyvsp[-2].decl).parms);
} else {
Swig_name_namewarn_add(Namespaceprefix,(fixname),decl,kws);
}
Delete(decl);
} else if (SwigType_ispointer(t)) {
String *nname = NewStringf("*%s",fixname);
- if ((yyvsp[(1) - (4)].intvalue)) {
- Swig_name_rename_add(Namespaceprefix,(nname),0,kws,(yyvsp[(2) - (4)].decl).parms);
+ if ((yyvsp[-3].intvalue)) {
+ Swig_name_rename_add(Namespaceprefix,(nname),0,kws,(yyvsp[-2].decl).parms);
} else {
Swig_name_namewarn_add(Namespaceprefix,(nname),0,kws);
}
Delete(nname);
}
} else {
- if ((yyvsp[(1) - (4)].intvalue)) {
- Swig_name_rename_add(Namespaceprefix,(fixname),0,kws,(yyvsp[(2) - (4)].decl).parms);
+ if ((yyvsp[-3].intvalue)) {
+ Swig_name_rename_add(Namespaceprefix,(fixname),0,kws,(yyvsp[-2].decl).parms);
} else {
Swig_name_namewarn_add(Namespaceprefix,(fixname),0,kws);
}
(yyval.node) = 0;
scanner_clear_rename();
}
+#line 5399 "y.tab.c" /* yacc.c:1646 */
break;
case 80:
-
-/* Line 1806 of yacc.c */
-#line 2496 "parser.y"
+#line 2202 "parser.y" /* yacc.c:1646 */
{
String *fixname;
- Hash *kws = (yyvsp[(3) - (7)].node);
- SwigType *t = (yyvsp[(5) - (7)].decl).type;
- fixname = feature_identifier_fix((yyvsp[(5) - (7)].decl).id);
+ Hash *kws = (yyvsp[-4].node);
+ SwigType *t = (yyvsp[-2].decl).type;
+ fixname = feature_identifier_fix((yyvsp[-2].decl).id);
if (!Len(t)) t = 0;
/* Special declarator check */
if (t) {
- if ((yyvsp[(6) - (7)].dtype).qualifier) SwigType_push(t,(yyvsp[(6) - (7)].dtype).qualifier);
+ if ((yyvsp[-1].dtype).qualifier) SwigType_push(t,(yyvsp[-1].dtype).qualifier);
if (SwigType_isfunction(t)) {
SwigType *decl = SwigType_pop_function(t);
if (SwigType_ispointer(t)) {
String *nname = NewStringf("*%s",fixname);
- if ((yyvsp[(1) - (7)].intvalue)) {
- Swig_name_rename_add(Namespaceprefix, nname,decl,kws,(yyvsp[(5) - (7)].decl).parms);
+ if ((yyvsp[-6].intvalue)) {
+ Swig_name_rename_add(Namespaceprefix, nname,decl,kws,(yyvsp[-2].decl).parms);
} else {
Swig_name_namewarn_add(Namespaceprefix,nname,decl,kws);
}
Delete(nname);
} else {
- if ((yyvsp[(1) - (7)].intvalue)) {
- Swig_name_rename_add(Namespaceprefix,(fixname),decl,kws,(yyvsp[(5) - (7)].decl).parms);
+ if ((yyvsp[-6].intvalue)) {
+ Swig_name_rename_add(Namespaceprefix,(fixname),decl,kws,(yyvsp[-2].decl).parms);
} else {
Swig_name_namewarn_add(Namespaceprefix,(fixname),decl,kws);
}
Delete(decl);
} else if (SwigType_ispointer(t)) {
String *nname = NewStringf("*%s",fixname);
- if ((yyvsp[(1) - (7)].intvalue)) {
- Swig_name_rename_add(Namespaceprefix,(nname),0,kws,(yyvsp[(5) - (7)].decl).parms);
+ if ((yyvsp[-6].intvalue)) {
+ Swig_name_rename_add(Namespaceprefix,(nname),0,kws,(yyvsp[-2].decl).parms);
} else {
Swig_name_namewarn_add(Namespaceprefix,(nname),0,kws);
}
Delete(nname);
}
} else {
- if ((yyvsp[(1) - (7)].intvalue)) {
- Swig_name_rename_add(Namespaceprefix,(fixname),0,kws,(yyvsp[(5) - (7)].decl).parms);
+ if ((yyvsp[-6].intvalue)) {
+ Swig_name_rename_add(Namespaceprefix,(fixname),0,kws,(yyvsp[-2].decl).parms);
} else {
Swig_name_namewarn_add(Namespaceprefix,(fixname),0,kws);
}
(yyval.node) = 0;
scanner_clear_rename();
}
+#line 5450 "y.tab.c" /* yacc.c:1646 */
break;
case 81:
-
-/* Line 1806 of yacc.c */
-#line 2542 "parser.y"
+#line 2248 "parser.y" /* yacc.c:1646 */
{
- if ((yyvsp[(1) - (6)].intvalue)) {
- Swig_name_rename_add(Namespaceprefix,(yyvsp[(5) - (6)].id),0,(yyvsp[(3) - (6)].node),0);
+ if ((yyvsp[-5].intvalue)) {
+ Swig_name_rename_add(Namespaceprefix,(yyvsp[-1].str),0,(yyvsp[-3].node),0);
} else {
- Swig_name_namewarn_add(Namespaceprefix,(yyvsp[(5) - (6)].id),0,(yyvsp[(3) - (6)].node));
+ Swig_name_namewarn_add(Namespaceprefix,(yyvsp[-1].str),0,(yyvsp[-3].node));
}
(yyval.node) = 0;
scanner_clear_rename();
}
+#line 5464 "y.tab.c" /* yacc.c:1646 */
break;
case 82:
-
-/* Line 1806 of yacc.c */
-#line 2553 "parser.y"
+#line 2259 "parser.y" /* yacc.c:1646 */
{
(yyval.intvalue) = 1;
}
+#line 5472 "y.tab.c" /* yacc.c:1646 */
break;
case 83:
-
-/* Line 1806 of yacc.c */
-#line 2556 "parser.y"
+#line 2262 "parser.y" /* yacc.c:1646 */
{
(yyval.intvalue) = 0;
}
+#line 5480 "y.tab.c" /* yacc.c:1646 */
break;
case 84:
-
-/* Line 1806 of yacc.c */
-#line 2583 "parser.y"
+#line 2289 "parser.y" /* yacc.c:1646 */
{
- String *val = (yyvsp[(7) - (7)].str) ? NewString((yyvsp[(7) - (7)].str)) : NewString("1");
- new_feature((yyvsp[(3) - (7)].id), val, 0, (yyvsp[(5) - (7)].decl).id, (yyvsp[(5) - (7)].decl).type, (yyvsp[(5) - (7)].decl).parms, (yyvsp[(6) - (7)].dtype).qualifier);
+ String *val = (yyvsp[0].str) ? NewString((yyvsp[0].str)) : NewString("1");
+ new_feature((yyvsp[-4].id), val, 0, (yyvsp[-2].decl).id, (yyvsp[-2].decl).type, (yyvsp[-2].decl).parms, (yyvsp[-1].dtype).qualifier);
(yyval.node) = 0;
scanner_clear_rename();
}
+#line 5491 "y.tab.c" /* yacc.c:1646 */
break;
case 85:
-
-/* Line 1806 of yacc.c */
-#line 2589 "parser.y"
+#line 2295 "parser.y" /* yacc.c:1646 */
{
- String *val = Len((yyvsp[(5) - (9)].id)) ? NewString((yyvsp[(5) - (9)].id)) : 0;
- new_feature((yyvsp[(3) - (9)].id), val, 0, (yyvsp[(7) - (9)].decl).id, (yyvsp[(7) - (9)].decl).type, (yyvsp[(7) - (9)].decl).parms, (yyvsp[(8) - (9)].dtype).qualifier);
+ String *val = Len((yyvsp[-4].str)) ? (yyvsp[-4].str) : 0;
+ new_feature((yyvsp[-6].id), val, 0, (yyvsp[-2].decl).id, (yyvsp[-2].decl).type, (yyvsp[-2].decl).parms, (yyvsp[-1].dtype).qualifier);
(yyval.node) = 0;
scanner_clear_rename();
}
+#line 5502 "y.tab.c" /* yacc.c:1646 */
break;
case 86:
-
-/* Line 1806 of yacc.c */
-#line 2595 "parser.y"
+#line 2301 "parser.y" /* yacc.c:1646 */
{
- String *val = (yyvsp[(8) - (8)].str) ? NewString((yyvsp[(8) - (8)].str)) : NewString("1");
- new_feature((yyvsp[(3) - (8)].id), val, (yyvsp[(4) - (8)].node), (yyvsp[(6) - (8)].decl).id, (yyvsp[(6) - (8)].decl).type, (yyvsp[(6) - (8)].decl).parms, (yyvsp[(7) - (8)].dtype).qualifier);
+ String *val = (yyvsp[0].str) ? NewString((yyvsp[0].str)) : NewString("1");
+ new_feature((yyvsp[-5].id), val, (yyvsp[-4].node), (yyvsp[-2].decl).id, (yyvsp[-2].decl).type, (yyvsp[-2].decl).parms, (yyvsp[-1].dtype).qualifier);
(yyval.node) = 0;
scanner_clear_rename();
}
+#line 5513 "y.tab.c" /* yacc.c:1646 */
break;
case 87:
-
-/* Line 1806 of yacc.c */
-#line 2601 "parser.y"
+#line 2307 "parser.y" /* yacc.c:1646 */
{
- String *val = Len((yyvsp[(5) - (10)].id)) ? NewString((yyvsp[(5) - (10)].id)) : 0;
- new_feature((yyvsp[(3) - (10)].id), val, (yyvsp[(6) - (10)].node), (yyvsp[(8) - (10)].decl).id, (yyvsp[(8) - (10)].decl).type, (yyvsp[(8) - (10)].decl).parms, (yyvsp[(9) - (10)].dtype).qualifier);
+ String *val = Len((yyvsp[-5].str)) ? (yyvsp[-5].str) : 0;
+ new_feature((yyvsp[-7].id), val, (yyvsp[-4].node), (yyvsp[-2].decl).id, (yyvsp[-2].decl).type, (yyvsp[-2].decl).parms, (yyvsp[-1].dtype).qualifier);
(yyval.node) = 0;
scanner_clear_rename();
}
+#line 5524 "y.tab.c" /* yacc.c:1646 */
break;
case 88:
-
-/* Line 1806 of yacc.c */
-#line 2609 "parser.y"
+#line 2315 "parser.y" /* yacc.c:1646 */
{
- String *val = (yyvsp[(5) - (5)].str) ? NewString((yyvsp[(5) - (5)].str)) : NewString("1");
- new_feature((yyvsp[(3) - (5)].id), val, 0, 0, 0, 0, 0);
+ String *val = (yyvsp[0].str) ? NewString((yyvsp[0].str)) : NewString("1");
+ new_feature((yyvsp[-2].id), val, 0, 0, 0, 0, 0);
(yyval.node) = 0;
scanner_clear_rename();
}
+#line 5535 "y.tab.c" /* yacc.c:1646 */
break;
case 89:
-
-/* Line 1806 of yacc.c */
-#line 2615 "parser.y"
+#line 2321 "parser.y" /* yacc.c:1646 */
{
- String *val = Len((yyvsp[(5) - (7)].id)) ? NewString((yyvsp[(5) - (7)].id)) : 0;
- new_feature((yyvsp[(3) - (7)].id), val, 0, 0, 0, 0, 0);
+ String *val = Len((yyvsp[-2].str)) ? (yyvsp[-2].str) : 0;
+ new_feature((yyvsp[-4].id), val, 0, 0, 0, 0, 0);
(yyval.node) = 0;
scanner_clear_rename();
}
+#line 5546 "y.tab.c" /* yacc.c:1646 */
break;
case 90:
-
-/* Line 1806 of yacc.c */
-#line 2621 "parser.y"
+#line 2327 "parser.y" /* yacc.c:1646 */
{
- String *val = (yyvsp[(6) - (6)].str) ? NewString((yyvsp[(6) - (6)].str)) : NewString("1");
- new_feature((yyvsp[(3) - (6)].id), val, (yyvsp[(4) - (6)].node), 0, 0, 0, 0);
+ String *val = (yyvsp[0].str) ? NewString((yyvsp[0].str)) : NewString("1");
+ new_feature((yyvsp[-3].id), val, (yyvsp[-2].node), 0, 0, 0, 0);
(yyval.node) = 0;
scanner_clear_rename();
}
+#line 5557 "y.tab.c" /* yacc.c:1646 */
break;
case 91:
-
-/* Line 1806 of yacc.c */
-#line 2627 "parser.y"
+#line 2333 "parser.y" /* yacc.c:1646 */
{
- String *val = Len((yyvsp[(5) - (8)].id)) ? NewString((yyvsp[(5) - (8)].id)) : 0;
- new_feature((yyvsp[(3) - (8)].id), val, (yyvsp[(6) - (8)].node), 0, 0, 0, 0);
+ String *val = Len((yyvsp[-3].str)) ? (yyvsp[-3].str) : 0;
+ new_feature((yyvsp[-5].id), val, (yyvsp[-2].node), 0, 0, 0, 0);
(yyval.node) = 0;
scanner_clear_rename();
}
+#line 5568 "y.tab.c" /* yacc.c:1646 */
break;
case 92:
-
-/* Line 1806 of yacc.c */
-#line 2635 "parser.y"
- { (yyval.str) = (yyvsp[(1) - (1)].str); }
+#line 2341 "parser.y" /* yacc.c:1646 */
+ { (yyval.str) = (yyvsp[0].str); }
+#line 5574 "y.tab.c" /* yacc.c:1646 */
break;
case 93:
-
-/* Line 1806 of yacc.c */
-#line 2636 "parser.y"
+#line 2342 "parser.y" /* yacc.c:1646 */
{ (yyval.str) = 0; }
+#line 5580 "y.tab.c" /* yacc.c:1646 */
break;
case 94:
-
-/* Line 1806 of yacc.c */
-#line 2637 "parser.y"
- { (yyval.str) = (yyvsp[(3) - (5)].pl); }
+#line 2343 "parser.y" /* yacc.c:1646 */
+ { (yyval.str) = (yyvsp[-2].pl); }
+#line 5586 "y.tab.c" /* yacc.c:1646 */
break;
case 95:
-
-/* Line 1806 of yacc.c */
-#line 2640 "parser.y"
+#line 2346 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = NewHash();
- Setattr((yyval.node),"name",(yyvsp[(2) - (4)].id));
- Setattr((yyval.node),"value",(yyvsp[(4) - (4)].id));
+ Setattr((yyval.node),"name",(yyvsp[-2].id));
+ Setattr((yyval.node),"value",(yyvsp[0].str));
}
+#line 5596 "y.tab.c" /* yacc.c:1646 */
break;
case 96:
-
-/* Line 1806 of yacc.c */
-#line 2645 "parser.y"
+#line 2351 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = NewHash();
- Setattr((yyval.node),"name",(yyvsp[(2) - (5)].id));
- Setattr((yyval.node),"value",(yyvsp[(4) - (5)].id));
- set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node));
+ Setattr((yyval.node),"name",(yyvsp[-3].id));
+ Setattr((yyval.node),"value",(yyvsp[-1].str));
+ set_nextSibling((yyval.node),(yyvsp[0].node));
}
+#line 5607 "y.tab.c" /* yacc.c:1646 */
break;
case 97:
-
-/* Line 1806 of yacc.c */
-#line 2655 "parser.y"
+#line 2361 "parser.y" /* yacc.c:1646 */
{
Parm *val;
String *name;
SwigType *t;
- if (Namespaceprefix) name = NewStringf("%s::%s", Namespaceprefix, (yyvsp[(5) - (7)].decl).id);
- else name = NewString((yyvsp[(5) - (7)].decl).id);
- val = (yyvsp[(3) - (7)].pl);
- if ((yyvsp[(5) - (7)].decl).parms) {
- Setmeta(val,"parms",(yyvsp[(5) - (7)].decl).parms);
+ if (Namespaceprefix) name = NewStringf("%s::%s", Namespaceprefix, (yyvsp[-2].decl).id);
+ else name = NewString((yyvsp[-2].decl).id);
+ val = (yyvsp[-4].pl);
+ if ((yyvsp[-2].decl).parms) {
+ Setmeta(val,"parms",(yyvsp[-2].decl).parms);
}
- t = (yyvsp[(5) - (7)].decl).type;
+ t = (yyvsp[-2].decl).type;
if (!Len(t)) t = 0;
if (t) {
- if ((yyvsp[(6) - (7)].dtype).qualifier) SwigType_push(t,(yyvsp[(6) - (7)].dtype).qualifier);
+ if ((yyvsp[-1].dtype).qualifier) SwigType_push(t,(yyvsp[-1].dtype).qualifier);
if (SwigType_isfunction(t)) {
SwigType *decl = SwigType_pop_function(t);
if (SwigType_ispointer(t)) {
Delete(name);
(yyval.node) = 0;
}
+#line 5647 "y.tab.c" /* yacc.c:1646 */
break;
case 98:
-
-/* Line 1806 of yacc.c */
-#line 2691 "parser.y"
- { (yyval.pl) = (yyvsp[(1) - (1)].pl); }
+#line 2397 "parser.y" /* yacc.c:1646 */
+ { (yyval.pl) = (yyvsp[0].pl); }
+#line 5653 "y.tab.c" /* yacc.c:1646 */
break;
case 99:
-
-/* Line 1806 of yacc.c */
-#line 2692 "parser.y"
+#line 2398 "parser.y" /* yacc.c:1646 */
{
int i;
int n;
Parm *p;
- n = atoi(Char((yyvsp[(1) - (3)].dtype).val));
+ n = atoi(Char((yyvsp[-2].dtype).val));
if (n <= 0) {
Swig_error(cparse_file, cparse_line,"Argument count in %%varargs must be positive.\n");
(yyval.pl) = 0;
} else {
- String *name = Getattr((yyvsp[(3) - (3)].p), "name");
- (yyval.pl) = Copy((yyvsp[(3) - (3)].p));
+ String *name = Getattr((yyvsp[0].p), "name");
+ (yyval.pl) = Copy((yyvsp[0].p));
if (name)
Setattr((yyval.pl), "name", NewStringf("%s%d", name, n));
for (i = 1; i < n; i++) {
- p = Copy((yyvsp[(3) - (3)].p));
+ p = Copy((yyvsp[0].p));
name = Getattr(p, "name");
if (name)
Setattr(p, "name", NewStringf("%s%d", name, n-i));
}
}
}
+#line 5682 "y.tab.c" /* yacc.c:1646 */
break;
case 100:
-
-/* Line 1806 of yacc.c */
-#line 2727 "parser.y"
+#line 2433 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = 0;
- if ((yyvsp[(3) - (6)].tmap).method) {
+ if ((yyvsp[-3].tmap).method) {
String *code = 0;
(yyval.node) = new_node("typemap");
- Setattr((yyval.node),"method",(yyvsp[(3) - (6)].tmap).method);
- if ((yyvsp[(3) - (6)].tmap).kwargs) {
- ParmList *kw = (yyvsp[(3) - (6)].tmap).kwargs;
- code = remove_block(kw, (yyvsp[(6) - (6)].str));
- Setattr((yyval.node),"kwargs", (yyvsp[(3) - (6)].tmap).kwargs);
+ Setattr((yyval.node),"method",(yyvsp[-3].tmap).method);
+ if ((yyvsp[-3].tmap).kwargs) {
+ ParmList *kw = (yyvsp[-3].tmap).kwargs;
+ code = remove_block(kw, (yyvsp[0].str));
+ Setattr((yyval.node),"kwargs", (yyvsp[-3].tmap).kwargs);
}
- code = code ? code : NewString((yyvsp[(6) - (6)].str));
+ code = code ? code : NewString((yyvsp[0].str));
Setattr((yyval.node),"code", code);
Delete(code);
- appendChild((yyval.node),(yyvsp[(5) - (6)].p));
+ appendChild((yyval.node),(yyvsp[-1].p));
}
}
+#line 5704 "y.tab.c" /* yacc.c:1646 */
break;
case 101:
-
-/* Line 1806 of yacc.c */
-#line 2744 "parser.y"
+#line 2450 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = 0;
- if ((yyvsp[(3) - (6)].tmap).method) {
+ if ((yyvsp[-3].tmap).method) {
(yyval.node) = new_node("typemap");
- Setattr((yyval.node),"method",(yyvsp[(3) - (6)].tmap).method);
- appendChild((yyval.node),(yyvsp[(5) - (6)].p));
+ Setattr((yyval.node),"method",(yyvsp[-3].tmap).method);
+ appendChild((yyval.node),(yyvsp[-1].p));
}
}
+#line 5717 "y.tab.c" /* yacc.c:1646 */
break;
case 102:
-
-/* Line 1806 of yacc.c */
-#line 2752 "parser.y"
+#line 2458 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = 0;
- if ((yyvsp[(3) - (8)].tmap).method) {
+ if ((yyvsp[-5].tmap).method) {
(yyval.node) = new_node("typemapcopy");
- Setattr((yyval.node),"method",(yyvsp[(3) - (8)].tmap).method);
- Setattr((yyval.node),"pattern", Getattr((yyvsp[(7) - (8)].p),"pattern"));
- appendChild((yyval.node),(yyvsp[(5) - (8)].p));
+ Setattr((yyval.node),"method",(yyvsp[-5].tmap).method);
+ Setattr((yyval.node),"pattern", Getattr((yyvsp[-1].p),"pattern"));
+ appendChild((yyval.node),(yyvsp[-3].p));
}
}
+#line 5731 "y.tab.c" /* yacc.c:1646 */
break;
case 103:
-
-/* Line 1806 of yacc.c */
-#line 2765 "parser.y"
+#line 2471 "parser.y" /* yacc.c:1646 */
{
Hash *p;
String *name;
- p = nextSibling((yyvsp[(1) - (1)].node));
+ p = nextSibling((yyvsp[0].node));
if (p && (!Getattr(p,"value"))) {
/* this is the deprecated two argument typemap form */
Swig_warning(WARN_DEPRECATED_TYPEMAP_LANG,cparse_file, cparse_line,
"Specifying the language name in %%typemap is deprecated - use #ifdef SWIG<LANG> instead.\n");
/* two argument typemap form */
- name = Getattr((yyvsp[(1) - (1)].node),"name");
+ name = Getattr((yyvsp[0].node),"name");
if (!name || (Strcmp(name,typemap_lang))) {
(yyval.tmap).method = 0;
(yyval.tmap).kwargs = 0;
}
} else {
/* one-argument typemap-form */
- (yyval.tmap).method = Getattr((yyvsp[(1) - (1)].node),"name");
+ (yyval.tmap).method = Getattr((yyvsp[0].node),"name");
(yyval.tmap).kwargs = p;
}
}
+#line 5759 "y.tab.c" /* yacc.c:1646 */
break;
case 104:
-
-/* Line 1806 of yacc.c */
-#line 2790 "parser.y"
+#line 2496 "parser.y" /* yacc.c:1646 */
{
- (yyval.p) = (yyvsp[(1) - (2)].p);
- set_nextSibling((yyval.p),(yyvsp[(2) - (2)].p));
+ (yyval.p) = (yyvsp[-1].p);
+ set_nextSibling((yyval.p),(yyvsp[0].p));
}
+#line 5768 "y.tab.c" /* yacc.c:1646 */
break;
case 105:
-
-/* Line 1806 of yacc.c */
-#line 2796 "parser.y"
+#line 2502 "parser.y" /* yacc.c:1646 */
{
- (yyval.p) = (yyvsp[(2) - (3)].p);
- set_nextSibling((yyval.p),(yyvsp[(3) - (3)].p));
+ (yyval.p) = (yyvsp[-1].p);
+ set_nextSibling((yyval.p),(yyvsp[0].p));
}
+#line 5777 "y.tab.c" /* yacc.c:1646 */
break;
case 106:
-
-/* Line 1806 of yacc.c */
-#line 2800 "parser.y"
+#line 2506 "parser.y" /* yacc.c:1646 */
{ (yyval.p) = 0;}
+#line 5783 "y.tab.c" /* yacc.c:1646 */
break;
case 107:
-
-/* Line 1806 of yacc.c */
-#line 2803 "parser.y"
+#line 2509 "parser.y" /* yacc.c:1646 */
{
Parm *parm;
- SwigType_push((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).type);
+ SwigType_push((yyvsp[-1].type),(yyvsp[0].decl).type);
(yyval.p) = new_node("typemapitem");
- parm = NewParmWithoutFileLineInfo((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).id);
+ parm = NewParmWithoutFileLineInfo((yyvsp[-1].type),(yyvsp[0].decl).id);
Setattr((yyval.p),"pattern",parm);
- Setattr((yyval.p),"parms", (yyvsp[(2) - (2)].decl).parms);
+ Setattr((yyval.p),"parms", (yyvsp[0].decl).parms);
Delete(parm);
/* $$ = NewParmWithoutFileLineInfo($1,$2.id);
Setattr($$,"parms",$2.parms); */
}
+#line 5799 "y.tab.c" /* yacc.c:1646 */
break;
case 108:
-
-/* Line 1806 of yacc.c */
-#line 2814 "parser.y"
+#line 2520 "parser.y" /* yacc.c:1646 */
{
(yyval.p) = new_node("typemapitem");
- Setattr((yyval.p),"pattern",(yyvsp[(2) - (3)].pl));
+ Setattr((yyval.p),"pattern",(yyvsp[-1].pl));
/* Setattr($$,"multitype",$2); */
}
+#line 5809 "y.tab.c" /* yacc.c:1646 */
break;
case 109:
-
-/* Line 1806 of yacc.c */
-#line 2819 "parser.y"
+#line 2525 "parser.y" /* yacc.c:1646 */
{
(yyval.p) = new_node("typemapitem");
- Setattr((yyval.p),"pattern", (yyvsp[(2) - (6)].pl));
+ Setattr((yyval.p),"pattern", (yyvsp[-4].pl));
/* Setattr($$,"multitype",$2); */
- Setattr((yyval.p),"parms",(yyvsp[(5) - (6)].pl));
+ Setattr((yyval.p),"parms",(yyvsp[-1].pl));
}
+#line 5820 "y.tab.c" /* yacc.c:1646 */
break;
case 110:
-
-/* Line 1806 of yacc.c */
-#line 2832 "parser.y"
+#line 2538 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("types");
- Setattr((yyval.node),"parms",(yyvsp[(3) - (5)].pl));
- if ((yyvsp[(5) - (5)].str))
- Setattr((yyval.node),"convcode",NewString((yyvsp[(5) - (5)].str)));
+ Setattr((yyval.node),"parms",(yyvsp[-2].pl));
+ if ((yyvsp[0].str))
+ Setattr((yyval.node),"convcode",NewString((yyvsp[0].str)));
}
+#line 5831 "y.tab.c" /* yacc.c:1646 */
break;
case 111:
-
-/* Line 1806 of yacc.c */
-#line 2844 "parser.y"
+#line 2550 "parser.y" /* yacc.c:1646 */
{
Parm *p, *tp;
Node *n;
+ Node *outer_class = currentOuterClass;
Symtab *tscope = 0;
int specialized = 0;
+ int variadic = 0;
(yyval.node) = 0;
/* If the class name is qualified, we need to create or lookup namespace entries */
if (!inclass) {
- (yyvsp[(5) - (9)].str) = resolve_create_node_scope((yyvsp[(5) - (9)].str));
+ (yyvsp[-4].str) = resolve_create_node_scope((yyvsp[-4].str));
+ }
+ if (nscope_inner && Strcmp(nodeType(nscope_inner), "class") == 0) {
+ outer_class = nscope_inner;
}
/*
This is closer to the C++ (typedef) behavior.
*/
- n = Swig_cparse_template_locate((yyvsp[(5) - (9)].str),(yyvsp[(7) - (9)].p),tscope);
+ n = Swig_cparse_template_locate((yyvsp[-4].str),(yyvsp[-2].p),tscope);
/* Patch the argument types to respect namespaces */
- p = (yyvsp[(7) - (9)].p);
+ p = (yyvsp[-2].p);
while (p) {
SwigType *value = Getattr(p,"value");
if (!value) {
{
Node *nn = n;
Node *linklistend = 0;
+ Node *linkliststart = 0;
while (nn) {
Node *templnode = 0;
if (Strcmp(nodeType(nn),"template") == 0) {
Parm *tparms = Getattr(nn,"templateparms");
if (!tparms) {
specialized = 1;
+ } else if (Getattr(tparms,"variadic") && strncmp(Char(Getattr(tparms,"variadic")), "1", 1)==0) {
+ variadic = 1;
}
- if (nnisclass && !specialized && ((ParmList_len((yyvsp[(7) - (9)].p)) > ParmList_len(tparms)))) {
+ if (nnisclass && !variadic && !specialized && (ParmList_len((yyvsp[-2].p)) > ParmList_len(tparms))) {
Swig_error(cparse_file, cparse_line, "Too many template parameters. Maximum of %d.\n", ParmList_len(tparms));
- } else if (nnisclass && !specialized && ((ParmList_len((yyvsp[(7) - (9)].p)) < ParmList_numrequired(tparms)))) {
- Swig_error(cparse_file, cparse_line, "Not enough template parameters specified. %d required.\n", ParmList_numrequired(tparms));
- } else if (!nnisclass && ((ParmList_len((yyvsp[(7) - (9)].p)) != ParmList_len(tparms)))) {
+ } else if (nnisclass && !specialized && ((ParmList_len((yyvsp[-2].p)) < (ParmList_numrequired(tparms) - (variadic?1:0))))) { /* Variadic parameter is optional */
+ Swig_error(cparse_file, cparse_line, "Not enough template parameters specified. %d required.\n", (ParmList_numrequired(tparms)-(variadic?1:0)) );
+ } else if (!nnisclass && ((ParmList_len((yyvsp[-2].p)) != ParmList_len(tparms)))) {
/* must be an overloaded templated method - ignore it as it is overloaded with a different number of template parameters */
nn = Getattr(nn,"sym:nextSibling"); /* repeat for overloaded templated functions */
continue;
} else {
- String *tname = Copy((yyvsp[(5) - (9)].str));
+ String *tname = Copy((yyvsp[-4].str));
int def_supplied = 0;
/* Expand the template */
- Node *templ = Swig_symbol_clookup((yyvsp[(5) - (9)].str),0);
+ Node *templ = Swig_symbol_clookup((yyvsp[-4].str),0);
Parm *targs = templ ? Getattr(templ,"templateparms") : 0;
ParmList *temparms;
- if (specialized) temparms = CopyParmList((yyvsp[(7) - (9)].p));
+ if (specialized) temparms = CopyParmList((yyvsp[-2].p));
else temparms = CopyParmList(tparms);
/* Create typedef's and arguments */
- p = (yyvsp[(7) - (9)].p);
+ p = (yyvsp[-2].p);
tp = temparms;
if (!p && ParmList_len(p) != ParmList_len(temparms)) {
/* we have no template parameters supplied in %template for a template that has default args*/
if (!p && tp) {
p = tp;
def_supplied = 1;
+ } else if (p && !tp) { /* Variadic template - tp < p */
+ SWIG_WARN_NODE_BEGIN(nn);
+ Swig_warning(WARN_CPP11_VARIADIC_TEMPLATE,cparse_file, cparse_line,"Only the first variadic template argument is currently supported.\n");
+ SWIG_WARN_NODE_END(nn);
+ break;
}
}
templnode = copy_node(nn);
+ update_nested_classes(templnode); /* update classes nested within template */
/* We need to set the node name based on name used to instantiate */
Setattr(templnode,"name",tname);
Delete(tname);
} else {
Setattr(templnode,"sym:typename","1");
}
- if ((yyvsp[(3) - (9)].id) && !inclass) {
+ /* for now, nested %template is allowed only in the same scope as the template declaration */
+ if ((yyvsp[-6].id) && !(nnisclass && ((outer_class && (outer_class != Getattr(nn, "nested:outer")))
+ ||(extendmode && current_class && (current_class != Getattr(nn, "nested:outer")))))) {
/*
Comment this out for 1.3.28. We need to
re-enable it later but first we need to
String *symname = Swig_name_make(templnode,0,$3,0,0);
*/
- String *symname = (yyvsp[(3) - (9)].id);
+ String *symname = NewString((yyvsp[-6].id));
Swig_cparse_template_expand(templnode,symname,temparms,tscope);
Setattr(templnode,"sym:name",symname);
} else {
Setattr(templnode,"sym:name",nname);
Delete(nname);
Setattr(templnode,"feature:onlychildren", "typemap,typemapitem,typemapcopy,typedef,types,fragment");
-
- if ((yyvsp[(3) - (9)].id)) {
+ if ((yyvsp[-6].id)) {
Swig_warning(WARN_PARSE_NESTED_TEMPLATE, cparse_file, cparse_line, "Named nested template instantiations not supported. Processing as if no name was given to %%template().\n");
}
}
Setfile(templnode,cparse_file);
Setline(templnode,cparse_line);
Delete(temparms);
-
+ if (outer_class && nnisclass) {
+ SetFlag(templnode, "nested");
+ Setattr(templnode, "nested:outer", outer_class);
+ }
add_symbols_copy(templnode);
if (Strcmp(nodeType(templnode),"class") == 0) {
csyms = Swig_symbol_current();
Swig_symbol_setscope(Getattr(templnode,"symtab"));
if (baselist) {
- List *bases = make_inherit_list(Getattr(templnode,"name"),baselist);
+ List *bases = Swig_make_inherit_list(Getattr(templnode,"name"),baselist, Namespaceprefix);
if (bases) {
Iterator s;
for (s = First(bases); s.item; s = Next(s)) {
Swig_symbol_setscope(csyms);
}
- /* Merge in %extend methods for this class */
+ /* Merge in %extend methods for this class.
+ This only merges methods within %extend for a template specialized class such as
+ template<typename T> class K {}; %extend K<int> { ... }
+ The copy_node() call above has already added in the generic %extend methods such as
+ template<typename T> class K {}; %extend K { ... } */
/* !!! This may be broken. We may have to add the
%extend methods at the beginning of the class */
-
- if (extendhash) {
+ {
String *stmp = 0;
String *clsname;
Node *am;
} else {
clsname = Getattr(templnode,"name");
}
- am = Getattr(extendhash,clsname);
+ am = Getattr(Swig_extend_hash(),clsname);
if (am) {
Symtab *st = Swig_symbol_current();
Swig_symbol_setscope(Getattr(templnode,"symtab"));
/* Printf(stdout,"%s: %s %p %p\n", Getattr(templnode,"name"), clsname, Swig_symbol_current(), Getattr(templnode,"symtab")); */
- merge_extensions(templnode,am);
+ Swig_extend_merge(templnode,am);
Swig_symbol_setscope(st);
- append_previous_extension(templnode,am);
- Delattr(extendhash,clsname);
+ Swig_extend_append_previous(templnode,am);
+ Delattr(Swig_extend_hash(),clsname);
}
if (stmp) Delete(stmp);
}
+
/* Add to classes hash */
- if (!classes) classes = NewHash();
+ if (!classes)
+ classes = NewHash();
- {
- if (Namespaceprefix) {
- String *temp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,"name"));
- Setattr(classes,temp,templnode);
- Delete(temp);
- } else {
- String *qs = Swig_symbol_qualifiedscopename(templnode);
- Setattr(classes, qs,templnode);
- Delete(qs);
- }
- }
+ if (Namespaceprefix) {
+ String *temp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,"name"));
+ Setattr(classes,temp,templnode);
+ Delete(temp);
+ } else {
+ String *qs = Swig_symbol_qualifiedscopename(templnode);
+ Setattr(classes, qs,templnode);
+ Delete(qs);
+ }
}
}
/* all the overloaded templated functions are added into a linked list */
+ if (!linkliststart)
+ linkliststart = templnode;
if (nscope_inner) {
/* non-global namespace */
if (templnode) {
}
nn = Getattr(nn,"sym:nextSibling"); /* repeat for overloaded templated functions. If a templated class there will never be a sibling. */
}
+ update_defaultargs(linkliststart);
}
Swig_symbol_setscope(tscope);
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
}
+#line 6127 "y.tab.c" /* yacc.c:1646 */
break;
case 112:
-
-/* Line 1806 of yacc.c */
-#line 3118 "parser.y"
+#line 2848 "parser.y" /* yacc.c:1646 */
{
- Swig_warning(0,cparse_file, cparse_line,"%s\n", (yyvsp[(2) - (2)].id));
+ Swig_warning(0,cparse_file, cparse_line,"%s\n", (yyvsp[0].str));
(yyval.node) = 0;
}
+#line 6136 "y.tab.c" /* yacc.c:1646 */
break;
case 113:
-
-/* Line 1806 of yacc.c */
-#line 3128 "parser.y"
+#line 2858 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(1) - (1)].node);
+ (yyval.node) = (yyvsp[0].node);
if ((yyval.node)) {
add_symbols((yyval.node));
default_arguments((yyval.node));
}
}
+#line 6148 "y.tab.c" /* yacc.c:1646 */
break;
case 114:
-
-/* Line 1806 of yacc.c */
-#line 3135 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 2865 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 6154 "y.tab.c" /* yacc.c:1646 */
break;
case 115:
-
-/* Line 1806 of yacc.c */
-#line 3136 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+#line 2866 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 6160 "y.tab.c" /* yacc.c:1646 */
break;
case 116:
-
-/* Line 1806 of yacc.c */
-#line 3140 "parser.y"
+#line 2870 "parser.y" /* yacc.c:1646 */
{
- if (Strcmp((yyvsp[(2) - (3)].id),"C") == 0) {
+ if (Strcmp((yyvsp[-1].str),"C") == 0) {
cparse_externc = 1;
}
}
+#line 6170 "y.tab.c" /* yacc.c:1646 */
break;
case 117:
-
-/* Line 1806 of yacc.c */
-#line 3144 "parser.y"
+#line 2874 "parser.y" /* yacc.c:1646 */
{
cparse_externc = 0;
- if (Strcmp((yyvsp[(2) - (6)].id),"C") == 0) {
- Node *n = firstChild((yyvsp[(5) - (6)].node));
+ if (Strcmp((yyvsp[-4].str),"C") == 0) {
+ Node *n = firstChild((yyvsp[-1].node));
(yyval.node) = new_node("extern");
- Setattr((yyval.node),"name",(yyvsp[(2) - (6)].id));
+ Setattr((yyval.node),"name",(yyvsp[-4].str));
appendChild((yyval.node),n);
while (n) {
SwigType *decl = Getattr(n,"decl");
n = nextSibling(n);
}
} else {
- Swig_warning(WARN_PARSE_UNDEFINED_EXTERN,cparse_file, cparse_line,"Unrecognized extern type \"%s\".\n", (yyvsp[(2) - (6)].id));
+ Swig_warning(WARN_PARSE_UNDEFINED_EXTERN,cparse_file, cparse_line,"Unrecognized extern type \"%s\".\n", (yyvsp[-4].str));
(yyval.node) = new_node("extern");
- Setattr((yyval.node),"name",(yyvsp[(2) - (6)].id));
- appendChild((yyval.node),firstChild((yyvsp[(5) - (6)].node)));
+ Setattr((yyval.node),"name",(yyvsp[-4].str));
+ appendChild((yyval.node),firstChild((yyvsp[-1].node)));
}
}
+#line 6196 "y.tab.c" /* yacc.c:1646 */
break;
case 118:
+#line 2895 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = (yyvsp[0].node);
+ SWIG_WARN_NODE_BEGIN((yyval.node));
+ Swig_warning(WARN_CPP11_LAMBDA, cparse_file, cparse_line, "Lambda expressions and closures are not fully supported yet.\n");
+ SWIG_WARN_NODE_END((yyval.node));
+ }
+#line 6207 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 119:
+#line 2901 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = new_node("using");
+ Setattr((yyval.node),"name",(yyvsp[-4].str));
+ SwigType_push((yyvsp[-2].type),(yyvsp[-1].decl).type);
+ Setattr((yyval.node),"uname",(yyvsp[-2].type));
+ add_symbols((yyval.node));
+ SWIG_WARN_NODE_BEGIN((yyval.node));
+ Swig_warning(WARN_CPP11_ALIAS_DECLARATION, cparse_file, cparse_line, "The 'using' keyword in type aliasing is not fully supported yet.\n");
+ SWIG_WARN_NODE_END((yyval.node));
+
+ (yyval.node) = 0; /* TODO - ignored for now */
+ }
+#line 6224 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 120:
+#line 2913 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = new_node("using");
+ Setattr((yyval.node),"name",(yyvsp[-4].str));
+ SwigType_push((yyvsp[-2].type),(yyvsp[-1].decl).type);
+ Setattr((yyval.node),"uname",(yyvsp[-2].type));
+ add_symbols((yyval.node));
+ SWIG_WARN_NODE_BEGIN((yyval.node));
+ Swig_warning(WARN_CPP11_ALIAS_TEMPLATE, cparse_file, cparse_line, "The 'using' keyword in template aliasing is not fully supported yet.\n");
+ SWIG_WARN_NODE_END((yyval.node));
+
+ (yyval.node) = 0; /* TODO - ignored for now */
+ }
+#line 6241 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 3171 "parser.y"
+ case 121:
+#line 2931 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("cdecl");
- if ((yyvsp[(4) - (5)].dtype).qualifier) SwigType_push((yyvsp[(3) - (5)].decl).type,(yyvsp[(4) - (5)].dtype).qualifier);
- Setattr((yyval.node),"type",(yyvsp[(2) - (5)].type));
- Setattr((yyval.node),"storage",(yyvsp[(1) - (5)].id));
- Setattr((yyval.node),"name",(yyvsp[(3) - (5)].decl).id);
- Setattr((yyval.node),"decl",(yyvsp[(3) - (5)].decl).type);
- Setattr((yyval.node),"parms",(yyvsp[(3) - (5)].decl).parms);
- Setattr((yyval.node),"value",(yyvsp[(4) - (5)].dtype).val);
- Setattr((yyval.node),"throws",(yyvsp[(4) - (5)].dtype).throws);
- Setattr((yyval.node),"throw",(yyvsp[(4) - (5)].dtype).throwf);
- if (!(yyvsp[(5) - (5)].node)) {
+ if ((yyvsp[-1].dtype).qualifier) SwigType_push((yyvsp[-2].decl).type,(yyvsp[-1].dtype).qualifier);
+ Setattr((yyval.node),"type",(yyvsp[-3].type));
+ Setattr((yyval.node),"storage",(yyvsp[-4].id));
+ Setattr((yyval.node),"name",(yyvsp[-2].decl).id);
+ Setattr((yyval.node),"decl",(yyvsp[-2].decl).type);
+ Setattr((yyval.node),"parms",(yyvsp[-2].decl).parms);
+ Setattr((yyval.node),"value",(yyvsp[-1].dtype).val);
+ Setattr((yyval.node),"throws",(yyvsp[-1].dtype).throws);
+ Setattr((yyval.node),"throw",(yyvsp[-1].dtype).throwf);
+ Setattr((yyval.node),"noexcept",(yyvsp[-1].dtype).nexcept);
+ if ((yyvsp[-1].dtype).val && (yyvsp[-1].dtype).type) {
+ /* store initializer type as it might be different to the declared type */
+ SwigType *valuetype = NewSwigType((yyvsp[-1].dtype).type);
+ if (Len(valuetype) > 0)
+ Setattr((yyval.node),"valuetype",valuetype);
+ else
+ Delete(valuetype);
+ }
+ if (!(yyvsp[0].node)) {
if (Len(scanner_ccode)) {
String *code = Copy(scanner_ccode);
Setattr((yyval.node),"code",code);
Delete(code);
}
} else {
- Node *n = (yyvsp[(5) - (5)].node);
+ Node *n = (yyvsp[0].node);
/* Inherit attributes */
while (n) {
- String *type = Copy((yyvsp[(2) - (5)].type));
+ String *type = Copy((yyvsp[-3].type));
Setattr(n,"type",type);
- Setattr(n,"storage",(yyvsp[(1) - (5)].id));
+ Setattr(n,"storage",(yyvsp[-4].id));
n = nextSibling(n);
Delete(type);
}
}
- if ((yyvsp[(4) - (5)].dtype).bitfield) {
- Setattr((yyval.node),"bitfield", (yyvsp[(4) - (5)].dtype).bitfield);
+ if ((yyvsp[-1].dtype).bitfield) {
+ Setattr((yyval.node),"bitfield", (yyvsp[-1].dtype).bitfield);
}
/* Look for "::" declarations (ignored) */
- if (Strstr((yyvsp[(3) - (5)].decl).id,"::")) {
+ if (Strstr((yyvsp[-2].decl).id,"::")) {
/* This is a special case. If the scope name of the declaration exactly
matches that of the declaration, then we will allow it. Otherwise, delete. */
- String *p = Swig_scopename_prefix((yyvsp[(3) - (5)].decl).id);
+ String *p = Swig_scopename_prefix((yyvsp[-2].decl).id);
if (p) {
- if ((Namespaceprefix && Strcmp(p,Namespaceprefix) == 0) ||
- (inclass && Strcmp(p,Classprefix) == 0)) {
- String *lstr = Swig_scopename_last((yyvsp[(3) - (5)].decl).id);
+ if ((Namespaceprefix && Strcmp(p, Namespaceprefix) == 0) ||
+ (Classprefix && Strcmp(p, Classprefix) == 0)) {
+ String *lstr = Swig_scopename_last((yyvsp[-2].decl).id);
Setattr((yyval.node),"name",lstr);
Delete(lstr);
- set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node));
+ set_nextSibling((yyval.node),(yyvsp[0].node));
} else {
Delete((yyval.node));
- (yyval.node) = (yyvsp[(5) - (5)].node);
+ (yyval.node) = (yyvsp[0].node);
}
Delete(p);
} else {
Delete((yyval.node));
- (yyval.node) = (yyvsp[(5) - (5)].node);
+ (yyval.node) = (yyvsp[0].node);
}
} else {
- set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node));
+ set_nextSibling((yyval.node),(yyvsp[0].node));
}
}
+#line 6312 "y.tab.c" /* yacc.c:1646 */
break;
- case 119:
+ case 122:
+#line 2999 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = new_node("cdecl");
+ if ((yyvsp[-1].dtype).qualifier) SwigType_push((yyvsp[-4].decl).type,(yyvsp[-1].dtype).qualifier);
+ Setattr((yyval.node),"type",(yyvsp[-2].node));
+ Setattr((yyval.node),"storage",(yyvsp[-6].id));
+ Setattr((yyval.node),"name",(yyvsp[-4].decl).id);
+ Setattr((yyval.node),"decl",(yyvsp[-4].decl).type);
+ Setattr((yyval.node),"parms",(yyvsp[-4].decl).parms);
+ Setattr((yyval.node),"value",(yyvsp[-1].dtype).val);
+ Setattr((yyval.node),"throws",(yyvsp[-1].dtype).throws);
+ Setattr((yyval.node),"throw",(yyvsp[-1].dtype).throwf);
+ Setattr((yyval.node),"noexcept",(yyvsp[-1].dtype).nexcept);
+ if (!(yyvsp[0].node)) {
+ if (Len(scanner_ccode)) {
+ String *code = Copy(scanner_ccode);
+ Setattr((yyval.node),"code",code);
+ Delete(code);
+ }
+ } else {
+ Node *n = (yyvsp[0].node);
+ while (n) {
+ String *type = Copy((yyvsp[-2].node));
+ Setattr(n,"type",type);
+ Setattr(n,"storage",(yyvsp[-6].id));
+ n = nextSibling(n);
+ Delete(type);
+ }
+ }
+ if ((yyvsp[-1].dtype).bitfield) {
+ Setattr((yyval.node),"bitfield", (yyvsp[-1].dtype).bitfield);
+ }
+
+ if (Strstr((yyvsp[-4].decl).id,"::")) {
+ String *p = Swig_scopename_prefix((yyvsp[-4].decl).id);
+ if (p) {
+ if ((Namespaceprefix && Strcmp(p, Namespaceprefix) == 0) ||
+ (Classprefix && Strcmp(p, Classprefix) == 0)) {
+ String *lstr = Swig_scopename_last((yyvsp[-4].decl).id);
+ Setattr((yyval.node),"name",lstr);
+ Delete(lstr);
+ set_nextSibling((yyval.node),(yyvsp[0].node));
+ } else {
+ Delete((yyval.node));
+ (yyval.node) = (yyvsp[0].node);
+ }
+ Delete(p);
+ } else {
+ Delete((yyval.node));
+ (yyval.node) = (yyvsp[0].node);
+ }
+ } else {
+ set_nextSibling((yyval.node),(yyvsp[0].node));
+ }
+ }
+#line 6371 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 3232 "parser.y"
+ case 123:
+#line 3057 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = 0;
Clear(scanner_ccode);
}
+#line 6380 "y.tab.c" /* yacc.c:1646 */
break;
- case 120:
-
-/* Line 1806 of yacc.c */
-#line 3236 "parser.y"
+ case 124:
+#line 3061 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("cdecl");
- if ((yyvsp[(3) - (4)].dtype).qualifier) SwigType_push((yyvsp[(2) - (4)].decl).type,(yyvsp[(3) - (4)].dtype).qualifier);
- Setattr((yyval.node),"name",(yyvsp[(2) - (4)].decl).id);
- Setattr((yyval.node),"decl",(yyvsp[(2) - (4)].decl).type);
- Setattr((yyval.node),"parms",(yyvsp[(2) - (4)].decl).parms);
- Setattr((yyval.node),"value",(yyvsp[(3) - (4)].dtype).val);
- Setattr((yyval.node),"throws",(yyvsp[(3) - (4)].dtype).throws);
- Setattr((yyval.node),"throw",(yyvsp[(3) - (4)].dtype).throwf);
- if ((yyvsp[(3) - (4)].dtype).bitfield) {
- Setattr((yyval.node),"bitfield", (yyvsp[(3) - (4)].dtype).bitfield);
+ if ((yyvsp[-1].dtype).qualifier) SwigType_push((yyvsp[-2].decl).type,(yyvsp[-1].dtype).qualifier);
+ Setattr((yyval.node),"name",(yyvsp[-2].decl).id);
+ Setattr((yyval.node),"decl",(yyvsp[-2].decl).type);
+ Setattr((yyval.node),"parms",(yyvsp[-2].decl).parms);
+ Setattr((yyval.node),"value",(yyvsp[-1].dtype).val);
+ Setattr((yyval.node),"throws",(yyvsp[-1].dtype).throws);
+ Setattr((yyval.node),"throw",(yyvsp[-1].dtype).throwf);
+ Setattr((yyval.node),"noexcept",(yyvsp[-1].dtype).nexcept);
+ if ((yyvsp[-1].dtype).bitfield) {
+ Setattr((yyval.node),"bitfield", (yyvsp[-1].dtype).bitfield);
}
- if (!(yyvsp[(4) - (4)].node)) {
+ if (!(yyvsp[0].node)) {
if (Len(scanner_ccode)) {
String *code = Copy(scanner_ccode);
Setattr((yyval.node),"code",code);
Delete(code);
}
} else {
- set_nextSibling((yyval.node),(yyvsp[(4) - (4)].node));
+ set_nextSibling((yyval.node),(yyvsp[0].node));
}
}
+#line 6408 "y.tab.c" /* yacc.c:1646 */
break;
- case 121:
-
-/* Line 1806 of yacc.c */
-#line 3258 "parser.y"
+ case 125:
+#line 3084 "parser.y" /* yacc.c:1646 */
{
skip_balanced('{','}');
(yyval.node) = 0;
}
+#line 6417 "y.tab.c" /* yacc.c:1646 */
break;
- case 122:
+ case 126:
+#line 3088 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = 0;
+ if (yychar == RPAREN) {
+ Swig_error(cparse_file, cparse_line, "Unexpected ')'.\n");
+ } else {
+ Swig_error(cparse_file, cparse_line, "Syntax error - possibly a missing semicolon.\n");
+ }
+ exit(1);
+ }
+#line 6431 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 3264 "parser.y"
+ case 127:
+#line 3099 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(1) - (1)].dtype);
+ (yyval.dtype) = (yyvsp[0].dtype);
(yyval.dtype).qualifier = 0;
(yyval.dtype).throws = 0;
(yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
}
+#line 6443 "y.tab.c" /* yacc.c:1646 */
break;
- case 123:
-
-/* Line 1806 of yacc.c */
-#line 3270 "parser.y"
+ case 128:
+#line 3106 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(2) - (2)].dtype);
- (yyval.dtype).qualifier = (yyvsp[(1) - (2)].str);
+ (yyval.dtype) = (yyvsp[0].dtype);
+ (yyval.dtype).qualifier = (yyvsp[-1].str);
(yyval.dtype).throws = 0;
(yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
}
+#line 6455 "y.tab.c" /* yacc.c:1646 */
break;
- case 124:
-
-/* Line 1806 of yacc.c */
-#line 3276 "parser.y"
+ case 129:
+#line 3113 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(5) - (5)].dtype);
+ (yyval.dtype) = (yyvsp[0].dtype);
(yyval.dtype).qualifier = 0;
- (yyval.dtype).throws = (yyvsp[(3) - (5)].pl);
- (yyval.dtype).throwf = NewString("1");
+ (yyval.dtype).throws = (yyvsp[-1].dtype).throws;
+ (yyval.dtype).throwf = (yyvsp[-1].dtype).throwf;
+ (yyval.dtype).nexcept = (yyvsp[-1].dtype).nexcept;
}
+#line 6467 "y.tab.c" /* yacc.c:1646 */
break;
- case 125:
-
-/* Line 1806 of yacc.c */
-#line 3282 "parser.y"
+ case 130:
+#line 3120 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(6) - (6)].dtype);
- (yyval.dtype).qualifier = (yyvsp[(1) - (6)].str);
- (yyval.dtype).throws = (yyvsp[(4) - (6)].pl);
- (yyval.dtype).throwf = NewString("1");
+ (yyval.dtype) = (yyvsp[0].dtype);
+ (yyval.dtype).qualifier = (yyvsp[-2].str);
+ (yyval.dtype).throws = (yyvsp[-1].dtype).throws;
+ (yyval.dtype).throwf = (yyvsp[-1].dtype).throwf;
+ (yyval.dtype).nexcept = (yyvsp[-1].dtype).nexcept;
}
+#line 6479 "y.tab.c" /* yacc.c:1646 */
break;
- case 126:
+ case 131:
+#line 3129 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].type); }
+#line 6485 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 132:
+#line 3130 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].type); }
+#line 6491 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 133:
+#line 3131 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].type); }
+#line 6497 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 134:
+#line 3135 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].type); }
+#line 6503 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 135:
+#line 3136 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].str); }
+#line 6509 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 136:
+#line 3137 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].type); }
+#line 6515 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 137:
+#line 3148 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = new_node("lambda");
+ Setattr((yyval.node),"name",(yyvsp[-8].str));
+ add_symbols((yyval.node));
+ }
+#line 6525 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 138:
+#line 3153 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = new_node("lambda");
+ Setattr((yyval.node),"name",(yyvsp[-10].str));
+ add_symbols((yyval.node));
+ }
+#line 6535 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 139:
+#line 3158 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = new_node("lambda");
+ Setattr((yyval.node),"name",(yyvsp[-4].str));
+ add_symbols((yyval.node));
+ }
+#line 6545 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 140:
+#line 3165 "parser.y" /* yacc.c:1646 */
+ {
+ skip_balanced('[',']');
+ (yyval.node) = 0;
+ }
+#line 6554 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 141:
+#line 3171 "parser.y" /* yacc.c:1646 */
+ {
+ skip_balanced('{','}');
+ (yyval.node) = 0;
+ }
+#line 6563 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 142:
+#line 3176 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.pl) = 0;
+ }
+#line 6571 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 143:
+#line 3179 "parser.y" /* yacc.c:1646 */
+ {
+ skip_balanced('(',')');
+ }
+#line 6579 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 144:
+#line 3181 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.pl) = 0;
+ }
+#line 6587 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 145:
+#line 3192 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = (char *)"enum";
+ }
+#line 6595 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 146:
+#line 3195 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = (char *)"enum class";
+ }
+#line 6603 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 147:
+#line 3198 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = (char *)"enum struct";
+ }
+#line 6611 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 3295 "parser.y"
+ case 148:
+#line 3207 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = (yyvsp[0].type);
+ }
+#line 6619 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 149:
+#line 3210 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = 0; }
+#line 6625 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 150:
+#line 3217 "parser.y" /* yacc.c:1646 */
{
SwigType *ty = 0;
+ int scopedenum = (yyvsp[-2].id) && !Equal((yyvsp[-3].node), "enum");
(yyval.node) = new_node("enumforward");
- ty = NewStringf("enum %s", (yyvsp[(3) - (4)].id));
- Setattr((yyval.node),"name",(yyvsp[(3) - (4)].id));
+ ty = NewStringf("enum %s", (yyvsp[-2].id));
+ Setattr((yyval.node),"enumkey",(yyvsp[-3].node));
+ if (scopedenum)
+ SetFlag((yyval.node), "scopedenum");
+ Setattr((yyval.node),"name",(yyvsp[-2].id));
+ Setattr((yyval.node),"inherit",(yyvsp[-1].node));
Setattr((yyval.node),"type",ty);
Setattr((yyval.node),"sym:weak", "1");
add_symbols((yyval.node));
}
+#line 6644 "y.tab.c" /* yacc.c:1646 */
break;
- case 127:
-
-/* Line 1806 of yacc.c */
-#line 3310 "parser.y"
+ case 151:
+#line 3239 "parser.y" /* yacc.c:1646 */
{
SwigType *ty = 0;
+ int scopedenum = (yyvsp[-5].id) && !Equal((yyvsp[-6].node), "enum");
(yyval.node) = new_node("enum");
- ty = NewStringf("enum %s", (yyvsp[(3) - (7)].id));
- Setattr((yyval.node),"name",(yyvsp[(3) - (7)].id));
+ ty = NewStringf("enum %s", (yyvsp[-5].id));
+ Setattr((yyval.node),"enumkey",(yyvsp[-6].node));
+ if (scopedenum)
+ SetFlag((yyval.node), "scopedenum");
+ Setattr((yyval.node),"name",(yyvsp[-5].id));
+ Setattr((yyval.node),"inherit",(yyvsp[-4].node));
Setattr((yyval.node),"type",ty);
- appendChild((yyval.node),(yyvsp[(5) - (7)].node));
- add_symbols((yyval.node)); /* Add to tag space */
- add_symbols((yyvsp[(5) - (7)].node)); /* Add enum values to id space */
+ appendChild((yyval.node),(yyvsp[-2].node));
+ add_symbols((yyval.node)); /* Add to tag space */
+
+ if (scopedenum) {
+ Swig_symbol_newscope();
+ Swig_symbol_setscopename((yyvsp[-5].id));
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ }
+
+ add_symbols((yyvsp[-2].node)); /* Add enum values to appropriate enum or enum class scope */
+
+ if (scopedenum) {
+ Setattr((yyval.node),"symtab", Swig_symbol_popscope());
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ }
}
+#line 6678 "y.tab.c" /* yacc.c:1646 */
break;
- case 128:
-
-/* Line 1806 of yacc.c */
-#line 3320 "parser.y"
+ case 152:
+#line 3268 "parser.y" /* yacc.c:1646 */
{
Node *n;
SwigType *ty = 0;
String *unnamed = 0;
int unnamedinstance = 0;
+ int scopedenum = (yyvsp[-7].id) && !Equal((yyvsp[-8].node), "enum");
(yyval.node) = new_node("enum");
- if ((yyvsp[(3) - (9)].id)) {
- Setattr((yyval.node),"name",(yyvsp[(3) - (9)].id));
- ty = NewStringf("enum %s", (yyvsp[(3) - (9)].id));
- } else if ((yyvsp[(7) - (9)].decl).id) {
+ Setattr((yyval.node),"enumkey",(yyvsp[-8].node));
+ if (scopedenum)
+ SetFlag((yyval.node), "scopedenum");
+ Setattr((yyval.node),"inherit",(yyvsp[-6].node));
+ if ((yyvsp[-7].id)) {
+ Setattr((yyval.node),"name",(yyvsp[-7].id));
+ ty = NewStringf("enum %s", (yyvsp[-7].id));
+ } else if ((yyvsp[-2].decl).id) {
unnamed = make_unnamed();
ty = NewStringf("enum %s", unnamed);
Setattr((yyval.node),"unnamed",unnamed);
/* name is not set for unnamed enum instances, e.g. enum { foo } Instance; */
- if ((yyvsp[(1) - (9)].id) && Cmp((yyvsp[(1) - (9)].id),"typedef") == 0) {
- Setattr((yyval.node),"name",(yyvsp[(7) - (9)].decl).id);
+ if ((yyvsp[-9].id) && Cmp((yyvsp[-9].id),"typedef") == 0) {
+ Setattr((yyval.node),"name",(yyvsp[-2].decl).id);
} else {
unnamedinstance = 1;
}
- Setattr((yyval.node),"storage",(yyvsp[(1) - (9)].id));
+ Setattr((yyval.node),"storage",(yyvsp[-9].id));
}
- if ((yyvsp[(7) - (9)].decl).id && Cmp((yyvsp[(1) - (9)].id),"typedef") == 0) {
- Setattr((yyval.node),"tdname",(yyvsp[(7) - (9)].decl).id);
+ if ((yyvsp[-2].decl).id && Cmp((yyvsp[-9].id),"typedef") == 0) {
+ Setattr((yyval.node),"tdname",(yyvsp[-2].decl).id);
Setattr((yyval.node),"allows_typedef","1");
}
- appendChild((yyval.node),(yyvsp[(5) - (9)].node));
+ appendChild((yyval.node),(yyvsp[-4].node));
n = new_node("cdecl");
Setattr(n,"type",ty);
- Setattr(n,"name",(yyvsp[(7) - (9)].decl).id);
- Setattr(n,"storage",(yyvsp[(1) - (9)].id));
- Setattr(n,"decl",(yyvsp[(7) - (9)].decl).type);
- Setattr(n,"parms",(yyvsp[(7) - (9)].decl).parms);
+ Setattr(n,"name",(yyvsp[-2].decl).id);
+ Setattr(n,"storage",(yyvsp[-9].id));
+ Setattr(n,"decl",(yyvsp[-2].decl).type);
+ Setattr(n,"parms",(yyvsp[-2].decl).parms);
Setattr(n,"unnamed",unnamed);
if (unnamedinstance) {
SetFlag(n,"unnamedinstance");
Delete(cty);
}
- if ((yyvsp[(9) - (9)].node)) {
- Node *p = (yyvsp[(9) - (9)].node);
+ if ((yyvsp[0].node)) {
+ Node *p = (yyvsp[0].node);
set_nextSibling(n,p);
while (p) {
SwigType *cty = Copy(ty);
Setattr(p,"type",cty);
Setattr(p,"unnamed",unnamed);
- Setattr(p,"storage",(yyvsp[(1) - (9)].id));
+ Setattr(p,"storage",(yyvsp[-9].id));
Delete(cty);
p = nextSibling(p);
}
/* Ensure that typedef enum ABC {foo} XYZ; uses XYZ for sym:name, like structs.
* Note that class_rename/yyrename are bit of a mess so used this simple approach to change the name. */
- if ((yyvsp[(7) - (9)].decl).id && (yyvsp[(3) - (9)].id) && Cmp((yyvsp[(1) - (9)].id),"typedef") == 0) {
- String *name = NewString((yyvsp[(7) - (9)].decl).id);
+ if ((yyvsp[-2].decl).id && (yyvsp[-7].id) && Cmp((yyvsp[-9].id),"typedef") == 0) {
+ String *name = NewString((yyvsp[-2].decl).id);
Setattr((yyval.node), "parser:makename", name);
Delete(name);
}
add_symbols((yyval.node)); /* Add enum to tag space */
set_nextSibling((yyval.node),n);
Delete(n);
- add_symbols((yyvsp[(5) - (9)].node)); /* Add enum values to id space */
+
+ if (scopedenum) {
+ Swig_symbol_newscope();
+ Swig_symbol_setscopename((yyvsp[-7].id));
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ }
+
+ add_symbols((yyvsp[-4].node)); /* Add enum values to appropriate enum or enum class scope */
+
+ if (scopedenum) {
+ Setattr((yyval.node),"symtab", Swig_symbol_popscope());
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ }
+
add_symbols(n);
Delete(unnamed);
}
+#line 6779 "y.tab.c" /* yacc.c:1646 */
break;
- case 129:
-
-/* Line 1806 of yacc.c */
-#line 3398 "parser.y"
+ case 153:
+#line 3366 "parser.y" /* yacc.c:1646 */
{
/* This is a sick hack. If the ctor_end has parameters,
and the parms parameter only has 1 parameter, this
int err = 0;
(yyval.node) = 0;
- if ((ParmList_len((yyvsp[(4) - (6)].pl)) == 1) && (!Swig_scopename_check((yyvsp[(2) - (6)].type)))) {
- SwigType *ty = Getattr((yyvsp[(4) - (6)].pl),"type");
- String *name = Getattr((yyvsp[(4) - (6)].pl),"name");
+ if ((ParmList_len((yyvsp[-2].pl)) == 1) && (!Swig_scopename_check((yyvsp[-4].type)))) {
+ SwigType *ty = Getattr((yyvsp[-2].pl),"type");
+ String *name = Getattr((yyvsp[-2].pl),"name");
err = 1;
if (!name) {
(yyval.node) = new_node("cdecl");
- Setattr((yyval.node),"type",(yyvsp[(2) - (6)].type));
- Setattr((yyval.node),"storage",(yyvsp[(1) - (6)].id));
+ Setattr((yyval.node),"type",(yyvsp[-4].type));
+ Setattr((yyval.node),"storage",(yyvsp[-5].id));
Setattr((yyval.node),"name",ty);
- if ((yyvsp[(6) - (6)].decl).have_parms) {
+ if ((yyvsp[0].decl).have_parms) {
SwigType *decl = NewStringEmpty();
- SwigType_add_function(decl,(yyvsp[(6) - (6)].decl).parms);
+ SwigType_add_function(decl,(yyvsp[0].decl).parms);
Setattr((yyval.node),"decl",decl);
- Setattr((yyval.node),"parms",(yyvsp[(6) - (6)].decl).parms);
+ Setattr((yyval.node),"parms",(yyvsp[0].decl).parms);
if (Len(scanner_ccode)) {
String *code = Copy(scanner_ccode);
Setattr((yyval.node),"code",code);
Delete(code);
}
}
- if ((yyvsp[(6) - (6)].decl).defarg) {
- Setattr((yyval.node),"value",(yyvsp[(6) - (6)].decl).defarg);
+ if ((yyvsp[0].decl).defarg) {
+ Setattr((yyval.node),"value",(yyvsp[0].decl).defarg);
}
- Setattr((yyval.node),"throws",(yyvsp[(6) - (6)].decl).throws);
- Setattr((yyval.node),"throw",(yyvsp[(6) - (6)].decl).throwf);
+ Setattr((yyval.node),"throws",(yyvsp[0].decl).throws);
+ Setattr((yyval.node),"throw",(yyvsp[0].decl).throwf);
+ Setattr((yyval.node),"noexcept",(yyvsp[0].decl).nexcept);
err = 0;
}
}
exit(1);
}
}
+#line 6830 "y.tab.c" /* yacc.c:1646 */
break;
- case 130:
-
-/* Line 1806 of yacc.c */
-#line 3449 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 154:
+#line 3418 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 6836 "y.tab.c" /* yacc.c:1646 */
break;
- case 131:
-
-/* Line 1806 of yacc.c */
-#line 3450 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 155:
+#line 3419 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 6842 "y.tab.c" /* yacc.c:1646 */
break;
- case 132:
-
-/* Line 1806 of yacc.c */
-#line 3451 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 156:
+#line 3420 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 6848 "y.tab.c" /* yacc.c:1646 */
break;
- case 133:
-
-/* Line 1806 of yacc.c */
-#line 3452 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 157:
+#line 3421 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 6854 "y.tab.c" /* yacc.c:1646 */
break;
- case 134:
-
-/* Line 1806 of yacc.c */
-#line 3453 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 158:
+#line 3422 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 6860 "y.tab.c" /* yacc.c:1646 */
break;
- case 135:
-
-/* Line 1806 of yacc.c */
-#line 3454 "parser.y"
+ case 159:
+#line 3423 "parser.y" /* yacc.c:1646 */
{ (yyval.node) = 0; }
+#line 6866 "y.tab.c" /* yacc.c:1646 */
break;
- case 136:
-
-/* Line 1806 of yacc.c */
-#line 3459 "parser.y"
+ case 160:
+#line 3428 "parser.y" /* yacc.c:1646 */
{
- if (nested_template == 0) {
String *prefix;
List *bases = 0;
Node *scope = 0;
+ String *code;
(yyval.node) = new_node("class");
Setline((yyval.node),cparse_start_line);
- Setattr((yyval.node),"kind",(yyvsp[(2) - (5)].id));
- if ((yyvsp[(4) - (5)].bases)) {
- Setattr((yyval.node),"baselist", Getattr((yyvsp[(4) - (5)].bases),"public"));
- Setattr((yyval.node),"protectedbaselist", Getattr((yyvsp[(4) - (5)].bases),"protected"));
- Setattr((yyval.node),"privatebaselist", Getattr((yyvsp[(4) - (5)].bases),"private"));
+ Setattr((yyval.node),"kind",(yyvsp[-3].id));
+ if ((yyvsp[-1].bases)) {
+ Setattr((yyval.node),"baselist", Getattr((yyvsp[-1].bases),"public"));
+ Setattr((yyval.node),"protectedbaselist", Getattr((yyvsp[-1].bases),"protected"));
+ Setattr((yyval.node),"privatebaselist", Getattr((yyvsp[-1].bases),"private"));
}
Setattr((yyval.node),"allows_typedef","1");
/* preserve the current scope */
- prev_symtab = Swig_symbol_current();
+ Setattr((yyval.node),"prev_symtab",Swig_symbol_current());
/* If the class name is qualified. We need to create or lookup namespace/scope entries */
- scope = resolve_create_node_scope((yyvsp[(3) - (5)].str));
+ scope = resolve_create_node_scope((yyvsp[-2].str));
+ /* save nscope_inner to the class - it may be overwritten in nested classes*/
+ Setattr((yyval.node), "nested:innerscope", nscope_inner);
+ Setattr((yyval.node), "nested:nscope", nscope);
Setfile(scope,cparse_file);
Setline(scope,cparse_line);
- (yyvsp[(3) - (5)].str) = scope;
-
- /* support for old nested classes "pseudo" support, such as:
-
- %rename(Ala__Ola) Ala::Ola;
- class Ala::Ola {
- public:
- Ola() {}
- };
+ (yyvsp[-2].str) = scope;
+ Setattr((yyval.node),"name",(yyvsp[-2].str));
- this should disappear when a proper implementation is added.
- */
- if (nscope_inner && Strcmp(nodeType(nscope_inner),"namespace") != 0) {
- if (Namespaceprefix) {
- String *name = NewStringf("%s::%s", Namespaceprefix, (yyvsp[(3) - (5)].str));
- (yyvsp[(3) - (5)].str) = name;
- Namespaceprefix = 0;
- nscope_inner = 0;
- }
+ if (currentOuterClass) {
+ SetFlag((yyval.node), "nested");
+ Setattr((yyval.node), "nested:outer", currentOuterClass);
+ set_access_mode((yyval.node));
}
- Setattr((yyval.node),"name",(yyvsp[(3) - (5)].str));
-
- Delete(class_rename);
- class_rename = make_name((yyval.node),(yyvsp[(3) - (5)].str),0);
- Classprefix = NewString((yyvsp[(3) - (5)].str));
+ Swig_features_get(Swig_cparse_features(), Namespaceprefix, Getattr((yyval.node), "name"), 0, (yyval.node));
+ /* save yyrename to the class attribute, to be used later in add_symbols()*/
+ Setattr((yyval.node), "class_rename", make_name((yyval.node), (yyvsp[-2].str), 0));
+ Setattr((yyval.node), "Classprefix", (yyvsp[-2].str));
+ Classprefix = NewString((yyvsp[-2].str));
/* Deal with inheritance */
- if ((yyvsp[(4) - (5)].bases)) {
- bases = make_inherit_list((yyvsp[(3) - (5)].str),Getattr((yyvsp[(4) - (5)].bases),"public"));
- }
- prefix = SwigType_istemplate_templateprefix((yyvsp[(3) - (5)].str));
+ if ((yyvsp[-1].bases))
+ bases = Swig_make_inherit_list((yyvsp[-2].str),Getattr((yyvsp[-1].bases),"public"),Namespaceprefix);
+ prefix = SwigType_istemplate_templateprefix((yyvsp[-2].str));
if (prefix) {
String *fbase, *tbase;
if (Namespaceprefix) {
- fbase = NewStringf("%s::%s", Namespaceprefix,(yyvsp[(3) - (5)].str));
+ fbase = NewStringf("%s::%s", Namespaceprefix,(yyvsp[-2].str));
tbase = NewStringf("%s::%s", Namespaceprefix, prefix);
} else {
- fbase = Copy((yyvsp[(3) - (5)].str));
+ fbase = Copy((yyvsp[-2].str));
tbase = Copy(prefix);
}
Swig_name_inherit(tbase,fbase);
Delete(fbase);
Delete(tbase);
}
- if (strcmp((yyvsp[(2) - (5)].id),"class") == 0) {
+ if (strcmp((yyvsp[-3].id),"class") == 0) {
cplus_mode = CPLUS_PRIVATE;
} else {
cplus_mode = CPLUS_PUBLIC;
}
- Swig_symbol_newscope();
- Swig_symbol_setscopename((yyvsp[(3) - (5)].str));
- if (bases) {
- Iterator s;
- for (s = First(bases); s.item; s = Next(s)) {
- Symtab *st = Getattr(s.item,"symtab");
- if (st) {
- Setfile(st,Getfile(s.item));
- Setline(st,Getline(s.item));
- Swig_symbol_inherit(st);
- }
- }
- Delete(bases);
+ if (!cparse_cplusplus) {
+ set_scope_to_global();
}
+ Swig_symbol_newscope();
+ Swig_symbol_setscopename((yyvsp[-2].str));
+ Swig_inherit_base_symbols(bases);
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
cparse_start_line = cparse_line;
Delete(tpname);
}
}
- if (class_level >= max_class_levels) {
- if (!max_class_levels) {
- max_class_levels = 16;
- } else {
- max_class_levels *= 2;
- }
- class_decl = (Node**) realloc(class_decl, sizeof(Node*) * max_class_levels);
- if (!class_decl) {
- Swig_error(cparse_file, cparse_line, "realloc() failed\n");
- }
- }
- class_decl[class_level++] = (yyval.node);
Delete(prefix);
inclass = 1;
- }
+ currentOuterClass = (yyval.node);
+ if (cparse_cplusplusout) {
+ /* save the structure declaration to declare it in global scope for C++ to see */
+ code = get_raw_text_balanced('{', '}');
+ Setattr((yyval.node), "code", code);
+ Delete(code);
+ }
}
+#line 6965 "y.tab.c" /* yacc.c:1646 */
break;
- case 137:
-
-/* Line 1806 of yacc.c */
-#line 3576 "parser.y"
+ case 161:
+#line 3521 "parser.y" /* yacc.c:1646 */
{
- (void) (yyvsp[(6) - (9)].node);
- if (nested_template == 0) {
Node *p;
SwigType *ty;
- Symtab *cscope = prev_symtab;
+ Symtab *cscope;
Node *am = 0;
String *scpname = 0;
- (yyval.node) = class_decl[--class_level];
- inclass = 0;
+ (void) (yyvsp[-3].node);
+ (yyval.node) = currentOuterClass;
+ currentOuterClass = Getattr((yyval.node), "nested:outer");
+ nscope_inner = Getattr((yyval.node), "nested:innerscope");
+ nscope = Getattr((yyval.node), "nested:nscope");
+ Delattr((yyval.node), "nested:innerscope");
+ Delattr((yyval.node), "nested:nscope");
+ if (nscope_inner && Strcmp(nodeType(nscope_inner), "class") == 0) { /* actual parent class for this class */
+ Node* forward_declaration = Swig_symbol_clookup_no_inherit(Getattr((yyval.node),"name"), Getattr(nscope_inner, "symtab"));
+ if (forward_declaration) {
+ Setattr((yyval.node), "access", Getattr(forward_declaration, "access"));
+ }
+ Setattr((yyval.node), "nested:outer", nscope_inner);
+ SetFlag((yyval.node), "nested");
+ }
+ if (!currentOuterClass)
+ inclass = 0;
+ cscope = Getattr((yyval.node), "prev_symtab");
+ Delattr((yyval.node), "prev_symtab");
/* Check for pure-abstract class */
- Setattr((yyval.node),"abstracts", pure_abstracts((yyvsp[(7) - (9)].node)));
+ Setattr((yyval.node),"abstracts", pure_abstracts((yyvsp[-2].node)));
/* This bit of code merges in a previously defined %extend directive (if any) */
-
- if (extendhash) {
+ {
String *clsname = Swig_symbol_qualifiedscopename(0);
- am = Getattr(extendhash,clsname);
+ am = Getattr(Swig_extend_hash(), clsname);
if (am) {
- merge_extensions((yyval.node),am);
- Delattr(extendhash,clsname);
+ Swig_extend_merge((yyval.node), am);
+ Delattr(Swig_extend_hash(), clsname);
}
Delete(clsname);
}
if (!classes) classes = NewHash();
scpname = Swig_symbol_qualifiedscopename(0);
- Setattr(classes,scpname,(yyval.node));
+ Setattr(classes, scpname, (yyval.node));
- appendChild((yyval.node),(yyvsp[(7) - (9)].node));
+ appendChild((yyval.node), (yyvsp[-2].node));
- if (am) append_previous_extension((yyval.node),am);
-
- p = (yyvsp[(9) - (9)].node);
- if (p) {
- set_nextSibling((yyval.node),p);
+ if (am)
+ Swig_extend_append_previous((yyval.node), am);
+
+ p = (yyvsp[0].node);
+ if (p && !nscope_inner) {
+ if (!cparse_cplusplus && currentOuterClass)
+ appendChild(currentOuterClass, p);
+ else
+ appendSibling((yyval.node), p);
}
- if (cparse_cplusplus && !cparse_externc) {
- ty = NewString((yyvsp[(3) - (9)].str));
+ if (nscope_inner) {
+ ty = NewString(scpname); /* if the class is declared out of scope, let the declarator use fully qualified type*/
+ } else if (cparse_cplusplus && !cparse_externc) {
+ ty = NewString((yyvsp[-6].str));
} else {
- ty = NewStringf("%s %s", (yyvsp[(2) - (9)].id),(yyvsp[(3) - (9)].str));
+ ty = NewStringf("%s %s", (yyvsp[-7].id), (yyvsp[-6].str));
}
while (p) {
- Setattr(p,"storage",(yyvsp[(1) - (9)].id));
- Setattr(p,"type",ty);
- p = nextSibling(p);
- }
- /* Class typedefs */
- {
- String *name = (yyvsp[(3) - (9)].str);
- if ((yyvsp[(9) - (9)].node)) {
- SwigType *decltype = Getattr((yyvsp[(9) - (9)].node),"decl");
- if (Cmp((yyvsp[(1) - (9)].id),"typedef") == 0) {
- if (!decltype || !Len(decltype)) {
- String *cname;
- String *tdscopename;
- String *class_scope = Swig_symbol_qualifiedscopename(cscope);
- name = Getattr((yyvsp[(9) - (9)].node),"name");
- cname = Copy(name);
- Setattr((yyval.node),"tdname",cname);
- tdscopename = class_scope ? NewStringf("%s::%s", class_scope, name) : Copy(name);
-
- /* Use typedef name as class name */
- if (class_rename && (Strcmp(class_rename,(yyvsp[(3) - (9)].str)) == 0)) {
- Delete(class_rename);
- class_rename = NewString(name);
- }
- if (!classes_typedefs) classes_typedefs = NewHash();
- if (!Equal(scpname, tdscopename) && !Getattr(classes_typedefs, tdscopename)) {
- Setattr(classes_typedefs, tdscopename, (yyval.node));
- }
- Setattr((yyval.node),"decl",decltype);
- Delete(class_scope);
- Delete(cname);
- Delete(tdscopename);
- }
- }
+ Setattr(p, "storage", (yyvsp[-8].id));
+ Setattr(p, "type" ,ty);
+ if (!cparse_cplusplus && currentOuterClass && (!Getattr(currentOuterClass, "name"))) {
+ SetFlag(p, "hasconsttype");
+ SetFlag(p, "feature:immutable");
}
- appendChild((yyval.node),dump_nested(Char(name)));
+ p = nextSibling(p);
}
+ if ((yyvsp[0].node) && Cmp((yyvsp[-8].id),"typedef") == 0)
+ add_typedef_name((yyval.node), (yyvsp[0].node), (yyvsp[-6].str), cscope, scpname);
Delete(scpname);
if (cplus_mode != CPLUS_PUBLIC) {
/* we 'open' the class at the end, to allow %template
to add new members */
Node *pa = new_node("access");
- Setattr(pa,"kind","public");
+ Setattr(pa, "kind", "public");
cplus_mode = CPLUS_PUBLIC;
- appendChild((yyval.node),pa);
+ appendChild((yyval.node), pa);
Delete(pa);
}
-
- Setattr((yyval.node),"symtab",Swig_symbol_popscope());
-
- Classprefix = 0;
- if (nscope_inner) {
+ if (currentOuterClass)
+ restore_access_mode((yyval.node));
+ Setattr((yyval.node), "symtab", Swig_symbol_popscope());
+ Classprefix = Getattr((yyval.node), "Classprefix");
+ Delattr((yyval.node), "Classprefix");
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ if (cplus_mode == CPLUS_PRIVATE) {
+ (yyval.node) = 0; /* skip private nested classes */
+ } else if (cparse_cplusplus && currentOuterClass && ignore_nested_classes && !GetFlag((yyval.node), "feature:flatnested")) {
+ (yyval.node) = nested_forward_declaration((yyvsp[-8].id), (yyvsp[-7].id), (yyvsp[-6].str), Copy((yyvsp[-6].str)), (yyvsp[0].node));
+ } else if (nscope_inner) {
/* this is tricky */
/* we add the declaration in the original namespace */
- appendChild(nscope_inner,(yyval.node));
- Swig_symbol_setscope(Getattr(nscope_inner,"symtab"));
+ if (Strcmp(nodeType(nscope_inner), "class") == 0 && cparse_cplusplus && ignore_nested_classes && !GetFlag((yyval.node), "feature:flatnested"))
+ (yyval.node) = nested_forward_declaration((yyvsp[-8].id), (yyvsp[-7].id), (yyvsp[-6].str), Copy((yyvsp[-6].str)), (yyvsp[0].node));
+ appendChild(nscope_inner, (yyval.node));
+ Swig_symbol_setscope(Getattr(nscope_inner, "symtab"));
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ yyrename = Copy(Getattr((yyval.node), "class_rename"));
add_symbols((yyval.node));
- if (nscope) (yyval.node) = nscope;
+ Delattr((yyval.node), "class_rename");
/* but the variable definition in the current scope */
Swig_symbol_setscope(cscope);
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
- add_symbols((yyvsp[(9) - (9)].node));
+ add_symbols((yyvsp[0].node));
+ if (nscope) {
+ (yyval.node) = nscope; /* here we return recreated namespace tower instead of the class itself */
+ if ((yyvsp[0].node)) {
+ appendSibling((yyval.node), (yyvsp[0].node));
+ }
+ } else if (!SwigType_istemplate(ty) && template_parameters == 0) { /* for tempalte we need the class itself */
+ (yyval.node) = (yyvsp[0].node);
+ }
} else {
Delete(yyrename);
- yyrename = Copy(class_rename);
- Delete(Namespaceprefix);
- Namespaceprefix = Swig_symbol_qualifiedscopename(0);
-
- add_symbols((yyval.node));
- add_symbols((yyvsp[(9) - (9)].node));
+ yyrename = 0;
+ if (!cparse_cplusplus && currentOuterClass) { /* nested C structs go into global scope*/
+ Node *outer = currentOuterClass;
+ while (Getattr(outer, "nested:outer"))
+ outer = Getattr(outer, "nested:outer");
+ appendSibling(outer, (yyval.node));
+ add_symbols((yyvsp[0].node));
+ set_scope_to_global();
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ yyrename = Copy(Getattr((yyval.node), "class_rename"));
+ add_symbols((yyval.node));
+ if (!cparse_cplusplusout)
+ Delattr((yyval.node), "nested:outer");
+ Delattr((yyval.node), "class_rename");
+ (yyval.node) = 0;
+ } else {
+ yyrename = Copy(Getattr((yyval.node), "class_rename"));
+ add_symbols((yyval.node));
+ add_symbols((yyvsp[0].node));
+ Delattr((yyval.node), "class_rename");
+ }
}
+ Delete(ty);
Swig_symbol_setscope(cscope);
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
- } else {
- (yyval.node) = new_node("class");
- Setattr((yyval.node),"kind",(yyvsp[(2) - (9)].id));
- Setattr((yyval.node),"name",NewString((yyvsp[(3) - (9)].str)));
- SetFlag((yyval.node),"nestedtemplateclass");
- }
+ Classprefix = currentOuterClass ? Getattr(currentOuterClass, "Classprefix") : 0;
}
+#line 7122 "y.tab.c" /* yacc.c:1646 */
break;
- case 138:
-
-/* Line 1806 of yacc.c */
-#line 3708 "parser.y"
+ case 162:
+#line 3676 "parser.y" /* yacc.c:1646 */
{
String *unnamed;
+ String *code;
unnamed = make_unnamed();
(yyval.node) = new_node("class");
Setline((yyval.node),cparse_start_line);
- Setattr((yyval.node),"kind",(yyvsp[(2) - (3)].id));
- Setattr((yyval.node),"storage",(yyvsp[(1) - (3)].id));
+ Setattr((yyval.node),"kind",(yyvsp[-2].id));
+ if ((yyvsp[-1].bases)) {
+ Setattr((yyval.node),"baselist", Getattr((yyvsp[-1].bases),"public"));
+ Setattr((yyval.node),"protectedbaselist", Getattr((yyvsp[-1].bases),"protected"));
+ Setattr((yyval.node),"privatebaselist", Getattr((yyvsp[-1].bases),"private"));
+ }
+ Setattr((yyval.node),"storage",(yyvsp[-3].id));
Setattr((yyval.node),"unnamed",unnamed);
Setattr((yyval.node),"allows_typedef","1");
- Delete(class_rename);
- class_rename = make_name((yyval.node),0,0);
- if (strcmp((yyvsp[(2) - (3)].id),"class") == 0) {
+ if (currentOuterClass) {
+ SetFlag((yyval.node), "nested");
+ Setattr((yyval.node), "nested:outer", currentOuterClass);
+ set_access_mode((yyval.node));
+ }
+ Swig_features_get(Swig_cparse_features(), Namespaceprefix, 0, 0, (yyval.node));
+ /* save yyrename to the class attribute, to be used later in add_symbols()*/
+ Setattr((yyval.node), "class_rename", make_name((yyval.node),0,0));
+ if (strcmp((yyvsp[-2].id),"class") == 0) {
cplus_mode = CPLUS_PRIVATE;
} else {
cplus_mode = CPLUS_PUBLIC;
}
Swig_symbol_newscope();
cparse_start_line = cparse_line;
- if (class_level >= max_class_levels) {
- if (!max_class_levels) {
- max_class_levels = 16;
- } else {
- max_class_levels *= 2;
- }
- class_decl = (Node**) realloc(class_decl, sizeof(Node*) * max_class_levels);
- if (!class_decl) {
- Swig_error(cparse_file, cparse_line, "realloc() failed\n");
- }
- }
- class_decl[class_level++] = (yyval.node);
+ currentOuterClass = (yyval.node);
inclass = 1;
- Classprefix = NewStringEmpty();
+ Classprefix = 0;
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
- }
+ /* save the structure declaration to make a typedef for it later*/
+ code = get_raw_text_balanced('{', '}');
+ Setattr((yyval.node), "code", code);
+ Delete(code);
+ }
+#line 7167 "y.tab.c" /* yacc.c:1646 */
break;
- case 139:
-
-/* Line 1806 of yacc.c */
-#line 3742 "parser.y"
+ case 163:
+#line 3715 "parser.y" /* yacc.c:1646 */
{
String *unnamed;
+ List *bases = 0;
+ String *name = 0;
Node *n;
- (void) (yyvsp[(4) - (9)].node);
Classprefix = 0;
- (yyval.node) = class_decl[--class_level];
- inclass = 0;
+ (void)(yyvsp[-3].node);
+ (yyval.node) = currentOuterClass;
+ currentOuterClass = Getattr((yyval.node), "nested:outer");
+ if (!currentOuterClass)
+ inclass = 0;
+ else
+ restore_access_mode((yyval.node));
unnamed = Getattr((yyval.node),"unnamed");
-
- /* Check for pure-abstract class */
- Setattr((yyval.node),"abstracts", pure_abstracts((yyvsp[(5) - (9)].node)));
-
- n = new_node("cdecl");
- Setattr(n,"name",(yyvsp[(7) - (9)].decl).id);
- Setattr(n,"unnamed",unnamed);
- Setattr(n,"type",unnamed);
- Setattr(n,"decl",(yyvsp[(7) - (9)].decl).type);
- Setattr(n,"parms",(yyvsp[(7) - (9)].decl).parms);
- Setattr(n,"storage",(yyvsp[(1) - (9)].id));
- if ((yyvsp[(9) - (9)].node)) {
- Node *p = (yyvsp[(9) - (9)].node);
- set_nextSibling(n,p);
- while (p) {
- String *type = Copy(unnamed);
- Setattr(p,"name",(yyvsp[(7) - (9)].decl).id);
- Setattr(p,"unnamed",unnamed);
- Setattr(p,"type",type);
- Delete(type);
- Setattr(p,"storage",(yyvsp[(1) - (9)].id));
- p = nextSibling(p);
- }
- }
- set_nextSibling((yyval.node),n);
- Delete(n);
- {
+ /* Check for pure-abstract class */
+ Setattr((yyval.node),"abstracts", pure_abstracts((yyvsp[-2].node)));
+ n = (yyvsp[0].node);
+ if (cparse_cplusplus && currentOuterClass && ignore_nested_classes && !GetFlag((yyval.node), "feature:flatnested")) {
+ String *name = n ? Copy(Getattr(n, "name")) : 0;
+ (yyval.node) = nested_forward_declaration((yyvsp[-7].id), (yyvsp[-6].id), 0, name, n);
+ Swig_symbol_popscope();
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ } else if (n) {
+ appendSibling((yyval.node),n);
/* If a proper typedef name was given, we'll use it to set the scope name */
- String *name = 0;
- if ((yyvsp[(1) - (9)].id) && (strcmp((yyvsp[(1) - (9)].id),"typedef") == 0)) {
- if (!Len((yyvsp[(7) - (9)].decl).type)) {
- String *scpname = 0;
- name = (yyvsp[(7) - (9)].decl).id;
- Setattr((yyval.node),"tdname",name);
- Setattr((yyval.node),"name",name);
- Swig_symbol_setscopename(name);
+ name = try_to_find_a_name_for_unnamed_structure((yyvsp[-7].id), n);
+ if (name) {
+ String *scpname = 0;
+ SwigType *ty;
+ Setattr((yyval.node),"tdname",name);
+ Setattr((yyval.node),"name",name);
+ Swig_symbol_setscopename(name);
+ if ((yyvsp[-5].bases))
+ bases = Swig_make_inherit_list(name,Getattr((yyvsp[-5].bases),"public"),Namespaceprefix);
+ Swig_inherit_base_symbols(bases);
/* If a proper name was given, we use that as the typedef, not unnamed */
- Clear(unnamed);
- Append(unnamed, name);
-
+ Clear(unnamed);
+ Append(unnamed, name);
+ if (cparse_cplusplus && !cparse_externc) {
+ ty = NewString(name);
+ } else {
+ ty = NewStringf("%s %s", (yyvsp[-6].id),name);
+ }
+ while (n) {
+ Setattr(n,"storage",(yyvsp[-7].id));
+ Setattr(n, "type", ty);
+ if (!cparse_cplusplus && currentOuterClass && (!Getattr(currentOuterClass, "name"))) {
+ SetFlag(n,"hasconsttype");
+ SetFlag(n,"feature:immutable");
+ }
n = nextSibling(n);
- set_nextSibling((yyval.node),n);
-
- /* Check for previous extensions */
- if (extendhash) {
- String *clsname = Swig_symbol_qualifiedscopename(0);
- Node *am = Getattr(extendhash,clsname);
- if (am) {
- /* Merge the extension into the symbol table */
- merge_extensions((yyval.node),am);
- append_previous_extension((yyval.node),am);
- Delattr(extendhash,clsname);
- }
- Delete(clsname);
+ }
+ n = (yyvsp[0].node);
+
+ /* Check for previous extensions */
+ {
+ String *clsname = Swig_symbol_qualifiedscopename(0);
+ Node *am = Getattr(Swig_extend_hash(),clsname);
+ if (am) {
+ /* Merge the extension into the symbol table */
+ Swig_extend_merge((yyval.node),am);
+ Swig_extend_append_previous((yyval.node),am);
+ Delattr(Swig_extend_hash(),clsname);
}
- if (!classes) classes = NewHash();
- scpname = Swig_symbol_qualifiedscopename(0);
- Setattr(classes,scpname,(yyval.node));
- Delete(scpname);
- } else {
- Swig_symbol_setscopename("<unnamed>");
+ Delete(clsname);
+ }
+ if (!classes) classes = NewHash();
+ scpname = Swig_symbol_qualifiedscopename(0);
+ Setattr(classes,scpname,(yyval.node));
+ Delete(scpname);
+ } else { /* no suitable name was found for a struct */
+ Setattr((yyval.node), "nested:unnamed", Getattr(n, "name")); /* save the name of the first declarator for later use in name generation*/
+ while (n) { /* attach unnamed struct to the declarators, so that they would receive proper type later*/
+ Setattr(n, "nested:unnamedtype", (yyval.node));
+ Setattr(n, "storage", (yyvsp[-7].id));
+ n = nextSibling(n);
}
+ n = (yyvsp[0].node);
+ Swig_symbol_setscopename("<unnamed>");
}
- appendChild((yyval.node),(yyvsp[(5) - (9)].node));
- appendChild((yyval.node),dump_nested(Char(name)));
- }
- /* Pop the scope */
- Setattr((yyval.node),"symtab",Swig_symbol_popscope());
- if (class_rename) {
- Delete(yyrename);
- yyrename = NewString(class_rename);
+ appendChild((yyval.node),(yyvsp[-2].node));
+ /* Pop the scope */
+ Setattr((yyval.node),"symtab",Swig_symbol_popscope());
+ if (name) {
+ Delete(yyrename);
+ yyrename = Copy(Getattr((yyval.node), "class_rename"));
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ add_symbols((yyval.node));
+ add_symbols(n);
+ Delattr((yyval.node), "class_rename");
+ }else if (cparse_cplusplus)
+ (yyval.node) = 0; /* ignore unnamed structs for C++ */
+ Delete(unnamed);
+ } else { /* unnamed struct w/o declarator*/
+ Swig_symbol_popscope();
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ add_symbols((yyvsp[-2].node));
+ Delete((yyval.node));
+ (yyval.node) = (yyvsp[-2].node); /* pass member list to outer class/namespace (instead of self)*/
}
- Delete(Namespaceprefix);
- Namespaceprefix = Swig_symbol_qualifiedscopename(0);
- add_symbols((yyval.node));
- add_symbols(n);
- Delete(unnamed);
+ Classprefix = currentOuterClass ? Getattr(currentOuterClass, "Classprefix") : 0;
}
+#line 7278 "y.tab.c" /* yacc.c:1646 */
break;
- case 140:
-
-/* Line 1806 of yacc.c */
-#line 3831 "parser.y"
+ case 164:
+#line 3823 "parser.y" /* yacc.c:1646 */
{ (yyval.node) = 0; }
+#line 7284 "y.tab.c" /* yacc.c:1646 */
break;
- case 141:
-
-/* Line 1806 of yacc.c */
-#line 3832 "parser.y"
+ case 165:
+#line 3824 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("cdecl");
- Setattr((yyval.node),"name",(yyvsp[(1) - (3)].decl).id);
- Setattr((yyval.node),"decl",(yyvsp[(1) - (3)].decl).type);
- Setattr((yyval.node),"parms",(yyvsp[(1) - (3)].decl).parms);
- set_nextSibling((yyval.node),(yyvsp[(3) - (3)].node));
+ Setattr((yyval.node),"name",(yyvsp[-2].decl).id);
+ Setattr((yyval.node),"decl",(yyvsp[-2].decl).type);
+ Setattr((yyval.node),"parms",(yyvsp[-2].decl).parms);
+ set_nextSibling((yyval.node),(yyvsp[0].node));
}
+#line 7296 "y.tab.c" /* yacc.c:1646 */
break;
- case 142:
-
-/* Line 1806 of yacc.c */
-#line 3844 "parser.y"
+ case 166:
+#line 3836 "parser.y" /* yacc.c:1646 */
{
- if ((yyvsp[(1) - (4)].id) && (Strcmp((yyvsp[(1) - (4)].id),"friend") == 0)) {
+ if ((yyvsp[-3].id) && (Strcmp((yyvsp[-3].id),"friend") == 0)) {
/* Ignore */
(yyval.node) = 0;
} else {
(yyval.node) = new_node("classforward");
- Setattr((yyval.node),"kind",(yyvsp[(2) - (4)].id));
- Setattr((yyval.node),"name",(yyvsp[(3) - (4)].str));
+ Setattr((yyval.node),"kind",(yyvsp[-2].id));
+ Setattr((yyval.node),"name",(yyvsp[-1].str));
Setattr((yyval.node),"sym:weak", "1");
add_symbols((yyval.node));
}
}
+#line 7313 "y.tab.c" /* yacc.c:1646 */
break;
- case 143:
-
-/* Line 1806 of yacc.c */
-#line 3862 "parser.y"
+ case 167:
+#line 3854 "parser.y" /* yacc.c:1646 */
{
- template_parameters = (yyvsp[(3) - (4)].tparms);
- if (inclass)
- nested_template++;
-
+ if (currentOuterClass)
+ Setattr(currentOuterClass, "template_parameters", template_parameters);
+ template_parameters = (yyvsp[-1].tparms);
}
+#line 7323 "y.tab.c" /* yacc.c:1646 */
break;
- case 144:
-
-/* Line 1806 of yacc.c */
-#line 3867 "parser.y"
- {
-
- /* Don't ignore templated functions declared within a class, unless the templated function is within a nested class */
- if (nested_template <= 1) {
- int is_nested_template_class = (yyvsp[(6) - (6)].node) && GetFlag((yyvsp[(6) - (6)].node), "nestedtemplateclass");
- if (is_nested_template_class) {
- (yyval.node) = 0;
- /* Nested template classes would probably better be ignored like ordinary nested classes using cpp_nested, but that introduces shift/reduce conflicts */
- if (cplus_mode == CPLUS_PUBLIC) {
- /* Treat the nested class/struct/union as a forward declaration until a proper nested class solution is implemented */
- String *kind = Getattr((yyvsp[(6) - (6)].node), "kind");
- String *name = Getattr((yyvsp[(6) - (6)].node), "name");
- (yyval.node) = new_node("template");
- Setattr((yyval.node),"kind",kind);
- Setattr((yyval.node),"name",name);
- Setattr((yyval.node),"sym:weak", "1");
- Setattr((yyval.node),"templatetype","classforward");
- Setattr((yyval.node),"templateparms", (yyvsp[(3) - (6)].tparms));
- add_symbols((yyval.node));
-
- if (GetFlag((yyval.node), "feature:nestedworkaround")) {
- Swig_symbol_remove((yyval.node));
- (yyval.node) = 0;
- } else {
- SWIG_WARN_NODE_BEGIN((yyval.node));
- Swig_warning(WARN_PARSE_NAMED_NESTED_CLASS, cparse_file, cparse_line, "Nested template %s not currently supported (%s ignored).\n", kind, name);
- SWIG_WARN_NODE_END((yyval.node));
- }
- }
- Delete((yyvsp[(6) - (6)].node));
- } else {
+ case 168:
+#line 3858 "parser.y" /* yacc.c:1646 */
+ {
String *tname = 0;
int error = 0;
/* check if we get a namespace node with a class declaration, and retrieve the class */
Symtab *cscope = Swig_symbol_current();
Symtab *sti = 0;
- Node *ntop = (yyvsp[(6) - (6)].node);
+ Node *ntop = (yyvsp[0].node);
Node *ni = ntop;
SwigType *ntype = ni ? nodeType(ni) : 0;
while (ni && Strcmp(ntype,"namespace") == 0) {
Swig_symbol_setscope(sti);
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
- (yyvsp[(6) - (6)].node) = ni;
+ (yyvsp[0].node) = ni;
}
- (yyval.node) = (yyvsp[(6) - (6)].node);
+ (yyval.node) = (yyvsp[0].node);
if ((yyval.node)) tname = Getattr((yyval.node),"name");
/* Check if the class is a template specialization */
Setattr((yyval.node),"templatetype",nodeType((yyval.node)));
set_nodeType((yyval.node),"template");
/* Template partial specialization */
- if (tempn && ((yyvsp[(3) - (6)].tparms)) && ((yyvsp[(6) - (6)].node))) {
+ if (tempn && ((yyvsp[-3].tparms)) && ((yyvsp[0].node))) {
List *tlist;
String *targs = SwigType_templateargs(tname);
tlist = SwigType_parmlist(targs);
int i, nargs;
Parm *tp = CopyParmList(Getattr(tempn,"templateparms"));
nargs = Len(tlist);
- p = (yyvsp[(3) - (6)].tparms);
+ p = (yyvsp[-3].tparms);
while (p) {
for (i = 0; i < nargs; i++){
pn = Getattr(p,"name");
if (tempn) {
Parm *p,*p1;
ParmList *tp = CopyParmList(Getattr(tempn,"templateparms"));
- p = (yyvsp[(3) - (6)].tparms);
+ p = (yyvsp[-3].tparms);
p1 = tp;
while (p && p1) {
String *pn = Getattr(p,"name");
Setattr((yyval.node),"templateparms",tp);
Delete(tp);
} else {
- Setattr((yyval.node),"templateparms",(yyvsp[(3) - (6)].tparms));
+ Setattr((yyval.node),"templateparms",(yyvsp[-3].tparms));
}
#endif
Delattr((yyval.node),"specialization");
Setattr((yyval.node),"partialspecialization","1");
/* Create a specialized name for matching */
{
- Parm *p = (yyvsp[(3) - (6)].tparms);
+ Parm *p = (yyvsp[-3].tparms);
String *fname = NewString(Getattr((yyval.node),"name"));
String *ffname = 0;
ParmList *partialparms = 0;
Delete(fname);
}
} else if ((yyval.node)) {
- Setattr((yyval.node),"templatetype",nodeType((yyvsp[(6) - (6)].node)));
+ Setattr((yyval.node),"templatetype",nodeType((yyvsp[0].node)));
set_nodeType((yyval.node),"template");
- Setattr((yyval.node),"templateparms", (yyvsp[(3) - (6)].tparms));
+ Setattr((yyval.node),"templateparms", (yyvsp[-3].tparms));
if (!Getattr((yyval.node),"sym:weak")) {
Setattr((yyval.node),"sym:typename","1");
}
{
Parm *p;
String *fname = NewStringf("%s<(", Getattr((yyval.node),"name"));
- p = (yyvsp[(3) - (6)].tparms);
+ p = (yyvsp[-3].tparms);
while (p) {
String *n = Getattr(p,"name");
if (!n) n = Getattr(p,"type");
Swig_symbol_setscope(cscope);
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
- if (error) (yyval.node) = 0;
- }
- } else {
- (yyval.node) = 0;
- }
- template_parameters = 0;
- if (inclass)
- nested_template--;
- }
+ if (error || (nscope_inner && Strcmp(nodeType(nscope_inner), "class") == 0)) {
+ (yyval.node) = 0;
+ }
+ if (currentOuterClass)
+ template_parameters = Getattr(currentOuterClass, "template_parameters");
+ else
+ template_parameters = 0;
+ }
+#line 7581 "y.tab.c" /* yacc.c:1646 */
break;
- case 145:
+ case 169:
+#line 4113 "parser.y" /* yacc.c:1646 */
+ {
+ Swig_warning(WARN_PARSE_EXPLICIT_TEMPLATE, cparse_file, cparse_line, "Explicit template instantiation ignored.\n");
+ (yyval.node) = 0;
+ }
+#line 7590 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4151 "parser.y"
+ case 170:
+#line 4119 "parser.y" /* yacc.c:1646 */
{
Swig_warning(WARN_PARSE_EXPLICIT_TEMPLATE, cparse_file, cparse_line, "Explicit template instantiation ignored.\n");
- (yyval.node) = 0;
+ (yyval.node) = 0;
}
+#line 7599 "y.tab.c" /* yacc.c:1646 */
break;
- case 146:
-
-/* Line 1806 of yacc.c */
-#line 4157 "parser.y"
+ case 171:
+#line 4125 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(1) - (1)].node);
+ (yyval.node) = (yyvsp[0].node);
}
+#line 7607 "y.tab.c" /* yacc.c:1646 */
break;
- case 147:
-
-/* Line 1806 of yacc.c */
-#line 4160 "parser.y"
+ case 172:
+#line 4128 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(1) - (1)].node);
+ (yyval.node) = (yyvsp[0].node);
}
+#line 7615 "y.tab.c" /* yacc.c:1646 */
break;
- case 148:
-
-/* Line 1806 of yacc.c */
-#line 4163 "parser.y"
+ case 173:
+#line 4131 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(1) - (1)].node);
+ (yyval.node) = (yyvsp[0].node);
}
+#line 7623 "y.tab.c" /* yacc.c:1646 */
break;
- case 149:
+ case 174:
+#line 4134 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.node) = (yyvsp[0].node);
+ }
+#line 7631 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4166 "parser.y"
+ case 175:
+#line 4137 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = 0;
}
+#line 7639 "y.tab.c" /* yacc.c:1646 */
break;
- case 150:
-
-/* Line 1806 of yacc.c */
-#line 4169 "parser.y"
+ case 176:
+#line 4140 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(1) - (1)].node);
+ (yyval.node) = (yyvsp[0].node);
}
+#line 7647 "y.tab.c" /* yacc.c:1646 */
break;
- case 151:
-
-/* Line 1806 of yacc.c */
-#line 4172 "parser.y"
+ case 177:
+#line 4143 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(1) - (1)].node);
+ (yyval.node) = (yyvsp[0].node);
}
+#line 7655 "y.tab.c" /* yacc.c:1646 */
break;
- case 152:
-
-/* Line 1806 of yacc.c */
-#line 4177 "parser.y"
+ case 178:
+#line 4148 "parser.y" /* yacc.c:1646 */
{
/* Rip out the parameter names */
- Parm *p = (yyvsp[(1) - (1)].pl);
- (yyval.tparms) = (yyvsp[(1) - (1)].pl);
+ Parm *p = (yyvsp[0].pl);
+ (yyval.tparms) = (yyvsp[0].pl);
while (p) {
String *name = Getattr(p,"name");
if ((strncmp(type,"class ",6) == 0) || (strncmp(type,"typename ", 9) == 0)) {
char *t = strchr(type,' ');
Setattr(p,"name", t+1);
+ } else
+ /* Variadic template args */
+ if ((strncmp(type,"class... ",9) == 0) || (strncmp(type,"typename... ", 12) == 0)) {
+ char *t = strchr(type,' ');
+ Setattr(p,"name", t+1);
+ Setattr(p,"variadic", "1");
} else {
/*
Swig_error(cparse_file, cparse_line, "Missing template parameter name\n");
p = nextSibling(p);
}
}
+#line 7694 "y.tab.c" /* yacc.c:1646 */
break;
- case 153:
-
-/* Line 1806 of yacc.c */
-#line 4207 "parser.y"
+ case 179:
+#line 4184 "parser.y" /* yacc.c:1646 */
{
- set_nextSibling((yyvsp[(1) - (2)].p),(yyvsp[(2) - (2)].pl));
- (yyval.pl) = (yyvsp[(1) - (2)].p);
+ set_nextSibling((yyvsp[-1].p),(yyvsp[0].pl));
+ (yyval.pl) = (yyvsp[-1].p);
}
+#line 7703 "y.tab.c" /* yacc.c:1646 */
break;
- case 154:
-
-/* Line 1806 of yacc.c */
-#line 4211 "parser.y"
+ case 180:
+#line 4188 "parser.y" /* yacc.c:1646 */
{ (yyval.pl) = 0; }
+#line 7709 "y.tab.c" /* yacc.c:1646 */
break;
- case 155:
-
-/* Line 1806 of yacc.c */
-#line 4214 "parser.y"
+ case 181:
+#line 4191 "parser.y" /* yacc.c:1646 */
{
- (yyval.p) = NewParmWithoutFileLineInfo(NewString((yyvsp[(1) - (1)].id)), 0);
+ (yyval.p) = NewParmWithoutFileLineInfo(NewString((yyvsp[0].id)), 0);
}
+#line 7717 "y.tab.c" /* yacc.c:1646 */
break;
- case 156:
-
-/* Line 1806 of yacc.c */
-#line 4217 "parser.y"
+ case 182:
+#line 4194 "parser.y" /* yacc.c:1646 */
{
- (yyval.p) = (yyvsp[(1) - (1)].p);
+ (yyval.p) = (yyvsp[0].p);
}
+#line 7725 "y.tab.c" /* yacc.c:1646 */
break;
- case 157:
-
-/* Line 1806 of yacc.c */
-#line 4222 "parser.y"
+ case 183:
+#line 4199 "parser.y" /* yacc.c:1646 */
{
- set_nextSibling((yyvsp[(2) - (3)].p),(yyvsp[(3) - (3)].pl));
- (yyval.pl) = (yyvsp[(2) - (3)].p);
+ set_nextSibling((yyvsp[-1].p),(yyvsp[0].pl));
+ (yyval.pl) = (yyvsp[-1].p);
}
+#line 7734 "y.tab.c" /* yacc.c:1646 */
break;
- case 158:
-
-/* Line 1806 of yacc.c */
-#line 4226 "parser.y"
+ case 184:
+#line 4203 "parser.y" /* yacc.c:1646 */
{ (yyval.pl) = 0; }
+#line 7740 "y.tab.c" /* yacc.c:1646 */
break;
- case 159:
-
-/* Line 1806 of yacc.c */
-#line 4231 "parser.y"
+ case 185:
+#line 4208 "parser.y" /* yacc.c:1646 */
{
- String *uname = Swig_symbol_type_qualify((yyvsp[(2) - (3)].str),0);
- String *name = Swig_scopename_last((yyvsp[(2) - (3)].str));
+ String *uname = Swig_symbol_type_qualify((yyvsp[-1].str),0);
+ String *name = Swig_scopename_last((yyvsp[-1].str));
(yyval.node) = new_node("using");
Setattr((yyval.node),"uname",uname);
Setattr((yyval.node),"name", name);
Delete(name);
add_symbols((yyval.node));
}
+#line 7755 "y.tab.c" /* yacc.c:1646 */
break;
- case 160:
-
-/* Line 1806 of yacc.c */
-#line 4241 "parser.y"
+ case 186:
+#line 4218 "parser.y" /* yacc.c:1646 */
{
- Node *n = Swig_symbol_clookup((yyvsp[(3) - (4)].str),0);
+ Node *n = Swig_symbol_clookup((yyvsp[-1].str),0);
if (!n) {
- Swig_error(cparse_file, cparse_line, "Nothing known about namespace '%s'\n", (yyvsp[(3) - (4)].str));
+ Swig_error(cparse_file, cparse_line, "Nothing known about namespace '%s'\n", (yyvsp[-1].str));
(yyval.node) = 0;
} else {
Symtab *symtab = Getattr(n,"symtab");
(yyval.node) = new_node("using");
Setattr((yyval.node),"node",n);
- Setattr((yyval.node),"namespace", (yyvsp[(3) - (4)].str));
+ Setattr((yyval.node),"namespace", (yyvsp[-1].str));
if (current != symtab) {
Swig_symbol_inherit(symtab);
}
} else {
- Swig_error(cparse_file, cparse_line, "'%s' is not a namespace.\n", (yyvsp[(3) - (4)].str));
+ Swig_error(cparse_file, cparse_line, "'%s' is not a namespace.\n", (yyvsp[-1].str));
(yyval.node) = 0;
}
} else {
}
}
}
+#line 7789 "y.tab.c" /* yacc.c:1646 */
break;
- case 161:
-
-/* Line 1806 of yacc.c */
-#line 4272 "parser.y"
+ case 187:
+#line 4249 "parser.y" /* yacc.c:1646 */
{
Hash *h;
- (yyvsp[(1) - (3)].node) = Swig_symbol_current();
- h = Swig_symbol_clookup((yyvsp[(2) - (3)].str),0);
- if (h && ((yyvsp[(1) - (3)].node) == Getattr(h,"sym:symtab")) && (Strcmp(nodeType(h),"namespace") == 0)) {
+ (yyvsp[-2].node) = Swig_symbol_current();
+ h = Swig_symbol_clookup((yyvsp[-1].str),0);
+ if (h && ((yyvsp[-2].node) == Getattr(h,"sym:symtab")) && (Strcmp(nodeType(h),"namespace") == 0)) {
if (Getattr(h,"alias")) {
h = Getattr(h,"namespace");
Swig_warning(WARN_PARSE_NAMESPACE_ALIAS, cparse_file, cparse_line, "Namespace alias '%s' not allowed here. Assuming '%s'\n",
- (yyvsp[(2) - (3)].str), Getattr(h,"name"));
- (yyvsp[(2) - (3)].str) = Getattr(h,"name");
+ (yyvsp[-1].str), Getattr(h,"name"));
+ (yyvsp[-1].str) = Getattr(h,"name");
}
Swig_symbol_setscope(Getattr(h,"symtab"));
} else {
Swig_symbol_newscope();
- Swig_symbol_setscopename((yyvsp[(2) - (3)].str));
+ Swig_symbol_setscopename((yyvsp[-1].str));
}
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
}
+#line 7813 "y.tab.c" /* yacc.c:1646 */
break;
- case 162:
-
-/* Line 1806 of yacc.c */
-#line 4290 "parser.y"
+ case 188:
+#line 4267 "parser.y" /* yacc.c:1646 */
{
- Node *n = (yyvsp[(5) - (6)].node);
+ Node *n = (yyvsp[-1].node);
set_nodeType(n,"namespace");
- Setattr(n,"name",(yyvsp[(2) - (6)].str));
+ Setattr(n,"name",(yyvsp[-4].str));
Setattr(n,"symtab", Swig_symbol_popscope());
- Swig_symbol_setscope((yyvsp[(1) - (6)].node));
+ Swig_symbol_setscope((yyvsp[-5].node));
(yyval.node) = n;
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
add_symbols((yyval.node));
}
+#line 7829 "y.tab.c" /* yacc.c:1646 */
break;
- case 163:
-
-/* Line 1806 of yacc.c */
-#line 4301 "parser.y"
+ case 189:
+#line 4278 "parser.y" /* yacc.c:1646 */
{
Hash *h;
- (yyvsp[(1) - (2)].node) = Swig_symbol_current();
- h = Swig_symbol_clookup((char *)" ",0);
+ (yyvsp[-1].node) = Swig_symbol_current();
+ h = Swig_symbol_clookup(" ",0);
if (h && (Strcmp(nodeType(h),"namespace") == 0)) {
Swig_symbol_setscope(Getattr(h,"symtab"));
} else {
}
Namespaceprefix = 0;
}
+#line 7847 "y.tab.c" /* yacc.c:1646 */
break;
- case 164:
-
-/* Line 1806 of yacc.c */
-#line 4313 "parser.y"
+ case 190:
+#line 4290 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(4) - (5)].node);
+ (yyval.node) = (yyvsp[-1].node);
set_nodeType((yyval.node),"namespace");
Setattr((yyval.node),"unnamed","1");
Setattr((yyval.node),"symtab", Swig_symbol_popscope());
- Swig_symbol_setscope((yyvsp[(1) - (5)].node));
+ Swig_symbol_setscope((yyvsp[-4].node));
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
add_symbols((yyval.node));
}
+#line 7862 "y.tab.c" /* yacc.c:1646 */
break;
- case 165:
-
-/* Line 1806 of yacc.c */
-#line 4323 "parser.y"
+ case 191:
+#line 4300 "parser.y" /* yacc.c:1646 */
{
/* Namespace alias */
Node *n;
(yyval.node) = new_node("namespace");
- Setattr((yyval.node),"name",(yyvsp[(2) - (5)].id));
- Setattr((yyval.node),"alias",(yyvsp[(4) - (5)].str));
- n = Swig_symbol_clookup((yyvsp[(4) - (5)].str),0);
+ Setattr((yyval.node),"name",(yyvsp[-3].id));
+ Setattr((yyval.node),"alias",(yyvsp[-1].str));
+ n = Swig_symbol_clookup((yyvsp[-1].str),0);
if (!n) {
- Swig_error(cparse_file, cparse_line, "Unknown namespace '%s'\n", (yyvsp[(4) - (5)].str));
+ Swig_error(cparse_file, cparse_line, "Unknown namespace '%s'\n", (yyvsp[-1].str));
(yyval.node) = 0;
} else {
if (Strcmp(nodeType(n),"namespace") != 0) {
- Swig_error(cparse_file, cparse_line, "'%s' is not a namespace\n",(yyvsp[(4) - (5)].str));
+ Swig_error(cparse_file, cparse_line, "'%s' is not a namespace\n",(yyvsp[-1].str));
(yyval.node) = 0;
} else {
while (Getattr(n,"alias")) {
Setattr((yyval.node),"namespace",n);
add_symbols((yyval.node));
/* Set up a scope alias */
- Swig_symbol_alias((yyvsp[(2) - (5)].id),Getattr(n,"symtab"));
+ Swig_symbol_alias((yyvsp[-3].id),Getattr(n,"symtab"));
}
}
}
+#line 7892 "y.tab.c" /* yacc.c:1646 */
break;
- case 166:
-
-/* Line 1806 of yacc.c */
-#line 4350 "parser.y"
+ case 192:
+#line 4327 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(1) - (2)].node);
+ (yyval.node) = (yyvsp[-1].node);
/* Insert cpp_member (including any siblings) to the front of the cpp_members linked list */
if ((yyval.node)) {
Node *p = (yyval.node);
pp = p;
p = nextSibling(p);
}
- set_nextSibling(pp,(yyvsp[(2) - (2)].node));
+ set_nextSibling(pp,(yyvsp[0].node));
+ if ((yyvsp[0].node))
+ set_previousSibling((yyvsp[0].node), pp);
} else {
- (yyval.node) = (yyvsp[(2) - (2)].node);
+ (yyval.node) = (yyvsp[0].node);
}
}
+#line 7914 "y.tab.c" /* yacc.c:1646 */
break;
- case 167:
-
-/* Line 1806 of yacc.c */
-#line 4365 "parser.y"
+ case 193:
+#line 4344 "parser.y" /* yacc.c:1646 */
{
- if (cplus_mode != CPLUS_PUBLIC) {
- Swig_error(cparse_file,cparse_line,"%%extend can only be used in a public section\n");
- }
+ extendmode = 1;
+ if (cplus_mode != CPLUS_PUBLIC) {
+ Swig_error(cparse_file,cparse_line,"%%extend can only be used in a public section\n");
+ }
}
+#line 7925 "y.tab.c" /* yacc.c:1646 */
break;
- case 168:
+ case 194:
+#line 4349 "parser.y" /* yacc.c:1646 */
+ {
+ extendmode = 0;
+ }
+#line 7933 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4369 "parser.y"
+ case 195:
+#line 4351 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("extend");
- tag_nodes((yyvsp[(4) - (6)].node),"feature:extend",(char*) "1");
- appendChild((yyval.node),(yyvsp[(4) - (6)].node));
- set_nextSibling((yyval.node),(yyvsp[(6) - (6)].node));
+ mark_nodes_as_extend((yyvsp[-3].node));
+ appendChild((yyval.node),(yyvsp[-3].node));
+ set_nextSibling((yyval.node),(yyvsp[0].node));
}
+#line 7944 "y.tab.c" /* yacc.c:1646 */
break;
- case 169:
-
-/* Line 1806 of yacc.c */
-#line 4375 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 196:
+#line 4357 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 7950 "y.tab.c" /* yacc.c:1646 */
break;
- case 170:
-
-/* Line 1806 of yacc.c */
-#line 4376 "parser.y"
+ case 197:
+#line 4358 "parser.y" /* yacc.c:1646 */
{ (yyval.node) = 0;}
+#line 7956 "y.tab.c" /* yacc.c:1646 */
break;
- case 171:
-
-/* Line 1806 of yacc.c */
-#line 4377 "parser.y"
+ case 198:
+#line 4359 "parser.y" /* yacc.c:1646 */
{
int start_line = cparse_line;
skip_decl();
Swig_error(cparse_file,start_line,"Syntax error in input(3).\n");
exit(1);
}
+#line 7967 "y.tab.c" /* yacc.c:1646 */
break;
- case 172:
-
-/* Line 1806 of yacc.c */
-#line 4382 "parser.y"
+ case 199:
+#line 4364 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(3) - (3)].node);
+ (yyval.node) = (yyvsp[0].node);
}
+#line 7975 "y.tab.c" /* yacc.c:1646 */
break;
- case 173:
-
-/* Line 1806 of yacc.c */
-#line 4393 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 200:
+#line 4375 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 7981 "y.tab.c" /* yacc.c:1646 */
break;
- case 174:
-
-/* Line 1806 of yacc.c */
-#line 4394 "parser.y"
+ case 201:
+#line 4376 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(1) - (1)].node);
- if (extendmode) {
+ (yyval.node) = (yyvsp[0].node);
+ if (extendmode && current_class) {
String *symname;
symname= make_name((yyval.node),Getattr((yyval.node),"name"), Getattr((yyval.node),"decl"));
if (Strcmp(symname,Getattr((yyval.node),"name")) == 0) {
add_symbols((yyval.node));
default_arguments((yyval.node));
}
+#line 8003 "y.tab.c" /* yacc.c:1646 */
break;
- case 175:
-
-/* Line 1806 of yacc.c */
-#line 4411 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 202:
+#line 4393 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8009 "y.tab.c" /* yacc.c:1646 */
break;
- case 176:
-
-/* Line 1806 of yacc.c */
-#line 4412 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 203:
+#line 4394 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8015 "y.tab.c" /* yacc.c:1646 */
break;
- case 177:
-
-/* Line 1806 of yacc.c */
-#line 4413 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 204:
+#line 4395 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8021 "y.tab.c" /* yacc.c:1646 */
break;
- case 178:
-
-/* Line 1806 of yacc.c */
-#line 4414 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 205:
+#line 4396 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8027 "y.tab.c" /* yacc.c:1646 */
break;
- case 179:
-
-/* Line 1806 of yacc.c */
-#line 4415 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 206:
+#line 4397 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8033 "y.tab.c" /* yacc.c:1646 */
break;
- case 180:
-
-/* Line 1806 of yacc.c */
-#line 4416 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 207:
+#line 4398 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8039 "y.tab.c" /* yacc.c:1646 */
break;
- case 181:
+ case 208:
+#line 4399 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8045 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4417 "parser.y"
+ case 209:
+#line 4400 "parser.y" /* yacc.c:1646 */
{ (yyval.node) = 0; }
+#line 8051 "y.tab.c" /* yacc.c:1646 */
break;
- case 182:
-
-/* Line 1806 of yacc.c */
-#line 4418 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 210:
+#line 4401 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8057 "y.tab.c" /* yacc.c:1646 */
break;
- case 183:
-
-/* Line 1806 of yacc.c */
-#line 4419 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 211:
+#line 4402 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8063 "y.tab.c" /* yacc.c:1646 */
break;
- case 184:
-
-/* Line 1806 of yacc.c */
-#line 4420 "parser.y"
+ case 212:
+#line 4403 "parser.y" /* yacc.c:1646 */
{ (yyval.node) = 0; }
+#line 8069 "y.tab.c" /* yacc.c:1646 */
break;
- case 185:
-
-/* Line 1806 of yacc.c */
-#line 4421 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 213:
+#line 4404 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8075 "y.tab.c" /* yacc.c:1646 */
break;
- case 186:
-
-/* Line 1806 of yacc.c */
-#line 4422 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 214:
+#line 4405 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8081 "y.tab.c" /* yacc.c:1646 */
break;
- case 187:
-
-/* Line 1806 of yacc.c */
-#line 4423 "parser.y"
+ case 215:
+#line 4406 "parser.y" /* yacc.c:1646 */
{ (yyval.node) = 0; }
+#line 8087 "y.tab.c" /* yacc.c:1646 */
break;
- case 188:
-
-/* Line 1806 of yacc.c */
-#line 4424 "parser.y"
- {(yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 216:
+#line 4407 "parser.y" /* yacc.c:1646 */
+ {(yyval.node) = (yyvsp[0].node); }
+#line 8093 "y.tab.c" /* yacc.c:1646 */
break;
- case 189:
-
-/* Line 1806 of yacc.c */
-#line 4425 "parser.y"
- {(yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 217:
+#line 4408 "parser.y" /* yacc.c:1646 */
+ {(yyval.node) = (yyvsp[0].node); }
+#line 8099 "y.tab.c" /* yacc.c:1646 */
break;
- case 190:
-
-/* Line 1806 of yacc.c */
-#line 4426 "parser.y"
+ case 218:
+#line 4409 "parser.y" /* yacc.c:1646 */
{ (yyval.node) = 0; }
+#line 8105 "y.tab.c" /* yacc.c:1646 */
break;
- case 191:
-
-/* Line 1806 of yacc.c */
-#line 4435 "parser.y"
- {
- if (Classprefix) {
- SwigType *decl = NewStringEmpty();
- (yyval.node) = new_node("constructor");
- Setattr((yyval.node),"storage",(yyvsp[(1) - (6)].id));
- Setattr((yyval.node),"name",(yyvsp[(2) - (6)].type));
- Setattr((yyval.node),"parms",(yyvsp[(4) - (6)].pl));
- SwigType_add_function(decl,(yyvsp[(4) - (6)].pl));
- Setattr((yyval.node),"decl",decl);
- Setattr((yyval.node),"throws",(yyvsp[(6) - (6)].decl).throws);
- Setattr((yyval.node),"throw",(yyvsp[(6) - (6)].decl).throwf);
- if (Len(scanner_ccode)) {
- String *code = Copy(scanner_ccode);
- Setattr((yyval.node),"code",code);
- Delete(code);
- }
- SetFlag((yyval.node),"feature:new");
+ case 219:
+#line 4418 "parser.y" /* yacc.c:1646 */
+ {
+ if (inclass || extendmode) {
+ SwigType *decl = NewStringEmpty();
+ (yyval.node) = new_node("constructor");
+ Setattr((yyval.node),"storage",(yyvsp[-5].id));
+ Setattr((yyval.node),"name",(yyvsp[-4].type));
+ Setattr((yyval.node),"parms",(yyvsp[-2].pl));
+ SwigType_add_function(decl,(yyvsp[-2].pl));
+ Setattr((yyval.node),"decl",decl);
+ Setattr((yyval.node),"throws",(yyvsp[0].decl).throws);
+ Setattr((yyval.node),"throw",(yyvsp[0].decl).throwf);
+ Setattr((yyval.node),"noexcept",(yyvsp[0].decl).nexcept);
+ if (Len(scanner_ccode)) {
+ String *code = Copy(scanner_ccode);
+ Setattr((yyval.node),"code",code);
+ Delete(code);
+ }
+ SetFlag((yyval.node),"feature:new");
+ if ((yyvsp[0].decl).defarg)
+ Setattr((yyval.node),"value",(yyvsp[0].decl).defarg);
} else {
(yyval.node) = 0;
}
}
+#line 8134 "y.tab.c" /* yacc.c:1646 */
break;
- case 192:
-
-/* Line 1806 of yacc.c */
-#line 4460 "parser.y"
+ case 220:
+#line 4446 "parser.y" /* yacc.c:1646 */
{
- String *name = NewStringf("%s",(yyvsp[(2) - (6)].str));
+ String *name = NewStringf("%s",(yyvsp[-4].str));
if (*(Char(name)) != '~') Insert(name,0,"~");
(yyval.node) = new_node("destructor");
Setattr((yyval.node),"name",name);
}
{
String *decl = NewStringEmpty();
- SwigType_add_function(decl,(yyvsp[(4) - (6)].pl));
+ SwigType_add_function(decl,(yyvsp[-2].pl));
Setattr((yyval.node),"decl",decl);
Delete(decl);
}
- Setattr((yyval.node),"throws",(yyvsp[(6) - (6)].dtype).throws);
- Setattr((yyval.node),"throw",(yyvsp[(6) - (6)].dtype).throwf);
+ Setattr((yyval.node),"throws",(yyvsp[0].dtype).throws);
+ Setattr((yyval.node),"throw",(yyvsp[0].dtype).throwf);
+ Setattr((yyval.node),"noexcept",(yyvsp[0].dtype).nexcept);
+ if ((yyvsp[0].dtype).val)
+ Setattr((yyval.node),"value",(yyvsp[0].dtype).val);
add_symbols((yyval.node));
}
+#line 8163 "y.tab.c" /* yacc.c:1646 */
break;
- case 193:
-
-/* Line 1806 of yacc.c */
-#line 4484 "parser.y"
+ case 221:
+#line 4473 "parser.y" /* yacc.c:1646 */
{
String *name;
(yyval.node) = new_node("destructor");
Setattr((yyval.node),"storage","virtual");
- name = NewStringf("%s",(yyvsp[(3) - (7)].str));
+ name = NewStringf("%s",(yyvsp[-4].str));
if (*(Char(name)) != '~') Insert(name,0,"~");
Setattr((yyval.node),"name",name);
Delete(name);
- Setattr((yyval.node),"throws",(yyvsp[(7) - (7)].dtype).throws);
- Setattr((yyval.node),"throw",(yyvsp[(7) - (7)].dtype).throwf);
- if ((yyvsp[(7) - (7)].dtype).val) {
- Setattr((yyval.node),"value","0");
- }
+ Setattr((yyval.node),"throws",(yyvsp[0].dtype).throws);
+ Setattr((yyval.node),"throw",(yyvsp[0].dtype).throwf);
+ Setattr((yyval.node),"noexcept",(yyvsp[0].dtype).nexcept);
+ if ((yyvsp[0].dtype).val)
+ Setattr((yyval.node),"value",(yyvsp[0].dtype).val);
if (Len(scanner_ccode)) {
String *code = Copy(scanner_ccode);
Setattr((yyval.node),"code",code);
}
{
String *decl = NewStringEmpty();
- SwigType_add_function(decl,(yyvsp[(5) - (7)].pl));
+ SwigType_add_function(decl,(yyvsp[-2].pl));
Setattr((yyval.node),"decl",decl);
Delete(decl);
}
add_symbols((yyval.node));
}
+#line 8195 "y.tab.c" /* yacc.c:1646 */
break;
- case 194:
-
-/* Line 1806 of yacc.c */
-#line 4515 "parser.y"
+ case 222:
+#line 4504 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("cdecl");
- Setattr((yyval.node),"type",(yyvsp[(3) - (8)].type));
- Setattr((yyval.node),"name",(yyvsp[(2) - (8)].str));
- Setattr((yyval.node),"storage",(yyvsp[(1) - (8)].id));
+ Setattr((yyval.node),"type",(yyvsp[-5].type));
+ Setattr((yyval.node),"name",(yyvsp[-6].str));
+ Setattr((yyval.node),"storage",(yyvsp[-7].id));
- SwigType_add_function((yyvsp[(4) - (8)].type),(yyvsp[(6) - (8)].pl));
- if ((yyvsp[(8) - (8)].dtype).qualifier) {
- SwigType_push((yyvsp[(4) - (8)].type),(yyvsp[(8) - (8)].dtype).qualifier);
+ SwigType_add_function((yyvsp[-4].type),(yyvsp[-2].pl));
+ if ((yyvsp[0].dtype).qualifier) {
+ SwigType_push((yyvsp[-4].type),(yyvsp[0].dtype).qualifier);
}
- Setattr((yyval.node),"decl",(yyvsp[(4) - (8)].type));
- Setattr((yyval.node),"parms",(yyvsp[(6) - (8)].pl));
+ Setattr((yyval.node),"decl",(yyvsp[-4].type));
+ Setattr((yyval.node),"parms",(yyvsp[-2].pl));
Setattr((yyval.node),"conversion_operator","1");
add_symbols((yyval.node));
}
+#line 8215 "y.tab.c" /* yacc.c:1646 */
break;
- case 195:
-
-/* Line 1806 of yacc.c */
-#line 4530 "parser.y"
+ case 223:
+#line 4519 "parser.y" /* yacc.c:1646 */
{
SwigType *decl;
(yyval.node) = new_node("cdecl");
- Setattr((yyval.node),"type",(yyvsp[(3) - (8)].type));
- Setattr((yyval.node),"name",(yyvsp[(2) - (8)].str));
- Setattr((yyval.node),"storage",(yyvsp[(1) - (8)].id));
+ Setattr((yyval.node),"type",(yyvsp[-5].type));
+ Setattr((yyval.node),"name",(yyvsp[-6].str));
+ Setattr((yyval.node),"storage",(yyvsp[-7].id));
decl = NewStringEmpty();
SwigType_add_reference(decl);
- SwigType_add_function(decl,(yyvsp[(6) - (8)].pl));
- if ((yyvsp[(8) - (8)].dtype).qualifier) {
- SwigType_push(decl,(yyvsp[(8) - (8)].dtype).qualifier);
+ SwigType_add_function(decl,(yyvsp[-2].pl));
+ if ((yyvsp[0].dtype).qualifier) {
+ SwigType_push(decl,(yyvsp[0].dtype).qualifier);
}
Setattr((yyval.node),"decl",decl);
- Setattr((yyval.node),"parms",(yyvsp[(6) - (8)].pl));
+ Setattr((yyval.node),"parms",(yyvsp[-2].pl));
Setattr((yyval.node),"conversion_operator","1");
add_symbols((yyval.node));
}
+#line 8237 "y.tab.c" /* yacc.c:1646 */
break;
- case 196:
+ case 224:
+#line 4536 "parser.y" /* yacc.c:1646 */
+ {
+ SwigType *decl;
+ (yyval.node) = new_node("cdecl");
+ Setattr((yyval.node),"type",(yyvsp[-5].type));
+ Setattr((yyval.node),"name",(yyvsp[-6].str));
+ Setattr((yyval.node),"storage",(yyvsp[-7].id));
+ decl = NewStringEmpty();
+ SwigType_add_rvalue_reference(decl);
+ SwigType_add_function(decl,(yyvsp[-2].pl));
+ if ((yyvsp[0].dtype).qualifier) {
+ SwigType_push(decl,(yyvsp[0].dtype).qualifier);
+ }
+ Setattr((yyval.node),"decl",decl);
+ Setattr((yyval.node),"parms",(yyvsp[-2].pl));
+ Setattr((yyval.node),"conversion_operator","1");
+ add_symbols((yyval.node));
+ }
+#line 8259 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4548 "parser.y"
+ case 225:
+#line 4554 "parser.y" /* yacc.c:1646 */
{
SwigType *decl;
(yyval.node) = new_node("cdecl");
- Setattr((yyval.node),"type",(yyvsp[(3) - (9)].type));
- Setattr((yyval.node),"name",(yyvsp[(2) - (9)].str));
- Setattr((yyval.node),"storage",(yyvsp[(1) - (9)].id));
+ Setattr((yyval.node),"type",(yyvsp[-6].type));
+ Setattr((yyval.node),"name",(yyvsp[-7].str));
+ Setattr((yyval.node),"storage",(yyvsp[-8].id));
decl = NewStringEmpty();
SwigType_add_pointer(decl);
SwigType_add_reference(decl);
- SwigType_add_function(decl,(yyvsp[(7) - (9)].pl));
- if ((yyvsp[(9) - (9)].dtype).qualifier) {
- SwigType_push(decl,(yyvsp[(9) - (9)].dtype).qualifier);
+ SwigType_add_function(decl,(yyvsp[-2].pl));
+ if ((yyvsp[0].dtype).qualifier) {
+ SwigType_push(decl,(yyvsp[0].dtype).qualifier);
}
Setattr((yyval.node),"decl",decl);
- Setattr((yyval.node),"parms",(yyvsp[(7) - (9)].pl));
+ Setattr((yyval.node),"parms",(yyvsp[-2].pl));
Setattr((yyval.node),"conversion_operator","1");
add_symbols((yyval.node));
}
+#line 8282 "y.tab.c" /* yacc.c:1646 */
break;
- case 197:
-
-/* Line 1806 of yacc.c */
-#line 4567 "parser.y"
+ case 226:
+#line 4573 "parser.y" /* yacc.c:1646 */
{
String *t = NewStringEmpty();
(yyval.node) = new_node("cdecl");
- Setattr((yyval.node),"type",(yyvsp[(3) - (7)].type));
- Setattr((yyval.node),"name",(yyvsp[(2) - (7)].str));
- Setattr((yyval.node),"storage",(yyvsp[(1) - (7)].id));
- SwigType_add_function(t,(yyvsp[(5) - (7)].pl));
- if ((yyvsp[(7) - (7)].dtype).qualifier) {
- SwigType_push(t,(yyvsp[(7) - (7)].dtype).qualifier);
+ Setattr((yyval.node),"type",(yyvsp[-4].type));
+ Setattr((yyval.node),"name",(yyvsp[-5].str));
+ Setattr((yyval.node),"storage",(yyvsp[-6].id));
+ SwigType_add_function(t,(yyvsp[-2].pl));
+ if ((yyvsp[0].dtype).qualifier) {
+ SwigType_push(t,(yyvsp[0].dtype).qualifier);
}
Setattr((yyval.node),"decl",t);
- Setattr((yyval.node),"parms",(yyvsp[(5) - (7)].pl));
+ Setattr((yyval.node),"parms",(yyvsp[-2].pl));
Setattr((yyval.node),"conversion_operator","1");
add_symbols((yyval.node));
}
+#line 8302 "y.tab.c" /* yacc.c:1646 */
break;
- case 198:
-
-/* Line 1806 of yacc.c */
-#line 4586 "parser.y"
+ case 227:
+#line 4592 "parser.y" /* yacc.c:1646 */
{
skip_balanced('{','}');
(yyval.node) = 0;
}
+#line 8311 "y.tab.c" /* yacc.c:1646 */
break;
- case 199:
+ case 228:
+#line 4599 "parser.y" /* yacc.c:1646 */
+ {
+ skip_balanced('(',')');
+ (yyval.node) = 0;
+ }
+#line 8320 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4593 "parser.y"
+ case 229:
+#line 4606 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("access");
Setattr((yyval.node),"kind","public");
cplus_mode = CPLUS_PUBLIC;
}
+#line 8330 "y.tab.c" /* yacc.c:1646 */
break;
- case 200:
-
-/* Line 1806 of yacc.c */
-#line 4600 "parser.y"
+ case 230:
+#line 4613 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("access");
Setattr((yyval.node),"kind","private");
cplus_mode = CPLUS_PRIVATE;
}
+#line 8340 "y.tab.c" /* yacc.c:1646 */
break;
- case 201:
-
-/* Line 1806 of yacc.c */
-#line 4608 "parser.y"
+ case 231:
+#line 4621 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = new_node("access");
Setattr((yyval.node),"kind","protected");
cplus_mode = CPLUS_PROTECTED;
}
+#line 8350 "y.tab.c" /* yacc.c:1646 */
break;
- case 202:
-
-/* Line 1806 of yacc.c */
-#line 4629 "parser.y"
- {
- cparse_start_line = cparse_line;
- skip_balanced('{','}');
- (yyval.str) = NewString(scanner_ccode); /* copied as initializers overwrite scanner_ccode */
- }
- break;
-
- case 203:
-
-/* Line 1806 of yacc.c */
-#line 4633 "parser.y"
- {
- (yyval.node) = 0;
- if (cplus_mode == CPLUS_PUBLIC) {
- if (cparse_cplusplus) {
- String *name = Copy((yyvsp[(3) - (7)].str));
- (yyval.node) = nested_forward_declaration((yyvsp[(1) - (7)].id), (yyvsp[(2) - (7)].id), (yyvsp[(3) - (7)].str), name, (yyvsp[(7) - (7)].node));
- } else if ((yyvsp[(7) - (7)].node)) {
- nested_new_struct((yyvsp[(2) - (7)].id), (yyvsp[(6) - (7)].str), (yyvsp[(7) - (7)].node));
- }
- }
- Delete((yyvsp[(6) - (7)].str));
- }
- break;
-
- case 204:
-
-/* Line 1806 of yacc.c */
-#line 4656 "parser.y"
- {
- cparse_start_line = cparse_line;
- skip_balanced('{','}');
- (yyval.str) = NewString(scanner_ccode); /* copied as initializers overwrite scanner_ccode */
- }
- break;
-
- case 205:
-
-/* Line 1806 of yacc.c */
-#line 4660 "parser.y"
- {
- (yyval.node) = 0;
- if (cplus_mode == CPLUS_PUBLIC) {
- if (cparse_cplusplus) {
- String *name = (yyvsp[(6) - (6)].node) ? Copy(Getattr((yyvsp[(6) - (6)].node), "name")) : 0;
- (yyval.node) = nested_forward_declaration((yyvsp[(1) - (6)].id), (yyvsp[(2) - (6)].id), 0, name, (yyvsp[(6) - (6)].node));
- } else {
- if ((yyvsp[(6) - (6)].node)) {
- nested_new_struct((yyvsp[(2) - (6)].id), (yyvsp[(5) - (6)].str), (yyvsp[(6) - (6)].node));
- } else {
- Swig_warning(WARN_PARSE_UNNAMED_NESTED_CLASS, cparse_file, cparse_line, "Nested %s not currently supported (ignored).\n", (yyvsp[(2) - (6)].id));
- }
- }
- }
- Delete((yyvsp[(5) - (6)].str));
- }
+ case 232:
+#line 4629 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8356 "y.tab.c" /* yacc.c:1646 */
break;
- case 206:
-
-/* Line 1806 of yacc.c */
-#line 4692 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 233:
+#line 4632 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8362 "y.tab.c" /* yacc.c:1646 */
break;
- case 207:
-
-/* Line 1806 of yacc.c */
-#line 4695 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 234:
+#line 4636 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8368 "y.tab.c" /* yacc.c:1646 */
break;
- case 208:
-
-/* Line 1806 of yacc.c */
-#line 4699 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 235:
+#line 4639 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8374 "y.tab.c" /* yacc.c:1646 */
break;
- case 209:
-
-/* Line 1806 of yacc.c */
-#line 4702 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 236:
+#line 4640 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8380 "y.tab.c" /* yacc.c:1646 */
break;
- case 210:
-
-/* Line 1806 of yacc.c */
-#line 4703 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 237:
+#line 4641 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8386 "y.tab.c" /* yacc.c:1646 */
break;
- case 211:
-
-/* Line 1806 of yacc.c */
-#line 4704 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 238:
+#line 4642 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8392 "y.tab.c" /* yacc.c:1646 */
break;
- case 212:
-
-/* Line 1806 of yacc.c */
-#line 4705 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 239:
+#line 4643 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8398 "y.tab.c" /* yacc.c:1646 */
break;
- case 213:
-
-/* Line 1806 of yacc.c */
-#line 4706 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 240:
+#line 4644 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8404 "y.tab.c" /* yacc.c:1646 */
break;
- case 214:
-
-/* Line 1806 of yacc.c */
-#line 4707 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 241:
+#line 4645 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8410 "y.tab.c" /* yacc.c:1646 */
break;
- case 215:
-
-/* Line 1806 of yacc.c */
-#line 4708 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 242:
+#line 4646 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 8416 "y.tab.c" /* yacc.c:1646 */
break;
- case 216:
-
-/* Line 1806 of yacc.c */
-#line 4709 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 243:
+#line 4649 "parser.y" /* yacc.c:1646 */
+ {
+ Clear(scanner_ccode);
+ (yyval.dtype).val = 0;
+ (yyval.dtype).throws = (yyvsp[-1].dtype).throws;
+ (yyval.dtype).throwf = (yyvsp[-1].dtype).throwf;
+ (yyval.dtype).nexcept = (yyvsp[-1].dtype).nexcept;
+ }
+#line 8428 "y.tab.c" /* yacc.c:1646 */
break;
- case 217:
-
-/* Line 1806 of yacc.c */
-#line 4712 "parser.y"
+ case 244:
+#line 4656 "parser.y" /* yacc.c:1646 */
{
Clear(scanner_ccode);
- (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws;
- (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf;
+ (yyval.dtype).val = (yyvsp[-1].dtype).val;
+ (yyval.dtype).throws = (yyvsp[-3].dtype).throws;
+ (yyval.dtype).throwf = (yyvsp[-3].dtype).throwf;
+ (yyval.dtype).nexcept = (yyvsp[-3].dtype).nexcept;
}
+#line 8440 "y.tab.c" /* yacc.c:1646 */
break;
- case 218:
-
-/* Line 1806 of yacc.c */
-#line 4717 "parser.y"
+ case 245:
+#line 4663 "parser.y" /* yacc.c:1646 */
{
skip_balanced('{','}');
- (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws;
- (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf;
+ (yyval.dtype).val = 0;
+ (yyval.dtype).throws = (yyvsp[-1].dtype).throws;
+ (yyval.dtype).throwf = (yyvsp[-1].dtype).throwf;
+ (yyval.dtype).nexcept = (yyvsp[-1].dtype).nexcept;
}
+#line 8452 "y.tab.c" /* yacc.c:1646 */
break;
- case 219:
-
-/* Line 1806 of yacc.c */
-#line 4724 "parser.y"
+ case 246:
+#line 4672 "parser.y" /* yacc.c:1646 */
{
Clear(scanner_ccode);
(yyval.dtype).val = 0;
- (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier;
+ (yyval.dtype).qualifier = (yyvsp[-1].dtype).qualifier;
(yyval.dtype).bitfield = 0;
- (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws;
- (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf;
+ (yyval.dtype).throws = (yyvsp[-1].dtype).throws;
+ (yyval.dtype).throwf = (yyvsp[-1].dtype).throwf;
+ (yyval.dtype).nexcept = (yyvsp[-1].dtype).nexcept;
}
+#line 8466 "y.tab.c" /* yacc.c:1646 */
break;
- case 220:
-
-/* Line 1806 of yacc.c */
-#line 4732 "parser.y"
+ case 247:
+#line 4681 "parser.y" /* yacc.c:1646 */
{
Clear(scanner_ccode);
- (yyval.dtype).val = (yyvsp[(3) - (4)].dtype).val;
- (yyval.dtype).qualifier = (yyvsp[(1) - (4)].dtype).qualifier;
+ (yyval.dtype).val = (yyvsp[-1].dtype).val;
+ (yyval.dtype).qualifier = (yyvsp[-3].dtype).qualifier;
(yyval.dtype).bitfield = 0;
- (yyval.dtype).throws = (yyvsp[(1) - (4)].dtype).throws;
- (yyval.dtype).throwf = (yyvsp[(1) - (4)].dtype).throwf;
+ (yyval.dtype).throws = (yyvsp[-3].dtype).throws;
+ (yyval.dtype).throwf = (yyvsp[-3].dtype).throwf;
+ (yyval.dtype).nexcept = (yyvsp[-3].dtype).nexcept;
}
+#line 8480 "y.tab.c" /* yacc.c:1646 */
break;
- case 221:
-
-/* Line 1806 of yacc.c */
-#line 4740 "parser.y"
+ case 248:
+#line 4690 "parser.y" /* yacc.c:1646 */
{
skip_balanced('{','}');
(yyval.dtype).val = 0;
- (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier;
+ (yyval.dtype).qualifier = (yyvsp[-1].dtype).qualifier;
(yyval.dtype).bitfield = 0;
- (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws;
- (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf;
+ (yyval.dtype).throws = (yyvsp[-1].dtype).throws;
+ (yyval.dtype).throwf = (yyvsp[-1].dtype).throwf;
+ (yyval.dtype).nexcept = (yyvsp[-1].dtype).nexcept;
}
+#line 8494 "y.tab.c" /* yacc.c:1646 */
break;
- case 222:
-
-/* Line 1806 of yacc.c */
-#line 4751 "parser.y"
+ case 249:
+#line 4702 "parser.y" /* yacc.c:1646 */
{ }
+#line 8500 "y.tab.c" /* yacc.c:1646 */
break;
- case 223:
+ case 250:
+#line 4705 "parser.y" /* yacc.c:1646 */
+ { (yyval.type) = (yyvsp[0].type);
+ /* Printf(stdout,"primitive = '%s'\n", $$);*/
+ }
+#line 8508 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4757 "parser.y"
- { (yyval.id) = "extern"; }
+ case 251:
+#line 4708 "parser.y" /* yacc.c:1646 */
+ { (yyval.type) = (yyvsp[0].type); }
+#line 8514 "y.tab.c" /* yacc.c:1646 */
break;
- case 224:
+ case 252:
+#line 4709 "parser.y" /* yacc.c:1646 */
+ { (yyval.type) = (yyvsp[0].type); }
+#line 8520 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4758 "parser.y"
- {
- if (strcmp((yyvsp[(2) - (2)].id),"C") == 0) {
+ case 253:
+#line 4713 "parser.y" /* yacc.c:1646 */
+ { (yyval.type) = (yyvsp[0].type); }
+#line 8526 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 254:
+#line 4715 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.type) = (yyvsp[0].str);
+ }
+#line 8534 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 255:
+#line 4723 "parser.y" /* yacc.c:1646 */
+ {
+ if (Strcmp((yyvsp[0].str),"C") == 0) {
(yyval.id) = "externc";
+ } else if (Strcmp((yyvsp[0].str),"C++") == 0) {
+ (yyval.id) = "extern";
} else {
- Swig_warning(WARN_PARSE_UNDEFINED_EXTERN,cparse_file, cparse_line,"Unrecognized extern type \"%s\".\n", (yyvsp[(2) - (2)].id));
+ Swig_warning(WARN_PARSE_UNDEFINED_EXTERN,cparse_file, cparse_line,"Unrecognized extern type \"%s\".\n", (yyvsp[0].str));
(yyval.id) = 0;
}
}
+#line 8549 "y.tab.c" /* yacc.c:1646 */
break;
- case 225:
+ case 256:
+#line 4735 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "extern"; }
+#line 8555 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4766 "parser.y"
- { (yyval.id) = "static"; }
+ case 257:
+#line 4736 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = (yyvsp[0].id); }
+#line 8561 "y.tab.c" /* yacc.c:1646 */
break;
- case 226:
+ case 258:
+#line 4737 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "thread_local"; }
+#line 8567 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4767 "parser.y"
+ case 259:
+#line 4738 "parser.y" /* yacc.c:1646 */
{ (yyval.id) = "typedef"; }
+#line 8573 "y.tab.c" /* yacc.c:1646 */
break;
- case 227:
+ case 260:
+#line 4739 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "static"; }
+#line 8579 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4768 "parser.y"
- { (yyval.id) = "virtual"; }
+ case 261:
+#line 4740 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "typedef"; }
+#line 8585 "y.tab.c" /* yacc.c:1646 */
break;
- case 228:
+ case 262:
+#line 4741 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "virtual"; }
+#line 8591 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4769 "parser.y"
+ case 263:
+#line 4742 "parser.y" /* yacc.c:1646 */
{ (yyval.id) = "friend"; }
+#line 8597 "y.tab.c" /* yacc.c:1646 */
break;
- case 229:
-
-/* Line 1806 of yacc.c */
-#line 4770 "parser.y"
+ case 264:
+#line 4743 "parser.y" /* yacc.c:1646 */
{ (yyval.id) = "explicit"; }
+#line 8603 "y.tab.c" /* yacc.c:1646 */
break;
- case 230:
+ case 265:
+#line 4744 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "constexpr"; }
+#line 8609 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4771 "parser.y"
- { (yyval.id) = 0; }
+ case 266:
+#line 4745 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "explicit constexpr"; }
+#line 8615 "y.tab.c" /* yacc.c:1646 */
break;
- case 231:
+ case 267:
+#line 4746 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "explicit constexpr"; }
+#line 8621 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 268:
+#line 4747 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "static constexpr"; }
+#line 8627 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 269:
+#line 4748 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "static constexpr"; }
+#line 8633 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 270:
+#line 4749 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "thread_local"; }
+#line 8639 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 271:
+#line 4750 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "static thread_local"; }
+#line 8645 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 272:
+#line 4751 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "static thread_local"; }
+#line 8651 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 4778 "parser.y"
+ case 273:
+#line 4752 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "extern thread_local"; }
+#line 8657 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 274:
+#line 4753 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = "extern thread_local"; }
+#line 8663 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 275:
+#line 4754 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = 0; }
+#line 8669 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 276:
+#line 4761 "parser.y" /* yacc.c:1646 */
{
Parm *p;
- (yyval.pl) = (yyvsp[(1) - (1)].pl);
- p = (yyvsp[(1) - (1)].pl);
+ (yyval.pl) = (yyvsp[0].pl);
+ p = (yyvsp[0].pl);
while (p) {
Replace(Getattr(p,"type"),"typename ", "", DOH_REPLACE_ANY);
p = nextSibling(p);
}
}
+#line 8683 "y.tab.c" /* yacc.c:1646 */
break;
- case 232:
-
-/* Line 1806 of yacc.c */
-#line 4789 "parser.y"
+ case 277:
+#line 4772 "parser.y" /* yacc.c:1646 */
{
- set_nextSibling((yyvsp[(1) - (2)].p),(yyvsp[(2) - (2)].pl));
- (yyval.pl) = (yyvsp[(1) - (2)].p);
+ set_nextSibling((yyvsp[-1].p),(yyvsp[0].pl));
+ (yyval.pl) = (yyvsp[-1].p);
}
+#line 8692 "y.tab.c" /* yacc.c:1646 */
break;
- case 233:
-
-/* Line 1806 of yacc.c */
-#line 4793 "parser.y"
+ case 278:
+#line 4776 "parser.y" /* yacc.c:1646 */
{ (yyval.pl) = 0; }
+#line 8698 "y.tab.c" /* yacc.c:1646 */
break;
- case 234:
-
-/* Line 1806 of yacc.c */
-#line 4796 "parser.y"
+ case 279:
+#line 4779 "parser.y" /* yacc.c:1646 */
{
- set_nextSibling((yyvsp[(2) - (3)].p),(yyvsp[(3) - (3)].pl));
- (yyval.pl) = (yyvsp[(2) - (3)].p);
+ set_nextSibling((yyvsp[-1].p),(yyvsp[0].pl));
+ (yyval.pl) = (yyvsp[-1].p);
}
+#line 8707 "y.tab.c" /* yacc.c:1646 */
break;
- case 235:
-
-/* Line 1806 of yacc.c */
-#line 4800 "parser.y"
+ case 280:
+#line 4783 "parser.y" /* yacc.c:1646 */
{ (yyval.pl) = 0; }
+#line 8713 "y.tab.c" /* yacc.c:1646 */
break;
- case 236:
-
-/* Line 1806 of yacc.c */
-#line 4804 "parser.y"
+ case 281:
+#line 4787 "parser.y" /* yacc.c:1646 */
{
- SwigType_push((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).type);
- (yyval.p) = NewParmWithoutFileLineInfo((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).id);
+ SwigType_push((yyvsp[-1].type),(yyvsp[0].decl).type);
+ (yyval.p) = NewParmWithoutFileLineInfo((yyvsp[-1].type),(yyvsp[0].decl).id);
Setfile((yyval.p),cparse_file);
Setline((yyval.p),cparse_line);
- if ((yyvsp[(2) - (2)].decl).defarg) {
- Setattr((yyval.p),"value",(yyvsp[(2) - (2)].decl).defarg);
+ if ((yyvsp[0].decl).defarg) {
+ Setattr((yyval.p),"value",(yyvsp[0].decl).defarg);
}
}
+#line 8727 "y.tab.c" /* yacc.c:1646 */
break;
- case 237:
-
-/* Line 1806 of yacc.c */
-#line 4814 "parser.y"
+ case 282:
+#line 4797 "parser.y" /* yacc.c:1646 */
{
- (yyval.p) = NewParmWithoutFileLineInfo(NewStringf("template<class> %s %s", (yyvsp[(5) - (7)].id),(yyvsp[(6) - (7)].str)), 0);
+ (yyval.p) = NewParmWithoutFileLineInfo(NewStringf("template<class> %s %s", (yyvsp[-2].id),(yyvsp[-1].str)), 0);
Setfile((yyval.p),cparse_file);
Setline((yyval.p),cparse_line);
- if ((yyvsp[(7) - (7)].dtype).val) {
- Setattr((yyval.p),"value",(yyvsp[(7) - (7)].dtype).val);
+ if ((yyvsp[0].dtype).val) {
+ Setattr((yyval.p),"value",(yyvsp[0].dtype).val);
}
}
+#line 8740 "y.tab.c" /* yacc.c:1646 */
break;
- case 238:
-
-/* Line 1806 of yacc.c */
-#line 4822 "parser.y"
+ case 283:
+#line 4805 "parser.y" /* yacc.c:1646 */
{
SwigType *t = NewString("v(...)");
(yyval.p) = NewParmWithoutFileLineInfo(t, 0);
Setfile((yyval.p),cparse_file);
Setline((yyval.p),cparse_line);
}
+#line 8751 "y.tab.c" /* yacc.c:1646 */
break;
- case 239:
-
-/* Line 1806 of yacc.c */
-#line 4830 "parser.y"
+ case 284:
+#line 4813 "parser.y" /* yacc.c:1646 */
{
Parm *p;
- (yyval.p) = (yyvsp[(1) - (1)].p);
- p = (yyvsp[(1) - (1)].p);
+ (yyval.p) = (yyvsp[0].p);
+ p = (yyvsp[0].p);
while (p) {
if (Getattr(p,"type")) {
Replace(Getattr(p,"type"),"typename ", "", DOH_REPLACE_ANY);
p = nextSibling(p);
}
}
+#line 8767 "y.tab.c" /* yacc.c:1646 */
break;
- case 240:
-
-/* Line 1806 of yacc.c */
-#line 4843 "parser.y"
+ case 285:
+#line 4826 "parser.y" /* yacc.c:1646 */
{
- set_nextSibling((yyvsp[(1) - (2)].p),(yyvsp[(2) - (2)].p));
- (yyval.p) = (yyvsp[(1) - (2)].p);
+ set_nextSibling((yyvsp[-1].p),(yyvsp[0].p));
+ (yyval.p) = (yyvsp[-1].p);
}
+#line 8776 "y.tab.c" /* yacc.c:1646 */
break;
- case 241:
-
-/* Line 1806 of yacc.c */
-#line 4847 "parser.y"
+ case 286:
+#line 4830 "parser.y" /* yacc.c:1646 */
{ (yyval.p) = 0; }
+#line 8782 "y.tab.c" /* yacc.c:1646 */
break;
- case 242:
-
-/* Line 1806 of yacc.c */
-#line 4850 "parser.y"
+ case 287:
+#line 4833 "parser.y" /* yacc.c:1646 */
{
- set_nextSibling((yyvsp[(2) - (3)].p),(yyvsp[(3) - (3)].p));
- (yyval.p) = (yyvsp[(2) - (3)].p);
+ set_nextSibling((yyvsp[-1].p),(yyvsp[0].p));
+ (yyval.p) = (yyvsp[-1].p);
}
+#line 8791 "y.tab.c" /* yacc.c:1646 */
break;
- case 243:
-
-/* Line 1806 of yacc.c */
-#line 4854 "parser.y"
+ case 288:
+#line 4837 "parser.y" /* yacc.c:1646 */
{ (yyval.p) = 0; }
+#line 8797 "y.tab.c" /* yacc.c:1646 */
break;
- case 244:
-
-/* Line 1806 of yacc.c */
-#line 4858 "parser.y"
+ case 289:
+#line 4841 "parser.y" /* yacc.c:1646 */
{
- (yyval.p) = (yyvsp[(1) - (1)].p);
+ (yyval.p) = (yyvsp[0].p);
{
/* We need to make a possible adjustment for integer parameters. */
SwigType *type;
Node *n = 0;
while (!n) {
- type = Getattr((yyvsp[(1) - (1)].p),"type");
+ type = Getattr((yyvsp[0].p),"type");
n = Swig_symbol_clookup(type,0); /* See if we can find a node that matches the typename */
if ((n) && (Strcmp(nodeType(n),"cdecl") == 0)) {
SwigType *decl = Getattr(n,"decl");
String *value = Getattr(n,"value");
if (value) {
String *v = Copy(value);
- Setattr((yyvsp[(1) - (1)].p),"type",v);
+ Setattr((yyvsp[0].p),"type",v);
Delete(v);
n = 0;
}
}
}
+#line 8830 "y.tab.c" /* yacc.c:1646 */
break;
- case 245:
-
-/* Line 1806 of yacc.c */
-#line 4886 "parser.y"
+ case 290:
+#line 4869 "parser.y" /* yacc.c:1646 */
{
(yyval.p) = NewParmWithoutFileLineInfo(0,0);
Setfile((yyval.p),cparse_file);
Setline((yyval.p),cparse_line);
- Setattr((yyval.p),"value",(yyvsp[(1) - (1)].dtype).val);
+ Setattr((yyval.p),"value",(yyvsp[0].dtype).val);
}
+#line 8841 "y.tab.c" /* yacc.c:1646 */
break;
- case 246:
-
-/* Line 1806 of yacc.c */
-#line 4894 "parser.y"
+ case 291:
+#line 4877 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(2) - (2)].dtype);
- if ((yyvsp[(2) - (2)].dtype).type == T_ERROR) {
+ (yyval.dtype) = (yyvsp[0].dtype);
+ if ((yyvsp[0].dtype).type == T_ERROR) {
Swig_warning(WARN_PARSE_BAD_DEFAULT,cparse_file, cparse_line, "Can't set default argument (ignored)\n");
(yyval.dtype).val = 0;
(yyval.dtype).rawval = 0;
(yyval.dtype).bitfield = 0;
(yyval.dtype).throws = 0;
(yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
}
}
+#line 8858 "y.tab.c" /* yacc.c:1646 */
break;
- case 247:
-
-/* Line 1806 of yacc.c */
-#line 4905 "parser.y"
+ case 292:
+#line 4889 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(2) - (5)].dtype);
- if ((yyvsp[(2) - (5)].dtype).type == T_ERROR) {
+ (yyval.dtype) = (yyvsp[-3].dtype);
+ if ((yyvsp[-3].dtype).type == T_ERROR) {
Swig_warning(WARN_PARSE_BAD_DEFAULT,cparse_file, cparse_line, "Can't set default argument (ignored)\n");
- (yyval.dtype) = (yyvsp[(2) - (5)].dtype);
+ (yyval.dtype) = (yyvsp[-3].dtype);
(yyval.dtype).val = 0;
(yyval.dtype).rawval = 0;
(yyval.dtype).bitfield = 0;
(yyval.dtype).throws = 0;
(yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
} else {
- (yyval.dtype).val = NewStringf("%s[%s]",(yyvsp[(2) - (5)].dtype).val,(yyvsp[(4) - (5)].dtype).val);
+ (yyval.dtype).val = NewStringf("%s[%s]",(yyvsp[-3].dtype).val,(yyvsp[-1].dtype).val);
}
}
+#line 8878 "y.tab.c" /* yacc.c:1646 */
break;
- case 248:
-
-/* Line 1806 of yacc.c */
-#line 4919 "parser.y"
+ case 293:
+#line 4904 "parser.y" /* yacc.c:1646 */
{
skip_balanced('{','}');
- (yyval.dtype).val = 0;
+ (yyval.dtype).val = NewString(scanner_ccode);
(yyval.dtype).rawval = 0;
(yyval.dtype).type = T_INT;
(yyval.dtype).bitfield = 0;
(yyval.dtype).throws = 0;
(yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
}
+#line 8893 "y.tab.c" /* yacc.c:1646 */
break;
- case 249:
-
-/* Line 1806 of yacc.c */
-#line 4928 "parser.y"
+ case 294:
+#line 4914 "parser.y" /* yacc.c:1646 */
{
(yyval.dtype).val = 0;
(yyval.dtype).rawval = 0;
(yyval.dtype).type = 0;
- (yyval.dtype).bitfield = (yyvsp[(2) - (2)].dtype).val;
+ (yyval.dtype).bitfield = (yyvsp[0].dtype).val;
(yyval.dtype).throws = 0;
(yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
}
+#line 8907 "y.tab.c" /* yacc.c:1646 */
break;
- case 250:
-
-/* Line 1806 of yacc.c */
-#line 4936 "parser.y"
+ case 295:
+#line 4923 "parser.y" /* yacc.c:1646 */
{
(yyval.dtype).val = 0;
(yyval.dtype).rawval = 0;
(yyval.dtype).bitfield = 0;
(yyval.dtype).throws = 0;
(yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
}
+#line 8921 "y.tab.c" /* yacc.c:1646 */
break;
- case 251:
-
-/* Line 1806 of yacc.c */
-#line 4946 "parser.y"
+ case 296:
+#line 4934 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(1) - (2)].decl);
- (yyval.decl).defarg = (yyvsp[(2) - (2)].dtype).rawval ? (yyvsp[(2) - (2)].dtype).rawval : (yyvsp[(2) - (2)].dtype).val;
+ (yyval.decl) = (yyvsp[-1].decl);
+ (yyval.decl).defarg = (yyvsp[0].dtype).rawval ? (yyvsp[0].dtype).rawval : (yyvsp[0].dtype).val;
}
+#line 8930 "y.tab.c" /* yacc.c:1646 */
break;
- case 252:
-
-/* Line 1806 of yacc.c */
-#line 4950 "parser.y"
+ case 297:
+#line 4938 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(1) - (2)].decl);
- (yyval.decl).defarg = (yyvsp[(2) - (2)].dtype).rawval ? (yyvsp[(2) - (2)].dtype).rawval : (yyvsp[(2) - (2)].dtype).val;
+ (yyval.decl) = (yyvsp[-1].decl);
+ (yyval.decl).defarg = (yyvsp[0].dtype).rawval ? (yyvsp[0].dtype).rawval : (yyvsp[0].dtype).val;
}
+#line 8939 "y.tab.c" /* yacc.c:1646 */
break;
- case 253:
-
-/* Line 1806 of yacc.c */
-#line 4954 "parser.y"
+ case 298:
+#line 4942 "parser.y" /* yacc.c:1646 */
{
(yyval.decl).type = 0;
(yyval.decl).id = 0;
- (yyval.decl).defarg = (yyvsp[(1) - (1)].dtype).rawval ? (yyvsp[(1) - (1)].dtype).rawval : (yyvsp[(1) - (1)].dtype).val;
+ (yyval.decl).defarg = (yyvsp[0].dtype).rawval ? (yyvsp[0].dtype).rawval : (yyvsp[0].dtype).val;
}
+#line 8949 "y.tab.c" /* yacc.c:1646 */
break;
- case 254:
-
-/* Line 1806 of yacc.c */
-#line 4961 "parser.y"
- {
- (yyval.decl) = (yyvsp[(1) - (1)].decl);
- if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) {
- Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type));
- } else if (SwigType_isarray((yyvsp[(1) - (1)].decl).type)) {
- SwigType *ta = SwigType_pop_arrays((yyvsp[(1) - (1)].decl).type);
- if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) {
- Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type));
+ case 299:
+#line 4949 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ if (SwigType_isfunction((yyvsp[0].decl).type)) {
+ Delete(SwigType_pop_function((yyvsp[0].decl).type));
+ } else if (SwigType_isarray((yyvsp[0].decl).type)) {
+ SwigType *ta = SwigType_pop_arrays((yyvsp[0].decl).type);
+ if (SwigType_isfunction((yyvsp[0].decl).type)) {
+ Delete(SwigType_pop_function((yyvsp[0].decl).type));
} else {
(yyval.decl).parms = 0;
}
- SwigType_push((yyvsp[(1) - (1)].decl).type,ta);
+ SwigType_push((yyvsp[0].decl).type,ta);
Delete(ta);
} else {
(yyval.decl).parms = 0;
}
}
+#line 8971 "y.tab.c" /* yacc.c:1646 */
break;
- case 255:
-
-/* Line 1806 of yacc.c */
-#line 4978 "parser.y"
- {
- (yyval.decl) = (yyvsp[(1) - (1)].decl);
- if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) {
- Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type));
- } else if (SwigType_isarray((yyvsp[(1) - (1)].decl).type)) {
- SwigType *ta = SwigType_pop_arrays((yyvsp[(1) - (1)].decl).type);
- if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) {
- Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type));
+ case 300:
+#line 4966 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ if (SwigType_isfunction((yyvsp[0].decl).type)) {
+ Delete(SwigType_pop_function((yyvsp[0].decl).type));
+ } else if (SwigType_isarray((yyvsp[0].decl).type)) {
+ SwigType *ta = SwigType_pop_arrays((yyvsp[0].decl).type);
+ if (SwigType_isfunction((yyvsp[0].decl).type)) {
+ Delete(SwigType_pop_function((yyvsp[0].decl).type));
} else {
(yyval.decl).parms = 0;
}
- SwigType_push((yyvsp[(1) - (1)].decl).type,ta);
+ SwigType_push((yyvsp[0].decl).type,ta);
Delete(ta);
} else {
(yyval.decl).parms = 0;
}
}
+#line 8993 "y.tab.c" /* yacc.c:1646 */
break;
- case 256:
-
-/* Line 1806 of yacc.c */
-#line 4995 "parser.y"
+ case 301:
+#line 4983 "parser.y" /* yacc.c:1646 */
{
(yyval.decl).type = 0;
(yyval.decl).id = 0;
(yyval.decl).parms = 0;
}
+#line 9003 "y.tab.c" /* yacc.c:1646 */
break;
- case 257:
-
-/* Line 1806 of yacc.c */
-#line 5003 "parser.y"
+ case 302:
+#line 4991 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(2) - (2)].decl);
+ (yyval.decl) = (yyvsp[0].decl);
if ((yyval.decl).type) {
- SwigType_push((yyvsp[(1) - (2)].type),(yyval.decl).type);
+ SwigType_push((yyvsp[-1].type),(yyval.decl).type);
Delete((yyval.decl).type);
}
- (yyval.decl).type = (yyvsp[(1) - (2)].type);
+ (yyval.decl).type = (yyvsp[-1].type);
}
+#line 9016 "y.tab.c" /* yacc.c:1646 */
break;
- case 258:
-
-/* Line 1806 of yacc.c */
-#line 5011 "parser.y"
+ case 303:
+#line 4999 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(3) - (3)].decl);
- SwigType_add_reference((yyvsp[(1) - (3)].type));
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_reference((yyvsp[-2].type));
if ((yyval.decl).type) {
- SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type);
+ SwigType_push((yyvsp[-2].type),(yyval.decl).type);
Delete((yyval.decl).type);
}
- (yyval.decl).type = (yyvsp[(1) - (3)].type);
+ (yyval.decl).type = (yyvsp[-2].type);
}
+#line 9030 "y.tab.c" /* yacc.c:1646 */
break;
- case 259:
+ case 304:
+#line 5008 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_rvalue_reference((yyvsp[-2].type));
+ if ((yyval.decl).type) {
+ SwigType_push((yyvsp[-2].type),(yyval.decl).type);
+ Delete((yyval.decl).type);
+ }
+ (yyval.decl).type = (yyvsp[-2].type);
+ }
+#line 9044 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5020 "parser.y"
+ case 305:
+#line 5017 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(1) - (1)].decl);
+ (yyval.decl) = (yyvsp[0].decl);
if (!(yyval.decl).type) (yyval.decl).type = NewStringEmpty();
}
+#line 9053 "y.tab.c" /* yacc.c:1646 */
break;
- case 260:
+ case 306:
+#line 5021 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ (yyval.decl).type = NewStringEmpty();
+ SwigType_add_reference((yyval.decl).type);
+ if ((yyvsp[0].decl).type) {
+ SwigType_push((yyval.decl).type,(yyvsp[0].decl).type);
+ Delete((yyvsp[0].decl).type);
+ }
+ }
+#line 9067 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 307:
+#line 5030 "parser.y" /* yacc.c:1646 */
+ {
+ /* Introduced in C++11, move operator && */
+ /* Adds one S/R conflict */
+ (yyval.decl) = (yyvsp[0].decl);
+ (yyval.decl).type = NewStringEmpty();
+ SwigType_add_rvalue_reference((yyval.decl).type);
+ if ((yyvsp[0].decl).type) {
+ SwigType_push((yyval.decl).type,(yyvsp[0].decl).type);
+ Delete((yyvsp[0].decl).type);
+ }
+ }
+#line 9083 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 308:
+#line 5041 "parser.y" /* yacc.c:1646 */
+ {
+ SwigType *t = NewStringEmpty();
+
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_memberpointer(t,(yyvsp[-2].str));
+ if ((yyval.decl).type) {
+ SwigType_push(t,(yyval.decl).type);
+ Delete((yyval.decl).type);
+ }
+ (yyval.decl).type = t;
+ }
+#line 9099 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5024 "parser.y"
+ case 309:
+#line 5052 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(2) - (2)].decl);
+ SwigType *t = NewStringEmpty();
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_memberpointer(t,(yyvsp[-2].str));
+ SwigType_push((yyvsp[-3].type),t);
+ if ((yyval.decl).type) {
+ SwigType_push((yyvsp[-3].type),(yyval.decl).type);
+ Delete((yyval.decl).type);
+ }
+ (yyval.decl).type = (yyvsp[-3].type);
+ Delete(t);
+ }
+#line 9116 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 310:
+#line 5064 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_memberpointer((yyvsp[-4].type),(yyvsp[-3].str));
+ SwigType_add_reference((yyvsp[-4].type));
+ if ((yyval.decl).type) {
+ SwigType_push((yyvsp[-4].type),(yyval.decl).type);
+ Delete((yyval.decl).type);
+ }
+ (yyval.decl).type = (yyvsp[-4].type);
+ }
+#line 9131 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 311:
+#line 5074 "parser.y" /* yacc.c:1646 */
+ {
+ SwigType *t = NewStringEmpty();
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_memberpointer(t,(yyvsp[-3].str));
+ SwigType_add_reference(t);
+ if ((yyval.decl).type) {
+ SwigType_push(t,(yyval.decl).type);
+ Delete((yyval.decl).type);
+ }
+ (yyval.decl).type = t;
+ }
+#line 9147 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 312:
+#line 5088 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ if ((yyval.decl).type) {
+ SwigType_push((yyvsp[-4].type),(yyval.decl).type);
+ Delete((yyval.decl).type);
+ }
+ (yyval.decl).type = (yyvsp[-4].type);
+ }
+#line 9160 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 313:
+#line 5096 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_reference((yyvsp[-5].type));
+ if ((yyval.decl).type) {
+ SwigType_push((yyvsp[-5].type),(yyval.decl).type);
+ Delete((yyval.decl).type);
+ }
+ (yyval.decl).type = (yyvsp[-5].type);
+ }
+#line 9174 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 314:
+#line 5105 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_rvalue_reference((yyvsp[-5].type));
+ if ((yyval.decl).type) {
+ SwigType_push((yyvsp[-5].type),(yyval.decl).type);
+ Delete((yyval.decl).type);
+ }
+ (yyval.decl).type = (yyvsp[-5].type);
+ }
+#line 9188 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 315:
+#line 5114 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ if (!(yyval.decl).type) (yyval.decl).type = NewStringEmpty();
+ }
+#line 9197 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 316:
+#line 5118 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ (yyval.decl).type = NewStringEmpty();
+ SwigType_add_reference((yyval.decl).type);
+ if ((yyvsp[0].decl).type) {
+ SwigType_push((yyval.decl).type,(yyvsp[0].decl).type);
+ Delete((yyvsp[0].decl).type);
+ }
+ }
+#line 9211 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 317:
+#line 5127 "parser.y" /* yacc.c:1646 */
+ {
+ /* Introduced in C++11, move operator && */
+ /* Adds one S/R conflict */
+ (yyval.decl) = (yyvsp[0].decl);
(yyval.decl).type = NewStringEmpty();
- SwigType_add_reference((yyval.decl).type);
- if ((yyvsp[(2) - (2)].decl).type) {
- SwigType_push((yyval.decl).type,(yyvsp[(2) - (2)].decl).type);
- Delete((yyvsp[(2) - (2)].decl).type);
+ SwigType_add_rvalue_reference((yyval.decl).type);
+ if ((yyvsp[0].decl).type) {
+ SwigType_push((yyval.decl).type,(yyvsp[0].decl).type);
+ Delete((yyvsp[0].decl).type);
}
}
+#line 9227 "y.tab.c" /* yacc.c:1646 */
break;
- case 261:
-
-/* Line 1806 of yacc.c */
-#line 5033 "parser.y"
+ case 318:
+#line 5138 "parser.y" /* yacc.c:1646 */
{
SwigType *t = NewStringEmpty();
- (yyval.decl) = (yyvsp[(3) - (3)].decl);
- SwigType_add_memberpointer(t,(yyvsp[(1) - (3)].str));
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_memberpointer(t,(yyvsp[-5].str));
if ((yyval.decl).type) {
SwigType_push(t,(yyval.decl).type);
Delete((yyval.decl).type);
}
(yyval.decl).type = t;
}
+#line 9243 "y.tab.c" /* yacc.c:1646 */
break;
- case 262:
-
-/* Line 1806 of yacc.c */
-#line 5044 "parser.y"
+ case 319:
+#line 5149 "parser.y" /* yacc.c:1646 */
{
SwigType *t = NewStringEmpty();
- (yyval.decl) = (yyvsp[(4) - (4)].decl);
- SwigType_add_memberpointer(t,(yyvsp[(2) - (4)].str));
- SwigType_push((yyvsp[(1) - (4)].type),t);
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_memberpointer(t,(yyvsp[-5].str));
+ SwigType_push((yyvsp[-6].type),t);
if ((yyval.decl).type) {
- SwigType_push((yyvsp[(1) - (4)].type),(yyval.decl).type);
+ SwigType_push((yyvsp[-6].type),(yyval.decl).type);
Delete((yyval.decl).type);
}
- (yyval.decl).type = (yyvsp[(1) - (4)].type);
+ (yyval.decl).type = (yyvsp[-6].type);
Delete(t);
}
+#line 9260 "y.tab.c" /* yacc.c:1646 */
break;
- case 263:
-
-/* Line 1806 of yacc.c */
-#line 5056 "parser.y"
+ case 320:
+#line 5161 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(5) - (5)].decl);
- SwigType_add_memberpointer((yyvsp[(1) - (5)].type),(yyvsp[(2) - (5)].str));
- SwigType_add_reference((yyvsp[(1) - (5)].type));
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_memberpointer((yyvsp[-7].type),(yyvsp[-6].str));
+ SwigType_add_reference((yyvsp[-7].type));
if ((yyval.decl).type) {
- SwigType_push((yyvsp[(1) - (5)].type),(yyval.decl).type);
+ SwigType_push((yyvsp[-7].type),(yyval.decl).type);
Delete((yyval.decl).type);
}
- (yyval.decl).type = (yyvsp[(1) - (5)].type);
+ (yyval.decl).type = (yyvsp[-7].type);
}
+#line 9275 "y.tab.c" /* yacc.c:1646 */
break;
- case 264:
+ case 321:
+#line 5171 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_memberpointer((yyvsp[-7].type),(yyvsp[-6].str));
+ SwigType_add_rvalue_reference((yyvsp[-7].type));
+ if ((yyval.decl).type) {
+ SwigType_push((yyvsp[-7].type),(yyval.decl).type);
+ Delete((yyval.decl).type);
+ }
+ (yyval.decl).type = (yyvsp[-7].type);
+ }
+#line 9290 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5066 "parser.y"
+ case 322:
+#line 5181 "parser.y" /* yacc.c:1646 */
{
SwigType *t = NewStringEmpty();
- (yyval.decl) = (yyvsp[(4) - (4)].decl);
- SwigType_add_memberpointer(t,(yyvsp[(1) - (4)].str));
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_memberpointer(t,(yyvsp[-6].str));
SwigType_add_reference(t);
if ((yyval.decl).type) {
SwigType_push(t,(yyval.decl).type);
}
(yyval.decl).type = t;
}
+#line 9306 "y.tab.c" /* yacc.c:1646 */
break;
- case 265:
+ case 323:
+#line 5192 "parser.y" /* yacc.c:1646 */
+ {
+ SwigType *t = NewStringEmpty();
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_memberpointer(t,(yyvsp[-6].str));
+ SwigType_add_rvalue_reference(t);
+ if ((yyval.decl).type) {
+ SwigType_push(t,(yyval.decl).type);
+ Delete((yyval.decl).type);
+ }
+ (yyval.decl).type = t;
+ }
+#line 9322 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5079 "parser.y"
+ case 324:
+#line 5205 "parser.y" /* yacc.c:1646 */
{
/* Note: This is non-standard C. Template declarator is allowed to follow an identifier */
- (yyval.decl).id = Char((yyvsp[(1) - (1)].str));
+ (yyval.decl).id = Char((yyvsp[0].str));
(yyval.decl).type = 0;
(yyval.decl).parms = 0;
(yyval.decl).have_parms = 0;
}
+#line 9334 "y.tab.c" /* yacc.c:1646 */
break;
- case 266:
-
-/* Line 1806 of yacc.c */
-#line 5086 "parser.y"
+ case 325:
+#line 5212 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl).id = Char(NewStringf("~%s",(yyvsp[(2) - (2)].str)));
+ (yyval.decl).id = Char(NewStringf("~%s",(yyvsp[0].str)));
(yyval.decl).type = 0;
(yyval.decl).parms = 0;
(yyval.decl).have_parms = 0;
}
+#line 9345 "y.tab.c" /* yacc.c:1646 */
break;
- case 267:
-
-/* Line 1806 of yacc.c */
-#line 5094 "parser.y"
+ case 326:
+#line 5220 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl).id = Char((yyvsp[(2) - (3)].str));
+ (yyval.decl).id = Char((yyvsp[-1].str));
(yyval.decl).type = 0;
(yyval.decl).parms = 0;
(yyval.decl).have_parms = 0;
}
+#line 9356 "y.tab.c" /* yacc.c:1646 */
break;
- case 268:
-
-/* Line 1806 of yacc.c */
-#line 5110 "parser.y"
+ case 327:
+#line 5236 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(3) - (4)].decl);
+ (yyval.decl) = (yyvsp[-1].decl);
if ((yyval.decl).type) {
- SwigType_push((yyvsp[(2) - (4)].type),(yyval.decl).type);
+ SwigType_push((yyvsp[-2].type),(yyval.decl).type);
Delete((yyval.decl).type);
}
- (yyval.decl).type = (yyvsp[(2) - (4)].type);
+ (yyval.decl).type = (yyvsp[-2].type);
}
+#line 9369 "y.tab.c" /* yacc.c:1646 */
break;
- case 269:
-
-/* Line 1806 of yacc.c */
-#line 5118 "parser.y"
+ case 328:
+#line 5244 "parser.y" /* yacc.c:1646 */
{
SwigType *t;
- (yyval.decl) = (yyvsp[(4) - (5)].decl);
+ (yyval.decl) = (yyvsp[-1].decl);
t = NewStringEmpty();
- SwigType_add_memberpointer(t,(yyvsp[(2) - (5)].str));
+ SwigType_add_memberpointer(t,(yyvsp[-3].str));
if ((yyval.decl).type) {
SwigType_push(t,(yyval.decl).type);
Delete((yyval.decl).type);
}
(yyval.decl).type = t;
}
+#line 9385 "y.tab.c" /* yacc.c:1646 */
break;
- case 270:
-
-/* Line 1806 of yacc.c */
-#line 5129 "parser.y"
+ case 329:
+#line 5255 "parser.y" /* yacc.c:1646 */
{
SwigType *t;
- (yyval.decl) = (yyvsp[(1) - (3)].decl);
+ (yyval.decl) = (yyvsp[-2].decl);
t = NewStringEmpty();
- SwigType_add_array(t,(char*)"");
+ SwigType_add_array(t,"");
if ((yyval.decl).type) {
SwigType_push(t,(yyval.decl).type);
Delete((yyval.decl).type);
}
(yyval.decl).type = t;
}
+#line 9401 "y.tab.c" /* yacc.c:1646 */
break;
- case 271:
-
-/* Line 1806 of yacc.c */
-#line 5140 "parser.y"
+ case 330:
+#line 5266 "parser.y" /* yacc.c:1646 */
{
SwigType *t;
- (yyval.decl) = (yyvsp[(1) - (4)].decl);
+ (yyval.decl) = (yyvsp[-3].decl);
t = NewStringEmpty();
- SwigType_add_array(t,(yyvsp[(3) - (4)].dtype).val);
+ SwigType_add_array(t,(yyvsp[-1].dtype).val);
if ((yyval.decl).type) {
SwigType_push(t,(yyval.decl).type);
Delete((yyval.decl).type);
}
(yyval.decl).type = t;
}
+#line 9417 "y.tab.c" /* yacc.c:1646 */
break;
- case 272:
-
-/* Line 1806 of yacc.c */
-#line 5151 "parser.y"
+ case 331:
+#line 5277 "parser.y" /* yacc.c:1646 */
{
SwigType *t;
- (yyval.decl) = (yyvsp[(1) - (4)].decl);
+ (yyval.decl) = (yyvsp[-3].decl);
t = NewStringEmpty();
- SwigType_add_function(t,(yyvsp[(3) - (4)].pl));
+ SwigType_add_function(t,(yyvsp[-1].pl));
if (!(yyval.decl).have_parms) {
- (yyval.decl).parms = (yyvsp[(3) - (4)].pl);
+ (yyval.decl).parms = (yyvsp[-1].pl);
(yyval.decl).have_parms = 1;
}
if (!(yyval.decl).type) {
(yyval.decl).type = t;
}
}
+#line 9439 "y.tab.c" /* yacc.c:1646 */
break;
- case 273:
-
-/* Line 1806 of yacc.c */
-#line 5170 "parser.y"
+ case 332:
+#line 5296 "parser.y" /* yacc.c:1646 */
{
/* Note: This is non-standard C. Template declarator is allowed to follow an identifier */
- (yyval.decl).id = Char((yyvsp[(1) - (1)].str));
+ (yyval.decl).id = Char((yyvsp[0].str));
(yyval.decl).type = 0;
(yyval.decl).parms = 0;
(yyval.decl).have_parms = 0;
}
+#line 9451 "y.tab.c" /* yacc.c:1646 */
break;
- case 274:
-
-/* Line 1806 of yacc.c */
-#line 5178 "parser.y"
+ case 333:
+#line 5304 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl).id = Char(NewStringf("~%s",(yyvsp[(2) - (2)].str)));
+ (yyval.decl).id = Char(NewStringf("~%s",(yyvsp[0].str)));
(yyval.decl).type = 0;
(yyval.decl).parms = 0;
(yyval.decl).have_parms = 0;
}
+#line 9462 "y.tab.c" /* yacc.c:1646 */
break;
- case 275:
-
-/* Line 1806 of yacc.c */
-#line 5195 "parser.y"
+ case 334:
+#line 5321 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(3) - (4)].decl);
+ (yyval.decl) = (yyvsp[-1].decl);
if ((yyval.decl).type) {
- SwigType_push((yyvsp[(2) - (4)].type),(yyval.decl).type);
+ SwigType_push((yyvsp[-2].type),(yyval.decl).type);
Delete((yyval.decl).type);
}
- (yyval.decl).type = (yyvsp[(2) - (4)].type);
+ (yyval.decl).type = (yyvsp[-2].type);
}
+#line 9475 "y.tab.c" /* yacc.c:1646 */
break;
- case 276:
-
-/* Line 1806 of yacc.c */
-#line 5203 "parser.y"
+ case 335:
+#line 5329 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(3) - (4)].decl);
+ (yyval.decl) = (yyvsp[-1].decl);
if (!(yyval.decl).type) {
(yyval.decl).type = NewStringEmpty();
}
SwigType_add_reference((yyval.decl).type);
}
+#line 9487 "y.tab.c" /* yacc.c:1646 */
break;
- case 277:
+ case 336:
+#line 5336 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[-1].decl);
+ if (!(yyval.decl).type) {
+ (yyval.decl).type = NewStringEmpty();
+ }
+ SwigType_add_rvalue_reference((yyval.decl).type);
+ }
+#line 9499 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5210 "parser.y"
+ case 337:
+#line 5343 "parser.y" /* yacc.c:1646 */
{
SwigType *t;
- (yyval.decl) = (yyvsp[(4) - (5)].decl);
+ (yyval.decl) = (yyvsp[-1].decl);
t = NewStringEmpty();
- SwigType_add_memberpointer(t,(yyvsp[(2) - (5)].str));
+ SwigType_add_memberpointer(t,(yyvsp[-3].str));
if ((yyval.decl).type) {
SwigType_push(t,(yyval.decl).type);
Delete((yyval.decl).type);
}
(yyval.decl).type = t;
}
+#line 9515 "y.tab.c" /* yacc.c:1646 */
break;
- case 278:
-
-/* Line 1806 of yacc.c */
-#line 5221 "parser.y"
+ case 338:
+#line 5354 "parser.y" /* yacc.c:1646 */
{
SwigType *t;
- (yyval.decl) = (yyvsp[(1) - (3)].decl);
+ (yyval.decl) = (yyvsp[-2].decl);
t = NewStringEmpty();
- SwigType_add_array(t,(char*)"");
+ SwigType_add_array(t,"");
if ((yyval.decl).type) {
SwigType_push(t,(yyval.decl).type);
Delete((yyval.decl).type);
}
(yyval.decl).type = t;
}
+#line 9531 "y.tab.c" /* yacc.c:1646 */
break;
- case 279:
-
-/* Line 1806 of yacc.c */
-#line 5232 "parser.y"
+ case 339:
+#line 5365 "parser.y" /* yacc.c:1646 */
{
SwigType *t;
- (yyval.decl) = (yyvsp[(1) - (4)].decl);
+ (yyval.decl) = (yyvsp[-3].decl);
t = NewStringEmpty();
- SwigType_add_array(t,(yyvsp[(3) - (4)].dtype).val);
+ SwigType_add_array(t,(yyvsp[-1].dtype).val);
if ((yyval.decl).type) {
SwigType_push(t,(yyval.decl).type);
Delete((yyval.decl).type);
}
(yyval.decl).type = t;
}
+#line 9547 "y.tab.c" /* yacc.c:1646 */
break;
- case 280:
+ case 340:
+#line 5376 "parser.y" /* yacc.c:1646 */
+ {
+ SwigType *t;
+ (yyval.decl) = (yyvsp[-3].decl);
+ t = NewStringEmpty();
+ SwigType_add_function(t,(yyvsp[-1].pl));
+ if (!(yyval.decl).have_parms) {
+ (yyval.decl).parms = (yyvsp[-1].pl);
+ (yyval.decl).have_parms = 1;
+ }
+ if (!(yyval.decl).type) {
+ (yyval.decl).type = t;
+ } else {
+ SwigType_push(t, (yyval.decl).type);
+ Delete((yyval.decl).type);
+ (yyval.decl).type = t;
+ }
+ }
+#line 9569 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5243 "parser.y"
+ case 341:
+#line 5396 "parser.y" /* yacc.c:1646 */
{
SwigType *t;
- (yyval.decl) = (yyvsp[(1) - (4)].decl);
+ Append((yyvsp[-4].str), " "); /* intervening space is mandatory */
+ Append((yyvsp[-4].str), Char((yyvsp[-3].id)));
+ (yyval.decl).id = Char((yyvsp[-4].str));
t = NewStringEmpty();
- SwigType_add_function(t,(yyvsp[(3) - (4)].pl));
+ SwigType_add_function(t,(yyvsp[-1].pl));
if (!(yyval.decl).have_parms) {
- (yyval.decl).parms = (yyvsp[(3) - (4)].pl);
+ (yyval.decl).parms = (yyvsp[-1].pl);
(yyval.decl).have_parms = 1;
}
if (!(yyval.decl).type) {
(yyval.decl).type = t;
}
}
+#line 9593 "y.tab.c" /* yacc.c:1646 */
break;
- case 281:
-
-/* Line 1806 of yacc.c */
-#line 5262 "parser.y"
+ case 342:
+#line 5417 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl).type = (yyvsp[(1) - (1)].type);
+ (yyval.decl).type = (yyvsp[0].type);
(yyval.decl).id = 0;
(yyval.decl).parms = 0;
(yyval.decl).have_parms = 0;
}
+#line 9604 "y.tab.c" /* yacc.c:1646 */
break;
- case 282:
-
-/* Line 1806 of yacc.c */
-#line 5268 "parser.y"
+ case 343:
+#line 5423 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(2) - (2)].decl);
- SwigType_push((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).type);
- (yyval.decl).type = (yyvsp[(1) - (2)].type);
- Delete((yyvsp[(2) - (2)].decl).type);
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_push((yyvsp[-1].type),(yyvsp[0].decl).type);
+ (yyval.decl).type = (yyvsp[-1].type);
+ Delete((yyvsp[0].decl).type);
}
+#line 9615 "y.tab.c" /* yacc.c:1646 */
break;
- case 283:
-
-/* Line 1806 of yacc.c */
-#line 5274 "parser.y"
+ case 344:
+#line 5429 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl).type = (yyvsp[(1) - (2)].type);
+ (yyval.decl).type = (yyvsp[-1].type);
SwigType_add_reference((yyval.decl).type);
(yyval.decl).id = 0;
(yyval.decl).parms = 0;
(yyval.decl).have_parms = 0;
}
+#line 9627 "y.tab.c" /* yacc.c:1646 */
break;
- case 284:
+ case 345:
+#line 5436 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl).type = (yyvsp[-1].type);
+ SwigType_add_rvalue_reference((yyval.decl).type);
+ (yyval.decl).id = 0;
+ (yyval.decl).parms = 0;
+ (yyval.decl).have_parms = 0;
+ }
+#line 9639 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5281 "parser.y"
+ case 346:
+#line 5443 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(3) - (3)].decl);
- SwigType_add_reference((yyvsp[(1) - (3)].type));
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_reference((yyvsp[-2].type));
if ((yyval.decl).type) {
- SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type);
+ SwigType_push((yyvsp[-2].type),(yyval.decl).type);
Delete((yyval.decl).type);
}
- (yyval.decl).type = (yyvsp[(1) - (3)].type);
+ (yyval.decl).type = (yyvsp[-2].type);
}
+#line 9653 "y.tab.c" /* yacc.c:1646 */
break;
- case 285:
-
-/* Line 1806 of yacc.c */
-#line 5290 "parser.y"
+ case 347:
+#line 5452 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(1) - (1)].decl);
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_rvalue_reference((yyvsp[-2].type));
+ if ((yyval.decl).type) {
+ SwigType_push((yyvsp[-2].type),(yyval.decl).type);
+ Delete((yyval.decl).type);
+ }
+ (yyval.decl).type = (yyvsp[-2].type);
}
+#line 9667 "y.tab.c" /* yacc.c:1646 */
break;
- case 286:
+ case 348:
+#line 5461 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ }
+#line 9675 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5293 "parser.y"
+ case 349:
+#line 5464 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(2) - (2)].decl);
+ (yyval.decl) = (yyvsp[0].decl);
(yyval.decl).type = NewStringEmpty();
SwigType_add_reference((yyval.decl).type);
- if ((yyvsp[(2) - (2)].decl).type) {
- SwigType_push((yyval.decl).type,(yyvsp[(2) - (2)].decl).type);
- Delete((yyvsp[(2) - (2)].decl).type);
+ if ((yyvsp[0].decl).type) {
+ SwigType_push((yyval.decl).type,(yyvsp[0].decl).type);
+ Delete((yyvsp[0].decl).type);
}
}
+#line 9689 "y.tab.c" /* yacc.c:1646 */
break;
- case 287:
+ case 350:
+#line 5473 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl) = (yyvsp[0].decl);
+ (yyval.decl).type = NewStringEmpty();
+ SwigType_add_rvalue_reference((yyval.decl).type);
+ if ((yyvsp[0].decl).type) {
+ SwigType_push((yyval.decl).type,(yyvsp[0].decl).type);
+ Delete((yyvsp[0].decl).type);
+ }
+ }
+#line 9703 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5302 "parser.y"
- {
+ case 351:
+#line 5482 "parser.y" /* yacc.c:1646 */
+ {
(yyval.decl).id = 0;
(yyval.decl).parms = 0;
(yyval.decl).have_parms = 0;
(yyval.decl).type = NewStringEmpty();
SwigType_add_reference((yyval.decl).type);
}
+#line 9715 "y.tab.c" /* yacc.c:1646 */
break;
- case 288:
+ case 352:
+#line 5489 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl).id = 0;
+ (yyval.decl).parms = 0;
+ (yyval.decl).have_parms = 0;
+ (yyval.decl).type = NewStringEmpty();
+ SwigType_add_rvalue_reference((yyval.decl).type);
+ }
+#line 9727 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5309 "parser.y"
+ case 353:
+#line 5496 "parser.y" /* yacc.c:1646 */
{
(yyval.decl).type = NewStringEmpty();
- SwigType_add_memberpointer((yyval.decl).type,(yyvsp[(1) - (2)].str));
+ SwigType_add_memberpointer((yyval.decl).type,(yyvsp[-1].str));
(yyval.decl).id = 0;
(yyval.decl).parms = 0;
(yyval.decl).have_parms = 0;
}
+#line 9739 "y.tab.c" /* yacc.c:1646 */
break;
- case 289:
-
-/* Line 1806 of yacc.c */
-#line 5316 "parser.y"
+ case 354:
+#line 5503 "parser.y" /* yacc.c:1646 */
{
SwigType *t = NewStringEmpty();
- (yyval.decl).type = (yyvsp[(1) - (3)].type);
+ (yyval.decl).type = (yyvsp[-2].type);
(yyval.decl).id = 0;
(yyval.decl).parms = 0;
(yyval.decl).have_parms = 0;
- SwigType_add_memberpointer(t,(yyvsp[(2) - (3)].str));
+ SwigType_add_memberpointer(t,(yyvsp[-1].str));
SwigType_push((yyval.decl).type,t);
Delete(t);
}
+#line 9754 "y.tab.c" /* yacc.c:1646 */
break;
- case 290:
-
-/* Line 1806 of yacc.c */
-#line 5326 "parser.y"
+ case 355:
+#line 5513 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(4) - (4)].decl);
- SwigType_add_memberpointer((yyvsp[(1) - (4)].type),(yyvsp[(2) - (4)].str));
+ (yyval.decl) = (yyvsp[0].decl);
+ SwigType_add_memberpointer((yyvsp[-3].type),(yyvsp[-2].str));
if ((yyval.decl).type) {
- SwigType_push((yyvsp[(1) - (4)].type),(yyval.decl).type);
+ SwigType_push((yyvsp[-3].type),(yyval.decl).type);
Delete((yyval.decl).type);
}
- (yyval.decl).type = (yyvsp[(1) - (4)].type);
+ (yyval.decl).type = (yyvsp[-3].type);
}
+#line 9768 "y.tab.c" /* yacc.c:1646 */
break;
- case 291:
-
-/* Line 1806 of yacc.c */
-#line 5337 "parser.y"
+ case 356:
+#line 5524 "parser.y" /* yacc.c:1646 */
{
SwigType *t;
- (yyval.decl) = (yyvsp[(1) - (3)].decl);
+ (yyval.decl) = (yyvsp[-2].decl);
t = NewStringEmpty();
- SwigType_add_array(t,(char*)"");
+ SwigType_add_array(t,"");
if ((yyval.decl).type) {
SwigType_push(t,(yyval.decl).type);
Delete((yyval.decl).type);
}
(yyval.decl).type = t;
}
+#line 9784 "y.tab.c" /* yacc.c:1646 */
break;
- case 292:
-
-/* Line 1806 of yacc.c */
-#line 5348 "parser.y"
+ case 357:
+#line 5535 "parser.y" /* yacc.c:1646 */
{
SwigType *t;
- (yyval.decl) = (yyvsp[(1) - (4)].decl);
+ (yyval.decl) = (yyvsp[-3].decl);
t = NewStringEmpty();
- SwigType_add_array(t,(yyvsp[(3) - (4)].dtype).val);
+ SwigType_add_array(t,(yyvsp[-1].dtype).val);
if ((yyval.decl).type) {
SwigType_push(t,(yyval.decl).type);
Delete((yyval.decl).type);
}
(yyval.decl).type = t;
}
+#line 9800 "y.tab.c" /* yacc.c:1646 */
break;
- case 293:
-
-/* Line 1806 of yacc.c */
-#line 5359 "parser.y"
+ case 358:
+#line 5546 "parser.y" /* yacc.c:1646 */
{
(yyval.decl).type = NewStringEmpty();
(yyval.decl).id = 0;
(yyval.decl).parms = 0;
(yyval.decl).have_parms = 0;
- SwigType_add_array((yyval.decl).type,(char*)"");
+ SwigType_add_array((yyval.decl).type,"");
}
+#line 9812 "y.tab.c" /* yacc.c:1646 */
break;
- case 294:
-
-/* Line 1806 of yacc.c */
-#line 5366 "parser.y"
+ case 359:
+#line 5553 "parser.y" /* yacc.c:1646 */
{
(yyval.decl).type = NewStringEmpty();
(yyval.decl).id = 0;
(yyval.decl).parms = 0;
(yyval.decl).have_parms = 0;
- SwigType_add_array((yyval.decl).type,(yyvsp[(2) - (3)].dtype).val);
+ SwigType_add_array((yyval.decl).type,(yyvsp[-1].dtype).val);
}
+#line 9824 "y.tab.c" /* yacc.c:1646 */
break;
- case 295:
-
-/* Line 1806 of yacc.c */
-#line 5373 "parser.y"
+ case 360:
+#line 5560 "parser.y" /* yacc.c:1646 */
{
- (yyval.decl) = (yyvsp[(2) - (3)].decl);
+ (yyval.decl) = (yyvsp[-1].decl);
}
+#line 9832 "y.tab.c" /* yacc.c:1646 */
break;
- case 296:
-
-/* Line 1806 of yacc.c */
-#line 5376 "parser.y"
+ case 361:
+#line 5563 "parser.y" /* yacc.c:1646 */
{
SwigType *t;
- (yyval.decl) = (yyvsp[(1) - (4)].decl);
+ (yyval.decl) = (yyvsp[-3].decl);
t = NewStringEmpty();
- SwigType_add_function(t,(yyvsp[(3) - (4)].pl));
+ SwigType_add_function(t,(yyvsp[-1].pl));
if (!(yyval.decl).type) {
(yyval.decl).type = t;
} else {
(yyval.decl).type = t;
}
if (!(yyval.decl).have_parms) {
- (yyval.decl).parms = (yyvsp[(3) - (4)].pl);
+ (yyval.decl).parms = (yyvsp[-1].pl);
(yyval.decl).have_parms = 1;
}
}
+#line 9854 "y.tab.c" /* yacc.c:1646 */
break;
- case 297:
-
-/* Line 1806 of yacc.c */
-#line 5393 "parser.y"
+ case 362:
+#line 5580 "parser.y" /* yacc.c:1646 */
{
(yyval.decl).type = NewStringEmpty();
- SwigType_add_function((yyval.decl).type,(yyvsp[(2) - (3)].pl));
- (yyval.decl).parms = (yyvsp[(2) - (3)].pl);
+ SwigType_add_function((yyval.decl).type,(yyvsp[-1].pl));
+ (yyval.decl).parms = (yyvsp[-1].pl);
(yyval.decl).have_parms = 1;
(yyval.decl).id = 0;
}
+#line 9866 "y.tab.c" /* yacc.c:1646 */
break;
- case 298:
-
-/* Line 1806 of yacc.c */
-#line 5403 "parser.y"
+ case 363:
+#line 5590 "parser.y" /* yacc.c:1646 */
{
(yyval.type) = NewStringEmpty();
SwigType_add_pointer((yyval.type));
- SwigType_push((yyval.type),(yyvsp[(2) - (3)].str));
- SwigType_push((yyval.type),(yyvsp[(3) - (3)].type));
- Delete((yyvsp[(3) - (3)].type));
+ SwigType_push((yyval.type),(yyvsp[-1].str));
+ SwigType_push((yyval.type),(yyvsp[0].type));
+ Delete((yyvsp[0].type));
}
+#line 9878 "y.tab.c" /* yacc.c:1646 */
break;
- case 299:
-
-/* Line 1806 of yacc.c */
-#line 5410 "parser.y"
+ case 364:
+#line 5597 "parser.y" /* yacc.c:1646 */
{
(yyval.type) = NewStringEmpty();
SwigType_add_pointer((yyval.type));
- SwigType_push((yyval.type),(yyvsp[(2) - (2)].type));
- Delete((yyvsp[(2) - (2)].type));
+ SwigType_push((yyval.type),(yyvsp[0].type));
+ Delete((yyvsp[0].type));
}
+#line 9889 "y.tab.c" /* yacc.c:1646 */
break;
- case 300:
-
-/* Line 1806 of yacc.c */
-#line 5416 "parser.y"
+ case 365:
+#line 5603 "parser.y" /* yacc.c:1646 */
{
(yyval.type) = NewStringEmpty();
SwigType_add_pointer((yyval.type));
- SwigType_push((yyval.type),(yyvsp[(2) - (2)].str));
+ SwigType_push((yyval.type),(yyvsp[0].str));
}
+#line 9899 "y.tab.c" /* yacc.c:1646 */
break;
- case 301:
-
-/* Line 1806 of yacc.c */
-#line 5421 "parser.y"
+ case 366:
+#line 5608 "parser.y" /* yacc.c:1646 */
{
(yyval.type) = NewStringEmpty();
SwigType_add_pointer((yyval.type));
}
+#line 9908 "y.tab.c" /* yacc.c:1646 */
break;
- case 302:
-
-/* Line 1806 of yacc.c */
-#line 5427 "parser.y"
+ case 367:
+#line 5614 "parser.y" /* yacc.c:1646 */
{
(yyval.str) = NewStringEmpty();
- if ((yyvsp[(1) - (1)].id)) SwigType_add_qualifier((yyval.str),(yyvsp[(1) - (1)].id));
+ if ((yyvsp[0].id)) SwigType_add_qualifier((yyval.str),(yyvsp[0].id));
}
+#line 9917 "y.tab.c" /* yacc.c:1646 */
break;
- case 303:
-
-/* Line 1806 of yacc.c */
-#line 5431 "parser.y"
+ case 368:
+#line 5618 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = (yyvsp[(2) - (2)].str);
- if ((yyvsp[(1) - (2)].id)) SwigType_add_qualifier((yyval.str),(yyvsp[(1) - (2)].id));
+ (yyval.str) = (yyvsp[0].str);
+ if ((yyvsp[-1].id)) SwigType_add_qualifier((yyval.str),(yyvsp[-1].id));
}
+#line 9926 "y.tab.c" /* yacc.c:1646 */
break;
- case 304:
-
-/* Line 1806 of yacc.c */
-#line 5437 "parser.y"
+ case 369:
+#line 5624 "parser.y" /* yacc.c:1646 */
{ (yyval.id) = "const"; }
+#line 9932 "y.tab.c" /* yacc.c:1646 */
break;
- case 305:
-
-/* Line 1806 of yacc.c */
-#line 5438 "parser.y"
+ case 370:
+#line 5625 "parser.y" /* yacc.c:1646 */
{ (yyval.id) = "volatile"; }
+#line 9938 "y.tab.c" /* yacc.c:1646 */
break;
- case 306:
-
-/* Line 1806 of yacc.c */
-#line 5439 "parser.y"
+ case 371:
+#line 5626 "parser.y" /* yacc.c:1646 */
{ (yyval.id) = 0; }
+#line 9944 "y.tab.c" /* yacc.c:1646 */
break;
- case 307:
-
-/* Line 1806 of yacc.c */
-#line 5445 "parser.y"
+ case 372:
+#line 5632 "parser.y" /* yacc.c:1646 */
{
- (yyval.type) = (yyvsp[(1) - (1)].type);
+ (yyval.type) = (yyvsp[0].type);
Replace((yyval.type),"typename ","", DOH_REPLACE_ANY);
}
+#line 9953 "y.tab.c" /* yacc.c:1646 */
break;
- case 308:
-
-/* Line 1806 of yacc.c */
-#line 5451 "parser.y"
+ case 373:
+#line 5638 "parser.y" /* yacc.c:1646 */
{
- (yyval.type) = (yyvsp[(2) - (2)].type);
- SwigType_push((yyval.type),(yyvsp[(1) - (2)].str));
+ (yyval.type) = (yyvsp[0].type);
+ SwigType_push((yyval.type),(yyvsp[-1].str));
}
+#line 9962 "y.tab.c" /* yacc.c:1646 */
break;
- case 309:
-
-/* Line 1806 of yacc.c */
-#line 5455 "parser.y"
- { (yyval.type) = (yyvsp[(1) - (1)].type); }
+ case 374:
+#line 5642 "parser.y" /* yacc.c:1646 */
+ { (yyval.type) = (yyvsp[0].type); }
+#line 9968 "y.tab.c" /* yacc.c:1646 */
break;
- case 310:
-
-/* Line 1806 of yacc.c */
-#line 5456 "parser.y"
+ case 375:
+#line 5643 "parser.y" /* yacc.c:1646 */
{
- (yyval.type) = (yyvsp[(1) - (2)].type);
- SwigType_push((yyval.type),(yyvsp[(2) - (2)].str));
+ (yyval.type) = (yyvsp[-1].type);
+ SwigType_push((yyval.type),(yyvsp[0].str));
}
+#line 9977 "y.tab.c" /* yacc.c:1646 */
break;
- case 311:
-
-/* Line 1806 of yacc.c */
-#line 5460 "parser.y"
+ case 376:
+#line 5647 "parser.y" /* yacc.c:1646 */
{
- (yyval.type) = (yyvsp[(2) - (3)].type);
- SwigType_push((yyval.type),(yyvsp[(3) - (3)].str));
- SwigType_push((yyval.type),(yyvsp[(1) - (3)].str));
+ (yyval.type) = (yyvsp[-1].type);
+ SwigType_push((yyval.type),(yyvsp[0].str));
+ SwigType_push((yyval.type),(yyvsp[-2].str));
}
+#line 9987 "y.tab.c" /* yacc.c:1646 */
break;
- case 312:
-
-/* Line 1806 of yacc.c */
-#line 5467 "parser.y"
- { (yyval.type) = (yyvsp[(1) - (1)].type);
+ case 377:
+#line 5654 "parser.y" /* yacc.c:1646 */
+ { (yyval.type) = (yyvsp[0].type);
/* Printf(stdout,"primitive = '%s'\n", $$);*/
}
+#line 9995 "y.tab.c" /* yacc.c:1646 */
break;
- case 313:
-
-/* Line 1806 of yacc.c */
-#line 5470 "parser.y"
- { (yyval.type) = (yyvsp[(1) - (1)].type); }
+ case 378:
+#line 5657 "parser.y" /* yacc.c:1646 */
+ { (yyval.type) = (yyvsp[0].type); }
+#line 10001 "y.tab.c" /* yacc.c:1646 */
break;
- case 314:
-
-/* Line 1806 of yacc.c */
-#line 5471 "parser.y"
- { (yyval.type) = (yyvsp[(1) - (1)].type); }
+ case 379:
+#line 5658 "parser.y" /* yacc.c:1646 */
+ { (yyval.type) = (yyvsp[0].type); }
+#line 10007 "y.tab.c" /* yacc.c:1646 */
break;
- case 315:
-
-/* Line 1806 of yacc.c */
-#line 5472 "parser.y"
- { (yyval.type) = NewStringf("%s%s",(yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].id)); }
+ case 380:
+#line 5662 "parser.y" /* yacc.c:1646 */
+ { (yyval.type) = NewStringf("enum %s", (yyvsp[0].str)); }
+#line 10013 "y.tab.c" /* yacc.c:1646 */
break;
- case 316:
-
-/* Line 1806 of yacc.c */
-#line 5473 "parser.y"
- { (yyval.type) = NewStringf("enum %s", (yyvsp[(2) - (2)].str)); }
+ case 381:
+#line 5663 "parser.y" /* yacc.c:1646 */
+ { (yyval.type) = (yyvsp[0].type); }
+#line 10019 "y.tab.c" /* yacc.c:1646 */
break;
- case 317:
-
-/* Line 1806 of yacc.c */
-#line 5474 "parser.y"
- { (yyval.type) = (yyvsp[(1) - (1)].type); }
+ case 382:
+#line 5665 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.type) = (yyvsp[0].str);
+ }
+#line 10027 "y.tab.c" /* yacc.c:1646 */
break;
- case 318:
+ case 383:
+#line 5668 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.type) = NewStringf("%s %s", (yyvsp[-1].id), (yyvsp[0].str));
+ }
+#line 10035 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5476 "parser.y"
+ case 384:
+#line 5671 "parser.y" /* yacc.c:1646 */
{
- (yyval.type) = (yyvsp[(1) - (1)].str);
+ (yyval.type) = (yyvsp[0].type);
}
+#line 10043 "y.tab.c" /* yacc.c:1646 */
break;
- case 319:
-
-/* Line 1806 of yacc.c */
-#line 5479 "parser.y"
- {
- (yyval.type) = NewStringf("%s %s", (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].str));
+ case 385:
+#line 5676 "parser.y" /* yacc.c:1646 */
+ {
+ Node *n = Swig_symbol_clookup((yyvsp[-1].str),0);
+ if (!n) {
+ Swig_error(cparse_file, cparse_line, "Identifier %s not defined.\n", (yyvsp[-1].str));
+ (yyval.type) = (yyvsp[-1].str);
+ } else {
+ (yyval.type) = Getattr(n, "type");
+ }
}
+#line 10057 "y.tab.c" /* yacc.c:1646 */
break;
- case 320:
-
-/* Line 1806 of yacc.c */
-#line 5484 "parser.y"
+ case 386:
+#line 5687 "parser.y" /* yacc.c:1646 */
{
- if (!(yyvsp[(1) - (1)].ptype).type) (yyvsp[(1) - (1)].ptype).type = NewString("int");
- if ((yyvsp[(1) - (1)].ptype).us) {
- (yyval.type) = NewStringf("%s %s", (yyvsp[(1) - (1)].ptype).us, (yyvsp[(1) - (1)].ptype).type);
- Delete((yyvsp[(1) - (1)].ptype).us);
- Delete((yyvsp[(1) - (1)].ptype).type);
+ if (!(yyvsp[0].ptype).type) (yyvsp[0].ptype).type = NewString("int");
+ if ((yyvsp[0].ptype).us) {
+ (yyval.type) = NewStringf("%s %s", (yyvsp[0].ptype).us, (yyvsp[0].ptype).type);
+ Delete((yyvsp[0].ptype).us);
+ Delete((yyvsp[0].ptype).type);
} else {
- (yyval.type) = (yyvsp[(1) - (1)].ptype).type;
+ (yyval.type) = (yyvsp[0].ptype).type;
}
if (Cmp((yyval.type),"signed int") == 0) {
Delete((yyval.type));
(yyval.type) = NewString("long long");
}
}
+#line 10085 "y.tab.c" /* yacc.c:1646 */
break;
- case 321:
-
-/* Line 1806 of yacc.c */
-#line 5509 "parser.y"
+ case 387:
+#line 5712 "parser.y" /* yacc.c:1646 */
{
- (yyval.ptype) = (yyvsp[(1) - (1)].ptype);
+ (yyval.ptype) = (yyvsp[0].ptype);
}
+#line 10093 "y.tab.c" /* yacc.c:1646 */
break;
- case 322:
-
-/* Line 1806 of yacc.c */
-#line 5512 "parser.y"
+ case 388:
+#line 5715 "parser.y" /* yacc.c:1646 */
{
- if ((yyvsp[(1) - (2)].ptype).us && (yyvsp[(2) - (2)].ptype).us) {
- Swig_error(cparse_file, cparse_line, "Extra %s specifier.\n", (yyvsp[(2) - (2)].ptype).us);
+ if ((yyvsp[-1].ptype).us && (yyvsp[0].ptype).us) {
+ Swig_error(cparse_file, cparse_line, "Extra %s specifier.\n", (yyvsp[0].ptype).us);
}
- (yyval.ptype) = (yyvsp[(2) - (2)].ptype);
- if ((yyvsp[(1) - (2)].ptype).us) (yyval.ptype).us = (yyvsp[(1) - (2)].ptype).us;
- if ((yyvsp[(1) - (2)].ptype).type) {
- if (!(yyvsp[(2) - (2)].ptype).type) (yyval.ptype).type = (yyvsp[(1) - (2)].ptype).type;
+ (yyval.ptype) = (yyvsp[0].ptype);
+ if ((yyvsp[-1].ptype).us) (yyval.ptype).us = (yyvsp[-1].ptype).us;
+ if ((yyvsp[-1].ptype).type) {
+ if (!(yyvsp[0].ptype).type) (yyval.ptype).type = (yyvsp[-1].ptype).type;
else {
int err = 0;
- if ((Cmp((yyvsp[(1) - (2)].ptype).type,"long") == 0)) {
- if ((Cmp((yyvsp[(2) - (2)].ptype).type,"long") == 0) || (Strncmp((yyvsp[(2) - (2)].ptype).type,"double",6) == 0)) {
- (yyval.ptype).type = NewStringf("long %s", (yyvsp[(2) - (2)].ptype).type);
- } else if (Cmp((yyvsp[(2) - (2)].ptype).type,"int") == 0) {
- (yyval.ptype).type = (yyvsp[(1) - (2)].ptype).type;
+ if ((Cmp((yyvsp[-1].ptype).type,"long") == 0)) {
+ if ((Cmp((yyvsp[0].ptype).type,"long") == 0) || (Strncmp((yyvsp[0].ptype).type,"double",6) == 0)) {
+ (yyval.ptype).type = NewStringf("long %s", (yyvsp[0].ptype).type);
+ } else if (Cmp((yyvsp[0].ptype).type,"int") == 0) {
+ (yyval.ptype).type = (yyvsp[-1].ptype).type;
} else {
err = 1;
}
- } else if ((Cmp((yyvsp[(1) - (2)].ptype).type,"short")) == 0) {
- if (Cmp((yyvsp[(2) - (2)].ptype).type,"int") == 0) {
- (yyval.ptype).type = (yyvsp[(1) - (2)].ptype).type;
+ } else if ((Cmp((yyvsp[-1].ptype).type,"short")) == 0) {
+ if (Cmp((yyvsp[0].ptype).type,"int") == 0) {
+ (yyval.ptype).type = (yyvsp[-1].ptype).type;
} else {
err = 1;
}
- } else if (Cmp((yyvsp[(1) - (2)].ptype).type,"int") == 0) {
- (yyval.ptype).type = (yyvsp[(2) - (2)].ptype).type;
- } else if (Cmp((yyvsp[(1) - (2)].ptype).type,"double") == 0) {
- if (Cmp((yyvsp[(2) - (2)].ptype).type,"long") == 0) {
+ } else if (Cmp((yyvsp[-1].ptype).type,"int") == 0) {
+ (yyval.ptype).type = (yyvsp[0].ptype).type;
+ } else if (Cmp((yyvsp[-1].ptype).type,"double") == 0) {
+ if (Cmp((yyvsp[0].ptype).type,"long") == 0) {
(yyval.ptype).type = NewString("long double");
- } else if (Cmp((yyvsp[(2) - (2)].ptype).type,"complex") == 0) {
+ } else if (Cmp((yyvsp[0].ptype).type,"complex") == 0) {
(yyval.ptype).type = NewString("double complex");
} else {
err = 1;
}
- } else if (Cmp((yyvsp[(1) - (2)].ptype).type,"float") == 0) {
- if (Cmp((yyvsp[(2) - (2)].ptype).type,"complex") == 0) {
+ } else if (Cmp((yyvsp[-1].ptype).type,"float") == 0) {
+ if (Cmp((yyvsp[0].ptype).type,"complex") == 0) {
(yyval.ptype).type = NewString("float complex");
} else {
err = 1;
}
- } else if (Cmp((yyvsp[(1) - (2)].ptype).type,"complex") == 0) {
- (yyval.ptype).type = NewStringf("%s complex", (yyvsp[(2) - (2)].ptype).type);
+ } else if (Cmp((yyvsp[-1].ptype).type,"complex") == 0) {
+ (yyval.ptype).type = NewStringf("%s complex", (yyvsp[0].ptype).type);
} else {
err = 1;
}
if (err) {
- Swig_error(cparse_file, cparse_line, "Extra %s specifier.\n", (yyvsp[(1) - (2)].ptype).type);
+ Swig_error(cparse_file, cparse_line, "Extra %s specifier.\n", (yyvsp[-1].ptype).type);
}
}
}
}
+#line 10149 "y.tab.c" /* yacc.c:1646 */
break;
- case 323:
-
-/* Line 1806 of yacc.c */
-#line 5566 "parser.y"
+ case 389:
+#line 5769 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).type = NewString("int");
(yyval.ptype).us = 0;
}
+#line 10158 "y.tab.c" /* yacc.c:1646 */
break;
- case 324:
-
-/* Line 1806 of yacc.c */
-#line 5570 "parser.y"
+ case 390:
+#line 5773 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).type = NewString("short");
(yyval.ptype).us = 0;
}
+#line 10167 "y.tab.c" /* yacc.c:1646 */
break;
- case 325:
-
-/* Line 1806 of yacc.c */
-#line 5574 "parser.y"
+ case 391:
+#line 5777 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).type = NewString("long");
(yyval.ptype).us = 0;
}
+#line 10176 "y.tab.c" /* yacc.c:1646 */
break;
- case 326:
-
-/* Line 1806 of yacc.c */
-#line 5578 "parser.y"
+ case 392:
+#line 5781 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).type = NewString("char");
(yyval.ptype).us = 0;
}
+#line 10185 "y.tab.c" /* yacc.c:1646 */
break;
- case 327:
-
-/* Line 1806 of yacc.c */
-#line 5582 "parser.y"
+ case 393:
+#line 5785 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).type = NewString("wchar_t");
(yyval.ptype).us = 0;
}
+#line 10194 "y.tab.c" /* yacc.c:1646 */
break;
- case 328:
-
-/* Line 1806 of yacc.c */
-#line 5586 "parser.y"
+ case 394:
+#line 5789 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).type = NewString("float");
(yyval.ptype).us = 0;
}
+#line 10203 "y.tab.c" /* yacc.c:1646 */
break;
- case 329:
-
-/* Line 1806 of yacc.c */
-#line 5590 "parser.y"
+ case 395:
+#line 5793 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).type = NewString("double");
(yyval.ptype).us = 0;
}
+#line 10212 "y.tab.c" /* yacc.c:1646 */
break;
- case 330:
-
-/* Line 1806 of yacc.c */
-#line 5594 "parser.y"
+ case 396:
+#line 5797 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).us = NewString("signed");
(yyval.ptype).type = 0;
}
+#line 10221 "y.tab.c" /* yacc.c:1646 */
break;
- case 331:
-
-/* Line 1806 of yacc.c */
-#line 5598 "parser.y"
+ case 397:
+#line 5801 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).us = NewString("unsigned");
(yyval.ptype).type = 0;
}
+#line 10230 "y.tab.c" /* yacc.c:1646 */
break;
- case 332:
-
-/* Line 1806 of yacc.c */
-#line 5602 "parser.y"
+ case 398:
+#line 5805 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).type = NewString("complex");
(yyval.ptype).us = 0;
}
+#line 10239 "y.tab.c" /* yacc.c:1646 */
break;
- case 333:
-
-/* Line 1806 of yacc.c */
-#line 5606 "parser.y"
+ case 399:
+#line 5809 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).type = NewString("__int8");
(yyval.ptype).us = 0;
}
+#line 10248 "y.tab.c" /* yacc.c:1646 */
break;
- case 334:
-
-/* Line 1806 of yacc.c */
-#line 5610 "parser.y"
+ case 400:
+#line 5813 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).type = NewString("__int16");
(yyval.ptype).us = 0;
}
+#line 10257 "y.tab.c" /* yacc.c:1646 */
break;
- case 335:
-
-/* Line 1806 of yacc.c */
-#line 5614 "parser.y"
+ case 401:
+#line 5817 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).type = NewString("__int32");
(yyval.ptype).us = 0;
}
+#line 10266 "y.tab.c" /* yacc.c:1646 */
break;
- case 336:
-
-/* Line 1806 of yacc.c */
-#line 5618 "parser.y"
+ case 402:
+#line 5821 "parser.y" /* yacc.c:1646 */
{
(yyval.ptype).type = NewString("__int64");
(yyval.ptype).us = 0;
}
+#line 10275 "y.tab.c" /* yacc.c:1646 */
break;
- case 337:
-
-/* Line 1806 of yacc.c */
-#line 5624 "parser.y"
+ case 403:
+#line 5827 "parser.y" /* yacc.c:1646 */
{ /* scanner_check_typedef(); */ }
+#line 10281 "y.tab.c" /* yacc.c:1646 */
break;
- case 338:
-
-/* Line 1806 of yacc.c */
-#line 5624 "parser.y"
+ case 404:
+#line 5827 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(2) - (2)].dtype);
+ (yyval.dtype) = (yyvsp[0].dtype);
if ((yyval.dtype).type == T_STRING) {
(yyval.dtype).rawval = NewStringf("\"%(escape)s\"",(yyval.dtype).val);
- } else if ((yyval.dtype).type != T_CHAR) {
+ } else if ((yyval.dtype).type != T_CHAR && (yyval.dtype).type != T_WSTRING && (yyval.dtype).type != T_WCHAR) {
(yyval.dtype).rawval = 0;
}
+ (yyval.dtype).qualifier = 0;
(yyval.dtype).bitfield = 0;
(yyval.dtype).throws = 0;
(yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
scanner_ignore_typedef();
}
+#line 10300 "y.tab.c" /* yacc.c:1646 */
break;
- case 339:
+ case 405:
+#line 5841 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype) = (yyvsp[0].dtype);
+ }
+#line 10308 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5650 "parser.y"
- { (yyval.id) = (yyvsp[(1) - (1)].id); }
+ case 406:
+#line 5846 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype) = (yyvsp[0].dtype);
+ }
+#line 10316 "y.tab.c" /* yacc.c:1646 */
break;
- case 340:
+ case 407:
+#line 5849 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype) = (yyvsp[0].dtype);
+ }
+#line 10324 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5651 "parser.y"
- { (yyval.id) = (char *) 0;}
+ case 408:
+#line 5855 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype).val = NewString("delete");
+ (yyval.dtype).rawval = 0;
+ (yyval.dtype).type = T_STRING;
+ (yyval.dtype).qualifier = 0;
+ (yyval.dtype).bitfield = 0;
+ (yyval.dtype).throws = 0;
+ (yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
+ }
+#line 10339 "y.tab.c" /* yacc.c:1646 */
break;
- case 341:
+ case 409:
+#line 5868 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype).val = NewString("default");
+ (yyval.dtype).rawval = 0;
+ (yyval.dtype).type = T_STRING;
+ (yyval.dtype).qualifier = 0;
+ (yyval.dtype).bitfield = 0;
+ (yyval.dtype).throws = 0;
+ (yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
+ }
+#line 10354 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5654 "parser.y"
- { (yyval.node) = (yyvsp[(1) - (1)].node); }
+ case 410:
+#line 5882 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = (yyvsp[0].id); }
+#line 10360 "y.tab.c" /* yacc.c:1646 */
break;
- case 342:
+ case 411:
+#line 5883 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = (char *) 0;}
+#line 10366 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5655 "parser.y"
- { (yyval.node) = 0; }
+ case 412:
+#line 5886 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = (yyvsp[0].node); }
+#line 10372 "y.tab.c" /* yacc.c:1646 */
break;
- case 343:
+ case 413:
+#line 5887 "parser.y" /* yacc.c:1646 */
+ { (yyval.node) = 0; }
+#line 10378 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5659 "parser.y"
+ case 414:
+#line 5891 "parser.y" /* yacc.c:1646 */
{
- Node *leftSibling = Getattr((yyvsp[(1) - (5)].node),"_last");
- set_nextSibling(leftSibling,(yyvsp[(4) - (5)].node));
- Setattr((yyvsp[(1) - (5)].node),"_last",(yyvsp[(4) - (5)].node));
- (yyval.node) = (yyvsp[(1) - (5)].node);
+ Node *leftSibling = Getattr((yyvsp[-4].node),"_last");
+ set_nextSibling(leftSibling,(yyvsp[-1].node));
+ Setattr((yyvsp[-4].node),"_last",(yyvsp[-1].node));
+ (yyval.node) = (yyvsp[-4].node);
}
+#line 10389 "y.tab.c" /* yacc.c:1646 */
break;
- case 344:
-
-/* Line 1806 of yacc.c */
-#line 5665 "parser.y"
+ case 415:
+#line 5897 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(1) - (3)].node);
+ (yyval.node) = (yyvsp[-2].node);
}
+#line 10397 "y.tab.c" /* yacc.c:1646 */
break;
- case 345:
-
-/* Line 1806 of yacc.c */
-#line 5668 "parser.y"
+ case 416:
+#line 5900 "parser.y" /* yacc.c:1646 */
{
- Setattr((yyvsp[(2) - (3)].node),"_last",(yyvsp[(2) - (3)].node));
- (yyval.node) = (yyvsp[(2) - (3)].node);
+ Setattr((yyvsp[-1].node),"_last",(yyvsp[-1].node));
+ (yyval.node) = (yyvsp[-1].node);
}
+#line 10406 "y.tab.c" /* yacc.c:1646 */
break;
- case 346:
-
-/* Line 1806 of yacc.c */
-#line 5672 "parser.y"
+ case 417:
+#line 5904 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = 0;
}
+#line 10414 "y.tab.c" /* yacc.c:1646 */
break;
- case 347:
-
-/* Line 1806 of yacc.c */
-#line 5677 "parser.y"
+ case 418:
+#line 5909 "parser.y" /* yacc.c:1646 */
{
SwigType *type = NewSwigType(T_INT);
(yyval.node) = new_node("enumitem");
- Setattr((yyval.node),"name",(yyvsp[(1) - (1)].id));
+ Setattr((yyval.node),"name",(yyvsp[0].id));
Setattr((yyval.node),"type",type);
SetFlag((yyval.node),"feature:immutable");
Delete(type);
}
+#line 10427 "y.tab.c" /* yacc.c:1646 */
break;
- case 348:
-
-/* Line 1806 of yacc.c */
-#line 5685 "parser.y"
+ case 419:
+#line 5917 "parser.y" /* yacc.c:1646 */
{
- SwigType *type = NewSwigType((yyvsp[(3) - (3)].dtype).type == T_BOOL ? T_BOOL : ((yyvsp[(3) - (3)].dtype).type == T_CHAR ? T_CHAR : T_INT));
+ SwigType *type = NewSwigType((yyvsp[0].dtype).type == T_BOOL ? T_BOOL : ((yyvsp[0].dtype).type == T_CHAR ? T_CHAR : T_INT));
(yyval.node) = new_node("enumitem");
- Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id));
+ Setattr((yyval.node),"name",(yyvsp[-2].id));
Setattr((yyval.node),"type",type);
SetFlag((yyval.node),"feature:immutable");
- Setattr((yyval.node),"enumvalue", (yyvsp[(3) - (3)].dtype).val);
- Setattr((yyval.node),"value",(yyvsp[(1) - (3)].id));
+ Setattr((yyval.node),"enumvalue", (yyvsp[0].dtype).val);
+ Setattr((yyval.node),"value",(yyvsp[-2].id));
Delete(type);
}
+#line 10442 "y.tab.c" /* yacc.c:1646 */
break;
- case 349:
-
-/* Line 1806 of yacc.c */
-#line 5697 "parser.y"
+ case 420:
+#line 5929 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(1) - (1)].dtype);
+ (yyval.dtype) = (yyvsp[0].dtype);
if (((yyval.dtype).type != T_INT) && ((yyval.dtype).type != T_UINT) &&
((yyval.dtype).type != T_LONG) && ((yyval.dtype).type != T_ULONG) &&
((yyval.dtype).type != T_LONGLONG) && ((yyval.dtype).type != T_ULONGLONG) &&
Swig_error(cparse_file,cparse_line,"Type error. Expecting an integral type\n");
}
}
+#line 10458 "y.tab.c" /* yacc.c:1646 */
break;
- case 350:
-
-/* Line 1806 of yacc.c */
-#line 5712 "parser.y"
- { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); }
+ case 421:
+#line 5944 "parser.y" /* yacc.c:1646 */
+ { (yyval.dtype) = (yyvsp[0].dtype); }
+#line 10464 "y.tab.c" /* yacc.c:1646 */
break;
- case 351:
-
-/* Line 1806 of yacc.c */
-#line 5713 "parser.y"
+ case 422:
+#line 5945 "parser.y" /* yacc.c:1646 */
{
Node *n;
- (yyval.dtype).val = (yyvsp[(1) - (1)].type);
+ (yyval.dtype).val = (yyvsp[0].type);
(yyval.dtype).type = T_INT;
/* Check if value is in scope */
- n = Swig_symbol_clookup((yyvsp[(1) - (1)].type),0);
+ n = Swig_symbol_clookup((yyvsp[0].type),0);
if (n) {
/* A band-aid for enum values used in expressions. */
if (Strcmp(nodeType(n),"enumitem") == 0) {
}
}
}
+#line 10486 "y.tab.c" /* yacc.c:1646 */
break;
- case 352:
-
-/* Line 1806 of yacc.c */
-#line 5732 "parser.y"
- { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); }
+ case 423:
+#line 5964 "parser.y" /* yacc.c:1646 */
+ { (yyval.dtype) = (yyvsp[0].dtype); }
+#line 10492 "y.tab.c" /* yacc.c:1646 */
break;
- case 353:
-
-/* Line 1806 of yacc.c */
-#line 5733 "parser.y"
+ case 424:
+#line 5965 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewString((yyvsp[(1) - (1)].id));
+ (yyval.dtype).val = (yyvsp[0].str);
(yyval.dtype).type = T_STRING;
}
+#line 10501 "y.tab.c" /* yacc.c:1646 */
break;
- case 354:
-
-/* Line 1806 of yacc.c */
-#line 5737 "parser.y"
+ case 425:
+#line 5969 "parser.y" /* yacc.c:1646 */
{
- SwigType_push((yyvsp[(3) - (5)].type),(yyvsp[(4) - (5)].decl).type);
- (yyval.dtype).val = NewStringf("sizeof(%s)",SwigType_str((yyvsp[(3) - (5)].type),0));
+ SwigType_push((yyvsp[-2].type),(yyvsp[-1].decl).type);
+ (yyval.dtype).val = NewStringf("sizeof(%s)",SwigType_str((yyvsp[-2].type),0));
(yyval.dtype).type = T_ULONG;
}
+#line 10511 "y.tab.c" /* yacc.c:1646 */
break;
- case 355:
+ case 426:
+#line 5974 "parser.y" /* yacc.c:1646 */
+ {
+ SwigType_push((yyvsp[-2].type),(yyvsp[-1].decl).type);
+ (yyval.dtype).val = NewStringf("sizeof...(%s)",SwigType_str((yyvsp[-2].type),0));
+ (yyval.dtype).type = T_ULONG;
+ }
+#line 10521 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5742 "parser.y"
- { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); }
+ case 427:
+#line 5979 "parser.y" /* yacc.c:1646 */
+ { (yyval.dtype) = (yyvsp[0].dtype); }
+#line 10527 "y.tab.c" /* yacc.c:1646 */
break;
- case 356:
+ case 428:
+#line 5980 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype).val = (yyvsp[0].str);
+ (yyval.dtype).rawval = NewStringf("L\"%s\"", (yyval.dtype).val);
+ (yyval.dtype).type = T_WSTRING;
+ }
+#line 10537 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5743 "parser.y"
+ case 429:
+#line 5985 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewString((yyvsp[(1) - (1)].str));
+ (yyval.dtype).val = NewString((yyvsp[0].str));
if (Len((yyval.dtype).val)) {
(yyval.dtype).rawval = NewStringf("'%(escape)s'", (yyval.dtype).val);
} else {
(yyval.dtype).bitfield = 0;
(yyval.dtype).throws = 0;
(yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
}
+#line 10555 "y.tab.c" /* yacc.c:1646 */
break;
- case 357:
+ case 430:
+#line 5998 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype).val = NewString((yyvsp[0].str));
+ if (Len((yyval.dtype).val)) {
+ (yyval.dtype).rawval = NewStringf("L\'%s\'", (yyval.dtype).val);
+ } else {
+ (yyval.dtype).rawval = NewString("L'\\0'");
+ }
+ (yyval.dtype).type = T_WCHAR;
+ (yyval.dtype).bitfield = 0;
+ (yyval.dtype).throws = 0;
+ (yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
+ }
+#line 10573 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5757 "parser.y"
+ case 431:
+#line 6013 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("(%s)",(yyvsp[(2) - (3)].dtype).val);
- (yyval.dtype).type = (yyvsp[(2) - (3)].dtype).type;
+ (yyval.dtype).val = NewStringf("(%s)",(yyvsp[-1].dtype).val);
+ (yyval.dtype).type = (yyvsp[-1].dtype).type;
}
+#line 10582 "y.tab.c" /* yacc.c:1646 */
break;
- case 358:
-
-/* Line 1806 of yacc.c */
-#line 5764 "parser.y"
+ case 432:
+#line 6020 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(4) - (4)].dtype);
- if ((yyvsp[(4) - (4)].dtype).type != T_STRING) {
- switch ((yyvsp[(2) - (4)].dtype).type) {
+ (yyval.dtype) = (yyvsp[0].dtype);
+ if ((yyvsp[0].dtype).type != T_STRING) {
+ switch ((yyvsp[-2].dtype).type) {
case T_FLOAT:
case T_DOUBLE:
case T_LONGDOUBLE:
case T_FLTCPLX:
case T_DBLCPLX:
- (yyval.dtype).val = NewStringf("(%s)%s", (yyvsp[(2) - (4)].dtype).val, (yyvsp[(4) - (4)].dtype).val); /* SwigType_str and decimal points don't mix! */
+ (yyval.dtype).val = NewStringf("(%s)%s", (yyvsp[-2].dtype).val, (yyvsp[0].dtype).val); /* SwigType_str and decimal points don't mix! */
break;
default:
- (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (4)].dtype).val,0), (yyvsp[(4) - (4)].dtype).val);
+ (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[-2].dtype).val,0), (yyvsp[0].dtype).val);
break;
}
}
}
+#line 10604 "y.tab.c" /* yacc.c:1646 */
break;
- case 359:
-
-/* Line 1806 of yacc.c */
-#line 5781 "parser.y"
+ case 433:
+#line 6037 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(5) - (5)].dtype);
- if ((yyvsp[(5) - (5)].dtype).type != T_STRING) {
- SwigType_push((yyvsp[(2) - (5)].dtype).val,(yyvsp[(3) - (5)].type));
- (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (5)].dtype).val,0), (yyvsp[(5) - (5)].dtype).val);
+ (yyval.dtype) = (yyvsp[0].dtype);
+ if ((yyvsp[0].dtype).type != T_STRING) {
+ SwigType_push((yyvsp[-3].dtype).val,(yyvsp[-2].type));
+ (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[-3].dtype).val,0), (yyvsp[0].dtype).val);
}
}
+#line 10616 "y.tab.c" /* yacc.c:1646 */
break;
- case 360:
-
-/* Line 1806 of yacc.c */
-#line 5788 "parser.y"
+ case 434:
+#line 6044 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(5) - (5)].dtype);
- if ((yyvsp[(5) - (5)].dtype).type != T_STRING) {
- SwigType_add_reference((yyvsp[(2) - (5)].dtype).val);
- (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (5)].dtype).val,0), (yyvsp[(5) - (5)].dtype).val);
+ (yyval.dtype) = (yyvsp[0].dtype);
+ if ((yyvsp[0].dtype).type != T_STRING) {
+ SwigType_add_reference((yyvsp[-3].dtype).val);
+ (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[-3].dtype).val,0), (yyvsp[0].dtype).val);
}
}
+#line 10628 "y.tab.c" /* yacc.c:1646 */
break;
- case 361:
+ case 435:
+#line 6051 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype) = (yyvsp[0].dtype);
+ if ((yyvsp[0].dtype).type != T_STRING) {
+ SwigType_add_rvalue_reference((yyvsp[-3].dtype).val);
+ (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[-3].dtype).val,0), (yyvsp[0].dtype).val);
+ }
+ }
+#line 10640 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5795 "parser.y"
+ case 436:
+#line 6058 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(6) - (6)].dtype);
- if ((yyvsp[(6) - (6)].dtype).type != T_STRING) {
- SwigType_push((yyvsp[(2) - (6)].dtype).val,(yyvsp[(3) - (6)].type));
- SwigType_add_reference((yyvsp[(2) - (6)].dtype).val);
- (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (6)].dtype).val,0), (yyvsp[(6) - (6)].dtype).val);
+ (yyval.dtype) = (yyvsp[0].dtype);
+ if ((yyvsp[0].dtype).type != T_STRING) {
+ SwigType_push((yyvsp[-4].dtype).val,(yyvsp[-3].type));
+ SwigType_add_reference((yyvsp[-4].dtype).val);
+ (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[-4].dtype).val,0), (yyvsp[0].dtype).val);
}
}
+#line 10653 "y.tab.c" /* yacc.c:1646 */
break;
- case 362:
+ case 437:
+#line 6066 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype) = (yyvsp[0].dtype);
+ if ((yyvsp[0].dtype).type != T_STRING) {
+ SwigType_push((yyvsp[-4].dtype).val,(yyvsp[-3].type));
+ SwigType_add_rvalue_reference((yyvsp[-4].dtype).val);
+ (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[-4].dtype).val,0), (yyvsp[0].dtype).val);
+ }
+ }
+#line 10666 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5803 "parser.y"
+ case 438:
+#line 6074 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(2) - (2)].dtype);
- (yyval.dtype).val = NewStringf("&%s",(yyvsp[(2) - (2)].dtype).val);
+ (yyval.dtype) = (yyvsp[0].dtype);
+ (yyval.dtype).val = NewStringf("&%s",(yyvsp[0].dtype).val);
}
+#line 10675 "y.tab.c" /* yacc.c:1646 */
break;
- case 363:
-
-/* Line 1806 of yacc.c */
-#line 5807 "parser.y"
+ case 439:
+#line 6078 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype) = (yyvsp[(2) - (2)].dtype);
- (yyval.dtype).val = NewStringf("*%s",(yyvsp[(2) - (2)].dtype).val);
+ (yyval.dtype) = (yyvsp[0].dtype);
+ (yyval.dtype).val = NewStringf("&&%s",(yyvsp[0].dtype).val);
}
+#line 10684 "y.tab.c" /* yacc.c:1646 */
break;
- case 364:
-
-/* Line 1806 of yacc.c */
-#line 5813 "parser.y"
- { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); }
+ case 440:
+#line 6082 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype) = (yyvsp[0].dtype);
+ (yyval.dtype).val = NewStringf("*%s",(yyvsp[0].dtype).val);
+ }
+#line 10693 "y.tab.c" /* yacc.c:1646 */
break;
- case 365:
-
-/* Line 1806 of yacc.c */
-#line 5814 "parser.y"
- { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); }
+ case 441:
+#line 6088 "parser.y" /* yacc.c:1646 */
+ { (yyval.dtype) = (yyvsp[0].dtype); }
+#line 10699 "y.tab.c" /* yacc.c:1646 */
break;
- case 366:
-
-/* Line 1806 of yacc.c */
-#line 5815 "parser.y"
- { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); }
+ case 442:
+#line 6089 "parser.y" /* yacc.c:1646 */
+ { (yyval.dtype) = (yyvsp[0].dtype); }
+#line 10705 "y.tab.c" /* yacc.c:1646 */
break;
- case 367:
-
-/* Line 1806 of yacc.c */
-#line 5816 "parser.y"
- { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); }
+ case 443:
+#line 6090 "parser.y" /* yacc.c:1646 */
+ { (yyval.dtype) = (yyvsp[0].dtype); }
+#line 10711 "y.tab.c" /* yacc.c:1646 */
break;
- case 368:
-
-/* Line 1806 of yacc.c */
-#line 5817 "parser.y"
- { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); }
+ case 444:
+#line 6091 "parser.y" /* yacc.c:1646 */
+ { (yyval.dtype) = (yyvsp[0].dtype); }
+#line 10717 "y.tab.c" /* yacc.c:1646 */
break;
- case 369:
-
-/* Line 1806 of yacc.c */
-#line 5818 "parser.y"
- { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); }
+ case 445:
+#line 6092 "parser.y" /* yacc.c:1646 */
+ { (yyval.dtype) = (yyvsp[0].dtype); }
+#line 10723 "y.tab.c" /* yacc.c:1646 */
break;
- case 370:
-
-/* Line 1806 of yacc.c */
-#line 5819 "parser.y"
- { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); }
+ case 446:
+#line 6093 "parser.y" /* yacc.c:1646 */
+ { (yyval.dtype) = (yyvsp[0].dtype); }
+#line 10729 "y.tab.c" /* yacc.c:1646 */
break;
- case 371:
-
-/* Line 1806 of yacc.c */
-#line 5820 "parser.y"
- { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); }
+ case 447:
+#line 6094 "parser.y" /* yacc.c:1646 */
+ { (yyval.dtype) = (yyvsp[0].dtype); }
+#line 10735 "y.tab.c" /* yacc.c:1646 */
break;
- case 372:
+ case 448:
+#line 6095 "parser.y" /* yacc.c:1646 */
+ { (yyval.dtype) = (yyvsp[0].dtype); }
+#line 10741 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5823 "parser.y"
+ case 449:
+#line 6098 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s+%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
- (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+ (yyval.dtype).val = NewStringf("%s+%s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
+ (yyval.dtype).type = promote((yyvsp[-2].dtype).type,(yyvsp[0].dtype).type);
}
+#line 10750 "y.tab.c" /* yacc.c:1646 */
break;
- case 373:
-
-/* Line 1806 of yacc.c */
-#line 5827 "parser.y"
+ case 450:
+#line 6102 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s-%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
- (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+ (yyval.dtype).val = NewStringf("%s-%s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
+ (yyval.dtype).type = promote((yyvsp[-2].dtype).type,(yyvsp[0].dtype).type);
}
+#line 10759 "y.tab.c" /* yacc.c:1646 */
break;
- case 374:
-
-/* Line 1806 of yacc.c */
-#line 5831 "parser.y"
+ case 451:
+#line 6106 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s*%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
- (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+ (yyval.dtype).val = NewStringf("%s*%s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
+ (yyval.dtype).type = promote((yyvsp[-2].dtype).type,(yyvsp[0].dtype).type);
}
+#line 10768 "y.tab.c" /* yacc.c:1646 */
break;
- case 375:
-
-/* Line 1806 of yacc.c */
-#line 5835 "parser.y"
+ case 452:
+#line 6110 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s/%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
- (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+ (yyval.dtype).val = NewStringf("%s/%s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
+ (yyval.dtype).type = promote((yyvsp[-2].dtype).type,(yyvsp[0].dtype).type);
}
+#line 10777 "y.tab.c" /* yacc.c:1646 */
break;
- case 376:
-
-/* Line 1806 of yacc.c */
-#line 5839 "parser.y"
+ case 453:
+#line 6114 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s%%%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
- (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+ (yyval.dtype).val = NewStringf("%s%%%s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
+ (yyval.dtype).type = promote((yyvsp[-2].dtype).type,(yyvsp[0].dtype).type);
}
+#line 10786 "y.tab.c" /* yacc.c:1646 */
break;
- case 377:
-
-/* Line 1806 of yacc.c */
-#line 5843 "parser.y"
+ case 454:
+#line 6118 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s&%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
- (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+ (yyval.dtype).val = NewStringf("%s&%s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
+ (yyval.dtype).type = promote((yyvsp[-2].dtype).type,(yyvsp[0].dtype).type);
}
+#line 10795 "y.tab.c" /* yacc.c:1646 */
break;
- case 378:
-
-/* Line 1806 of yacc.c */
-#line 5847 "parser.y"
+ case 455:
+#line 6122 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s|%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
- (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+ (yyval.dtype).val = NewStringf("%s|%s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
+ (yyval.dtype).type = promote((yyvsp[-2].dtype).type,(yyvsp[0].dtype).type);
}
+#line 10804 "y.tab.c" /* yacc.c:1646 */
break;
- case 379:
-
-/* Line 1806 of yacc.c */
-#line 5851 "parser.y"
+ case 456:
+#line 6126 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s^%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
- (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+ (yyval.dtype).val = NewStringf("%s^%s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
+ (yyval.dtype).type = promote((yyvsp[-2].dtype).type,(yyvsp[0].dtype).type);
}
+#line 10813 "y.tab.c" /* yacc.c:1646 */
break;
- case 380:
-
-/* Line 1806 of yacc.c */
-#line 5855 "parser.y"
+ case 457:
+#line 6130 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s << %s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
- (yyval.dtype).type = promote_type((yyvsp[(1) - (3)].dtype).type);
+ (yyval.dtype).val = NewStringf("%s << %s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
+ (yyval.dtype).type = promote_type((yyvsp[-2].dtype).type);
}
+#line 10822 "y.tab.c" /* yacc.c:1646 */
break;
- case 381:
-
-/* Line 1806 of yacc.c */
-#line 5859 "parser.y"
+ case 458:
+#line 6134 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s >> %s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
- (yyval.dtype).type = promote_type((yyvsp[(1) - (3)].dtype).type);
+ (yyval.dtype).val = NewStringf("%s >> %s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
+ (yyval.dtype).type = promote_type((yyvsp[-2].dtype).type);
}
+#line 10831 "y.tab.c" /* yacc.c:1646 */
break;
- case 382:
-
-/* Line 1806 of yacc.c */
-#line 5863 "parser.y"
+ case 459:
+#line 6138 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s&&%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
+ (yyval.dtype).val = NewStringf("%s&&%s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
(yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
}
+#line 10840 "y.tab.c" /* yacc.c:1646 */
break;
- case 383:
-
-/* Line 1806 of yacc.c */
-#line 5867 "parser.y"
+ case 460:
+#line 6142 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s||%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
+ (yyval.dtype).val = NewStringf("%s||%s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
(yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
}
+#line 10849 "y.tab.c" /* yacc.c:1646 */
break;
- case 384:
-
-/* Line 1806 of yacc.c */
-#line 5871 "parser.y"
+ case 461:
+#line 6146 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s==%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
+ (yyval.dtype).val = NewStringf("%s==%s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
(yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
}
+#line 10858 "y.tab.c" /* yacc.c:1646 */
break;
- case 385:
-
-/* Line 1806 of yacc.c */
-#line 5875 "parser.y"
+ case 462:
+#line 6150 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s!=%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val);
+ (yyval.dtype).val = NewStringf("%s!=%s",(yyvsp[-2].dtype).val,(yyvsp[0].dtype).val);
(yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
}
+#line 10867 "y.tab.c" /* yacc.c:1646 */
break;
- case 386:
-
-/* Line 1806 of yacc.c */
-#line 5889 "parser.y"
+ case 463:
+#line 6164 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s >= %s", (yyvsp[(1) - (3)].dtype).val, (yyvsp[(3) - (3)].dtype).val);
+ (yyval.dtype).val = NewStringf("%s >= %s", (yyvsp[-2].dtype).val, (yyvsp[0].dtype).val);
(yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
}
+#line 10876 "y.tab.c" /* yacc.c:1646 */
break;
- case 387:
-
-/* Line 1806 of yacc.c */
-#line 5893 "parser.y"
+ case 464:
+#line 6168 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s <= %s", (yyvsp[(1) - (3)].dtype).val, (yyvsp[(3) - (3)].dtype).val);
+ (yyval.dtype).val = NewStringf("%s <= %s", (yyvsp[-2].dtype).val, (yyvsp[0].dtype).val);
(yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
}
+#line 10885 "y.tab.c" /* yacc.c:1646 */
break;
- case 388:
-
-/* Line 1806 of yacc.c */
-#line 5897 "parser.y"
+ case 465:
+#line 6172 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("%s?%s:%s", (yyvsp[(1) - (5)].dtype).val, (yyvsp[(3) - (5)].dtype).val, (yyvsp[(5) - (5)].dtype).val);
+ (yyval.dtype).val = NewStringf("%s?%s:%s", (yyvsp[-4].dtype).val, (yyvsp[-2].dtype).val, (yyvsp[0].dtype).val);
/* This may not be exactly right, but is probably good enough
* for the purposes of parsing constant expressions. */
- (yyval.dtype).type = promote((yyvsp[(3) - (5)].dtype).type, (yyvsp[(5) - (5)].dtype).type);
+ (yyval.dtype).type = promote((yyvsp[-2].dtype).type, (yyvsp[0].dtype).type);
}
+#line 10896 "y.tab.c" /* yacc.c:1646 */
break;
- case 389:
-
-/* Line 1806 of yacc.c */
-#line 5903 "parser.y"
+ case 466:
+#line 6178 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("-%s",(yyvsp[(2) - (2)].dtype).val);
- (yyval.dtype).type = (yyvsp[(2) - (2)].dtype).type;
+ (yyval.dtype).val = NewStringf("-%s",(yyvsp[0].dtype).val);
+ (yyval.dtype).type = (yyvsp[0].dtype).type;
}
+#line 10905 "y.tab.c" /* yacc.c:1646 */
break;
- case 390:
-
-/* Line 1806 of yacc.c */
-#line 5907 "parser.y"
+ case 467:
+#line 6182 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("+%s",(yyvsp[(2) - (2)].dtype).val);
- (yyval.dtype).type = (yyvsp[(2) - (2)].dtype).type;
+ (yyval.dtype).val = NewStringf("+%s",(yyvsp[0].dtype).val);
+ (yyval.dtype).type = (yyvsp[0].dtype).type;
}
+#line 10914 "y.tab.c" /* yacc.c:1646 */
break;
- case 391:
-
-/* Line 1806 of yacc.c */
-#line 5911 "parser.y"
+ case 468:
+#line 6186 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("~%s",(yyvsp[(2) - (2)].dtype).val);
- (yyval.dtype).type = (yyvsp[(2) - (2)].dtype).type;
+ (yyval.dtype).val = NewStringf("~%s",(yyvsp[0].dtype).val);
+ (yyval.dtype).type = (yyvsp[0].dtype).type;
}
+#line 10923 "y.tab.c" /* yacc.c:1646 */
break;
- case 392:
-
-/* Line 1806 of yacc.c */
-#line 5915 "parser.y"
+ case 469:
+#line 6190 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).val = NewStringf("!%s",(yyvsp[(2) - (2)].dtype).val);
+ (yyval.dtype).val = NewStringf("!%s",(yyvsp[0].dtype).val);
(yyval.dtype).type = T_INT;
}
+#line 10932 "y.tab.c" /* yacc.c:1646 */
break;
- case 393:
-
-/* Line 1806 of yacc.c */
-#line 5919 "parser.y"
+ case 470:
+#line 6194 "parser.y" /* yacc.c:1646 */
{
String *qty;
skip_balanced('(',')');
- qty = Swig_symbol_type_qualify((yyvsp[(1) - (2)].type),0);
+ qty = Swig_symbol_type_qualify((yyvsp[-1].type),0);
if (SwigType_istemplate(qty)) {
String *nstr = SwigType_namestr(qty);
Delete(qty);
(yyval.dtype).type = T_INT;
Delete(qty);
}
+#line 10951 "y.tab.c" /* yacc.c:1646 */
break;
- case 394:
-
-/* Line 1806 of yacc.c */
-#line 5935 "parser.y"
+ case 471:
+#line 6210 "parser.y" /* yacc.c:1646 */
{
- (yyval.bases) = (yyvsp[(1) - (1)].bases);
- }
+ (yyval.str) = NewString("...");
+ }
+#line 10959 "y.tab.c" /* yacc.c:1646 */
break;
- case 395:
+ case 472:
+#line 6215 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = (yyvsp[0].str);
+ }
+#line 10967 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5940 "parser.y"
- { inherit_list = 1; }
+ case 473:
+#line 6218 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = 0;
+ }
+#line 10975 "y.tab.c" /* yacc.c:1646 */
break;
- case 396:
+ case 474:
+#line 6223 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.bases) = (yyvsp[0].bases);
+ }
+#line 10983 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5940 "parser.y"
- { (yyval.bases) = (yyvsp[(3) - (3)].bases); inherit_list = 0; }
+ case 475:
+#line 6228 "parser.y" /* yacc.c:1646 */
+ { inherit_list = 1; }
+#line 10989 "y.tab.c" /* yacc.c:1646 */
break;
- case 397:
+ case 476:
+#line 6228 "parser.y" /* yacc.c:1646 */
+ { (yyval.bases) = (yyvsp[0].bases); inherit_list = 0; }
+#line 10995 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 5941 "parser.y"
+ case 477:
+#line 6229 "parser.y" /* yacc.c:1646 */
{ (yyval.bases) = 0; }
+#line 11001 "y.tab.c" /* yacc.c:1646 */
break;
- case 398:
-
-/* Line 1806 of yacc.c */
-#line 5944 "parser.y"
+ case 478:
+#line 6232 "parser.y" /* yacc.c:1646 */
{
Hash *list = NewHash();
- Node *base = (yyvsp[(1) - (1)].node);
+ Node *base = (yyvsp[0].node);
Node *name = Getattr(base,"name");
List *lpublic = NewList();
List *lprotected = NewList();
Append(Getattr(list,Getattr(base,"access")),name);
(yyval.bases) = list;
}
+#line 11022 "y.tab.c" /* yacc.c:1646 */
break;
- case 399:
-
-/* Line 1806 of yacc.c */
-#line 5961 "parser.y"
+ case 479:
+#line 6249 "parser.y" /* yacc.c:1646 */
{
- Hash *list = (yyvsp[(1) - (3)].bases);
- Node *base = (yyvsp[(3) - (3)].node);
+ Hash *list = (yyvsp[-2].bases);
+ Node *base = (yyvsp[0].node);
Node *name = Getattr(base,"name");
Append(Getattr(list,Getattr(base,"access")),name);
(yyval.bases) = list;
}
+#line 11034 "y.tab.c" /* yacc.c:1646 */
break;
- case 400:
-
-/* Line 1806 of yacc.c */
-#line 5970 "parser.y"
+ case 480:
+#line 6258 "parser.y" /* yacc.c:1646 */
{
(yyval.intvalue) = cparse_line;
}
+#line 11042 "y.tab.c" /* yacc.c:1646 */
break;
- case 401:
-
-/* Line 1806 of yacc.c */
-#line 5972 "parser.y"
+ case 481:
+#line 6260 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = NewHash();
Setfile((yyval.node),cparse_file);
- Setline((yyval.node),(yyvsp[(2) - (3)].intvalue));
- Setattr((yyval.node),"name",(yyvsp[(3) - (3)].str));
- Setfile((yyvsp[(3) - (3)].str),cparse_file);
- Setline((yyvsp[(3) - (3)].str),(yyvsp[(2) - (3)].intvalue));
+ Setline((yyval.node),(yyvsp[-2].intvalue));
+ Setattr((yyval.node),"name",(yyvsp[-1].str));
+ Setfile((yyvsp[-1].str),cparse_file);
+ Setline((yyvsp[-1].str),(yyvsp[-2].intvalue));
if (last_cpptype && (Strcmp(last_cpptype,"struct") != 0)) {
Setattr((yyval.node),"access","private");
- Swig_warning(WARN_PARSE_NO_ACCESS, Getfile((yyval.node)), Getline((yyval.node)), "No access specifier given for base class '%s' (ignored).\n", SwigType_namestr((yyvsp[(3) - (3)].str)));
+ Swig_warning(WARN_PARSE_NO_ACCESS, Getfile((yyval.node)), Getline((yyval.node)), "No access specifier given for base class '%s' (ignored).\n", SwigType_namestr((yyvsp[-1].str)));
} else {
Setattr((yyval.node),"access","public");
}
+ if ((yyvsp[0].str))
+ SetFlag((yyval.node), "variadic");
}
+#line 11063 "y.tab.c" /* yacc.c:1646 */
break;
- case 402:
-
-/* Line 1806 of yacc.c */
-#line 5986 "parser.y"
+ case 482:
+#line 6276 "parser.y" /* yacc.c:1646 */
{
(yyval.intvalue) = cparse_line;
}
+#line 11071 "y.tab.c" /* yacc.c:1646 */
break;
- case 403:
-
-/* Line 1806 of yacc.c */
-#line 5988 "parser.y"
+ case 483:
+#line 6278 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = NewHash();
Setfile((yyval.node),cparse_file);
- Setline((yyval.node),(yyvsp[(3) - (5)].intvalue));
- Setattr((yyval.node),"name",(yyvsp[(5) - (5)].str));
- Setfile((yyvsp[(5) - (5)].str),cparse_file);
- Setline((yyvsp[(5) - (5)].str),(yyvsp[(3) - (5)].intvalue));
- Setattr((yyval.node),"access",(yyvsp[(2) - (5)].id));
- if (Strcmp((yyvsp[(2) - (5)].id),"public") != 0) {
- Swig_warning(WARN_PARSE_PRIVATE_INHERIT, Getfile((yyval.node)), Getline((yyval.node)), "%s inheritance from base '%s' (ignored).\n", (yyvsp[(2) - (5)].id), SwigType_namestr((yyvsp[(5) - (5)].str)));
+ Setline((yyval.node),(yyvsp[-3].intvalue));
+ Setattr((yyval.node),"name",(yyvsp[-1].str));
+ Setfile((yyvsp[-1].str),cparse_file);
+ Setline((yyvsp[-1].str),(yyvsp[-3].intvalue));
+ Setattr((yyval.node),"access",(yyvsp[-4].id));
+ if (Strcmp((yyvsp[-4].id),"public") != 0) {
+ Swig_warning(WARN_PARSE_PRIVATE_INHERIT, Getfile((yyval.node)), Getline((yyval.node)), "%s inheritance from base '%s' (ignored).\n", (yyvsp[-4].id), SwigType_namestr((yyvsp[-1].str)));
}
+ if ((yyvsp[0].str))
+ SetFlag((yyval.node), "variadic");
}
+#line 11090 "y.tab.c" /* yacc.c:1646 */
break;
- case 404:
-
-/* Line 1806 of yacc.c */
-#line 6002 "parser.y"
+ case 484:
+#line 6294 "parser.y" /* yacc.c:1646 */
{ (yyval.id) = (char*)"public"; }
+#line 11096 "y.tab.c" /* yacc.c:1646 */
break;
- case 405:
-
-/* Line 1806 of yacc.c */
-#line 6003 "parser.y"
+ case 485:
+#line 6295 "parser.y" /* yacc.c:1646 */
{ (yyval.id) = (char*)"private"; }
+#line 11102 "y.tab.c" /* yacc.c:1646 */
break;
- case 406:
-
-/* Line 1806 of yacc.c */
-#line 6004 "parser.y"
+ case 486:
+#line 6296 "parser.y" /* yacc.c:1646 */
{ (yyval.id) = (char*)"protected"; }
+#line 11108 "y.tab.c" /* yacc.c:1646 */
break;
- case 407:
-
-/* Line 1806 of yacc.c */
-#line 6008 "parser.y"
+ case 487:
+#line 6300 "parser.y" /* yacc.c:1646 */
{
(yyval.id) = (char*)"class";
if (!inherit_list) last_cpptype = (yyval.id);
}
+#line 11117 "y.tab.c" /* yacc.c:1646 */
break;
- case 408:
-
-/* Line 1806 of yacc.c */
-#line 6012 "parser.y"
+ case 488:
+#line 6304 "parser.y" /* yacc.c:1646 */
{
(yyval.id) = (char *)"typename";
if (!inherit_list) last_cpptype = (yyval.id);
}
+#line 11126 "y.tab.c" /* yacc.c:1646 */
break;
- case 409:
+ case 489:
+#line 6308 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.id) = (char *)"class...";
+ if (!inherit_list) last_cpptype = (yyval.id);
+ }
+#line 11135 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6018 "parser.y"
- {
- (yyval.id) = (yyvsp[(1) - (1)].id);
+ case 490:
+#line 6312 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.id) = (char *)"typename...";
+ if (!inherit_list) last_cpptype = (yyval.id);
}
+#line 11144 "y.tab.c" /* yacc.c:1646 */
break;
- case 410:
+ case 491:
+#line 6318 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.id) = (yyvsp[0].id);
+ }
+#line 11152 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6021 "parser.y"
+ case 492:
+#line 6321 "parser.y" /* yacc.c:1646 */
{
(yyval.id) = (char*)"struct";
if (!inherit_list) last_cpptype = (yyval.id);
}
+#line 11161 "y.tab.c" /* yacc.c:1646 */
break;
- case 411:
-
-/* Line 1806 of yacc.c */
-#line 6025 "parser.y"
+ case 493:
+#line 6325 "parser.y" /* yacc.c:1646 */
{
(yyval.id) = (char*)"union";
if (!inherit_list) last_cpptype = (yyval.id);
}
+#line 11170 "y.tab.c" /* yacc.c:1646 */
break;
- case 414:
+ case 496:
+#line 6335 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = 0;
+ }
+#line 11178 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6035 "parser.y"
+ case 497:
+#line 6338 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = 0;
+ }
+#line 11186 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 498:
+#line 6341 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = 0;
+ }
+#line 11194 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 499:
+#line 6344 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = 0;
+ }
+#line 11202 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 500:
+#line 6349 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype).throws = (yyvsp[-1].pl);
+ (yyval.dtype).throwf = NewString("1");
+ (yyval.dtype).nexcept = 0;
+ }
+#line 11212 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 501:
+#line 6354 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).qualifier = (yyvsp[(1) - (1)].str);
(yyval.dtype).throws = 0;
(yyval.dtype).throwf = 0;
- }
+ (yyval.dtype).nexcept = NewString("true");
+ }
+#line 11222 "y.tab.c" /* yacc.c:1646 */
break;
- case 415:
+ case 502:
+#line 6359 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype).throws = 0;
+ (yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
+ }
+#line 11232 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6040 "parser.y"
+ case 503:
+#line 6364 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).qualifier = 0;
- (yyval.dtype).throws = (yyvsp[(3) - (4)].pl);
- (yyval.dtype).throwf = NewString("1");
- }
+ (yyval.dtype).throws = 0;
+ (yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = NewString("true");
+ }
+#line 11242 "y.tab.c" /* yacc.c:1646 */
break;
- case 416:
+ case 504:
+#line 6369 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype).throws = 0;
+ (yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = (yyvsp[-1].dtype).val;
+ }
+#line 11252 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6045 "parser.y"
+ case 505:
+#line 6376 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).qualifier = (yyvsp[(1) - (5)].str);
- (yyval.dtype).throws = (yyvsp[(4) - (5)].pl);
- (yyval.dtype).throwf = NewString("1");
+ (yyval.dtype).throws = 0;
+ (yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
+ (yyval.dtype).qualifier = (yyvsp[0].str);
}
+#line 11263 "y.tab.c" /* yacc.c:1646 */
break;
- case 417:
+ case 506:
+#line 6382 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype) = (yyvsp[0].dtype);
+ (yyval.dtype).qualifier = 0;
+ }
+#line 11272 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 507:
+#line 6386 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.dtype) = (yyvsp[0].dtype);
+ (yyval.dtype).qualifier = (yyvsp[-1].str);
+ }
+#line 11281 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6050 "parser.y"
+ case 508:
+#line 6390 "parser.y" /* yacc.c:1646 */
{
- (yyval.dtype).qualifier = 0;
(yyval.dtype).throws = 0;
(yyval.dtype).throwf = 0;
+ (yyval.dtype).nexcept = 0;
+ (yyval.dtype).qualifier = 0;
}
+#line 11292 "y.tab.c" /* yacc.c:1646 */
break;
- case 418:
-
-/* Line 1806 of yacc.c */
-#line 6057 "parser.y"
+ case 509:
+#line 6398 "parser.y" /* yacc.c:1646 */
{
Clear(scanner_ccode);
(yyval.decl).have_parms = 0;
(yyval.decl).defarg = 0;
- (yyval.decl).throws = (yyvsp[(1) - (3)].dtype).throws;
- (yyval.decl).throwf = (yyvsp[(1) - (3)].dtype).throwf;
+ (yyval.decl).throws = (yyvsp[-2].dtype).throws;
+ (yyval.decl).throwf = (yyvsp[-2].dtype).throwf;
+ (yyval.decl).nexcept = (yyvsp[-2].dtype).nexcept;
}
+#line 11305 "y.tab.c" /* yacc.c:1646 */
break;
- case 419:
-
-/* Line 1806 of yacc.c */
-#line 6064 "parser.y"
+ case 510:
+#line 6406 "parser.y" /* yacc.c:1646 */
{
skip_balanced('{','}');
(yyval.decl).have_parms = 0;
(yyval.decl).defarg = 0;
- (yyval.decl).throws = (yyvsp[(1) - (3)].dtype).throws;
- (yyval.decl).throwf = (yyvsp[(1) - (3)].dtype).throwf;
+ (yyval.decl).throws = (yyvsp[-2].dtype).throws;
+ (yyval.decl).throwf = (yyvsp[-2].dtype).throwf;
+ (yyval.decl).nexcept = (yyvsp[-2].dtype).nexcept;
}
+#line 11318 "y.tab.c" /* yacc.c:1646 */
break;
- case 420:
-
-/* Line 1806 of yacc.c */
-#line 6071 "parser.y"
+ case 511:
+#line 6414 "parser.y" /* yacc.c:1646 */
{
Clear(scanner_ccode);
- (yyval.decl).parms = (yyvsp[(2) - (4)].pl);
+ (yyval.decl).parms = (yyvsp[-2].pl);
(yyval.decl).have_parms = 1;
(yyval.decl).defarg = 0;
(yyval.decl).throws = 0;
(yyval.decl).throwf = 0;
+ (yyval.decl).nexcept = 0;
}
+#line 11332 "y.tab.c" /* yacc.c:1646 */
break;
- case 421:
-
-/* Line 1806 of yacc.c */
-#line 6079 "parser.y"
+ case 512:
+#line 6423 "parser.y" /* yacc.c:1646 */
{
skip_balanced('{','}');
- (yyval.decl).parms = (yyvsp[(2) - (4)].pl);
+ (yyval.decl).parms = (yyvsp[-2].pl);
(yyval.decl).have_parms = 1;
(yyval.decl).defarg = 0;
(yyval.decl).throws = 0;
(yyval.decl).throwf = 0;
+ (yyval.decl).nexcept = 0;
}
+#line 11346 "y.tab.c" /* yacc.c:1646 */
break;
- case 422:
-
-/* Line 1806 of yacc.c */
-#line 6087 "parser.y"
+ case 513:
+#line 6432 "parser.y" /* yacc.c:1646 */
{
(yyval.decl).have_parms = 0;
- (yyval.decl).defarg = (yyvsp[(2) - (3)].dtype).val;
+ (yyval.decl).defarg = (yyvsp[-1].dtype).val;
(yyval.decl).throws = 0;
(yyval.decl).throwf = 0;
+ (yyval.decl).nexcept = 0;
}
+#line 11358 "y.tab.c" /* yacc.c:1646 */
break;
- case 427:
+ case 514:
+#line 6439 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.decl).have_parms = 0;
+ (yyval.decl).defarg = (yyvsp[-1].dtype).val;
+ (yyval.decl).throws = (yyvsp[-3].dtype).throws;
+ (yyval.decl).throwf = (yyvsp[-3].dtype).throwf;
+ (yyval.decl).nexcept = (yyvsp[-3].dtype).nexcept;
+ }
+#line 11370 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6103 "parser.y"
+ case 521:
+#line 6458 "parser.y" /* yacc.c:1646 */
{
- skip_balanced('(',')');
- Clear(scanner_ccode);
- }
+ skip_balanced('(',')');
+ Clear(scanner_ccode);
+ }
+#line 11379 "y.tab.c" /* yacc.c:1646 */
break;
- case 428:
+ case 522:
+#line 6470 "parser.y" /* yacc.c:1646 */
+ {
+ skip_balanced('{','}');
+ Clear(scanner_ccode);
+ }
+#line 11388 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6109 "parser.y"
- {
+ case 523:
+#line 6476 "parser.y" /* yacc.c:1646 */
+ {
String *s = NewStringEmpty();
- SwigType_add_template(s,(yyvsp[(2) - (3)].p));
+ SwigType_add_template(s,(yyvsp[-1].p));
(yyval.id) = Char(s);
scanner_last_id(1);
- }
+ }
+#line 11399 "y.tab.c" /* yacc.c:1646 */
break;
- case 429:
-
-/* Line 1806 of yacc.c */
-#line 6115 "parser.y"
- { (yyval.id) = (char*)""; }
+ case 524:
+#line 6485 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = (yyvsp[0].id); }
+#line 11405 "y.tab.c" /* yacc.c:1646 */
break;
- case 430:
-
-/* Line 1806 of yacc.c */
-#line 6118 "parser.y"
- { (yyval.id) = (yyvsp[(1) - (1)].id); }
+ case 525:
+#line 6486 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = Swig_copy_string("override"); }
+#line 11411 "y.tab.c" /* yacc.c:1646 */
break;
- case 431:
+ case 526:
+#line 6487 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = Swig_copy_string("final"); }
+#line 11417 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6119 "parser.y"
- { (yyval.id) = (yyvsp[(1) - (1)].id); }
+ case 527:
+#line 6490 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = (yyvsp[0].id); }
+#line 11423 "y.tab.c" /* yacc.c:1646 */
break;
- case 432:
+ case 528:
+#line 6491 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = Char((yyvsp[0].dtype).val); }
+#line 11429 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6122 "parser.y"
- { (yyval.id) = (yyvsp[(1) - (1)].id); }
+ case 529:
+#line 6492 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = Char((yyvsp[0].str)); }
+#line 11435 "y.tab.c" /* yacc.c:1646 */
break;
- case 433:
+ case 530:
+#line 6495 "parser.y" /* yacc.c:1646 */
+ { (yyval.id) = (yyvsp[0].id); }
+#line 11441 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6123 "parser.y"
+ case 531:
+#line 6496 "parser.y" /* yacc.c:1646 */
{ (yyval.id) = 0; }
+#line 11447 "y.tab.c" /* yacc.c:1646 */
break;
- case 434:
-
-/* Line 1806 of yacc.c */
-#line 6126 "parser.y"
+ case 532:
+#line 6499 "parser.y" /* yacc.c:1646 */
{
(yyval.str) = 0;
- if (!(yyval.str)) (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
- Delete((yyvsp[(2) - (2)].str));
+ if (!(yyval.str)) (yyval.str) = NewStringf("%s%s", (yyvsp[-1].str),(yyvsp[0].str));
+ Delete((yyvsp[0].str));
}
+#line 11457 "y.tab.c" /* yacc.c:1646 */
break;
- case 435:
-
-/* Line 1806 of yacc.c */
-#line 6131 "parser.y"
- {
- (yyval.str) = NewStringf("::%s%s",(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
- Delete((yyvsp[(4) - (4)].str));
+ case 533:
+#line 6504 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = NewStringf("::%s%s",(yyvsp[-1].str),(yyvsp[0].str));
+ Delete((yyvsp[0].str));
}
+#line 11466 "y.tab.c" /* yacc.c:1646 */
break;
- case 436:
-
-/* Line 1806 of yacc.c */
-#line 6135 "parser.y"
+ case 534:
+#line 6508 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewString((yyvsp[(1) - (1)].str));
+ (yyval.str) = NewString((yyvsp[0].str));
}
+#line 11474 "y.tab.c" /* yacc.c:1646 */
break;
- case 437:
-
-/* Line 1806 of yacc.c */
-#line 6138 "parser.y"
+ case 535:
+#line 6511 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].str));
+ (yyval.str) = NewStringf("::%s",(yyvsp[0].str));
}
+#line 11482 "y.tab.c" /* yacc.c:1646 */
break;
- case 438:
-
-/* Line 1806 of yacc.c */
-#line 6141 "parser.y"
+ case 536:
+#line 6514 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewString((yyvsp[(1) - (1)].str));
+ (yyval.str) = NewStringf("%s", (yyvsp[0].str));
}
+#line 11490 "y.tab.c" /* yacc.c:1646 */
break;
- case 439:
+ case 537:
+#line 6517 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = NewStringf("%s%s", (yyvsp[-1].str), (yyvsp[0].id));
+ }
+#line 11498 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6144 "parser.y"
+ case 538:
+#line 6520 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].str));
+ (yyval.str) = NewStringf("::%s",(yyvsp[0].str));
}
+#line 11506 "y.tab.c" /* yacc.c:1646 */
break;
- case 440:
-
-/* Line 1806 of yacc.c */
-#line 6149 "parser.y"
+ case 539:
+#line 6525 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("::%s%s",(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
- Delete((yyvsp[(3) - (3)].str));
+ (yyval.str) = NewStringf("::%s%s",(yyvsp[-1].str),(yyvsp[0].str));
+ Delete((yyvsp[0].str));
}
+#line 11515 "y.tab.c" /* yacc.c:1646 */
break;
- case 441:
-
-/* Line 1806 of yacc.c */
-#line 6153 "parser.y"
+ case 540:
+#line 6529 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].str));
+ (yyval.str) = NewStringf("::%s",(yyvsp[0].str));
}
+#line 11523 "y.tab.c" /* yacc.c:1646 */
break;
- case 442:
-
-/* Line 1806 of yacc.c */
-#line 6156 "parser.y"
+ case 541:
+#line 6532 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].str));
+ (yyval.str) = NewStringf("::%s",(yyvsp[0].str));
}
+#line 11531 "y.tab.c" /* yacc.c:1646 */
break;
- case 443:
-
-/* Line 1806 of yacc.c */
-#line 6163 "parser.y"
+ case 542:
+#line 6539 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("::~%s",(yyvsp[(2) - (2)].str));
+ (yyval.str) = NewStringf("::~%s",(yyvsp[0].str));
}
+#line 11539 "y.tab.c" /* yacc.c:1646 */
break;
- case 444:
+ case 543:
+#line 6545 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = NewStringf("%s", (yyvsp[0].id));
+ }
+#line 11547 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6169 "parser.y"
+ case 544:
+#line 6548 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("%s%s",(yyvsp[(1) - (2)].id),(yyvsp[(2) - (2)].id));
- /* if (Len($2)) {
- scanner_last_id(1);
- } */
- }
+ (yyval.str) = NewStringf("%s%s", (yyvsp[-1].id), (yyvsp[0].id));
+ }
+#line 11555 "y.tab.c" /* yacc.c:1646 */
break;
- case 445:
+ case 545:
+#line 6553 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = (yyvsp[0].str);
+ }
+#line 11563 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6178 "parser.y"
- {
+ case 546:
+#line 6556 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = NewStringf("%s%s", (yyvsp[-1].id), (yyvsp[0].id));
+ }
+#line 11571 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 547:
+#line 6562 "parser.y" /* yacc.c:1646 */
+ {
(yyval.str) = 0;
- if (!(yyval.str)) (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].id),(yyvsp[(2) - (2)].str));
- Delete((yyvsp[(2) - (2)].str));
+ if (!(yyval.str)) (yyval.str) = NewStringf("%s%s", (yyvsp[-1].id),(yyvsp[0].str));
+ Delete((yyvsp[0].str));
}
+#line 11581 "y.tab.c" /* yacc.c:1646 */
break;
- case 446:
-
-/* Line 1806 of yacc.c */
-#line 6183 "parser.y"
- {
- (yyval.str) = NewStringf("::%s%s",(yyvsp[(3) - (4)].id),(yyvsp[(4) - (4)].str));
- Delete((yyvsp[(4) - (4)].str));
+ case 548:
+#line 6567 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = NewStringf("::%s%s",(yyvsp[-1].id),(yyvsp[0].str));
+ Delete((yyvsp[0].str));
}
+#line 11590 "y.tab.c" /* yacc.c:1646 */
break;
- case 447:
-
-/* Line 1806 of yacc.c */
-#line 6187 "parser.y"
+ case 549:
+#line 6571 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewString((yyvsp[(1) - (1)].id));
+ (yyval.str) = NewString((yyvsp[0].id));
}
+#line 11598 "y.tab.c" /* yacc.c:1646 */
break;
- case 448:
-
-/* Line 1806 of yacc.c */
-#line 6190 "parser.y"
+ case 550:
+#line 6574 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].id));
+ (yyval.str) = NewStringf("::%s",(yyvsp[0].id));
}
+#line 11606 "y.tab.c" /* yacc.c:1646 */
break;
- case 449:
-
-/* Line 1806 of yacc.c */
-#line 6193 "parser.y"
+ case 551:
+#line 6577 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewString((yyvsp[(1) - (1)].str));
+ (yyval.str) = NewString((yyvsp[0].str));
}
+#line 11614 "y.tab.c" /* yacc.c:1646 */
break;
- case 450:
-
-/* Line 1806 of yacc.c */
-#line 6196 "parser.y"
+ case 552:
+#line 6580 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].str));
+ (yyval.str) = NewStringf("::%s",(yyvsp[0].str));
}
+#line 11622 "y.tab.c" /* yacc.c:1646 */
break;
- case 451:
-
-/* Line 1806 of yacc.c */
-#line 6201 "parser.y"
+ case 553:
+#line 6585 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("::%s%s",(yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].str));
- Delete((yyvsp[(3) - (3)].str));
+ (yyval.str) = NewStringf("::%s%s",(yyvsp[-1].id),(yyvsp[0].str));
+ Delete((yyvsp[0].str));
}
+#line 11631 "y.tab.c" /* yacc.c:1646 */
break;
- case 452:
-
-/* Line 1806 of yacc.c */
-#line 6205 "parser.y"
+ case 554:
+#line 6589 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].id));
+ (yyval.str) = NewStringf("::%s",(yyvsp[0].id));
}
+#line 11639 "y.tab.c" /* yacc.c:1646 */
break;
- case 453:
-
-/* Line 1806 of yacc.c */
-#line 6208 "parser.y"
+ case 555:
+#line 6592 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].str));
+ (yyval.str) = NewStringf("::%s",(yyvsp[0].str));
}
+#line 11647 "y.tab.c" /* yacc.c:1646 */
break;
- case 454:
-
-/* Line 1806 of yacc.c */
-#line 6211 "parser.y"
+ case 556:
+#line 6595 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewStringf("::~%s",(yyvsp[(2) - (2)].id));
+ (yyval.str) = NewStringf("::~%s",(yyvsp[0].id));
}
+#line 11655 "y.tab.c" /* yacc.c:1646 */
break;
- case 455:
-
-/* Line 1806 of yacc.c */
-#line 6217 "parser.y"
+ case 557:
+#line 6601 "parser.y" /* yacc.c:1646 */
{
- (yyval.id) = (char *) malloc(strlen((yyvsp[(1) - (2)].id))+strlen((yyvsp[(2) - (2)].id))+1);
- strcpy((yyval.id),(yyvsp[(1) - (2)].id));
- strcat((yyval.id),(yyvsp[(2) - (2)].id));
+ (yyval.str) = NewStringf("%s%s", (yyvsp[-1].str), (yyvsp[0].id));
}
+#line 11663 "y.tab.c" /* yacc.c:1646 */
break;
- case 456:
+ case 558:
+#line 6604 "parser.y" /* yacc.c:1646 */
+ { (yyval.str) = NewString((yyvsp[0].id));}
+#line 11669 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6222 "parser.y"
- { (yyval.id) = (yyvsp[(1) - (1)].id);}
+ case 559:
+#line 6607 "parser.y" /* yacc.c:1646 */
+ {
+ (yyval.str) = NewStringf("%s%s", (yyvsp[-1].str), (yyvsp[0].id));
+ }
+#line 11677 "y.tab.c" /* yacc.c:1646 */
break;
- case 457:
+ case 560:
+#line 6615 "parser.y" /* yacc.c:1646 */
+ { (yyval.str) = NewString((yyvsp[0].id));}
+#line 11683 "y.tab.c" /* yacc.c:1646 */
+ break;
-/* Line 1806 of yacc.c */
-#line 6225 "parser.y"
+ case 561:
+#line 6618 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = NewString((yyvsp[(1) - (1)].id));
+ (yyval.str) = (yyvsp[0].str);
}
+#line 11691 "y.tab.c" /* yacc.c:1646 */
break;
- case 458:
-
-/* Line 1806 of yacc.c */
-#line 6228 "parser.y"
+ case 562:
+#line 6621 "parser.y" /* yacc.c:1646 */
{
skip_balanced('{','}');
(yyval.str) = NewString(scanner_ccode);
}
+#line 11700 "y.tab.c" /* yacc.c:1646 */
break;
- case 459:
-
-/* Line 1806 of yacc.c */
-#line 6232 "parser.y"
+ case 563:
+#line 6625 "parser.y" /* yacc.c:1646 */
{
- (yyval.str) = (yyvsp[(1) - (1)].str);
+ (yyval.str) = (yyvsp[0].str);
}
+#line 11708 "y.tab.c" /* yacc.c:1646 */
break;
- case 460:
-
-/* Line 1806 of yacc.c */
-#line 6237 "parser.y"
+ case 564:
+#line 6630 "parser.y" /* yacc.c:1646 */
{
Hash *n;
(yyval.node) = NewHash();
- n = (yyvsp[(2) - (3)].node);
+ n = (yyvsp[-1].node);
while(n) {
String *name, *value;
name = Getattr(n,"name");
n = nextSibling(n);
}
}
+#line 11726 "y.tab.c" /* yacc.c:1646 */
break;
- case 461:
-
-/* Line 1806 of yacc.c */
-#line 6250 "parser.y"
+ case 565:
+#line 6643 "parser.y" /* yacc.c:1646 */
{ (yyval.node) = 0; }
+#line 11732 "y.tab.c" /* yacc.c:1646 */
break;
- case 462:
-
-/* Line 1806 of yacc.c */
-#line 6254 "parser.y"
+ case 566:
+#line 6647 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = NewHash();
- Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id));
- Setattr((yyval.node),"value",(yyvsp[(3) - (3)].id));
+ Setattr((yyval.node),"name",(yyvsp[-2].id));
+ Setattr((yyval.node),"value",(yyvsp[0].str));
}
+#line 11742 "y.tab.c" /* yacc.c:1646 */
break;
- case 463:
-
-/* Line 1806 of yacc.c */
-#line 6259 "parser.y"
+ case 567:
+#line 6652 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = NewHash();
- Setattr((yyval.node),"name",(yyvsp[(1) - (5)].id));
- Setattr((yyval.node),"value",(yyvsp[(3) - (5)].id));
- set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node));
+ Setattr((yyval.node),"name",(yyvsp[-4].id));
+ Setattr((yyval.node),"value",(yyvsp[-2].str));
+ set_nextSibling((yyval.node),(yyvsp[0].node));
}
+#line 11753 "y.tab.c" /* yacc.c:1646 */
break;
- case 464:
-
-/* Line 1806 of yacc.c */
-#line 6265 "parser.y"
+ case 568:
+#line 6658 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = NewHash();
- Setattr((yyval.node),"name",(yyvsp[(1) - (1)].id));
+ Setattr((yyval.node),"name",(yyvsp[0].id));
}
+#line 11762 "y.tab.c" /* yacc.c:1646 */
break;
- case 465:
-
-/* Line 1806 of yacc.c */
-#line 6269 "parser.y"
+ case 569:
+#line 6662 "parser.y" /* yacc.c:1646 */
{
(yyval.node) = NewHash();
- Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id));
- set_nextSibling((yyval.node),(yyvsp[(3) - (3)].node));
+ Setattr((yyval.node),"name",(yyvsp[-2].id));
+ set_nextSibling((yyval.node),(yyvsp[0].node));
}
+#line 11772 "y.tab.c" /* yacc.c:1646 */
break;
- case 466:
-
-/* Line 1806 of yacc.c */
-#line 6274 "parser.y"
+ case 570:
+#line 6667 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(3) - (3)].node);
- Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id));
+ (yyval.node) = (yyvsp[0].node);
+ Setattr((yyval.node),"name",(yyvsp[-2].id));
}
+#line 11781 "y.tab.c" /* yacc.c:1646 */
break;
- case 467:
-
-/* Line 1806 of yacc.c */
-#line 6278 "parser.y"
+ case 571:
+#line 6671 "parser.y" /* yacc.c:1646 */
{
- (yyval.node) = (yyvsp[(3) - (5)].node);
- Setattr((yyval.node),"name",(yyvsp[(1) - (5)].id));
- set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node));
+ (yyval.node) = (yyvsp[-2].node);
+ Setattr((yyval.node),"name",(yyvsp[-4].id));
+ set_nextSibling((yyval.node),(yyvsp[0].node));
}
+#line 11791 "y.tab.c" /* yacc.c:1646 */
break;
- case 468:
-
-/* Line 1806 of yacc.c */
-#line 6285 "parser.y"
+ case 572:
+#line 6678 "parser.y" /* yacc.c:1646 */
{
- (yyval.id) = (yyvsp[(1) - (1)].id);
+ (yyval.str) = (yyvsp[0].str);
}
+#line 11799 "y.tab.c" /* yacc.c:1646 */
break;
- case 469:
-
-/* Line 1806 of yacc.c */
-#line 6288 "parser.y"
+ case 573:
+#line 6681 "parser.y" /* yacc.c:1646 */
{
- (yyval.id) = Char((yyvsp[(1) - (1)].dtype).val);
+ (yyval.str) = Char((yyvsp[0].dtype).val);
}
+#line 11807 "y.tab.c" /* yacc.c:1646 */
break;
-
-/* Line 1806 of yacc.c */
-#line 11422 "y.tab.c"
+#line 11811 "y.tab.c" /* yacc.c:1646 */
default: break;
}
/* User semantic actions sometimes alter yychar, and that requires
*++yyvsp = yyval;
- /* Now `shift' the result of the reduction. Determine what state
+ /* Now 'shift' the result of the reduction. Determine what state
that goes to, based on the state we popped back to and the rule
number reduced by. */
goto yynewstate;
-/*------------------------------------.
-| yyerrlab -- here on detecting error |
-`------------------------------------*/
+/*--------------------------------------.
+| yyerrlab -- here on detecting error. |
+`--------------------------------------*/
yyerrlab:
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
if (yyerrstatus == 3)
{
/* If just tried and failed to reuse lookahead token after an
- error, discard it. */
+ error, discard it. */
if (yychar <= YYEOF)
- {
- /* Return failure if at end of input. */
- if (yychar == YYEOF)
- YYABORT;
- }
+ {
+ /* Return failure if at end of input. */
+ if (yychar == YYEOF)
+ YYABORT;
+ }
else
- {
- yydestruct ("Error: discarding",
- yytoken, &yylval);
- yychar = YYEMPTY;
- }
+ {
+ yydestruct ("Error: discarding",
+ yytoken, &yylval);
+ yychar = YYEMPTY;
+ }
}
/* Else will try to reuse lookahead token after shifting the error
if (/*CONSTCOND*/ 0)
goto yyerrorlab;
- /* Do not reclaim the symbols of the rule which action triggered
+ /* Do not reclaim the symbols of the rule whose action triggered
this YYERROR. */
YYPOPSTACK (yylen);
yylen = 0;
| yyerrlab1 -- common code for both syntax error and YYERROR. |
`-------------------------------------------------------------*/
yyerrlab1:
- yyerrstatus = 3; /* Each real token shifted decrements this. */
+ yyerrstatus = 3; /* Each real token shifted decrements this. */
for (;;)
{
yyn = yypact[yystate];
if (!yypact_value_is_default (yyn))
- {
- yyn += YYTERROR;
- if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
- {
- yyn = yytable[yyn];
- if (0 < yyn)
- break;
- }
- }
+ {
+ yyn += YYTERROR;
+ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+ {
+ yyn = yytable[yyn];
+ if (0 < yyn)
+ break;
+ }
+ }
/* Pop the current state because it cannot handle the error token. */
if (yyssp == yyss)
- YYABORT;
+ YYABORT;
yydestruct ("Error: popping",
- yystos[yystate], yyvsp);
+ yystos[yystate], yyvsp);
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
/* Shift the error token. */
yyresult = 1;
goto yyreturn;
-#if !defined(yyoverflow) || YYERROR_VERBOSE
+#if !defined yyoverflow || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval);
}
- /* Do not reclaim the symbols of the rule which action triggered
+ /* Do not reclaim the symbols of the rule whose action triggered
this YYABORT or YYACCEPT. */
YYPOPSTACK (yylen);
YY_STACK_PRINT (yyss, yyssp);
while (yyssp != yyss)
{
yydestruct ("Cleanup: popping",
- yystos[*yyssp], yyvsp);
+ yystos[*yyssp], yyvsp);
YYPOPSTACK (1);
}
#ifndef yyoverflow
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
- /* Make sure YYID is used. */
- return YYID (yyresult);
+ return yyresult;
}
-
-
-
-/* Line 2067 of yacc.c */
-#line 6295 "parser.y"
+#line 6688 "parser.y" /* yacc.c:1906 */
SwigType *Swig_cparse_type(String *s) {
return top;
}
-
-/* A Bison parser, made by GNU Bison 2.5. */
+/* A Bison parser, made by GNU Bison 3.0.4. */
/* Bison interface for Yacc-like parsers in C
-
- Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
-
+
+ Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
-
+
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
+#ifndef YY_YY_Y_TAB_H_INCLUDED
+# define YY_YY_Y_TAB_H_INCLUDED
+/* Debug traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
-/* Tokens. */
+/* Token type. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
- /* Put the tokens into the symbol table, so that GDB and other debuggers
- know about them. */
- enum yytokentype {
- ID = 258,
- HBLOCK = 259,
- POUND = 260,
- STRING = 261,
- INCLUDE = 262,
- IMPORT = 263,
- INSERT = 264,
- CHARCONST = 265,
- NUM_INT = 266,
- NUM_FLOAT = 267,
- NUM_UNSIGNED = 268,
- NUM_LONG = 269,
- NUM_ULONG = 270,
- NUM_LONGLONG = 271,
- NUM_ULONGLONG = 272,
- NUM_BOOL = 273,
- TYPEDEF = 274,
- TYPE_INT = 275,
- TYPE_UNSIGNED = 276,
- TYPE_SHORT = 277,
- TYPE_LONG = 278,
- TYPE_FLOAT = 279,
- TYPE_DOUBLE = 280,
- TYPE_CHAR = 281,
- TYPE_WCHAR = 282,
- TYPE_VOID = 283,
- TYPE_SIGNED = 284,
- TYPE_BOOL = 285,
- TYPE_COMPLEX = 286,
- TYPE_TYPEDEF = 287,
- TYPE_RAW = 288,
- TYPE_NON_ISO_INT8 = 289,
- TYPE_NON_ISO_INT16 = 290,
- TYPE_NON_ISO_INT32 = 291,
- TYPE_NON_ISO_INT64 = 292,
- LPAREN = 293,
- RPAREN = 294,
- COMMA = 295,
- SEMI = 296,
- EXTERN = 297,
- INIT = 298,
- LBRACE = 299,
- RBRACE = 300,
- PERIOD = 301,
- CONST_QUAL = 302,
- VOLATILE = 303,
- REGISTER = 304,
- STRUCT = 305,
- UNION = 306,
- EQUAL = 307,
- SIZEOF = 308,
- MODULE = 309,
- LBRACKET = 310,
- RBRACKET = 311,
- BEGINFILE = 312,
- ENDOFFILE = 313,
- ILLEGAL = 314,
- CONSTANT = 315,
- NAME = 316,
- RENAME = 317,
- NAMEWARN = 318,
- EXTEND = 319,
- PRAGMA = 320,
- FEATURE = 321,
- VARARGS = 322,
- ENUM = 323,
- CLASS = 324,
- TYPENAME = 325,
- PRIVATE = 326,
- PUBLIC = 327,
- PROTECTED = 328,
- COLON = 329,
- STATIC = 330,
- VIRTUAL = 331,
- FRIEND = 332,
- THROW = 333,
- CATCH = 334,
- EXPLICIT = 335,
- USING = 336,
- NAMESPACE = 337,
- NATIVE = 338,
- INLINE = 339,
- TYPEMAP = 340,
- EXCEPT = 341,
- ECHO = 342,
- APPLY = 343,
- CLEAR = 344,
- SWIGTEMPLATE = 345,
- FRAGMENT = 346,
- WARN = 347,
- LESSTHAN = 348,
- GREATERTHAN = 349,
- DELETE_KW = 350,
- LESSTHANOREQUALTO = 351,
- GREATERTHANOREQUALTO = 352,
- EQUALTO = 353,
- NOTEQUALTO = 354,
- QUESTIONMARK = 355,
- TYPES = 356,
- PARMS = 357,
- NONID = 358,
- DSTAR = 359,
- DCNOT = 360,
- TEMPLATE = 361,
- OPERATOR = 362,
- COPERATOR = 363,
- PARSETYPE = 364,
- PARSEPARM = 365,
- PARSEPARMS = 366,
- CAST = 367,
- LOR = 368,
- LAND = 369,
- OR = 370,
- XOR = 371,
- AND = 372,
- RSHIFT = 373,
- LSHIFT = 374,
- MINUS = 375,
- PLUS = 376,
- MODULO = 377,
- SLASH = 378,
- STAR = 379,
- LNOT = 380,
- NOT = 381,
- UMINUS = 382,
- DCOLON = 383
- };
+ enum yytokentype
+ {
+ ID = 258,
+ HBLOCK = 259,
+ POUND = 260,
+ STRING = 261,
+ WSTRING = 262,
+ INCLUDE = 263,
+ IMPORT = 264,
+ INSERT = 265,
+ CHARCONST = 266,
+ WCHARCONST = 267,
+ NUM_INT = 268,
+ NUM_FLOAT = 269,
+ NUM_UNSIGNED = 270,
+ NUM_LONG = 271,
+ NUM_ULONG = 272,
+ NUM_LONGLONG = 273,
+ NUM_ULONGLONG = 274,
+ NUM_BOOL = 275,
+ TYPEDEF = 276,
+ TYPE_INT = 277,
+ TYPE_UNSIGNED = 278,
+ TYPE_SHORT = 279,
+ TYPE_LONG = 280,
+ TYPE_FLOAT = 281,
+ TYPE_DOUBLE = 282,
+ TYPE_CHAR = 283,
+ TYPE_WCHAR = 284,
+ TYPE_VOID = 285,
+ TYPE_SIGNED = 286,
+ TYPE_BOOL = 287,
+ TYPE_COMPLEX = 288,
+ TYPE_TYPEDEF = 289,
+ TYPE_RAW = 290,
+ TYPE_NON_ISO_INT8 = 291,
+ TYPE_NON_ISO_INT16 = 292,
+ TYPE_NON_ISO_INT32 = 293,
+ TYPE_NON_ISO_INT64 = 294,
+ LPAREN = 295,
+ RPAREN = 296,
+ COMMA = 297,
+ SEMI = 298,
+ EXTERN = 299,
+ INIT = 300,
+ LBRACE = 301,
+ RBRACE = 302,
+ PERIOD = 303,
+ CONST_QUAL = 304,
+ VOLATILE = 305,
+ REGISTER = 306,
+ STRUCT = 307,
+ UNION = 308,
+ EQUAL = 309,
+ SIZEOF = 310,
+ MODULE = 311,
+ LBRACKET = 312,
+ RBRACKET = 313,
+ BEGINFILE = 314,
+ ENDOFFILE = 315,
+ ILLEGAL = 316,
+ CONSTANT = 317,
+ NAME = 318,
+ RENAME = 319,
+ NAMEWARN = 320,
+ EXTEND = 321,
+ PRAGMA = 322,
+ FEATURE = 323,
+ VARARGS = 324,
+ ENUM = 325,
+ CLASS = 326,
+ TYPENAME = 327,
+ PRIVATE = 328,
+ PUBLIC = 329,
+ PROTECTED = 330,
+ COLON = 331,
+ STATIC = 332,
+ VIRTUAL = 333,
+ FRIEND = 334,
+ THROW = 335,
+ CATCH = 336,
+ EXPLICIT = 337,
+ STATIC_ASSERT = 338,
+ CONSTEXPR = 339,
+ THREAD_LOCAL = 340,
+ DECLTYPE = 341,
+ AUTO = 342,
+ NOEXCEPT = 343,
+ OVERRIDE = 344,
+ FINAL = 345,
+ USING = 346,
+ NAMESPACE = 347,
+ NATIVE = 348,
+ INLINE = 349,
+ TYPEMAP = 350,
+ EXCEPT = 351,
+ ECHO = 352,
+ APPLY = 353,
+ CLEAR = 354,
+ SWIGTEMPLATE = 355,
+ FRAGMENT = 356,
+ WARN = 357,
+ LESSTHAN = 358,
+ GREATERTHAN = 359,
+ DELETE_KW = 360,
+ DEFAULT = 361,
+ LESSTHANOREQUALTO = 362,
+ GREATERTHANOREQUALTO = 363,
+ EQUALTO = 364,
+ NOTEQUALTO = 365,
+ ARROW = 366,
+ QUESTIONMARK = 367,
+ TYPES = 368,
+ PARMS = 369,
+ NONID = 370,
+ DSTAR = 371,
+ DCNOT = 372,
+ TEMPLATE = 373,
+ OPERATOR = 374,
+ CONVERSIONOPERATOR = 375,
+ PARSETYPE = 376,
+ PARSEPARM = 377,
+ PARSEPARMS = 378,
+ CAST = 379,
+ LOR = 380,
+ LAND = 381,
+ OR = 382,
+ XOR = 383,
+ AND = 384,
+ LSHIFT = 385,
+ RSHIFT = 386,
+ PLUS = 387,
+ MINUS = 388,
+ STAR = 389,
+ SLASH = 390,
+ MODULO = 391,
+ UMINUS = 392,
+ NOT = 393,
+ LNOT = 394,
+ DCOLON = 395
+ };
#endif
/* Tokens. */
#define ID 258
#define HBLOCK 259
#define POUND 260
#define STRING 261
-#define INCLUDE 262
-#define IMPORT 263
-#define INSERT 264
-#define CHARCONST 265
-#define NUM_INT 266
-#define NUM_FLOAT 267
-#define NUM_UNSIGNED 268
-#define NUM_LONG 269
-#define NUM_ULONG 270
-#define NUM_LONGLONG 271
-#define NUM_ULONGLONG 272
-#define NUM_BOOL 273
-#define TYPEDEF 274
-#define TYPE_INT 275
-#define TYPE_UNSIGNED 276
-#define TYPE_SHORT 277
-#define TYPE_LONG 278
-#define TYPE_FLOAT 279
-#define TYPE_DOUBLE 280
-#define TYPE_CHAR 281
-#define TYPE_WCHAR 282
-#define TYPE_VOID 283
-#define TYPE_SIGNED 284
-#define TYPE_BOOL 285
-#define TYPE_COMPLEX 286
-#define TYPE_TYPEDEF 287
-#define TYPE_RAW 288
-#define TYPE_NON_ISO_INT8 289
-#define TYPE_NON_ISO_INT16 290
-#define TYPE_NON_ISO_INT32 291
-#define TYPE_NON_ISO_INT64 292
-#define LPAREN 293
-#define RPAREN 294
-#define COMMA 295
-#define SEMI 296
-#define EXTERN 297
-#define INIT 298
-#define LBRACE 299
-#define RBRACE 300
-#define PERIOD 301
-#define CONST_QUAL 302
-#define VOLATILE 303
-#define REGISTER 304
-#define STRUCT 305
-#define UNION 306
-#define EQUAL 307
-#define SIZEOF 308
-#define MODULE 309
-#define LBRACKET 310
-#define RBRACKET 311
-#define BEGINFILE 312
-#define ENDOFFILE 313
-#define ILLEGAL 314
-#define CONSTANT 315
-#define NAME 316
-#define RENAME 317
-#define NAMEWARN 318
-#define EXTEND 319
-#define PRAGMA 320
-#define FEATURE 321
-#define VARARGS 322
-#define ENUM 323
-#define CLASS 324
-#define TYPENAME 325
-#define PRIVATE 326
-#define PUBLIC 327
-#define PROTECTED 328
-#define COLON 329
-#define STATIC 330
-#define VIRTUAL 331
-#define FRIEND 332
-#define THROW 333
-#define CATCH 334
-#define EXPLICIT 335
-#define USING 336
-#define NAMESPACE 337
-#define NATIVE 338
-#define INLINE 339
-#define TYPEMAP 340
-#define EXCEPT 341
-#define ECHO 342
-#define APPLY 343
-#define CLEAR 344
-#define SWIGTEMPLATE 345
-#define FRAGMENT 346
-#define WARN 347
-#define LESSTHAN 348
-#define GREATERTHAN 349
-#define DELETE_KW 350
-#define LESSTHANOREQUALTO 351
-#define GREATERTHANOREQUALTO 352
-#define EQUALTO 353
-#define NOTEQUALTO 354
-#define QUESTIONMARK 355
-#define TYPES 356
-#define PARMS 357
-#define NONID 358
-#define DSTAR 359
-#define DCNOT 360
-#define TEMPLATE 361
-#define OPERATOR 362
-#define COPERATOR 363
-#define PARSETYPE 364
-#define PARSEPARM 365
-#define PARSEPARMS 366
-#define CAST 367
-#define LOR 368
-#define LAND 369
-#define OR 370
-#define XOR 371
-#define AND 372
-#define RSHIFT 373
-#define LSHIFT 374
-#define MINUS 375
-#define PLUS 376
-#define MODULO 377
-#define SLASH 378
-#define STAR 379
-#define LNOT 380
-#define NOT 381
-#define UMINUS 382
-#define DCOLON 383
-
-
-
+#define WSTRING 262
+#define INCLUDE 263
+#define IMPORT 264
+#define INSERT 265
+#define CHARCONST 266
+#define WCHARCONST 267
+#define NUM_INT 268
+#define NUM_FLOAT 269
+#define NUM_UNSIGNED 270
+#define NUM_LONG 271
+#define NUM_ULONG 272
+#define NUM_LONGLONG 273
+#define NUM_ULONGLONG 274
+#define NUM_BOOL 275
+#define TYPEDEF 276
+#define TYPE_INT 277
+#define TYPE_UNSIGNED 278
+#define TYPE_SHORT 279
+#define TYPE_LONG 280
+#define TYPE_FLOAT 281
+#define TYPE_DOUBLE 282
+#define TYPE_CHAR 283
+#define TYPE_WCHAR 284
+#define TYPE_VOID 285
+#define TYPE_SIGNED 286
+#define TYPE_BOOL 287
+#define TYPE_COMPLEX 288
+#define TYPE_TYPEDEF 289
+#define TYPE_RAW 290
+#define TYPE_NON_ISO_INT8 291
+#define TYPE_NON_ISO_INT16 292
+#define TYPE_NON_ISO_INT32 293
+#define TYPE_NON_ISO_INT64 294
+#define LPAREN 295
+#define RPAREN 296
+#define COMMA 297
+#define SEMI 298
+#define EXTERN 299
+#define INIT 300
+#define LBRACE 301
+#define RBRACE 302
+#define PERIOD 303
+#define CONST_QUAL 304
+#define VOLATILE 305
+#define REGISTER 306
+#define STRUCT 307
+#define UNION 308
+#define EQUAL 309
+#define SIZEOF 310
+#define MODULE 311
+#define LBRACKET 312
+#define RBRACKET 313
+#define BEGINFILE 314
+#define ENDOFFILE 315
+#define ILLEGAL 316
+#define CONSTANT 317
+#define NAME 318
+#define RENAME 319
+#define NAMEWARN 320
+#define EXTEND 321
+#define PRAGMA 322
+#define FEATURE 323
+#define VARARGS 324
+#define ENUM 325
+#define CLASS 326
+#define TYPENAME 327
+#define PRIVATE 328
+#define PUBLIC 329
+#define PROTECTED 330
+#define COLON 331
+#define STATIC 332
+#define VIRTUAL 333
+#define FRIEND 334
+#define THROW 335
+#define CATCH 336
+#define EXPLICIT 337
+#define STATIC_ASSERT 338
+#define CONSTEXPR 339
+#define THREAD_LOCAL 340
+#define DECLTYPE 341
+#define AUTO 342
+#define NOEXCEPT 343
+#define OVERRIDE 344
+#define FINAL 345
+#define USING 346
+#define NAMESPACE 347
+#define NATIVE 348
+#define INLINE 349
+#define TYPEMAP 350
+#define EXCEPT 351
+#define ECHO 352
+#define APPLY 353
+#define CLEAR 354
+#define SWIGTEMPLATE 355
+#define FRAGMENT 356
+#define WARN 357
+#define LESSTHAN 358
+#define GREATERTHAN 359
+#define DELETE_KW 360
+#define DEFAULT 361
+#define LESSTHANOREQUALTO 362
+#define GREATERTHANOREQUALTO 363
+#define EQUALTO 364
+#define NOTEQUALTO 365
+#define ARROW 366
+#define QUESTIONMARK 367
+#define TYPES 368
+#define PARMS 369
+#define NONID 370
+#define DSTAR 371
+#define DCNOT 372
+#define TEMPLATE 373
+#define OPERATOR 374
+#define CONVERSIONOPERATOR 375
+#define PARSETYPE 376
+#define PARSEPARM 377
+#define PARSEPARMS 378
+#define CAST 379
+#define LOR 380
+#define LAND 381
+#define OR 382
+#define XOR 383
+#define AND 384
+#define LSHIFT 385
+#define RSHIFT 386
+#define PLUS 387
+#define MINUS 388
+#define STAR 389
+#define SLASH 390
+#define MODULO 391
+#define UMINUS 392
+#define NOT 393
+#define LNOT 394
+#define DCOLON 395
+/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-{
-/* Line 2068 of yacc.c */
-#line 1647 "parser.y"
+union YYSTYPE
+{
+#line 1341 "parser.y" /* yacc.c:1909 */
- char *id;
+ const char *id;
List *bases;
struct Define {
String *val;
String *bitfield;
Parm *throws;
String *throwf;
+ String *nexcept;
} dtype;
struct {
- char *type;
+ const char *type;
String *filename;
int line;
} loc;
short have_parms;
ParmList *throws;
String *throwf;
+ String *nexcept;
} decl;
Parm *tparms;
struct {
int intvalue;
Node *node;
+#line 379 "y.tab.h" /* yacc.c:1909 */
+};
-
-/* Line 2068 of yacc.c */
-#line 351 "y.tab.h"
-} YYSTYPE;
+typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
#endif
+
extern YYSTYPE yylval;
+int yyparse (void);
+#endif /* !YY_YY_Y_TAB_H_INCLUDED */
* some point. Beware.
* ----------------------------------------------------------------------------- */
-%{
+/* There are 6 known shift-reduce conflicts in this file, fail compilation if any
+ more are introduced.
+
+ Please don't increase the number of the conflicts if at all possible. And if
+ you really have no choice but to do it, make sure you clearly document each
+ new conflict in this file.
+ */
+%expect 6
+%{
#define yylex yylex
#include "swig.h"
static Node *top = 0; /* Top of the generated parse tree */
static int unnamed = 0; /* Unnamed datatype counter */
-static Hash *extendhash = 0; /* Hash table of added methods */
static Hash *classes = 0; /* Hash table of classes */
static Hash *classes_typedefs = 0; /* Hash table of typedef classes: typedef struct X {...} Y; */
static Symtab *prev_symtab = 0;
static String *Classprefix = 0;
static String *Namespaceprefix = 0;
static int inclass = 0;
-static int nested_template = 0; /* template class/function definition within a class */
-static char *last_cpptype = 0;
+static Node *currentOuterClass = 0; /* for nested classes */
+static const char *last_cpptype = 0;
static int inherit_list = 0;
static Parm *template_parameters = 0;
static int extendmode = 0;
static int compact_default_args = 0;
static int template_reduce = 0;
static int cparse_externc = 0;
-
-static int max_class_levels = 0;
-static int class_level = 0;
-static Node **class_decl = NULL;
-
+int ignore_nested_classes = 0;
+int kwargs_supported = 0;
/* -----------------------------------------------------------------------------
* Assist Functions
* ----------------------------------------------------------------------------- */
(void)e;
}
-static Node *new_node(const_String_or_char_ptr tag) {
- Node *n = NewHash();
- set_nodeType(n,tag);
- Setfile(n,cparse_file);
- Setline(n,cparse_line);
- return n;
-}
-
/* Copies a node. Does not copy tree links or symbol table data (except for
sym:name) */
Delete(pl);
continue;
}
+ if (strcmp(ckey,"nested:outer") == 0) { /* don't copy outer classes links, they will be updated later */
+ Setattr(nn, key, k.item);
+ continue;
+ }
+ /* defaultargs will be patched back in later in update_defaultargs() */
+ if (strcmp(ckey,"defaultargs") == 0) {
+ Setattr(nn, "needs_defaultargs", "1");
+ continue;
+ }
/* Looks okay. Just copy the data using Copy */
ci = Copy(k.item);
Setattr(nn, key, ci);
static char *typemap_lang = 0; /* Current language setting */
static int cplus_mode = 0;
-static String *class_rename = 0;
/* C++ modes */
}
}
+static void set_access_mode(Node *n) {
+ if (cplus_mode == CPLUS_PUBLIC)
+ Setattr(n, "access", "public");
+ else if (cplus_mode == CPLUS_PROTECTED)
+ Setattr(n, "access", "protected");
+ else
+ Setattr(n, "access", "private");
+}
+
+static void restore_access_mode(Node *n) {
+ String *mode = Getattr(n, "access");
+ if (Strcmp(mode, "private") == 0)
+ cplus_mode = CPLUS_PRIVATE;
+ else if (Strcmp(mode, "protected") == 0)
+ cplus_mode = CPLUS_PROTECTED;
+ else
+ cplus_mode = CPLUS_PUBLIC;
+}
+
/* Generate the symbol table name for an object */
/* This is a bit of a mess. Need to clean up */
static String *add_oldname = 0;
String *decl;
String *wrn = 0;
- if (nested_template) {
- if (!(n && Equal(nodeType(n), "template"))) {
- return;
- }
- /* continue if template function, but not template class, declared within a class */
- }
-
if (inclass && n) {
cparse_normalize_void(n);
}
int isfriend = inclass && is_friend(n);
int iscdecl = Cmp(nodeType(n),"cdecl") == 0;
int only_csymbol = 0;
- if (extendmode) {
- Setattr(n,"isextension","1");
- }
if (inclass) {
String *name = Getattr(n, "name");
}
Delete(prefix);
}
-
- /*
- if (!Getattr(n,"parentNode") && class_level) set_parentNode(n,class_decl[class_level - 1]);
- */
- Setattr(n,"ismember","1");
}
}
+
+ if (!isfriend && (inclass || extendmode)) {
+ Setattr(n,"ismember","1");
+ }
+
+ if (extendmode) {
+ Setattr(n,"isextendmember","1");
+ }
+
if (!isfriend && inclass) {
if ((cplus_mode != CPLUS_PUBLIC)) {
only_csymbol = 1;
if ((Cmp(Getattr(n,"storage"),"virtual") == 0) && (Cmp(Getattr(n,"value"),"0") == 0)) {
only_csymbol = 0;
}
+ if (Cmp(nodeType(n),"destructor") == 0) {
+ /* Needed for "unref" feature */
+ only_csymbol = 0;
+ }
}
} else {
Setattr(n,"access", "public");
} else {
ty = type;
}
- if (!SwigType_ismutable(ty)) {
+ if (!SwigType_ismutable(ty) || (storage && Strstr(storage, "constexpr"))) {
SetFlag(n,"hasconsttype");
SetFlag(n,"feature:immutable");
}
n = nextSibling(n);
continue;
}
- if (only_csymbol || GetFlag(n,"feature:ignore")) {
+ if (cparse_cplusplus) {
+ String *value = Getattr(n, "value");
+ if (value && Strcmp(value, "delete") == 0) {
+ /* C++11 deleted definition / deleted function */
+ SetFlag(n,"deleted");
+ SetFlag(n,"feature:ignore");
+ }
+ }
+ if (only_csymbol || GetFlag(n,"feature:ignore") || strncmp(Char(symname),"$ignore",7) == 0) {
/* Only add to C symbol table and continue */
Swig_symbol_add(0, n);
- } else if (strncmp(Char(symname),"$ignore",7) == 0) {
- char *c = Char(symname)+7;
- SetFlag(n,"feature:ignore");
- if (strlen(c)) {
- SWIG_WARN_NODE_BEGIN(n);
- Swig_warning(0,Getfile(n), Getline(n), "%s\n",c+1);
- SWIG_WARN_NODE_END(n);
+ if (!only_csymbol && !GetFlag(n, "feature:ignore")) {
+ /* Print the warning attached to $ignore name, if any */
+ char *c = Char(symname) + 7;
+ if (strlen(c)) {
+ SWIG_WARN_NODE_BEGIN(n);
+ Swig_warning(0,Getfile(n), Getline(n), "%s\n",c+1);
+ SWIG_WARN_NODE_END(n);
+ }
+ /* If the symbol was ignored via "rename" and is visible, set also feature:ignore*/
+ SetFlag(n, "feature:ignore");
+ }
+ if (!GetFlag(n, "feature:ignore") && Strcmp(symname,"$ignore") == 0) {
+ /* Add feature:ignore if the symbol was explicitely ignored, regardless of visibility */
+ SetFlag(n, "feature:ignore");
}
- Swig_symbol_add(0, n);
} else {
Node *c;
if ((wrn) && (Len(wrn))) {
}
}
-/* Extension merge. This function is used to handle the %extend directive
- when it appears before a class definition. To handle this, the %extend
- actually needs to take precedence. Therefore, we will selectively nuke symbols
- from the current symbol table, replacing them with the added methods */
-
-static void merge_extensions(Node *cls, Node *am) {
- Node *n;
- Node *csym;
-
- n = firstChild(am);
- while (n) {
- String *symname;
- if (Strcmp(nodeType(n),"constructor") == 0) {
- symname = Getattr(n,"sym:name");
- if (symname) {
- if (Strcmp(symname,Getattr(n,"name")) == 0) {
- /* If the name and the sym:name of a constructor are the same,
- then it hasn't been renamed. However---the name of the class
- itself might have been renamed so we need to do a consistency
- check here */
- if (Getattr(cls,"sym:name")) {
- Setattr(n,"sym:name", Getattr(cls,"sym:name"));
- }
+/* Add in the "defaultargs" attribute for functions in instantiated templates.
+ * n should be any instantiated template (class or start of linked list of functions). */
+static void update_defaultargs(Node *n) {
+ if (n) {
+ Node *firstdefaultargs = n;
+ update_defaultargs(firstChild(n));
+ n = nextSibling(n);
+ /* recursively loop through nodes of all types, but all we really need are the overloaded functions */
+ while (n) {
+ update_defaultargs(firstChild(n));
+ if (!Getattr(n, "defaultargs")) {
+ if (Getattr(n, "needs_defaultargs")) {
+ Setattr(n, "defaultargs", firstdefaultargs);
+ Delattr(n, "needs_defaultargs");
+ } else {
+ firstdefaultargs = n;
}
- }
- }
-
- symname = Getattr(n,"sym:name");
- DohIncref(symname);
- if ((symname) && (!Getattr(n,"error"))) {
- /* Remove node from its symbol table */
- Swig_symbol_remove(n);
- csym = Swig_symbol_add(symname,n);
- if (csym != n) {
- /* Conflict with previous definition. Nuke previous definition */
- String *e = NewStringEmpty();
- String *en = NewStringEmpty();
- String *ec = NewStringEmpty();
- Printf(ec,"Identifier '%s' redefined by %%extend (ignored),",symname);
- Printf(en,"%%extend definition of '%s'.",symname);
- SWIG_WARN_NODE_BEGIN(n);
- Swig_warning(WARN_PARSE_REDEFINED,Getfile(csym),Getline(csym),"%s\n",ec);
- Swig_warning(WARN_PARSE_REDEFINED,Getfile(n),Getline(n),"%s\n",en);
- SWIG_WARN_NODE_END(n);
- Printf(e,"%s:%d:%s\n%s:%d:%s\n",Getfile(csym),Getline(csym),ec,
- Getfile(n),Getline(n),en);
- Setattr(csym,"error",e);
- Delete(e);
- Delete(en);
- Delete(ec);
- Swig_symbol_remove(csym); /* Remove class definition */
- Swig_symbol_add(symname,n); /* Insert extend definition */
+ } else {
+ /* Functions added in with %extend (for specialized template classes) will already have default args patched up */
+ assert(Getattr(n, "defaultargs") == firstdefaultargs);
}
- }
- n = nextSibling(n);
- }
-}
-
-static void append_previous_extension(Node *cls, Node *am) {
- Node *n, *ne;
- Node *pe = 0;
- Node *ae = 0;
-
- if (!am) return;
-
- n = firstChild(am);
- while (n) {
- ne = nextSibling(n);
- set_nextSibling(n,0);
- /* typemaps and fragments need to be prepended */
- if (((Cmp(nodeType(n),"typemap") == 0) || (Cmp(nodeType(n),"fragment") == 0))) {
- if (!pe) pe = new_node("extend");
- appendChild(pe, n);
- } else {
- if (!ae) ae = new_node("extend");
- appendChild(ae, n);
- }
- n = ne;
- }
- if (pe) prependChild(cls,pe);
- if (ae) appendChild(cls,ae);
-}
-
-
-/* Check for unused %extend. Special case, don't report unused
- extensions for templates */
-
-static void check_extensions() {
- Iterator ki;
-
- if (!extendhash) return;
- for (ki = First(extendhash); ki.key; ki = Next(ki)) {
- if (!Strchr(ki.key,'<')) {
- SWIG_WARN_NODE_BEGIN(ki.item);
- Swig_warning(WARN_PARSE_EXTEND_UNDEF,Getfile(ki.item), Getline(ki.item), "%%extend defined for an undeclared class %s.\n", SwigType_namestr(ki.key));
- SWIG_WARN_NODE_END(ki.item);
+ n = nextSibling(n);
}
}
}
return nname;
}
-static List *make_inherit_list(String *clsname, List *names) {
- int i, ilen;
- String *derived;
- List *bases = NewList();
-
- if (Namespaceprefix) derived = NewStringf("%s::%s", Namespaceprefix,clsname);
- else derived = NewString(clsname);
-
- ilen = Len(names);
- for (i = 0; i < ilen; i++) {
- Node *s;
- String *base;
- String *n = Getitem(names,i);
- /* Try to figure out where this symbol is */
- s = Swig_symbol_clookup(n,0);
- if (s) {
- while (s && (Strcmp(nodeType(s),"class") != 0)) {
- /* Not a class. Could be a typedef though. */
- String *storage = Getattr(s,"storage");
- if (storage && (Strcmp(storage,"typedef") == 0)) {
- String *nn = Getattr(s,"type");
- s = Swig_symbol_clookup(nn,Getattr(s,"sym:symtab"));
- } else {
- break;
- }
- }
- if (s && ((Strcmp(nodeType(s),"class") == 0) || (Strcmp(nodeType(s),"template") == 0))) {
- String *q = Swig_symbol_qualified(s);
- Append(bases,s);
- if (q) {
- base = NewStringf("%s::%s", q, Getattr(s,"name"));
- Delete(q);
- } else {
- base = NewString(Getattr(s,"name"));
- }
- } else {
- base = NewString(n);
- }
- } else {
- base = NewString(n);
- }
- if (base) {
- Swig_name_inherit(base,derived);
- Delete(base);
+/* Use typedef name as class name */
+
+static void add_typedef_name(Node *n, Node *declnode, String *oldName, Symtab *cscope, String *scpname) {
+ String *class_rename = 0;
+ SwigType *decl = Getattr(declnode, "decl");
+ if (!decl || !Len(decl)) {
+ String *cname;
+ String *tdscopename;
+ String *class_scope = Swig_symbol_qualifiedscopename(cscope);
+ String *name = Getattr(declnode, "name");
+ cname = Copy(name);
+ Setattr(n, "tdname", cname);
+ tdscopename = class_scope ? NewStringf("%s::%s", class_scope, name) : Copy(name);
+ class_rename = Getattr(n, "class_rename");
+ if (class_rename && (Strcmp(class_rename, oldName) == 0))
+ Setattr(n, "class_rename", NewString(name));
+ if (!classes_typedefs) classes_typedefs = NewHash();
+ if (!Equal(scpname, tdscopename) && !Getattr(classes_typedefs, tdscopename)) {
+ Setattr(classes_typedefs, tdscopename, n);
}
+ Setattr(n, "decl", decl);
+ Delete(class_scope);
+ Delete(cname);
+ Delete(tdscopename);
}
- return bases;
}
/* If the class name is qualified. We need to create or lookup namespace entries */
String *name = Getattr(kw,"name");
if (name && (Cmp(name,"noblock") == 0)) {
char *cstr = Char(inputcode);
- size_t len = Len(inputcode);
+ int len = Len(inputcode);
if (len && cstr[0] == '{') {
--len; ++cstr;
if (len && cstr[len - 1] == '}') { --len; }
return cname;
}
-
-
-/* Structures for handling code fragments built for nested classes */
-
-typedef struct Nested {
- String *code; /* Associated code fragment */
- int line; /* line number where it starts */
- const char *name; /* Name associated with this nested class */
- const char *kind; /* Kind of class */
- int unnamed; /* unnamed class */
- SwigType *type; /* Datatype associated with the name */
- struct Nested *next; /* Next code fragment in list */
-} Nested;
-
-/* Some internal variables for saving nested class information */
-
-static Nested *nested_list = 0;
-
-/* Add a function to the nested list */
-
-static void add_nested(Nested *n) {
- if (!nested_list) {
- nested_list = n;
- } else {
- Nested *n1 = nested_list;
- while (n1->next)
- n1 = n1->next;
- n1->next = n;
+/* look for simple typedef name in typedef list */
+static String *try_to_find_a_name_for_unnamed_structure(const char *storage, Node *decls) {
+ String *name = 0;
+ Node *n = decls;
+ if (storage && (strcmp(storage, "typedef") == 0)) {
+ for (; n; n = nextSibling(n)) {
+ if (!Len(Getattr(n, "decl"))) {
+ name = Copy(Getattr(n, "name"));
+ break;
+ }
+ }
}
+ return name;
}
-/* -----------------------------------------------------------------------------
- * nested_new_struct()
- *
- * Nested struct handling for C code only creates a global struct from the nested struct.
- *
- * Nested structure. This is a sick "hack". If we encounter
- * a nested structure, we're going to grab the text of its definition and
- * feed it back into the scanner. In the meantime, we need to grab
- * variable declaration information and generate the associated wrapper
- * code later. Yikes!
- *
- * This really only works in a limited sense. Since we use the
- * code attached to the nested class to generate both C code
- * it can't have any SWIG directives in it. It also needs to be parsable
- * by SWIG or this whole thing is going to puke.
- * ----------------------------------------------------------------------------- */
-
-static void nested_new_struct(const char *kind, String *struct_code, Node *cpp_opt_declarators) {
- String *name;
- String *decl;
-
- /* Create a new global struct declaration which is just a copy of the nested struct */
- Nested *nested = (Nested *) malloc(sizeof(Nested));
- Nested *n = nested;
-
- name = Getattr(cpp_opt_declarators, "name");
- decl = Getattr(cpp_opt_declarators, "decl");
-
- n->code = NewStringEmpty();
- Printv(n->code, "typedef ", kind, " ", struct_code, " $classname_", name, ";\n", NIL);
- n->name = Swig_copy_string(Char(name));
- n->line = cparse_start_line;
- n->type = NewStringEmpty();
- n->kind = kind;
- n->unnamed = 0;
- SwigType_push(n->type, decl);
- n->next = 0;
-
- /* Repeat for any multiple instances of the nested struct */
- {
- Node *p = cpp_opt_declarators;
- p = nextSibling(p);
- while (p) {
- Nested *nn = (Nested *) malloc(sizeof(Nested));
-
- name = Getattr(p, "name");
- decl = Getattr(p, "decl");
-
- nn->code = NewStringEmpty();
- Printv(nn->code, "typedef ", kind, " ", struct_code, " $classname_", name, ";\n", NIL);
- nn->name = Swig_copy_string(Char(name));
- nn->line = cparse_start_line;
- nn->type = NewStringEmpty();
- nn->kind = kind;
- nn->unnamed = 0;
- SwigType_push(nn->type, decl);
- nn->next = 0;
- n->next = nn;
- n = nn;
- p = nextSibling(p);
- }
+/* traverse copied tree segment, and update outer class links*/
+static void update_nested_classes(Node *n)
+{
+ Node *c = firstChild(n);
+ while (c) {
+ if (Getattr(c, "nested:outer"))
+ Setattr(c, "nested:outer", n);
+ update_nested_classes(c);
+ c = nextSibling(c);
}
-
- add_nested(nested);
}
/* -----------------------------------------------------------------------------
* nested_forward_declaration()
*
- * Nested struct handling for C++ code only.
- *
- * Treat the nested class/struct/union as a forward declaration until a proper
- * nested class solution is implemented.
+ * Nested struct handling for C++ code if the nested classes are disabled.
+ * Create the nested class/struct/union as a forward declaration.
* ----------------------------------------------------------------------------- */
static Node *nested_forward_declaration(const char *storage, const char *kind, String *sname, String *name, Node *cpp_opt_declarators) {
Node *nn = 0;
- int warned = 0;
if (sname) {
/* Add forward declaration of the nested type */
}
}
- if (nn && Equal(nodeType(nn), "classforward")) {
- Node *n = nn;
- if (GetFlag(n, "feature:nestedworkaround")) {
- Swig_symbol_remove(n);
- nn = 0;
- warned = 1;
+ if (!currentOuterClass || !GetFlag(currentOuterClass, "nested")) {
+ if (nn && Equal(nodeType(nn), "classforward")) {
+ Node *n = nn;
+ if (!GetFlag(n, "feature:ignore")) {
+ SWIG_WARN_NODE_BEGIN(n);
+ Swig_warning(WARN_PARSE_NAMED_NESTED_CLASS, cparse_file, cparse_line,"Nested %s not currently supported (%s ignored)\n", kind, sname ? sname : name);
+ SWIG_WARN_NODE_END(n);
+ }
} else {
- SWIG_WARN_NODE_BEGIN(n);
- Swig_warning(WARN_PARSE_NAMED_NESTED_CLASS, cparse_file, cparse_line,"Nested %s not currently supported (%s ignored)\n", kind, sname ? sname : name);
- SWIG_WARN_NODE_END(n);
- warned = 1;
+ Swig_warning(WARN_PARSE_UNNAMED_NESTED_CLASS, cparse_file, cparse_line, "Nested %s not currently supported (ignored).\n", kind);
}
}
- if (!warned)
- Swig_warning(WARN_PARSE_UNNAMED_NESTED_CLASS, cparse_file, cparse_line, "Nested %s not currently supported (ignored).\n", kind);
-
return nn;
}
-/* Strips C-style and C++-style comments from string in-place. */
-static void strip_comments(char *string) {
- int state = 0; /*
- * 0 - not in comment
- * 1 - in c-style comment
- * 2 - in c++-style comment
- * 3 - in string
- * 4 - after reading / not in comments
- * 5 - after reading * in c-style comments
- * 6 - after reading \ in strings
- */
- char * c = string;
- while (*c) {
- switch (state) {
- case 0:
- if (*c == '\"')
- state = 3;
- else if (*c == '/')
- state = 4;
- break;
- case 1:
- if (*c == '*')
- state = 5;
- *c = ' ';
- break;
- case 2:
- if (*c == '\n')
- state = 0;
- else
- *c = ' ';
- break;
- case 3:
- if (*c == '\"')
- state = 0;
- else if (*c == '\\')
- state = 6;
- break;
- case 4:
- if (*c == '/') {
- *(c-1) = ' ';
- *c = ' ';
- state = 2;
- } else if (*c == '*') {
- *(c-1) = ' ';
- *c = ' ';
- state = 1;
- } else
- state = 0;
- break;
- case 5:
- if (*c == '/')
- state = 0;
- else
- state = 1;
- *c = ' ';
- break;
- case 6:
- state = 3;
- break;
- }
- ++c;
- }
-}
-
-/* Dump all of the nested class declarations to the inline processor
- * However. We need to do a few name replacements and other munging
- * first. This function must be called before closing a class! */
-
-static Node *dump_nested(const char *parent) {
- Nested *n,*n1;
- Node *ret = 0;
- Node *last = 0;
- n = nested_list;
- if (!parent) {
- nested_list = 0;
- return 0;
- }
- while (n) {
- Node *retx;
- SwigType *nt;
- /* Token replace the name of the parent class */
- Replace(n->code, "$classname", parent, DOH_REPLACE_ANY);
-
- /* Fix up the name of the datatype (for building typedefs and other stuff) */
- Append(n->type,parent);
- Append(n->type,"_");
- Append(n->type,n->name);
-
- /* Add the appropriate declaration to the C++ processor */
- retx = new_node("cdecl");
- Setattr(retx,"name",n->name);
- nt = Copy(n->type);
- Setattr(retx,"type",nt);
- Delete(nt);
- Setattr(retx,"nested",parent);
- if (n->unnamed) {
- Setattr(retx,"unnamed","1");
- }
-
- add_symbols(retx);
- if (ret) {
- set_nextSibling(last, retx);
- Delete(retx);
- } else {
- ret = retx;
- }
- last = retx;
-
- /* Strip comments - further code may break in presence of comments. */
- strip_comments(Char(n->code));
-
- /* Make all SWIG created typedef structs/unions/classes unnamed else
- redefinition errors occur - nasty hack alert.*/
-
- {
- const char* types_array[3] = {"struct", "union", "class"};
- int i;
- for (i=0; i<3; i++) {
- char* code_ptr = Char(n->code);
- while (code_ptr) {
- /* Replace struct name (as in 'struct name {...}' ) with whitespace
- name will be between struct and opening brace */
-
- code_ptr = strstr(code_ptr, types_array[i]);
- if (code_ptr) {
- char *open_bracket_pos;
- code_ptr += strlen(types_array[i]);
- open_bracket_pos = strchr(code_ptr, '{');
- if (open_bracket_pos) {
- /* Make sure we don't have something like struct A a; */
- char* semi_colon_pos = strchr(code_ptr, ';');
- if (!(semi_colon_pos && (semi_colon_pos < open_bracket_pos)))
- while (code_ptr < open_bracket_pos)
- *code_ptr++ = ' ';
- }
- }
- }
- }
- }
-
- {
- /* Remove SWIG directive %constant which may be left in the SWIG created typedefs */
- char* code_ptr = Char(n->code);
- while (code_ptr) {
- code_ptr = strstr(code_ptr, "%constant");
- if (code_ptr) {
- char* directive_end_pos = strchr(code_ptr, ';');
- if (directive_end_pos) {
- while (code_ptr <= directive_end_pos)
- *code_ptr++ = ' ';
- }
- }
- }
- }
- {
- Node *newnode = new_node("insert");
- String *code = NewStringEmpty();
- Wrapper_pretty_print(n->code, code);
- Setattr(newnode,"code", code);
- Delete(code);
- set_nextSibling(last, newnode);
- Delete(newnode);
- last = newnode;
- }
-
- /* Dump the code to the scanner */
- start_inline(Char(Getattr(last, "code")),n->line);
-
- n1 = n->next;
- Delete(n->code);
- free(n);
- n = n1;
- }
- nested_list = 0;
- return ret;
-}
Node *Swig_cparse(File *f) {
scanner_file(f);
/* Printf(stdout, "single_new_feature: [%s] [%s] [%s] [%s] [%s] [%s]\n", featurename, val, declaratorid, t, ParmList_str_defaultargs(declaratorparms), qualifier); */
+ /* Warn about deprecated features */
+ if (strcmp(featurename, "nestedworkaround") == 0)
+ Swig_warning(WARN_DEPRECATED_NESTED_WORKAROUND, cparse_file, cparse_line, "The 'nestedworkaround' feature is deprecated.\n");
+
fname = NewStringf("feature:%s",featurename);
if (declaratorid) {
fixname = feature_identifier_fix(declaratorid);
/* check if a function declaration is a plain C object */
static int is_cfunction(Node *n) {
- if (!cparse_cplusplus || cparse_externc) return 1;
- if (Cmp(Getattr(n,"storage"),"externc") == 0) {
+ if (!cparse_cplusplus || cparse_externc)
+ return 1;
+ if (Swig_storage_isexternc(n)) {
return 1;
}
return 0;
if (compact_default_args
|| is_cfunction(function)
|| GetFlag(function,"feature:compactdefaultargs")
- || GetFlag(function,"feature:kwargs")) {
+ || (GetFlag(function,"feature:kwargs") && kwargs_supported)) {
ParmList *p = Getattr(function,"parms");
if (p)
Setattr(p,"compactdefargs", "1"); /* mark parameters for special handling */
}
/* -----------------------------------------------------------------------------
- * tag_nodes()
+ * mark_nodes_as_extend()
*
- * Used by the parser to mark subtypes with extra information.
+ * Used by the %extend to mark subtypes with "feature:extend".
+ * template instances declared within %extend are skipped
* ----------------------------------------------------------------------------- */
-static void tag_nodes(Node *n, const_String_or_char_ptr attrname, DOH *value) {
- while (n) {
- Setattr(n, attrname, value);
- tag_nodes(firstChild(n), attrname, value);
- n = nextSibling(n);
+static void mark_nodes_as_extend(Node *n) {
+ for (; n; n = nextSibling(n)) {
+ if (Getattr(n, "template") && Strcmp(nodeType(n), "class") == 0)
+ continue;
+ /* Fix me: extend is not a feature. Replace with isextendmember? */
+ Setattr(n, "feature:extend", "1");
+ mark_nodes_as_extend(firstChild(n));
}
}
%}
%union {
- char *id;
+ const char *id;
List *bases;
struct Define {
String *val;
String *bitfield;
Parm *throws;
String *throwf;
+ String *nexcept;
} dtype;
struct {
- char *type;
+ const char *type;
String *filename;
int line;
} loc;
short have_parms;
ParmList *throws;
String *throwf;
+ String *nexcept;
} decl;
Parm *tparms;
struct {
%token <id> ID
%token <str> HBLOCK
%token <id> POUND
-%token <id> STRING
+%token <id> STRING WSTRING
%token <loc> INCLUDE IMPORT INSERT
-%token <str> CHARCONST
+%token <str> CHARCONST WCHARCONST
%token <dtype> NUM_INT NUM_FLOAT NUM_UNSIGNED NUM_LONG NUM_ULONG NUM_LONGLONG NUM_ULONGLONG NUM_BOOL
%token <intvalue> TYPEDEF
%token <type> TYPE_INT TYPE_UNSIGNED TYPE_SHORT TYPE_LONG TYPE_FLOAT TYPE_DOUBLE TYPE_CHAR TYPE_WCHAR TYPE_VOID TYPE_SIGNED TYPE_BOOL TYPE_COMPLEX TYPE_TYPEDEF TYPE_RAW TYPE_NON_ISO_INT8 TYPE_NON_ISO_INT16 TYPE_NON_ISO_INT32 TYPE_NON_ISO_INT64
%token NAME RENAME NAMEWARN EXTEND PRAGMA FEATURE VARARGS
%token ENUM
%token CLASS TYPENAME PRIVATE PUBLIC PROTECTED COLON STATIC VIRTUAL FRIEND THROW CATCH EXPLICIT
+%token STATIC_ASSERT CONSTEXPR THREAD_LOCAL DECLTYPE AUTO NOEXCEPT /* C++11 keywords */
+%token OVERRIDE FINAL /* C++11 identifiers with special meaning */
%token USING
%token <node> NAMESPACE
%token NATIVE INLINE
%token TYPEMAP EXCEPT ECHO APPLY CLEAR SWIGTEMPLATE FRAGMENT
%token WARN
-%token LESSTHAN GREATERTHAN DELETE_KW
+%token LESSTHAN GREATERTHAN DELETE_KW DEFAULT
%token LESSTHANOREQUALTO GREATERTHANOREQUALTO EQUALTO NOTEQUALTO
+%token ARROW
%token QUESTIONMARK
%token TYPES PARMS
%token NONID DSTAR DCNOT
%token <intvalue> TEMPLATE
%token <str> OPERATOR
-%token <str> COPERATOR
+%token <str> CONVERSIONOPERATOR
%token PARSETYPE PARSEPARM PARSEPARMS
%left CAST
%type <node> types_directive template_directive warn_directive ;
/* C declarations */
-%type <node> c_declaration c_decl c_decl_tail c_enum_decl c_enum_forward_decl c_constructor_decl ;
+%type <node> c_declaration c_decl c_decl_tail c_enum_key c_enum_inherit c_enum_decl c_enum_forward_decl c_constructor_decl;
%type <node> enumlist edecl;
/* C++ declarations */
-%type <node> cpp_declaration cpp_class_decl cpp_forward_class_decl cpp_template_decl;
+%type <node> cpp_declaration cpp_class_decl cpp_forward_class_decl cpp_template_decl cpp_alternate_rettype;
%type <node> cpp_members cpp_member;
-%type <node> cpp_constructor_decl cpp_destructor_decl cpp_protection_decl cpp_conversion_operator;
-%type <node> cpp_swig_directive cpp_temp_possible cpp_nested cpp_opt_declarators ;
-%type <node> cpp_using_decl cpp_namespace_decl cpp_catch_decl ;
+%type <node> cpp_constructor_decl cpp_destructor_decl cpp_protection_decl cpp_conversion_operator cpp_static_assert;
+%type <node> cpp_swig_directive cpp_temp_possible cpp_opt_declarators ;
+%type <node> cpp_using_decl cpp_namespace_decl cpp_catch_decl cpp_lambda_decl;
%type <node> kwargs options;
/* Misc */
-%type <dtype> initializer cpp_const ;
-%type <id> storage_class;
-%type <pl> parms ptail rawparms varargs_parms;
+%type <id> identifier;
+%type <dtype> initializer cpp_const exception_specification;
+%type <id> storage_class extern_string;
+%type <pl> parms ptail rawparms varargs_parms ;
%type <pl> templateparameters templateparameterstail;
%type <p> parm valparm rawvalparms valparms valptail ;
%type <p> typemap_parm tm_list tm_tail ;
%type <p> templateparameter ;
%type <id> templcpptype cpptype access_specifier;
-%type <node> base_specifier
-%type <type> type rawtype type_right ;
+%type <node> base_specifier;
+%type <str> ellipsis variadic;
+%type <type> type rawtype type_right anon_bitfield_type decltype ;
%type <bases> base_list inherit raw_inherit;
-%type <dtype> definetype def_args etype;
+%type <dtype> definetype def_args etype default_delete deleted_definition explicit_default;
%type <dtype> expr exprnum exprcompound valexpr;
%type <id> ename ;
-%type <id> template_decl;
+%type <id> less_valparms_greater;
%type <str> type_qualifier ;
%type <id> type_qualifier_raw;
%type <id> idstring idstringopt;
%type <str> pragma_arg;
%type <loc> includetype;
%type <type> pointer primitive_type;
-%type <decl> declarator direct_declarator notso_direct_declarator parameter_declarator typemap_parameter_declarator;
+%type <decl> declarator direct_declarator notso_direct_declarator parameter_declarator plain_declarator;
%type <decl> abstract_declarator direct_abstract_declarator ctor_end;
%type <tmap> typemap_type;
-%type <str> idcolon idcolontail idcolonnt idcolontailnt idtemplate stringbrace stringbracesemi;
-%type <id> string stringnum ;
+%type <str> idcolon idcolontail idcolonnt idcolontailnt idtemplate idtemplatetemplate stringbrace stringbracesemi;
+%type <str> string stringnum wstring;
%type <tparms> template_parms;
%type <dtype> cpp_end cpp_vend;
%type <intvalue> rename_namewarn;
%type <ptype> type_specifier primitive_type_list ;
%type <node> fname stringtype;
%type <node> featattr;
+%type <node> lambda_introducer lambda_body;
+%type <pl> lambda_tail;
%type <node> optional_constant_directive;
+%type <str> virt_specifier_seq;
%%
Setattr(module_node,"name",ModuleName);
}
Setattr($1,"module",module_node);
- check_extensions();
top = $1;
}
| PARSETYPE parm SEMI {
| SEMI { $$ = 0; }
| error {
$$ = 0;
- Swig_error(cparse_file, cparse_line,"Syntax error in input(1).\n");
+ if (cparse_unknown_directive) {
+ Swig_error(cparse_file, cparse_line, "Unknown directive '%s'.\n", cparse_unknown_directive);
+ } else {
+ Swig_error(cparse_file, cparse_line, "Syntax error in input(1).\n");
+ }
exit(1);
}
/* Out of class constructor/destructor declarations */
This is nearly impossible to parse normally. We just let the
first part generate a syntax error and then resynchronize on the
- COPERATOR token---discarding the rest of the definition. Ugh.
+ CONVERSIONOPERATOR token---discarding the rest of the definition. Ugh.
*/
- | error COPERATOR {
+ | error CONVERSIONOPERATOR {
$$ = 0;
skip_decl();
}
extend_directive : EXTEND options idcolon LBRACE {
Node *cls;
String *clsname;
+ extendmode = 1;
cplus_mode = CPLUS_PUBLIC;
if (!classes) classes = NewHash();
if (!classes_typedefs) classes_typedefs = NewHash();
- if (!extendhash) extendhash = NewHash();
clsname = make_class_name($3);
cls = Getattr(classes,clsname);
if (!cls) {
cls = Getattr(classes_typedefs, clsname);
if (!cls) {
/* No previous definition. Create a new scope */
- Node *am = Getattr(extendhash,clsname);
+ Node *am = Getattr(Swig_extend_hash(),clsname);
if (!am) {
Swig_symbol_newscope();
Swig_symbol_setscopename($3);
Note that %extend before the class typedef never worked, only %extend after the class typdef. */
prev_symtab = Swig_symbol_setscope(Getattr(cls, "symtab"));
current_class = cls;
- extendmode = 1;
SWIG_WARN_NODE_BEGIN(cls);
Swig_warning(WARN_PARSE_EXTEND_NAME, cparse_file, cparse_line, "Deprecated %%extend name used - the %s name '%s' should be used instead of the typedef name '%s'.\n", Getattr(cls, "kind"), SwigType_namestr(Getattr(cls, "name")), $3);
SWIG_WARN_NODE_END(cls);
/* Previous class definition. Use its symbol table */
prev_symtab = Swig_symbol_setscope(Getattr(cls,"symtab"));
current_class = cls;
- extendmode = 1;
}
Classprefix = NewString($3);
Namespaceprefix= Swig_symbol_qualifiedscopename(0);
clsname = make_class_name($3);
Setattr($$,"name",clsname);
- /* Mark members as extend */
-
- tag_nodes($6,"feature:extend",(char*) "1");
+ mark_nodes_as_extend($6);
if (current_class) {
/* We add the extension to the previously defined class */
appendChild($$,$6);
appendChild(current_class,$$);
} else {
/* We store the extensions in the extensions hash */
- Node *am = Getattr(extendhash,clsname);
+ Node *am = Getattr(Swig_extend_hash(),clsname);
if (am) {
/* Append the members to the previous extend methods */
appendChild(am,$6);
} else {
appendChild($$,$6);
- Setattr(extendhash,clsname,$$);
+ Setattr(Swig_extend_hash(),clsname,$$);
}
}
current_class = 0;
%constant type name = value;
------------------------------------------------------------ */
-constant_directive : CONSTANT ID EQUAL definetype SEMI {
+constant_directive : CONSTANT identifier EQUAL definetype SEMI {
if (($4.type != T_ERROR) && ($4.type != T_SYMBOL)) {
SwigType *type = NewSwigType($4.type);
$$ = new_node("constant");
}
| ECHO string {
char temp[64];
- String *s = NewString($2);
+ String *s = $2;
Replace(s,"$file",cparse_file, DOH_REPLACE_ANY);
sprintf(temp,"%d", cparse_line);
Replace(s,"$line",temp,DOH_REPLACE_ANY);
%except;
------------------------------------------------------------ */
-except_directive : EXCEPT LPAREN ID RPAREN LBRACE {
+except_directive : EXCEPT LPAREN identifier RPAREN LBRACE {
skip_balanced('{','}');
$$ = 0;
Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n");
Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n");
}
- | EXCEPT LPAREN ID RPAREN SEMI {
+ | EXCEPT LPAREN identifier RPAREN SEMI {
$$ = 0;
Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n");
}
include_directive: includetype options string BEGINFILE {
$1.filename = Copy(cparse_file);
$1.line = cparse_line;
- scanner_set_location(NewString($3),1);
+ scanner_set_location($3,1);
if ($2) {
String *maininput = Getattr($2, "maininput");
if (maininput)
Node *nint = new_node("import");
Node *mnode = new_node("module");
Setattr(mnode,"name", mname);
+ Setattr(mnode,"options",$2);
appendChild(nint,mnode);
Delete(mnode);
appendChild(nint,firstChild($$));
}
;
-includetype : INCLUDE { $$.type = (char *) "include"; }
- | IMPORT { $$.type = (char *) "import"; ++import_mode;}
+includetype : INCLUDE { $$.type = "include"; }
+ | IMPORT { $$.type = "import"; ++import_mode;}
;
/* ------------------------------------------------------------
Setattr($$,"options",$2);
if (Getattr($2,"directors")) {
Wrapper_director_mode_set(1);
+ if (!cparse_cplusplus) {
+ Swig_error(cparse_file, cparse_line, "Directors are not supported for C code and require the -c++ option\n");
+ }
}
if (Getattr($2,"dirprot")) {
Wrapper_director_protected_mode_set(1);
%native(scriptname) type name (parms);
------------------------------------------------------------ */
-native_directive : NATIVE LPAREN ID RPAREN storage_class ID SEMI {
+native_directive : NATIVE LPAREN identifier RPAREN storage_class identifier SEMI {
$$ = new_node("native");
Setattr($$,"name",$3);
Setattr($$,"wrap:name",$6);
add_symbols($$);
}
- | NATIVE LPAREN ID RPAREN storage_class type declarator SEMI {
+ | NATIVE LPAREN identifier RPAREN storage_class type declarator SEMI {
if (!SwigType_isfunction($7.type)) {
Swig_error(cparse_file,cparse_line,"%%native declaration '%s' is not a function.\n", $7.id);
$$ = 0;
%pragma name
------------------------------------------------------------ */
-pragma_directive : PRAGMA pragma_lang ID EQUAL pragma_arg {
+pragma_directive : PRAGMA pragma_lang identifier EQUAL pragma_arg {
$$ = new_node("pragma");
Setattr($$,"lang",$2);
Setattr($$,"name",$3);
Setattr($$,"value",$5);
}
- | PRAGMA pragma_lang ID {
+ | PRAGMA pragma_lang identifier {
$$ = new_node("pragma");
Setattr($$,"lang",$2);
Setattr($$,"name",$3);
}
;
-pragma_arg : string { $$ = NewString($1); }
+pragma_arg : string { $$ = $1; }
| HBLOCK { $$ = $1; }
;
-pragma_lang : LPAREN ID RPAREN { $$ = $2; }
+pragma_lang : LPAREN identifier RPAREN { $$ = $2; }
| empty { $$ = (char *) "swig"; }
;
/* ------------------------------------------------------------
- %rename identifier newname;
- %rename identifier "newname";
+ %rename(newname) identifier;
------------------------------------------------------------ */
rename_directive : rename_namewarn declarator idstring SEMI {
scanner_clear_rename();
}
| FEATURE LPAREN idstring COMMA stringnum RPAREN declarator cpp_const SEMI {
- String *val = Len($5) ? NewString($5) : 0;
+ String *val = Len($5) ? $5 : 0;
new_feature($3, val, 0, $7.id, $7.type, $7.parms, $8.qualifier);
$$ = 0;
scanner_clear_rename();
scanner_clear_rename();
}
| FEATURE LPAREN idstring COMMA stringnum featattr RPAREN declarator cpp_const SEMI {
- String *val = Len($5) ? NewString($5) : 0;
+ String *val = Len($5) ? $5 : 0;
new_feature($3, val, $6, $8.id, $8.type, $8.parms, $9.qualifier);
$$ = 0;
scanner_clear_rename();
scanner_clear_rename();
}
| FEATURE LPAREN idstring COMMA stringnum RPAREN SEMI {
- String *val = Len($5) ? NewString($5) : 0;
+ String *val = Len($5) ? $5 : 0;
new_feature($3, val, 0, 0, 0, 0, 0);
$$ = 0;
scanner_clear_rename();
scanner_clear_rename();
}
| FEATURE LPAREN idstring COMMA stringnum featattr RPAREN SEMI {
- String *val = Len($5) ? NewString($5) : 0;
+ String *val = Len($5) ? $5 : 0;
new_feature($3, val, $6, 0, 0, 0, 0);
$$ = 0;
scanner_clear_rename();
| empty { $$ = 0;}
;
-typemap_parm : type typemap_parameter_declarator {
+typemap_parm : type plain_declarator {
Parm *parm;
SwigType_push($1,$2.type);
$$ = new_node("typemapitem");
template_directive: SWIGTEMPLATE LPAREN idstringopt RPAREN idcolonnt LESSTHAN valparms GREATERTHAN SEMI {
Parm *p, *tp;
Node *n;
+ Node *outer_class = currentOuterClass;
Symtab *tscope = 0;
int specialized = 0;
+ int variadic = 0;
$$ = 0;
if (!inclass) {
$5 = resolve_create_node_scope($5);
}
+ if (nscope_inner && Strcmp(nodeType(nscope_inner), "class") == 0) {
+ outer_class = nscope_inner;
+ }
/*
We use the new namespace entry 'nscope' only to
{
Node *nn = n;
Node *linklistend = 0;
+ Node *linkliststart = 0;
while (nn) {
Node *templnode = 0;
if (Strcmp(nodeType(nn),"template") == 0) {
Parm *tparms = Getattr(nn,"templateparms");
if (!tparms) {
specialized = 1;
+ } else if (Getattr(tparms,"variadic") && strncmp(Char(Getattr(tparms,"variadic")), "1", 1)==0) {
+ variadic = 1;
}
- if (nnisclass && !specialized && ((ParmList_len($7) > ParmList_len(tparms)))) {
+ if (nnisclass && !variadic && !specialized && (ParmList_len($7) > ParmList_len(tparms))) {
Swig_error(cparse_file, cparse_line, "Too many template parameters. Maximum of %d.\n", ParmList_len(tparms));
- } else if (nnisclass && !specialized && ((ParmList_len($7) < ParmList_numrequired(tparms)))) {
- Swig_error(cparse_file, cparse_line, "Not enough template parameters specified. %d required.\n", ParmList_numrequired(tparms));
+ } else if (nnisclass && !specialized && ((ParmList_len($7) < (ParmList_numrequired(tparms) - (variadic?1:0))))) { /* Variadic parameter is optional */
+ Swig_error(cparse_file, cparse_line, "Not enough template parameters specified. %d required.\n", (ParmList_numrequired(tparms)-(variadic?1:0)) );
} else if (!nnisclass && ((ParmList_len($7) != ParmList_len(tparms)))) {
/* must be an overloaded templated method - ignore it as it is overloaded with a different number of template parameters */
nn = Getattr(nn,"sym:nextSibling"); /* repeat for overloaded templated functions */
if (!p && tp) {
p = tp;
def_supplied = 1;
+ } else if (p && !tp) { /* Variadic template - tp < p */
+ SWIG_WARN_NODE_BEGIN(nn);
+ Swig_warning(WARN_CPP11_VARIADIC_TEMPLATE,cparse_file, cparse_line,"Only the first variadic template argument is currently supported.\n");
+ SWIG_WARN_NODE_END(nn);
+ break;
}
}
templnode = copy_node(nn);
+ update_nested_classes(templnode); /* update classes nested within template */
/* We need to set the node name based on name used to instantiate */
Setattr(templnode,"name",tname);
Delete(tname);
} else {
Setattr(templnode,"sym:typename","1");
}
- if ($3 && !inclass) {
+ /* for now, nested %template is allowed only in the same scope as the template declaration */
+ if ($3 && !(nnisclass && ((outer_class && (outer_class != Getattr(nn, "nested:outer")))
+ ||(extendmode && current_class && (current_class != Getattr(nn, "nested:outer")))))) {
/*
Comment this out for 1.3.28. We need to
re-enable it later but first we need to
String *symname = Swig_name_make(templnode,0,$3,0,0);
*/
- String *symname = $3;
+ String *symname = NewString($3);
Swig_cparse_template_expand(templnode,symname,temparms,tscope);
Setattr(templnode,"sym:name",symname);
} else {
Setattr(templnode,"sym:name",nname);
Delete(nname);
Setattr(templnode,"feature:onlychildren", "typemap,typemapitem,typemapcopy,typedef,types,fragment");
-
if ($3) {
Swig_warning(WARN_PARSE_NESTED_TEMPLATE, cparse_file, cparse_line, "Named nested template instantiations not supported. Processing as if no name was given to %%template().\n");
}
Setfile(templnode,cparse_file);
Setline(templnode,cparse_line);
Delete(temparms);
-
+ if (outer_class && nnisclass) {
+ SetFlag(templnode, "nested");
+ Setattr(templnode, "nested:outer", outer_class);
+ }
add_symbols_copy(templnode);
if (Strcmp(nodeType(templnode),"class") == 0) {
csyms = Swig_symbol_current();
Swig_symbol_setscope(Getattr(templnode,"symtab"));
if (baselist) {
- List *bases = make_inherit_list(Getattr(templnode,"name"),baselist);
+ List *bases = Swig_make_inherit_list(Getattr(templnode,"name"),baselist, Namespaceprefix);
if (bases) {
Iterator s;
for (s = First(bases); s.item; s = Next(s)) {
Swig_symbol_setscope(csyms);
}
- /* Merge in %extend methods for this class */
+ /* Merge in %extend methods for this class.
+ This only merges methods within %extend for a template specialized class such as
+ template<typename T> class K {}; %extend K<int> { ... }
+ The copy_node() call above has already added in the generic %extend methods such as
+ template<typename T> class K {}; %extend K { ... } */
/* !!! This may be broken. We may have to add the
%extend methods at the beginning of the class */
-
- if (extendhash) {
+ {
String *stmp = 0;
String *clsname;
Node *am;
} else {
clsname = Getattr(templnode,"name");
}
- am = Getattr(extendhash,clsname);
+ am = Getattr(Swig_extend_hash(),clsname);
if (am) {
Symtab *st = Swig_symbol_current();
Swig_symbol_setscope(Getattr(templnode,"symtab"));
/* Printf(stdout,"%s: %s %p %p\n", Getattr(templnode,"name"), clsname, Swig_symbol_current(), Getattr(templnode,"symtab")); */
- merge_extensions(templnode,am);
+ Swig_extend_merge(templnode,am);
Swig_symbol_setscope(st);
- append_previous_extension(templnode,am);
- Delattr(extendhash,clsname);
+ Swig_extend_append_previous(templnode,am);
+ Delattr(Swig_extend_hash(),clsname);
}
if (stmp) Delete(stmp);
}
+
/* Add to classes hash */
- if (!classes) classes = NewHash();
+ if (!classes)
+ classes = NewHash();
- {
- if (Namespaceprefix) {
- String *temp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,"name"));
- Setattr(classes,temp,templnode);
- Delete(temp);
- } else {
- String *qs = Swig_symbol_qualifiedscopename(templnode);
- Setattr(classes, qs,templnode);
- Delete(qs);
- }
- }
+ if (Namespaceprefix) {
+ String *temp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,"name"));
+ Setattr(classes,temp,templnode);
+ Delete(temp);
+ } else {
+ String *qs = Swig_symbol_qualifiedscopename(templnode);
+ Setattr(classes, qs,templnode);
+ Delete(qs);
+ }
}
}
/* all the overloaded templated functions are added into a linked list */
+ if (!linkliststart)
+ linkliststart = templnode;
if (nscope_inner) {
/* non-global namespace */
if (templnode) {
}
nn = Getattr(nn,"sym:nextSibling"); /* repeat for overloaded templated functions. If a templated class there will never be a sibling. */
}
+ update_defaultargs(linkliststart);
}
Swig_symbol_setscope(tscope);
Delete(Namespaceprefix);
appendChild($$,firstChild($5));
}
}
+ | cpp_lambda_decl {
+ $$ = $1;
+ SWIG_WARN_NODE_BEGIN($$);
+ Swig_warning(WARN_CPP11_LAMBDA, cparse_file, cparse_line, "Lambda expressions and closures are not fully supported yet.\n");
+ SWIG_WARN_NODE_END($$);
+ }
+ | USING idcolon EQUAL type plain_declarator SEMI {
+ $$ = new_node("using");
+ Setattr($$,"name",$2);
+ SwigType_push($4,$5.type);
+ Setattr($$,"uname",$4);
+ add_symbols($$);
+ SWIG_WARN_NODE_BEGIN($$);
+ Swig_warning(WARN_CPP11_ALIAS_DECLARATION, cparse_file, cparse_line, "The 'using' keyword in type aliasing is not fully supported yet.\n");
+ SWIG_WARN_NODE_END($$);
+
+ $$ = 0; /* TODO - ignored for now */
+ }
+ | TEMPLATE LESSTHAN template_parms GREATERTHAN USING idcolon EQUAL type plain_declarator SEMI {
+ $$ = new_node("using");
+ Setattr($$,"name",$6);
+ SwigType_push($8,$9.type);
+ Setattr($$,"uname",$8);
+ add_symbols($$);
+ SWIG_WARN_NODE_BEGIN($$);
+ Swig_warning(WARN_CPP11_ALIAS_TEMPLATE, cparse_file, cparse_line, "The 'using' keyword in template aliasing is not fully supported yet.\n");
+ SWIG_WARN_NODE_END($$);
+
+ $$ = 0; /* TODO - ignored for now */
+ }
;
/* ------------------------------------------------------------
Setattr($$,"value",$4.val);
Setattr($$,"throws",$4.throws);
Setattr($$,"throw",$4.throwf);
+ Setattr($$,"noexcept",$4.nexcept);
+ if ($4.val && $4.type) {
+ /* store initializer type as it might be different to the declared type */
+ SwigType *valuetype = NewSwigType($4.type);
+ if (Len(valuetype) > 0)
+ Setattr($$,"valuetype",valuetype);
+ else
+ Delete(valuetype);
+ }
if (!$5) {
if (Len(scanner_ccode)) {
String *code = Copy(scanner_ccode);
matches that of the declaration, then we will allow it. Otherwise, delete. */
String *p = Swig_scopename_prefix($3.id);
if (p) {
- if ((Namespaceprefix && Strcmp(p,Namespaceprefix) == 0) ||
- (inclass && Strcmp(p,Classprefix) == 0)) {
+ if ((Namespaceprefix && Strcmp(p, Namespaceprefix) == 0) ||
+ (Classprefix && Strcmp(p, Classprefix) == 0)) {
String *lstr = Swig_scopename_last($3.id);
Setattr($$,"name",lstr);
Delete(lstr);
set_nextSibling($$,$5);
}
}
+ /* Alternate function syntax introduced in C++11:
+ auto funcName(int x, int y) -> int; */
+ | storage_class AUTO declarator ARROW cpp_alternate_rettype initializer c_decl_tail {
+ $$ = new_node("cdecl");
+ if ($6.qualifier) SwigType_push($3.type,$6.qualifier);
+ Setattr($$,"type",$5);
+ Setattr($$,"storage",$1);
+ Setattr($$,"name",$3.id);
+ Setattr($$,"decl",$3.type);
+ Setattr($$,"parms",$3.parms);
+ Setattr($$,"value",$6.val);
+ Setattr($$,"throws",$6.throws);
+ Setattr($$,"throw",$6.throwf);
+ Setattr($$,"noexcept",$6.nexcept);
+ if (!$7) {
+ if (Len(scanner_ccode)) {
+ String *code = Copy(scanner_ccode);
+ Setattr($$,"code",code);
+ Delete(code);
+ }
+ } else {
+ Node *n = $7;
+ while (n) {
+ String *type = Copy($5);
+ Setattr(n,"type",type);
+ Setattr(n,"storage",$1);
+ n = nextSibling(n);
+ Delete(type);
+ }
+ }
+ if ($6.bitfield) {
+ Setattr($$,"bitfield", $6.bitfield);
+ }
+
+ if (Strstr($3.id,"::")) {
+ String *p = Swig_scopename_prefix($3.id);
+ if (p) {
+ if ((Namespaceprefix && Strcmp(p, Namespaceprefix) == 0) ||
+ (Classprefix && Strcmp(p, Classprefix) == 0)) {
+ String *lstr = Swig_scopename_last($3.id);
+ Setattr($$,"name",lstr);
+ Delete(lstr);
+ set_nextSibling($$,$7);
+ } else {
+ Delete($$);
+ $$ = $7;
+ }
+ Delete(p);
+ } else {
+ Delete($$);
+ $$ = $7;
+ }
+ } else {
+ set_nextSibling($$,$7);
+ }
+ }
;
/* Allow lists of variables and functions to be built up */
Setattr($$,"value",$3.val);
Setattr($$,"throws",$3.throws);
Setattr($$,"throw",$3.throwf);
+ Setattr($$,"noexcept",$3.nexcept);
if ($3.bitfield) {
Setattr($$,"bitfield", $3.bitfield);
}
skip_balanced('{','}');
$$ = 0;
}
+ | error {
+ $$ = 0;
+ if (yychar == RPAREN) {
+ Swig_error(cparse_file, cparse_line, "Unexpected ')'.\n");
+ } else {
+ Swig_error(cparse_file, cparse_line, "Syntax error - possibly a missing semicolon.\n");
+ }
+ exit(1);
+ }
;
initializer : def_args {
$$.qualifier = 0;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
}
| type_qualifier def_args {
$$ = $2;
$$.qualifier = $1;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
}
- | THROW LPAREN parms RPAREN def_args {
- $$ = $5;
+ | exception_specification def_args {
+ $$ = $2;
$$.qualifier = 0;
- $$.throws = $3;
- $$.throwf = NewString("1");
+ $$.throws = $1.throws;
+ $$.throwf = $1.throwf;
+ $$.nexcept = $1.nexcept;
}
- | type_qualifier THROW LPAREN parms RPAREN def_args {
- $$ = $6;
+ | type_qualifier exception_specification def_args {
+ $$ = $3;
$$.qualifier = $1;
- $$.throws = $4;
- $$.throwf = NewString("1");
+ $$.throws = $2.throws;
+ $$.throwf = $2.throwf;
+ $$.nexcept = $2.nexcept;
}
;
+cpp_alternate_rettype : primitive_type { $$ = $1; }
+ | TYPE_BOOL { $$ = $1; }
+ | TYPE_VOID { $$ = $1; }
+/*
+ | TYPE_TYPEDEF template_decl { $$ = NewStringf("%s%s",$1,$2); }
+*/
+ | TYPE_RAW { $$ = $1; }
+ | idcolon { $$ = $1; }
+ | decltype { $$ = $1; }
+ ;
+
+/* ------------------------------------------------------------
+ Lambda functions and expressions, such as:
+ auto myFunc = [] { return something; };
+ auto myFunc = [](int x, int y) { return x+y; };
+ auto myFunc = [](int x, int y) -> int { return x+y; };
+ auto myFunc = [](int x, int y) throw() -> int { return x+y; };
+ auto six = [](int x, int y) { return x+y; }(4, 2);
+ ------------------------------------------------------------ */
+cpp_lambda_decl : storage_class AUTO idcolon EQUAL lambda_introducer LPAREN parms RPAREN cpp_const lambda_body lambda_tail {
+ $$ = new_node("lambda");
+ Setattr($$,"name",$3);
+ add_symbols($$);
+ }
+ | storage_class AUTO idcolon EQUAL lambda_introducer LPAREN parms RPAREN cpp_const ARROW type lambda_body lambda_tail {
+ $$ = new_node("lambda");
+ Setattr($$,"name",$3);
+ add_symbols($$);
+ }
+ | storage_class AUTO idcolon EQUAL lambda_introducer lambda_body lambda_tail {
+ $$ = new_node("lambda");
+ Setattr($$,"name",$3);
+ add_symbols($$);
+ }
+ ;
+
+lambda_introducer : LBRACKET {
+ skip_balanced('[',']');
+ $$ = 0;
+ }
+ ;
+
+lambda_body : LBRACE {
+ skip_balanced('{','}');
+ $$ = 0;
+ }
+
+lambda_tail : SEMI {
+ $$ = 0;
+ }
+ | LPAREN {
+ skip_balanced('(',')');
+ } SEMI {
+ $$ = 0;
+ }
+ ;
+
+/* ------------------------------------------------------------
+ enum
+ or
+ enum class
+ ------------------------------------------------------------ */
+c_enum_key : ENUM {
+ $$ = (char *)"enum";
+ }
+ | ENUM CLASS {
+ $$ = (char *)"enum class";
+ }
+ | ENUM STRUCT {
+ $$ = (char *)"enum struct";
+ }
+ ;
+
+/* ------------------------------------------------------------
+ base enum type (eg. unsigned short)
+ ------------------------------------------------------------ */
+
+c_enum_inherit : COLON type_right {
+ $$ = $2;
+ }
+ | empty { $$ = 0; }
+ ;
/* ------------------------------------------------------------
- enum Name;
+ enum [class] Name;
+ enum [class] Name [: base_type];
------------------------------------------------------------ */
-c_enum_forward_decl : storage_class ENUM ID SEMI {
+c_enum_forward_decl : storage_class c_enum_key ename c_enum_inherit SEMI {
SwigType *ty = 0;
+ int scopedenum = $3 && !Equal($2, "enum");
$$ = new_node("enumforward");
ty = NewStringf("enum %s", $3);
+ Setattr($$,"enumkey",$2);
+ if (scopedenum)
+ SetFlag($$, "scopedenum");
Setattr($$,"name",$3);
+ Setattr($$,"inherit",$4);
Setattr($$,"type",ty);
Setattr($$,"sym:weak", "1");
add_symbols($$);
;
/* ------------------------------------------------------------
- enum { ... }
+ enum [class] Name [: base_type] { ... };
+ or
+ enum [class] Name [: base_type] { ... } MyEnum [= ...];
* ------------------------------------------------------------ */
-c_enum_decl : storage_class ENUM ename LBRACE enumlist RBRACE SEMI {
+c_enum_decl : storage_class c_enum_key ename c_enum_inherit LBRACE enumlist RBRACE SEMI {
SwigType *ty = 0;
+ int scopedenum = $3 && !Equal($2, "enum");
$$ = new_node("enum");
ty = NewStringf("enum %s", $3);
+ Setattr($$,"enumkey",$2);
+ if (scopedenum)
+ SetFlag($$, "scopedenum");
Setattr($$,"name",$3);
+ Setattr($$,"inherit",$4);
Setattr($$,"type",ty);
- appendChild($$,$5);
- add_symbols($$); /* Add to tag space */
- add_symbols($5); /* Add enum values to id space */
+ appendChild($$,$6);
+ add_symbols($$); /* Add to tag space */
+
+ if (scopedenum) {
+ Swig_symbol_newscope();
+ Swig_symbol_setscopename($3);
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ }
+
+ add_symbols($6); /* Add enum values to appropriate enum or enum class scope */
+
+ if (scopedenum) {
+ Setattr($$,"symtab", Swig_symbol_popscope());
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ }
}
- | storage_class ENUM ename LBRACE enumlist RBRACE declarator initializer c_decl_tail {
+ | storage_class c_enum_key ename c_enum_inherit LBRACE enumlist RBRACE declarator initializer c_decl_tail {
Node *n;
SwigType *ty = 0;
String *unnamed = 0;
int unnamedinstance = 0;
+ int scopedenum = $3 && !Equal($2, "enum");
$$ = new_node("enum");
+ Setattr($$,"enumkey",$2);
+ if (scopedenum)
+ SetFlag($$, "scopedenum");
+ Setattr($$,"inherit",$4);
if ($3) {
Setattr($$,"name",$3);
ty = NewStringf("enum %s", $3);
- } else if ($7.id) {
+ } else if ($8.id) {
unnamed = make_unnamed();
ty = NewStringf("enum %s", unnamed);
Setattr($$,"unnamed",unnamed);
/* name is not set for unnamed enum instances, e.g. enum { foo } Instance; */
if ($1 && Cmp($1,"typedef") == 0) {
- Setattr($$,"name",$7.id);
+ Setattr($$,"name",$8.id);
} else {
unnamedinstance = 1;
}
Setattr($$,"storage",$1);
}
- if ($7.id && Cmp($1,"typedef") == 0) {
- Setattr($$,"tdname",$7.id);
+ if ($8.id && Cmp($1,"typedef") == 0) {
+ Setattr($$,"tdname",$8.id);
Setattr($$,"allows_typedef","1");
}
- appendChild($$,$5);
+ appendChild($$,$6);
n = new_node("cdecl");
Setattr(n,"type",ty);
- Setattr(n,"name",$7.id);
+ Setattr(n,"name",$8.id);
Setattr(n,"storage",$1);
- Setattr(n,"decl",$7.type);
- Setattr(n,"parms",$7.parms);
+ Setattr(n,"decl",$8.type);
+ Setattr(n,"parms",$8.parms);
Setattr(n,"unnamed",unnamed);
if (unnamedinstance) {
SetFlag(n,"unnamedinstance");
Delete(cty);
}
- if ($9) {
- Node *p = $9;
+ if ($10) {
+ Node *p = $10;
set_nextSibling(n,p);
while (p) {
SwigType *cty = Copy(ty);
/* Ensure that typedef enum ABC {foo} XYZ; uses XYZ for sym:name, like structs.
* Note that class_rename/yyrename are bit of a mess so used this simple approach to change the name. */
- if ($7.id && $3 && Cmp($1,"typedef") == 0) {
- String *name = NewString($7.id);
+ if ($8.id && $3 && Cmp($1,"typedef") == 0) {
+ String *name = NewString($8.id);
Setattr($$, "parser:makename", name);
Delete(name);
}
add_symbols($$); /* Add enum to tag space */
set_nextSibling($$,n);
Delete(n);
- add_symbols($5); /* Add enum values to id space */
- add_symbols(n);
- Delete(unnamed);
- }
- ;
-
-c_constructor_decl : storage_class type LPAREN parms RPAREN ctor_end {
- /* This is a sick hack. If the ctor_end has parameters,
- and the parms parameter only has 1 parameter, this
- could be a declaration of the form:
+
+ if (scopedenum) {
+ Swig_symbol_newscope();
+ Swig_symbol_setscopename($3);
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ }
+
+ add_symbols($6); /* Add enum values to appropriate enum or enum class scope */
+
+ if (scopedenum) {
+ Setattr($$,"symtab", Swig_symbol_popscope());
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ }
+
+ add_symbols(n);
+ Delete(unnamed);
+ }
+ ;
+
+c_constructor_decl : storage_class type LPAREN parms RPAREN ctor_end {
+ /* This is a sick hack. If the ctor_end has parameters,
+ and the parms parameter only has 1 parameter, this
+ could be a declaration of the form:
type (id)(parms)
}
Setattr($$,"throws",$6.throws);
Setattr($$,"throw",$6.throwf);
+ Setattr($$,"noexcept",$6.nexcept);
err = 0;
}
}
/* A simple class/struct/union definition */
cpp_class_decl : storage_class cpptype idcolon inherit LBRACE {
- if (nested_template == 0) {
String *prefix;
List *bases = 0;
Node *scope = 0;
+ String *code;
$<node>$ = new_node("class");
Setline($<node>$,cparse_start_line);
Setattr($<node>$,"kind",$2);
Setattr($<node>$,"allows_typedef","1");
/* preserve the current scope */
- prev_symtab = Swig_symbol_current();
+ Setattr($<node>$,"prev_symtab",Swig_symbol_current());
/* If the class name is qualified. We need to create or lookup namespace/scope entries */
scope = resolve_create_node_scope($3);
+ /* save nscope_inner to the class - it may be overwritten in nested classes*/
+ Setattr($<node>$, "nested:innerscope", nscope_inner);
+ Setattr($<node>$, "nested:nscope", nscope);
Setfile(scope,cparse_file);
Setline(scope,cparse_line);
$3 = scope;
-
- /* support for old nested classes "pseudo" support, such as:
-
- %rename(Ala__Ola) Ala::Ola;
- class Ala::Ola {
- public:
- Ola() {}
- };
-
- this should disappear when a proper implementation is added.
- */
- if (nscope_inner && Strcmp(nodeType(nscope_inner),"namespace") != 0) {
- if (Namespaceprefix) {
- String *name = NewStringf("%s::%s", Namespaceprefix, $3);
- $3 = name;
- Namespaceprefix = 0;
- nscope_inner = 0;
- }
- }
Setattr($<node>$,"name",$3);
- Delete(class_rename);
- class_rename = make_name($<node>$,$3,0);
+ if (currentOuterClass) {
+ SetFlag($<node>$, "nested");
+ Setattr($<node>$, "nested:outer", currentOuterClass);
+ set_access_mode($<node>$);
+ }
+ Swig_features_get(Swig_cparse_features(), Namespaceprefix, Getattr($<node>$, "name"), 0, $<node>$);
+ /* save yyrename to the class attribute, to be used later in add_symbols()*/
+ Setattr($<node>$, "class_rename", make_name($<node>$, $3, 0));
+ Setattr($<node>$, "Classprefix", $3);
Classprefix = NewString($3);
/* Deal with inheritance */
- if ($4) {
- bases = make_inherit_list($3,Getattr($4,"public"));
- }
+ if ($4)
+ bases = Swig_make_inherit_list($3,Getattr($4,"public"),Namespaceprefix);
prefix = SwigType_istemplate_templateprefix($3);
if (prefix) {
String *fbase, *tbase;
} else {
cplus_mode = CPLUS_PUBLIC;
}
+ if (!cparse_cplusplus) {
+ set_scope_to_global();
+ }
Swig_symbol_newscope();
Swig_symbol_setscopename($3);
- if (bases) {
- Iterator s;
- for (s = First(bases); s.item; s = Next(s)) {
- Symtab *st = Getattr(s.item,"symtab");
- if (st) {
- Setfile(st,Getfile(s.item));
- Setline(st,Getline(s.item));
- Swig_symbol_inherit(st);
- }
- }
- Delete(bases);
- }
+ Swig_inherit_base_symbols(bases);
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
cparse_start_line = cparse_line;
Delete(tpname);
}
}
- if (class_level >= max_class_levels) {
- if (!max_class_levels) {
- max_class_levels = 16;
- } else {
- max_class_levels *= 2;
- }
- class_decl = (Node**) realloc(class_decl, sizeof(Node*) * max_class_levels);
- if (!class_decl) {
- Swig_error(cparse_file, cparse_line, "realloc() failed\n");
- }
- }
- class_decl[class_level++] = $<node>$;
Delete(prefix);
inclass = 1;
- }
+ currentOuterClass = $<node>$;
+ if (cparse_cplusplusout) {
+ /* save the structure declaration to declare it in global scope for C++ to see */
+ code = get_raw_text_balanced('{', '}');
+ Setattr($<node>$, "code", code);
+ Delete(code);
+ }
} cpp_members RBRACE cpp_opt_declarators {
- (void) $<node>6;
- if (nested_template == 0) {
Node *p;
SwigType *ty;
- Symtab *cscope = prev_symtab;
+ Symtab *cscope;
Node *am = 0;
String *scpname = 0;
- $$ = class_decl[--class_level];
- inclass = 0;
+ (void) $<node>6;
+ $$ = currentOuterClass;
+ currentOuterClass = Getattr($$, "nested:outer");
+ nscope_inner = Getattr($<node>$, "nested:innerscope");
+ nscope = Getattr($<node>$, "nested:nscope");
+ Delattr($<node>$, "nested:innerscope");
+ Delattr($<node>$, "nested:nscope");
+ if (nscope_inner && Strcmp(nodeType(nscope_inner), "class") == 0) { /* actual parent class for this class */
+ Node* forward_declaration = Swig_symbol_clookup_no_inherit(Getattr($<node>$,"name"), Getattr(nscope_inner, "symtab"));
+ if (forward_declaration) {
+ Setattr($<node>$, "access", Getattr(forward_declaration, "access"));
+ }
+ Setattr($<node>$, "nested:outer", nscope_inner);
+ SetFlag($<node>$, "nested");
+ }
+ if (!currentOuterClass)
+ inclass = 0;
+ cscope = Getattr($$, "prev_symtab");
+ Delattr($$, "prev_symtab");
/* Check for pure-abstract class */
Setattr($$,"abstracts", pure_abstracts($7));
/* This bit of code merges in a previously defined %extend directive (if any) */
-
- if (extendhash) {
+ {
String *clsname = Swig_symbol_qualifiedscopename(0);
- am = Getattr(extendhash,clsname);
+ am = Getattr(Swig_extend_hash(), clsname);
if (am) {
- merge_extensions($$,am);
- Delattr(extendhash,clsname);
+ Swig_extend_merge($$, am);
+ Delattr(Swig_extend_hash(), clsname);
}
Delete(clsname);
}
if (!classes) classes = NewHash();
scpname = Swig_symbol_qualifiedscopename(0);
- Setattr(classes,scpname,$$);
+ Setattr(classes, scpname, $$);
- appendChild($$,$7);
+ appendChild($$, $7);
- if (am) append_previous_extension($$,am);
+ if (am)
+ Swig_extend_append_previous($$, am);
p = $9;
- if (p) {
- set_nextSibling($$,p);
+ if (p && !nscope_inner) {
+ if (!cparse_cplusplus && currentOuterClass)
+ appendChild(currentOuterClass, p);
+ else
+ appendSibling($$, p);
}
- if (cparse_cplusplus && !cparse_externc) {
+ if (nscope_inner) {
+ ty = NewString(scpname); /* if the class is declared out of scope, let the declarator use fully qualified type*/
+ } else if (cparse_cplusplus && !cparse_externc) {
ty = NewString($3);
} else {
- ty = NewStringf("%s %s", $2,$3);
+ ty = NewStringf("%s %s", $2, $3);
}
while (p) {
- Setattr(p,"storage",$1);
- Setattr(p,"type",ty);
- p = nextSibling(p);
- }
- /* Class typedefs */
- {
- String *name = $3;
- if ($9) {
- SwigType *decltype = Getattr($9,"decl");
- if (Cmp($1,"typedef") == 0) {
- if (!decltype || !Len(decltype)) {
- String *cname;
- String *tdscopename;
- String *class_scope = Swig_symbol_qualifiedscopename(cscope);
- name = Getattr($9,"name");
- cname = Copy(name);
- Setattr($$,"tdname",cname);
- tdscopename = class_scope ? NewStringf("%s::%s", class_scope, name) : Copy(name);
-
- /* Use typedef name as class name */
- if (class_rename && (Strcmp(class_rename,$3) == 0)) {
- Delete(class_rename);
- class_rename = NewString(name);
- }
- if (!classes_typedefs) classes_typedefs = NewHash();
- if (!Equal(scpname, tdscopename) && !Getattr(classes_typedefs, tdscopename)) {
- Setattr(classes_typedefs, tdscopename, $$);
- }
- Setattr($$,"decl",decltype);
- Delete(class_scope);
- Delete(cname);
- Delete(tdscopename);
- }
- }
+ Setattr(p, "storage", $1);
+ Setattr(p, "type" ,ty);
+ if (!cparse_cplusplus && currentOuterClass && (!Getattr(currentOuterClass, "name"))) {
+ SetFlag(p, "hasconsttype");
+ SetFlag(p, "feature:immutable");
}
- appendChild($$,dump_nested(Char(name)));
+ p = nextSibling(p);
}
+ if ($9 && Cmp($1,"typedef") == 0)
+ add_typedef_name($$, $9, $3, cscope, scpname);
Delete(scpname);
if (cplus_mode != CPLUS_PUBLIC) {
/* we 'open' the class at the end, to allow %template
to add new members */
Node *pa = new_node("access");
- Setattr(pa,"kind","public");
+ Setattr(pa, "kind", "public");
cplus_mode = CPLUS_PUBLIC;
- appendChild($$,pa);
+ appendChild($$, pa);
Delete(pa);
}
-
- Setattr($$,"symtab",Swig_symbol_popscope());
-
- Classprefix = 0;
- if (nscope_inner) {
+ if (currentOuterClass)
+ restore_access_mode($$);
+ Setattr($$, "symtab", Swig_symbol_popscope());
+ Classprefix = Getattr($<node>$, "Classprefix");
+ Delattr($<node>$, "Classprefix");
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ if (cplus_mode == CPLUS_PRIVATE) {
+ $$ = 0; /* skip private nested classes */
+ } else if (cparse_cplusplus && currentOuterClass && ignore_nested_classes && !GetFlag($$, "feature:flatnested")) {
+ $$ = nested_forward_declaration($1, $2, $3, Copy($3), $9);
+ } else if (nscope_inner) {
/* this is tricky */
/* we add the declaration in the original namespace */
- appendChild(nscope_inner,$$);
- Swig_symbol_setscope(Getattr(nscope_inner,"symtab"));
+ if (Strcmp(nodeType(nscope_inner), "class") == 0 && cparse_cplusplus && ignore_nested_classes && !GetFlag($$, "feature:flatnested"))
+ $$ = nested_forward_declaration($1, $2, $3, Copy($3), $9);
+ appendChild(nscope_inner, $$);
+ Swig_symbol_setscope(Getattr(nscope_inner, "symtab"));
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ yyrename = Copy(Getattr($<node>$, "class_rename"));
add_symbols($$);
- if (nscope) $$ = nscope;
+ Delattr($$, "class_rename");
/* but the variable definition in the current scope */
Swig_symbol_setscope(cscope);
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
add_symbols($9);
+ if (nscope) {
+ $$ = nscope; /* here we return recreated namespace tower instead of the class itself */
+ if ($9) {
+ appendSibling($$, $9);
+ }
+ } else if (!SwigType_istemplate(ty) && template_parameters == 0) { /* for tempalte we need the class itself */
+ $$ = $9;
+ }
} else {
Delete(yyrename);
- yyrename = Copy(class_rename);
- Delete(Namespaceprefix);
- Namespaceprefix = Swig_symbol_qualifiedscopename(0);
-
- add_symbols($$);
- add_symbols($9);
+ yyrename = 0;
+ if (!cparse_cplusplus && currentOuterClass) { /* nested C structs go into global scope*/
+ Node *outer = currentOuterClass;
+ while (Getattr(outer, "nested:outer"))
+ outer = Getattr(outer, "nested:outer");
+ appendSibling(outer, $$);
+ add_symbols($9);
+ set_scope_to_global();
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ yyrename = Copy(Getattr($<node>$, "class_rename"));
+ add_symbols($$);
+ if (!cparse_cplusplusout)
+ Delattr($$, "nested:outer");
+ Delattr($$, "class_rename");
+ $$ = 0;
+ } else {
+ yyrename = Copy(Getattr($<node>$, "class_rename"));
+ add_symbols($$);
+ add_symbols($9);
+ Delattr($$, "class_rename");
+ }
}
+ Delete(ty);
Swig_symbol_setscope(cscope);
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
- } else {
- $$ = new_node("class");
- Setattr($$,"kind",$2);
- Setattr($$,"name",NewString($3));
- SetFlag($$,"nestedtemplateclass");
- }
+ Classprefix = currentOuterClass ? Getattr(currentOuterClass, "Classprefix") : 0;
}
/* An unnamed struct, possibly with a typedef */
- | storage_class cpptype LBRACE {
+ | storage_class cpptype inherit LBRACE {
String *unnamed;
+ String *code;
unnamed = make_unnamed();
$<node>$ = new_node("class");
Setline($<node>$,cparse_start_line);
Setattr($<node>$,"kind",$2);
+ if ($3) {
+ Setattr($<node>$,"baselist", Getattr($3,"public"));
+ Setattr($<node>$,"protectedbaselist", Getattr($3,"protected"));
+ Setattr($<node>$,"privatebaselist", Getattr($3,"private"));
+ }
Setattr($<node>$,"storage",$1);
Setattr($<node>$,"unnamed",unnamed);
Setattr($<node>$,"allows_typedef","1");
- Delete(class_rename);
- class_rename = make_name($<node>$,0,0);
+ if (currentOuterClass) {
+ SetFlag($<node>$, "nested");
+ Setattr($<node>$, "nested:outer", currentOuterClass);
+ set_access_mode($<node>$);
+ }
+ Swig_features_get(Swig_cparse_features(), Namespaceprefix, 0, 0, $<node>$);
+ /* save yyrename to the class attribute, to be used later in add_symbols()*/
+ Setattr($<node>$, "class_rename", make_name($<node>$,0,0));
if (strcmp($2,"class") == 0) {
cplus_mode = CPLUS_PRIVATE;
} else {
}
Swig_symbol_newscope();
cparse_start_line = cparse_line;
- if (class_level >= max_class_levels) {
- if (!max_class_levels) {
- max_class_levels = 16;
- } else {
- max_class_levels *= 2;
- }
- class_decl = (Node**) realloc(class_decl, sizeof(Node*) * max_class_levels);
- if (!class_decl) {
- Swig_error(cparse_file, cparse_line, "realloc() failed\n");
- }
- }
- class_decl[class_level++] = $<node>$;
+ currentOuterClass = $<node>$;
inclass = 1;
- Classprefix = NewStringEmpty();
+ Classprefix = 0;
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
- } cpp_members RBRACE declarator initializer c_decl_tail {
+ /* save the structure declaration to make a typedef for it later*/
+ code = get_raw_text_balanced('{', '}');
+ Setattr($<node>$, "code", code);
+ Delete(code);
+ } cpp_members RBRACE cpp_opt_declarators {
String *unnamed;
+ List *bases = 0;
+ String *name = 0;
Node *n;
- (void) $<node>4;
Classprefix = 0;
- $$ = class_decl[--class_level];
- inclass = 0;
+ (void)$<node>5;
+ $$ = currentOuterClass;
+ currentOuterClass = Getattr($$, "nested:outer");
+ if (!currentOuterClass)
+ inclass = 0;
+ else
+ restore_access_mode($$);
unnamed = Getattr($$,"unnamed");
-
- /* Check for pure-abstract class */
- Setattr($$,"abstracts", pure_abstracts($5));
-
- n = new_node("cdecl");
- Setattr(n,"name",$7.id);
- Setattr(n,"unnamed",unnamed);
- Setattr(n,"type",unnamed);
- Setattr(n,"decl",$7.type);
- Setattr(n,"parms",$7.parms);
- Setattr(n,"storage",$1);
- if ($9) {
- Node *p = $9;
- set_nextSibling(n,p);
- while (p) {
- String *type = Copy(unnamed);
- Setattr(p,"name",$7.id);
- Setattr(p,"unnamed",unnamed);
- Setattr(p,"type",type);
- Delete(type);
- Setattr(p,"storage",$1);
- p = nextSibling(p);
- }
- }
- set_nextSibling($$,n);
- Delete(n);
- {
+ /* Check for pure-abstract class */
+ Setattr($$,"abstracts", pure_abstracts($6));
+ n = $8;
+ if (cparse_cplusplus && currentOuterClass && ignore_nested_classes && !GetFlag($$, "feature:flatnested")) {
+ String *name = n ? Copy(Getattr(n, "name")) : 0;
+ $$ = nested_forward_declaration($1, $2, 0, name, n);
+ Swig_symbol_popscope();
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ } else if (n) {
+ appendSibling($$,n);
/* If a proper typedef name was given, we'll use it to set the scope name */
- String *name = 0;
- if ($1 && (strcmp($1,"typedef") == 0)) {
- if (!Len($7.type)) {
- String *scpname = 0;
- name = $7.id;
- Setattr($$,"tdname",name);
- Setattr($$,"name",name);
- Swig_symbol_setscopename(name);
+ name = try_to_find_a_name_for_unnamed_structure($1, n);
+ if (name) {
+ String *scpname = 0;
+ SwigType *ty;
+ Setattr($$,"tdname",name);
+ Setattr($$,"name",name);
+ Swig_symbol_setscopename(name);
+ if ($3)
+ bases = Swig_make_inherit_list(name,Getattr($3,"public"),Namespaceprefix);
+ Swig_inherit_base_symbols(bases);
/* If a proper name was given, we use that as the typedef, not unnamed */
- Clear(unnamed);
- Append(unnamed, name);
-
+ Clear(unnamed);
+ Append(unnamed, name);
+ if (cparse_cplusplus && !cparse_externc) {
+ ty = NewString(name);
+ } else {
+ ty = NewStringf("%s %s", $2,name);
+ }
+ while (n) {
+ Setattr(n,"storage",$1);
+ Setattr(n, "type", ty);
+ if (!cparse_cplusplus && currentOuterClass && (!Getattr(currentOuterClass, "name"))) {
+ SetFlag(n,"hasconsttype");
+ SetFlag(n,"feature:immutable");
+ }
n = nextSibling(n);
- set_nextSibling($$,n);
-
- /* Check for previous extensions */
- if (extendhash) {
- String *clsname = Swig_symbol_qualifiedscopename(0);
- Node *am = Getattr(extendhash,clsname);
- if (am) {
- /* Merge the extension into the symbol table */
- merge_extensions($$,am);
- append_previous_extension($$,am);
- Delattr(extendhash,clsname);
- }
- Delete(clsname);
+ }
+ n = $8;
+
+ /* Check for previous extensions */
+ {
+ String *clsname = Swig_symbol_qualifiedscopename(0);
+ Node *am = Getattr(Swig_extend_hash(),clsname);
+ if (am) {
+ /* Merge the extension into the symbol table */
+ Swig_extend_merge($$,am);
+ Swig_extend_append_previous($$,am);
+ Delattr(Swig_extend_hash(),clsname);
}
- if (!classes) classes = NewHash();
- scpname = Swig_symbol_qualifiedscopename(0);
- Setattr(classes,scpname,$$);
- Delete(scpname);
- } else {
- Swig_symbol_setscopename("<unnamed>");
+ Delete(clsname);
+ }
+ if (!classes) classes = NewHash();
+ scpname = Swig_symbol_qualifiedscopename(0);
+ Setattr(classes,scpname,$$);
+ Delete(scpname);
+ } else { /* no suitable name was found for a struct */
+ Setattr($$, "nested:unnamed", Getattr(n, "name")); /* save the name of the first declarator for later use in name generation*/
+ while (n) { /* attach unnamed struct to the declarators, so that they would receive proper type later*/
+ Setattr(n, "nested:unnamedtype", $$);
+ Setattr(n, "storage", $1);
+ n = nextSibling(n);
}
+ n = $8;
+ Swig_symbol_setscopename("<unnamed>");
}
- appendChild($$,$5);
- appendChild($$,dump_nested(Char(name)));
- }
- /* Pop the scope */
- Setattr($$,"symtab",Swig_symbol_popscope());
- if (class_rename) {
- Delete(yyrename);
- yyrename = NewString(class_rename);
+ appendChild($$,$6);
+ /* Pop the scope */
+ Setattr($$,"symtab",Swig_symbol_popscope());
+ if (name) {
+ Delete(yyrename);
+ yyrename = Copy(Getattr($<node>$, "class_rename"));
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ add_symbols($$);
+ add_symbols(n);
+ Delattr($$, "class_rename");
+ }else if (cparse_cplusplus)
+ $$ = 0; /* ignore unnamed structs for C++ */
+ Delete(unnamed);
+ } else { /* unnamed struct w/o declarator*/
+ Swig_symbol_popscope();
+ Delete(Namespaceprefix);
+ Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+ add_symbols($6);
+ Delete($$);
+ $$ = $6; /* pass member list to outer class/namespace (instead of self)*/
}
- Delete(Namespaceprefix);
- Namespaceprefix = Swig_symbol_qualifiedscopename(0);
- add_symbols($$);
- add_symbols(n);
- Delete(unnamed);
+ Classprefix = currentOuterClass ? Getattr(currentOuterClass, "Classprefix") : 0;
}
;
------------------------------------------------------------ */
cpp_template_decl : TEMPLATE LESSTHAN template_parms GREATERTHAN {
+ if (currentOuterClass)
+ Setattr(currentOuterClass, "template_parameters", template_parameters);
template_parameters = $3;
- if (inclass)
- nested_template++;
-
} cpp_temp_possible {
-
- /* Don't ignore templated functions declared within a class, unless the templated function is within a nested class */
- if (nested_template <= 1) {
- int is_nested_template_class = $6 && GetFlag($6, "nestedtemplateclass");
- if (is_nested_template_class) {
- $$ = 0;
- /* Nested template classes would probably better be ignored like ordinary nested classes using cpp_nested, but that introduces shift/reduce conflicts */
- if (cplus_mode == CPLUS_PUBLIC) {
- /* Treat the nested class/struct/union as a forward declaration until a proper nested class solution is implemented */
- String *kind = Getattr($6, "kind");
- String *name = Getattr($6, "name");
- $$ = new_node("template");
- Setattr($$,"kind",kind);
- Setattr($$,"name",name);
- Setattr($$,"sym:weak", "1");
- Setattr($$,"templatetype","classforward");
- Setattr($$,"templateparms", $3);
- add_symbols($$);
-
- if (GetFlag($$, "feature:nestedworkaround")) {
- Swig_symbol_remove($$);
- $$ = 0;
- } else {
- SWIG_WARN_NODE_BEGIN($$);
- Swig_warning(WARN_PARSE_NAMED_NESTED_CLASS, cparse_file, cparse_line, "Nested template %s not currently supported (%s ignored).\n", kind, name);
- SWIG_WARN_NODE_END($$);
- }
- }
- Delete($6);
- } else {
String *tname = 0;
int error = 0;
Swig_symbol_setscope(cscope);
Delete(Namespaceprefix);
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
- if (error) $$ = 0;
- }
- } else {
- $$ = 0;
- }
- template_parameters = 0;
- if (inclass)
- nested_template--;
- }
+ if (error || (nscope_inner && Strcmp(nodeType(nscope_inner), "class") == 0)) {
+ $$ = 0;
+ }
+ if (currentOuterClass)
+ template_parameters = Getattr(currentOuterClass, "template_parameters");
+ else
+ template_parameters = 0;
+ }
+
+ /* Explicit template instantiation */
| TEMPLATE cpptype idcolon {
Swig_warning(WARN_PARSE_EXPLICIT_TEMPLATE, cparse_file, cparse_line, "Explicit template instantiation ignored.\n");
- $$ = 0;
+ $$ = 0;
+ }
+
+ /* Explicit template instantiation without the translation unit */
+ | EXTERN TEMPLATE cpptype idcolon {
+ Swig_warning(WARN_PARSE_EXPLICIT_TEMPLATE, cparse_file, cparse_line, "Explicit template instantiation ignored.\n");
+ $$ = 0;
}
;
| cpp_constructor_decl {
$$ = $1;
}
+ | cpp_static_assert {
+ $$ = $1;
+ }
| cpp_template_decl {
$$ = 0;
}
if ((strncmp(type,"class ",6) == 0) || (strncmp(type,"typename ", 9) == 0)) {
char *t = strchr(type,' ');
Setattr(p,"name", t+1);
+ } else
+ /* Variadic template args */
+ if ((strncmp(type,"class... ",9) == 0) || (strncmp(type,"typename... ", 12) == 0)) {
+ char *t = strchr(type,' ');
+ Setattr(p,"name", t+1);
+ Setattr(p,"variadic", "1");
} else {
/*
Swig_error(cparse_file, cparse_line, "Missing template parameter name\n");
| NAMESPACE LBRACE {
Hash *h;
$1 = Swig_symbol_current();
- h = Swig_symbol_clookup((char *)" ",0);
+ h = Swig_symbol_clookup(" ",0);
if (h && (Strcmp(nodeType(h),"namespace") == 0)) {
Swig_symbol_setscope(Getattr(h,"symtab"));
} else {
Namespaceprefix = Swig_symbol_qualifiedscopename(0);
add_symbols($$);
}
- | NAMESPACE ID EQUAL idcolon SEMI {
+ | NAMESPACE identifier EQUAL idcolon SEMI {
/* Namespace alias */
Node *n;
$$ = new_node("namespace");
p = nextSibling(p);
}
set_nextSibling(pp,$2);
+ if ($2)
+ set_previousSibling($2, pp);
} else {
$$ = $2;
}
}
| EXTEND LBRACE {
- if (cplus_mode != CPLUS_PUBLIC) {
- Swig_error(cparse_file,cparse_line,"%%extend can only be used in a public section\n");
- }
- } cpp_members RBRACE cpp_members {
+ extendmode = 1;
+ if (cplus_mode != CPLUS_PUBLIC) {
+ Swig_error(cparse_file,cparse_line,"%%extend can only be used in a public section\n");
+ }
+ } cpp_members RBRACE {
+ extendmode = 0;
+ } cpp_members {
$$ = new_node("extend");
- tag_nodes($4,"feature:extend",(char*) "1");
+ mark_nodes_as_extend($4);
appendChild($$,$4);
- set_nextSibling($$,$6);
+ set_nextSibling($$,$7);
}
| include_directive { $$ = $1; }
| empty { $$ = 0;}
cpp_member : c_declaration { $$ = $1; }
| cpp_constructor_decl {
$$ = $1;
- if (extendmode) {
+ if (extendmode && current_class) {
String *symname;
symname= make_name($$,Getattr($$,"name"), Getattr($$,"decl"));
if (Strcmp(symname,Getattr($$,"name")) == 0) {
default_arguments($$);
}
| cpp_destructor_decl { $$ = $1; }
+ | cpp_static_assert { $$ = $1; }
| cpp_protection_decl { $$ = $1; }
| cpp_swig_directive { $$ = $1; }
| cpp_conversion_operator { $$ = $1; }
| cpp_forward_class_decl { $$ = $1; }
- | cpp_nested { $$ = $1; }
+ | cpp_class_decl { $$ = $1; }
| storage_class idcolon SEMI { $$ = 0; }
| cpp_using_decl { $$ = $1; }
| cpp_template_decl { $$ = $1; }
*/
cpp_constructor_decl : storage_class type LPAREN parms RPAREN ctor_end {
- if (Classprefix) {
- SwigType *decl = NewStringEmpty();
- $$ = new_node("constructor");
- Setattr($$,"storage",$1);
- Setattr($$,"name",$2);
- Setattr($$,"parms",$4);
- SwigType_add_function(decl,$4);
- Setattr($$,"decl",decl);
- Setattr($$,"throws",$6.throws);
- Setattr($$,"throw",$6.throwf);
- if (Len(scanner_ccode)) {
- String *code = Copy(scanner_ccode);
- Setattr($$,"code",code);
- Delete(code);
- }
- SetFlag($$,"feature:new");
+ if (inclass || extendmode) {
+ SwigType *decl = NewStringEmpty();
+ $$ = new_node("constructor");
+ Setattr($$,"storage",$1);
+ Setattr($$,"name",$2);
+ Setattr($$,"parms",$4);
+ SwigType_add_function(decl,$4);
+ Setattr($$,"decl",decl);
+ Setattr($$,"throws",$6.throws);
+ Setattr($$,"throw",$6.throwf);
+ Setattr($$,"noexcept",$6.nexcept);
+ if (Len(scanner_ccode)) {
+ String *code = Copy(scanner_ccode);
+ Setattr($$,"code",code);
+ Delete(code);
+ }
+ SetFlag($$,"feature:new");
+ if ($6.defarg)
+ Setattr($$,"value",$6.defarg);
} else {
$$ = 0;
}
}
Setattr($$,"throws",$6.throws);
Setattr($$,"throw",$6.throwf);
+ Setattr($$,"noexcept",$6.nexcept);
+ if ($6.val)
+ Setattr($$,"value",$6.val);
add_symbols($$);
}
Delete(name);
Setattr($$,"throws",$7.throws);
Setattr($$,"throw",$7.throwf);
- if ($7.val) {
- Setattr($$,"value","0");
- }
+ Setattr($$,"noexcept",$7.nexcept);
+ if ($7.val)
+ Setattr($$,"value",$7.val);
if (Len(scanner_ccode)) {
String *code = Copy(scanner_ccode);
Setattr($$,"code",code);
/* C++ type conversion operator */
-cpp_conversion_operator : storage_class COPERATOR type pointer LPAREN parms RPAREN cpp_vend {
+cpp_conversion_operator : storage_class CONVERSIONOPERATOR type pointer LPAREN parms RPAREN cpp_vend {
$$ = new_node("cdecl");
Setattr($$,"type",$3);
Setattr($$,"name",$2);
Setattr($$,"conversion_operator","1");
add_symbols($$);
}
- | storage_class COPERATOR type AND LPAREN parms RPAREN cpp_vend {
+ | storage_class CONVERSIONOPERATOR type AND LPAREN parms RPAREN cpp_vend {
SwigType *decl;
$$ = new_node("cdecl");
Setattr($$,"type",$3);
Setattr($$,"conversion_operator","1");
add_symbols($$);
}
+ | storage_class CONVERSIONOPERATOR type LAND LPAREN parms RPAREN cpp_vend {
+ SwigType *decl;
+ $$ = new_node("cdecl");
+ Setattr($$,"type",$3);
+ Setattr($$,"name",$2);
+ Setattr($$,"storage",$1);
+ decl = NewStringEmpty();
+ SwigType_add_rvalue_reference(decl);
+ SwigType_add_function(decl,$6);
+ if ($8.qualifier) {
+ SwigType_push(decl,$8.qualifier);
+ }
+ Setattr($$,"decl",decl);
+ Setattr($$,"parms",$6);
+ Setattr($$,"conversion_operator","1");
+ add_symbols($$);
+ }
- | storage_class COPERATOR type pointer AND LPAREN parms RPAREN cpp_vend {
+ | storage_class CONVERSIONOPERATOR type pointer AND LPAREN parms RPAREN cpp_vend {
SwigType *decl;
$$ = new_node("cdecl");
Setattr($$,"type",$3);
add_symbols($$);
}
- | storage_class COPERATOR type LPAREN parms RPAREN cpp_vend {
+ | storage_class CONVERSIONOPERATOR type LPAREN parms RPAREN cpp_vend {
String *t = NewStringEmpty();
$$ = new_node("cdecl");
Setattr($$,"type",$3);
}
;
+/* static_assert(bool, const char*); */
+cpp_static_assert : STATIC_ASSERT LPAREN {
+ skip_balanced('(',')');
+ $$ = 0;
+ }
+ ;
+
/* public: */
cpp_protection_decl : PUBLIC COLON {
$$ = new_node("access");
cplus_mode = CPLUS_PROTECTED;
}
;
-
-
-/* ------------------------------------------------------------
- Named nested structs:
- struct sname { };
- struct sname { } id;
- struct sname : bases { };
- struct sname : bases { } id;
- typedef sname struct { } td;
- typedef sname struct : bases { } td;
-
- Adding inheritance, ie replacing 'ID' with 'idcolon inherit'
- added one shift/reduce
- ------------------------------------------------------------ */
-
-cpp_nested : storage_class cpptype idcolon inherit LBRACE {
- cparse_start_line = cparse_line;
- skip_balanced('{','}');
- $<str>$ = NewString(scanner_ccode); /* copied as initializers overwrite scanner_ccode */
- } cpp_opt_declarators {
- $$ = 0;
- if (cplus_mode == CPLUS_PUBLIC) {
- if (cparse_cplusplus) {
- String *name = Copy($3);
- $$ = nested_forward_declaration($1, $2, $3, name, $7);
- } else if ($7) {
- nested_new_struct($2, $<str>6, $7);
- }
- }
- Delete($<str>6);
- }
-
-/* ------------------------------------------------------------
- Unnamed/anonymous nested structs:
- struct { };
- struct { } id;
- struct : bases { };
- struct : bases { } id;
- typedef struct { } td;
- typedef struct : bases { } td;
- ------------------------------------------------------------ */
-
- | storage_class cpptype inherit LBRACE {
- cparse_start_line = cparse_line;
- skip_balanced('{','}');
- $<str>$ = NewString(scanner_ccode); /* copied as initializers overwrite scanner_ccode */
- } cpp_opt_declarators {
- $$ = 0;
- if (cplus_mode == CPLUS_PUBLIC) {
- if (cparse_cplusplus) {
- String *name = $6 ? Copy(Getattr($6, "name")) : 0;
- $$ = nested_forward_declaration($1, $2, 0, name, $6);
- } else {
- if ($6) {
- nested_new_struct($2, $<str>5, $6);
- } else {
- Swig_warning(WARN_PARSE_UNNAMED_NESTED_CLASS, cparse_file, cparse_line, "Nested %s not currently supported (ignored).\n", $2);
- }
- }
- }
- Delete($<str>5);
- }
-
-
-/* This unfortunately introduces 4 shift/reduce conflicts, so instead the somewhat hacky nested_template is used for ignore nested template classes. */
-/*
- | TEMPLATE LESSTHAN template_parms GREATERTHAN cpptype idcolon LBRACE { cparse_start_line = cparse_line; skip_balanced('{','}');
- } SEMI {
- $$ = 0;
- if (cplus_mode == CPLUS_PUBLIC) {
- Swig_warning(WARN_PARSE_NAMED_NESTED_CLASS, cparse_file, cparse_line,"Nested %s not currently supported (%s ignored)\n", $5, $6);
- }
- }
-*/
- ;
-
/* These directives can be included inside a class definition */
cpp_swig_directive: pragma_directive { $$ = $1; }
cpp_end : cpp_const SEMI {
Clear(scanner_ccode);
+ $$.val = 0;
$$.throws = $1.throws;
$$.throwf = $1.throwf;
+ $$.nexcept = $1.nexcept;
+ }
+ | cpp_const EQUAL default_delete SEMI {
+ Clear(scanner_ccode);
+ $$.val = $3.val;
+ $$.throws = $1.throws;
+ $$.throwf = $1.throwf;
+ $$.nexcept = $1.nexcept;
}
| cpp_const LBRACE {
skip_balanced('{','}');
+ $$.val = 0;
$$.throws = $1.throws;
$$.throwf = $1.throwf;
+ $$.nexcept = $1.nexcept;
}
;
$$.bitfield = 0;
$$.throws = $1.throws;
$$.throwf = $1.throwf;
+ $$.nexcept = $1.nexcept;
}
| cpp_const EQUAL definetype SEMI {
Clear(scanner_ccode);
$$.bitfield = 0;
$$.throws = $1.throws;
$$.throwf = $1.throwf;
+ $$.nexcept = $1.nexcept;
}
| cpp_const LBRACE {
skip_balanced('{','}');
$$.bitfield = 0;
$$.throws = $1.throws;
$$.throwf = $1.throwf;
+ $$.nexcept = $1.nexcept;
}
;
-anonymous_bitfield : storage_class type COLON expr SEMI { };
+anonymous_bitfield : storage_class anon_bitfield_type COLON expr SEMI { };
+
+/* Equals type_right without the ENUM keyword and cpptype (templates etc.): */
+anon_bitfield_type : primitive_type { $$ = $1;
+ /* Printf(stdout,"primitive = '%s'\n", $$);*/
+ }
+ | TYPE_BOOL { $$ = $1; }
+ | TYPE_VOID { $$ = $1; }
+/*
+ | TYPE_TYPEDEF template_decl { $$ = NewStringf("%s%s",$1,$2); }
+*/
+ | TYPE_RAW { $$ = $1; }
+
+ | idcolon {
+ $$ = $1;
+ }
+ ;
/* ======================================================================
* PRIMITIVES
* ====================================================================== */
-
-storage_class : EXTERN { $$ = "extern"; }
- | EXTERN string {
- if (strcmp($2,"C") == 0) {
+extern_string : EXTERN string {
+ if (Strcmp($2,"C") == 0) {
$$ = "externc";
+ } else if (Strcmp($2,"C++") == 0) {
+ $$ = "extern";
} else {
Swig_warning(WARN_PARSE_UNDEFINED_EXTERN,cparse_file, cparse_line,"Unrecognized extern type \"%s\".\n", $2);
$$ = 0;
}
}
+ ;
+
+storage_class : EXTERN { $$ = "extern"; }
+ | extern_string { $$ = $1; }
+ | extern_string THREAD_LOCAL { $$ = "thread_local"; }
+ | extern_string TYPEDEF { $$ = "typedef"; }
| STATIC { $$ = "static"; }
| TYPEDEF { $$ = "typedef"; }
| VIRTUAL { $$ = "virtual"; }
| FRIEND { $$ = "friend"; }
| EXPLICIT { $$ = "explicit"; }
+ | CONSTEXPR { $$ = "constexpr"; }
+ | EXPLICIT CONSTEXPR { $$ = "explicit constexpr"; }
+ | CONSTEXPR EXPLICIT { $$ = "explicit constexpr"; }
+ | STATIC CONSTEXPR { $$ = "static constexpr"; }
+ | CONSTEXPR STATIC { $$ = "static constexpr"; }
+ | THREAD_LOCAL { $$ = "thread_local"; }
+ | THREAD_LOCAL STATIC { $$ = "static thread_local"; }
+ | STATIC THREAD_LOCAL { $$ = "static thread_local"; }
+ | EXTERN THREAD_LOCAL { $$ = "extern thread_local"; }
+ | THREAD_LOCAL EXTERN { $$ = "extern thread_local"; }
| empty { $$ = 0; }
;
$$.bitfield = 0;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
}
}
| EQUAL definetype LBRACKET expr RBRACKET {
$$.bitfield = 0;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
} else {
$$.val = NewStringf("%s[%s]",$2.val,$4.val);
}
}
| EQUAL LBRACE {
skip_balanced('{','}');
- $$.val = 0;
+ $$.val = NewString(scanner_ccode);
$$.rawval = 0;
$$.type = T_INT;
$$.bitfield = 0;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
}
| COLON expr {
$$.val = 0;
$$.bitfield = $2.val;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
}
| empty {
$$.val = 0;
$$.bitfield = 0;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
}
;
}
;
-typemap_parameter_declarator : declarator {
+plain_declarator : declarator {
$$ = $1;
if (SwigType_isfunction($1.type)) {
Delete(SwigType_pop_function($1.type));
}
$$.type = $1;
}
+ | pointer LAND notso_direct_declarator {
+ $$ = $3;
+ SwigType_add_rvalue_reference($1);
+ if ($$.type) {
+ SwigType_push($1,$$.type);
+ Delete($$.type);
+ }
+ $$.type = $1;
+ }
| direct_declarator {
$$ = $1;
if (!$$.type) $$.type = NewStringEmpty();
}
- | AND notso_direct_declarator {
+ | AND notso_direct_declarator {
$$ = $2;
$$.type = NewStringEmpty();
SwigType_add_reference($$.type);
Delete($2.type);
}
}
+ | LAND notso_direct_declarator {
+ /* Introduced in C++11, move operator && */
+ /* Adds one S/R conflict */
+ $$ = $2;
+ $$.type = NewStringEmpty();
+ SwigType_add_rvalue_reference($$.type);
+ if ($2.type) {
+ SwigType_push($$.type,$2.type);
+ Delete($2.type);
+ }
+ }
| idcolon DSTAR notso_direct_declarator {
SwigType *t = NewStringEmpty();
}
$$.type = t;
}
+
+ /* Variadic versions eg. MyClasses&... myIds */
+
+ | pointer PERIOD PERIOD PERIOD notso_direct_declarator {
+ $$ = $5;
+ if ($$.type) {
+ SwigType_push($1,$$.type);
+ Delete($$.type);
+ }
+ $$.type = $1;
+ }
+ | pointer AND PERIOD PERIOD PERIOD notso_direct_declarator {
+ $$ = $6;
+ SwigType_add_reference($1);
+ if ($$.type) {
+ SwigType_push($1,$$.type);
+ Delete($$.type);
+ }
+ $$.type = $1;
+ }
+ | pointer LAND PERIOD PERIOD PERIOD notso_direct_declarator {
+ $$ = $6;
+ SwigType_add_rvalue_reference($1);
+ if ($$.type) {
+ SwigType_push($1,$$.type);
+ Delete($$.type);
+ }
+ $$.type = $1;
+ }
+ | PERIOD PERIOD PERIOD direct_declarator {
+ $$ = $4;
+ if (!$$.type) $$.type = NewStringEmpty();
+ }
+ | AND PERIOD PERIOD PERIOD notso_direct_declarator {
+ $$ = $5;
+ $$.type = NewStringEmpty();
+ SwigType_add_reference($$.type);
+ if ($5.type) {
+ SwigType_push($$.type,$5.type);
+ Delete($5.type);
+ }
+ }
+ | LAND PERIOD PERIOD PERIOD notso_direct_declarator {
+ /* Introduced in C++11, move operator && */
+ /* Adds one S/R conflict */
+ $$ = $5;
+ $$.type = NewStringEmpty();
+ SwigType_add_rvalue_reference($$.type);
+ if ($5.type) {
+ SwigType_push($$.type,$5.type);
+ Delete($5.type);
+ }
+ }
+ | idcolon DSTAR PERIOD PERIOD PERIOD notso_direct_declarator {
+ SwigType *t = NewStringEmpty();
+
+ $$ = $6;
+ SwigType_add_memberpointer(t,$1);
+ if ($$.type) {
+ SwigType_push(t,$$.type);
+ Delete($$.type);
+ }
+ $$.type = t;
+ }
+ | pointer idcolon DSTAR PERIOD PERIOD PERIOD notso_direct_declarator {
+ SwigType *t = NewStringEmpty();
+ $$ = $7;
+ SwigType_add_memberpointer(t,$2);
+ SwigType_push($1,t);
+ if ($$.type) {
+ SwigType_push($1,$$.type);
+ Delete($$.type);
+ }
+ $$.type = $1;
+ Delete(t);
+ }
+ | pointer idcolon DSTAR AND PERIOD PERIOD PERIOD notso_direct_declarator {
+ $$ = $8;
+ SwigType_add_memberpointer($1,$2);
+ SwigType_add_reference($1);
+ if ($$.type) {
+ SwigType_push($1,$$.type);
+ Delete($$.type);
+ }
+ $$.type = $1;
+ }
+ | pointer idcolon DSTAR LAND PERIOD PERIOD PERIOD notso_direct_declarator {
+ $$ = $8;
+ SwigType_add_memberpointer($1,$2);
+ SwigType_add_rvalue_reference($1);
+ if ($$.type) {
+ SwigType_push($1,$$.type);
+ Delete($$.type);
+ }
+ $$.type = $1;
+ }
+ | idcolon DSTAR AND PERIOD PERIOD PERIOD notso_direct_declarator {
+ SwigType *t = NewStringEmpty();
+ $$ = $7;
+ SwigType_add_memberpointer(t,$1);
+ SwigType_add_reference(t);
+ if ($$.type) {
+ SwigType_push(t,$$.type);
+ Delete($$.type);
+ }
+ $$.type = t;
+ }
+ | idcolon DSTAR LAND PERIOD PERIOD PERIOD notso_direct_declarator {
+ SwigType *t = NewStringEmpty();
+ $$ = $7;
+ SwigType_add_memberpointer(t,$1);
+ SwigType_add_rvalue_reference(t);
+ if ($$.type) {
+ SwigType_push(t,$$.type);
+ Delete($$.type);
+ }
+ $$.type = t;
+ }
;
notso_direct_declarator : idcolon {
SwigType *t;
$$ = $1;
t = NewStringEmpty();
- SwigType_add_array(t,(char*)"");
+ SwigType_add_array(t,"");
if ($$.type) {
SwigType_push(t,$$.type);
Delete($$.type);
$$.parms = 0;
$$.have_parms = 0;
}
-
+
| NOT idcolon {
$$.id = Char(NewStringf("~%s",$2));
$$.type = 0;
}
SwigType_add_reference($$.type);
}
+ | LPAREN LAND direct_declarator RPAREN {
+ $$ = $3;
+ if (!$$.type) {
+ $$.type = NewStringEmpty();
+ }
+ SwigType_add_rvalue_reference($$.type);
+ }
| LPAREN idcolon DSTAR direct_declarator RPAREN {
SwigType *t;
$$ = $4;
SwigType *t;
$$ = $1;
t = NewStringEmpty();
- SwigType_add_array(t,(char*)"");
+ SwigType_add_array(t,"");
if ($$.type) {
SwigType_push(t,$$.type);
Delete($$.type);
Delete($$.type);
$$.type = t;
}
+ }
+ /* User-defined string literals. eg.
+ int operator"" _mySuffix(const char* val, int length) {...} */
+ /* This produces one S/R conflict. */
+ | OPERATOR ID LPAREN parms RPAREN {
+ SwigType *t;
+ Append($1, " "); /* intervening space is mandatory */
+ Append($1, Char($2));
+ $$.id = Char($1);
+ t = NewStringEmpty();
+ SwigType_add_function(t,$4);
+ if (!$$.have_parms) {
+ $$.parms = $4;
+ $$.have_parms = 1;
+ }
+ if (!$$.type) {
+ $$.type = t;
+ } else {
+ SwigType_push(t, $$.type);
+ Delete($$.type);
+ $$.type = t;
+ }
}
;
$$.parms = 0;
$$.have_parms = 0;
}
+ | pointer LAND {
+ $$.type = $1;
+ SwigType_add_rvalue_reference($$.type);
+ $$.id = 0;
+ $$.parms = 0;
+ $$.have_parms = 0;
+ }
| pointer AND direct_abstract_declarator {
$$ = $3;
SwigType_add_reference($1);
}
$$.type = $1;
}
+ | pointer LAND direct_abstract_declarator {
+ $$ = $3;
+ SwigType_add_rvalue_reference($1);
+ if ($$.type) {
+ SwigType_push($1,$$.type);
+ Delete($$.type);
+ }
+ $$.type = $1;
+ }
| direct_abstract_declarator {
$$ = $1;
}
Delete($2.type);
}
}
- | AND {
+ | LAND direct_abstract_declarator {
+ $$ = $2;
+ $$.type = NewStringEmpty();
+ SwigType_add_rvalue_reference($$.type);
+ if ($2.type) {
+ SwigType_push($$.type,$2.type);
+ Delete($2.type);
+ }
+ }
+ | AND {
$$.id = 0;
$$.parms = 0;
$$.have_parms = 0;
$$.type = NewStringEmpty();
SwigType_add_reference($$.type);
}
+ | LAND {
+ $$.id = 0;
+ $$.parms = 0;
+ $$.have_parms = 0;
+ $$.type = NewStringEmpty();
+ SwigType_add_rvalue_reference($$.type);
+ }
| idcolon DSTAR {
$$.type = NewStringEmpty();
SwigType_add_memberpointer($$.type,$1);
SwigType *t;
$$ = $1;
t = NewStringEmpty();
- SwigType_add_array(t,(char*)"");
+ SwigType_add_array(t,"");
if ($$.type) {
SwigType_push(t,$$.type);
Delete($$.type);
$$.id = 0;
$$.parms = 0;
$$.have_parms = 0;
- SwigType_add_array($$.type,(char*)"");
+ SwigType_add_array($$.type,"");
}
| LBRACKET expr RBRACKET {
$$.type = NewStringEmpty();
}
| TYPE_BOOL { $$ = $1; }
| TYPE_VOID { $$ = $1; }
+/*
| TYPE_TYPEDEF template_decl { $$ = NewStringf("%s%s",$1,$2); }
- | ENUM idcolon { $$ = NewStringf("enum %s", $2); }
+*/
+ | c_enum_key idcolon { $$ = NewStringf("enum %s", $2); }
| TYPE_RAW { $$ = $1; }
| idcolon {
| cpptype idcolon {
$$ = NewStringf("%s %s", $1, $2);
}
+ | decltype {
+ $$ = $1;
+ }
+ ;
+
+decltype : DECLTYPE LPAREN idcolon RPAREN {
+ Node *n = Swig_symbol_clookup($3,0);
+ if (!n) {
+ Swig_error(cparse_file, cparse_line, "Identifier %s not defined.\n", $3);
+ $$ = $3;
+ } else {
+ $$ = Getattr(n, "type");
+ }
+ }
;
primitive_type : primitive_type_list {
$$ = $2;
if ($$.type == T_STRING) {
$$.rawval = NewStringf("\"%(escape)s\"",$$.val);
- } else if ($$.type != T_CHAR) {
+ } else if ($$.type != T_CHAR && $$.type != T_WSTRING && $$.type != T_WCHAR) {
$$.rawval = 0;
}
+ $$.qualifier = 0;
$$.bitfield = 0;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
scanner_ignore_typedef();
}
-/*
- | string {
- $$.val = NewString($1);
- $$.rawval = NewStringf("\"%(escape)s\"",$$.val);
- $$.type = T_STRING;
- $$.bitfield = 0;
- $$.throws = 0;
- $$.throwf = 0;
+ | default_delete {
+ $$ = $1;
}
-*/
;
+default_delete : deleted_definition {
+ $$ = $1;
+ }
+ | explicit_default {
+ $$ = $1;
+ }
+ ;
+
+/* For C++ deleted definition '= delete' */
+deleted_definition : DELETE_KW {
+ $$.val = NewString("delete");
+ $$.rawval = 0;
+ $$.type = T_STRING;
+ $$.qualifier = 0;
+ $$.bitfield = 0;
+ $$.throws = 0;
+ $$.throwf = 0;
+ $$.nexcept = 0;
+ }
+ ;
+
+/* For C++ explicitly defaulted functions '= default' */
+explicit_default : DEFAULT {
+ $$.val = NewString("default");
+ $$.rawval = 0;
+ $$.type = T_STRING;
+ $$.qualifier = 0;
+ $$.bitfield = 0;
+ $$.throws = 0;
+ $$.throwf = 0;
+ $$.nexcept = 0;
+ }
+ ;
+
/* Some stuff for handling enums */
-ename : ID { $$ = $1; }
+ename : identifier { $$ = $1; }
| empty { $$ = (char *) 0;}
;
}
;
-edecl : ID {
+edecl : identifier {
SwigType *type = NewSwigType(T_INT);
$$ = new_node("enumitem");
Setattr($$,"name",$1);
SetFlag($$,"feature:immutable");
Delete(type);
}
- | ID EQUAL etype {
+ | identifier EQUAL etype {
SwigType *type = NewSwigType($3.type == T_BOOL ? T_BOOL : ($3.type == T_CHAR ? T_CHAR : T_INT));
$$ = new_node("enumitem");
Setattr($$,"name",$1);
valexpr : exprnum { $$ = $1; }
| string {
- $$.val = NewString($1);
+ $$.val = $1;
$$.type = T_STRING;
}
| SIZEOF LPAREN type parameter_declarator RPAREN {
$$.val = NewStringf("sizeof(%s)",SwigType_str($3,0));
$$.type = T_ULONG;
}
+ | SIZEOF PERIOD PERIOD PERIOD LPAREN type parameter_declarator RPAREN {
+ SwigType_push($6,$7.type);
+ $$.val = NewStringf("sizeof...(%s)",SwigType_str($6,0));
+ $$.type = T_ULONG;
+ }
| exprcompound { $$ = $1; }
+ | wstring {
+ $$.val = $1;
+ $$.rawval = NewStringf("L\"%s\"", $$.val);
+ $$.type = T_WSTRING;
+ }
| CHARCONST {
$$.val = NewString($1);
if (Len($$.val)) {
$$.bitfield = 0;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
+ }
+ | WCHARCONST {
+ $$.val = NewString($1);
+ if (Len($$.val)) {
+ $$.rawval = NewStringf("L\'%s\'", $$.val);
+ } else {
+ $$.rawval = NewString("L'\\0'");
+ }
+ $$.type = T_WCHAR;
+ $$.bitfield = 0;
+ $$.throws = 0;
+ $$.throwf = 0;
+ $$.nexcept = 0;
}
/* grouping */
$$.val = NewStringf("(%s) %s", SwigType_str($2.val,0), $5.val);
}
}
+ | LPAREN expr LAND RPAREN expr %prec CAST {
+ $$ = $5;
+ if ($5.type != T_STRING) {
+ SwigType_add_rvalue_reference($2.val);
+ $$.val = NewStringf("(%s) %s", SwigType_str($2.val,0), $5.val);
+ }
+ }
| LPAREN expr pointer AND RPAREN expr %prec CAST {
$$ = $6;
if ($6.type != T_STRING) {
$$.val = NewStringf("(%s) %s", SwigType_str($2.val,0), $6.val);
}
}
+ | LPAREN expr pointer LAND RPAREN expr %prec CAST {
+ $$ = $6;
+ if ($6.type != T_STRING) {
+ SwigType_push($2.val,$3);
+ SwigType_add_rvalue_reference($2.val);
+ $$.val = NewStringf("(%s) %s", SwigType_str($2.val,0), $6.val);
+ }
+ }
| AND expr {
$$ = $2;
$$.val = NewStringf("&%s",$2.val);
}
+ | LAND expr {
+ $$ = $2;
+ $$.val = NewStringf("&&%s",$2.val);
+ }
| STAR expr {
$$ = $2;
$$.val = NewStringf("*%s",$2.val);
}
/* Sadly this causes 2 reduce-reduce conflicts with templates. FIXME resolve these.
| expr GREATERTHAN expr {
- $$.val = NewStringf("%s < %s", $1.val, $3.val);
+ $$.val = NewStringf("%s > %s", $1.val, $3.val);
$$.type = cparse_cplusplus ? T_BOOL : T_INT;
}
| expr LESSTHAN expr {
- $$.val = NewStringf("%s > %s", $1.val, $3.val);
+ $$.val = NewStringf("%s < %s", $1.val, $3.val);
$$.type = cparse_cplusplus ? T_BOOL : T_INT;
}
*/
}
;
+ellipsis : PERIOD PERIOD PERIOD {
+ $$ = NewString("...");
+ }
+ ;
+
+variadic : ellipsis {
+ $$ = $1;
+ }
+ | empty {
+ $$ = 0;
+ }
+ ;
+
inherit : raw_inherit {
$$ = $1;
}
base_specifier : opt_virtual {
$<intvalue>$ = cparse_line;
- } idcolon {
+ } idcolon variadic {
$$ = NewHash();
Setfile($$,cparse_file);
Setline($$,$<intvalue>2);
} else {
Setattr($$,"access","public");
}
+ if ($4)
+ SetFlag($$, "variadic");
}
| opt_virtual access_specifier {
$<intvalue>$ = cparse_line;
- } opt_virtual idcolon {
+ } opt_virtual idcolon variadic {
$$ = NewHash();
Setfile($$,cparse_file);
Setline($$,$<intvalue>3);
if (Strcmp($2,"public") != 0) {
Swig_warning(WARN_PARSE_PRIVATE_INHERIT, Getfile($$), Getline($$), "%s inheritance from base '%s' (ignored).\n", $2, SwigType_namestr($5));
}
+ if ($6)
+ SetFlag($$, "variadic");
}
;
$$ = (char *)"typename";
if (!inherit_list) last_cpptype = $$;
}
+ | CLASS PERIOD PERIOD PERIOD {
+ $$ = (char *)"class...";
+ if (!inherit_list) last_cpptype = $$;
+ }
+ | TYPENAME PERIOD PERIOD PERIOD {
+ $$ = (char *)"typename...";
+ if (!inherit_list) last_cpptype = $$;
+ }
;
cpptype : templcpptype {
| empty
;
+virt_specifier_seq : OVERRIDE {
+ $$ = 0;
+ }
+ | FINAL {
+ $$ = 0;
+ }
+ | FINAL OVERRIDE {
+ $$ = 0;
+ }
+ | OVERRIDE FINAL {
+ $$ = 0;
+ }
+ ;
+
+exception_specification : THROW LPAREN parms RPAREN {
+ $$.throws = $3;
+ $$.throwf = NewString("1");
+ $$.nexcept = 0;
+ }
+ | NOEXCEPT {
+ $$.throws = 0;
+ $$.throwf = 0;
+ $$.nexcept = NewString("true");
+ }
+ | virt_specifier_seq {
+ $$.throws = 0;
+ $$.throwf = 0;
+ $$.nexcept = 0;
+ }
+ | NOEXCEPT virt_specifier_seq {
+ $$.throws = 0;
+ $$.throwf = 0;
+ $$.nexcept = NewString("true");
+ }
+ | NOEXCEPT LPAREN expr RPAREN {
+ $$.throws = 0;
+ $$.throwf = 0;
+ $$.nexcept = $3.val;
+ }
+ ;
+
cpp_const : type_qualifier {
- $$.qualifier = $1;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
+ $$.qualifier = $1;
}
- | THROW LPAREN parms RPAREN {
+ | exception_specification {
+ $$ = $1;
$$.qualifier = 0;
- $$.throws = $3;
- $$.throwf = NewString("1");
}
- | type_qualifier THROW LPAREN parms RPAREN {
+ | type_qualifier exception_specification {
+ $$ = $2;
$$.qualifier = $1;
- $$.throws = $4;
- $$.throwf = NewString("1");
}
| empty {
- $$.qualifier = 0;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
+ $$.qualifier = 0;
}
;
$$.defarg = 0;
$$.throws = $1.throws;
$$.throwf = $1.throwf;
+ $$.nexcept = $1.nexcept;
}
| cpp_const ctor_initializer LBRACE {
skip_balanced('{','}');
$$.defarg = 0;
$$.throws = $1.throws;
$$.throwf = $1.throwf;
+ $$.nexcept = $1.nexcept;
}
| LPAREN parms RPAREN SEMI {
Clear(scanner_ccode);
$$.defarg = 0;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
}
| LPAREN parms RPAREN LBRACE {
skip_balanced('{','}');
$$.defarg = 0;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
}
| EQUAL definetype SEMI {
$$.have_parms = 0;
$$.defarg = $2.val;
$$.throws = 0;
$$.throwf = 0;
+ $$.nexcept = 0;
+ }
+ | exception_specification EQUAL default_delete SEMI {
+ $$.have_parms = 0;
+ $$.defarg = $3.val;
+ $$.throws = $1.throws;
+ $$.throwf = $1.throwf;
+ $$.nexcept = $1.nexcept;
}
;
mem_initializer_list : mem_initializer
| mem_initializer_list COMMA mem_initializer
+ | mem_initializer PERIOD PERIOD PERIOD
+ | mem_initializer_list COMMA mem_initializer PERIOD PERIOD PERIOD
;
mem_initializer : idcolon LPAREN {
- skip_balanced('(',')');
- Clear(scanner_ccode);
- }
+ skip_balanced('(',')');
+ Clear(scanner_ccode);
+ }
+ /* Uniform initialization in C++11.
+ Example:
+ struct MyStruct {
+ MyStruct(int x, double y) : x_{x}, y_{y} {}
+ int x_;
+ double y_;
+ };
+ */
+ | idcolon LBRACE {
+ skip_balanced('{','}');
+ Clear(scanner_ccode);
+ }
;
-template_decl : LESSTHAN valparms GREATERTHAN {
+less_valparms_greater : LESSTHAN valparms GREATERTHAN {
String *s = NewStringEmpty();
SwigType_add_template(s,$2);
$$ = Char(s);
scanner_last_id(1);
- }
- | empty { $$ = (char*)""; }
- ;
+ }
+ ;
-idstring : ID { $$ = $1; }
- | string { $$ = $1; }
+/* Identifiers including the C++11 identifiers with special meaning */
+identifier : ID { $$ = $1; }
+ | OVERRIDE { $$ = Swig_copy_string("override"); }
+ | FINAL { $$ = Swig_copy_string("final"); }
+ ;
+
+idstring : identifier { $$ = $1; }
+ | default_delete { $$ = Char($1.val); }
+ | string { $$ = Char($1); }
;
idstringopt : idstring { $$ = $1; }
| empty { $$ = 0; }
;
-
+
idcolon : idtemplate idcolontail {
$$ = 0;
if (!$$) $$ = NewStringf("%s%s", $1,$2);
Delete($2);
}
- | NONID DCOLON idtemplate idcolontail {
+ | NONID DCOLON idtemplatetemplate idcolontail {
$$ = NewStringf("::%s%s",$3,$4);
Delete($4);
}
| idtemplate {
$$ = NewString($1);
- }
- | NONID DCOLON idtemplate {
+ }
+ | NONID DCOLON idtemplatetemplate {
$$ = NewStringf("::%s",$3);
}
| OPERATOR {
- $$ = NewString($1);
+ $$ = NewStringf("%s", $1);
+ }
+ | OPERATOR less_valparms_greater {
+ $$ = NewStringf("%s%s", $1, $2);
}
| NONID DCOLON OPERATOR {
$$ = NewStringf("::%s",$3);
}
;
-idcolontail : DCOLON idtemplate idcolontail {
+idcolontail : DCOLON idtemplatetemplate idcolontail {
$$ = NewStringf("::%s%s",$2,$3);
Delete($3);
}
- | DCOLON idtemplate {
+ | DCOLON idtemplatetemplate {
$$ = NewStringf("::%s",$2);
}
| DCOLON OPERATOR {
$$ = NewStringf("::%s",$2);
}
-/* | DCOLON COPERATOR {
+/* | DCOLON CONVERSIONOPERATOR {
$$ = NewString($2);
} */
;
-idtemplate : ID template_decl {
- $$ = NewStringf("%s%s",$1,$2);
- /* if (Len($2)) {
- scanner_last_id(1);
- } */
- }
+idtemplate : identifier {
+ $$ = NewStringf("%s", $1);
+ }
+ | identifier less_valparms_greater {
+ $$ = NewStringf("%s%s", $1, $2);
+ }
+ ;
+
+idtemplatetemplate : idtemplate {
+ $$ = $1;
+ }
+ | TEMPLATE identifier less_valparms_greater {
+ $$ = NewStringf("%s%s", $2, $3);
+ }
;
/* Identifier, but no templates */
-idcolonnt : ID idcolontailnt {
+idcolonnt : identifier idcolontailnt {
$$ = 0;
if (!$$) $$ = NewStringf("%s%s", $1,$2);
Delete($2);
}
- | NONID DCOLON ID idcolontailnt {
+ | NONID DCOLON identifier idcolontailnt {
$$ = NewStringf("::%s%s",$3,$4);
Delete($4);
}
- | ID {
+ | identifier {
$$ = NewString($1);
}
- | NONID DCOLON ID {
+ | NONID DCOLON identifier {
$$ = NewStringf("::%s",$3);
}
| OPERATOR {
}
;
-idcolontailnt : DCOLON ID idcolontailnt {
+idcolontailnt : DCOLON identifier idcolontailnt {
$$ = NewStringf("::%s%s",$2,$3);
Delete($3);
}
- | DCOLON ID {
+ | DCOLON identifier {
$$ = NewStringf("::%s",$2);
}
| DCOLON OPERATOR {
$$ = NewStringf("::%s",$2);
}
- | DCNOT ID {
+ | DCNOT identifier {
$$ = NewStringf("::~%s",$2);
}
;
/* Concatenated strings */
string : string STRING {
- $$ = (char *) malloc(strlen($1)+strlen($2)+1);
- strcpy($$,$1);
- strcat($$,$2);
+ $$ = NewStringf("%s%s", $1, $2);
}
- | STRING { $$ = $1;}
+ | STRING { $$ = NewString($1);}
;
+/* Concatenated wide strings: L"str1" L"str2" */
+wstring : wstring WSTRING {
+ $$ = NewStringf("%s%s", $1, $2);
+ }
+/* Concatenated wide string and normal string literal: L"str1" "str2" */
+/*not all the compilers support this concatenation mode, so perhaps better to postpone it*/
+ /*| wstring STRING { here $2 comes unescaped, we have to escape it back first via NewStringf("%(escape)s)"
+ $$ = NewStringf("%s%s", $1, $2);
+ }*/
+ | WSTRING { $$ = NewString($1);}
+ ;
stringbrace : string {
- $$ = NewString($1);
+ $$ = $1;
}
| LBRACE {
skip_balanced('{','}');
Append(cpatchlist, Getattr(n, "sym:name"));
}
}
+ if (checkAttribute(n, "storage", "friend")) {
+ String *symname = Getattr(n, "sym:name");
+ if (symname) {
+ String *stripped_name = SwigType_templateprefix(symname);
+ Setattr(n, "sym:name", stripped_name);
+ Delete(stripped_name);
+ }
+ Append(typelist, Getattr(n, "name"));
+ }
add_parms(Getattr(n, "parms"), cpatchlist, typelist);
add_parms(Getattr(n, "throws"), cpatchlist, typelist);
if (!c) {
return Copy(s);
}
- prefix = NewStringWithSize(cp, c - cp);
+ prefix = NewStringWithSize(cp, (int)(c - cp));
newarg = Copy(s);
Replace(newarg, prefix, "", DOH_REPLACE_ANY | DOH_REPLACE_FIRST);
Delete(prefix);
/* If not a templated class we must have a templated function.
The template found is not necessarily the one we want when dealing with templated
functions. We don't want any specialized templated functions as they won't have
- the default parameters. Lets look for the unspecialized template. Also make sure
+ the default parameters. Let's look for the unspecialized template. Also make sure
the number of template parameters is correct as it is possible to overload a
templated function with different numbers of template parameters. */
}
/* -----------------------------------------------------------------------------
+ * Swig_cparse_smartptr()
+ *
+ * Parse the type in smartptr feature and convert into a SwigType.
+ * Error out if the parsing fails as this is like a parser syntax error.
+ * ----------------------------------------------------------------------------- */
+
+SwigType *Swig_cparse_smartptr(Node *n) {
+ SwigType *smart = 0;
+ String *smartptr = Getattr(n, "feature:smartptr");
+ if (smartptr) {
+ SwigType *cpt = Swig_cparse_type(smartptr);
+ if (cpt) {
+ smart = SwigType_typedef_resolve_all(cpt);
+ Delete(cpt);
+ } else {
+ Swig_error(Getfile(n), Getline(n), "Invalid type (%s) in 'smartptr' feature for class %s.\n", smartptr, SwigType_namestr(Getattr(n, "name")));
+ }
+ }
+ return smart;
+}
+
+/* -----------------------------------------------------------------------------
* cparse_normalize_void()
*
* This function is used to replace arguments of the form (void) with empty
}
}
}
+
+/* -----------------------------------------------------------------------------
+ * new_node()
+ *
+ * Create an empty parse node, setting file and line number information
+ * ----------------------------------------------------------------------------- */
+
+Node *new_node(const_String_or_char_ptr tag) {
+ Node *n = NewHash();
+ set_nodeType(n,tag);
+ Setfile(n,cparse_file);
+ Setline(n,cparse_line);
+ return n;
+}
-------------------
Getitem(list,index) Get an item
Setitem(list,index,val) Set an item
-Delitem(list,index,val) Delete an item
+Delitem(list,index) Delete an item
Insert(list,index,val) Insert an item
Append(list,val) Append to end
Push(list,val) Insert at beginning
Ungetc(ch,obj) Put character back on input stream
Seek(obj,offset,whence) Seek
Tell(obj) Return file pointer
-Close(obj) Close
+Delete(obj) Decrease the reference count, close file if zero
String Operations
-----------------
}
return 0;
} else {
- return strlen((char *) obj);
+ return (int)strlen((char *) obj);
}
}
return -1;
}
/* Hmmm. Not a file. Maybe it's a real FILE */
- return fread(buffer, 1, length, (FILE *) b);
+ return (int)fread(buffer, 1, length, (FILE *) b);
}
/* -----------------------------------------------------------------------------
return -1;
}
/* Hmmm. Not a file. Maybe it's a real FILE */
- return fwrite(buffer, 1, length, (FILE *) b);
+ return (int)fwrite(buffer, 1, length, (FILE *) b);
}
/* -----------------------------------------------------------------------------
DOH *DohCall(DOH *func, DOH *args) {
DOH *result;
- DOH *(*builtin) (DOH *);
+ DohFuncPtr_t builtin;
- builtin = (DOH *(*)(DOH *)) GetVoid(func, "builtin");
- if (!builtin)
+ builtin.p = GetVoid(func, "builtin");
+
+ if (!builtin.p)
return 0;
- result = (*builtin) (args);
+ result = (*builtin.func) (args);
return result;
}
extern DOHList *DohSplitLines(DOHFile * input);
extern DOH *DohNone;
+/* Helper union for converting between function and object pointers. */
+typedef union DohFuncPtr {
+ void* p;
+ DOH *(*func)(DOH *);
+} DohFuncPtr_t;
+
extern void DohMemoryDebug(void);
#ifndef DOH_LONG_NAMES
DohFile *f = (DohFile *) ObjData(fo);
if (f->filep) {
- return fread(buffer, 1, len, f->filep);
+ return (int)fread(buffer, 1, len, f->filep);
} else if (f->fd) {
#ifdef DOH_INTFILE
return read(f->fd, buffer, len);
* ----------------------------------------------------------------------------- */
void DohEncoding(const char *name, DOH *(*fn) (DOH *s)) {
+ DohFuncPtr_t fp;
+
if (!encodings)
encodings = NewHash();
- Setattr(encodings, (void *) name, NewVoid((void *) fn, 0));
+
+ fp.func = fn;
+ Setattr(encodings, (void *) name, NewVoid(fp.p, 0));
}
/* internal function for processing an encoding */
static DOH *encode(char *name, DOH *s) {
DOH *handle, *ns;
- DOH *(*fn) (DOH *);
+ DohFuncPtr_t fp;
long pos;
char *cfmt = strchr(name, ':');
DOH *tmp = 0;
s = tmp;
pos = Tell(s);
Seek(s, 0, SEEK_SET);
- fn = (DOH *(*)(DOH *)) Data(handle);
- ns = (*fn) (s);
+
+ fp.p = Data(handle);
+ ns = (*fp.func) (s);
assert(pos != -1);
(void)Seek(s, pos, SEEK_SET);
if (tmp)
}
if (strlen(encoder)) {
enc = encode(encoder, Sval);
- maxwidth = maxwidth + strlen(newformat) + Len(enc);
+ maxwidth = maxwidth + (int)strlen(newformat) + Len(enc);
} else {
- maxwidth = maxwidth + strlen(newformat) + Len(Sval);
+ maxwidth = maxwidth + (int)strlen(newformat) + Len(Sval);
}
*(fmt++) = 's';
*fmt = 0;
} else {
nbytes += sprintf(stemp, newformat, Data(Sval));
}
- if (Writen(so, stemp, strlen(stemp)) < 0)
+ if (Writen(so, stemp, (int)strlen(stemp)) < 0)
return -1;
if ((DOH *) Sval != doh) {
Delete(Sval);
} else {
enc = 0;
}
- maxwidth = maxwidth + strlen(newformat) + strlen((char *) doh);
+ maxwidth = maxwidth + (int)strlen(newformat) + (int)strlen((char *) doh);
*(fmt++) = 's';
*fmt = 0;
if ((maxwidth + 1) < OBUFLEN) {
stemp = (char *) DohMalloc(maxwidth + 1);
}
nbytes += sprintf(stemp, newformat, doh);
- if (Writen(so, stemp, strlen(stemp)) < 0)
+ if (Writen(so, stemp, (int)strlen(stemp)) < 0)
return -1;
if (stemp != obuffer) {
DohFree(stemp);
} else {
*(fmt++) = *p;
*fmt = 0;
- maxwidth = maxwidth + strlen(newformat) + 64;
+ maxwidth = maxwidth + (int)strlen(newformat) + 64;
/* Only allocate a buffer if it is too big to fit. Shouldn't have to do
this very often */
default:
break;
}
- if (Writen(so, stemp, strlen(stemp)) < 0)
+ if (Writen(so, stemp, (int)strlen(stemp)) < 0)
return -1;
if (stemp != obuffer)
DohFree(stemp);
if (state) {
int r;
*fmt = 0;
- r = Writen(so, fmt, strlen(fmt));
+ r = Writen(so, fmt, (int)strlen(fmt));
if (r < 0)
return -1;
nbytes += r;
if (DohCheck(obj)) {
ret += DohDump(obj, f);
} else {
- ret += DohWrite(f, obj, strlen((char *) obj));
+ ret += DohWrite(f, obj, (int)strlen((char *) obj));
}
}
va_end(ap);
return s->hashkey;
} else {
register char *c = s->str;
- register int len = s->len > 50 ? 50 : s->len;
- register int h = 0;
- register int mlen = len >> 2;
- register int i = mlen;
+ register unsigned int len = s->len > 50 ? 50 : s->len;
+ register unsigned int h = 0;
+ register unsigned int mlen = len >> 2;
+ register unsigned int i = mlen;
for (; i; --i) {
h = (h << 5) + *(c++);
h = (h << 5) + *(c++);
h = (h << 5) + *(c++);
}
h &= 0x7fffffff;
- s->hashkey = h;
+ s->hashkey = (int)h;
return h;
}
}
return 0;
base = str->str;
- tokenlen = strlen(token);
+ tokenlen = (int)strlen(token);
s = (*match) (base, base, token, tokenlen);
if (!s)
}
first = s;
- replen = strlen(rep);
+ replen = (int)strlen(rep);
delta = (replen - tokenlen);
str->maxsize = max;
if (s) {
strncpy(str->str, s, len);
+ str->str[l] = 0;
str->len = l;
str->sp = l;
} else {
/* Source/Include/swigconfig.h.in. Generated from configure.ac by autoheader. */
-/* Define to 1 if the system has the type `bool'. */
-#undef HAVE_BOOL
-
/* define if the Boost library is available */
#undef HAVE_BOOST
/* Define to 1 if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H
-/* Define to 1 if your C compiler doesn't accept -c and -o together. */
-#undef NO_MINUS_C_MINUS_O
-
/* Name of package */
#undef PACKAGE
/* Default language */
#define SWIG_LANG "-tcl"
-/* Deal with Microsofts attempt at deprecating C standard runtime functions */
+/* Deal with attempt by Microsoft to deprecate C standard runtime functions */
#if defined(_MSC_VER)
# define _CRT_SECURE_NO_DEPRECATE
#endif
#define WARN_DEPRECATED_NODEFAULT 123
#define WARN_DEPRECATED_TYPEMAP_LANG 124
#define WARN_DEPRECATED_INPUT_FILE 125
+#define WARN_DEPRECATED_NESTED_WORKAROUND 126
/* -- Preprocessor -- */
#define WARN_PARSE_NAMED_NESTED_CLASS 325
#define WARN_PARSE_EXTEND_NAME 326
+#define WARN_CPP11_LAMBDA 340
+#define WARN_CPP11_ALIAS_DECLARATION 341
+#define WARN_CPP11_ALIAS_TEMPLATE 342
+#define WARN_CPP11_VARIADIC_TEMPLATE 343
+
#define WARN_IGNORE_OPERATOR_NEW 350 /* new */
#define WARN_IGNORE_OPERATOR_DELETE 351 /* delete */
#define WARN_IGNORE_OPERATOR_PLUS 352 /* + */
#define WARN_TYPEMAP_DIRECTOROUT_PTR 473
#define WARN_TYPEMAP_OUT_OPTIMAL_IGNORED 474
#define WARN_TYPEMAP_OUT_OPTIMAL_MULTIPLE 475
+#define WARN_TYPEMAP_INITIALIZER_LIST 476
+#define WARN_TYPEMAP_DIRECTORTHROWS_UNDEF 477
/* -- Fragments -- */
#define WARN_FRAGMENT_NOT_FOUND 490
/* please leave 700-719 free for D */
+#define WARN_SCILAB_TRUNCATED_NAME 720
+
+/* please leave 720-739 free for Scilab */
+
+#define WARN_PYTHON_INDENT_MISMATCH 740
+
+/* please leave 740-759 free for Python */
+
#define WARN_RUBY_WRONG_NAME 801
#define WARN_RUBY_MULTIPLE_INHERITANCE 802
#define WARN_JAVA_TYPEMAP_JAVAIN_UNDEF 818
#define WARN_JAVA_TYPEMAP_JAVADIRECTORIN_UNDEF 819
#define WARN_JAVA_TYPEMAP_JAVADIRECTOROUT_UNDEF 820
+#define WARN_JAVA_TYPEMAP_INTERFACECODE_UNDEF 821
#define WARN_JAVA_COVARIANT_RET 822
#define WARN_JAVA_TYPEMAP_JAVACONSTRUCT_UNDEF 823
#define WARN_JAVA_TYPEMAP_DIRECTORIN_NODESC 824
#define WARN_CSHARP_TYPEMAP_CSIN_UNDEF 838
#define WARN_CSHARP_TYPEMAP_CSDIRECTORIN_UNDEF 839
#define WARN_CSHARP_TYPEMAP_CSDIRECTOROUT_UNDEF 840
+#define WARN_CSHARP_TYPEMAP_INTERFACECODE_UNDEF 841
#define WARN_CSHARP_COVARIANT_RET 842
#define WARN_CSHARP_TYPEMAP_CSCONSTRUCT_UNDEF 843
#define WARN_CSHARP_EXCODE 844
Modules/emit.cxx \
Modules/go.cxx \
Modules/guile.cxx \
+ Modules/interface.cxx \
Modules/java.cxx \
+ Modules/javascript.cxx \
Modules/lang.cxx \
Modules/lua.cxx \
Modules/main.cxx \
Modules/modula3.cxx \
Modules/module.cxx \
Modules/mzscheme.cxx \
+ Modules/nested.cxx \
Modules/ocaml.cxx \
Modules/octave.cxx \
Modules/overload.cxx \
Modules/r.cxx \
Modules/ruby.cxx \
Modules/s-exp.cxx \
+ Modules/scilab.cxx \
Modules/swigmain.cxx \
Modules/tcl8.cxx \
Modules/typepass.cxx \
Swig/cwrap.c \
Swig/deprecate.c \
Swig/error.c \
+ Swig/extend.c \
Swig/fragment.c \
Swig/getopt.c \
Swig/include.c \
Swig/typeobj.c \
Swig/typemap.c \
Swig/typesys.c \
- Swig/wrapfunc.c
+ Swig/wrapfunc.c
bin_PROGRAMS = eswig
eswig_LDADD = @SWIGLIBS@
CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
# The executable is copied to the root directory for installation and running the test-suite.
-# This occurs on each invocation of make and is a step towards providing support for multiple
+# This occurs on each invocation of make and is a step towards providing support for multiple
# build directories.
all-local: eswig@EXEEXT@
cp -f $(top_builddir)/Source/eswig@EXEEXT@ $(top_builddir)/swig@EXEEXT@
# swig executable as a way of checking before and after the 'beautifying'.
# Single files can be beautified with the beautify-file target, eg: 'make beautify-file INDENTFILE=chosenfile.c'
-SWIGTYPEDEFS=-T bool -T File -T DohObjInfo -T Parm -T Language -T List -T Typetab -T ModuleFactory -T ErrorMessageFormat -T Symtab -T Hash -T String -T DohBase -T Node -T String_or_char -T SwigType -T Dispatcher -T Wrapper -T DohStringMethods -T DohFileMethods -T DohListMethods -T DohHashMethods -T DOH -T DohIterator -T ParmList -T FILE -T HashNode -T DOHString_or_char
+SWIGTYPEDEFS=-T bool -T File -T DohObjInfo -T Parm -T Language -T List -T Typetab -T ModuleFactory -T ErrorMessageFormat -T Symtab -T Hash -T Scanner -T String -T DohBase -T Node -T String_or_char -T SwigType -T Dispatcher -T Wrapper -T DohStringMethods -T DohFileMethods -T DohListMethods -T DohHashMethods -T DOH -T DohIterator -T ParmList -T FILE -T HashNode -T DOHObj_or_char -T DOHFile -T DOHString -T DOHString_or_char -T UpcallData
INDENTBAKSDIR=../IndentBaks
beautify:
indent -kr --honour-newlines --line-length160 --indent-level2 --braces-on-func-def-line --leave-optional-blank-lines $(SWIGTYPEDEFS) $(INDENTFILE) -o $(INDENTFILE).tmp;
cat $(INDENTFILE).tmp | sed -e 's/const const /const /' > $(INDENTFILE);
rm $(INDENTFILE).tmp;
-
-# Makefile.in generated by automake 1.11.3 from Makefile.am.
+# Makefile.in generated by automake 1.15 from Makefile.am.
# @configure_input@
-# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
-# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
-# Foundation, Inc.
+# Copyright (C) 1994-2014 Free Software Foundation, Inc.
+
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
@SET_MAKE@
VPATH = @srcdir@
+am__is_gnu_make = { \
+ if test -z '$(MAKELEVEL)'; then \
+ false; \
+ elif test -n '$(MAKE_HOST)'; then \
+ true; \
+ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+ true; \
+ else \
+ false; \
+ fi; \
+}
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
host_triplet = @host@
bin_PROGRAMS = eswig$(EXEEXT)
subdir = Source
-DIST_COMMON = README $(srcdir)/Makefile.am $(srcdir)/Makefile.in \
- CParse/parser.c CParse/parser.h
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = \
- $(top_srcdir)/Tools/config/ac_compare_version.m4 \
$(top_srcdir)/Tools/config/ac_compile_warnings.m4 \
$(top_srcdir)/Tools/config/ac_define_dir.m4 \
$(top_srcdir)/Tools/config/ax_boost_base.m4 \
$(top_srcdir)/Tools/config/ax_compare_version.m4 \
+ $(top_srcdir)/Tools/config/ax_cxx_compile_stdcxx_11.m4 \
$(top_srcdir)/Tools/config/ax_path_generic.m4 \
$(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/Source/Include/swigconfig.h
CONFIG_CLEAN_FILES =
Modules/contract.$(OBJEXT) Modules/csharp.$(OBJEXT) \
Modules/d.$(OBJEXT) Modules/directors.$(OBJEXT) \
Modules/emit.$(OBJEXT) Modules/go.$(OBJEXT) \
- Modules/guile.$(OBJEXT) Modules/java.$(OBJEXT) \
+ Modules/guile.$(OBJEXT) Modules/interface.$(OBJEXT) \
+ Modules/java.$(OBJEXT) Modules/javascript.$(OBJEXT) \
Modules/lang.$(OBJEXT) Modules/lua.$(OBJEXT) \
Modules/main.$(OBJEXT) Modules/modula3.$(OBJEXT) \
Modules/module.$(OBJEXT) Modules/mzscheme.$(OBJEXT) \
- Modules/ocaml.$(OBJEXT) Modules/octave.$(OBJEXT) \
- Modules/overload.$(OBJEXT) Modules/perl5.$(OBJEXT) \
- Modules/php.$(OBJEXT) Modules/pike.$(OBJEXT) \
- Modules/python.$(OBJEXT) Modules/r.$(OBJEXT) \
- Modules/ruby.$(OBJEXT) Modules/s-exp.$(OBJEXT) \
+ Modules/nested.$(OBJEXT) Modules/ocaml.$(OBJEXT) \
+ Modules/octave.$(OBJEXT) Modules/overload.$(OBJEXT) \
+ Modules/perl5.$(OBJEXT) Modules/php.$(OBJEXT) \
+ Modules/pike.$(OBJEXT) Modules/python.$(OBJEXT) \
+ Modules/r.$(OBJEXT) Modules/ruby.$(OBJEXT) \
+ Modules/s-exp.$(OBJEXT) Modules/scilab.$(OBJEXT) \
Modules/swigmain.$(OBJEXT) Modules/tcl8.$(OBJEXT) \
Modules/typepass.$(OBJEXT) Modules/uffi.$(OBJEXT) \
Modules/utils.$(OBJEXT) Modules/xml.$(OBJEXT) \
Preprocessor/cpp.$(OBJEXT) Preprocessor/expr.$(OBJEXT) \
Swig/cwrap.$(OBJEXT) Swig/deprecate.$(OBJEXT) \
- Swig/error.$(OBJEXT) Swig/fragment.$(OBJEXT) \
- Swig/getopt.$(OBJEXT) Swig/include.$(OBJEXT) \
- Swig/misc.$(OBJEXT) Swig/naming.$(OBJEXT) Swig/parms.$(OBJEXT) \
+ Swig/error.$(OBJEXT) Swig/extend.$(OBJEXT) \
+ Swig/fragment.$(OBJEXT) Swig/getopt.$(OBJEXT) \
+ Swig/include.$(OBJEXT) Swig/misc.$(OBJEXT) \
+ Swig/naming.$(OBJEXT) Swig/parms.$(OBJEXT) \
Swig/scanner.$(OBJEXT) Swig/stype.$(OBJEXT) \
Swig/symbol.$(OBJEXT) Swig/tree.$(OBJEXT) \
Swig/typeobj.$(OBJEXT) Swig/typemap.$(OBJEXT) \
Swig/typesys.$(OBJEXT) Swig/wrapfunc.$(OBJEXT)
eswig_OBJECTS = $(am_eswig_OBJECTS)
eswig_DEPENDENCIES =
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
DEFAULT_INCLUDES =
depcomp = $(SHELL) $(top_srcdir)/Tools/config/depcomp
am__depfiles_maybe = depfiles
am__mv = mv -f
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo " CC " $@;
+am__v_CC_1 =
CCLD = $(CC)
LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo " CCLD " $@;
+am__v_CCLD_1 =
CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
CXXLD = $(CXX)
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+am__yacc_c2h = sed -e s/cc$$/hh/ -e s/cpp$$/hpp/ -e s/cxx$$/hxx/ \
+ -e s/c++$$/h++/ -e s/c$$/h/
YACCCOMPILE = $(YACC) $(AM_YFLAGS) $(YFLAGS)
+AM_V_YACC = $(am__v_YACC_@AM_V@)
+am__v_YACC_ = $(am__v_YACC_@AM_DEFAULT_V@)
+am__v_YACC_0 = @echo " YACC " $@;
+am__v_YACC_1 =
YLWRAP = $(top_srcdir)/Tools/config/ylwrap
SOURCES = $(eswig_SOURCES)
DIST_SOURCES = $(eswig_SOURCES)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
ETAGS = etags
CTAGS = ctags
+am__DIST_COMMON = $(srcdir)/Makefile.in \
+ $(top_srcdir)/Tools/config/depcomp \
+ $(top_srcdir)/Tools/config/ylwrap CParse/parser.c \
+ CParse/parser.h README
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
ADB = @ADB@
ALLEGROCLBIN = @ALLEGROCLBIN@
AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
ANDROID = @ANDROID@
ANT = @ANT@
-AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
BOOST_CPPFLAGS = @BOOST_CPPFLAGS@
BOOST_LDFLAGS = @BOOST_LDFLAGS@
+CAMLP4 = @CAMLP4@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CCSHARED = @CCSHARED@
CSHARPCILINTERPRETER = @CSHARPCILINTERPRETER@
CSHARPCILINTERPRETER_FLAGS = @CSHARPCILINTERPRETER_FLAGS@
CSHARPCOMPILER = @CSHARPCOMPILER@
-CSHARPCYGPATH_W = @CSHARPCYGPATH_W@
+CSHARPCONVERTPATH = @CSHARPCONVERTPATH@
CSHARPDYNAMICLINKING = @CSHARPDYNAMICLINKING@
CSHARPLIBRARYPREFIX = @CSHARPLIBRARYPREFIX@
-CSHARPPATHSEPARATOR = @CSHARPPATHSEPARATOR@
CSHARPSO = @CSHARPSO@
CXX = @CXX@
CXXDEPMODE = @CXXDEPMODE@
ENABLE_CCACHE = @ENABLE_CCACHE@
EXEEXT = @EXEEXT@
EXTRA_CLEAN = @EXTRA_CLEAN@
+GCCGO = @GCCGO@
+GCCGOOPT = @GCCGOOPT@
GCJ = @GCJ@
GCJH = @GCJH@
GO = @GO@
GO1 = @GO1@
+GO12 = @GO12@
+GO13 = @GO13@
+GO15 = @GO15@
GOC = @GOC@
GOGCC = @GOGCC@
GOOPT = @GOOPT@
GUILE_CONFIG = @GUILE_CONFIG@
GUILE_LIBS = @GUILE_LIBS@
GUILE_SO = @GUILE_SO@
+HAVE_CXX11_COMPILER = @HAVE_CXX11_COMPILER@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
JAVACFLAGS = @JAVACFLAGS@
JAVACXXSHARED = @JAVACXXSHARED@
JAVADYNAMICLINKING = @JAVADYNAMICLINKING@
+JAVAFLAGS = @JAVAFLAGS@
JAVAINC = @JAVAINC@
JAVALDSHARED = @JAVALDSHARED@
JAVALIBRARYPREFIX = @JAVALIBRARYPREFIX@
JAVASO = @JAVASO@
+JSCENABLED = @JSCENABLED@
+JSCOREDYNAMICLINKING = @JSCOREDYNAMICLINKING@
+JSCOREINC = @JSCOREINC@
+JSCOREVERSION = @JSCOREVERSION@
+JSINTERPRETERCXX = @JSINTERPRETERCXX@
+JSINTERPRETERLINKFLAGS = @JSINTERPRETERLINKFLAGS@
+JSV8DYNAMICLINKING = @JSV8DYNAMICLINKING@
+JSV8ENABLED = @JSV8ENABLED@
+JSV8INC = @JSV8INC@
LDFLAGS = @LDFLAGS@
LDSHARED = @LDSHARED@
LIBC = @LIBC@
MZSCHEME = @MZSCHEME@
MZSCHEME_SO = @MZSCHEME_SO@
NDKBUILD = @NDKBUILD@
+NODEGYP = @NODEGYP@
+NODEJS = @NODEJS@
OBJEXT = @OBJEXT@
-OCAMLBIN = @OCAMLBIN@
OCAMLC = @OCAMLC@
OCAMLDLGEN = @OCAMLDLGEN@
OCAMLFIND = @OCAMLFIND@
-OCAMLINC = @OCAMLINC@
-OCAMLLOC = @OCAMLLOC@
OCAMLMKTOP = @OCAMLMKTOP@
-OCAMLVER = @OCAMLVER@
OCTAVE = @OCTAVE@
OCTAVE_CPPFLAGS = @OCTAVE_CPPFLAGS@
OCTAVE_CXXFLAGS = @OCTAVE_CXXFLAGS@
PCRE_CFLAGS = @PCRE_CFLAGS@
PCRE_CONFIG = @PCRE_CONFIG@
PCRE_LIBS = @PCRE_LIBS@
+PEP8 = @PEP8@
PERL = @PERL@
PERL5CCCDLFLAGS = @PERL5CCCDLFLAGS@
PERL5CCDLFLAGS = @PERL5CCDLFLAGS@
PIKECONFIG = @PIKECONFIG@
PIKEDYNAMICLINKING = @PIKEDYNAMICLINKING@
PIKEINCLUDE = @PIKEINCLUDE@
-PLATFLAGS = @PLATFLAGS@
+PKGCONFIG = @PKGCONFIG@
+PLATCFLAGS = @PLATCFLAGS@
+PLATCXXFLAGS = @PLATCXXFLAGS@
PY3CONFIG = @PY3CONFIG@
PY3INCLUDE = @PY3INCLUDE@
PY3LIB = @PY3LIB@
PYTHON3DYNAMICLINKING = @PYTHON3DYNAMICLINKING@
PYTHONDYNAMICLINKING = @PYTHONDYNAMICLINKING@
PYTHON_SO = @PYTHON_SO@
-RANLIB = @RANLIB@
RBIN = @RBIN@
ROOT_DIR = @ROOT_DIR@
RPATH = @RPATH@
RUBYLIB = @RUBYLIB@
RUBYLINK = @RUBYLINK@
RUBYSO = @RUBYSO@
+SCILAB = @SCILAB@
+SCILABINCLUDE = @SCILABINCLUDE@
+SCILABOPT = @SCILABOPT@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
SKIP_GO = @SKIP_GO@
SKIP_GUILE = @SKIP_GUILE@
SKIP_JAVA = @SKIP_JAVA@
+SKIP_JAVASCRIPT = @SKIP_JAVASCRIPT@
SKIP_LUA = @SKIP_LUA@
SKIP_MODULA3 = @SKIP_MODULA3@
SKIP_MZSCHEME = @SKIP_MZSCHEME@
SKIP_PYTHON3 = @SKIP_PYTHON3@
SKIP_R = @SKIP_R@
SKIP_RUBY = @SKIP_RUBY@
+SKIP_SCILAB = @SKIP_SCILAB@
SKIP_TCL = @SKIP_TCL@
SKIP_UFFI = @SKIP_UFFI@
SO = @SO@
STRIP = @STRIP@
SWIGLIBS = @SWIGLIBS@
SWIG_LIB = @SWIG_LIB@
+SWIG_LIB_INSTALL = @SWIG_LIB_INSTALL@
+SWIG_LIB_PREINST = @SWIG_LIB_PREINST@
+SWIG_LIB_SET = @SWIG_LIB_SET@
SWILL = @SWILL@
TCLCXXSHARED = @TCLCXXSHARED@
TCLDYNAMICLINKING = @TCLDYNAMICLINKING@
TCL_SO = @TCL_SO@
TRYLINKINGWITHCXX = @TRYLINKINGWITHCXX@
VERSION = @VERSION@
-XINCLUDES = @XINCLUDES@
-XLIBSW = @XLIBSW@
-XMKMF = @XMKMF@
YACC = @YACC@
YFLAGS = @YFLAGS@
-YODL2HTML = @YODL2HTML@
-YODL2MAN = @YODL2MAN@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
+runstatedir = @runstatedir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
subdirs = @subdirs@
-swig_lib = @swig_lib@
sysconfdir = @sysconfdir@
target_alias = @target_alias@
top_build_prefix = @top_build_prefix@
Modules/emit.cxx \
Modules/go.cxx \
Modules/guile.cxx \
+ Modules/interface.cxx \
Modules/java.cxx \
+ Modules/javascript.cxx \
Modules/lang.cxx \
Modules/lua.cxx \
Modules/main.cxx \
Modules/modula3.cxx \
Modules/module.cxx \
Modules/mzscheme.cxx \
+ Modules/nested.cxx \
Modules/ocaml.cxx \
Modules/octave.cxx \
Modules/overload.cxx \
Modules/r.cxx \
Modules/ruby.cxx \
Modules/s-exp.cxx \
+ Modules/scilab.cxx \
Modules/swigmain.cxx \
Modules/tcl8.cxx \
Modules/typepass.cxx \
Swig/cwrap.c \
Swig/deprecate.c \
Swig/error.c \
+ Swig/extend.c \
Swig/fragment.c \
Swig/getopt.c \
Swig/include.c \
Swig/typeobj.c \
Swig/typemap.c \
Swig/typesys.c \
- Swig/wrapfunc.c
+ Swig/wrapfunc.c
eswig_LDADD = @SWIGLIBS@
# Compiling with -DNDEBUG and no optimisations will allow one to do a binary diff of the
# swig executable as a way of checking before and after the 'beautifying'.
# Single files can be beautified with the beautify-file target, eg: 'make beautify-file INDENTFILE=chosenfile.c'
-SWIGTYPEDEFS = -T bool -T File -T DohObjInfo -T Parm -T Language -T List -T Typetab -T ModuleFactory -T ErrorMessageFormat -T Symtab -T Hash -T String -T DohBase -T Node -T String_or_char -T SwigType -T Dispatcher -T Wrapper -T DohStringMethods -T DohFileMethods -T DohListMethods -T DohHashMethods -T DOH -T DohIterator -T ParmList -T FILE -T HashNode -T DOHString_or_char
+SWIGTYPEDEFS = -T bool -T File -T DohObjInfo -T Parm -T Language -T List -T Typetab -T ModuleFactory -T ErrorMessageFormat -T Symtab -T Hash -T Scanner -T String -T DohBase -T Node -T String_or_char -T SwigType -T Dispatcher -T Wrapper -T DohStringMethods -T DohFileMethods -T DohListMethods -T DohHashMethods -T DOH -T DohIterator -T ParmList -T FILE -T HashNode -T DOHObj_or_char -T DOHFile -T DOHString -T DOHString_or_char -T UpcallData
INDENTBAKSDIR = ../IndentBaks
all: $(BUILT_SOURCES)
$(MAKE) $(AM_MAKEFLAGS) all-am
echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Source/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --foreign Source/Makefile
-.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
$(am__aclocal_m4_deps):
install-binPROGRAMS: $(bin_PROGRAMS)
@$(NORMAL_INSTALL)
- test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)"
@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ if test -n "$$list"; then \
+ echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
+ fi; \
for p in $$list; do echo "$$p $$p"; done | \
sed 's/$(EXEEXT)$$//' | \
- while read p p1; do if test -f $$p; \
- then echo "$$p"; echo "$$p"; else :; fi; \
+ while read p p1; do if test -f $$p \
+ ; then echo "$$p"; echo "$$p"; else :; fi; \
done | \
- sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \
+ sed -e 'p;s,.*/,,;n;h' \
+ -e 's|.*|.|' \
-e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
sed 'N;N;N;s,\n, ,g' | \
$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
files=`for p in $$list; do echo "$$p"; done | \
sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
- -e 's/$$/$(EXEEXT)/' `; \
+ -e 's/$$/$(EXEEXT)/' \
+ `; \
test -n "$$list" || exit 0; \
echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
cd "$(DESTDIR)$(bindir)" && rm -f $$files
Modules/$(DEPDIR)/$(am__dirstamp)
Modules/guile.$(OBJEXT): Modules/$(am__dirstamp) \
Modules/$(DEPDIR)/$(am__dirstamp)
+Modules/interface.$(OBJEXT): Modules/$(am__dirstamp) \
+ Modules/$(DEPDIR)/$(am__dirstamp)
Modules/java.$(OBJEXT): Modules/$(am__dirstamp) \
Modules/$(DEPDIR)/$(am__dirstamp)
+Modules/javascript.$(OBJEXT): Modules/$(am__dirstamp) \
+ Modules/$(DEPDIR)/$(am__dirstamp)
Modules/lang.$(OBJEXT): Modules/$(am__dirstamp) \
Modules/$(DEPDIR)/$(am__dirstamp)
Modules/lua.$(OBJEXT): Modules/$(am__dirstamp) \
Modules/$(DEPDIR)/$(am__dirstamp)
Modules/mzscheme.$(OBJEXT): Modules/$(am__dirstamp) \
Modules/$(DEPDIR)/$(am__dirstamp)
+Modules/nested.$(OBJEXT): Modules/$(am__dirstamp) \
+ Modules/$(DEPDIR)/$(am__dirstamp)
Modules/ocaml.$(OBJEXT): Modules/$(am__dirstamp) \
Modules/$(DEPDIR)/$(am__dirstamp)
Modules/octave.$(OBJEXT): Modules/$(am__dirstamp) \
Modules/$(DEPDIR)/$(am__dirstamp)
Modules/s-exp.$(OBJEXT): Modules/$(am__dirstamp) \
Modules/$(DEPDIR)/$(am__dirstamp)
+Modules/scilab.$(OBJEXT): Modules/$(am__dirstamp) \
+ Modules/$(DEPDIR)/$(am__dirstamp)
Modules/swigmain.$(OBJEXT): Modules/$(am__dirstamp) \
Modules/$(DEPDIR)/$(am__dirstamp)
Modules/tcl8.$(OBJEXT): Modules/$(am__dirstamp) \
Swig/$(DEPDIR)/$(am__dirstamp)
Swig/error.$(OBJEXT): Swig/$(am__dirstamp) \
Swig/$(DEPDIR)/$(am__dirstamp)
+Swig/extend.$(OBJEXT): Swig/$(am__dirstamp) \
+ Swig/$(DEPDIR)/$(am__dirstamp)
Swig/fragment.$(OBJEXT): Swig/$(am__dirstamp) \
Swig/$(DEPDIR)/$(am__dirstamp)
Swig/getopt.$(OBJEXT): Swig/$(am__dirstamp) \
Swig/$(DEPDIR)/$(am__dirstamp)
Swig/wrapfunc.$(OBJEXT): Swig/$(am__dirstamp) \
Swig/$(DEPDIR)/$(am__dirstamp)
+
eswig$(EXEEXT): $(eswig_OBJECTS) $(eswig_DEPENDENCIES) $(EXTRA_eswig_DEPENDENCIES)
@rm -f eswig$(EXEEXT)
- $(CXXLINK) $(eswig_OBJECTS) $(eswig_LDADD) $(LIBS)
+ $(AM_V_CXXLD)$(CXXLINK) $(eswig_OBJECTS) $(eswig_LDADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
- -rm -f CParse/cscanner.$(OBJEXT)
- -rm -f CParse/parser.$(OBJEXT)
- -rm -f CParse/templ.$(OBJEXT)
- -rm -f CParse/util.$(OBJEXT)
- -rm -f DOH/base.$(OBJEXT)
- -rm -f DOH/file.$(OBJEXT)
- -rm -f DOH/fio.$(OBJEXT)
- -rm -f DOH/hash.$(OBJEXT)
- -rm -f DOH/list.$(OBJEXT)
- -rm -f DOH/memory.$(OBJEXT)
- -rm -f DOH/string.$(OBJEXT)
- -rm -f DOH/void.$(OBJEXT)
- -rm -f Modules/allegrocl.$(OBJEXT)
- -rm -f Modules/allocate.$(OBJEXT)
- -rm -f Modules/browser.$(OBJEXT)
- -rm -f Modules/cffi.$(OBJEXT)
- -rm -f Modules/chicken.$(OBJEXT)
- -rm -f Modules/clisp.$(OBJEXT)
- -rm -f Modules/contract.$(OBJEXT)
- -rm -f Modules/csharp.$(OBJEXT)
- -rm -f Modules/d.$(OBJEXT)
- -rm -f Modules/directors.$(OBJEXT)
- -rm -f Modules/emit.$(OBJEXT)
- -rm -f Modules/go.$(OBJEXT)
- -rm -f Modules/guile.$(OBJEXT)
- -rm -f Modules/java.$(OBJEXT)
- -rm -f Modules/lang.$(OBJEXT)
- -rm -f Modules/lua.$(OBJEXT)
- -rm -f Modules/main.$(OBJEXT)
- -rm -f Modules/modula3.$(OBJEXT)
- -rm -f Modules/module.$(OBJEXT)
- -rm -f Modules/mzscheme.$(OBJEXT)
- -rm -f Modules/ocaml.$(OBJEXT)
- -rm -f Modules/octave.$(OBJEXT)
- -rm -f Modules/overload.$(OBJEXT)
- -rm -f Modules/perl5.$(OBJEXT)
- -rm -f Modules/php.$(OBJEXT)
- -rm -f Modules/pike.$(OBJEXT)
- -rm -f Modules/python.$(OBJEXT)
- -rm -f Modules/r.$(OBJEXT)
- -rm -f Modules/ruby.$(OBJEXT)
- -rm -f Modules/s-exp.$(OBJEXT)
- -rm -f Modules/swigmain.$(OBJEXT)
- -rm -f Modules/tcl8.$(OBJEXT)
- -rm -f Modules/typepass.$(OBJEXT)
- -rm -f Modules/uffi.$(OBJEXT)
- -rm -f Modules/utils.$(OBJEXT)
- -rm -f Modules/xml.$(OBJEXT)
- -rm -f Preprocessor/cpp.$(OBJEXT)
- -rm -f Preprocessor/expr.$(OBJEXT)
- -rm -f Swig/cwrap.$(OBJEXT)
- -rm -f Swig/deprecate.$(OBJEXT)
- -rm -f Swig/error.$(OBJEXT)
- -rm -f Swig/fragment.$(OBJEXT)
- -rm -f Swig/getopt.$(OBJEXT)
- -rm -f Swig/include.$(OBJEXT)
- -rm -f Swig/misc.$(OBJEXT)
- -rm -f Swig/naming.$(OBJEXT)
- -rm -f Swig/parms.$(OBJEXT)
- -rm -f Swig/scanner.$(OBJEXT)
- -rm -f Swig/stype.$(OBJEXT)
- -rm -f Swig/symbol.$(OBJEXT)
- -rm -f Swig/tree.$(OBJEXT)
- -rm -f Swig/typemap.$(OBJEXT)
- -rm -f Swig/typeobj.$(OBJEXT)
- -rm -f Swig/typesys.$(OBJEXT)
- -rm -f Swig/wrapfunc.$(OBJEXT)
+ -rm -f CParse/*.$(OBJEXT)
+ -rm -f DOH/*.$(OBJEXT)
+ -rm -f Modules/*.$(OBJEXT)
+ -rm -f Preprocessor/*.$(OBJEXT)
+ -rm -f Swig/*.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/emit.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/go.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/guile.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/interface.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/java.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/javascript.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/lang.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/lua.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/main.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/modula3.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/module.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/mzscheme.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/nested.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/ocaml.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/octave.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/overload.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/r.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/ruby.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/s-exp.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/scilab.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/swigmain.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/tcl8.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Modules/$(DEPDIR)/typepass.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Swig/$(DEPDIR)/cwrap.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Swig/$(DEPDIR)/deprecate.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Swig/$(DEPDIR)/error.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Swig/$(DEPDIR)/extend.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Swig/$(DEPDIR)/fragment.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Swig/$(DEPDIR)/getopt.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Swig/$(DEPDIR)/include.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Swig/$(DEPDIR)/wrapfunc.Po@am__quote@
.c.o:
-@am__fastdepCC_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@ $(COMPILE) -c -o $@ $<
+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
.c.obj:
-@am__fastdepCC_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@ $(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
.cxx.o:
-@am__fastdepCXX_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ $<
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
.cxx.obj:
-@am__fastdepCXX_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
.y.c:
- $(am__skipyacc) $(SHELL) $(YLWRAP) $< y.tab.c $@ y.tab.h $*.h y.output $*.output -- $(YACCCOMPILE)
-
-ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
- list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
- unique=`for i in $$list; do \
- if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
- done | \
- $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
- END { if (nonempty) { for (i in files) print i; }; }'`; \
- mkid -fID $$unique
-tags: TAGS
-
-TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
- $(TAGS_FILES) $(LISP)
+ $(AM_V_YACC)$(am__skipyacc) $(SHELL) $(YLWRAP) $< y.tab.c $@ y.tab.h `echo $@ | $(am__yacc_c2h)` y.output $*.output -- $(YACCCOMPILE)
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
set x; \
here=`pwd`; \
- list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
- unique=`for i in $$list; do \
- if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
- done | \
- $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
- END { if (nonempty) { for (i in files) print i; }; }'`; \
+ $(am__define_uniq_tagged_files); \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
$$unique; \
fi; \
fi
-ctags: CTAGS
-CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
- $(TAGS_FILES) $(LISP)
- list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
- unique=`for i in $$list; do \
- if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
- done | \
- $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
- END { if (nonempty) { for (i in files) print i; }; }'`; \
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
.MAKE: all check install install-am install-strip
-.PHONY: CTAGS GTAGS all all-am all-local check check-am clean \
- clean-binPROGRAMS clean-generic clean-local ctags distclean \
- distclean-compile distclean-generic distclean-local \
- distclean-tags distdir dvi dvi-am html html-am info info-am \
- install install-am install-binPROGRAMS install-data \
- install-data-am install-dvi install-dvi-am install-exec \
- install-exec-am install-html install-html-am install-info \
- install-info-am install-man install-pdf install-pdf-am \
- install-ps install-ps-am install-strip installcheck \
- installcheck-am installdirs maintainer-clean \
+.PHONY: CTAGS GTAGS TAGS all all-am all-local check check-am clean \
+ clean-binPROGRAMS clean-generic clean-local cscopelist-am \
+ ctags ctags-am distclean distclean-compile distclean-generic \
+ distclean-local distclean-tags distdir dvi dvi-am html html-am \
+ info info-am install install-am install-binPROGRAMS \
+ install-data install-data-am install-dvi install-dvi-am \
+ install-exec install-exec-am install-html install-html-am \
+ install-info install-info-am install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-compile \
- mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
+ mostlyclean-generic pdf pdf-am ps ps-am tags tags-am uninstall \
uninstall-am uninstall-binPROGRAMS
+.PRECIOUS: Makefile
+
# The executable is copied to the root directory for installation and running the test-suite.
-# This occurs on each invocation of make and is a step towards providing support for multiple
+# This occurs on each invocation of make and is a step towards providing support for multiple
# build directories.
all-local: eswig@EXEEXT@
cp -f $(top_builddir)/Source/eswig@EXEEXT@ $(top_builddir)/swig@EXEEXT@
// #define ALLEGROCL_TYPE_DEBUG
// #define ALLEGROCL_CLASS_DEBUG
-static const char *usage = (char *) "\
+static const char *usage = "\
Allegro CL Options (available with -allegrocl)\n\
-identifier-converter <type or funcname> - \n\
Specifies the type of conversion to do on C identifiers to convert\n\
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGALLEGROCL\n");
- Printf(f_runtime, "\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGALLEGROCL\n#define SWIGALLEGROCL\n#endif\n\n");
Swig_banner_target_lang(f_cl, ";;");
String *t2 = Getattr(p2, "tmap:typecheck:precedence");
if ((!t1) && (!nodes[i].error)) {
Swig_warning(WARN_TYPEMAP_TYPECHECK, Getfile(nodes[i].n), Getline(nodes[i].n),
- "Overloaded method %s not supported (no type checking rule for '%s').\n",
+ "Overloaded method %s not supported (incomplete type checking rule - no precedence level in typecheck typemap for '%s').\n",
Swig_name_decl(nodes[i].n), SwigType_str(Getattr(p1, "type"), 0));
nodes[i].error = 1;
} else if ((!t2) && (!nodes[j].error)) {
Swig_warning(WARN_TYPEMAP_TYPECHECK, Getfile(nodes[j].n), Getline(nodes[j].n),
- "Overloaded method %s not supported (no type checking rule for '%s').\n",
+ "Overloaded method %s not supported (incomplete type checking rule - no precedence level in typecheck typemap for '%s').\n",
Swig_name_decl(nodes[j].n), SwigType_str(Getattr(p2, "type"), 0));
nodes[j].error = 1;
}
Swig_warning(WARN_LANG_OVERLOAD_CONST, Getfile(nodes[i].n), Getline(nodes[i].n),
"using non-const method %s instead.\n", Swig_name_decl(nodes[i].n));
} else {
- if (!Getattr(nodes[j].n, "overload:ignore"))
+ if (!Getattr(nodes[j].n, "overload:ignore")) {
Swig_warning(WARN_LANG_OVERLOAD_IGNORED, Getfile(nodes[j].n), Getline(nodes[j].n),
"Overloaded method %s ignored,\n", Swig_name_decl(nodes[j].n));
Swig_warning(WARN_LANG_OVERLOAD_IGNORED, Getfile(nodes[i].n), Getline(nodes[i].n),
"using %s instead.\n", Swig_name_decl(nodes[i].n));
+ }
}
}
nodes[j].error = 1;
Swig_warning(WARN_LANG_OVERLOAD_CONST, Getfile(nodes[i].n), Getline(nodes[i].n),
"using non-const method %s instead.\n", Swig_name_decl(nodes[i].n));
} else {
- if (!Getattr(nodes[j].n, "overload:ignore"))
+ if (!Getattr(nodes[j].n, "overload:ignore")) {
Swig_warning(WARN_LANG_OVERLOAD_IGNORED, Getfile(nodes[j].n), Getline(nodes[j].n),
"Overloaded method %s ignored,\n", Swig_name_decl(nodes[j].n));
Swig_warning(WARN_LANG_OVERLOAD_IGNORED, Getfile(nodes[i].n), Getline(nodes[i].n),
"using %s instead.\n", Swig_name_decl(nodes[i].n));
+ }
}
}
nodes[j].error = 1;
Swig_warning(WARN_LANG_OVERLOAD_SHADOW, Getfile(nodes[i].n), Getline(nodes[i].n),
"as it is shadowed by %s.\n", Swig_name_decl(nodes[i].n));
} else {
- if (!Getattr(nodes[j].n, "overload:ignore"))
+ if (!Getattr(nodes[j].n, "overload:ignore")) {
Swig_warning(WARN_LANG_OVERLOAD_IGNORED, Getfile(nodes[j].n), Getline(nodes[j].n),
"Overloaded method %s ignored,\n", Swig_name_decl(nodes[j].n));
Swig_warning(WARN_LANG_OVERLOAD_IGNORED, Getfile(nodes[i].n), Getline(nodes[i].n),
"using %s instead.\n", Swig_name_decl(nodes[i].n));
+ }
}
nodes[j].error = 1;
}
Printf(stderr, "enumDeclaration %s\n", Getattr(n, "name"));
#endif
+ if (getCurrentClass() && (cplus_mode != PUBLIC))
+ return SWIG_NOWRAP;
+
if (Getattr(n, "sym:name")) {
add_defined_foreign_type(n);
}
while (cc) {
Node *cp = cc;
if (classname) {
- Setattr(cp, "classname", classname);
+ Setattr(cp, "extendsmartclassname", classname);
}
Setattr(cp, "allocate:smartpointeraccess", "1");
/* If constant, we have to be careful */
virtual int classDeclaration(Node *n) {
Symtab *symtab = Swig_symbol_current();
Swig_symbol_setscope(Getattr(n, "symtab"));
-
+ save_value<Node*> oldInclass(inclass);
+ save_value<AccessMode> oldAcessMode(cplus_mode);
+ save_value<int> oldExtendMode(extendmode);
+ if (Getattr(n, "template"))
+ extendmode = 0;
if (!CPlusPlus) {
/* Always have default constructors/destructors in C */
Setattr(n, "allocate:default_constructor", "1");
}
}
}
-
inclass = n;
String *kind = Getattr(n, "kind");
if (Strcmp(kind, "class") == 0) {
}
if (!Getattr(n, "allocate:has_destructor")) {
- /* No destructor was defined. We need to check a few things here too */
+ /* No destructor was defined */
List *bases = Getattr(n, "allbases");
int allows_destruct = 1;
}
if (!Getattr(n, "allocate:has_assign")) {
- /* No destructor was defined. We need to check a few things here too */
+ /* No assignment operator was defined */
List *bases = Getattr(n, "allbases");
int allows_assign = 1;
for (int i = 0; i < Len(bases); i++) {
Node *n = Getitem(bases, i);
- /* If base class does not allow default destructor, we don't allow it either */
+ /* If base class does not allow assignment, we don't allow it either */
if (Getattr(n, "allocate:has_assign")) {
allows_assign = !Getattr(n, "allocate:noassign");
}
}
if (!Getattr(n, "allocate:has_new")) {
- /* No destructor was defined. We need to check a few things here too */
+ /* No new operator was defined */
List *bases = Getattr(n, "allbases");
int allows_new = 1;
for (int i = 0; i < Len(bases); i++) {
Node *n = Getitem(bases, i);
- /* If base class does not allow default destructor, we don't allow it either */
+ /* If base class does not allow new operator, we don't allow it either */
if (Getattr(n, "allocate:has_new")) {
allows_new = !Getattr(n, "allocate:nonew");
}
/* Check if base classes allow smart pointers, but might be hidden */
if (!Getattr(n, "allocate:smartpointer")) {
- Node *sp = Swig_symbol_clookup((char *) "operator ->", 0);
+ Node *sp = Swig_symbol_clookup("operator ->", 0);
if (sp) {
/* Look for parent */
Node *p = parentNode(sp);
}
}
+ Swig_interface_propagate_methods(n);
+
/* Only care about default behavior. Remove temporary values */
Setattr(n, "allocate:visit", "1");
- inclass = 0;
Swig_symbol_setscope(symtab);
return SWIG_OK;
}
/* Check to see if this is a static member or not. If so, we add an attribute
cplus:staticbase that saves the current class */
- if (checkAttribute(n, "storage", "static")) {
+ if (Swig_storage_isstatic(n)) {
Setattr(n, "cplus:staticbase", inclass);
}
if (cplus_mode != PUBLIC) {
if (Strcmp(name, "operator =") == 0) {
/* Look for a private assignment operator */
- Setattr(inclass, "allocate:has_assign", "1");
+ if (!GetFlag(n, "deleted"))
+ Setattr(inclass, "allocate:has_assign", "1");
Setattr(inclass, "allocate:noassign", "1");
} else if (Strcmp(name, "operator new") == 0) {
/* Look for a private new operator */
- Setattr(inclass, "allocate:has_new", "1");
+ if (!GetFlag(n, "deleted"))
+ Setattr(inclass, "allocate:has_new", "1");
Setattr(inclass, "allocate:nonew", "1");
}
} else {
if (Strcmp(name, "operator =") == 0) {
- Setattr(inclass, "allocate:has_assign", "1");
+ if (!GetFlag(n, "deleted"))
+ Setattr(inclass, "allocate:has_assign", "1");
+ else
+ Setattr(inclass, "allocate:noassign", "1");
} else if (Strcmp(name, "operator new") == 0) {
- Setattr(inclass, "allocate:has_new", "1");
+ if (!GetFlag(n, "deleted"))
+ Setattr(inclass, "allocate:has_new", "1");
+ else
+ Setattr(inclass, "allocate:nonew", "1");
}
/* Look for smart pointer operator */
if ((Strcmp(name, "operator ->") == 0) && (!GetFlag(n, "feature:ignore"))) {
}
List *methods = smart_pointer_methods(sc, 0, isconst);
Setattr(inclass, "allocate:smartpointer", methods);
- Setattr(inclass, "allocate:smartpointerbase", base);
+ Setattr(inclass, "allocate:smartpointerpointeeclassname", Getattr(sc, "name"));
} else {
/* Hmmm. The return value is not a pointer. If the type is a value
or reference. We're going to chase it to see if another operator->()
can be found */
if ((SwigType_check_decl(type, "")) || (SwigType_check_decl(type, "r."))) {
- Node *nn = Swig_symbol_clookup((char *) "operator ->", Getattr(sc, "symtab"));
+ Node *nn = Swig_symbol_clookup("operator ->", Getattr(sc, "symtab"));
if (nn) {
Delete(base);
Delete(type);
Setattr(inclass, "allocate:default_destructor", "1");
} else if (cplus_mode == PROTECTED) {
Setattr(inclass, "allocate:default_base_destructor", "1");
+ } else if (cplus_mode == PRIVATE) {
+ Setattr(inclass, "allocate:private_destructor", "1");
}
} else {
Setattr(inclass, "allocate:has_destructor", "1");
return SWIG_OK;
}
+ virtual int lambdaDeclaration(Node *n) {
+ show_attributes(n);
+ emit_children(n);
+ return SWIG_OK;
+ }
+
virtual int enumDeclaration(Node *n) {
show_attributes(n);
emit_children(n);
//#define CFFI_DEBUG
//#define CFFI_WRAP_DEBUG
-static const char *usage = (char *) "\
+static const char *usage = "\
CFFI Options (available with -cffi)\n\
-generate-typedef - Use defctype to generate shortcuts according to the\n\
typedefs in the input.\n\
virtual int classHandler(Node *n);
private:
+ static void checkConstraints(ParmList *parms, Wrapper *f);
+ static void argout(ParmList *parms, Wrapper *f);
+ static String *freearg(ParmList *parms);
+ static void cleanupFunction(Node *n, Wrapper *f, ParmList *parms);
+
void emit_defun(Node *n, String *name);
void emit_defmethod(Node *n);
void emit_initialize_instance(Node *n);
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGCFFI\n");
- Printf(f_runtime, "\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGCFFI\n#define SWIGCFFI\n#endif\n\n");
Swig_banner_target_lang(f_lisp, ";;;");
return Language::membervariableHandler(n);
}
+
+void CFFI::checkConstraints(ParmList *parms, Wrapper *f) {
+ Parm *p = parms;
+ while (p) {
+ String *tm = Getattr(p, "tmap:check");
+ if (!tm) {
+ p = nextSibling(p);
+ } else {
+ tm = Copy(tm);
+ Replaceall(tm, "$input", Getattr(p, "emit:input"));
+ Printv(f->code, tm, "\n\n", NULL);
+ Delete(tm);
+ p = Getattr(p, "tmap:check:next");
+ }
+ }
+}
+
+void CFFI::argout(ParmList *parms, Wrapper *f) {
+ Parm *p = parms;
+ while (p) {
+ String *tm = Getattr(p, "tmap:argout");
+ if (!tm) {
+ p = nextSibling(p);
+ } else {
+ tm = Copy(tm);
+ Replaceall(tm, "$result", Swig_cresult_name());
+ Replaceall(tm, "$input", Getattr(p, "emit:input"));
+ Printv(f->code, tm, "\n", NULL);
+ Delete(tm);
+ p = Getattr(p, "tmap:argout:next");
+ }
+ }
+}
+
+String *CFFI::freearg(ParmList *parms) {
+ String *ret = NewString("");
+ Parm *p = parms;
+ while (p) {
+ String *tm = Getattr(p, "tmap:freearg");
+ if (!tm) {
+ p = nextSibling(p);
+ } else {
+ tm = Copy(tm);
+ Replaceall(tm, "$input", Getattr(p, "emit:input"));
+ Printv(ret, tm, "\n", NULL);
+ Delete(tm);
+ p = Getattr(p, "tmap:freearg:next");
+ }
+ }
+ return ret;
+}
+
+void CFFI::cleanupFunction(Node *n, Wrapper *f, ParmList *parms) {
+ String *cleanup = freearg(parms);
+ Printv(f->code, cleanup, NULL);
+
+ if (GetFlag(n, "feature:new")) {
+ String *tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0);
+ if (tm) {
+ Replaceall(tm, "$source", Swig_cresult_name());
+ Printv(f->code, tm, "\n", NULL);
+ Delete(tm);
+ }
+ }
+
+ Replaceall(f->code, "$cleanup", cleanup);
+ Delete(cleanup);
+
+ Replaceall(f->code, "$symname", Getattr(n, "sym:name"));
+}
+
int CFFI::functionWrapper(Node *n) {
ParmList *parms = Getattr(n, "parms");
// Emit the function definition
String *signature = SwigType_str(return_type, name_and_parms);
Printf(f->def, "EXPORT %s {", signature);
+
+ checkConstraints(parms, f);
+
Printf(f->code, " try {\n");
String *actioncode = emit_action(n);
if (result_convert) {
Replaceall(result_convert, "$result", "lresult");
Printf(f->code, "%s\n", result_convert);
- if(!is_void_return) Printf(f->code, " return lresult;\n");
- Delete(result_convert);
}
+ Delete(result_convert);
+
+ argout(parms, f);
+
+ cleanupFunction(n, f, parms);
+
+ if (!is_void_return) {
+ Printf(f->code, " return lresult;\n");
+ }
+
emit_return_variable(n, Getattr(n, "type"), f);
Printf(f->code, " } catch (...) {\n");
void CFFI::emit_defun(Node *n, String *name) {
-
- // String *storage=Getattr(n,"storage");
- // if(!storage || (Strcmp(storage,"extern") && Strcmp(storage,"externc")))
- // return SWIG_OK;
-
String *func_name = Getattr(n, "sym:name");
ParmList *pl = Getattr(n, "parms");
}
int CFFI::variableWrapper(Node *n) {
- // String *storage=Getattr(n,"storage");
- // Printf(stdout,"\"%s\" %s)\n",storage,Getattr(n, "sym:name"));
-
- // if(!storage || (Strcmp(storage,"extern") && Strcmp(storage,"externc")))
- // return SWIG_OK;
-
String *var_name = Getattr(n, "sym:name");
String *lisp_type = Swig_typemap_lookup("cin", n, "", 0);
String *lisp_name = lispify_name(n, var_name, "'variable");
}
int CFFI::enumDeclaration(Node *n) {
+ if (getCurrentClass() && (cplus_mode != PUBLIC))
+ return SWIG_NOWRAP;
+
String *name = Getattr(n, "sym:name");
bool slot_name_keywords;
String *lisp_name = 0;
if (!first)
Printf(supers, " ");
String *s = Getattr(i.item, "name");
- Printf(supers, "%s", lispify_name(i.item, s, "'classname"));
+ Printf(supers, "%s", lispify_name(i.item, lispy_name(Char(s)), "'classname"));
}
} else {
// Printf(supers,"ff:foreign-pointer");
if (slot_name && (Strcmp(slot_name, "t") == 0 || Strcmp(slot_name, "T") == 0))
slot_name = NewStringf("t_var");
- Printf(f_cl, "\n\t(%s %s)", slot_name, typespec);
+ if (SwigType_isarray(childType) && SwigType_array_ndim(childType) == 1) {
+ String *dim = SwigType_array_getdim(childType, 0);
+ Printf(f_cl, "\n\t(%s %s :count %s)", slot_name, typespec, dim);
+ Delete(dim);
+ } else
+ Printf(f_cl, "\n\t(%s %s)", slot_name, typespec);
Delete(node);
Delete(childType);
}
void CFFI::emit_export(Node *n, String *name) {
- if (GetInt(n, "feature:export"))
- Printf(f_cl, "\n(cl:export '%s)\n", name);
+ if (GetInt(n, "feature:export")) {
+ String* package = Getattr(n, "feature:export:package");
+ Printf(f_cl, "\n(cl:export '%s%s%s)\n", name, package ? " " : "",
+ package ? package : "");
+ }
}
void CFFI::emit_inline(Node *n, String *name) {
return num;
} else if (SwigType_type(type) == T_CHAR) {
/* Use CL syntax for character literals */
- String* result = NewStringf("#\\%c", s[0]);
+ String* result = NewStringf("#\\%s", s);
Delete(num);
return result;
} else if (SwigType_type(type) == T_STRING) {
#include <ctype.h>
-static const char *usage = (char *) "\
+static const char *usage = "\
\
CHICKEN Options (available with -chicken)\n\
-closprefix <prefix> - Prepend <prefix> to all clos identifiers\n\
\n";
static char *module = 0;
-static char *chicken_path = (char *) "chicken";
+static const char *chicken_path = "chicken";
static int num_methods = 0;
static File *f_begin = 0;
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGCHICKEN\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGCHICKEN\n#define SWIGCHICKEN\n#endif\n\n");
if (no_collection)
Printf(f_runtime, "#define SWIG_CHICKEN_NO_COLLECTION 1\n");
if (in_class)
clos_name = NewString(member_name);
else
- clos_name = chickenNameMapping(scmname, (char *) "");
+ clos_name = chickenNameMapping(scmname, "");
if (!any_specialized_arg) {
method_def = NewString("");
if (in_class)
clos_name = NewString(member_name);
else
- clos_name = chickenNameMapping(scmname, (char *) "");
+ clos_name = chickenNameMapping(scmname, "");
Node *class_node = classLookup(t);
String *clos_code = Getattr(n, "tmap:varin:closcode");
if (in_class)
clos_name = NewString(member_name);
else
- clos_name = chickenNameMapping(scmname, (char *) "");
+ clos_name = chickenNameMapping(scmname, "");
if (GetFlag(n, "feature:constasvar")) {
Printv(clos_methods, "(define ", clos_name, " (", chickenPrimitiveName(scmname), "))\n", NIL);
Printv(scm_const_defs, "(set! ", scmname, " (", scmname, "))\n", NIL);
} else if (in_class)
clos_name = NewString(member_name);
else
- clos_name = chickenNameMapping(scmname, (char *) "");
+ clos_name = chickenNameMapping(scmname, "");
Iterator f;
List *prev = 0;
#include "swigmod.h"
-static const char *usage = (char *) "\
+static const char *usage = "\
CLISP Options (available with -clisp)\n\
-extern-all - Create clisp definitions for all the functions and\n\
global variables otherwise only definitions for\n\
int CLISP::functionWrapper(Node *n) {
is_function = 1;
String *storage = Getattr(n, "storage");
- if (!extern_all_flag && (!storage || (Strcmp(storage, "extern") && Strcmp(storage, "externc"))))
+ if (!extern_all_flag && (!storage || (!Swig_storage_isextern(n) && !Swig_storage_isexternc(n))))
return SWIG_OK;
String *func_name = Getattr(n, "sym:name");
int CLISP::variableWrapper(Node *n) {
is_function = 0;
- // SwigType *type=;
String *storage = Getattr(n, "storage");
- if (!extern_all_flag && (!storage || (Strcmp(storage, "extern") && Strcmp(storage, "externc"))))
+ if (!extern_all_flag && (!storage || (!Swig_storage_isextern(n) && !Swig_storage_isexternc(n))))
return SWIG_OK;
String *var_name = Getattr(n, "sym:name");
}
int CLISP::enumDeclaration(Node *n) {
+ if (getCurrentClass() && (cplus_mode != PUBLIC))
+ return SWIG_NOWRAP;
+
is_function = 0;
String *name = Getattr(n, "sym:name");
return SWIG_OK;
if (Getattr(n, "feature:contract"))
- ret = emit_contract(n, (InClass && !checkAttribute(n, "storage", "static")));
+ ret = emit_contract(n, InClass && !Swig_storage_isstatic(n));
return ret;
}
int Contracts::classDeclaration(Node *n) {
int ret = SWIG_OK;
+ int oldInClass = InClass;
+ Node *oldClass = CurrentClass;
InClass = 1;
CurrentClass = n;
emit_children(n);
- InClass = 0;
- CurrentClass = 0;
+ InClass = oldInClass;
+ CurrentClass = oldClass;
return ret;
}
File *f_init;
File *f_directors;
File *f_directors_h;
+ File *f_single_out;
List *filenames_list;
bool proxy_flag; // Flag for generating proxy classes
String *imclass_class_code; // intermediary class code
String *proxy_class_def;
String *proxy_class_code;
+ String *interface_class_code; // if %feature("interface") was declared for a class, here goes the interface declaration
String *module_class_code;
String *proxy_class_name; // proxy class name
- String *full_proxy_class_name;// fully qualified proxy class name when using nspace feature, otherwise same as proxy_class_name
String *full_imclass_name; // fully qualified intermediary class name when using nspace feature, otherwise same as imclass_name
String *variable_name; //Name of a variable being wrapped
String *proxy_class_constants_code;
String *director_method_types; // Director method types
String *director_connect_parms; // Director delegates parameter list for director connect call
String *destructor_call; //C++ destructor call if any
+ String *output_file; // File name for single file mode. If set all generated code will be written to this file
// Director method stuff:
List *dmethods_seq;
int n_directors;
int first_class_dmethod;
int curr_class_dmethod;
+ int nesting_depth;
enum EnumFeature { SimpleEnum, TypeunsafeEnum, TypesafeEnum, ProperEnum };
f_init(NULL),
f_directors(NULL),
f_directors_h(NULL),
+ f_single_out(NULL),
filenames_list(NULL),
proxy_flag(true),
native_function_flag(false),
imclass_class_code(NULL),
proxy_class_def(NULL),
proxy_class_code(NULL),
+ interface_class_code(NULL),
module_class_code(NULL),
proxy_class_name(NULL),
- full_proxy_class_name(NULL),
full_imclass_name(NULL),
variable_name(NULL),
proxy_class_constants_code(NULL),
director_method_types(NULL),
director_connect_parms(NULL),
destructor_call(NULL),
+ output_file(NULL),
dmethods_seq(NULL),
dmethods_table(NULL),
n_dmethods(0),
n_directors(0),
first_class_dmethod(0),
- curr_class_dmethod(0) {
+ curr_class_dmethod(0),
+ nesting_depth(0){
/* for now, multiple inheritance in directors is disabled, this
should be easy to implement though */
director_multiple_inheritance = 0;
proxyname = Getattr(n, "proxyname");
if (!proxyname) {
String *nspace = Getattr(n, "sym:nspace");
- String *symname = Getattr(n, "sym:name");
+ String *symname = Copy(Getattr(n, "sym:name"));
+ if (symname && !GetFlag(n, "feature:flatnested")) {
+ for (Node *outer_class = Getattr(n, "nested:outer"); outer_class; outer_class = Getattr(outer_class, "nested:outer")) {
+ Push(symname, ".");
+ Push(symname, Getattr(outer_class, "sym:name"));
+ }
+ }
if (nspace) {
if (namespce)
proxyname = NewStringf("%s.%s.%s", namespce, nspace, symname);
}
Setattr(n, "proxyname", proxyname);
Delete(proxyname);
+ Delete(symname);
}
}
}
} else if (strcmp(argv[i], "-oldvarnames") == 0) {
Swig_mark_arg(i);
old_variable_names = true;
+ } else if (strcmp(argv[i], "-outfile") == 0) {
+ if (argv[i + 1]) {
+ output_file = NewString("");
+ Printf(output_file, argv[i + 1]);
+ Swig_mark_arg(i);
+ Swig_mark_arg(i + 1);
+ i++;
+ } else {
+ Swig_arg_error();
+ }
} else if (strcmp(argv[i], "-help") == 0) {
Printf(stdout, "%s\n", usage);
}
SWIG_config_file("csharp.swg");
allow_overloading();
+ Swig_interface_feature_enable();
}
/* ---------------------------------------------------------------------
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGCSHARP\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGCSHARP\n#define SWIGCSHARP\n#endif\n\n");
if (directorsEnabled()) {
Printf(f_runtime, "#define SWIG_DIRECTORS\n");
}
Printf(f_runtime, "\n");
+ if (namespce) {
+ String *wrapper_name = NewStringf("");
+ Printf(wrapper_name, "CSharp_%s_%%f", namespce);
+ Swig_name_register("wrapper", wrapper_name);
+ Delete(wrapper_name);
+ }
+ else {
+ Swig_name_register("wrapper", "CSharp_%f");
+ }
- Swig_name_register("wrapper", "CSharp_%f");
if (old_variable_names) {
Swig_name_register("set", "set_%n%v");
Swig_name_register("get", "get_%n%v");
if (directorsEnabled()) {
// Insert director runtime into the f_runtime file (make it occur before %header section)
+ Swig_insert_file("director_common.swg", f_runtime);
Swig_insert_file("director.swg", f_runtime);
}
// Generate the intermediary class
{
- String *filen = NewStringf("%s%s.cs", SWIG_output_directory(), imclass_name);
- File *f_im = NewFile(filen, "w", SWIG_output_files());
- if (!f_im) {
- FileErrorDisplay(filen);
- SWIG_exit(EXIT_FAILURE);
- }
- Append(filenames_list, Copy(filen));
- Delete(filen);
- filen = NULL;
-
- // Start writing out the intermediary class file
- emitBanner(f_im);
+ File *f_im = getOutputFile(SWIG_output_directory(), imclass_name);
addOpenNamespace(0, f_im);
Printf(f_im, "}\n");
addCloseNamespace(0, f_im);
- Delete(f_im);
+ if (f_im != f_single_out)
+ Delete(f_im);
+ f_im = NULL;
}
// Generate the C# module class
{
- String *filen = NewStringf("%s%s.cs", SWIG_output_directory(), module_class_name);
- File *f_module = NewFile(filen, "w", SWIG_output_files());
- if (!f_module) {
- FileErrorDisplay(filen);
- SWIG_exit(EXIT_FAILURE);
- }
- Append(filenames_list, Copy(filen));
- Delete(filen);
- filen = NULL;
-
- // Start writing out the module class file
- emitBanner(f_module);
+ File *f_module = getOutputFile(SWIG_output_directory(), module_class_name);
addOpenNamespace(0, f_module);
Printf(f_module, "}\n");
addCloseNamespace(0, f_module);
- Delete(f_module);
+ if (f_module != f_single_out)
+ Delete(f_module);
+ f_module = NULL;
}
if (upcasts_code)
f_directors_h = NULL;
}
+ if (f_single_out) {
+ Dump(f_single_out, f_begin);
+ Delete(f_single_out);
+ f_single_out = NULL;
+ }
+
Dump(f_wrappers, f_begin);
Wrapper_pretty_print(f_init, f_begin);
Delete(f_header);
* ----------------------------------------------------------------------------- */
void emitBanner(File *f) {
- Printf(f, "/* ----------------------------------------------------------------------------\n");
- Swig_banner_target_lang(f, " *");
- Printf(f, " * ----------------------------------------------------------------------------- */\n\n");
+ Printf(f, "//------------------------------------------------------------------------------\n");
+ Printf(f, "// <auto-generated />\n");
+ Printf(f, "//\n");
+ Swig_banner_target_lang(f, "//");
+ Printf(f, "//------------------------------------------------------------------------------\n\n");
+ }
+
+ /* -----------------------------------------------------------------------------
+ * getOutputFile()
+ *
+ * Prepares a File object by creating the file in the file system and
+ * writing the banner for auto-generated files to it (emitBanner).
+ * If '-outfile' is provided (single file mode) the supplied parameters will
+ * be ignored and the returned file will always be:
+ * <outdir>/<outfile>
+ * Otherwise the file will be:
+ * <dir>/<name>.cs
+ * ----------------------------------------------------------------------------- */
+
+ File *getOutputFile(const String *dir, const String *name) {
+ if (output_file) {
+ if (!f_single_out) {
+ String *filen = NewStringf("%s%s", SWIG_output_directory(), output_file);
+ f_single_out = NewFile(filen, "w", SWIG_output_files());
+ if (!f_single_out) {
+ FileErrorDisplay(filen);
+ SWIG_exit(EXIT_FAILURE);
+ }
+ Append(filenames_list, Copy(filen));
+ Delete(filen);
+ filen = NULL;
+
+ emitBanner(f_single_out);
+ }
+ return f_single_out;
+ } else {
+ String *filen = NewStringf("%s%s.cs", dir, name);
+ File *f = NewFile(filen, "w", SWIG_output_files());
+ if (!f) {
+ FileErrorDisplay(f);
+ SWIG_exit(EXIT_FAILURE);
+ }
+ Append(filenames_list, Copy(filen));
+ Delete(filen);
+ filen = NULL;
+
+ emitBanner(f);
+ return f;
+ }
}
/*-----------------------------------------------------------------------
String *overloaded_name = getOverloadedName(n);
if (!Getattr(n, "sym:overloaded")) {
- if (!addSymbol(Getattr(n, "sym:name"), n, imclass_name))
+ if (!addSymbol(symname, n, imclass_name))
return SWIG_ERROR;
}
}
}
- Printv(imclass_class_code, "\n [DllImport(\"", dllimport, "\", EntryPoint=\"", wname, "\")]\n", NIL);
+ Printv(imclass_class_code, "\n [global::System.Runtime.InteropServices.DllImport(\"", dllimport, "\", EntryPoint=\"", wname, "\")]\n", NIL);
if (im_outattributes)
Printf(imclass_class_code, " %s\n", im_outattributes);
String *null_attribute = 0;
// Now write code to make the function call
if (!native_function_flag) {
- if (Cmp(nodeType(n), "constant") == 0) {
- // Wrapping a constant hack
- Swig_save("functionWrapper", n, "wrap:action", NIL);
-
- // below based on Swig_VargetToFunction()
- SwigType *ty = Swig_wrapped_var_type(Getattr(n, "type"), use_naturalvar_mode(n));
- Setattr(n, "wrap:action", NewStringf("%s = (%s)(%s);", Swig_cresult_name(), SwigType_lstr(ty, 0), Getattr(n, "value")));
- }
Swig_director_emit_dynamic_cast(n, f);
String *actioncode = emit_action(n);
- if (Cmp(nodeType(n), "constant") == 0)
- Swig_restore(n);
-
/* Return value if necessary */
if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) {
canThrow(n, "out", n);
*/
if (proxy_flag && wrapping_member_flag && !enum_constant_flag) {
// Capitalize the first letter in the variable in the getter/setter function name
- bool getter_flag = Cmp(symname, Swig_name_set(getNSpace(), Swig_name_member(0, proxy_class_name, variable_name))) != 0;
+ bool getter_flag = Cmp(symname, Swig_name_set(getNSpace(), Swig_name_member(0, getClassPrefix(), variable_name))) != 0;
String *getter_setter_name = NewString("");
if (!getter_flag)
return ret;
}
+
+ String *getCurrentScopeName(String *nspace) {
+ String *scope = 0;
+ if (nspace || getCurrentClass()) {
+ scope = NewString("");
+ if (nspace)
+ Printf(scope, "%s", nspace);
+ if (Node *cls = getCurrentClass()) {
+ if (Node *outer = Getattr(cls, "nested:outer")) {
+ String *outerClassesPrefix = Copy(Getattr(outer, "sym:name"));
+ for (outer = Getattr(outer, "nested:outer"); outer != 0; outer = Getattr(outer, "nested:outer")) {
+ Push(outerClassesPrefix, ".");
+ Push(outerClassesPrefix, Getattr(outer, "sym:name"));
+ }
+ Printv(scope, nspace ? "." : "", outerClassesPrefix, ".", proxy_class_name, NIL);
+ Delete(outerClassesPrefix);
+ } else
+ Printv(scope, nspace ? "." : "", proxy_class_name, NIL);
+ }
+ }
+ return scope;
+ }
/* ----------------------------------------------------------------------
* enumDeclaration()
if ((enum_feature != SimpleEnum) && symname && typemap_lookup_type) {
// Wrap (non-anonymous) C/C++ enum within a typesafe, typeunsafe or proper C# enum
- String *scope = 0;
- if (nspace || proxy_class_name) {
- scope = NewString("");
- if (nspace)
- Printf(scope, "%s", nspace);
- if (proxy_class_name)
- Printv(scope, nspace ? "." : "", proxy_class_name, NIL);
- }
+ String *scope = getCurrentScopeName(nspace);
if (!addSymbol(symname, n, scope))
return SWIG_ERROR;
} else {
// Global enums are defined in their own file
String *output_directory = outputDirectory(nspace);
- String *filen = NewStringf("%s%s.cs", output_directory, symname);
- File *f_enum = NewFile(filen, "w", SWIG_output_files());
- if (!f_enum) {
- FileErrorDisplay(filen);
- SWIG_exit(EXIT_FAILURE);
- }
- Append(filenames_list, Copy(filen));
- Delete(filen);
- filen = NULL;
-
- // Start writing out the enum file
- emitBanner(f_enum);
+ File *f_enum = getOutputFile(output_directory, symname);
addOpenNamespace(nspace, f_enum);
"\n", enum_code, "\n", NIL);
addCloseNamespace(nspace, f_enum);
- Delete(f_enum);
+ if (f_enum != f_single_out)
+ Delete(f_enum);
+ f_enum = NULL;
Delete(output_directory);
}
} else {
int unnamedinstance = GetFlag(parent, "unnamedinstance");
String *parent_name = Getattr(parent, "name");
String *nspace = getNSpace();
+ String *newsymname = 0;
String *tmpValue;
// Strange hack from parent method
const char *val = Equal(Getattr(n, "enumvalue"), "true") ? "1" : "0";
Setattr(n, "enumvalue", val);
} else if (swigtype == T_CHAR) {
- String *val = NewStringf("'%s'", Getattr(n, "enumvalue"));
+ String *val = NewStringf("'%(hexescape)s'", Getattr(n, "enumvalue"));
Setattr(n, "enumvalue", val);
Delete(val);
}
{
EnumFeature enum_feature = decodeEnumFeature(parent);
+ if ((enum_feature == SimpleEnum) && GetFlag(parent, "scopedenum")) {
+ newsymname = Swig_name_member(0, Getattr(parent, "sym:name"), symname);
+ symname = newsymname;
+ }
+
// Add to language symbol table
String *scope = 0;
if (unnamedinstance || !parent_name || enum_feature == SimpleEnum) {
- if (proxy_class_name) {
+ String *enumClassPrefix = getEnumClassPrefix();
+ if (enumClassPrefix) {
scope = NewString("");
if (nspace)
Printf(scope, "%s.", nspace);
- Printf(scope, "%s", proxy_class_name);
+ Printf(scope, "%s", enumClassPrefix);
} else {
scope = Copy(module_class_name);
}
} else {
- scope = NewString("");
- if (nspace)
- Printf(scope, "%s.", nspace);
- if (proxy_class_name)
- Printf(scope, "%s.", proxy_class_name);
- Printf(scope, "%s",Getattr(parent, "sym:name"));
+ scope = getCurrentScopeName(nspace);
+ if (!scope)
+ scope = Copy(Getattr(parent, "sym:name"));
+ else
+ Printf(scope, ".%s", Getattr(parent, "sym:name"));
}
- if (!addSymbol(name, n, scope))
+ if (!addSymbol(symname, n, scope))
return SWIG_ERROR;
const String *csattributes = Getattr(n, "feature:cs:attributes");
Delete(scope);
}
+ Delete(newsymname);
Delete(tmpValue);
Swig_restore(n);
return SWIG_OK;
virtual int constantWrapper(Node *n) {
String *symname = Getattr(n, "sym:name");
SwigType *t = Getattr(n, "type");
+ SwigType *valuetype = Getattr(n, "valuetype");
ParmList *l = Getattr(n, "parms");
String *tm;
String *return_type = NewString("");
Swig_warning(WARN_CSHARP_TYPEMAP_CSWTYPE_UNDEF, input_file, line_number, "No cstype typemap defined for %s\n", SwigType_str(t, 0));
}
+ // Default (octal) escaping is no good - change to hex escaped value
+ String *hexescaped_value = Getattr(n, "rawvalue") ? NewStringf("%(hexescape)s", Getattr(n, "rawvalue")) : 0;
// Add the stripped quotes back in
String *new_value = NewString("");
if (SwigType_type(t) == T_STRING) {
- Printf(new_value, "\"%s\"", Copy(Getattr(n, "value")));
+ Printf(new_value, "\"%s\"", hexescaped_value ? hexescaped_value : Copy(Getattr(n, "value")));
Setattr(n, "value", new_value);
} else if (SwigType_type(t) == T_CHAR) {
- Printf(new_value, "\'%s\'", Copy(Getattr(n, "value")));
+ Printf(new_value, "\'%s\'", hexescaped_value ? hexescaped_value : Copy(Getattr(n, "value")));
Setattr(n, "value", new_value);
}
} else {
// Alternative constant handling will use the C syntax to make a true C# constant and hope that it compiles as C# code
if (Getattr(n, "wrappedasconstant")) {
- if (SwigType_type(t) == T_CHAR)
- Printf(constants_code, "\'%s\';\n", Getattr(n, "staticmembervariableHandler:value"));
- else
+ if (SwigType_type(t) == T_CHAR) {
+ if (SwigType_type(valuetype) == T_CHAR)
+ Printf(constants_code, "\'%(hexescape)s\';\n", Getattr(n, "staticmembervariableHandler:value"));
+ else
+ Printf(constants_code, "(char)%s;\n", Getattr(n, "staticmembervariableHandler:value"));
+ } else {
Printf(constants_code, "%s;\n", Getattr(n, "staticmembervariableHandler:value"));
+ }
} else {
Printf(constants_code, "%s;\n", Getattr(n, "value"));
}
}
/* -----------------------------------------------------------------------------
+ * getQualifiedInterfaceName()
+ * ----------------------------------------------------------------------------- */
+
+ String *getQualifiedInterfaceName(Node *n) {
+ String *ret = Getattr(n, "interface:qname");
+ if (!ret) {
+ String *nspace = Getattr(n, "sym:nspace");
+ String *interface_name = Getattr(n, "interface:name");
+ if (nspace) {
+ if (namespce)
+ ret = NewStringf("%s.%s.%s", namespce, nspace, interface_name);
+ else
+ ret = NewStringf("%s.%s", nspace, interface_name);
+ } else {
+ ret = Copy(interface_name);
+ }
+ Setattr(n, "interface:qname", ret);
+ }
+ return ret;
+ }
+
+ /* -----------------------------------------------------------------------------
+ * getInterfaceName()
+ * ----------------------------------------------------------------------------- */
+
+ String *getInterfaceName(SwigType *t, bool qualified) {
+ String *interface_name = NULL;
+ if (proxy_flag) {
+ Node *n = classLookup(t);
+ if (n && Getattr(n, "interface:name"))
+ interface_name = qualified ? getQualifiedInterfaceName(n) : Getattr(n, "interface:name");
+ }
+ return interface_name;
+ }
+
+ /* -----------------------------------------------------------------------------
+ * addInterfaceNameAndUpcasts()
+ * ----------------------------------------------------------------------------- */
+
+ void addInterfaceNameAndUpcasts(SwigType *smart, String *interface_list, String *interface_upcasts, Hash *base_list, String *c_classname) {
+ List *keys = Keys(base_list);
+ for (Iterator it = First(keys); it.item; it = Next(it)) {
+ Node *base = Getattr(base_list, it.item);
+ String *c_baseclass = SwigType_namestr(Getattr(base, "name"));
+ String *interface_name = Getattr(base, "interface:name");
+ if (Len(interface_list))
+ Append(interface_list, ", ");
+ Append(interface_list, interface_name);
+
+ Node *attributes = NewHash();
+ String *interface_code = Copy(typemapLookup(base, "csinterfacecode", Getattr(base, "classtypeobj"), WARN_CSHARP_TYPEMAP_INTERFACECODE_UNDEF, attributes));
+ String *cptr_method_name = 0;
+ if (interface_code) {
+ Replaceall(interface_code, "$interfacename", interface_name);
+ Printv(interface_upcasts, interface_code, NIL);
+ cptr_method_name = Copy(Getattr(attributes, "tmap:csinterfacecode:cptrmethod"));
+ }
+ if (!cptr_method_name)
+ cptr_method_name = NewStringf("%s_GetInterfaceCPtr", interface_name);
+ Replaceall(cptr_method_name, ".", "_");
+ Replaceall(cptr_method_name, "$interfacename", interface_name);
+
+ String *upcast_method_name = Swig_name_member(getNSpace(), proxy_class_name, cptr_method_name);
+ upcastsCode(smart, upcast_method_name, c_classname, c_baseclass);
+
+ Delete(upcast_method_name);
+ Delete(cptr_method_name);
+ Delete(interface_code);
+ Delete(c_baseclass);
+ }
+ Delete(keys);
+ }
+
+ /* -----------------------------------------------------------------------------
+ * upcastsCode()
+ *
+ * Add code for C++ casting to base class
+ * ----------------------------------------------------------------------------- */
+
+ void upcastsCode(SwigType *smart, String *upcast_method_name, String *c_classname, String *c_baseclass) {
+ String *wname = Swig_name_wrapper(upcast_method_name);
+
+ Printv(imclass_cppcasts_code, "\n [global::System.Runtime.InteropServices.DllImport(\"", dllimport, "\", EntryPoint=\"", wname, "\")]\n", NIL);
+ Printf(imclass_cppcasts_code, " public static extern global::System.IntPtr %s(global::System.IntPtr jarg1);\n", upcast_method_name);
+
+ Replaceall(imclass_cppcasts_code, "$csclassname", proxy_class_name);
+
+ if (smart) {
+ SwigType *bsmart = Copy(smart);
+ SwigType *rclassname = SwigType_typedef_resolve_all(c_classname);
+ SwigType *rbaseclass = SwigType_typedef_resolve_all(c_baseclass);
+ Replaceall(bsmart, rclassname, rbaseclass);
+ Delete(rclassname);
+ Delete(rbaseclass);
+ String *smartnamestr = SwigType_namestr(smart);
+ String *bsmartnamestr = SwigType_namestr(bsmart);
+ Printv(upcasts_code,
+ "SWIGEXPORT ", bsmartnamestr, " * SWIGSTDCALL ", wname, "(", smartnamestr, " *jarg1) {\n",
+ " return jarg1 ? new ", bsmartnamestr, "(*jarg1) : 0;\n"
+ "}\n", "\n", NIL);
+ Delete(bsmartnamestr);
+ Delete(smartnamestr);
+ Delete(bsmart);
+ } else {
+ Printv(upcasts_code,
+ "SWIGEXPORT ", c_baseclass, " * SWIGSTDCALL ", wname, "(", c_classname, " *jarg1) {\n",
+ " return (", c_baseclass, " *)jarg1;\n"
+ "}\n", "\n", NIL);
+ }
+ Delete(wname);
+ }
+
+ /* -----------------------------------------------------------------------------
* emitProxyClassDefAndCPPCasts()
* ----------------------------------------------------------------------------- */
String *c_baseclass = NULL;
String *baseclass = NULL;
String *c_baseclassname = NULL;
+ String *interface_list = NewStringEmpty();
+ String *interface_upcasts = NewStringEmpty();
SwigType *typemap_lookup_type = Getattr(n, "classtypeobj");
bool feature_director = Swig_directorclass(n) ? true : false;
+ bool has_outerclass = Getattr(n, "nested:outer") != 0 && !GetFlag(n, "feature:flatnested");
+ SwigType *smart = Swig_cparse_smartptr(n);
// Inheritance from pure C# classes
Node *attributes = NewHash();
if (!purebase_replace) {
List *baselist = Getattr(n, "bases");
if (baselist) {
- Iterator base = First(baselist);
- while (base.item && GetFlag(base.item, "feature:ignore")) {
- base = Next(base);
- }
- if (base.item) {
- c_baseclassname = Getattr(base.item, "name");
- baseclass = Copy(getProxyName(c_baseclassname));
- if (baseclass)
- c_baseclass = SwigType_namestr(Getattr(base.item, "name"));
- base = Next(base);
- /* Warn about multiple inheritance for additional base class(es) */
- while (base.item) {
- if (GetFlag(base.item, "feature:ignore")) {
- base = Next(base);
- continue;
- }
- String *proxyclassname = Getattr(n, "classtypeobj");
- String *baseclassname = Getattr(base.item, "name");
- Swig_warning(WARN_CSHARP_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
- "Warning for %s proxy: Base %s ignored. Multiple inheritance is not supported in Java.\n", SwigType_namestr(proxyclassname), SwigType_namestr(baseclassname));
- base = Next(base);
- }
- }
+ Iterator base = First(baselist);
+ while (base.item) {
+ if (!(GetFlag(base.item, "feature:ignore") || Getattr(base.item, "feature:interface"))) {
+ String *baseclassname = Getattr(base.item, "name");
+ if (!c_baseclassname) {
+ c_baseclassname = baseclassname;
+ baseclass = Copy(getProxyName(baseclassname));
+ if (baseclass)
+ c_baseclass = SwigType_namestr(baseclassname);
+ } else {
+ /* Warn about multiple inheritance for additional base class(es) */
+ String *proxyclassname = Getattr(n, "classtypeobj");
+ Swig_warning(WARN_CSHARP_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
+ "Warning for %s, base %s ignored. Multiple inheritance is not supported in C#.\n", SwigType_namestr(proxyclassname), SwigType_namestr(baseclassname));
+ }
+ }
+ base = Next(base);
+ }
}
}
+ Hash *interface_bases = Getattr(n, "interface:bases");
+ if (interface_bases)
+ addInterfaceNameAndUpcasts(smart, interface_list, interface_upcasts, interface_bases, c_classname);
bool derived = baseclass && getProxyName(c_baseclassname);
if (derived && purebase_notderived)
Swig_error(Getfile(n), Getline(n), "The csbase typemap for proxy %s must contain just one of the 'replace' or 'notderived' attributes.\n", typemap_lookup_type);
} else if (Len(pure_baseclass) > 0 && Len(baseclass) > 0) {
Swig_warning(WARN_CSHARP_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
- "Warning for %s proxy: Base %s ignored. Multiple inheritance is not supported in C#. "
+ "Warning for %s, base %s ignored. Multiple inheritance is not supported in C#. "
"Perhaps you need one of the 'replace' or 'notderived' attributes in the csbase typemap?\n", typemap_lookup_type, pure_baseclass);
}
// Pure C# interfaces
const String *pure_interfaces = typemapLookup(n, derived ? "csinterfaces_derived" : "csinterfaces", typemap_lookup_type, WARN_NONE);
+ if (*Char(interface_list) && *Char(pure_interfaces))
+ Append(interface_list, ", ");
+ Append(interface_list, pure_interfaces);
// Start writing the proxy class
- Printv(proxy_class_def, typemapLookup(n, "csimports", typemap_lookup_type, WARN_NONE), // Import statements
+ if (!has_outerclass)
+ Printv(proxy_class_def, typemapLookup(n, "csimports", typemap_lookup_type, WARN_NONE), // Import statements
"\n", NIL);
// Class attributes
Printv(proxy_class_def, typemapLookup(n, "csclassmodifiers", typemap_lookup_type, WARN_CSHARP_TYPEMAP_CLASSMOD_UNDEF), // Class modifiers
" $csclassname", // Class name and base class
- (*Char(wanted_base) || *Char(pure_interfaces)) ? " : " : "", wanted_base, (*Char(wanted_base) && *Char(pure_interfaces)) ? // Interfaces
- ", " : "", pure_interfaces, " {", derived ? typemapLookup(n, "csbody_derived", typemap_lookup_type, WARN_CSHARP_TYPEMAP_CSBODY_UNDEF) : // main body of class
+ (*Char(wanted_base) || *Char(interface_list)) ? " : " : "", wanted_base, (*Char(wanted_base) && *Char(interface_list)) ? // Interfaces
+ ", " : "", interface_list, " {", derived ? typemapLookup(n, "csbody_derived", typemap_lookup_type, WARN_CSHARP_TYPEMAP_CSBODY_UNDEF) : // main body of class
typemapLookup(n, "csbody", typemap_lookup_type, WARN_CSHARP_TYPEMAP_CSBODY_UNDEF), // main body of class
NIL);
if (*Char(destructor_call))
Replaceall(destruct, "$imcall", destructor_call);
else
- Replaceall(destruct, "$imcall", "throw new MethodAccessException(\"C++ destructor does not have public access\")");
+ Replaceall(destruct, "$imcall", "throw new global::System.MethodAccessException(\"C++ destructor does not have public access\")");
if (*Char(destruct))
Printv(proxy_class_def, "\n ", destruct_methodmodifiers, " ", derived ? "override" : "virtual", " void ", destruct_methodname, "() ", destruct, "\n",
NIL);
}
+ if (*Char(interface_upcasts))
+ Printv(proxy_class_def, interface_upcasts, NIL);
if (feature_director) {
// Generate director connect method
Printf(proxy_class_code, " if (SwigDerivedClassHasMethod(\"%s\", swigMethodTypes%s))\n", method, methid);
Printf(proxy_class_code, " swigDelegate%s = new SwigDelegate%s_%s(SwigDirector%s);\n", methid, proxy_class_name, methid, overname);
}
- String *director_connect_method_name = Swig_name_member(getNSpace(), proxy_class_name, "director_connect");
+ String *director_connect_method_name = Swig_name_member(getNSpace(), getClassPrefix(), "director_connect");
Printf(proxy_class_code, " %s.%s(swigCPtr", imclass_name, director_connect_method_name);
for (i = first_class_dmethod; i < curr_class_dmethod; ++i) {
UpcallData *udata = Getitem(dmethods_seq, i);
if (first_class_dmethod < curr_class_dmethod) {
// Only emit if there is at least one director method
Printf(proxy_class_code, "\n");
- Printf(proxy_class_code, " private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes) {\n");
+ Printf(proxy_class_code, " private bool SwigDerivedClassHasMethod(string methodName, global::System.Type[] methodTypes) {\n");
Printf(proxy_class_code,
- " System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, methodTypes, null);\n");
+ " global::System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance, null, methodTypes, null);\n");
Printf(proxy_class_code, " bool hasDerivedMethod = methodInfo.DeclaringType.IsSubclassOf(typeof(%s));\n", proxy_class_name);
/* Could add this code to cover corner case where the GetMethod() returns a method which allows type
* promotion, eg it will return foo(double), if looking for foo(int).
Delete(director_connect_method_name);
}
+ Delete(interface_upcasts);
+ Delete(interface_list);
Delete(attributes);
Delete(destruct);
Printv(proxy_class_def, typemapLookup(n, "cscode", typemap_lookup_type, WARN_NONE), // extra C# code
"\n", NIL);
- // Add code to do C++ casting to base class (only for classes in an inheritance hierarchy)
if (derived) {
- String *smartptr = Getattr(n, "feature:smartptr");
- String *upcast_method = Swig_name_member(getNSpace(), proxy_class_name, smartptr != 0 ? "SWIGSmartPtrUpcast" : "SWIGUpcast");
- String *wname = Swig_name_wrapper(upcast_method);
-
- Printv(imclass_cppcasts_code, "\n [DllImport(\"", dllimport, "\", EntryPoint=\"", wname, "\")]\n", NIL);
- Printf(imclass_cppcasts_code, " public static extern IntPtr %s(IntPtr jarg1);\n", upcast_method);
-
- Replaceall(imclass_cppcasts_code, "$csclassname", proxy_class_name);
-
- if (smartptr) {
- SwigType *spt = Swig_cparse_type(smartptr);
- if (spt) {
- SwigType *smart = SwigType_typedef_resolve_all(spt);
- Delete(spt);
- SwigType *bsmart = Copy(smart);
- SwigType *rclassname = SwigType_typedef_resolve_all(c_classname);
- SwigType *rbaseclass = SwigType_typedef_resolve_all(c_baseclass);
- Replaceall(bsmart, rclassname, rbaseclass);
- Delete(rclassname);
- Delete(rbaseclass);
- String *smartnamestr = SwigType_namestr(smart);
- String *bsmartnamestr = SwigType_namestr(bsmart);
- Printv(upcasts_code,
- "SWIGEXPORT ", bsmartnamestr, " * SWIGSTDCALL ", wname, "(", smartnamestr, " *jarg1) {\n",
- " return jarg1 ? new ", bsmartnamestr, "(*jarg1) : 0;\n"
- "}\n", "\n", NIL);
- Delete(bsmartnamestr);
- Delete(smartnamestr);
- Delete(bsmart);
- } else {
- Swig_error(Getfile(n), Getline(n), "Invalid type (%s) in 'smartptr' feature for class %s.\n", smartptr, c_classname);
+ String *upcast_method_name = Swig_name_member(getNSpace(), getClassPrefix(), smart != 0 ? "SWIGSmartPtrUpcast" : "SWIGUpcast");
+ upcastsCode(smart, upcast_method_name, c_classname, c_baseclass);
+ Delete(upcast_method_name);
+ }
+
+ Delete(smart);
+ Delete(baseclass);
+ }
+
+ /* ----------------------------------------------------------------------
+ * emitInterfaceDeclaration()
+ * ---------------------------------------------------------------------- */
+
+ void emitInterfaceDeclaration(Node *n, String *interface_name, File *f_interface) {
+ Printv(f_interface, typemapLookup(n, "csimports", Getattr(n, "classtypeobj"), WARN_NONE), "\n", NIL);
+ Printf(f_interface, "public interface %s", interface_name);
+ if (List *baselist = Getattr(n, "bases")) {
+ String *bases = 0;
+ for (Iterator base = First(baselist); base.item; base = Next(base)) {
+ if (GetFlag(base.item, "feature:ignore") || !Getattr(base.item, "feature:interface"))
+ continue; // TODO: warn about skipped non-interface bases
+ String *base_iname = Getattr(base.item, "interface:name");
+ if (!bases)
+ bases = NewStringf(" : %s", base_iname);
+ else {
+ Append(bases, ", ");
+ Append(bases, base_iname);
}
- } else {
- Printv(upcasts_code,
- "SWIGEXPORT ", c_baseclass, " * SWIGSTDCALL ", wname, "(", c_classname, " *jarg1) {\n",
- " return (", c_baseclass, " *)jarg1;\n"
- "}\n", "\n", NIL);
}
- Delete(wname);
- Delete(upcast_method);
+ if (bases) {
+ Printv(f_interface, bases, NIL);
+ Delete(bases);
+ }
+ }
+ Printf(f_interface, " {\n");
+
+ Node *attributes = NewHash();
+ String *interface_code = Copy(typemapLookup(n, "csinterfacecode", Getattr(n, "classtypeobj"), WARN_CSHARP_TYPEMAP_INTERFACECODE_UNDEF, attributes));
+ if (interface_code) {
+ String *interface_declaration = Copy(Getattr(attributes, "tmap:csinterfacecode:declaration"));
+ if (interface_declaration) {
+ Replaceall(interface_declaration, "$interfacename", interface_name);
+ Printv(f_interface, interface_declaration, NIL);
+ Delete(interface_declaration);
+ }
+ Delete(interface_code);
}
- Delete(baseclass);
+ }
+
+ /* ----------------------------------------------------------------------
+ * calculateDirectBase()
+ * ---------------------------------------------------------------------- */
+
+ void calculateDirectBase(Node* n) {
+ Node* direct_base = 0;
+ // C++ inheritance
+ Node *attributes = NewHash();
+ SwigType *typemap_lookup_type = Getattr(n, "classtypeobj");
+ const String *pure_baseclass = typemapLookup(n, "csbase", typemap_lookup_type, WARN_NONE, attributes);
+ bool purebase_replace = GetFlag(attributes, "tmap:csbase:replace") ? true : false;
+ bool purebase_notderived = GetFlag(attributes, "tmap:csbase:notderived") ? true : false;
+ Delete(attributes);
+ if (!purebase_replace) {
+ if (List *baselist = Getattr(n, "bases")) {
+ Iterator base = First(baselist);
+ while (base.item && (GetFlag(base.item, "feature:ignore") || Getattr(base.item, "feature:interface")))
+ base = Next(base);
+ direct_base = base.item;
+ }
+ if (!direct_base && purebase_notderived)
+ direct_base = symbolLookup(const_cast<String*>(pure_baseclass));
+ } else {
+ direct_base = symbolLookup(const_cast<String*>(pure_baseclass));
+ }
+ Setattr(n, "direct_base", direct_base);
}
/* ----------------------------------------------------------------------
* ---------------------------------------------------------------------- */
virtual int classHandler(Node *n) {
-
String *nspace = getNSpace();
File *f_proxy = NULL;
+ File *f_interface = NULL;
+ // save class local variables
+ String *old_proxy_class_name = proxy_class_name;
+ String *old_full_imclass_name = full_imclass_name;
+ String *old_destructor_call = destructor_call;
+ String *old_proxy_class_constants_code = proxy_class_constants_code;
+ String *old_proxy_class_def = proxy_class_def;
+ String *old_proxy_class_code = proxy_class_code;
+ bool has_outerclass = Getattr(n, "nested:outer") && !GetFlag(n, "feature:flatnested");
+ String *old_interface_class_code = interface_class_code;
+ interface_class_code = 0;
+
if (proxy_flag) {
proxy_class_name = NewString(Getattr(n, "sym:name"));
+ String *interface_name = Getattr(n, "feature:interface") ? Getattr(n, "interface:name") : 0;
+ if (Node *outer = Getattr(n, "nested:outer")) {
+ String *outerClassesPrefix = Copy(Getattr(outer, "sym:name"));
+ for (outer = Getattr(outer, "nested:outer"); outer != 0; outer = Getattr(outer, "nested:outer")) {
+ Push(outerClassesPrefix, ".");
+ Push(outerClassesPrefix, Getattr(outer, "sym:name"));
+ }
+ String *fnspace = nspace ? NewStringf("%s.%s", nspace, outerClassesPrefix) : outerClassesPrefix;
+ if (!addSymbol(proxy_class_name, n, fnspace))
+ return SWIG_ERROR;
+ if (interface_name && !addInterfaceSymbol(interface_name, n, fnspace))
+ return SWIG_ERROR;
+ if (nspace)
+ Delete(fnspace);
+ Delete(outerClassesPrefix);
+ } else {
+ if (!addSymbol(proxy_class_name, n, nspace))
+ return SWIG_ERROR;
+ if (interface_name && !addInterfaceSymbol(interface_name, n, nspace))
+ return SWIG_ERROR;
+ }
if (!nspace) {
- full_proxy_class_name = NewStringf("%s", proxy_class_name);
full_imclass_name = NewStringf("%s", imclass_name);
if (Cmp(proxy_class_name, imclass_name) == 0) {
Printf(stderr, "Class name cannot be equal to intermediary class name: %s\n", proxy_class_name);
}
} else {
if (namespce) {
- full_proxy_class_name = NewStringf("%s.%s.%s", namespce, nspace, proxy_class_name);
full_imclass_name = NewStringf("%s.%s", namespce, imclass_name);
} else {
- full_proxy_class_name = NewStringf("%s.%s", nspace, proxy_class_name);
full_imclass_name = NewStringf("%s", imclass_name);
}
}
- if (!addSymbol(proxy_class_name, n, nspace))
- return SWIG_ERROR;
+ if (!has_outerclass) {
+ String *output_directory = outputDirectory(nspace);
+ f_proxy = getOutputFile(output_directory, proxy_class_name);
- String *output_directory = outputDirectory(nspace);
- String *filen = NewStringf("%s%s.cs", output_directory, proxy_class_name);
- f_proxy = NewFile(filen, "w", SWIG_output_files());
- if (!f_proxy) {
- FileErrorDisplay(filen);
- SWIG_exit(EXIT_FAILURE);
+ addOpenNamespace(nspace, f_proxy);
+ Delete(output_directory);
}
- Append(filenames_list, Copy(filen));
- Delete(filen);
- filen = NULL;
-
- // Start writing out the proxy class file
- emitBanner(f_proxy);
-
- addOpenNamespace(nspace, f_proxy);
-
- Clear(proxy_class_def);
- Clear(proxy_class_code);
+ else
+ ++nesting_depth;
+ proxy_class_def = NewString("");
+ proxy_class_code = NewString("");
destructor_call = NewString("");
proxy_class_constants_code = NewString("");
+
+ if (Getattr(n, "feature:interface")) {
+ interface_class_code = NewString("");
+ String *output_directory = outputDirectory(nspace);
+ f_interface = getOutputFile(output_directory, interface_name);
+ addOpenNamespace(nspace, f_interface);
+ emitInterfaceDeclaration(n, interface_name, interface_class_code);
+ Delete(output_directory);
+ }
+ calculateDirectBase(n);
}
Language::classHandler(n);
emitProxyClassDefAndCPPCasts(n);
- String *csclazzname = Swig_name_member(getNSpace(), proxy_class_name, ""); // mangled full proxy class name
+ String *csclazzname = Swig_name_member(getNSpace(), getClassPrefix(), ""); // mangled full proxy class name
Replaceall(proxy_class_def, "$csclassname", proxy_class_name);
Replaceall(proxy_class_code, "$csclassname", proxy_class_name);
Replaceall(proxy_class_constants_code, "$csclassname", proxy_class_name);
+ Replaceall(interface_class_code, "$csclassname", proxy_class_name);
Replaceall(proxy_class_def, "$csclazzname", csclazzname);
Replaceall(proxy_class_code, "$csclazzname", csclazzname);
Replaceall(proxy_class_constants_code, "$csclazzname", csclazzname);
+ Replaceall(interface_class_code, "$csclazzname", csclazzname);
Replaceall(proxy_class_def, "$module", module_class_name);
Replaceall(proxy_class_code, "$module", module_class_name);
Replaceall(proxy_class_constants_code, "$module", module_class_name);
+ Replaceall(interface_class_code, "$module", module_class_name);
Replaceall(proxy_class_def, "$imclassname", full_imclass_name);
Replaceall(proxy_class_code, "$imclassname", full_imclass_name);
Replaceall(proxy_class_constants_code, "$imclassname", full_imclass_name);
+ Replaceall(interface_class_code, "$imclassname", full_imclass_name);
Replaceall(proxy_class_def, "$dllimport", dllimport);
Replaceall(proxy_class_code, "$dllimport", dllimport);
Replaceall(proxy_class_constants_code, "$dllimport", dllimport);
-
- Printv(f_proxy, proxy_class_def, proxy_class_code, NIL);
+ Replaceall(interface_class_code, "$dllimport", dllimport);
+
+ if (!has_outerclass)
+ Printv(f_proxy, proxy_class_def, proxy_class_code, NIL);
+ else {
+ Swig_offset_string(proxy_class_def, nesting_depth);
+ Append(old_proxy_class_code, proxy_class_def);
+ Swig_offset_string(proxy_class_code, nesting_depth);
+ Append(old_proxy_class_code, proxy_class_code);
+ }
// Write out all the constants
- if (Len(proxy_class_constants_code) != 0)
- Printv(f_proxy, proxy_class_constants_code, NIL);
-
- Printf(f_proxy, "}\n");
- addCloseNamespace(nspace, f_proxy);
- Delete(f_proxy);
- f_proxy = NULL;
+ if (Len(proxy_class_constants_code) != 0) {
+ if (!has_outerclass)
+ Printv(f_proxy, proxy_class_constants_code, NIL);
+ else {
+ Swig_offset_string(proxy_class_constants_code, nesting_depth);
+ Append(old_proxy_class_code, proxy_class_constants_code);
+ }
+ }
+ if (!has_outerclass) {
+ Printf(f_proxy, "}\n");
+ addCloseNamespace(nspace, f_proxy);
+ if (f_proxy != f_single_out)
+ Delete(f_proxy);
+ f_proxy = NULL;
+ } else {
+ for (int i = 0; i < nesting_depth; ++i)
+ Append(old_proxy_class_code, " ");
+ Append(old_proxy_class_code, "}\n\n");
+ --nesting_depth;
+ }
/* Output the downcast method, if necessary. Note: There's no other really
good place to put this code, since Abstract Base Classes (ABCs) can and should have
downcasts, making the constructorHandler() a bad place (because ABCs don't get to
have constructors emitted.) */
- if (GetFlag(n, "feature:javadowncast")) {
+ if (GetFlag(n, "feature:csdowncast")) {
String *downcast_method = Swig_name_member(getNSpace(), proxy_class_name, "SWIGDowncast");
String *wname = Swig_name_wrapper(downcast_method);
Delete(downcast_method);
}
+ if (f_interface) {
+ Printv(f_interface, interface_class_code, "}\n", NIL);
+ addCloseNamespace(nspace, f_interface);
+ if (f_interface != f_single_out)
+ Delete(f_interface);
+ f_interface = 0;
+ }
+
emitDirectorExtraMethods(n);
+ Delete(interface_class_code);
+ interface_class_code = old_interface_class_code;
Delete(csclazzname);
Delete(proxy_class_name);
- proxy_class_name = NULL;
- Delete(full_proxy_class_name);
- full_proxy_class_name = NULL;
+ proxy_class_name = old_proxy_class_name;
Delete(full_imclass_name);
- full_imclass_name = NULL;
+ full_imclass_name = old_full_imclass_name;
Delete(destructor_call);
- destructor_call = NULL;
+ destructor_call = old_destructor_call;
Delete(proxy_class_constants_code);
- proxy_class_constants_code = NULL;
+ proxy_class_constants_code = old_proxy_class_constants_code;
+ Delete(proxy_class_def);
+ proxy_class_def = old_proxy_class_def;
+ Delete(proxy_class_code);
+ proxy_class_code = old_proxy_class_code;
}
-
return SWIG_OK;
}
if (proxy_flag) {
String *overloaded_name = getOverloadedName(n);
- String *intermediary_function_name = Swig_name_member(getNSpace(), proxy_class_name, overloaded_name);
+ String *intermediary_function_name = Swig_name_member(getNSpace(), getClassPrefix(), overloaded_name);
Setattr(n, "proxyfuncname", Getattr(n, "sym:name"));
Setattr(n, "imfuncname", intermediary_function_name);
proxyClassFunctionHandler(n);
if (proxy_flag) {
String *overloaded_name = getOverloadedName(n);
- String *intermediary_function_name = Swig_name_member(getNSpace(), proxy_class_name, overloaded_name);
+ String *intermediary_function_name = Swig_name_member(getNSpace(), getClassPrefix(), overloaded_name);
Setattr(n, "proxyfuncname", Getattr(n, "sym:name"));
Setattr(n, "imfuncname", intermediary_function_name);
proxyClassFunctionHandler(n);
String *pre_code = NewString("");
String *post_code = NewString("");
String *terminator_code = NewString("");
+ bool is_interface = Getattr(parentNode(n), "feature:interface") != 0
+ && !static_flag && Getattr(n, "interface:owner") == 0;
if (!proxy_flag)
return;
if (wrapping_member_flag && !enum_constant_flag) {
// Properties
- setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(getNSpace(), Swig_name_member(0, proxy_class_name, variable_name))) == 0);
+ setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(getNSpace(), Swig_name_member(0, getClassPrefix(), variable_name))) == 0);
if (setter_flag)
Swig_typemap_attach_parms("csvarin", l, NULL);
}
Printf(function_code, " %s ", methodmods);
if (!is_smart_pointer()) {
// Smart pointer classes do not mirror the inheritance hierarchy of the underlying pointer type, so no virtual/override/new required.
- if (Getattr(n, "override"))
- Printf(function_code, "override ");
+ if (Node *base_ovr = Getattr(n, "override")) {
+ if (GetFlag(n, "isextendmember"))
+ Printf(function_code, "override ");
+ else {
+ Node* base = parentNode(base_ovr);
+ bool ovr = false;
+ for (Node* direct_base = Getattr(parentNode(n), "direct_base"); direct_base; direct_base = Getattr(direct_base, "direct_base")) {
+ if (direct_base == base) { // "override" only applies if the base was not discarded (e.g. in case of multiple inheritance or via "ignore")
+ ovr = true;
+ break;
+ }
+ }
+ Printf(function_code, ovr ? "override " : "virtual ");
+ }
+ }
else if (checkAttribute(n, "storage", "virtual"))
Printf(function_code, "virtual ");
if (Getattr(n, "hides"))
if (static_flag)
Printf(function_code, "static ");
Printf(function_code, "%s %s(", return_type, proxy_function_name);
+ if (is_interface)
+ Printf(interface_class_code, " %s %s(", return_type, proxy_function_name);
+
Printv(imcall, full_imclass_name, ".$imfuncname(", NIL);
if (!static_flag)
}
/* Add parameter to proxy function */
- if (gencomma >= 2)
+ if (gencomma >= 2) {
Printf(function_code, ", ");
+ if (is_interface)
+ Printf(interface_class_code, ", ");
+ }
gencomma = 2;
Printf(function_code, "%s %s", param_type, arg);
+ if (is_interface)
+ Printf(interface_class_code, "%s %s", param_type, arg);
Delete(arg);
Delete(param_type);
Printf(imcall, ")");
Printf(function_code, ")");
+ if (is_interface)
+ Printf(interface_class_code, ");\n");
// Transform return type used in PInvoke function (in intermediary class) to type used in C# wrapper function (in proxy class)
if ((tm = Swig_typemap_lookup("csout", n, "", 0))) {
Node *explicit_n = Getattr(n, "explicitcallnode");
if (explicit_n) {
String *ex_overloaded_name = getOverloadedName(explicit_n);
- String *ex_intermediary_function_name = Swig_name_member(getNSpace(), proxy_class_name, ex_overloaded_name);
+ String *ex_intermediary_function_name = Swig_name_member(getNSpace(), getClassPrefix(), ex_overloaded_name);
String *ex_imcall = Copy(imcall);
Replaceall(ex_imcall, "$imfuncname", ex_intermediary_function_name);
// Use the C syntax to make a true C# constant and hope that it compiles as C# code
value = Getattr(n, "enumvalue") ? Copy(Getattr(n, "enumvalue")) : Copy(Getattr(n, "enumvalueex"));
} else {
+ String *newsymname = 0;
+ if (!getCurrentClass() || !proxy_flag) {
+ String *enumClassPrefix = getEnumClassPrefix();
+ if (enumClassPrefix) {
+ // A global scoped enum
+ newsymname = Swig_name_member(0, enumClassPrefix, symname);
+ symname = newsymname;
+ }
+ }
+
// Get the enumvalue from a PINVOKE call
if (!getCurrentClass() || !cparse_cplusplus || !proxy_flag) {
// Strange hack to change the name
value = NewStringf("%s.%s()", full_imclass_name ? full_imclass_name : imclass_name, Swig_name_get(getNSpace(), symname));
} else {
memberconstantHandler(n);
- value = NewStringf("%s.%s()", full_imclass_name ? full_imclass_name : imclass_name, Swig_name_get(getNSpace(), Swig_name_member(0, proxy_class_name, symname)));
+ value = NewStringf("%s.%s()", full_imclass_name ? full_imclass_name : imclass_name, Swig_name_get(getNSpace(), Swig_name_member(0, getEnumClassPrefix(), symname)));
}
}
}
substitution_performed = true;
Delete(classnametype);
}
+ if (Strstr(tm, "$csinterfacename")) {
+ SwigType *interfacenametype = Copy(strippedtype);
+ substituteInterfacenameSpecialVariable(interfacenametype, tm, "$csinterfacename", true);
+ substitution_performed = true;
+ Delete(interfacenametype);
+ }
+ if (Strstr(tm, "$*csinterfacename")) {
+ SwigType *interfacenametype = Copy(strippedtype);
+ Delete(SwigType_pop(interfacenametype));
+ if (Len(interfacenametype) > 0) {
+ substituteInterfacenameSpecialVariable(interfacenametype, tm, "$*csinterfacename", true);
+ substitution_performed = true;
+ }
+ Delete(interfacenametype);
+ }
+ if (Strstr(tm, "$&csinterfacename")) {
+ SwigType *interfacenametype = Copy(strippedtype);
+ SwigType_add_pointer(interfacenametype);
+ substituteInterfacenameSpecialVariable(interfacenametype, tm, "$&csinterfacename", true);
+ substitution_performed = true;
+ Delete(interfacenametype);
+ }
+ if (Strstr(tm, "$interfacename")) {
+ SwigType *interfacenametype = Copy(strippedtype);
+ substituteInterfacenameSpecialVariable(interfacenametype, tm, "$interfacename", false);
+ substitution_performed = true;
+ Delete(interfacenametype);
+ }
+ if (Strstr(tm, "$*interfacename")) {
+ SwigType *interfacenametype = Copy(strippedtype);
+ Delete(SwigType_pop(interfacenametype));
+ if (Len(interfacenametype) > 0) {
+ substituteInterfacenameSpecialVariable(interfacenametype, tm, "$*interfacename", false);
+ substitution_performed = true;
+ }
+ Delete(interfacenametype);
+ }
+ if (Strstr(tm, "$&interfacename")) {
+ SwigType *interfacenametype = Copy(strippedtype);
+ SwigType_add_pointer(interfacenametype);
+ substituteInterfacenameSpecialVariable(interfacenametype, tm, "$&interfacename", false);
+ substitution_performed = true;
+ Delete(interfacenametype);
+ }
Delete(strippedtype);
Delete(type);
* ----------------------------------------------------------------------------- */
void substituteClassnameSpecialVariable(SwigType *classnametype, String *tm, const char *classnamespecialvariable) {
+ String *replacementname;
if (SwigType_isenum(classnametype)) {
String *enumname = getEnumName(classnametype);
- if (enumname)
- Replaceall(tm, classnamespecialvariable, enumname);
- else
- Replaceall(tm, classnamespecialvariable, NewStringf("int"));
+ if (enumname) {
+ replacementname = Copy(enumname);
+ } else {
+ bool anonymous_enum = (Cmp(classnametype, "enum ") == 0);
+ if (anonymous_enum) {
+ replacementname = NewString("int");
+ } else {
+ // An unknown enum - one that has not been parsed (neither a C enum forward reference nor a definition) or an ignored enum
+ replacementname = NewStringf("SWIGTYPE%s", SwigType_manglestr(classnametype));
+ Replace(replacementname, "enum ", "", DOH_REPLACE_ANY);
+ Setattr(swig_types_hash, replacementname, classnametype);
+ }
+ }
} else {
- String *classname = getProxyName(classnametype);
+ String *classname = getProxyName(classnametype); // getProxyName() works for pointers to classes too
if (classname) {
- Replaceall(tm, classnamespecialvariable, classname); // getProxyName() works for pointers to classes too
- } else { // use $descriptor if SWIG does not know anything about this type. Note that any typedefs are resolved.
- String *descriptor = NewStringf("SWIGTYPE%s", SwigType_manglestr(classnametype));
- Replaceall(tm, classnamespecialvariable, descriptor);
+ replacementname = Copy(classname);
+ } else {
+ // use $descriptor if SWIG does not know anything about this type. Note that any typedefs are resolved.
+ replacementname = NewStringf("SWIGTYPE%s", SwigType_manglestr(classnametype));
// Add to hash table so that the type wrapper classes can be created later
- Setattr(swig_types_hash, descriptor, classnametype);
- Delete(descriptor);
+ Setattr(swig_types_hash, replacementname, classnametype);
}
}
+ Replaceall(tm, classnamespecialvariable, replacementname);
+
+ Delete(replacementname);
}
/* -----------------------------------------------------------------------------
- * makeParameterName()
- *
- * Inputs:
- * n - Node
- * p - parameter node
- * arg_num - parameter argument number
- * setter - set this flag when wrapping variables
- * Return:
- * arg - a unique parameter name
+ * substituteInterfacenameSpecialVariable()
* ----------------------------------------------------------------------------- */
- String *makeParameterName(Node *n, Parm *p, int arg_num, bool setter) {
+ void substituteInterfacenameSpecialVariable(SwigType *interfacenametype, String *tm, const char *interfacenamespecialvariable, bool qualified) {
- String *arg = 0;
- String *pn = Getattr(p, "name");
-
- // Use C parameter name unless it is a duplicate or an empty parameter name
- int count = 0;
- ParmList *plist = Getattr(n, "parms");
- while (plist) {
- if ((Cmp(pn, Getattr(plist, "name")) == 0))
- count++;
- plist = nextSibling(plist);
+ String *interfacename = getInterfaceName(interfacenametype, qualified);
+ if (interfacename) {
+ String *replacementname = Copy(interfacename);
+ Replaceall(tm, interfacenamespecialvariable, replacementname);
+ Delete(replacementname);
}
- String *wrn = pn ? Swig_name_warning(p, 0, pn, 0) : 0;
- arg = (!pn || (count > 1) || wrn) ? NewStringf("arg%d", arg_num) : Copy(pn);
-
- if (setter && Cmp(arg, "self") != 0) {
- // Note that in C# properties, the input variable name is always called 'value'
- Delete(arg);
- arg = NewString("value");
- }
-
- return arg;
}
/* -----------------------------------------------------------------------------
Setline(n, line_number);
String *swigtype = NewString("");
- String *filen = NewStringf("%s%s.cs", SWIG_output_directory(), classname);
- File *f_swigtype = NewFile(filen, "w", SWIG_output_files());
- if (!f_swigtype) {
- FileErrorDisplay(filen);
- SWIG_exit(EXIT_FAILURE);
- }
- Append(filenames_list, Copy(filen));
- Delete(filen);
- filen = NULL;
-
- // Start writing out the type wrapper class file
- emitBanner(f_swigtype);
+ File *f_swigtype = getOutputFile(SWIG_output_directory(), classname);
addOpenNamespace(0, f_swigtype);
Replaceall(swigtype, "$imclassname", imclass_name);
Replaceall(swigtype, "$dllimport", dllimport);
+ // For unknown enums
+ Replaceall(swigtype, "$enumvalues", "");
+
Printv(f_swigtype, swigtype, NIL);
addCloseNamespace(0, f_swigtype);
-
- Delete(f_swigtype);
+ if (f_swigtype != f_single_out)
+ Delete(f_swigtype);
+ f_swigtype = NULL;
Delete(swigtype);
Delete(n);
}
/* -----------------------------------------------------------------------------
* outputDirectory()
*
- * Return the directory to use for generating Java classes/enums and create the
+ * Return the directory to use for generating C# classes/enums and create the
* subdirectory (does not create if language specific outdir does not exist).
* ----------------------------------------------------------------------------- */
// Output the director connect method:
String *norm_name = SwigType_namestr(Getattr(n, "name"));
- String *swig_director_connect = Swig_name_member(getNSpace(), proxy_class_name, "director_connect");
+ String *dirclassname = directorClassName(n);
+ String *swig_director_connect = Swig_name_member(getNSpace(), getClassPrefix(), "director_connect");
String *wname = Swig_name_wrapper(swig_director_connect);
String *sym_name = Getattr(n, "sym:name");
String *qualified_classname = Copy(sym_name);
String *nspace = getNSpace();
String *dirClassName = directorClassName(n);
String *smartptr = Getattr(n, "feature:smartptr");
+ if (!GetFlag(n, "feature:flatnested")) {
+ for (Node *outer_class = Getattr(n, "nested:outer"); outer_class; outer_class = Getattr(outer_class, "nested:outer")) {
+ Push(qualified_classname, ".");
+ Push(qualified_classname, Getattr(outer_class, "sym:name"));
+ }
+ }
if (nspace)
Insert(qualified_classname, 0, NewStringf("%s.", nspace));
- Printv(imclass_class_code, "\n [DllImport(\"", dllimport, "\", EntryPoint=\"", wname, "\")]\n", NIL);
- Printf(imclass_class_code, " public static extern void %s(HandleRef jarg1", swig_director_connect);
+ Printv(imclass_class_code, "\n [global::System.Runtime.InteropServices.DllImport(\"", dllimport, "\", EntryPoint=\"", wname, "\")]\n", NIL);
+ Printf(imclass_class_code, " public static extern void %s(global::System.Runtime.InteropServices.HandleRef jarg1", swig_director_connect);
Wrapper *code_wrap = NewWrapper();
Printf(code_wrap->def, "SWIGEXPORT void SWIGSTDCALL %s(void *objarg", wname);
- if (Len(smartptr)) {
+ if (smartptr) {
Printf(code_wrap->code, " %s *obj = (%s *)objarg;\n", smartptr, smartptr);
Printf(code_wrap->code, " // Keep a local instance of the smart pointer around while we are using the raw pointer\n");
Printf(code_wrap->code, " // Avoids using smart pointer specific API.\n");
Printf(code_wrap->def, ", ");
if (i != first_class_dmethod)
Printf(code_wrap->code, ", ");
- Printf(code_wrap->def, "%s::SWIG_Callback%s_t callback%s", dirClassName, methid, methid);
+ Printf(code_wrap->def, "%s::SWIG_Callback%s_t callback%s", dirclassname, methid, methid);
Printf(code_wrap->code, "callback%s", methid);
Printf(imclass_class_code, ", %s.SwigDelegate%s_%s delegate%s", qualified_classname, sym_name, methid, methid);
}
Delete(wname);
Delete(swig_director_connect);
Delete(qualified_classname);
- Delete(dirClassName);
+ Delete(dirclassname);
}
/* ---------------------------------------------------------------
* classDirectorMethod()
*
* Emit a virtual director method to pass a method call on to the
- * underlying Java object.
+ * underlying C# object.
*
* --------------------------------------------------------------- */
// we're consistent with the sym:overload name in functionWrapper. (?? when
// does the overloaded method name get set?)
- imclass_dmethod = NewStringf("SwigDirector_%s", Swig_name_member(getNSpace(), classname, overloaded_name));
+ imclass_dmethod = NewStringf("SwigDirector_%s", Swig_name_member(getNSpace(), getClassPrefix(), overloaded_name));
qualified_return = SwigType_rcaststr(returntype, "c_result");
if (!ignored_method)
Printf(w->code, "} else {\n");
- /* Go through argument list, convert from native to Java */
+ /* Go through argument list, convert from native to C# */
for (i = 0, p = l; p; ++i) {
/* Is this superfluous? */
while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
Printf(director_delegate_definitions, " SwigDelegate%s_%s(%s);\n", classname, methid, delegate_parms);
Printf(director_delegate_instances, " private SwigDelegate%s_%s swigDelegate%s;\n", classname, methid, methid);
- Printf(director_method_types, " private static Type[] swigMethodTypes%s = new Type[] { %s };\n", methid, proxy_method_types);
+ Printf(director_method_types, " private static global::System.Type[] swigMethodTypes%s = new global::System.Type[] { %s };\n", methid, proxy_method_types);
Printf(director_connect_parms, "SwigDirector%s%s delegate%s", classname, methid, methid);
}
Delete(proxy_method_types);
Delete(callback_def);
Delete(callback_code);
+ Delete(dirclassname);
DelWrapper(w);
return status;
String *basetype = Getattr(parent, "classtype");
String *target = Swig_method_decl(0, decl, dirclassname, parms, 0, 0);
String *call = Swig_csuperclass_call(0, basetype, superparms);
- String *classtype = SwigType_namestr(Getattr(n, "name"));
Printf(f_directors, "%s::%s : %s, %s {\n", dirclassname, target, call, Getattr(parent, "director:ctor"));
Printf(f_directors, " swig_init_callbacks();\n");
Printf(f_directors, "}\n\n");
- Delete(classtype);
Delete(target);
Delete(call);
}
return Language::classDirectorInit(n);
}
+ int classDeclaration(Node *n) {
+ String *old_director_callback_typedefs = director_callback_typedefs;
+ String *old_director_callbacks = director_callbacks;
+ String *old_director_delegate_callback = director_delegate_callback;
+ String *old_director_delegate_definitions = director_delegate_definitions;
+ String *old_director_delegate_instances = director_delegate_instances;
+ String *old_director_method_types = director_method_types;
+ String *old_director_connect_parms = director_connect_parms;
+
+ int ret = Language::classDeclaration(n);
+
+ // these variables are deleted in emitProxyClassDefAndCPPCasts, hence no Delete here
+ director_callback_typedefs = old_director_callback_typedefs;
+ director_callbacks = old_director_callbacks;
+ director_delegate_callback = old_director_delegate_callback;
+ director_delegate_definitions = old_director_delegate_definitions;
+ director_delegate_instances = old_director_delegate_instances;
+ director_method_types = old_director_method_types;
+ director_connect_parms = old_director_connect_parms;
+
+ return ret;
+ }
+
/* ----------------------------------------------------------------------
* classDirectorDestructor()
* ---------------------------------------------------------------------- */
int classDirectorEnd(Node *n) {
int i;
- String *director_classname = directorClassName(n);
+ String *dirclassname = directorClassName(n);
Wrapper *w = NewWrapper();
Printf(f_directors_h, " void swig_connect_director(");
- Printf(w->def, "void %s::swig_connect_director(", director_classname);
+ Printf(w->def, "void %s::swig_connect_director(", dirclassname);
for (i = first_class_dmethod; i < curr_class_dmethod; ++i) {
UpcallData *udata = Getitem(dmethods_seq, i);
Printf(f_directors_h, "};\n\n");
Printf(w->code, "}\n\n");
- Printf(w->code, "void %s::swig_init_callbacks() {\n", director_classname);
+ Printf(w->code, "void %s::swig_init_callbacks() {\n", dirclassname);
for (i = first_class_dmethod; i < curr_class_dmethod; ++i) {
UpcallData *udata = Getitem(dmethods_seq, i);
String *overname = Getattr(udata, "overname");
Wrapper_print(w, f_directors);
DelWrapper(w);
+ Delete(dirclassname);
return Language::classDirectorEnd(n);
}
String *base = Getattr(n, "classtype");
String *class_ctor = NewString("Swig::Director()");
- String *directorname = directorClassName(n);
- String *declaration = Swig_class_declaration(n, directorname);
+ String *dirclassname = directorClassName(n);
+ String *declaration = Swig_class_declaration(n, dirclassname);
Printf(declaration, " : public %s, public Swig::Director", base);
Setattr(n, "director:decl", declaration);
Setattr(n, "director:ctor", class_ctor);
- Delete(directorname);
+ Delete(dirclassname);
}
+ /*----------------------------------------------------------------------
+ * nestedClassesSupport()
+ *--------------------------------------------------------------------*/
+
+ NestedClassSupport nestedClassesSupport() const {
+ return NCS_Full;
+ }
}; /* class CSHARP */
/* -----------------------------------------------------------------------------
* Static member variables
* ----------------------------------------------------------------------------- */
-const char *CSHARP::usage = (char *) "\
+const char *CSHARP::usage = "\
C# Options (available with -csharp)\n\
-dllimport <dl> - Override DllImport attribute name to <dl>\n\
-namespace <nm> - Generate wrappers into C# namespace <nm>\n\
-noproxy - Generate the low-level functional interface instead\n\
of proxy classes\n\
-oldvarnames - Old intermediary method names for variable wrappers\n\
+ -outfile <file> - Write all C# into a single <file> located in the output directory\n\
\n";
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGD\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGD\n#define SWIGD\n#endif\n\n");
if (directorsEnabled()) {
Printf(f_runtime, "#define SWIG_DIRECTORS\n");
if (directorsEnabled()) {
// Insert director runtime into the f_runtime file (before %header section).
+ Swig_insert_file("director_common.swg", f_runtime);
Swig_insert_file("director.swg", f_runtime);
}
writeTypeWrapperClass(swig_type.key, swig_type.item);
}
- // Add the proxy functions (and classes, if they are not written to a
- // seperate file).
+ // Add the proxy functions (and classes, if they are not written to a separate file).
replaceModuleVariables(proxy_dmodule_code);
Printv(proxy_d_file, proxy_dmodule_code, NIL);
// Emit each enum item.
Language::enumDeclaration(n);
- if (!GetFlag(n, "nonempty")) {
- // Do not wrap empty enums; the resulting D code would be illegal.
- Delete(proxy_enum_code);
- return SWIG_NOWRAP;
- }
-
- // Finish the enum.
- if (typemap_lookup_type) {
- Printv(proxy_enum_code,
- lookupCodeTypemap(n, "dcode", typemap_lookup_type, WARN_NONE), // Extra D code
- "\n}\n", NIL);
+ if (GetFlag(n, "nonempty")) {
+ // Finish the enum.
+ if (typemap_lookup_type) {
+ Printv(proxy_enum_code,
+ lookupCodeTypemap(n, "dcode", typemap_lookup_type, WARN_NONE), // Extra D code
+ "\n}\n", NIL);
+ } else {
+ // Handle anonymous enums.
+ Printv(proxy_enum_code, "\n}\n", NIL);
+ }
+ Replaceall(proxy_enum_code, "$dclassname", symname);
} else {
- // Handle anonymous enums.
- Printv(proxy_enum_code, "\n}\n", NIL);
+ // D enum declarations must have at least one member to be legal, so emit
+ // an alias to int instead (their ctype/imtype is always int).
+ Delete(proxy_enum_code);
+ proxy_enum_code = NewStringf("\nalias int %s;\n", symname);
}
- Replaceall(proxy_enum_code, "$dclassname", symname);
-
const String* imports =
lookupCodeTypemap(n, "dimports", typemap_lookup_type, WARN_NONE);
String* imports_trimmed;
const char *val = Equal(Getattr(n, "enumvalue"), "true") ? "1" : "0";
Setattr(n, "enumvalue", val);
} else if (swigtype == T_CHAR) {
- String *val = NewStringf("'%s'", Getattr(n, "enumvalue"));
+ String *val = NewStringf("'%(escape)s'", Getattr(n, "enumvalue"));
Setattr(n, "enumvalue", val);
Delete(val);
}
// generates a getter function (which is the same as a read only property
// in D) which retrieves the value via by calling the C wrapper.
// Note that this is only called for global constants, static member
- // constants are already handeled in staticmemberfunctionHandler().
+ // constants are already handled in staticmemberfunctionHandler().
Swig_save("constantWrapper", n, "value", NIL);
Swig_save("constantWrapper", n, "tmap:ctype:out", "tmap:imtype:out", "tmap:dtype:out", "tmap:out:null", "tmap:imtype:outattributes", "tmap:dtype:outattributes", NIL);
String *constants_code = NewString("");
SwigType *t = Getattr(n, "type");
+ SwigType *valuetype = Getattr(n, "valuetype");
ParmList *l = Getattr(n, "parms");
// Attach the non-standard typemaps to the parameter list.
Printf(constants_code, "%s;\n", override_value);
} else {
// Just take the value from the C definition and hope it compiles in D.
- String* value = Getattr(n, "wrappedasconstant") ?
- Getattr(n, "staticmembervariableHandler:value") : Getattr(n, "value");
-
- // Add the stripped quotes back in.
- if (SwigType_type(t) == T_STRING) {
- Printf(constants_code, "\"%s\";\n", value);
- } else if (SwigType_type(t) == T_CHAR) {
- Printf(constants_code, "\'%s\';\n", value);
+ if (Getattr(n, "wrappedasconstant")) {
+ if (SwigType_type(valuetype) == T_CHAR)
+ Printf(constants_code, "\'%(escape)s\';\n", Getattr(n, "staticmembervariableHandler:value"));
+ else
+ Printf(constants_code, "%s;\n", Getattr(n, "staticmembervariableHandler:value"));
} else {
- Printf(constants_code, "%s;\n", value);
+ // Add the stripped quotes back in.
+ String* value = Getattr(n, "value");
+ if (SwigType_type(t) == T_STRING) {
+ Printf(constants_code, "\"%s\";\n", value);
+ } else if (SwigType_type(t) == T_CHAR) {
+ Printf(constants_code, "\'%s\';\n", value);
+ } else {
+ Printf(constants_code, "%s;\n", value);
+ }
}
}
String *null_attribute = 0;
// Now write code to make the function call
if (!native_function_flag) {
- if (Cmp(nodeType(n), "constant") == 0) {
- // Wrapping a constant hack
- Swig_save("functionWrapper", n, "wrap:action", NIL);
-
- // below based on Swig_VargetToFunction()
- SwigType *ty = Swig_wrapped_var_type(Getattr(n, "type"), use_naturalvar_mode(n));
- Setattr(n, "wrap:action", NewStringf("%s = (%s) %s;", Swig_cresult_name(), SwigType_lstr(ty, 0), Getattr(n, "value")));
- }
Swig_director_emit_dynamic_cast(n, f);
String *actioncode = emit_action(n);
- if (Cmp(nodeType(n), "constant") == 0)
- Swig_restore(n);
-
/* Return value if necessary */
if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) {
canThrow(n, "out", n);
const_String_or_char_ptr wrapper_function_name) {
// TODO: Add support for static linking here.
- Printf(im_dmodule_code, "extern(C) %s function%s %s;\n", return_type,
+ Printf(im_dmodule_code, "SwigExternC!(%s function%s) %s;\n", return_type,
parameters, d_name);
Printv(wrapper_loader_bind_code, wrapper_loader_bind_command, NIL);
Replaceall(wrapper_loader_bind_code, "$function", d_name);
// polymorphic call or an explicit method call. Needed to prevent infinite
// recursion when calling director methods.
Node *explicit_n = Getattr(n, "explicitcallnode");
- if (explicit_n) {
+ if (explicit_n && Swig_directorclass(getCurrentClass())) {
String *ex_overloaded_name = getOverloadedName(explicit_n);
String *ex_intermediary_function_name = Swig_name_member(getNSpace(), proxy_class_name, ex_overloaded_name);
List *baselist = Getattr(n, "bases");
if (baselist) {
Iterator base = First(baselist);
- while (base.item && GetFlag(base.item, "feature:ignore")) {
- base = Next(base);
- }
- if (base.item) {
- basenode = base.item;
- c_baseclassname = Getattr(base.item, "name");
- basename = createProxyName(c_baseclassname);
- if (basename)
- c_baseclass = SwigType_namestr(Getattr(base.item, "name"));
- base = Next(base);
- /* Warn about multiple inheritance for additional base class(es) */
- while (base.item) {
- if (GetFlag(base.item, "feature:ignore")) {
- base = Next(base);
- continue;
+ while (base.item) {
+ if (!GetFlag(base.item, "feature:ignore")) {
+ String *baseclassname = Getattr(base.item, "name");
+ if (!c_baseclassname) {
+ basenode = base.item;
+ c_baseclassname = baseclassname;
+ basename = createProxyName(c_baseclassname);
+ if (basename)
+ c_baseclass = SwigType_namestr(baseclassname);
+ } else {
+ /* Warn about multiple inheritance for additional base class(es) */
+ String *proxyclassname = Getattr(n, "classtypeobj");
+ Swig_warning(WARN_D_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
+ "Base %s of class %s ignored: multiple inheritance is not supported in D.\n", SwigType_namestr(baseclassname), SwigType_namestr(proxyclassname));
}
- String *proxyclassname = SwigType_str(Getattr(n, "classtypeobj"), 0);
- String *baseclassname = SwigType_str(Getattr(base.item, "name"), 0);
- Swig_warning(WARN_D_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
- "Base %s of class %s ignored: multiple inheritance is not supported in D.\n", baseclassname, proxyclassname);
- base = Next(base);
}
+ base = Next(base);
}
}
}
}
} else if (basename && Len(pure_baseclass) > 0) {
Swig_warning(WARN_D_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
- "Warning for %s proxy: Base class %s ignored. Multiple inheritance is not supported in D. "
+ "Warning for %s, base class %s ignored. Multiple inheritance is not supported in D. "
"Perhaps you need one of the 'replace' or 'notderived' attributes in the dbase typemap?\n", typemap_lookup_type, pure_baseclass);
}
/* ---------------------------------------------------------------------------
* D::writeClassUpcast()
* --------------------------------------------------------------------------- */
- void writeClassUpcast(Node *n, const String* d_class_name,
- String* c_class_name, String* c_base_name) {
-
- String *smartptr = Getattr(n, "feature:smartptr");
- String *upcast_name = Swig_name_member(getNSpace(), d_class_name,
- (smartptr != 0 ? "SmartPtrUpcast" : "Upcast"));
+ void writeClassUpcast(Node *n, const String* d_class_name, String* c_class_name, String* c_base_name) {
+ SwigType *smart = Swig_cparse_smartptr(n);
+ String *upcast_name = Swig_name_member(getNSpace(), d_class_name, (smart != 0 ? "SmartPtrUpcast" : "Upcast"));
String *upcast_wrapper_name = Swig_name_wrapper(upcast_name);
writeImDModuleFunction(upcast_name, "void*", "(void* objectRef)",
upcast_wrapper_name);
- if (smartptr) {
- SwigType *spt = Swig_cparse_type(smartptr);
- if (spt) {
- SwigType *smart = SwigType_typedef_resolve_all(spt);
- Delete(spt);
- SwigType *bsmart = Copy(smart);
- SwigType *rclassname = SwigType_typedef_resolve_all(c_class_name);
- SwigType *rbaseclass = SwigType_typedef_resolve_all(c_base_name);
- Replaceall(bsmart, rclassname, rbaseclass);
- Delete(rclassname);
- Delete(rbaseclass);
- String *smartnamestr = SwigType_namestr(smart);
- String *bsmartnamestr = SwigType_namestr(bsmart);
- Printv(upcasts_code,
- "SWIGEXPORT ", bsmartnamestr, " * ", upcast_wrapper_name,
- "(", smartnamestr, " *objectRef) {\n",
- " return objectRef ? new ", bsmartnamestr, "(*objectRef) : 0;\n"
- "}\n",
- "\n", NIL);
- Delete(bsmartnamestr);
- Delete(smartnamestr);
- Delete(bsmart);
- } else {
- Swig_error(Getfile(n), Getline(n),
- "Invalid type (%s) in 'smartptr' feature for class %s.\n",
- smartptr, c_class_name);
- }
+ if (smart) {
+ SwigType *bsmart = Copy(smart);
+ SwigType *rclassname = SwigType_typedef_resolve_all(c_class_name);
+ SwigType *rbaseclass = SwigType_typedef_resolve_all(c_base_name);
+ Replaceall(bsmart, rclassname, rbaseclass);
+ Delete(rclassname);
+ Delete(rbaseclass);
+ String *smartnamestr = SwigType_namestr(smart);
+ String *bsmartnamestr = SwigType_namestr(bsmart);
+ Printv(upcasts_code,
+ "SWIGEXPORT ", bsmartnamestr, " * ", upcast_wrapper_name,
+ "(", smartnamestr, " *objectRef) {\n",
+ " return objectRef ? new ", bsmartnamestr, "(*objectRef) : 0;\n"
+ "}\n",
+ "\n", NIL);
+ Delete(bsmartnamestr);
+ Delete(smartnamestr);
+ Delete(bsmart);
} else {
Printv(upcasts_code,
"SWIGEXPORT ", c_base_name, " * ", upcast_wrapper_name,
Delete(upcast_name);
Delete(upcast_wrapper_name);
+ Delete(smart);
}
/* ---------------------------------------------------------------------------
* package if one is set.
*
* This is only used for dependencies created in generated code, user-
- * (i.e. typemap-) specified import statements are handeled seperately.
+ * (i.e. typemap-) specified import statements are handled separately.
* --------------------------------------------------------------------------- */
void requireDType(const String *nspace, const String *symname) {
String *dmodule = createModuleName(nspace, symname);
// TODO: Fix const-correctness of methods called in here and make type const.
// We make use of the fact that this function is called at least once for
- // every type encountered which is written to a seperate file, which allows
+ // every type encountered which is written to a separate file, which allows
// us to handle imports here.
// When working in split proxy module mode, each generated proxy class/enum
- // is written to a seperate module. This requires us to add a corresponding
+ // is written to a separate module. This requires us to add a corresponding
// import when a type is used in another generated module. If we are not
// working in split proxy module mode, this is not relevant and the
// generated module name is discarded.
if (SwigType_isenum(type)) {
// RESEARCH: Make sure that we really cannot get here for anonymous enums.
Node *n = enumLookup(type);
- String *enum_name = Getattr(n, "sym:name");
+ if (n) {
+ String *enum_name = Getattr(n, "sym:name");
- Node *p = parentNode(n);
- if (p && !Strcmp(nodeType(p), "class")) {
- // This is a nested enum.
- String *parent_name = Getattr(p, "sym:name");
- String *nspace = Getattr(p, "sym:nspace");
+ Node *p = parentNode(n);
+ if (p && !Strcmp(nodeType(p), "class")) {
+ // This is a nested enum.
+ String *parent_name = Getattr(p, "sym:name");
+ String *nspace = Getattr(p, "sym:nspace");
- // An enum nested in a class is not written to a seperate module (this
- // would not even be possible in D), so just import the parent.
- requireDType(nspace, parent_name);
+ // An enum nested in a class is not written to a separate module (this
+ // would not even be possible in D), so just import the parent.
+ requireDType(nspace, parent_name);
- String *module = createModuleName(nspace, parent_name);
- if (inProxyModule(module)) {
- type_name = NewStringf("%s.%s", parent_name, enum_name);
+ String *module = createModuleName(nspace, parent_name);
+ if (inProxyModule(module)) {
+ type_name = NewStringf("%s.%s", parent_name, enum_name);
+ } else {
+ type_name = NewStringf("%s%s.%s.%s", package, module, parent_name, enum_name);
+ }
} else {
- type_name = NewStringf("%s%s.%s.%s", package, module, parent_name, enum_name);
- }
- } else {
- // A non-nested enum is written to a seperate module, import it.
- String *nspace = Getattr(n, "sym:nspace");
- requireDType(nspace, enum_name);
+ // A non-nested enum is written to a separate module, import it.
+ String *nspace = Getattr(n, "sym:nspace");
+ requireDType(nspace, enum_name);
- String *module = createModuleName(nspace, enum_name);
- if (inProxyModule(module)) {
- type_name = Copy(enum_name);
- } else {
- type_name = NewStringf("%s%s.%s", package, module, enum_name);
+ String *module = createModuleName(nspace, enum_name);
+ if (inProxyModule(module)) {
+ type_name = Copy(enum_name);
+ } else {
+ type_name = NewStringf("%s%s.%s", package, module, enum_name);
+ }
}
+ } else {
+ type_name = NewStringf("int");
}
} else {
Node *n = classLookup(type);
return proxyname;
}
- /* ---------------------------------------------------------------------------
- * D::makeParameterName()
- *
- * Inputs:
- * n - Node
- * p - parameter node
- * arg_num - parameter argument number
- * setter - set this flag when wrapping variables
- * Return:
- * arg - a unique parameter name
- * --------------------------------------------------------------------------- */
String *makeParameterName(Node *n, Parm *p, int arg_num, bool setter) const {
- String *arg = 0;
- String *pn = Getattr(p, "name");
-
- // Use C parameter name unless it is a duplicate or an empty parameter name
- int count = 0;
- ParmList *plist = Getattr(n, "parms");
- while (plist) {
- if ((Cmp(pn, Getattr(plist, "name")) == 0))
- count++;
- plist = nextSibling(plist);
- }
- String *wrn = pn ? Swig_name_warning(p, 0, pn, 0) : 0;
- arg = (!pn || (count > 1) || wrn) ? NewStringf("arg%d", arg_num) : Copy(pn);
-
- if (setter && Cmp(arg, "self") != 0) {
- // In theory, we could use the normal parameter name for setter functions.
- // Unfortunately, it is set to "Class::VariableName" for static public
- // members by the parser, which is not legal D syntax. Thus, we just force
- // it to "value".
- Delete(arg);
- arg = NewString("value");
- }
+ String *arg = Language::makeParameterName(n, p, arg_num, setter);
if (split_proxy_dmodule && Strncmp(arg, package, Len(arg)) == 0) {
// If we are in split proxy mode and the argument is named like the target
/* -----------------------------------------------------------------------------
* Usage information displayed at the command line.
* ----------------------------------------------------------------------------- */
-const char *D::usage = (char *) "\
+const char *D::usage = "\
D Options (available with -d)\n\
-d2 - Generate code for D2/Phobos (default: D1/Tango)\n\
-package <pkg> - Write generated D modules into package <pkg>\n\
void Swig_director_emit_dynamic_cast(Node *n, Wrapper *f) {
// TODO: why is the storage element removed in staticmemberfunctionHandler ??
if ((!is_public(n) && (is_member_director(n) || GetFlag(n, "explicitcall"))) ||
- (is_non_virtual_protected_access(n) && !(checkAttribute(n, "staticmemberfunctionHandler:storage", "static") ||
- checkAttribute(n, "storage", "static"))
+ (is_non_virtual_protected_access(n) && !(Swig_storage_isstatic_custom(n, "staticmemberfunctionHandler:storage") ||
+ Swig_storage_isstatic(n))
&& !Equal(nodeType(n), "constructor"))) {
Node *parent = Getattr(n, "parentNode");
String *dirname;
#include "cparse.h"
#include <ctype.h>
+/* ----------------------------------------------------------------------
+ * siphash()
+ *
+ * 64-bit SipHash-2-4 to generate unique id for each module
+ * ---------------------------------------------------------------------- */
+
+// An unsigned 64-bit integer that works on a 32-bit host.
+typedef struct {
+ // Assume unsigned long is at least 32 bits.
+ unsigned long hi;
+ unsigned long lo;
+} swig_uint64;
+
+// Rotate v left by bits, which must be <= 32.
+static inline void _rotl(swig_uint64 *v, int bits) {
+ assert(bits <= 32);
+ unsigned long tmp = v->hi;
+ if (bits == 32) {
+ v->hi = v->lo;
+ v->lo = tmp;
+ } else {
+ v->hi = (tmp << bits) | ((0xfffffffful & v->lo) >> (32 - bits));
+ v->lo = (v->lo << bits) | ((0xfffffffful & tmp) >> (32 - bits));
+ }
+}
+
+// dst ^= src
+static inline void _xor(swig_uint64 *dst, swig_uint64 *src) {
+ dst->lo ^= src->lo;
+ dst->hi ^= src->hi;
+}
+
+// dst += src
+static inline void _add(swig_uint64 *dst, swig_uint64 *src) {
+ dst->lo += src->lo;
+ dst->hi += src->hi + ((dst->lo & 0xfffffffful) < (src->lo&0xfffffffful) ? 1 : 0);
+}
+#define SIPROUND \
+ do { \
+ _add(&v0, &v1); _rotl(&v1, 13); _xor(&v1, &v0); _rotl(&v0, 32); \
+ _add(&v2, &v3); _rotl(&v3, 16); _xor(&v3, &v2); \
+ _add(&v0, &v3); _rotl(&v3, 21); _xor(&v3, &v0); \
+ _add(&v2, &v1); _rotl(&v1, 17); _xor(&v1, &v2); _rotl(&v2, 32); \
+ } while(0)
+
+// Set out to the hash of inc/inlen.
+static void siphash(swig_uint64 *out, const char *inc, unsigned long inlen) {
+ /* "somepseudorandomlygeneratedbytes" */
+ swig_uint64 v0 = {0x736f6d65UL, 0x70736575UL};
+ swig_uint64 v1 = {0x646f7261UL, 0x6e646f6dUL};
+ swig_uint64 v2 = {0x6c796765UL, 0x6e657261UL};
+ swig_uint64 v3 = {0x74656462UL, 0x79746573UL};
+ swig_uint64 b;
+ /* hard-coded k. */
+ swig_uint64 k0 = {0x07060504UL, 0x03020100UL};
+ swig_uint64 k1 = {0x0F0E0D0CUL, 0x0B0A0908UL};
+ int i;
+ const int cROUNDS = 2, dROUNDS = 4;
+ const unsigned char *in = (const unsigned char *)inc;
+ const unsigned char *end = in + inlen - (inlen % 8);
+ int left = inlen & 7;
+ _xor(&v3, &k1); _xor(&v2, &k0); _xor(&v1, &k1); _xor(&v0, &k0);
+ for (; in != end; in += 8) {
+ b.hi = 0; b.lo = 0;
+ for (i = 0; i < 4; i++) {
+ b.lo |= ((unsigned long)in[i]) << (8*i);
+ }
+ for (i = 0; i < 4; i++) {
+ b.hi |= ((unsigned long)in[i+4]) << (8*i);
+ }
+ _xor(&v3, &b);
+ for (i = 0; i < cROUNDS; i++) {
+ SIPROUND;
+ }
+ _xor(&v0, &b);
+ }
+ b.hi = (inlen & 0xff)<<24; b.lo = 0;
+ for (; left; left--) {
+ if (left > 4) {
+ b.hi |= ((unsigned long)in[left-1]) << (8*left-8-32);
+ } else {
+ b.lo |= ((unsigned long)in[left-1]) << (8*left-8);
+ }
+ }
+ _xor(&v3, &b);
+ for(i=0; i<cROUNDS; i++) {
+ SIPROUND;
+ }
+ _xor(&v0, &b); v2.lo ^= 0xff;
+ for(i=0; i<dROUNDS; i++) {
+ SIPROUND;
+ }
+ out->lo = 0; out->hi = 0;
+ _xor(out, &v0); _xor(out, &v1); _xor(out, &v2); _xor(out, &v3);
+}
+#undef SIPROUND
+
class GO:public Language {
static const char *const usage;
String *package;
// SWIG module name.
String *module;
+ // Flag for generating cgo input files.
+ bool cgo_flag;
// Flag for generating gccgo output.
bool gccgo_flag;
// Prefix to use with gccgo.
String *go_prefix;
+ // -fgo-prefix option.
+ String *prefix_option;
+ // -fgo-pkgpath option.
+ String *pkgpath_option;
+ // Whether to use a shared library.
+ bool use_shlib;
// Name of shared library to import.
String *soname;
- // Size in bits of the C type "long".
- int long_type_size;
// Size in bits of the Go type "int". 0 if not specified.
int intgo_type_size;
File *f_c_init;
File *f_c_directors;
File *f_c_directors_h;
+ File *f_go_imports;
File *f_go_runtime;
File *f_go_header;
File *f_go_wrappers;
+ File *f_go_directors;
File *f_gc_runtime;
File *f_gc_header;
File *f_gc_wrappers;
+ File *f_cgo_comment;
+ File *f_cgo_comment_typedefs;
// True if we imported a module.
bool saw_import;
bool making_variable_wrappers;
// True when working with a static member function.
bool is_static_member_function;
+ // A hash table of enum types that we have seen but which may not have
+ // been defined. The index is a SwigType.
+ Hash *undefined_enum_types;
// A hash table of types that we have seen but which may not have
// been defined. The index is a SwigType.
Hash *undefined_types;
// A hash table of classes which were defined. The index is a Go
// type name.
Hash *defined_types;
+ // A hash table of all the go_imports already imported. The index is a full
+ // import name e.g. '"runtime"' or '_ "runtime/cgo"' or 'sc "syscall"'.
+ Hash *go_imports;
+ // A unique ID used to make public symbols unique.
+ String *unique_id;
public:
GO():package(NULL),
module(NULL),
+ cgo_flag(false),
gccgo_flag(false),
go_prefix(NULL),
+ prefix_option(NULL),
+ pkgpath_option(NULL),
+ use_shlib(false),
soname(NULL),
- long_type_size(32),
intgo_type_size(0),
f_c_begin(NULL),
f_go_begin(NULL),
f_c_init(NULL),
f_c_directors(NULL),
f_c_directors_h(NULL),
+ f_go_imports(NULL),
f_go_runtime(NULL),
f_go_header(NULL),
f_go_wrappers(NULL),
+ f_go_directors(NULL),
f_gc_runtime(NULL),
f_gc_header(NULL),
f_gc_wrappers(NULL),
+ f_cgo_comment(NULL),
+ f_cgo_comment_typedefs(NULL),
saw_import(false),
imported_package(NULL),
interfaces(NULL),
class_methods(NULL),
making_variable_wrappers(false),
is_static_member_function(false),
+ undefined_enum_types(NULL),
undefined_types(NULL),
- defined_types(NULL) {
+ defined_types(NULL),
+ go_imports(NULL),
+ unique_id(NULL) {
director_multiple_inheritance = 1;
director_language = 1;
director_prot_ctor_code = NewString("_swig_gopanic(\"accessing abstract class or protected constructor\");");
} else {
Swig_arg_error();
}
+ } else if (strcmp(argv[i], "-cgo") == 0) {
+ Swig_mark_arg(i);
+ cgo_flag = true;
} else if (strcmp(argv[i], "-gccgo") == 0) {
Swig_mark_arg(i);
gccgo_flag = true;
} else if (strcmp(argv[i], "-go-prefix") == 0) {
if (argv[i + 1]) {
- go_prefix = NewString(argv[i + 1]);
+ prefix_option = NewString(argv[i + 1]);
+ Swig_mark_arg(i);
+ Swig_mark_arg(i + 1);
+ i++;
+ } else {
+ Swig_arg_error();
+ }
+ } else if (strcmp(argv[i], "-go-pkgpath") == 0) {
+ if (argv[i + 1]) {
+ pkgpath_option = NewString(argv[i + 1]);
Swig_mark_arg(i);
Swig_mark_arg(i + 1);
i++;
} else {
Swig_arg_error();
}
+ } else if (strcmp(argv[i], "-use-shlib") == 0) {
+ Swig_mark_arg(i);
+ use_shlib = true;
} else if (strcmp(argv[i], "-soname") == 0) {
if (argv[i + 1]) {
soname = NewString(argv[i + 1]);
Swig_arg_error();
}
} else if (strcmp(argv[i], "-longsize") == 0) {
+ // Ignore for backward compatibility.
if (argv[i + 1]) {
- long_type_size = atoi(argv[i + 1]);
- if (long_type_size != 32 && long_type_size != 64) {
- Printf(stderr, "-longsize not 32 or 64\n");
- Swig_arg_error();
- }
Swig_mark_arg(i);
Swig_mark_arg(i + 1);
++i;
}
}
- if (gccgo_flag && !go_prefix) {
- go_prefix = NewString("go");
+ if (gccgo_flag && !pkgpath_option && !prefix_option) {
+ prefix_option = NewString("go");
}
// Add preprocessor symbol to parser.
Preprocessor_define("SWIGGO 1", 0);
- if (gccgo_flag) {
- Preprocessor_define("SWIGGO_GCCGO 1", 0);
+ if (cgo_flag) {
+ Preprocessor_define("SWIGGO_CGO 1", 0);
}
- if (long_type_size == 32) {
- Preprocessor_define("SWIGGO_LONG_TYPE_SIZE 32", 0);
- } else {
- Preprocessor_define("SWIGGO_LONG_TYPE_SIZE 64", 0);
+ if (gccgo_flag) {
+ Preprocessor_define("SWIGGO_GCCGO 1", 0);
}
// This test may be removed in the future, when we can assume that
if (!package) {
package = Copy(module);
}
- if (!soname) {
+ if (!soname && use_shlib) {
soname = Copy(package);
Append(soname, ".so");
}
+ if (gccgo_flag) {
+ String *pref;
+ if (pkgpath_option) {
+ pref = pkgpath_option;
+ } else {
+ pref = prefix_option;
+ }
+ go_prefix = NewString("");
+ for (char *p = Char(pref); *p != '\0'; p++) {
+ if ((*p >= 'A' && *p <= 'Z') || (*p >= 'a' && *p <= 'z') || (*p >= '0' && *p <= '9') || *p == '.' || *p == '$') {
+ Putc(*p, go_prefix);
+ } else {
+ Putc('_', go_prefix);
+ }
+ }
+ if (!pkgpath_option) {
+ Append(go_prefix, ".");
+ Append(go_prefix, getModuleName(package));
+ }
+ }
+
// Get filenames.
+ String *swig_filename = Getattr(n, "infile");
String *c_filename = Getattr(n, "outfile");
String *c_filename_h = Getattr(n, "outfile_h");
Printf(gc_filename, "%s%s_gc.c", SWIG_output_directory(), module);
}
+ // Generate a unique ID based on a hash of the SWIG input.
+ swig_uint64 hash = {0, 0};
+ FILE *swig_input = Swig_open(swig_filename);
+ if (swig_input == NULL) {
+ FileErrorDisplay(swig_filename);
+ SWIG_exit(EXIT_FAILURE);
+ }
+ String *swig_input_content = Swig_read_file(swig_input);
+ siphash(&hash, Char(swig_input_content), Len(swig_input_content));
+ Delete(swig_input_content);
+ fclose(swig_input);
+ unique_id = NewString("");
+ Printf(unique_id, "_%s_%08x%08x", getModuleName(package), hash.hi, hash.lo);
+
// Open files.
f_c_begin = NewFile(c_filename, "w", SWIG_output_files());
SWIG_exit(EXIT_FAILURE);
}
- if (!gccgo_flag) {
+ if (!gccgo_flag && !cgo_flag) {
f_gc_begin = NewFile(gc_filename, "w", SWIG_output_files());
if (!f_gc_begin) {
FileErrorDisplay(gc_filename);
f_c_wrappers = NewString("");
f_c_init = NewString("");
f_c_directors = NewString("");
+ f_go_imports = NewString("");
f_go_runtime = NewString("");
f_go_header = NewString("");
f_go_wrappers = NewString("");
- if (!gccgo_flag) {
+ f_go_directors = NewString("");
+ if (!gccgo_flag && !cgo_flag) {
f_gc_runtime = NewString("");
f_gc_header = NewString("");
f_gc_wrappers = NewString("");
}
+ if (cgo_flag) {
+ f_cgo_comment = NewString("");
+ f_cgo_comment_typedefs = NewString("");
+ }
Swig_register_filebyname("begin", f_c_begin);
Swig_register_filebyname("runtime", f_c_runtime);
Swig_register_filebyname("director", f_c_directors);
Swig_register_filebyname("director_h", f_c_directors_h);
Swig_register_filebyname("go_begin", f_go_begin);
+ Swig_register_filebyname("go_imports", f_go_imports);
Swig_register_filebyname("go_runtime", f_go_runtime);
Swig_register_filebyname("go_header", f_go_header);
Swig_register_filebyname("go_wrapper", f_go_wrappers);
- if (!gccgo_flag) {
+ Swig_register_filebyname("go_director", f_go_directors);
+ if (!gccgo_flag && !cgo_flag) {
Swig_register_filebyname("gc_begin", f_gc_begin);
Swig_register_filebyname("gc_runtime", f_gc_runtime);
Swig_register_filebyname("gc_header", f_gc_header);
Swig_register_filebyname("gc_wrapper", f_gc_wrappers);
}
+ if (cgo_flag) {
+ Swig_register_filebyname("cgo_comment", f_cgo_comment);
+ Swig_register_filebyname("cgo_comment_typedefs", f_cgo_comment_typedefs);
+ }
Swig_banner(f_c_begin);
+ if (CPlusPlus) {
+ Printf(f_c_begin, "\n// source: %s\n\n", swig_filename);
+ } else {
+ Printf(f_c_begin, "\n/* source: %s */\n\n", swig_filename);
+ }
Printf(f_c_runtime, "#define SWIGMODULE %s\n", module);
+ if (gccgo_flag) {
+ Printf(f_c_runtime, "#define SWIGGO_PREFIX %s\n", go_prefix);
+ }
if (directorsEnabled()) {
Printf(f_c_runtime, "#define SWIG_DIRECTORS\n");
Swig_banner(f_c_directors_h);
+ Printf(f_c_directors_h, "\n// source: %s\n\n", swig_filename);
+
Printf(f_c_directors_h, "#ifndef SWIG_%s_WRAP_H_\n", module);
Printf(f_c_directors_h, "#define SWIG_%s_WRAP_H_\n\n", module);
+ Printf(f_c_directors_h, "class Swig_memory;\n\n");
Printf(f_c_directors, "\n// C++ director class methods.\n");
String *filename = Swig_file_filename(c_filename_h);
}
Swig_banner(f_go_begin);
+ Printf(f_go_begin, "\n// source: %s\n", swig_filename);
- if (!gccgo_flag) {
+ if (!gccgo_flag && !cgo_flag && soname) {
Swig_banner(f_gc_begin);
+ Printf(f_gc_begin, "\n/* source: %s */\n\n", swig_filename);
Printf(f_gc_begin, "\n/* This file should be compiled with 6c/8c. */\n");
Printf(f_gc_begin, "#pragma dynimport _ _ \"%s\"\n", soname);
}
+ if (cgo_flag) {
+ Printv(f_cgo_comment_typedefs, "/*\n", NULL);
+
+ // The cgo program defines the intgo type after our function
+ // definitions, but we want those definitions to be able to use
+ // intgo also.
+ Printv(f_cgo_comment_typedefs, "#define intgo swig_intgo\n", NULL);
+ Printv(f_cgo_comment_typedefs, "typedef void *swig_voidp;\n", NULL);
+ }
+
// Output module initialization code.
- Printf(f_go_begin, "\npackage %s\n\n", package);
+ Printf(f_go_begin, "\npackage %s\n\n", getModuleName(package));
- Printf(f_go_runtime, "//extern %sSwigCgocall\n", module);
- Printf(f_go_runtime, "func SwigCgocall()\n");
- Printf(f_go_runtime, "//extern %sSwigCgocallDone\n", module);
- Printf(f_go_runtime, "func SwigCgocallDone()\n");
- Printf(f_go_runtime, "//extern %sSwigCgocallBack\n", module);
- Printf(f_go_runtime, "func SwigCgocallBack()\n");
- Printf(f_go_runtime, "//extern %sSwigCgocallBackDone\n", module);
- Printf(f_go_runtime, "func SwigCgocallBackDone()\n\n");
+ if (gccgo_flag && !cgo_flag) {
+ Printf(f_go_runtime, "func SwigCgocall()\n");
+ Printf(f_go_runtime, "func SwigCgocallDone()\n");
+ Printf(f_go_runtime, "func SwigCgocallBack()\n");
+ Printf(f_go_runtime, "func SwigCgocallBackDone()\n\n");
+ }
// All the C++ wrappers should be extern "C".
// Set up the hash table for types not defined by SWIG.
+ undefined_enum_types = NewHash();
undefined_types = NewHash();
defined_types = NewHash();
+ go_imports = NewHash();
// Emit code.
Language::top(n);
+ Delete(go_imports);
+
// Write out definitions for the types not defined by SWIG.
+ if (Len(undefined_enum_types) > 0)
+ Printv(f_go_wrappers, "\n", NULL);
+ for (Iterator p = First(undefined_enum_types); p.key; p = Next(p)) {
+ String *name = p.item;
+ Printv(f_go_wrappers, "type ", name, " int\n", NULL);
+ }
+
Printv(f_go_wrappers, "\n", NULL);
for (Iterator p = First(undefined_types); p.key; p = Next(p)) {
String *ty = goType(NULL, p.key);
}
Delete(ty);
}
+ Delete(undefined_enum_types);
Delete(undefined_types);
Delete(defined_types);
// End the extern "C".
Printv(f_c_wrappers, "#ifdef __cplusplus\n", "}\n", "#endif\n\n", NULL);
+ if (cgo_flag) {
+ // End the cgo comment.
+ Printv(f_cgo_comment, "#undef intgo\n", NULL);
+ Printv(f_cgo_comment, "*/\n", NULL);
+ Printv(f_cgo_comment, "import \"C\"\n", NULL);
+ Printv(f_cgo_comment, "\n", NULL);
+ }
+
Dump(f_c_runtime, f_c_begin);
Dump(f_c_wrappers, f_c_begin);
Dump(f_c_init, f_c_begin);
+ if (cgo_flag) {
+ Dump(f_cgo_comment_typedefs, f_go_begin);
+ Dump(f_cgo_comment, f_go_begin);
+ }
+ Dump(f_go_imports, f_go_begin);
Dump(f_go_header, f_go_begin);
Dump(f_go_runtime, f_go_begin);
Dump(f_go_wrappers, f_go_begin);
- if (!gccgo_flag) {
+ if (directorsEnabled()) {
+ Dump(f_go_directors, f_go_begin);
+ }
+ if (!gccgo_flag && !cgo_flag) {
Dump(f_gc_header, f_gc_begin);
Dump(f_gc_runtime, f_gc_begin);
Dump(f_gc_wrappers, f_gc_begin);
Delete(f_c_header);
Delete(f_c_wrappers);
Delete(f_c_init);
+ Delete(f_go_imports);
Delete(f_go_runtime);
Delete(f_go_header);
Delete(f_go_wrappers);
- if (!gccgo_flag) {
+ Delete(f_go_directors);
+ if (!gccgo_flag && !cgo_flag) {
Delete(f_gc_runtime);
Delete(f_gc_header);
Delete(f_gc_wrappers);
}
+ if (cgo_flag) {
+ Delete(f_cgo_comment);
+ Delete(f_cgo_comment_typedefs);
+ }
Delete(f_c_begin);
Delete(f_go_begin);
- if (!gccgo_flag) {
+ if (!gccgo_flag && !cgo_flag) {
Delete(f_gc_begin);
}
String *hold_import = imported_package;
String *modname = Getattr(n, "module");
if (modname) {
- Printv(f_go_begin, "import \"", modname, "\"\n", NULL);
+ if (!Getattr(go_imports, modname)) {
+ Setattr(go_imports, modname, modname);
+ Printv(f_go_imports, "import \"", modname, "\"\n", NULL);
+ }
imported_package = modname;
saw_import = true;
}
}
/* ----------------------------------------------------------------------
+ * Language::insertDirective()
+ *
+ * If the section is go_imports, store them for later.
+ * ---------------------------------------------------------------------- */
+ virtual int insertDirective(Node *n) {
+ char *section = Char(Getattr(n, "section"));
+ if ((ImportMode && !Getattr(n, "generated")) ||
+ !section || (strcmp(section, "go_imports") != 0)) {
+ return Language::insertDirective(n);
+ }
+
+ char *code = Char(Getattr(n, "code"));
+ char *pch = strtok(code, ",");
+ while (pch != NULL) {
+ // Do not import same thing more than once.
+ if (!Getattr(go_imports, pch)) {
+ Setattr(go_imports, pch, pch);
+ Printv(f_go_imports, "import ", pch, "\n", NULL);
+ }
+ pch = strtok(NULL, ",");
+ }
+ return SWIG_OK;
+ }
+
+ /* ----------------------------------------------------------------------
* functionWrapper()
*
* Implement a function.
return SWIG_OK;
}
+ // Don't emit constructors for abstract director classes. They
+ // will never succeed anyhow.
+ if (Swig_methodclass(n) && Swig_directorclass(n)
+ && Strcmp(Char(Getattr(n, "wrap:action")), director_prot_ctor_code) == 0) {
+ return SWIG_OK;
+ }
+
String *name = Getattr(n, "sym:name");
String *nodetype = Getattr(n, "nodeType");
bool is_static = is_static_member_function || isStatic(n);
Delete(c2);
Delete(c1);
- if (Swig_methodclass(n) && Swig_directorclass(n)
- && Strcmp(Char(Getattr(n, "wrap:action")), director_prot_ctor_code) != 0) {
+ if (Swig_methodclass(n) && Swig_directorclass(n)) {
// The core SWIG code skips the first parameter when
// generating the $nondirector_new string. Recreate the
// action in this case. But don't it if we are using the
if (overname) {
Append(wname, overname);
}
+ Append(wname, unique_id);
Setattr(n, "wrap:name", wname);
ParmList *parms = Getattr(n, "parms");
assert(result);
- bool needs_wrapper;
- int r = goFunctionWrapper(n, name, go_name, overname, wname, base, parms, result, is_static, &needs_wrapper);
- if (r != SWIG_OK) {
- return r;
- }
+ int ret = SWIG_OK;
- if (!gccgo_flag) {
- r = gcFunctionWrapper(n, name, go_name, overname, wname, parms, result, is_static, needs_wrapper);
- if (r != SWIG_OK) {
- return r;
- }
- r = gccFunctionWrapper(n, base, wname, parms, result);
+ if (cgo_flag) {
+ int r = makeCgoWrappers(n, go_name, overname, wname, base, parms, result, is_static);
if (r != SWIG_OK) {
- return r;
+ ret = r;
}
} else {
- r = gccgoFunctionWrapper(n, base, wname, parms, result);
+ int r = goFunctionWrapper(n, name, go_name, overname, wname, base, parms, result, is_static);
if (r != SWIG_OK) {
- return r;
+ ret = r;
+ }
+
+ if (!gccgo_flag) {
+ r = gcFunctionWrapper(wname);
+ if (r != SWIG_OK) {
+ ret = r;
+ }
+ r = gccFunctionWrapper(n, base, wname, parms, result);
+ if (r != SWIG_OK) {
+ ret = r;
+ }
+ } else {
+ r = gccgoFunctionWrapper(n, base, wname, parms, result);
+ if (r != SWIG_OK) {
+ ret = r;
+ }
}
}
Setattr(class_methods, Getattr(n, "name"), NewString(""));
}
- return SWIG_OK;
+ return ret;
}
/* ----------------------------------------------------------------------
- * goFunctionWrapper()
+ * struct cgoWrapperInfo
*
- * Write out a function wrapper in Go. When not implementing a
- * method, the actual code is all in C; here we just declare the C
- * function. When implementing a method, we have to call the C
- * function, because it will have a different name. If base is not
- * NULL, then we are being called to forward a virtual method to a
- * base class.
+ * Information needed by the CGO wrapper functions.
* ---------------------------------------------------------------------- */
- int goFunctionWrapper(Node *n, String *name, String *go_name, String *overname, String *wname, List *base, ParmList *parms, SwigType *result, bool is_static, bool *p_needs_wrapper) {
- Wrapper *dummy = NewWrapper();
- emit_attach_parmmaps(parms, dummy);
- Swig_typemap_attach_parms("default", parms, dummy);
- Swig_typemap_attach_parms("gotype", parms, dummy);
- int parm_count = emit_num_arguments(parms);
- int required_count = emit_num_required(parms);
+ struct cgoWrapperInfo {
+ // The function we are generating code for.
+ Node *n;
+ // The name of the Go function.
+ String *go_name;
+ // The overload string for an overloaded function.
+ String *overname;
+ // The name of the C wrapper function.
+ String *wname;
+ // The base classes.
+ List *base;
+ // The parameters.
+ ParmList *parms;
+ // The result type.
+ SwigType *result;
+ // Whether this is a static function, not a class method.
+ bool is_static;
+ // The Go receiver type.
+ String *receiver;
+ // Whether this is a class constructor.
+ bool is_constructor;
+ // Whether this is a class destructor.
+ bool is_destructor;
+ };
- String *receiver = class_receiver;
- if (receiver && is_static) {
- receiver = NULL;
+ /* ----------------------------------------------------------------------
+ * makeCgoWrappers()
+ *
+ * Write out the wrappers for a function when producing cgo input
+ * files.
+ * ---------------------------------------------------------------------- */
+
+ int makeCgoWrappers(Node *n, String *go_name, String *overname, String *wname, List *base, ParmList *parms, SwigType *result, bool is_static) {
+ Swig_save("makeCgoWrappers", n, "emit:cgotype", "emit:cgotypestruct", NULL);
+
+ cgoWrapperInfo info;
+
+ info.n = n;
+ info.go_name = go_name;
+ info.overname = overname;
+ info.wname = wname;
+ info.base = base;
+ info.parms = parms;
+ info.result = result;
+ info.is_static = is_static;
+
+ info.receiver = class_receiver;
+ if (is_static) {
+ info.receiver = NULL;
}
String *nodetype = Getattr(n, "nodeType");
- bool is_constructor = Cmp(nodetype, "constructor") == 0;
- bool is_destructor = Cmp(nodetype, "destructor") == 0;
- if (is_constructor || is_destructor) {
+ info.is_constructor = Cmp(nodetype, "constructor") == 0;
+ info.is_destructor = Cmp(nodetype, "destructor") == 0;
+ if (info.is_constructor || info.is_destructor) {
assert(class_receiver);
assert(!base);
- receiver = NULL;
+ info.receiver = NULL;
}
- bool add_to_interface = (interfaces && !is_constructor && !is_destructor && !is_static && !overname && checkFunctionVisibility(n, NULL));
-
- bool needs_wrapper = (gccgo_flag || receiver || is_constructor || is_destructor || parm_count > required_count);
+ int ret = SWIG_OK;
- // See whether any of the function parameters are represented by
- // interface values When calling the C++ code, we need to convert
- // back to a uintptr.
- if (!needs_wrapper) {
- Parm *p = parms;
- for (int i = 0; i < parm_count; ++i) {
- p = getParm(p);
- String *ty = Getattr(p, "type");
- if (goTypeIsInterface(p, ty)) {
- needs_wrapper = true;
- break;
- }
- p = nextParm(p);
- }
- }
- if (goTypeIsInterface(n, result)) {
- needs_wrapper = true;
+ int r = cgoGoWrapper(&info);
+ if (r != SWIG_OK) {
+ ret = r;
}
- *p_needs_wrapper = needs_wrapper;
+ r = cgoCommentWrapper(&info);
+ if (r != SWIG_OK) {
+ ret = r;
+ }
- // If this is a method, first declare the C function we will call.
- // If we do not need a wrapper, then we will only be writing a
- // declaration.
- String *wrapper_name = NULL;
- if (needs_wrapper) {
- wrapper_name = buildGoWrapperName(name, overname);
+ r = cgoGccWrapper(&info);
+ if (r != SWIG_OK) {
+ ret = r;
+ }
- if (gccgo_flag) {
- Printv(f_go_wrappers, "//extern ", go_prefix, "_", wname, "\n", NULL);
- }
+ Swig_restore(n);
- Printv(f_go_wrappers, "func ", wrapper_name, "(", NULL);
- if (parm_count > required_count) {
- Printv(f_go_wrappers, "int", NULL);
- }
- Parm *p = getParm(parms);
- Swig_cparm_name(p, 0);
- int i = 0;
- if (is_destructor) {
- if (parm_count > required_count) {
- Printv(f_go_wrappers, ", ", NULL);
- }
- Printv(f_go_wrappers, "uintptr", NULL);
- ++i;
- p = nextParm(p);
- } else if (receiver && (base || !is_constructor)) {
- if (parm_count > required_count) {
- Printv(f_go_wrappers, ", ", NULL);
- }
- Printv(f_go_wrappers, receiver, NULL);
- if (!base) {
- ++i;
- p = nextParm(p);
- }
- }
- for (; i < parm_count; ++i) {
- p = getParm(p);
- // Give the parameter a name we will use below.
- Swig_cparm_name(p, i);
- if (i > 0 || (base && receiver) || parm_count > required_count) {
- Printv(f_go_wrappers, ", ", NULL);
- }
- String *tm = goWrapperType(p, Getattr(p, "type"), false);
- Printv(f_go_wrappers, tm, NULL);
- Delete(tm);
- p = nextParm(p);
- }
- Printv(f_go_wrappers, ")", NULL);
- if (is_constructor) {
- Printv(f_go_wrappers, " ", class_receiver, NULL);
- } else {
- if (SwigType_type(result) != T_VOID) {
- String *tm = goWrapperType(n, result, true);
- Printv(f_go_wrappers, " ", tm, NULL);
- Delete(tm);
- }
- }
+ return ret;
+ }
- Printv(f_go_wrappers, "\n\n", NULL);
- }
+ /* ----------------------------------------------------------------------
+ * cgoGoWrapper()
+ *
+ * Write out Go code to call a cgo function. This code will go into
+ * the generated Go output file.
+ * ---------------------------------------------------------------------- */
+ int cgoGoWrapper(const cgoWrapperInfo *info) {
- // Start defining the Go function.
+ Wrapper *dummy = initGoTypemaps(info->parms);
- if (!needs_wrapper && gccgo_flag) {
- Printv(f_go_wrappers, "//extern ", go_prefix, "_", wname, "\n", NULL);
- }
+ bool add_to_interface = interfaces && !info->is_constructor && !info->is_destructor && !info->is_static && !info->overname && checkFunctionVisibility(info->n, NULL);
Printv(f_go_wrappers, "func ", NULL);
- Parm *p = parms;
+ Parm *p = info->parms;
int pi = 0;
- // Add the receiver if this is a method.
- if (receiver) {
+ // Add the receiver first if this is a method.
+ if (info->receiver) {
Printv(f_go_wrappers, "(", NULL);
- if (base && receiver) {
+ if (info->base && info->receiver) {
Printv(f_go_wrappers, "_swig_base", NULL);
} else {
Printv(f_go_wrappers, Getattr(p, "lname"), NULL);
p = nextParm(p);
++pi;
}
- Printv(f_go_wrappers, " ", receiver, ") ", NULL);
+ Printv(f_go_wrappers, " ", info->receiver, ") ", NULL);
}
- Printv(f_go_wrappers, go_name, NULL);
- if (overname) {
- Printv(f_go_wrappers, overname, NULL);
+ Printv(f_go_wrappers, info->go_name, NULL);
+ if (info->overname) {
+ Printv(f_go_wrappers, info->overname, NULL);
}
Printv(f_go_wrappers, "(", NULL);
- // If we are doing methods, add this function to the interface.
+ // If we are doing methods, add this method to the interface.
if (add_to_interface) {
- Printv(interfaces, "\t", go_name, "(", NULL);
+ Printv(interfaces, "\t", info->go_name, "(", NULL);
}
// Write out the parameters to both the function definition and
String *parm_print = NewString("");
+ int parm_count = emit_num_arguments(info->parms);
+ int required_count = emit_num_required(info->parms);
+ int args = 0;
+
for (; pi < parm_count; ++pi) {
p = getParm(p);
- if (pi == 0 && is_destructor) {
+ if (pi == 0 && info->is_destructor) {
String *cl = exportedName(class_name);
Printv(parm_print, Getattr(p, "lname"), " ", cl, NULL);
Delete(cl);
+ ++args;
} else {
- if (pi > (receiver && !base ? 1 : 0)) {
+ if (args > 0) {
Printv(parm_print, ", ", NULL);
}
+ ++args;
if (pi >= required_count) {
Printv(parm_print, "_swig_args ...interface{}", NULL);
break;
}
- if (needs_wrapper) {
- Printv(parm_print, Getattr(p, "lname"), " ", NULL);
- }
+ Printv(parm_print, Getattr(p, "lname"), " ", NULL);
String *tm = goType(p, Getattr(p, "type"));
Printv(parm_print, tm, NULL);
Delete(tm);
Printv(parm_print, ")", NULL);
// Write out the result type.
- if (is_constructor) {
+ if (info->is_constructor) {
String *cl = exportedName(class_name);
- Printv(parm_print, " ", cl, NULL);
+ Printv(parm_print, " (_swig_ret ", cl, ")", NULL);
Delete(cl);
} else {
- if (SwigType_type(result) != T_VOID) {
- String *tm = goType(n, result);
- Printv(parm_print, " ", tm, NULL);
+ if (SwigType_type(info->result) != T_VOID) {
+ String *tm = goType(info->n, info->result);
+ Printv(parm_print, " (_swig_ret ", tm, ")", NULL);
Delete(tm);
}
}
Printv(interfaces, parm_print, "\n", NULL);
}
- // If this is a wrapper, we need to actually call the C function.
- if (needs_wrapper) {
- Printv(f_go_wrappers, " {\n", NULL);
+ // Write out the function body.
- if (parm_count > required_count) {
- Parm *p = parms;
- int i;
- for (i = 0; i < required_count; ++i) {
- p = getParm(p);
- p = nextParm(p);
- }
- for (; i < parm_count; ++i) {
- p = getParm(p);
- String *tm = goType(p, Getattr(p, "type"));
- Printv(f_go_wrappers, "\tvar ", Getattr(p, "lname"), " ", tm, "\n", NULL);
- Printf(f_go_wrappers, "\tif len(_swig_args) > %d {\n", i - required_count);
- Printf(f_go_wrappers, "\t\t%s = _swig_args[%d].(%s)\n", Getattr(p, "lname"), i - required_count, tm);
- Printv(f_go_wrappers, "\t}\n", NULL);
- Delete(tm);
- p = nextParm(p);
- }
- }
+ Printv(f_go_wrappers, " {\n", NULL);
- if (gccgo_flag) {
- if (!is_constructor) {
- Printv(f_go_wrappers, "\tdefer SwigCgocallDone()\n", NULL);
- Printv(f_go_wrappers, "\tSwigCgocall()\n", NULL);
- } else {
- // For a constructor the wrapper function will return a
- // uintptr but we will return an interface. We want to
- // convert the uintptr to the interface after calling
- // SwigCgocallDone, so that we don't try to allocate memory
- // while the Go scheduler can't see us.
- Printv(f_go_wrappers, "\tvar done bool\n", NULL);
- Printv(f_go_wrappers, "\tdefer func() {\n", NULL);
- Printv(f_go_wrappers, "\t\tif !done {\n", NULL);
- Printv(f_go_wrappers, "\t\t\tSwigCgocallDone()\n", NULL);
- Printv(f_go_wrappers, "\t\t}\n", NULL);
- Printv(f_go_wrappers, "\t}()\n", NULL);
- Printv(f_go_wrappers, "\tSwigCgocall()\n", NULL);
- }
+ if (parm_count > required_count) {
+ Parm *p = info->parms;
+ int i;
+ for (i = 0; i < required_count; ++i) {
+ p = getParm(p);
+ p = nextParm(p);
}
-
- Printv(f_go_wrappers, "\t", NULL);
- if (SwigType_type(result) != T_VOID) {
- if (gccgo_flag && is_constructor) {
- Printv(f_go_wrappers, "swig_r := ", NULL);
- } else {
- Printv(f_go_wrappers, "return ", NULL);
- }
+ for (; i < parm_count; ++i) {
+ p = getParm(p);
+ String *tm = goType(p, Getattr(p, "type"));
+ Printv(f_go_wrappers, "\tvar ", Getattr(p, "lname"), " ", tm, "\n", NULL);
+ Printf(f_go_wrappers, "\tif len(_swig_args) > %d {\n", i - required_count);
+ Printf(f_go_wrappers, "\t\t%s = _swig_args[%d].(%s)\n", Getattr(p, "lname"), i - required_count, tm);
+ Printv(f_go_wrappers, "\t}\n", NULL);
+ Delete(tm);
+ p = nextParm(p);
}
+ }
- Printv(f_go_wrappers, wrapper_name, "(", NULL);
+ String *call = NewString("\t");
- if (parm_count > required_count) {
- Printv(f_go_wrappers, "len(_swig_args)", NULL);
+ String *ret_type = NULL;
+ bool memcpy_ret = false;
+ String *wt = NULL;
+ if (SwigType_type(info->result) != T_VOID) {
+ if (info->is_constructor) {
+ ret_type = exportedName(class_name);
+ } else {
+ ret_type = goImType(info->n, info->result);
}
+ Printv(f_go_wrappers, "\tvar swig_r ", ret_type, "\n", NULL);
- if (base && receiver) {
- if (parm_count > required_count) {
- Printv(f_go_wrappers, ", ", NULL);
- }
- Printv(f_go_wrappers, "_swig_base", NULL);
+ bool c_struct_type;
+ Delete(cgoTypeForGoValue(info->n, info->result, &c_struct_type));
+ if (c_struct_type) {
+ memcpy_ret = true;
}
- Parm *p = parms;
- for (int i = 0; i < parm_count; ++i) {
- p = getParm(p);
- if (i > 0 || (base && receiver)
- || parm_count > required_count) {
- Printv(f_go_wrappers, ", ", NULL);
- }
- Printv(f_go_wrappers, Getattr(p, "lname"), NULL);
-
- // If this is a destructor, then the C function expects the
- // C++ value, and we have the interface. We need to get the
- // C++ value. The same is true for a type represented as an
- // interface.
- if ((i == 0 && is_destructor) || ((i > 0 || !receiver || base || is_constructor) && goTypeIsInterface(p, Getattr(p, "type")))) {
- Printv(f_go_wrappers, ".Swigcptr()", NULL);
- }
-
- p = nextParm(p);
+ if (memcpy_ret) {
+ Printv(call, "swig_r_p := ", NULL);
+ } else {
+ Printv(call, "swig_r = (", ret_type, ")(", NULL);
}
- Printv(f_go_wrappers, ")\n", NULL);
- if (gccgo_flag && is_constructor) {
- Printv(f_go_wrappers, "\tSwigCgocallDone()\n", NULL);
- Printv(f_go_wrappers, "\tdone = true\n", NULL);
- Printv(f_go_wrappers, "\treturn swig_r\n", NULL);
+ if (info->is_constructor || goTypeIsInterface(info->n, info->result)) {
+ if (info->is_constructor) {
+ wt = Copy(class_receiver);
+ } else {
+ wt = goWrapperType(info->n, info->result, true);
+ }
+ Printv(call, wt, "(", NULL);
}
-
- Printv(f_go_wrappers, "}\n", NULL);
}
- Printv(f_go_wrappers, "\n", NULL);
-
- Delete(wrapper_name);
- DelWrapper(dummy);
-
- return SWIG_OK;
- }
-
- /* ----------------------------------------------------------------------
- * gcFunctionWrapper()
- *
- * This is used for 6g/8g, not for gccgo. Write out the function
- * wrapper which will be compiled with 6c/8c.
- * ---------------------------------------------------------------------- */
-
- int gcFunctionWrapper(Node *n, String *name, String *go_name, String *overname, String *wname, ParmList *parms, SwigType *result, bool is_static, bool needs_wrapper) {
- Wrapper *f = NewWrapper();
-
- Printv(f->def, "#pragma dynimport ", wname, " ", wname, " \"\"\n", NULL);
- Printv(f->def, "extern void (*", wname, ")(void*);\n", NULL);
- Printv(f->def, "static void (*x", wname, ")(void*) = ", wname, ";\n", NULL);
- Printv(f->def, "\n", NULL);
- Printv(f->def, "void\n", NULL);
-
- Wrapper *dummy = NewWrapper();
- emit_attach_parmmaps(parms, dummy);
- Swig_typemap_attach_parms("default", parms, dummy);
- Swig_typemap_attach_parms("gosize", parms, dummy);
- int parm_count = emit_num_arguments(parms);
- int required_count = emit_num_required(parms);
+ Printv(call, "C.", info->wname, "(", NULL);
- String *parm_size = NewString("");
+ args = 0;
if (parm_count > required_count) {
- Append(parm_size, "SWIG_PARM_SIZE");
+ Printv(call, "C.swig_intgo(len(_swig_args))", NULL);
+ ++args;
}
- if (class_receiver && !is_static) {
- if (Len(parm_size) > 0) {
- Append(parm_size, " + ");
+ if (info->base && info->receiver) {
+ if (args > 0) {
+ Printv(call, ", ", NULL);
}
- Append(parm_size, "SWIG_PARM_SIZE");
+ ++args;
+ Printv(call, "C.uintptr_t(_swig_base)", NULL);
}
- Parm *p = parms;
+ p = info->parms;
for (int i = 0; i < parm_count; ++i) {
p = getParm(p);
- addGcTypeSize(p, Getattr(p, "type"), parm_size);
+ if (args > 0) {
+ Printv(call, ", ", NULL);
+ }
+ ++args;
+
+ SwigType *pt = Getattr(p, "type");
+ String *ln = Getattr(p, "lname");
+
+ String *ivar = NewStringf("_swig_i_%d", i);
+
+ String *goin = goGetattr(p, "tmap:goin");
+ if (goin == NULL) {
+ Printv(f_go_wrappers, "\t", ivar, " := ", ln, NULL);
+ if ((i == 0 && info->is_destructor) || ((i > 0 || !info->receiver || info->base || info->is_constructor) && goTypeIsInterface(p, pt))) {
+ Printv(f_go_wrappers, ".Swigcptr()", NULL);
+ }
+ Printv(f_go_wrappers, "\n", NULL);
+ Setattr(p, "emit:goinput", ln);
+ } else {
+ String *itm = goImType(p, pt);
+ Printv(f_go_wrappers, "\tvar ", ivar, " ", itm, "\n", NULL);
+ goin = Copy(goin);
+ Replaceall(goin, "$input", ln);
+ Replaceall(goin, "$result", ivar);
+ Printv(f_go_wrappers, goin, "\n", NULL);
+ Delete(goin);
+ Setattr(p, "emit:goinput", ivar);
+ }
+
+ bool c_struct_type;
+ String *ct = cgoTypeForGoValue(p, pt, &c_struct_type);
+ if (c_struct_type) {
+ Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL);
+ } else {
+ Printv(call, "C.", ct, "(", ivar, ")", NULL);
+ }
+ Delete(ct);
+
p = nextParm(p);
}
- if (SwigType_type(result) != T_VOID) {
- addGcTypeSize(n, result, parm_size);
- }
+ Printv(f_go_wrappers, call, ")", NULL);
+ Delete(call);
- if (Len(parm_size) == 0) {
- Append(parm_size, "1");
+ if (wt) {
+ // Close the type conversion to the wrapper type.
+ Printv(f_go_wrappers, ")", NULL);
+ }
+ if (SwigType_type(info->result) != T_VOID && !memcpy_ret) {
+ // Close the type conversion of the return value.
+ Printv(f_go_wrappers, ")", NULL);
}
- String *fn_name;
- if (!needs_wrapper) {
- fn_name = Copy(go_name);
- if (overname) {
- Append(fn_name, overname);
- }
- } else {
- fn_name = buildGoWrapperName(name, overname);
+ Printv(f_go_wrappers, "\n", NULL);
+
+ if (memcpy_ret) {
+ Printv(f_go_wrappers, "\tswig_r = *(*", ret_type, ")(unsafe.Pointer(&swig_r_p))\n", NULL);
+ }
+ if (ret_type) {
+ Delete(ret_type);
}
- // \xc2\xb7 is UTF-8 for U+00B7 which is Unicode 'Middle Dot'
- Printv(f->def, "\xc2\xb7", fn_name, "(struct { uint8 x[", parm_size, "];} p)", NULL);
+ goargout(info->parms);
- Delete(fn_name);
- Delete(parm_size);
+ if (SwigType_type(info->result) != T_VOID) {
- Printv(f->code, "{\n", NULL);
- Printv(f->code, "\truntime\xc2\xb7" "cgocall(x", wname, ", &p);\n", NULL);
- Printv(f->code, "}\n", NULL);
- Printv(f->code, "\n", NULL);
+ Swig_save("cgoGoWrapper", info->n, "type", "tmap:goout", NULL);
+ Setattr(info->n, "type", info->result);
- Wrapper_print(f, f_gc_wrappers);
+ String *goout = goTypemapLookup("goout", info->n, "swig_r");
+ if (goout == NULL) {
+ Printv(f_go_wrappers, "\treturn swig_r\n", NULL);
+ } else {
+ String *tm = goType(info->n, info->result);
+ Printv(f_go_wrappers, "\tvar swig_r_1 ", tm, "\n", NULL);
+ goout = Copy(goout);
+ Replaceall(goout, "$input", "swig_r");
+ Replaceall(goout, "$result", "swig_r_1");
+ Printv(f_go_wrappers, goout, "\n", NULL);
+ Printv(f_go_wrappers, "\treturn swig_r_1\n", NULL);
+ }
+
+ Swig_restore(info->n);
+ }
+
+ Printv(f_go_wrappers, "}\n\n", NULL);
- DelWrapper(f);
DelWrapper(dummy);
return SWIG_OK;
}
/* ----------------------------------------------------------------------
- * getGcTypeSize()
+ * cgoCommentWrapper()
*
- * Return the size to use when passing a type from 6g/8g to 6c/8c.
+ * Write out a cgo function to call a C/C++ function. This code
+ * will go into the cgo comment in the generated Go output file.
* ---------------------------------------------------------------------- */
-
- String *addGcTypeSize(Node *n, SwigType *type, String *orig) {
- if (Len(orig) > 0) {
- Append(orig, " + ");
- }
-
- String *go = goType(n, type);
- if (Cmp(go, "string") == 0) {
- // A string has a pointer and a length.
- Append(orig, "(2 * SWIG_PARM_SIZE)");
- } else if (Strncmp(go, "[]", 2) == 0) {
- // A slice has a pointer, a length, and a capacity.
- Append(orig, "(3 * SWIG_PARM_SIZE)");
- } else if (Strcmp(go, "float64") == 0) {
- Append(orig, "8");
- } else if (Strcmp(go, "complex64") == 0) {
- Append(orig, "8");
- } else if (Strcmp(go, "complex128") == 0) {
- Append(orig, "16");
+ int cgoCommentWrapper(const cgoWrapperInfo *info) {
+ String *ret_type;
+ if (SwigType_type(info->result) == T_VOID) {
+ ret_type = NewString("void");
} else {
- Append(orig, "SWIG_PARM_SIZE");
- }
-
- return orig;
- }
-
- /* ----------------------------------------------------------------------
- * gccFunctionWrapper()
- *
- * This is used for 6g/8g, not for gccgo. Write out the function
- * wrapper which will be compiled with gcc. If the base parameter
- * is not NULL, this is calls the base class method rather than
- * executing the SWIG wrapper code.
- * ---------------------------------------------------------------------- */
-
- int gccFunctionWrapper(Node *n, List *base, String *wname, ParmList *parms, SwigType *result) {
- Wrapper *f = NewWrapper();
-
- Swig_save("gccFunctionWrapper", n, "parms", NULL);
-
- Parm *base_parm = NULL;
- if (base && !isStatic(n)) {
- SwigType *base_type = Copy(getClassType());
- SwigType_add_pointer(base_type);
- base_parm = NewParm(base_type, NewString("arg1"), n);
- set_nextSibling(base_parm, parms);
- parms = base_parm;
+ bool c_struct_type;
+ ret_type = cgoTypeForGoValue(info->n, info->result, &c_struct_type);
}
- emit_parameter_variables(parms, f);
- emit_attach_parmmaps(parms, f);
- int parm_count = emit_num_arguments(parms);
- int required_count = emit_num_required(parms);
-
- emit_return_variable(n, result, f);
-
- // Start the function definition.
+ Printv(f_cgo_comment, "extern ", ret_type, " ", info->wname, "(", NULL);
- Printv(f->def, "void\n", wname, "(void *swig_v)\n", "{\n", NULL);
-
- // The single function parameter is a pointer to the real argument
- // values. Define the structure that it points to.
+ Delete(ret_type);
- Printv(f->code, "\tstruct swigargs {\n", NULL);
+ int parm_count = emit_num_arguments(info->parms);
+ int required_count = emit_num_required(info->parms);
+ int args = 0;
if (parm_count > required_count) {
- Printv(f->code, "\t\tintgo _swig_optargc;\n", NULL);
+ Printv(f_cgo_comment, "intgo _swig_args", NULL);
+ ++args;
}
- Parm *p = parms;
- for (int i = 0; i < parm_count; ++i) {
- p = getParm(p);
- String *ln = Getattr(p, "lname");
- SwigType *pt = Getattr(p, "type");
- String *ct = gcCTypeForGoValue(p, pt, ln);
- Printv(f->code, "\t\t\t", ct, ";\n", NULL);
- Delete(ct);
- p = nextParm(p);
- }
- if (SwigType_type(result) != T_VOID) {
- Printv(f->code, "\t\tlong : 0;\n", NULL);
- String *ln = NewString(Swig_cresult_name());
- String *ct = gcCTypeForGoValue(n, result, ln);
- Delete(ln);
- Printv(f->code, "\t\t", ct, ";\n", NULL);
- Delete(ct);
+ if (info->base && info->receiver) {
+ if (args > 0) {
+ Printv(f_cgo_comment, ", ", NULL);
+ }
+ ++args;
+ Printv(f_cgo_comment, "uintptr_t _swig_base", NULL);
}
- Printv(f->code, "\t} *swig_a = (struct swigargs *) swig_v;\n", NULL);
-
- Printv(f->code, "\n", NULL);
-
- // Copy the input arguments out of the structure into the
- // parameter variables.
- p = parms;
+ Parm *p = info->parms;
for (int i = 0; i < parm_count; ++i) {
p = getParm(p);
-
- String *tm = Getattr(p, "tmap:in");
- if (!tm) {
- Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument\n", SwigType_str(Getattr(p, "type"), 0));
- } else {
- String *ln = Getattr(p, "lname");
- String *input = NewString("");
- Printv(input, "swig_a->", ln, NULL);
- Replaceall(tm, "$input", input);
- Setattr(p, "emit:input", input);
- if (i < required_count) {
- Printv(f->code, "\t", tm, "\n", NULL);
- } else {
- Printf(f->code, "\tif (swig_a->_swig_optargc > %d) {\n", i - required_count);
- Printv(f->code, "\t\t", tm, "\n", NULL);
- Printv(f->code, "\t}\n", NULL);
- }
+ if (args > 0) {
+ Printv(f_cgo_comment, ", ", NULL);
}
- p = nextParm(p);
- }
-
- Printv(f->code, "\n", NULL);
+ ++args;
- // Do the real work of the function.
-
- checkConstraints(parms, f);
-
- emitGoAction(n, base, parms, result, f);
-
- argout(parms, f);
-
- cleanupFunction(n, f, parms);
+ SwigType *pt = Getattr(p, "type");
+ String *ln = Getattr(p, "lname");
- Printv(f->code, "}\n", NULL);
+ bool c_struct_type;
+ String *ct = cgoTypeForGoValue(p, pt, &c_struct_type);
+ Printv(f_cgo_comment, ct, " ", ln, NULL);
+ Delete(ct);
- Wrapper_print(f, f_c_wrappers);
+ p = nextParm(p);
+ }
- Swig_restore(n);
+ if (args == 0) {
+ Printv(f_cgo_comment, "void", NULL);
+ }
- DelWrapper(f);
- Delete(base_parm);
+ Printv(f_cgo_comment, ");\n", NULL);
return SWIG_OK;
}
/* ----------------------------------------------------------------------
- * gccgoFunctionWrapper()
+ * cgoGccWrapper()
*
- * This is used for gccgo, not 6g/8g. Write out the function
- * wrapper which will be compiled with gcc. If the base parameter
- * is not NULL, this is calls the base class method rather than
- * executing the SWIG wrapper code.
+ * Write out code to the C/C++ wrapper file. This code will be
+ * called by the code generated by cgoCommentWrapper.
* ---------------------------------------------------------------------- */
-
- int gccgoFunctionWrapper(Node *n, List *base, String *wname, ParmList *parms, SwigType *result) {
+ int cgoGccWrapper(const cgoWrapperInfo *info) {
Wrapper *f = NewWrapper();
- Swig_save("gccgoFunctionWrapper", n, "parms", NULL);
+ Swig_save("cgoGccWrapper", info->n, "parms", NULL);
+
+ ParmList *parms = info->parms;
Parm *base_parm = NULL;
- if (base && !isStatic(n)) {
+ if (info->base && !isStatic(info->n)) {
SwigType *base_type = Copy(getClassType());
SwigType_add_pointer(base_type);
- base_parm = NewParm(base_type, NewString("arg1"), n);
+ base_parm = NewParm(base_type, NewString("arg1"), info->n);
set_nextSibling(base_parm, parms);
parms = base_parm;
}
int parm_count = emit_num_arguments(parms);
int required_count = emit_num_required(parms);
- emit_return_variable(n, result, f);
+ emit_return_variable(info->n, info->result, f);
// Start the function definition.
String *fnname = NewString("");
- Printv(fnname, go_prefix, "_", wname, "(", NULL);
+ Printv(fnname, info->wname, "(", NULL);
+
+ int args = 0;
if (parm_count > required_count) {
Printv(fnname, "intgo _swig_optargc", NULL);
+ ++args;
}
Parm *p = parms;
for (int i = 0; i < parm_count; ++i) {
+ if (args > 0) {
+ Printv(fnname, ", ", NULL);
+ }
+ ++args;
+
p = getParm(p);
+
SwigType *pt = Copy(Getattr(p, "type"));
if (SwigType_isarray(pt)) {
SwigType_del_array(pt);
SwigType_add_pointer(pt);
}
- String *pn = NewString("g");
- Append(pn, Getattr(p, "lname"));
- String *ct = gccgoCTypeForGoValue(p, pt, pn);
- if (i > 0 || parm_count > required_count) {
- Printv(fnname, ", ", NULL);
- }
+ String *pn = NewStringf("_swig_go_%d", i);
+ String *ct = gcCTypeForGoValue(p, pt, pn);
Printv(fnname, ct, NULL);
Delete(ct);
Delete(pn);
Delete(pt);
+
p = nextParm(p);
}
-
+
Printv(fnname, ")", NULL);
- if (SwigType_type(result) == T_VOID) {
+ if (SwigType_type(info->result) == T_VOID) {
Printv(f->def, "void ", fnname, NULL);
} else {
- String *ct = gccgoCTypeForGoValue(n, result, fnname);
+ String *ct = gcCTypeForGoValue(info->n, info->result, fnname);
Printv(f->def, ct, NULL);
Delete(ct);
- }
- Printv(f->def, " {\n", NULL);
-
- Delete(fnname);
-
- if (SwigType_type(result) != T_VOID) {
- String *ln = NewString("go_result");
- String *ct = gccgoCTypeForGoValue(n, result, ln);
- Wrapper_add_local(f, "go_result", ct);
+ String *ln = NewString("_swig_go_result");
+ ct = gcCTypeForGoValue(info->n, info->result, ln);
+ Wrapper_add_local(f, "_swig_go_result", ct);
Delete(ct);
Delete(ln);
}
- // Copy the parameters into the variables which hold their values,
- // applying appropriate transformations.
+ Delete(fnname);
+
+ Printv(f->def, " {\n", NULL);
+
+ // Apply the in typemaps.
p = parms;
for (int i = 0; i < parm_count; ++i) {
p = getParm(p);
-
String *tm = Getattr(p, "tmap:in");
if (!tm) {
- Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number,
- "Unable to use type %s as a function argument\n", SwigType_str(Getattr(p, "type"), 0));
+ Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "unable to use type %s as a function argument\n", SwigType_str(Getattr(p, "type"), 0));
} else {
- String *ln = Getattr(p, "lname");
- String *pn = NewString("g");
- Append(pn, ln);
+ tm = Copy(tm);
+ String *pn = NewStringf("_swig_go_%d", i);
Replaceall(tm, "$input", pn);
- Setattr(p, "emit:input", pn);
if (i < required_count) {
- Printv(f->code, " ", tm, "\n", NULL);
+ Printv(f->code, "\t", tm, "\n", NULL);
} else {
- Printf(f->code, " if (_swig_optargc > %d) {\n", i - required_count);
- Printv(f->code, " ", tm, "\n", NULL);
- Printv(f->code, " }\n", NULL);
+ Printf(f->code, "\tif (_swig_optargc > %d) {\n", i - required_count);
+ Printv(f->code, "\t\t", tm, "\n", NULL);
+ Printv(f->code, "\t}\n", NULL);
}
+ Delete(tm);
+ Setattr(p, "emit:input", pn);
}
-
p = nextParm(p);
}
checkConstraints(parms, f);
- emitGoAction(n, base, parms, result, f);
+ emitGoAction(info->n, info->base, parms, info->result, f);
argout(parms, f);
- cleanupFunction(n, f, parms);
+ cleanupFunction(info->n, f, parms);
- if (SwigType_type(result) != T_VOID) {
- Printv(f->code, " return go_result;\n", NULL);
+ if (SwigType_type(info->result) != T_VOID) {
+ Printv(f->code, "\treturn _swig_go_result;\n", NULL);
+ }
+
+ Printv(f->code, "}\n", NULL);
+
+ Wrapper_print(f, f_c_wrappers);
+
+ Swig_restore(info->n);
+
+ DelWrapper(f);
+ if (base_parm) {
+ Delete(base_parm);
+ }
+
+ return SWIG_OK;
+ }
+
+ /* ----------------------------------------------------------------------
+ * goFunctionWrapper()
+ *
+ * Write out a function wrapper in Go. When not implementing a
+ * method, the actual code is all in C; here we just declare the C
+ * function. When implementing a method, we have to call the C
+ * function, because it will have a different name. If base is not
+ * NULL, then we are being called to forward a virtual method to a
+ * base class.
+ * ---------------------------------------------------------------------- */
+
+ int goFunctionWrapper(Node *n, String *name, String *go_name, String *overname, String *wname, List *base, ParmList *parms, SwigType *result, bool is_static) {
+ Wrapper *dummy = initGoTypemaps(parms);
+
+ int parm_count = emit_num_arguments(parms);
+ int required_count = emit_num_required(parms);
+
+ String *receiver = class_receiver;
+ if (receiver && is_static) {
+ receiver = NULL;
+ }
+
+ String *nodetype = Getattr(n, "nodeType");
+ bool is_constructor = Cmp(nodetype, "constructor") == 0;
+ bool is_destructor = Cmp(nodetype, "destructor") == 0;
+ if (is_constructor || is_destructor) {
+ assert(class_receiver);
+ assert(!base);
+ receiver = NULL;
+ }
+
+ Swig_save("cgoGoWrapper", n, "type", "tmap:goout", NULL);
+ Setattr(n, "type", result);
+
+ String *goout = goTypemapLookup("goout", n, "swig_r");
+
+ Swig_restore(n);
+
+ bool add_to_interface = (interfaces && !is_constructor && !is_destructor && !is_static && !overname && checkFunctionVisibility(n, NULL));
+
+ bool needs_wrapper = (gccgo_flag || receiver || is_constructor || is_destructor || parm_count > required_count);
+
+ bool has_goout = false;
+ if (goout) {
+ has_goout = true;
+ }
+
+ // See whether any of the function parameters are represented by
+ // interface values. When calling the C++ code, we need to convert
+ // back to a uintptr.
+ Parm *p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ String *ty = Getattr(p, "type");
+ if (goGetattr(p, "tmap:goargout")) {
+ has_goout = true;
+ needs_wrapper = true;
+ } else if (goTypeIsInterface(p, ty) || goGetattr(p, "tmap:goin")) {
+ needs_wrapper = true;
+ }
+
+ if (paramNeedsEscape(p)) {
+ needs_wrapper = true;
+ }
+
+ p = nextParm(p);
+ }
+ if (goTypeIsInterface(n, result) || goout != NULL) {
+ needs_wrapper = true;
+ }
+
+ if (!gccgo_flag) {
+ Printv(f_go_wrappers, "var ", wname, " unsafe.Pointer\n\n", NULL);
+ }
+
+ // If this is a method, first declare the C function we will call.
+ // If we do not need a wrapper, then we will only be writing a
+ // declaration.
+ String *wrapper_name = NULL;
+ if (needs_wrapper) {
+ wrapper_name = buildGoWrapperName(name, overname);
+
+ if (gccgo_flag) {
+ Printv(f_go_wrappers, "//extern ", go_prefix, "_", wname, "\n", NULL);
+ }
+
+ bool arg = false;
+ Printv(f_go_wrappers, "func ", wrapper_name, "(", NULL);
+ if (parm_count > required_count) {
+ Printv(f_go_wrappers, argName(&arg), " int", NULL);
+ }
+ Parm *p = getParm(parms);
+ int i = 0;
+ if (is_destructor) {
+ if (parm_count > required_count) {
+ Printv(f_go_wrappers, ", ", NULL);
+ }
+ Printv(f_go_wrappers, argName(&arg), " uintptr", NULL);
+ ++i;
+ p = nextParm(p);
+ } else if (receiver && (base || !is_constructor)) {
+ if (parm_count > required_count) {
+ Printv(f_go_wrappers, ", ", NULL);
+ }
+ Printv(f_go_wrappers, argName(&arg), " ", receiver, NULL);
+ if (!base) {
+ ++i;
+ p = nextParm(p);
+ }
+ }
+ for (; i < parm_count; ++i) {
+ p = getParm(p);
+ if (i > 0 || (base && receiver) || parm_count > required_count) {
+ Printv(f_go_wrappers, ", ", NULL);
+ }
+ String *tm = goWrapperType(p, Getattr(p, "type"), false);
+ Printv(f_go_wrappers, argName(&arg), " ", tm, NULL);
+ Delete(tm);
+ p = nextParm(p);
+ }
+ Printv(f_go_wrappers, ")", NULL);
+ if (is_constructor) {
+ Printv(f_go_wrappers, " (", argName(&arg), " ", class_receiver, ")", NULL);
+ } else {
+ if (SwigType_type(result) != T_VOID) {
+ String *tm = goWrapperType(n, result, true);
+ Printv(f_go_wrappers, " (", argName(&arg), " ", tm, ")", NULL);
+ Delete(tm);
+ }
+ }
+
+ if (!gccgo_flag) {
+ Printv(f_go_wrappers, " {\n", NULL);
+ if (arg) {
+ Printv(f_go_wrappers, "\t_swig_p := uintptr(unsafe.Pointer(&base))\n", NULL);
+ } else {
+ Printv(f_go_wrappers, "\tvar _swig_p uintptr\n", NULL);
+ }
+ Printv(f_go_wrappers, "\t_cgo_runtime_cgocall(", wname, ", _swig_p)\n", NULL);
+ Printv(f_go_wrappers, "\treturn\n", NULL);
+ Printv(f_go_wrappers, "}", NULL);
+ }
+
+ Printv(f_go_wrappers, "\n\n", NULL);
+ }
+
+ // Start defining the Go function.
+
+ if (!needs_wrapper && gccgo_flag) {
+ Printv(f_go_wrappers, "//extern ", go_prefix, "_", wname, "\n", NULL);
+ }
+
+ Printv(f_go_wrappers, "func ", NULL);
+
+ p = parms;
+ int pi = 0;
+
+ // Add the receiver if this is a method.
+ String *first = NULL;
+ if (receiver) {
+ Printv(f_go_wrappers, "(", NULL);
+ if (base && receiver) {
+ Printv(f_go_wrappers, "_swig_base", NULL);
+ if (first == NULL) {
+ first = NewString("_swig_base");
+ }
+ } else {
+ Printv(f_go_wrappers, Getattr(p, "lname"), NULL);
+ if (first == NULL) {
+ first = Copy(Getattr(p, "lname"));
+ }
+ p = nextParm(p);
+ ++pi;
+ }
+ Printv(f_go_wrappers, " ", receiver, ") ", NULL);
+ }
+
+ Printv(f_go_wrappers, go_name, NULL);
+ if (overname) {
+ Printv(f_go_wrappers, overname, NULL);
+ }
+ Printv(f_go_wrappers, "(", NULL);
+
+ // If we are doing methods, add this function to the interface.
+ if (add_to_interface) {
+ Printv(interfaces, "\t", go_name, "(", NULL);
+ }
+
+ // Write out the parameters to both the function definition and
+ // the interface.
+
+ String *parm_print = NewString("");
+
+ for (; pi < parm_count; ++pi) {
+ p = getParm(p);
+ if (pi == 0 && is_destructor) {
+ String *cl = exportedName(class_name);
+ Printv(parm_print, Getattr(p, "lname"), " ", cl, NULL);
+ if (first == NULL) {
+ first = Copy(Getattr(p, "lname"));
+ }
+ Delete(cl);
+ } else {
+ if (pi > (receiver && !base ? 1 : 0)) {
+ Printv(parm_print, ", ", NULL);
+ }
+ if (pi >= required_count) {
+ Printv(parm_print, "_swig_args ...interface{}", NULL);
+ if (first == NULL) {
+ first = NewString("_swig_args");
+ }
+ break;
+ }
+ Printv(parm_print, Getattr(p, "lname"), " ", NULL);
+ if (first == NULL) {
+ first = Copy(Getattr(p, "lname"));
+ }
+ String *tm = goType(p, Getattr(p, "type"));
+ Printv(parm_print, tm, NULL);
+ Delete(tm);
+ }
+ p = nextParm(p);
+ }
+
+ Printv(parm_print, ")", NULL);
+
+ // Write out the result type.
+ if (is_constructor) {
+ String *cl = exportedName(class_name);
+ Printv(parm_print, " (_swig_ret ", cl, ")", NULL);
+ if (first == NULL) {
+ first = NewString("_swig_ret");
+ }
+ Delete(cl);
+ } else {
+ if (SwigType_type(result) != T_VOID) {
+ String *tm = goType(n, result);
+ Printv(parm_print, " (_swig_ret ", tm, ")", NULL);
+ if (first == NULL) {
+ first = NewString("_swig_ret");
+ }
+ Delete(tm);
+ }
+ }
+
+ Printv(f_go_wrappers, parm_print, NULL);
+ if (add_to_interface) {
+ Printv(interfaces, parm_print, "\n", NULL);
+ }
+
+ // If this is a wrapper, we need to actually call the C function.
+ if (needs_wrapper) {
+ Printv(f_go_wrappers, " {\n", NULL);
+
+ if (parm_count > required_count) {
+ Parm *p = parms;
+ int i;
+ for (i = 0; i < required_count; ++i) {
+ p = getParm(p);
+ p = nextParm(p);
+ }
+ for (; i < parm_count; ++i) {
+ p = getParm(p);
+ String *tm = goType(p, Getattr(p, "type"));
+ Printv(f_go_wrappers, "\tvar ", Getattr(p, "lname"), " ", tm, "\n", NULL);
+ Printf(f_go_wrappers, "\tif len(_swig_args) > %d {\n", i - required_count);
+ Printf(f_go_wrappers, "\t\t%s = _swig_args[%d].(%s)\n", Getattr(p, "lname"), i - required_count, tm);
+ Printv(f_go_wrappers, "\t}\n", NULL);
+ Delete(tm);
+ p = nextParm(p);
+ }
+ }
+
+ String *call = NewString("");
+
+ bool need_return_var = SwigType_type(result) != T_VOID && ((gccgo_flag && is_constructor) || has_goout);
+ if (need_return_var) {
+ Printv(f_go_wrappers, "\tvar swig_r ", NULL);
+ if (is_constructor) {
+ String *cl = exportedName(class_name);
+ Printv(f_go_wrappers, cl, NULL);
+ Delete(cl);
+ } else {
+ Printv(f_go_wrappers, goImType(n, result), NULL);
+ }
+ Printv(f_go_wrappers, "\n", NULL);
+ }
+
+ if (gccgo_flag) {
+ if (has_goout || is_constructor) {
+ Printv(call, "\tfunc() {\n", NULL);
+ }
+ Printv(call, "\tdefer SwigCgocallDone()\n", NULL);
+ Printv(call, "\tSwigCgocall()\n", NULL);
+ }
+
+ Printv(call, "\t", NULL);
+ if (SwigType_type(result) != T_VOID) {
+ if (need_return_var) {
+ Printv(call, "swig_r = ", NULL);
+ } else {
+ Printv(call, "return ", NULL);
+ }
+ }
+
+ Printv(call, wrapper_name, "(", NULL);
+
+ if (parm_count > required_count) {
+ Printv(call, "len(_swig_args)", NULL);
+ }
+
+ if (base && receiver) {
+ if (parm_count > required_count) {
+ Printv(call, ", ", NULL);
+ }
+ Printv(call, "_swig_base", NULL);
+ }
+
+ Parm *p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ if (i > 0 || (base && receiver)
+ || parm_count > required_count) {
+ Printv(call, ", ", NULL);
+ }
+
+ SwigType *pt = Getattr(p, "type");
+ String *ln = Getattr(p, "lname");
+
+ String *goin = goGetattr(p, "tmap:goin");
+ if (goin == NULL) {
+ Printv(call, ln, NULL);
+ if ((i == 0 && is_destructor) || ((i > 0 || !receiver || base || is_constructor) && goTypeIsInterface(p, pt))) {
+ Printv(call, ".Swigcptr()", NULL);
+ }
+ Setattr(p, "emit:goinput", ln);
+ } else {
+ String *ivar = NewString("");
+ Printf(ivar, "_swig_i_%d", i);
+ String *itm = goImType(p, pt);
+ Printv(f_go_wrappers, "\tvar ", ivar, " ", itm, "\n", NULL);
+ goin = Copy(goin);
+ Replaceall(goin, "$input", ln);
+ Replaceall(goin, "$result", ivar);
+ Printv(f_go_wrappers, goin, "\n", NULL);
+ Delete(goin);
+ Printv(call, ivar, NULL);
+ Setattr(p, "emit:goinput", ivar);
+ }
+
+ // If the parameter has an argout or freearg typemap, make
+ // sure that it escapes.
+ if (paramNeedsEscape(p)) {
+ Printv(f_go_wrappers, "\tif Swig_escape_always_false {\n", NULL);
+ Printv(f_go_wrappers, "\t\tSwig_escape_val = ", Getattr(p, "emit:goinput"), "\n", NULL);
+ Printv(f_go_wrappers, "\t}\n", NULL);
+ }
+
+ p = nextParm(p);
+ }
+ Printv(call, ")\n", NULL);
+
+ if (gccgo_flag && (has_goout || is_constructor)) {
+ Printv(call, "\t}()\n", NULL);
+ }
+
+ Printv(f_go_wrappers, call, NULL);
+ Delete(call);
+
+ goargout(parms);
+
+ if (need_return_var) {
+ if (goout == NULL) {
+ Printv(f_go_wrappers, "\treturn swig_r\n", NULL);
+ } else {
+ String *tm = goType(n, result);
+ Printv(f_go_wrappers, "\tvar swig_r_1 ", tm, "\n", NULL);
+ Replaceall(goout, "$input", "swig_r");
+ Replaceall(goout, "$result", "swig_r_1");
+ Printv(f_go_wrappers, goout, "\n", NULL);
+ Printv(f_go_wrappers, "\treturn swig_r_1\n", NULL);
+ }
+ }
+
+ Printv(f_go_wrappers, "}\n", NULL);
+ } else if (!gccgo_flag) {
+ // We don't need a wrapper. If we're using gccgo, the function
+ // declaration is all we need--it has a //extern comment to
+ // GCC-compiled wrapper. If we're not using gccgo, we need to
+ // call the GCC-compiled wrapper here.
+ Printv(f_go_wrappers, " {\n", NULL);
+ if (first == NULL) {
+ Printv(f_go_wrappers, "\tvar _swig_p uintptr\n", NULL);
+ } else {
+ Printv(f_go_wrappers, "\t_swig_p := uintptr(unsafe.Pointer(&", first, "))\n", NULL);
+ }
+ Printv(f_go_wrappers, "\t_cgo_runtime_cgocall(", wname, ", _swig_p)\n", NULL);
+ Printv(f_go_wrappers, "\treturn\n", NULL);
+ Printv(f_go_wrappers, "}", NULL);
+ }
+
+ Printv(f_go_wrappers, "\n", NULL);
+
+ Delete(wrapper_name);
+ DelWrapper(dummy);
+
+ return SWIG_OK;
+ }
+
+ /* ----------------------------------------------------------------------
+ * initGoTypemaps()
+ *
+ * Initialize the typenames for a Go wrapper, returning a dummy
+ * Wrapper*. Also set consistent names for the parameters.
+ * ---------------------------------------------------------------------- */
+
+ Wrapper* initGoTypemaps(ParmList *parms) {
+ Wrapper *dummy = NewWrapper();
+ emit_attach_parmmaps(parms, dummy);
+
+ Parm *p = parms;
+ int parm_count = emit_num_arguments(parms);
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ Swig_cparm_name(p, i);
+ p = nextParm(p);
+ }
+
+ Swig_typemap_attach_parms("default", parms, dummy);
+ Swig_typemap_attach_parms("gotype", parms, dummy);
+ Swig_typemap_attach_parms("goin", parms, dummy);
+ Swig_typemap_attach_parms("goargout", parms, dummy);
+ Swig_typemap_attach_parms("imtype", parms, dummy);
+
+ return dummy;
+ }
+
+ /* ----------------------------------------------------------------------
+ * argName()
+ *
+ * A helper for goFunctionWrapper to output the first argument name
+ * as "base" and all others as "_".
+ * ---------------------------------------------------------------------- */
+
+ const char *argName(bool *arg) {
+ if (*arg) {
+ return "_";
+ }
+ *arg = true;
+ return "base";
+ }
+
+ /* ----------------------------------------------------------------------
+ * paramNeedsEscape()
+ *
+ * A helper for goFunctionWrapper that returns whether a parameter
+ * needs to explicitly escape. This is true if the parameter has a
+ * non-empty argout or freearg typemap, because in those cases the
+ * Go argument might be or contain a pointer. We need to ensure
+ * that that pointer does not point into the stack, which means that
+ * it needs to escape.
+ * ---------------------------------------------------------------------- */
+ bool paramNeedsEscape(Parm *p) {
+ String *argout = Getattr(p, "tmap:argout");
+ String *freearg = Getattr(p, "tmap:freearg");
+ if ((!argout || Len(argout) == 0) && (!freearg || Len(freearg) == 0)) {
+ return false;
+ }
+ // If a C++ type is represented as an interface type in Go, then
+ // we don't care whether it escapes, because we know that the
+ // pointer is a C++ pointer.
+ if (goTypeIsInterface(p, Getattr(p, "type"))) {
+ return false;
+ }
+ return true;
+ }
+
+ /* ----------------------------------------------------------------------
+ * gcFunctionWrapper()
+ *
+ * This is used for 6g/8g, not for gccgo. Write out the function
+ * redirector that will be compiled with 6c/8c. This used to write
+ * out a real function wrapper, but that has moved into Go code.
+ * ---------------------------------------------------------------------- */
+
+ int gcFunctionWrapper(String *wname) {
+ Wrapper *f = NewWrapper();
+
+ Printv(f->def, "#pragma dynimport ", wname, " ", wname, " \"\"\n", NULL);
+ Printv(f->def, "#pragma cgo_import_static ", wname, "\n", NULL);
+ Printv(f->def, "extern void ", wname, "(void*);\n", NULL);
+ // Declare this as a uintptr, since it is not a pointer into the
+ // Go heap.
+ // \xc2\xb7 is UTF-8 for U+00B7 which is Unicode 'Middle Dot'
+ Printv(f->def, "uintptr \xc2\xb7", wname, " = (uintptr)", wname, ";\n", NULL);
+
+ Wrapper_print(f, f_gc_wrappers);
+
+ DelWrapper(f);
+
+ return SWIG_OK;
+ }
+
+ /* ----------------------------------------------------------------------
+ * gccFunctionWrapper()
+ *
+ * This is used for 6g/8g, not for gccgo. Write out the function
+ * wrapper which will be compiled with gcc. If the base parameter
+ * is not NULL, this is calls the base class method rather than
+ * executing the SWIG wrapper code.
+ * ---------------------------------------------------------------------- */
+
+ int gccFunctionWrapper(Node *n, List *base, String *wname, ParmList *parms, SwigType *result) {
+ Wrapper *f = NewWrapper();
+
+ Swig_save("gccFunctionWrapper", n, "parms", NULL);
+
+ Parm *base_parm = NULL;
+ if (base && !isStatic(n)) {
+ SwigType *base_type = Copy(getClassType());
+ SwigType_add_pointer(base_type);
+ base_parm = NewParm(base_type, NewString("arg1"), n);
+ set_nextSibling(base_parm, parms);
+ parms = base_parm;
+ }
+
+ emit_parameter_variables(parms, f);
+ emit_attach_parmmaps(parms, f);
+ int parm_count = emit_num_arguments(parms);
+ int required_count = emit_num_required(parms);
+ bool needs_swigargs = false;
+
+ emit_return_variable(n, result, f);
+
+ // Start the function definition.
+
+ Printv(f->def, "void\n", wname, "(void *swig_v)\n", "{\n", NULL);
+
+ // The single function parameter is a pointer to the real argument
+ // values. Define the structure that it points to.
+
+ String *swigargs = NewString("\tstruct swigargs {\n");
+
+ if (parm_count > required_count) {
+ needs_swigargs = true;
+ Printv(swigargs, "\t\tintgo _swig_optargc;\n", NULL);
+ }
+
+ Parm *p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+
+ String *ln = Getattr(p, "lname");
+ SwigType *pt = Getattr(p, "type");
+ String *ct = gcCTypeForGoValue(p, pt, ln);
+ Printv(swigargs, "\t\t\t", ct, ";\n", NULL);
+ needs_swigargs = true;
+ Delete(ct);
+
+ String *gn = NewStringf("_swig_go_%d", i);
+ ct = gcCTypeForGoValue(p, pt, gn);
+ Setattr(p, "emit:input", gn);
+ Wrapper_add_local(f, gn, ct);
+ Delete(ct);
+
+ p = nextParm(p);
+ }
+ if (SwigType_type(result) != T_VOID) {
+ Printv(swigargs, "\t\tlong : 0;\n", NULL);
+ String *ln = NewString(Swig_cresult_name());
+ String *ct = gcCTypeForGoValue(n, result, ln);
+ Delete(ln);
+ Printv(swigargs, "\t\t", ct, ";\n", NULL);
+ needs_swigargs = true;
+ Delete(ct);
+
+ ln = NewString("_swig_go_result");
+ ct = gcCTypeForGoValue(n, result, ln);
+ Wrapper_add_local(f, "_swig_go_result", ct);
+ Delete(ct);
+ Delete(ln);
+ }
+ Printv(swigargs, "\t} SWIGSTRUCTPACKED *swig_a = (struct swigargs *) swig_v;\n", NULL);
+
+ // Copy the input arguments out of the structure into the Go local
+ // variables.
+ p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ String *ln = Getattr(p, "lname");
+ String *gn = Getattr(p, "emit:input");
+ Printv(f->code, "\t", gn, " = swig_a->", ln, ";\n", NULL);
+ p = nextParm(p);
+ }
+
+ // Apply the in typemaps.
+ p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ String *tm = Getattr(p, "tmap:in");
+ if (!tm) {
+ Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument\n", SwigType_str(Getattr(p, "type"), 0));
+ } else {
+ tm = Copy(tm);
+ String *gn = Getattr(p, "emit:input");
+ Replaceall(tm, "$input", gn);
+ if (i < required_count) {
+ Printv(f->code, "\t", tm, "\n", NULL);
+ } else {
+ Printf(f->code, "\tif (swig_a->_swig_optargc > %d) {\n", i - required_count);
+ Printv(f->code, "\t\t", tm, "\n", NULL);
+ Printv(f->code, "\t}\n", NULL);
+ }
+ Delete(tm);
+ }
+ p = nextParm(p);
+ }
+
+ Printv(f->code, "\n", NULL);
+
+ // Do the real work of the function.
+
+ checkConstraints(parms, f);
+
+ emitGoAction(n, base, parms, result, f);
+
+ argout(parms, f);
+
+ cleanupFunction(n, f, parms);
+
+ if (needs_swigargs)
+ {
+ Printv(f->locals, swigargs, NULL);
+ }
+
+ Printv(f->code, "}\n", NULL);
+
+ Wrapper_print(f, f_c_wrappers);
+
+ Swig_restore(n);
+
+ Delete(swigargs);
+ DelWrapper(f);
+ Delete(base_parm);
+
+ return SWIG_OK;
+ }
+
+ /* ----------------------------------------------------------------------
+ * gccgoFunctionWrapper()
+ *
+ * This is used for gccgo, not 6g/8g. Write out the function
+ * wrapper which will be compiled with gcc. If the base parameter
+ * is not NULL, this is calls the base class method rather than
+ * executing the SWIG wrapper code.
+ * ---------------------------------------------------------------------- */
+
+ int gccgoFunctionWrapper(Node *n, List *base, String *wname, ParmList *parms, SwigType *result) {
+ Wrapper *f = NewWrapper();
+
+ Swig_save("gccgoFunctionWrapper", n, "parms", NULL);
+
+ Parm *base_parm = NULL;
+ if (base && !isStatic(n)) {
+ SwigType *base_type = Copy(getClassType());
+ SwigType_add_pointer(base_type);
+ base_parm = NewParm(base_type, NewString("arg1"), n);
+ set_nextSibling(base_parm, parms);
+ parms = base_parm;
+ }
+
+ emit_parameter_variables(parms, f);
+ emit_attach_parmmaps(parms, f);
+ int parm_count = emit_num_arguments(parms);
+ int required_count = emit_num_required(parms);
+
+ emit_return_variable(n, result, f);
+
+ // Start the function definition.
+
+ String *fnname = NewString("");
+ Printv(fnname, "go_", wname, "(", NULL);
+
+ if (parm_count > required_count) {
+ Printv(fnname, "intgo _swig_optargc", NULL);
+ }
+
+ Parm *p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ SwigType *pt = Copy(Getattr(p, "type"));
+ if (SwigType_isarray(pt)) {
+ SwigType_del_array(pt);
+ SwigType_add_pointer(pt);
+ }
+ String *pn = NewString("g");
+ Append(pn, Getattr(p, "lname"));
+ String *ct = gccgoCTypeForGoValue(p, pt, pn);
+ if (i > 0 || parm_count > required_count) {
+ Printv(fnname, ", ", NULL);
+ }
+ Printv(fnname, ct, NULL);
+ Delete(ct);
+ Delete(pn);
+ Delete(pt);
+ p = nextParm(p);
+ }
+
+ Printv(fnname, ")", NULL);
+
+ String *fndef = NewString("");
+ if (SwigType_type(result) == T_VOID) {
+ Printv(fndef, "void ", fnname, NULL);
+ } else {
+ String *ct = gccgoCTypeForGoValue(n, result, fnname);
+ Printv(fndef, ct, NULL);
+ Delete(ct);
+ }
+
+ Printv(f->def, fndef, " __asm__(\"", go_prefix, "_", wname, "\");\n", NULL);
+
+ Printv(f->def, fndef, " {\n", NULL);
+
+ Delete(fnname);
+ Delete(fndef);
+
+ if (SwigType_type(result) != T_VOID) {
+ String *ln = NewString("_swig_go_result");
+ String *ct = gccgoCTypeForGoValue(n, result, ln);
+ Wrapper_add_local(f, "_swig_go_result", ct);
+ Delete(ct);
+ Delete(ln);
+ }
+
+ // Copy the parameters into the variables which hold their values,
+ // applying appropriate transformations.
+
+ p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+
+ String *tm = Getattr(p, "tmap:in");
+ if (!tm) {
+ Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number,
+ "Unable to use type %s as a function argument\n", SwigType_str(Getattr(p, "type"), 0));
+ } else {
+ String *ln = Getattr(p, "lname");
+ String *pn = NewString("g");
+ Append(pn, ln);
+ tm = Copy(tm);
+ Replaceall(tm, "$input", pn);
+ Setattr(p, "emit:input", pn);
+ if (i < required_count) {
+ Printv(f->code, " ", tm, "\n", NULL);
+ } else {
+ Printf(f->code, " if (_swig_optargc > %d) {\n", i - required_count);
+ Printv(f->code, " ", tm, "\n", NULL);
+ Printv(f->code, " }\n", NULL);
+ }
+ Delete(tm);
+ }
+
+ p = nextParm(p);
+ }
+
+ Printv(f->code, "\n", NULL);
+
+ // Do the real work of the function.
+
+ checkConstraints(parms, f);
+
+ emitGoAction(n, base, parms, result, f);
+
+ argout(parms, f);
+
+ cleanupFunction(n, f, parms);
+
+ if (SwigType_type(result) != T_VOID) {
+ Printv(f->code, " return _swig_go_result;\n", NULL);
}
Printv(f->code, "}\n", NULL);
if (!tm) {
p = nextSibling(p);
} else {
+ tm = Copy(tm);
Replaceall(tm, "$input", Getattr(p, "emit:input"));
Printv(f->code, tm, "\n\n", NULL);
+ Delete(tm);
p = Getattr(p, "tmap:check:next");
}
}
}
/* -----------------------------------------------------------------------
- * getGoAction()
+ * emitGoAction()
*
- * Get the action of the function. This is used for C/C++ function.
+ * Emit the action of the function. This is used for the C/C++ function.
* ----------------------------------------------------------------------- */
void emitGoAction(Node *n, List *base, ParmList *parms, SwigType *result, Wrapper *f) {
+ if (!gccgo_flag && !cgo_flag && SwigType_type(result) != T_VOID) {
+ Wrapper_add_local(f, "swig_stktop", "char *swig_stktop");
+ Printv(f->code, "\tswig_stktop = _swig_topofstack();\n", NULL);
+ }
String *actioncode;
if (!base || isStatic(n)) {
Swig_director_emit_dynamic_cast(n, f);
actioncode = NewString("");
String *current = NewString("");
- if (!gccgo_flag) {
+ if (!gccgo_flag && !cgo_flag) {
Printv(current, "swig_a->", NULL);
}
Printv(current, Getattr(parms, "lname"), NULL);
if (!tm) {
Swig_warning(WARN_TYPEMAP_OUT_UNDEF, input_file, line_number, "Unable to use return type %s\n", SwigType_str(result, 0));
} else {
- if (!gccgo_flag) {
- static const String *swig_a_result = NewStringf("swig_a->%s", Swig_cresult_name());
- Replaceall(tm, "$result", swig_a_result);
- } else {
- Replaceall(tm, "$result", "go_result");
- }
+ Replaceall(tm, "$result", "_swig_go_result");
if (GetFlag(n, "feature:new")) {
Replaceall(tm, "$owner", "1");
} else {
Delete(tm);
}
+ if (!gccgo_flag && !cgo_flag && SwigType_type(result) != T_VOID) {
+ // If the function called back into the Go code, the stack might
+ // have been copied. We need to adjust swig_a accordingly here.
+ // This is what cgo does.
+ Printv(f->code, "\tswig_a = (struct swigargs*)((char*)swig_a + (_swig_topofstack() - swig_stktop));\n", NULL);
+ Printv(f->code, "\tswig_a->", Swig_cresult_name(), " = ", "_swig_go_result;\n", NULL);
+ }
+
Swig_restore(n);
}
if (!tm) {
p = nextSibling(p);
} else {
+ tm = Copy(tm);
Replaceall(tm, "$result", Swig_cresult_name());
Replaceall(tm, "$input", Getattr(p, "emit:input"));
Printv(f->code, tm, "\n", NULL);
+ Delete(tm);
p = Getattr(p, "tmap:argout:next");
}
}
}
/* -----------------------------------------------------------------------
+ * goargout()
+ *
+ * Handle Go argument output code if any. This is used for the Go
+ * function. This assumes that each parameter has an "emit:goinput"
+ * property with the name to use to refer to that parameter.
+ * ----------------------------------------------------------------------- */
+
+ void goargout(ParmList *parms) {
+ Parm *p = parms;
+ while (p) {
+ String *tm = Getattr(p, "tmap:goargout");
+ if (!tm) {
+ p = nextSibling(p);
+ } else {
+ tm = Copy(tm);
+ Replaceall(tm, "$result", "swig_r");
+ Replaceall(tm, "$input", Getattr(p, "emit:goinput"));
+ Printv(f_go_wrappers, tm, "\n", NULL);
+ Delete(tm);
+ p = Getattr(p, "tmap:goargout:next");
+ }
+ }
+
+ // When using cgo, if we need to memcpy a parameter to pass it to
+ // the C code, the compiler may think that the parameter is not
+ // live during the function call. If the garbage collector runs
+ // while the C/C++ function is running, the parameter may be
+ // freed. Force the compiler to see the parameter as live across
+ // the C/C++ function.
+ if (cgo_flag) {
+ int parm_count = emit_num_arguments(parms);
+ p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ bool c_struct_type;
+ Delete(cgoTypeForGoValue(p, Getattr(p, "type"), &c_struct_type));
+ if (c_struct_type) {
+ Printv(f_go_wrappers, "\tif Swig_escape_always_false {\n", NULL);
+ Printv(f_go_wrappers, "\t\tSwig_escape_val = ", Getattr(p, "emit:goinput"), "\n", NULL);
+ Printv(f_go_wrappers, "\t}\n", NULL);
+ }
+ p = nextParm(p);
+ }
+ }
+ }
+
+ /* -----------------------------------------------------------------------
* freearg()
*
* Handle argument cleanup code if any. This is used for the C/C++
if (!tm) {
p = nextSibling(p);
} else {
+ tm = Copy(tm);
Replaceall(tm, "$input", Getattr(p, "emit:input"));
Printv(ret, tm, "\n", NULL);
+ Delete(tm);
p = Getattr(p, "tmap:freearg:next");
}
}
return goComplexConstant(n, type);
}
- if (Getattr(n, "storage") && Strcmp(Getattr(n, "storage"), "static") == 0) {
+ if (Swig_storage_isstatic(n)) {
return goComplexConstant(n, type);
}
// exponentiation. Treat anything else as too complicated to
// handle as a Go constant.
char *p = Char(value);
- int len = strlen(p);
+ int len = (int)strlen(p);
bool need_copy = false;
while (len > 0) {
char c = p[len - 1];
* ---------------------------------------------------------------------- */
virtual int enumDeclaration(Node *n) {
+ if (getCurrentClass() && (cplus_mode != PUBLIC))
+ return SWIG_NOWRAP;
+
String *name = goEnumName(n);
if (Strcmp(name, "int") != 0) {
if (!ImportMode || !imported_package) {
Printv(f_go_wrappers, "type ", name, " int\n", NULL);
} else {
String *nw = NewString("");
- Printv(nw, imported_package, ".", name, NULL);
+ Printv(nw, getModuleName(imported_package), ".", name, NULL);
Setattr(n, "go:enumname", nw);
}
}
if (!is_public(n)) {
return SWIG_OK;
}
- if (Getattr(parentNode(n), "unnamed")) {
+
+ Swig_require("enumvalueDeclaration", n, "*sym:name", NIL);
+ Node *parent = parentNode(n);
+
+ if (Getattr(parent, "unnamed")) {
Setattr(n, "type", NewString("int"));
} else {
- Setattr(n, "type", Getattr(parentNode(n), "enumtype"));
+ Setattr(n, "type", Getattr(parent, "enumtype"));
}
- return goComplexConstant(n, Getattr(n, "type"));
+
+ if (GetFlag(parent, "scopedenum")) {
+ String *symname = Getattr(n, "sym:name");
+ symname = Swig_name_member(0, Getattr(parent, "sym:name"), symname);
+ Setattr(n, "sym:name", symname);
+ Delete(symname);
+ }
+
+ int ret = goComplexConstant(n, Getattr(n, "type"));
+ Swig_restore(n);
+ return ret;
}
/* -----------------------------------------------------------------------
} else if (SwigType_type(type) == T_CHAR) {
quote = '\'';
} else if (SwigType_type(type) == T_STRING) {
+ Printv(get, "(char *)", NULL);
quote = '"';
} else {
quote = '\0';
Append(go_name, sname);
String *wname = Swig_name_wrapper(sname);
+ Append(wname, unique_id);
Setattr(n, "wrap:name", wname);
int r = makeWrappers(n, sname, go_name, NULL, wname, NULL, NULL, type, true);
}
Append(f_go_wrappers, interfaces);
- Printf(f_go_wrappers, "}\n\n", NULL);
+ Printv(f_go_wrappers, "}\n\n", NULL);
Delete(interfaces);
interfaces = NULL;
if (overname) {
Append(wname, overname);
}
+ Append(wname, unique_id);
String *result = NewString(Getattr(method, "type"));
SwigType_push(result, Getattr(method, "decl"));
Setattr(var, "type", var_type);
SwigType *vt = Copy(var_type);
- if (SwigType_isclass(vt)) {
- SwigType_add_pointer(vt);
- }
int flags = Extend | SmartPointer | use_naturalvar_mode(var);
if (isNonVirtualProtectedAccess(var)) {
flags |= CWRAP_ALL_PROTECTED_ACCESS;
}
+ // Copied from Swig_wrapped_member_var_type.
+ if (SwigType_isclass(vt)) {
+ if (flags & CWRAP_NATURAL_VAR) {
+ if (CPlusPlus) {
+ if (!SwigType_isconst(vt)) {
+ SwigType_add_qualifier(vt, "const");
+ }
+ SwigType_add_reference(vt);
+ }
+ } else {
+ SwigType_add_pointer(vt);
+ }
+ }
+
String *mname = Swig_name_member(getNSpace(), Getattr(var_class, "sym:name"), var_name);
if (is_assignable(var)) {
Swig_MembersetToFunction(var, class_name, flags);
String *wname = Swig_name_wrapper(mname_set);
+ Append(wname, unique_id);
ParmList *parms = NewParm(vt, var_name, var);
String *result = NewString("void");
int r = makeWrappers(var, mname_set, go_name, NULL, wname, bases, parms, result, false);
Append(go_name, var_name);
String *wname = Swig_name_wrapper(mname_get);
+ Append(wname, unique_id);
int r = makeWrappers(var, mname_get, go_name, NULL, wname, bases, NULL, vt, false);
if (r != SWIG_OK) {
Delete(c1);
String *wname = Swig_name_wrapper(name);
+ Append(wname, unique_id);
Setattr(n, "wrap:name", wname);
SwigType *result = Copy(Getattr(b.item, "classtypeobj"));
}
}
+ String *fn_with_over_name = Copy(fn_name);
+ if (overname) {
+ Append(fn_with_over_name, overname);
+ }
+
String *wname = Swig_name_wrapper(fn_name);
if (overname) {
Append(wname, overname);
}
+ Append(wname, unique_id);
Setattr(n, "wrap:name", wname);
bool is_static = isStatic(n);
DelWrapper(dummy);
Swig_typemap_attach_parms("gotype", parms, NULL);
+ Swig_typemap_attach_parms("goin", parms, NULL);
+ Swig_typemap_attach_parms("goargout", parms, NULL);
+ Swig_typemap_attach_parms("imtype", parms, NULL);
int parm_count = emit_num_arguments(parms);
String *func_name = NewString("NewDirector");
Append(func_with_over_name, overname);
}
- SwigType *first_type = NewString("void");
- SwigType_add_pointer(first_type);
+ SwigType *first_type = NewString("int");
Parm *first_parm = NewParm(first_type, "swig_p", n);
set_nextSibling(first_parm, parms);
Setattr(first_parm, "lname", "p");
}
if (!is_ignored) {
- // Declare the C++ wrapper.
+ if (cgo_flag) {
+ Printv(f_cgo_comment, "extern uintptr_t ", wname, "(int", NULL);
- if (gccgo_flag) {
- Printv(f_go_wrappers, "//extern ", go_prefix, "_", wname, "\n", NULL);
- }
+ p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ bool c_struct_type;
+ String *ct = cgoTypeForGoValue(p, Getattr(p, "type"), &c_struct_type);
+ Printv(f_cgo_comment, ", ", ct, " ", Getattr(p, "lname"), NULL);
+ p = nextParm(p);
+ }
+ Printv(f_cgo_comment, ");\n", NULL);
+ } else {
+ // Declare the C++ wrapper.
+
+ if (!gccgo_flag) {
+ Printv(f_go_wrappers, "var ", wname, " unsafe.Pointer\n\n", NULL);
+ } else {
+ Printv(f_go_wrappers, "//extern ", go_prefix, "_", wname, "\n", NULL);
+ }
+
+ Printv(f_go_wrappers, "func ", fn_with_over_name, "(_swig_director int", NULL);
+
+ p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ String *tm = goWrapperType(p, Getattr(p, "type"), false);
+ Printv(f_go_wrappers, ", _ ", tm, NULL);
+ Delete(tm);
+ p = nextParm(p);
+ }
+
+ Printv(f_go_wrappers, ") (_swig_ret ", go_type_name, ")", NULL);
- Printv(f_go_wrappers, "func ", fn_name, NULL);
- if (overname) {
- Printv(f_go_wrappers, overname, NULL);
+ if (!gccgo_flag) {
+ Printv(f_go_wrappers, " {\n", NULL);
+ Printv(f_go_wrappers, "\t_swig_p := uintptr(unsafe.Pointer(&_swig_director))\n", NULL);
+ Printv(f_go_wrappers, "\t_cgo_runtime_cgocall(", wname, ", _swig_p)\n", NULL);
+ Printv(f_go_wrappers, "\treturn\n", NULL);
+ Printv(f_go_wrappers, "}", NULL);
+ }
+
+ Printv(f_go_wrappers, "\n\n", NULL);
}
- Printv(f_go_wrappers, "(*", director_struct_name, NULL);
+
+ // Write out the Go function that calls the wrapper.
+
+ Printv(f_go_wrappers, "func ", func_with_over_name, "(v interface{}", NULL);
p = parms;
for (int i = 0; i < parm_count; ++i) {
p = getParm(p);
+ Printv(f_go_wrappers, ", ", Getattr(p, "lname"), " ", NULL);
String *tm = goType(p, Getattr(p, "type"));
- Printv(f_go_wrappers, ", ", tm, NULL);
+ Printv(f_go_wrappers, tm, NULL);
Delete(tm);
p = nextParm(p);
}
- Printv(f_go_wrappers, ") ", go_type_name, "\n\n", NULL);
+ Printv(f_go_wrappers, ") ", cn, " {\n", NULL);
- Printv(f_go_wrappers, "func ", func_with_over_name, "(v interface{}", NULL);
+ Printv(f_go_wrappers, "\tp := &", director_struct_name, "{0, v}\n", NULL);
+
+ if (gccgo_flag && !cgo_flag) {
+ Printv(f_go_wrappers, "\tdefer SwigCgocallDone()\n", NULL);
+ Printv(f_go_wrappers, "\tSwigCgocall()\n", NULL);
+ }
+
+ String *call = NewString("");
+
+ Printv(call, "\tp.", class_receiver, " = ", NULL);
+ if (cgo_flag) {
+ Printv(call, go_type_name, "(C.", wname, "(C.int(swigDirectorAdd(p))", NULL);
+ } else {
+ Printv(call, fn_with_over_name, "(swigDirectorAdd(p)", NULL);
+ }
p = parms;
for (int i = 0; i < parm_count; ++i) {
+ Printv(call, ", ", NULL);
+
p = getParm(p);
- // Set the lname parameter.
- Printv(f_go_wrappers, ", ", Getattr(p, "lname"), " ", NULL);
- String *tm = goType(p, Getattr(p, "type"));
- Printv(f_go_wrappers, tm, NULL);
- Delete(tm);
+ String *pt = Getattr(p, "type");
+ String *ln = Getattr(p, "lname");
+
+ String *ivar = NewStringf("_swig_i_%d", i);
+
+ String *goin = goGetattr(p, "tmap:goin");
+ if (goin == NULL) {
+ Printv(f_go_wrappers, "\t", ivar, " := ", ln, NULL);
+ if (goTypeIsInterface(p, pt)) {
+ Printv(f_go_wrappers, ".Swigcptr()", NULL);
+ }
+ Printv(f_go_wrappers, "\n", NULL);
+ } else {
+ String *itm = goImType(p, pt);
+ Printv(f_go_wrappers, "\tvar ", ivar, " ", itm, "\n", NULL);
+ goin = Copy(goin);
+ Replaceall(goin, "$input", ln);
+ Replaceall(goin, "$result", ivar);
+ Printv(f_go_wrappers, goin, "\n", NULL);
+ Delete(goin);
+ }
+
+ Setattr(p, "emit:goinput", ivar);
+
+ if (cgo_flag) {
+ bool c_struct_type;
+ String *ct = cgoTypeForGoValue(p, pt, &c_struct_type);
+ if (c_struct_type) {
+ Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL);
+ } else {
+ Printv(call, "C.", ct, "(", ivar, ")", NULL);
+ }
+ Delete(ct);
+ } else {
+ Printv(call, ivar, NULL);
+ }
p = nextParm(p);
}
- Printv(f_go_wrappers, ") ", cn, " {\n", NULL);
-
- Printv(f_go_wrappers, "\tp := &", director_struct_name, "{0, v}\n", NULL);
-
- if (gccgo_flag) {
- Printv(f_go_wrappers, "\tdefer SwigCgocallDone()\n", NULL);
- Printv(f_go_wrappers, "\tSwigCgocall()\n", NULL);
+ Printv(call, ")", NULL);
+ if (cgo_flag) {
+ Printv(call, ")", NULL);
}
- Printv(f_go_wrappers, "\tp.", class_receiver, " = ", fn_name, NULL);
- if (overname) {
- Printv(f_go_wrappers, overname, NULL);
- }
- Printv(f_go_wrappers, "(p", NULL);
+ Printv(f_go_wrappers, call, "\n", NULL);
- p = parms;
- for (int i = 0; i < parm_count; ++i) {
- p = getParm(p);
- Printv(f_go_wrappers, ", ", Getattr(p, "lname"), NULL);
- p = nextParm(p);
- }
+ goargout(parms);
- Printv(f_go_wrappers, ")\n", NULL);
Printv(f_go_wrappers, "\treturn p\n", NULL);
Printv(f_go_wrappers, "}\n\n", NULL);
Swig_save("classDirectorConstructor", n, "wrap:name", "wrap:action", NULL);
- Setattr(n, "wrap:name", Swig_name_wrapper(name));
+ String *dwname = Swig_name_wrapper(name);
+ Append(dwname, unique_id);
+ Setattr(n, "wrap:name", dwname);
String *action = NewString("");
Printv(action, Swig_cresult_name(), " = new SwigDirector_", class_name, "(", NULL);
Printv(action, ");", NULL);
Setattr(n, "wrap:action", action);
- if (!gccgo_flag) {
- int r = gcFunctionWrapper(n, fn_name, fn_name, overname, wname,
- first_parm, result, is_static, false);
+ if (cgo_flag) {
+ cgoWrapperInfo info;
+
+ info.n = n;
+ info.go_name = func_name;
+ info.overname = overname;
+ info.wname = wname;
+ info.base = NULL;
+ info.parms = first_parm;
+ info.result = result;
+ info.is_static = false;
+ info.receiver = NULL;
+ info.is_constructor = true;
+ info.is_destructor = false;
+
+ int r = cgoGccWrapper(&info);
+ if (r != SWIG_OK) {
+ return r;
+ }
+ } else if (!gccgo_flag) {
+ int r = gcFunctionWrapper(wname);
if (r != SWIG_OK) {
return r;
}
p = nextParm(p);
}
Printv(f_c_directors, "),\n", NULL);
- Printv(f_c_directors, " go_val(swig_p)\n", NULL);
+ Printv(f_c_directors, " go_val(swig_p), swig_mem(0)\n", NULL);
Printv(f_c_directors, "{ }\n\n", NULL);
if (Getattr(n, "sym:overloaded") && !Getattr(n, "sym:nextSibling")) {
Delete(go_type_name);
Delete(director_struct_name);
Delete(fn_name);
+ Delete(fn_with_over_name);
Delete(func_name);
Delete(func_with_over_name);
Delete(wname);
Delete(c1);
String *wname = Swig_name_wrapper(fnname);
+ Append(wname, unique_id);
Setattr(n, "wrap:name", fnname);
// Go code is keeping a pointer to the C++ object, we need to call
// back to the Go code to let it know that the C++ object is gone.
- String *wname = NewString("_swiggo_wrap_DeleteDirector_");
- Append(wname, class_name);
-
String *go_name = NewString("Swiggo_DeleteDirector_");
Append(go_name, class_name);
Printv(f_c_directors_h, ";\n", NULL);
- if (!is_ignored) {
- if (!gccgo_flag) {
- Printv(f_c_directors, "extern \"C\" void ", wname, "(void*, int);\n", NULL);
- } else {
- Printv(f_c_directors, "extern \"C\" void ", wname, "(void*) __asm__(\"", go_prefix, ".", package, ".", go_name, "\");\n", NULL);
- }
- }
+ String *director_sig = NewString("");
- Printv(f_c_directors, "SwigDirector_", class_name, "::~SwigDirector_", class_name, "()", NULL);
+ Printv(director_sig, "SwigDirector_", class_name, "::~SwigDirector_", class_name, "()", NULL);
if (throws) {
- Printv(f_c_directors, " ", throws, NULL);
+ Printv(director_sig, " ", throws, NULL);
Delete(throws);
}
- Printv(f_c_directors, "\n", NULL);
- Printv(f_c_directors, "{\n", NULL);
+ Printv(director_sig, "\n", NULL);
+ Printv(director_sig, "{\n", NULL);
- if (!is_ignored) {
- if (!gccgo_flag) {
- Printv(f_c_directors, " struct { void *p; } a;\n", NULL);
- Printv(f_c_directors, " a.p = go_val;\n", NULL);
- Printv(f_c_directors, " crosscall2(", wname, ", &a, (int) sizeof a);\n", NULL);
-
- Printv(f_gc_wrappers, "#pragma dynexport ", wname, " ", wname, "\n", NULL);
- Printv(f_gc_wrappers, "extern void \xc2\xb7", go_name, "();\n", NULL);
- Printv(f_gc_wrappers, "void\n", NULL);
- Printv(f_gc_wrappers, wname, "(void *a, int32 n)\n", NULL);
- Printv(f_gc_wrappers, "{\n", NULL);
- Printv(f_gc_wrappers, "\truntime\xc2\xb7" "cgocallback(\xc2\xb7", go_name, ", a, n);\n", NULL);
- Printv(f_gc_wrappers, "}\n\n", NULL);
- } else {
- Printv(f_c_directors, " ", wname, "(go_val);\n", NULL);
- }
+ if (is_ignored) {
+ Printv(f_c_directors, director_sig, NULL);
+ } else {
+ makeDirectorDestructorWrapper(go_name, director_struct_name, director_sig);
}
- Printv(f_c_directors, "}\n\n", NULL);
+ Printv(f_c_directors, " delete swig_mem;\n", NULL);
- if (!is_ignored) {
- Printv(f_go_wrappers, "func ", go_name, "(p *", director_struct_name, ") {\n", NULL);
- Printv(f_go_wrappers, "\tp.", class_receiver, " = 0\n", NULL);
- Printv(f_go_wrappers, "}\n\n", NULL);
- }
+ Printv(f_c_directors, "}\n\n", NULL);
- Delete(wname);
+ Delete(director_sig);
Delete(go_name);
Delete(cn);
Delete(director_struct_name);
}
/* ------------------------------------------------------------
+ * makeDirectorDestructorWrapper
+ *
+ * Emit the function wrapper for the destructor of a director class.
+ * This writes director_sig to f_c_directors and leaves the function
+ * unfinished.
+ * ------------------------------------------------------------ */
+
+ void makeDirectorDestructorWrapper(String *go_name, String *director_struct_name, String *director_sig) {
+ if (cgo_flag) {
+ makeCgoDirectorDestructorWrapper(go_name, director_struct_name, director_sig);
+ return;
+ }
+
+ Printv(f_go_wrappers, "func ", go_name, "(c int) {\n", NULL);
+ if (gccgo_flag) {
+ Printv(f_go_wrappers, "\tSwigCgocallBack()\n", NULL);
+ Printv(f_go_wrappers, "\tdefer SwigCgocallBackDone()\n", NULL);
+ }
+ Printv(f_go_wrappers, "\tswigDirectorLookup(c).(*", director_struct_name, ").", class_receiver, " = 0\n", NULL);
+ Printv(f_go_wrappers, "\tswigDirectorDelete(c)\n", NULL);
+ Printv(f_go_wrappers, "}\n\n", NULL);
+
+ String *wname = NewString("_swiggo_wrap_DeleteDirector_");
+ Append(wname, class_name);
+
+ if (!gccgo_flag) {
+ Printv(f_c_directors, "extern \"C\" void ", wname, "(void*, int);\n", NULL);
+ } else {
+ Printv(f_c_directors, "extern \"C\" void ", wname, "(intgo) __asm__(\"", go_prefix, ".", go_name, "\");\n", NULL);
+ }
+
+ Printv(f_c_directors, director_sig, NULL);
+
+ if (!gccgo_flag) {
+ Printv(f_c_directors, " struct { intgo p; } SWIGSTRUCTPACKED a;\n", NULL);
+ Printv(f_c_directors, " a.p = go_val;\n", NULL);
+ Printv(f_c_directors, " crosscall2(", wname, ", &a, (int) sizeof a);\n", NULL);
+
+ Printv(f_gc_wrappers, "#pragma dynexport ", wname, " ", wname, "\n", NULL);
+ Printv(f_gc_wrappers, "#pragma cgo_export_static ", wname, " ", wname, "\n", NULL);
+ Printv(f_gc_wrappers, "#pragma textflag 7\n", NULL);
+ Printv(f_gc_wrappers, "extern void \xc2\xb7", go_name, "();\n", NULL);
+ Printv(f_gc_wrappers, "void\n", NULL);
+ Printv(f_gc_wrappers, wname, "(void *a, int32 n)\n", NULL);
+ Printv(f_gc_wrappers, "{\n", NULL);
+ Printv(f_gc_wrappers, "\truntime\xc2\xb7" "cgocallback(\xc2\xb7", go_name, ", a, n);\n", NULL);
+ Printv(f_gc_wrappers, "}\n\n", NULL);
+ } else {
+ Printv(f_c_directors, " ", wname, "(go_val);\n", NULL);
+ }
+
+ Delete(wname);
+ }
+
+ /* ------------------------------------------------------------
+ * makeCgoDirectorDestructorWrapper
+ *
+ * When using cgo, emit the function wrapper for the destructor of a
+ * director class.
+ * ------------------------------------------------------------ */
+
+ void makeCgoDirectorDestructorWrapper(String *go_name, String *director_struct_name, String *director_sig) {
+ String *wname = Copy(go_name);
+ Append(wname, unique_id);
+
+ Printv(f_go_wrappers, "//export ", wname, "\n", NULL);
+ Printv(f_go_wrappers, "func ", wname, "(c int) {\n", NULL);
+ Printv(f_go_wrappers, "\tswigDirectorLookup(c).(*", director_struct_name, ").", class_receiver, " = 0\n", NULL);
+ Printv(f_go_wrappers, "\tswigDirectorDelete(c)\n", NULL);
+ Printv(f_go_wrappers, "}\n\n", NULL);
+
+ Printv(f_c_directors, "extern \"C\" void ", wname, "(intgo);\n", NULL);
+ Printv(f_c_directors, director_sig, NULL);
+ Printv(f_c_directors, " ", wname, "(go_val);\n", NULL);
+ }
+
+ /* ------------------------------------------------------------
* classDirectorMethod
*
* Emit a method for a director class, plus its overloads.
// set.
String *wn = Swig_name_wrapper(Getattr(on, "sym:name"));
Append(wn, Getattr(on, "sym:overname"));
+ Append(wn, unique_id);
Setattr(on, "wrap:name", wn);
Delete(wn);
Setattr(on, "wrap:parms", Getattr(on, "parms"));
return r;
}
- String *go_upcall = NewString("Director");
- Append(go_upcall, cn);
- Append(go_upcall, go_name);
- r = makeDispatchFunction(on, go_upcall, director_struct_name, is_static, director_struct_name, true);
- if (r != SWIG_OK) {
- return r;
+ if (!GetFlag(n, "abstract")) {
+ String *go_upcall = NewString("Director");
+ Append(go_upcall, cn);
+ Append(go_upcall, go_name);
+ r = makeDispatchFunction(on, go_upcall, director_struct_name, is_static, director_struct_name, true);
+ if (r != SWIG_OK) {
+ return r;
+ }
+ Delete(go_upcall);
}
- Delete(cn);
- Delete(go_name);
+
Delete(director_struct_name);
- Delete(go_upcall);
+ Delete(go_name);
+ Delete(cn);
}
}
Setattr(class_methods, name, NewString(""));
DelWrapper(dummy);
Swig_typemap_attach_parms("gotype", parms, NULL);
+ Swig_typemap_attach_parms("imtype", parms, NULL);
int parm_count = emit_num_arguments(parms);
SwigType *result = Getattr(n, "type");
if (overname) {
Append(callback_name, overname);
}
-
- String *callback_wname = Swig_name_wrapper(callback_name);
+ if (cgo_flag) {
+ Append(callback_name, unique_id);
+ }
String *upcall_name = Copy(director_struct_name);
Append(upcall_name, "_upcall_");
Append(upcall_name, go_name);
String *upcall_wname = Swig_name_wrapper(upcall_name);
+ if (overname) {
+ Append(upcall_wname, overname);
+ }
+ Append(upcall_wname, unique_id);
+
+ String *upcall_gc_name = buildGoWrapperName(upcall_name, overname);
String *go_with_over_name = Copy(go_name);
if (overname) {
Swig_typemap_attach_parms("directorin", parms, w);
Swig_typemap_attach_parms("directorargout", parms, w);
+ Swig_typemap_attach_parms("godirectorin", parms, w);
+ Swig_typemap_attach_parms("goin", parms, dummy);
+ Swig_typemap_attach_parms("goargout", parms, dummy);
if (!is_ignored) {
// We use an interface to see if this method is defined in Go.
Printv(f_go_wrappers, "\n", NULL);
Printv(f_go_wrappers, "}\n\n", NULL);
- // Declare the upcall function, which calls the method on the
- // parent class.
+ if (!GetFlag(n, "abstract")) {
+ if (cgo_flag) {
+ Printv(f_cgo_comment, "extern ", NULL);
- if (overname) {
- Append(upcall_wname, overname);
- }
+ if (SwigType_type(result) == T_VOID) {
+ Printv(f_cgo_comment, "void", NULL);
+ } else {
+ bool c_struct_type;
+ String *ret_type = cgoTypeForGoValue(n, result, &c_struct_type);
+ Printv(f_cgo_comment, ret_type, NULL);
+ Delete(ret_type);
+ }
- String *upcall_gc_name = buildGoWrapperName(upcall_name, overname);
+ Printv(f_cgo_comment, " ", upcall_wname, "(uintptr_t", NULL);
- if (gccgo_flag) {
- Printv(f_go_wrappers, "//extern ", go_prefix, "_", upcall_wname, "\n", NULL);
- }
+ p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ bool c_struct_type;
+ String *ct = cgoTypeForGoValue(p, Getattr(p, "type"), &c_struct_type);
+ Printv(f_cgo_comment, ", ", ct, " ", Getattr(p, "lname"), NULL);
+ p = nextParm(p);
+ }
+ Printv(f_cgo_comment, ");\n", NULL);
+ } else {
+ // Declare the upcall function, which calls the method on
+ // the parent class.
- Printv(f_go_wrappers, "func ", upcall_gc_name, "(", go_type_name, NULL);
+ if (!gccgo_flag) {
+ Printv(f_go_wrappers, "var ", upcall_wname, " unsafe.Pointer\n\n", NULL);
+ } else {
+ Printv(f_go_wrappers, "//extern ", go_prefix, "_", upcall_wname, "\n", NULL);
+ }
- p = parms;
- for (int i = 0; i < parm_count; ++i) {
- p = getParm(p);
- String *tm = goWrapperType(p, Getattr(p, "type"), false);
- Printv(f_go_wrappers, ", ", tm, NULL);
- Delete(tm);
- p = nextParm(p);
- }
+ Printv(f_go_wrappers, "func ", upcall_gc_name, "(_swig_ptr ", go_type_name, NULL);
- Printv(f_go_wrappers, ")", NULL);
+ p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ String *tm = goWrapperType(p, Getattr(p, "type"), false);
+ Printv(f_go_wrappers, ", _ ", tm, NULL);
+ Delete(tm);
+ p = nextParm(p);
+ }
- if (SwigType_type(result) != T_VOID) {
- String *tm = goWrapperType(n, result, true);
- Printv(f_go_wrappers, " ", tm, NULL);
- Delete(tm);
- }
+ Printv(f_go_wrappers, ")", NULL);
- Printv(f_go_wrappers, "\n", NULL);
+ if (SwigType_type(result) != T_VOID) {
+ String *tm = goWrapperType(n, result, true);
+ Printv(f_go_wrappers, " (_swig_ret ", tm, ")", NULL);
+ Delete(tm);
+ }
+
+ if (!gccgo_flag) {
+ Printv(f_go_wrappers, " {\n", NULL);
+ Printv(f_go_wrappers, "\t_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))\n", NULL);
+ Printv(f_go_wrappers, "\t_cgo_runtime_cgocall(", upcall_wname, ", _swig_p)\n", NULL);
+ Printv(f_go_wrappers, "\treturn\n", NULL);
+ Printv(f_go_wrappers, "}", NULL);
+ }
+
+ Printv(f_go_wrappers, "\n\n", NULL);
+ }
+ }
// Define the method on the director class in Go.
}
Printv(f_go_wrappers, "\t}\n", NULL);
- if (gccgo_flag) {
- Printv(f_go_wrappers, "\tdefer SwigCgocallDone()\n", NULL);
- Printv(f_go_wrappers, "\tSwigCgocall()\n", NULL);
- }
+ if (GetFlag(n, "abstract")) {
+ Printv(f_go_wrappers, "\tpanic(\"call to pure virtual method\")\n", NULL);
+ } else {
+ String *ret_type = NULL;
+ bool memcpy_ret = false;
+ String *wt = NULL;
+ bool has_goout = false;
+ String *goout = NULL;
+ if (SwigType_type(result) != T_VOID) {
+ ret_type = goImType(n, result);
+ Printv(f_go_wrappers, "\tvar swig_r ", ret_type, "\n", NULL);
+ goout = goTypemapLookup("goout", n, "swig_r");
+ if (goout) {
+ has_goout = true;
+ }
- Printv(f_go_wrappers, "\t", NULL);
- if (SwigType_type(result) != T_VOID) {
- Printv(f_go_wrappers, "return ", NULL);
- }
- Printv(f_go_wrappers, upcall_gc_name, "(swig_p.", go_type_name, NULL);
+ if (cgo_flag) {
+ bool c_struct_type;
+ Delete(cgoTypeForGoValue(n, result, &c_struct_type));
+ if (c_struct_type) {
+ memcpy_ret = true;
+ }
+ }
+ }
- p = parms;
- for (int i = 0; i < parm_count; ++i) {
- p = getParm(p);
- SwigType *pt = Getattr(p, "type");
- Printv(f_go_wrappers, ", ", Getattr(p, "lname"), NULL);
- if (goTypeIsInterface(p, pt)) {
- Printv(f_go_wrappers, ".Swigcptr()", NULL);
+ p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ if (goGetattr(p, "tmap:goargout")) {
+ has_goout = true;
+ }
+ p = nextParm(p);
+ }
+
+ String *call = NewString("");
+
+ if (gccgo_flag && !cgo_flag) {
+ if (has_goout) {
+ Printv(call, "\tfunc() {\n", NULL);
+ }
+ Printv(call, "\tdefer SwigCgocallDone()\n", NULL);
+ Printv(call, "\tSwigCgocall()\n", NULL);
+ }
+
+ Printv(call, "\t", NULL);
+ if (SwigType_type(result) != T_VOID) {
+ if (memcpy_ret) {
+ Printv(call, "swig_r_p := ", NULL);
+ } else {
+ Printv(call, "swig_r = ", NULL);
+ if (cgo_flag) {
+ Printv(call, "(", ret_type, ")(", NULL);
+ }
+ }
+ if (cgo_flag && goTypeIsInterface(n, result)) {
+ wt = goWrapperType(n, result, true);
+ Printv(call, "(", wt, ")(", NULL);
+ }
+ }
+
+ if (cgo_flag) {
+ Printv(call, "C.", upcall_wname, NULL);
+ } else {
+ Printv(call, upcall_gc_name, NULL);
+ }
+ Printv(call, "(", NULL);
+ if (cgo_flag) {
+ Printv(call, "C.uintptr_t(", NULL);
+ }
+ Printv(call, "swig_p.", go_type_name, NULL);
+ if (cgo_flag) {
+ Printv(call, ")", NULL);
+ }
+
+ p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ Printv(call, ", ", NULL);
+ p = getParm(p);
+ SwigType *pt = Getattr(p, "type");
+
+ String *ln = Getattr(p, "lname");
+
+ String *ivar = NewStringf("_swig_i_%d", i);
+
+ // This is an ordinary call from Go to C++, so adjust using
+ // the goin typemap.
+ String *goin = goGetattr(p, "tmap:goin");
+ if (goin == NULL) {
+ Printv(f_go_wrappers, "\t", ivar, " := ", ln, NULL);
+ if (goTypeIsInterface(p, pt)) {
+ Printv(f_go_wrappers, ".Swigcptr()", NULL);
+ }
+ Printv(f_go_wrappers, "\n", NULL);
+ } else {
+ String *itm = goImType(p, pt);
+ Printv(f_go_wrappers, "\tvar ", ivar, " ", itm, "\n", NULL);
+ goin = Copy(goin);
+ Replaceall(goin, "$input", ln);
+ Replaceall(goin, "$result", ivar);
+ Printv(f_go_wrappers, goin, NULL);
+ Delete(goin);
+ }
+
+ Setattr(p, "emit:goinput", ivar);
+
+ if (cgo_flag) {
+ bool c_struct_type;
+ String *ct = cgoTypeForGoValue(p, pt, &c_struct_type);
+ if (c_struct_type) {
+ Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL);
+ } else {
+ Printv(call, "C.", ct, "(", ivar, ")", NULL);
+ }
+ } else {
+ Printv(call, ivar, NULL);
+ }
+
+ p = nextParm(p);
+ }
+
+ Printv(call, ")", NULL);
+
+ if (gccgo_flag && !cgo_flag && has_goout) {
+ Printv(call, "\n\t}()", NULL);
+ }
+
+ if (cgo_flag) {
+ if (wt) {
+ // Close the type conversion to the wrapper type.
+ Printv(call, ")", NULL);
+ }
+ if (SwigType_type(result) != T_VOID && !memcpy_ret) {
+ // Close the type conversion of the return value.
+ Printv(call, ")", NULL);
+ }
+ }
+
+ Printv(call, "\n", NULL);
+
+ Printv(f_go_wrappers, call, NULL);
+ Delete(call);
+
+ if (memcpy_ret) {
+ Printv(f_go_wrappers, "\tswig_r = *(*", ret_type, ")(unsafe.Pointer(&swig_r_p))\n", NULL);
+ }
+
+ goargout(parms);
+
+ if (SwigType_type(result) != T_VOID) {
+ if (goout == NULL) {
+ Printv(f_go_wrappers, "\treturn swig_r\n", NULL);
+ } else {
+ String *tm = goType(n, result);
+ Printv(f_go_wrappers, "\tvar swig_r_1 ", tm, "\n", NULL);
+ Replaceall(goout, "$input", "swig_r");
+ Replaceall(goout, "$result", "swig_r_1");
+ Printv(f_go_wrappers, goout, "\n", NULL);
+ Printv(f_go_wrappers, "\treturn swig_r_1\n", NULL);
+ }
+ }
+
+ if (ret_type) {
+ Delete(ret_type);
+ }
+ if (wt) {
+ Delete(wt);
}
- p = nextParm(p);
}
- Printv(f_go_wrappers, ")\n", NULL);
Printv(f_go_wrappers, "}\n\n", NULL);
// Define a method in the C++ director class that the C++ upcall
// function can call. This permits an upcall to a protected
// method.
- String *upcall_method_name = NewString("_swig_upcall_");
- Append(upcall_method_name, name);
- if (overname) {
- Append(upcall_method_name, overname);
- }
- SwigType *rtype = Getattr(n, "classDirectorMethods:type");
- String *upcall_decl = Swig_method_decl(rtype, Getattr(n, "decl"), upcall_method_name, parms, 0, 0);
- Printv(f_c_directors_h, " ", upcall_decl, " {\n", NULL);
- Delete(upcall_decl);
+ if (!GetFlag(n, "abstract")) {
+ String *upcall_method_name = NewString("_swig_upcall_");
+ Append(upcall_method_name, name);
+ if (overname) {
+ Append(upcall_method_name, overname);
+ }
+ SwigType *rtype = Getattr(n, "classDirectorMethods:type");
+ String *upcall_decl = Swig_method_decl(rtype, Getattr(n, "decl"), upcall_method_name, parms, 0, 0);
+ Printv(f_c_directors_h, " ", upcall_decl, " {\n", NULL);
+ Delete(upcall_decl);
- Printv(f_c_directors_h, " ", NULL);
- if (SwigType_type(result) != T_VOID) {
- Printv(f_c_directors_h, "return ", NULL);
- }
+ Printv(f_c_directors_h, " ", NULL);
+ if (SwigType_type(result) != T_VOID) {
+ Printv(f_c_directors_h, "return ", NULL);
+ }
+
+ String *super_call = Swig_method_call(super, parms);
+ Printv(f_c_directors_h, super_call, ";\n", NULL);
+ Delete(super_call);
+
+ Printv(f_c_directors_h, " }\n", NULL);
+
+ // Define the C++ function that the Go function calls.
+
+ SwigType *first_type = NULL;
+ Parm *first_parm = parms;
+ if (!is_static) {
+ first_type = NewString("SwigDirector_");
+ Append(first_type, class_name);
+ SwigType_add_pointer(first_type);
+ first_parm = NewParm(first_type, "p", n);
+ set_nextSibling(first_parm, parms);
+ }
+
+ Swig_save("classDirectorMethod", n, "wrap:name", "wrap:action", NULL);
+
+ Setattr(n, "wrap:name", upcall_wname);
+
+ String *action = NewString("");
+ if (SwigType_type(result) != T_VOID) {
+ Printv(action, Swig_cresult_name(), " = (", SwigType_lstr(result, 0), ")", NULL);
+ if (SwigType_isreference(result)) {
+ Printv(action, "&", NULL);
+ }
+ }
+ Printv(action, Swig_cparm_name(NULL, 0), "->", upcall_method_name, "(", NULL);
+
+ p = parms;
+ int i = 0;
+ while (p != NULL) {
+ if (SwigType_type(Getattr(p, "type")) != T_VOID) {
+ String *pname = Swig_cparm_name(NULL, i + 1);
+ if (i > 0) {
+ Printv(action, ", ", NULL);
+ }
- String *super_call = Swig_method_call(super, parms);
- Printv(f_c_directors_h, super_call, ";\n", NULL);
- Delete(super_call);
+ // A parameter whose type is a reference is converted into a
+ // pointer type by gcCTypeForGoValue. We are calling a
+ // function which expects a reference so we need to convert
+ // back.
+ if (SwigType_isreference(Getattr(p, "type"))) {
+ Printv(action, "*", NULL);
+ }
+
+ Printv(action, pname, NULL);
+ Delete(pname);
+ i++;
+ }
+ p = nextSibling(p);
+ }
+ Printv(action, ");", NULL);
+ Setattr(n, "wrap:action", action);
+
+ if (cgo_flag) {
+ cgoWrapperInfo info;
+
+ info.n = n;
+ info.go_name = go_name;
+ info.overname = overname;
+ info.wname = upcall_wname;
+ info.base = NULL;
+ info.parms = first_parm;
+ info.result = result;
+ info.is_static = is_static;
+ info.receiver = NULL;
+ info.is_constructor = false;
+ info.is_destructor = false;
+
+ int r = cgoGccWrapper(&info);
+ if (r != SWIG_OK) {
+ return r;
+ }
+ } else if (!gccgo_flag) {
+ // Write the upcall wrapper function. This is compiled by gc
+ // and calls the C++ function.
+ int r = gcFunctionWrapper(upcall_wname);
+ if (r != SWIG_OK) {
+ return r;
+ }
+ r = gccFunctionWrapper(n, NULL, upcall_wname, first_parm, result);
+ if (r != SWIG_OK) {
+ return r;
+ }
+ } else {
+ int r = gccgoFunctionWrapper(n, NULL, upcall_wname, first_parm, result);
+ if (r != SWIG_OK) {
+ return r;
+ }
+ }
+
+ Delete(first_type);
+ if (first_parm != parms) {
+ Delete(first_parm);
+ }
+
+ Swig_restore(n);
+ Delete(upcall_method_name);
+
+ // Define a function that uses the Go director type that other
+ // methods in the Go type can call to get parent methods.
+
+ Printv(f_go_wrappers, "func Director", cn, go_with_over_name, "(p ", cn, NULL);
+
+ p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ p = getParm(p);
+ Printv(f_go_wrappers, ", ", Getattr(p, "lname"), " ", NULL);
+ String *tm = goType(p, Getattr(p, "type"));
+ Printv(f_go_wrappers, tm, NULL);
+ Delete(tm);
+ p = nextParm(p);
+ }
- Printv(f_c_directors_h, " }\n", NULL);
+ Printv(f_go_wrappers, ")", NULL);
- // Define the C++ function that the Go function calls.
+ if (SwigType_type(result) != T_VOID) {
+ String *tm = goType(n, result);
+ Printv(f_go_wrappers, " ", tm, NULL);
+ Delete(tm);
+ }
- SwigType *first_type = NULL;
- Parm *first_parm = parms;
- if (!is_static) {
- first_type = NewString("SwigDirector_");
- Append(first_type, class_name);
- SwigType_add_pointer(first_type);
- first_parm = NewParm(first_type, "p", n);
- set_nextSibling(first_parm, parms);
- }
+ Printv(f_go_wrappers, " {\n", NULL);
- Swig_save("classDirectorMethod", n, "wrap:name", "wrap:action", NULL);
+ String *ret_type = NULL;
+ bool memcpy_ret = false;
+ String *wt = NULL;
+ String *goout = NULL;
+ if (SwigType_type(result) != T_VOID) {
+ ret_type = goImType(n, result);
+ Printv(f_go_wrappers, "\tvar swig_r ", ret_type, "\n", NULL);
+ goout = goTypemapLookup("goout", n, "swig_r");
+
+ if (cgo_flag) {
+ bool c_struct_type;
+ Delete(cgoTypeForGoValue(n, result, &c_struct_type));
+ if (c_struct_type) {
+ memcpy_ret = true;
+ }
+ }
+ }
- Setattr(n, "wrap:name", upcall_wname);
+ String *call = NewString("");
- String *action = NewString("");
- if (SwigType_type(result) != T_VOID) {
- Printv(action, Swig_cresult_name(), " = (", SwigType_lstr(result, 0), ")", NULL);
- if (SwigType_isreference(result)) {
- Printv(action, "&", NULL);
+ if (gccgo_flag && !cgo_flag) {
+ if (goout != NULL) {
+ Printv(call, "\tfunc() {\n", NULL);
+ }
+ Printv(call, "\tdefer SwigCgocallDone()\n", NULL);
+ Printv(call, "\tSwigCgocall()\n", NULL);
}
- }
- Printv(action, Swig_cparm_name(NULL, 0), "->", upcall_method_name, "(", NULL);
- p = parms;
- int i = 0;
- while (p != NULL) {
- if (SwigType_type(Getattr(p, "type")) != T_VOID) {
- String *pname = Swig_cparm_name(NULL, i + 1);
- if (i > 0) {
- Printv(action, ", ", NULL);
+ Printv(call, "\t", NULL);
+ if (SwigType_type(result) != T_VOID) {
+ if (memcpy_ret) {
+ Printv(call, "swig_r_p := ", NULL);
+ } else {
+ Printv(call, "swig_r = ", NULL);
+ if (cgo_flag) {
+ Printv(call, "(", ret_type, ")(", NULL);
+ }
}
-
- // A parameter whose type is a reference is converted into a
- // pointer type by gcCTypeForGoValue. We are calling a
- // function which expects a reference so we need to convert
- // back.
- if (SwigType_isreference(Getattr(p, "type"))) {
- Printv(action, "*", NULL);
+ if (cgo_flag && goTypeIsInterface(n, result)) {
+ wt = goWrapperType(n, result, true);
+ Printv(call, "(", wt, ")(", NULL);
}
-
- Printv(action, pname, NULL);
- Delete(pname);
- i++;
}
- p = nextSibling(p);
- }
- Printv(action, ");", NULL);
- Setattr(n, "wrap:action", action);
- if (!gccgo_flag) {
- // Write the upcall wrapper function. This is compiled by gc
- // and calls the C++ function.
- int r = gcFunctionWrapper(n, upcall_name, upcall_name, overname, upcall_wname, first_parm, result, is_static, true);
- if (r != SWIG_OK) {
- return r;
+ if (cgo_flag) {
+ Printv(call, "C.", upcall_wname, NULL);
+ } else {
+ Printv(call, upcall_gc_name, NULL);
}
- r = gccFunctionWrapper(n, NULL, upcall_wname, first_parm, result);
- if (r != SWIG_OK) {
- return r;
+ Printv(call, "(", NULL);
+ if (cgo_flag) {
+ Printv(call, "C.uintptr_t(", NULL);
}
- } else {
- int r = gccgoFunctionWrapper(n, NULL, upcall_wname, first_parm, result);
- if (r != SWIG_OK) {
- return r;
+ Printv(call, "p.(*", director_struct_name, ").", go_type_name, NULL);
+ if (cgo_flag) {
+ Printv(call, ")", NULL);
}
- }
- Delete(first_type);
- if (first_parm != parms) {
- Delete(first_parm);
- }
+ p = parms;
+ for (int i = 0; i < parm_count; ++i) {
+ Printv(call, ", ", NULL);
+ p = getParm(p);
+ SwigType *pt = Getattr(p, "type");
- Swig_restore(n);
+ String *ivar = NewStringf("_swig_i_%d", i);
- // Define a function which uses the Go director type that other
- // methods in the Go type can call to get parent methods.
+ String *ln = Copy(Getattr(p, "lname"));
- Printv(f_go_wrappers, "func Director", cn, go_with_over_name, "(p ", cn, NULL);
+ String *goin = goGetattr(p, "tmap:goin");
+ if (goin == NULL) {
+ Printv(f_go_wrappers, "\t", ivar, " := ", ln, NULL);
+ if (goTypeIsInterface(p, pt)) {
+ Printv(f_go_wrappers, ".Swigcptr()", NULL);
+ }
+ Printv(f_go_wrappers, "\n", NULL);
+ } else {
+ String *itm = goImType(p, pt);
+ Printv(f_go_wrappers, "\tvar ", ivar, " ", itm, "\n", NULL);
+ goin = Copy(goin);
+ Replaceall(goin, "$input", ln);
+ Replaceall(goin, "$result", ivar);
+ Printv(f_go_wrappers, goin, NULL);
+ Delete(goin);
+ }
- p = parms;
- for (int i = 0; i < parm_count; ++i) {
- p = getParm(p);
- Printv(f_go_wrappers, ", ", Getattr(p, "lname"), " ", NULL);
- String *tm = goType(p, Getattr(p, "type"));
- Printv(f_go_wrappers, tm, NULL);
- Delete(tm);
- p = nextParm(p);
- }
+ Setattr(p, "emit:goinput", ivar);
- Printv(f_go_wrappers, ")", NULL);
+ if (cgo_flag) {
+ bool c_struct_type;
+ String *ct = cgoTypeForGoValue(p, pt, &c_struct_type);
+ if (c_struct_type) {
+ Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL);
+ } else {
+ Printv(call, "C.", ct, "(", ivar, ")", NULL);
+ }
+ } else {
+ Printv(call, ivar, NULL);
+ }
- if (SwigType_type(result) != T_VOID) {
- String *tm = goType(n, result);
- Printv(f_go_wrappers, " ", tm, NULL);
- Delete(tm);
- }
+ Delete(ln);
- Printv(f_go_wrappers, " {\n", NULL);
+ p = nextParm(p);
+ }
- if (gccgo_flag) {
- Printv(f_go_wrappers, "\tdefer SwigCgocallDone()\n", NULL);
- Printv(f_go_wrappers, "\tSwigCgocall()\n", NULL);
- }
+ Printv(call, ")", NULL);
- Printv(f_go_wrappers, "\t", NULL);
- if (SwigType_type(result) != T_VOID) {
- Printv(f_go_wrappers, "return ", NULL);
- }
- Printv(f_go_wrappers, upcall_gc_name, "(p.(*", director_struct_name, ").", go_type_name, NULL);
+ if (gccgo_flag && !cgo_flag && goout != NULL) {
+ Printv(call, "\n\t}()", NULL);
+ }
- p = parms;
- for (int i = 0; i < parm_count; ++i) {
- p = getParm(p);
- SwigType *pt = Getattr(p, "type");
- Printv(f_go_wrappers, ", ", Getattr(p, "lname"), NULL);
- if (goTypeIsInterface(p, pt)) {
- Printv(f_go_wrappers, ".Swigcptr()", NULL);
+ if (cgo_flag) {
+ if (wt) {
+ // Close the type conversion to the wrapper type.
+ Printv(call, ")", NULL);
+ }
+ if (SwigType_type(result) != T_VOID && !memcpy_ret) {
+ // Close the type conversion of the return value.
+ Printv(call, ")", NULL);
+ }
+ }
+
+ Printv(call, "\n", NULL);
+
+ Printv(f_go_wrappers, call, NULL);
+ Delete(call);
+
+ if (memcpy_ret) {
+ Printv(f_go_wrappers, "\tswig_r = *(*", ret_type, ")(unsafe.Pointer(&swig_r_p))\n", NULL);
+ }
+
+ goargout(parms);
+
+ if (SwigType_type(result) != T_VOID) {
+ if (goout == NULL) {
+ Printv(f_go_wrappers, "\treturn swig_r\n", NULL);
+ } else {
+ String *tm = goType(n, result);
+ Printv(f_go_wrappers, "\tvar swig_r_1 ", tm, "\n", NULL);
+ Replaceall(goout, "$input", "swig_r");
+ Replaceall(goout, "$result", "swig_r_1");
+ Printv(f_go_wrappers, goout, "\n", NULL);
+ Printv(f_go_wrappers, "\treturn swig_r_1\n", NULL);
+ }
+ }
+
+ Printv(f_go_wrappers, "}\n\n", NULL);
+
+ if (ret_type) {
+ Delete(ret_type);
+ }
+ if (wt) {
+ Delete(wt);
}
- p = nextParm(p);
}
- Printv(f_go_wrappers, ")\n", NULL);
- Printv(f_go_wrappers, "}\n\n", NULL);
+ // The Go function which invokes the method. This is called by
+ // the C++ method on the director class.
- // The Go function which invokes the method. This is called
- // from by the C++ method on the director class.
+ if (cgo_flag) {
+ Printv(f_go_wrappers, "//export ", callback_name, "\n", NULL);
+ }
- Printv(f_go_wrappers, "func ", callback_name, "(p *", director_struct_name, NULL);
+ Printv(f_go_wrappers, "func ", callback_name, "(swig_c int", NULL);
p = parms;
for (int i = 0; i < parm_count; ++i) {
}
Printv(f_go_wrappers, "{\n", NULL);
- if (gccgo_flag) {
- Printv(f_go_wrappers, "\tSwigCgocallBack()\n", NULL);
- Printv(f_go_wrappers, "\tdefer SwigCgocallBackDone()\n", NULL);
- }
-
- Printv(f_go_wrappers, "\t", NULL);
-
if (is_ignored) {
- Printv(f_go_wrappers, "return\n", NULL);
+ Printv(f_go_wrappers, "\treturn\n", NULL);
} else {
bool result_is_interface = false;
+ String *goout = NULL;
if (SwigType_type(result) != T_VOID) {
- Printv(f_go_wrappers, "return ", NULL);
result_is_interface = goTypeIsInterface(NULL, result);
+ Printv(f_go_wrappers, "\tvar swig_r ", NULL);
+ if (!result_is_interface) {
+ Printv(f_go_wrappers, goType(n, result), NULL);
+ } else {
+ Printv(f_go_wrappers, result_wrapper, NULL);
+ }
+ Printv(f_go_wrappers, "\n", NULL);
+ goout = goTypemapLookup("godirectorout", n, "swig_r");
+ }
+
+ String *call = NewString("");
+ Printv(call, "\t", NULL);
+
+ if (SwigType_type(result) != T_VOID) {
+ Printv(call, "swig_r = ", NULL);
if (result_is_interface) {
- Printv(f_go_wrappers, result_wrapper, "(", NULL);
+ Printv(call, result_wrapper, "(", NULL);
}
}
- Printv(f_go_wrappers, "p.", go_with_over_name, "(", NULL);
+ Printv(call, "swig_p.", go_with_over_name, "(", NULL);
+
+ String *goincode = NewString("");
p = parms;
for (int i = 0; i < parm_count; ++i) {
p = getParm(p);
if (i > 0) {
- Printv(f_go_wrappers, ", ", NULL);
+ Printv(call, ", ", NULL);
}
SwigType *pt = Getattr(p, "type");
+ String *ln = NewString("");
+
// If the Go representation is an interface type class, then
// we are receiving a uintptr, and must convert to the
// interface.
// Passing is_result as true to goWrapperType gives us the
// name of the Go type we need to convert to an interface.
String *wt = goWrapperType(p, pt, true);
- Printv(f_go_wrappers, wt, "(", NULL);
+ Printv(ln, wt, "(", NULL);
Delete(wt);
}
- Printv(f_go_wrappers, Getattr(p, "lname"), NULL);
+ Printv(ln, Getattr(p, "lname"), NULL);
if (is_interface) {
- Printv(f_go_wrappers, ")", NULL);
+ Printv(ln, ")", NULL);
+ }
+
+ String *goin = goGetattr(p, "tmap:godirectorin");
+ if (goin == NULL) {
+ Printv(call, ln, NULL);
+ } else {
+ String *ivar = NewString("");
+ Printf(ivar, "_swig_i_%d", i);
+ String *itm = goType(p, pt);
+ Printv(f_go_wrappers, "\tvar ", ivar, " ", itm, "\n", NULL);
+ goin = Copy(goin);
+ Replaceall(goin, "$input", ln);
+ Replaceall(goin, "$result", ivar);
+ Printv(goincode, goin, "\n", NULL);
+ Delete(goin);
+ Printv(call, ivar, NULL);
+ Delete(ivar);
}
+ Delete(ln);
+
p = nextParm(p);
}
- Printv(f_go_wrappers, ")", NULL);
+ Printv(call, ")", NULL);
if (result_is_interface) {
- Printv(f_go_wrappers, ".Swigcptr())", NULL);
+ Printv(call, ".Swigcptr())", NULL);
}
+ Printv(call, "\n", NULL);
- Printv(f_go_wrappers, "\n", NULL);
+ if (gccgo_flag && !cgo_flag) {
+ if (goout != NULL) {
+ Printv(f_go_wrappers, "\tfunc() {\n", NULL);
+ }
+ Printv(f_go_wrappers, "\tSwigCgocallBack()\n", NULL);
+ Printv(f_go_wrappers, "\tdefer SwigCgocallBackDone()\n", NULL);
+ }
+
+ Printv(f_go_wrappers, "\tswig_p := swigDirectorLookup(swig_c).(*", director_struct_name, ")\n", NULL);
+ Printv(f_go_wrappers, goincode, NULL);
+ Printv(f_go_wrappers, call, NULL);
+ Delete(call);
+
+ if (gccgo_flag && !cgo_flag && goout != NULL) {
+ Printv(f_go_wrappers, "\t}()\n", NULL);
+ }
- Delete(upcall_gc_name);
+ if (SwigType_type(result) != T_VOID) {
+ if (goout == NULL) {
+ Printv(f_go_wrappers, "\treturn swig_r\n", NULL);
+ } else {
+ String *tm = goImType(n, result);
+ Printv(f_go_wrappers, "\tvar swig_r_1 ", tm, "\n", NULL);
+ Replaceall(goout, "$input", "swig_r");
+ Replaceall(goout, "$result", "swig_r_1");
+ Printv(f_go_wrappers, goout, "\n", NULL);
+ Printv(f_go_wrappers, "\treturn swig_r_1\n", NULL);
+ }
+ }
}
Printv(f_go_wrappers, "}\n\n", NULL);
Delete(result_wrapper);
- // Build the C++ functions.
-
Delete(upcall_wname);
+ Delete(upcall_gc_name);
+ Delete(go_with_over_name);
+ }
- if (!gccgo_flag) {
- Printv(f_c_directors, "extern \"C\" void ", callback_wname, "(void*, int);\n", NULL);
+ if (!is_ignored || is_pure_virtual) {
+ // Declare the method for the director class.
+
+ SwigType *rtype = Getattr(n, "conversion_operator") ? 0 : Getattr(n, "classDirectorMethods:type");
+ String *decl = Swig_method_decl(rtype, Getattr(n, "decl"), Getattr(n, "name"), parms, 0, 0);
+ Printv(f_c_directors_h, " virtual ", decl, NULL);
+ Delete(decl);
+
+ String *qname = NewString("");
+ Printv(qname, "SwigDirector_", class_name, "::", Getattr(n, "name"), NULL);
+ decl = Swig_method_decl(rtype, Getattr(n, "decl"), qname, parms, 0, 0);
+ Printv(w->def, decl, NULL);
+ Delete(decl);
+ Delete(qname);
+
+ String *throws = buildThrow(n);
+ if (throws) {
+ Printv(f_c_directors_h, " ", throws, NULL);
+ Printv(w->def, " ", throws, NULL);
+ Delete(throws);
+ }
+
+ Printv(f_c_directors_h, ";\n", NULL);
+
+ Printv(w->def, " {\n", NULL);
+
+ if (SwigType_type(result) != T_VOID) {
+ Wrapper_add_local(w, "c_result", SwigType_lstr(result, "c_result"));
+ }
+
+ if (!is_ignored) {
+ makeDirectorMethodWrapper(n, w, callback_name);
+ } else {
+ assert(is_pure_virtual);
+ Printv(w->code, " _swig_gopanic(\"call to pure virtual function ", Getattr(parent, "sym:name"), name, "\");\n", NULL);
+ if (SwigType_type(result) != T_VOID) {
+ String *retstr = SwigType_rcaststr(result, "c_result");
+ Printv(w->code, " return ", retstr, ";\n", NULL);
+ Delete(retstr);
+ }
+ }
+
+ Printv(w->code, "}", NULL);
+
+ Replaceall(w->code, "$symname", symname);
+ Wrapper_print(w, f_c_directors);
+ }
+
+ Delete(cn);
+ Delete(go_type_name);
+ Delete(director_struct_name);
+ Delete(interface_name);
+ Delete(callback_name);
+ Delete(upcall_name);
+ Delete(go_name);
+ DelWrapper(w);
+
+ return SWIG_OK;
+ }
+
+ /* ------------------------------------------------------------
+ * makeDirectorMethodWrapper
+ *
+ * Emit the function wrapper for a director method.
+ * ------------------------------------------------------------ */
+ void makeDirectorMethodWrapper(Node *n, Wrapper *w, String *callback_name) {
+ if (cgo_flag) {
+ makeCgoDirectorMethodWrapper(n, w, callback_name);
+ return;
+ }
+
+ ParmList *parms = Getattr(n, "wrap:parms");
+ SwigType *result = Getattr(n, "type");
+
+ String *callback_wname = Swig_name_wrapper(callback_name);
+ Append(callback_wname, unique_id);
+
+ if (!gccgo_flag) {
+ Printv(f_c_directors, "extern \"C\" void ", callback_wname, "(void*, int);\n", NULL);
+ } else {
+ Printv(f_c_directors, "extern \"C\" ", NULL);
+
+ String *fnname = NewString("");
+ Printv(fnname, callback_wname, "(int", NULL);
+
+ Parm *p = parms;
+ while (p) {
+ while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
+ p = Getattr(p, "tmap:directorin:next");
+ }
+ String *cg = gccgoCTypeForGoValue(p, Getattr(p, "type"),
+ Getattr(p, "lname"));
+ Printv(fnname, ", ", cg, NULL);
+ Delete(cg);
+ p = Getattr(p, "tmap:directorin:next");
+ }
+
+ Printv(fnname, ")", NULL);
+
+ if (SwigType_type(result) == T_VOID) {
+ Printv(f_c_directors, "void ", fnname, NULL);
} else {
- Printv(f_c_directors, "extern \"C\" ", NULL);
+ String *tm = gccgoCTypeForGoValue(n, result, fnname);
+ Printv(f_c_directors, tm, NULL);
+ Delete(tm);
+ }
+
+ Delete(fnname);
+
+ Printv(f_c_directors, " __asm__(\"", go_prefix, ".", callback_name, "\");\n", NULL);
+ }
+
+ if (!gccgo_flag) {
+ Printv(w->code, " struct {\n", NULL);
+ Printv(w->code, " intgo go_val;\n", NULL);
+
+ Parm *p = parms;
+ while (p) {
+ while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
+ p = Getattr(p, "tmap:directorin:next");
+ }
+ String *ln = Getattr(p, "lname");
+ String *cg = gcCTypeForGoValue(p, Getattr(p, "type"), ln);
+ Printv(w->code, " ", cg, ";\n", NULL);
+ Delete(cg);
+ p = Getattr(p, "tmap:directorin:next");
+ }
+ if (SwigType_type(result) != T_VOID) {
+ Printv(w->code, " long : 0;\n", NULL);
+ String *rname = NewString(Swig_cresult_name());
+ String *cg = gcCTypeForGoValue(n, result, rname);
+ Printv(w->code, " ", cg, ";\n", NULL);
+ Delete(cg);
+ Delete(rname);
+ }
+
+ Printv(w->code, " } SWIGSTRUCTPACKED swig_a;\n", NULL);
+ Printv(w->code, " swig_a.go_val = go_val;\n", NULL);
+
+ p = parms;
+ while (p) {
+ while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
+ p = Getattr(p, "tmap:directorin:next");
+ }
+ String *tm = Getattr(p, "tmap:directorin");
+ if (!tm) {
+ Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file,
+ line_number, "Unable to use type %s as director method argument\n", SwigType_str(Getattr(p, "type"), 0));
+ } else {
+ tm = Copy(tm);
+ String *ln = Getattr(p, "lname");
+ String *input = NewString("");
+ Printv(input, "swig_a.", ln, NULL);
+ Setattr(p, "emit:directorinput", input);
+ Replaceall(tm, "$input", input);
+ Replaceall(tm, "$owner", "0");
+ Delete(input);
+ Printv(w->code, "\t", tm, "\n", NULL);
+ Delete(tm);
+ }
+ p = Getattr(p, "tmap:directorin:next");
+ }
+
+ Printv(w->code, " crosscall2(", callback_wname, ", &swig_a, (int) sizeof swig_a);\n", NULL);
+
+ /* Marshal outputs */
+ for (p = parms; p;) {
+ String *tm;
+ if ((tm = Getattr(p, "tmap:directorargout"))) {
+ tm = Copy(tm);
+ Replaceall(tm, "$result", "jresult");
+ Replaceall(tm, "$input", Getattr(p, "emit:directorinput"));
+ Printv(w->code, tm, "\n", NIL);
+ Delete(tm);
+ p = Getattr(p, "tmap:directorargout:next");
+ } else {
+ p = nextSibling(p);
+ }
+ }
+
+ if (SwigType_type(result) != T_VOID) {
+ String *result_str = NewString("c_result");
+ String *tm = Swig_typemap_lookup("directorout", n, result_str, NULL);
+ if (!tm) {
+ Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
+ "Unable to use type %s as director method result\n", SwigType_str(result, 0));
+ } else {
+ static const String *swig_a_result = NewStringf("swig_a.%s", Swig_cresult_name());
+ Replaceall(tm, "$input", swig_a_result);
+ Replaceall(tm, "$result", "c_result");
+ Printv(w->code, " ", tm, "\n", NULL);
+ String *retstr = SwigType_rcaststr(result, "c_result");
+ Printv(w->code, " return ", retstr, ";\n", NULL);
+ Delete(retstr);
+ Delete(tm);
+ }
+ Delete(result_str);
+ }
+
+ // The C wrapper code which calls the Go function.
+ Printv(f_gc_wrappers, "#pragma dynexport ", callback_wname, " ", callback_wname, "\n", NULL);
+ Printv(f_gc_wrappers, "#pragma cgo_export_static ", callback_wname, " ", callback_wname, "\n", NULL);
+ Printv(f_gc_wrappers, "#pragma textflag 7\n", NULL);
+ Printv(f_gc_wrappers, "extern void \xc2\xb7", callback_name, "();\n", NULL);
+ Printv(f_gc_wrappers, "void\n", NULL);
+ Printv(f_gc_wrappers, callback_wname, "(void *a, int32 n)\n", NULL);
+ Printv(f_gc_wrappers, "{\n", NULL);
+ Printv(f_gc_wrappers, "\truntime\xc2\xb7" "cgocallback(\xc2\xb7", callback_name, ", a, n);\n", NULL);
+ Printv(f_gc_wrappers, "}\n\n", NULL);
+ } else {
+ if (SwigType_type(result) != T_VOID) {
+ String *r = NewString(Swig_cresult_name());
+ String *tm = gccgoCTypeForGoValue(n, result, r);
+ Wrapper_add_local(w, r, tm);
+ Delete(tm);
+ Delete(r);
+ }
- String *fnname = NewString("");
- Printv(fnname, callback_wname, "(void*", NULL);
+ String *args = NewString("");
- p = parms;
- while (p) {
- while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
- p = Getattr(p, "tmap:directorin:next");
- }
- String *cg = gccgoCTypeForGoValue(p, Getattr(p, "type"),
- Getattr(p, "lname"));
- Printv(fnname, ", ", cg, NULL);
- Delete(cg);
+ Parm *p = parms;
+ while (p) {
+ while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
p = Getattr(p, "tmap:directorin:next");
}
- Printv(fnname, ")", NULL);
+ String *pn = NewString("g");
+ Append(pn, Getattr(p, "lname"));
+ Setattr(p, "emit:directorinput", pn);
+
+ String *tm = gccgoCTypeForGoValue(n, Getattr(p, "type"), pn);
+ Wrapper_add_local(w, pn, tm);
+ Delete(tm);
- if (SwigType_type(result) == T_VOID) {
- Printv(f_c_directors, "void ", fnname, NULL);
+ tm = Getattr(p, "tmap:directorin");
+ if (!tm) {
+ Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file,
+ line_number, "Unable to use type %s as director method argument\n", SwigType_str(Getattr(p, "type"), 0));
} else {
- String *tm = gccgoCTypeForGoValue(n, result, fnname);
- Printv(f_c_directors, tm, NULL);
+ tm = Copy(tm);
+ Replaceall(tm, "$input", pn);
+ Replaceall(tm, "$owner", 0);
+ Printv(w->code, " ", tm, "\n", NULL);
Delete(tm);
- }
- Delete(fnname);
+ Printv(args, ", ", pn, NULL);
+ }
- Printv(f_c_directors, " __asm__(\"", go_prefix, ".", package, ".", callback_name, "\");\n", NULL);
+ p = Getattr(p, "tmap:directorin:next");
}
- Delete(upcall_method_name);
- Delete(go_with_over_name);
- }
-
- if (!is_ignored || is_pure_virtual) {
- // Declare the method for the director class.
-
- SwigType *rtype = Getattr(n, "conversion_operator") ? 0 : Getattr(n, "classDirectorMethods:type");
- String *decl = Swig_method_decl(rtype, Getattr(n, "decl"), Getattr(n, "name"), parms, 0, 0);
- Printv(f_c_directors_h, " virtual ", decl, NULL);
- Delete(decl);
-
- String *qname = NewString("");
- Printv(qname, "SwigDirector_", class_name, "::", Getattr(n, "name"), NULL);
- decl = Swig_method_decl(rtype, Getattr(n, "decl"), qname, parms, 0, 0);
- Printv(w->def, decl, NULL);
- Delete(decl);
- Delete(qname);
-
- String *throws = buildThrow(n);
- if (throws) {
- Printv(f_c_directors_h, " ", throws, NULL);
- Printv(w->def, " ", throws, NULL);
- Delete(throws);
+ Printv(w->code, " ", NULL);
+ if (SwigType_type(result) != T_VOID) {
+ Printv(w->code, Swig_cresult_name(), " = ", NULL);
+ }
+ Printv(w->code, callback_wname, "(go_val", args, ");\n", NULL);
+
+ /* Marshal outputs */
+ for (p = parms; p;) {
+ String *tm;
+ if ((tm = Getattr(p, "tmap:directorargout"))) {
+ tm = Copy(tm);
+ Replaceall(tm, "$result", "jresult");
+ Replaceall(tm, "$input", Getattr(p, "emit:directorinput"));
+ Printv(w->code, tm, "\n", NIL);
+ Delete(tm);
+ p = Getattr(p, "tmap:directorargout:next");
+ } else {
+ p = nextSibling(p);
+ }
}
- Printv(f_c_directors_h, ";\n", NULL);
-
- Printv(w->def, " {\n", NULL);
-
if (SwigType_type(result) != T_VOID) {
- Wrapper_add_local(w, "c_result", SwigType_lstr(result, "c_result"));
+ String *result_str = NewString("c_result");
+ String *tm = Swig_typemap_lookup("directorout", n, result_str, NULL);
+ if (!tm) {
+ Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
+ "Unable to use type %s as director method result\n", SwigType_str(result, 0));
+ } else {
+ Replaceall(tm, "$input", Swig_cresult_name());
+ Replaceall(tm, "$result", "c_result");
+ Printv(w->code, " ", tm, "\n", NULL);
+ String *retstr = SwigType_rcaststr(result, "c_result");
+ Printv(w->code, " return ", retstr, ";\n", NULL);
+ Delete(retstr);
+ Delete(tm);
+ }
+ Delete(result_str);
}
+ }
- if (!is_ignored) {
- if (!gccgo_flag) {
- Printv(w->code, " struct {\n", NULL);
- Printv(w->code, " void *go_val;\n", NULL);
-
- p = parms;
- while (p) {
- while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
- p = Getattr(p, "tmap:directorin:next");
- }
- String *ln = Getattr(p, "lname");
- String *cg = gcCTypeForGoValue(p, Getattr(p, "type"), ln);
- Printv(w->code, " ", cg, ";\n", NULL);
- Delete(cg);
- p = Getattr(p, "tmap:directorin:next");
- }
- if (SwigType_type(result) != T_VOID) {
- Printv(w->code, " long : 0;\n", NULL);
- String *rname = NewString(Swig_cresult_name());
- String *cg = gcCTypeForGoValue(n, result, rname);
- Printv(w->code, " ", cg, ";\n", NULL);
- Delete(cg);
- Delete(rname);
- }
+ Delete(callback_wname);
+ }
- Printv(w->code, " } swig_a;\n", NULL);
- Printv(w->code, " swig_a.go_val = go_val;\n", NULL);
+ /* ------------------------------------------------------------
+ * makeDirectorMethodWrapper
+ *
+ * Emit the function wrapper for a director method for cgo.
+ * ------------------------------------------------------------ */
- p = parms;
- while (p) {
- while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
- p = Getattr(p, "tmap:directorin:next");
- }
- String *tm = Getattr(p, "tmap:directorin");
- if (!tm) {
- Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file,
- line_number, "Unable to use type %s as director method argument\n", SwigType_str(Getattr(p, "type"), 0));
- } else {
- String *ln = Getattr(p, "lname");
- String *input = NewString("");
- Printv(input, "swig_a.", ln, NULL);
- Setattr(p, "emit:directorinput", input);
- Replaceall(tm, "$input", input);
- Replaceall(tm, "$owner", "0");
- Delete(input);
- Printv(w->code, "\t", tm, "\n", NULL);
- }
- p = Getattr(p, "tmap:directorin:next");
- }
+ void makeCgoDirectorMethodWrapper(Node *n, Wrapper *w, String *callback_name) {
+ ParmList *parms = Getattr(n, "wrap:parms");
+ SwigType *result = Getattr(n, "type");
- Printv(w->code, " crosscall2(", callback_wname, ", &swig_a, (int) sizeof swig_a);\n", NULL);
+ Printv(f_c_directors, "extern \"C\" ", NULL);
- if (SwigType_type(result) != T_VOID) {
- String *result_str = NewString("c_result");
- String *tm = Swig_typemap_lookup("directorout", n, result_str, NULL);
- if (!tm) {
- Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
- "Unable to use type %s as director method result\n", SwigType_str(result, 0));
- } else {
- static const String *swig_a_result = NewStringf("swig_a.%s", Swig_cresult_name());
- Replaceall(tm, "$input", swig_a_result);
- Replaceall(tm, "$result", "c_result");
- Printv(w->code, " ", tm, "\n", NULL);
- String *retstr = SwigType_rcaststr(result, "c_result");
- Printv(w->code, " return ", retstr, ";\n", NULL);
- Delete(retstr);
- Delete(tm);
- }
- Delete(result_str);
- }
+ String *fnname = Copy(callback_name);
+ Append(fnname, "(int");
- // The C wrapper code which calls the Go function.
- Printv(f_gc_wrappers, "#pragma dynexport ", callback_wname, " ", callback_wname, "\n", NULL);
- Printv(f_gc_wrappers, "extern void \xc2\xb7", callback_name, "();\n", NULL);
- Printv(f_gc_wrappers, "void\n", NULL);
- Printv(f_gc_wrappers, callback_wname, "(void *a, int32 n)\n", NULL);
- Printv(f_gc_wrappers, "{\n", NULL);
- Printv(f_gc_wrappers, "\truntime\xc2\xb7" "cgocallback(\xc2\xb7", callback_name, ", a, n);\n", NULL);
- Printv(f_gc_wrappers, "}\n\n", NULL);
- } else {
- if (SwigType_type(result) != T_VOID) {
- String *r = NewString(Swig_cresult_name());
- String *tm = gccgoCTypeForGoValue(n, result, r);
- Wrapper_add_local(w, r, tm);
- Delete(tm);
- Delete(r);
- }
+ Parm *p = parms;
+ while (p) {
+ while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
+ p = Getattr(p, "tmap:directorin:next");
+ }
+ String *cg = gcCTypeForGoValue(p, Getattr(p, "type"), Getattr(p, "lname"));
+ Printv(fnname, ", ", cg, NULL);
+ Delete(cg);
+ p = Getattr(p, "tmap:directorin:next");
+ }
- String *args = NewString("");
+ Printv(fnname, ")", NULL);
- p = parms;
- while (p) {
- while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
- p = Getattr(p, "tmap:directorin:next");
- }
+ if (SwigType_type(result) == T_VOID) {
+ Printv(f_c_directors, "void ", fnname, NULL);
+ } else {
+ String *tm = gcCTypeForGoValue(n, result, fnname);
+ Printv(f_c_directors, tm, NULL);
+ Delete(tm);
+ }
- String *pn = NewString("g");
- Append(pn, Getattr(p, "lname"));
- Setattr(p, "emit:input", pn);
+ Delete(fnname);
- String *tm = gccgoCTypeForGoValue(n, Getattr(p, "type"), pn);
- Wrapper_add_local(w, pn, tm);
- Delete(tm);
+ Printv(f_c_directors, ";\n", NULL);
- tm = Getattr(p, "tmap:directorin");
- if (!tm) {
- Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file,
- line_number, "Unable to use type %s as director method argument\n", SwigType_str(Getattr(p, "type"), 0));
- } else {
- Replaceall(tm, "$input", pn);
- Replaceall(tm, "$owner", 0);
- Printv(w->code, " ", tm, "\n", NULL);
+ if (SwigType_type(result) != T_VOID) {
+ String *r = NewString(Swig_cresult_name());
+ String *tm = gcCTypeForGoValue(n, result, r);
+ Wrapper_add_local(w, r, tm);
+ Delete(tm);
+ Delete(r);
+ }
- Printv(args, ", ", pn, NULL);
- }
+ String *args = NewString("");
- p = Getattr(p, "tmap:directorin:next");
- }
+ p = parms;
+ while (p) {
+ while (checkAttribute(p, "tmap:directorin:numinputs", "0")) {
+ p = Getattr(p, "tmap:directorin:next");
+ }
- Printv(w->code, " ", NULL);
- if (SwigType_type(result) != T_VOID) {
- Printv(w->code, Swig_cresult_name(), " = ", NULL);
- }
- Printv(w->code, callback_wname, "(go_val", args, ");\n", NULL);
+ String *pn = NewString("swig_");
+ Append(pn, Getattr(p, "lname"));
+ Setattr(p, "emit:directorinput", pn);
- if (SwigType_type(result) != T_VOID) {
- String *result_str = NewString("c_result");
- String *tm = Swig_typemap_lookup("directorout", n, result_str, NULL);
- if (!tm) {
- Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
- "Unable to use type %s as director method result\n", SwigType_str(result, 0));
- } else {
- Replaceall(tm, "$input", Swig_cresult_name());
- Replaceall(tm, "$result", "c_result");
- Printv(w->code, " ", tm, "\n", NULL);
- String *retstr = SwigType_rcaststr(result, "c_result");
- Printv(w->code, " return ", retstr, ";\n", NULL);
- Delete(retstr);
- Delete(tm);
- }
- Delete(result_str);
- }
- }
+ String *tm = gcCTypeForGoValue(p, Getattr(p, "type"), pn);
+ Wrapper_add_local(w, pn, tm);
+ Delete(tm);
- /* Marshal outputs */
- for (p = parms; p;) {
- String *tm;
- if ((tm = Getattr(p, "tmap:directorargout"))) {
- Replaceall(tm, "$result", "jresult");
- Replaceall(tm, "$input", Getattr(p, "emit:directorinput"));
- Printv(w->code, tm, "\n", NIL);
- p = Getattr(p, "tmap:directorargout:next");
- } else {
- p = nextSibling(p);
- }
- }
+ tm = Getattr(p, "tmap:directorin");
+ if (!tm) {
+ Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file,
+ line_number, "Unable to use type %s as director method argument\n", SwigType_str(Getattr(p, "type"), 0));
} else {
- assert(is_pure_virtual);
- Printv(w->code, " _swig_gopanic(\"call to pure virtual function ", Getattr(parent, "sym:name"), name, "\");\n", NULL);
- if (SwigType_type(result) != T_VOID) {
- String *retstr = SwigType_rcaststr(result, "c_result");
- Printv(w->code, " return ", retstr, ";\n", NULL);
- Delete(retstr);
- }
- }
+ tm = Copy(tm);
+ Replaceall(tm, "$input", pn);
+ Replaceall(tm, "$owner", 0);
+ Printv(w->code, " ", tm, "\n", NULL);
+ Delete(tm);
- Printv(w->code, "}", NULL);
+ Printv(args, ", ", pn, NULL);
+ }
- Replaceall(w->code, "$symname", symname);
- Wrapper_print(w, f_c_directors);
+ p = Getattr(p, "tmap:directorin:next");
}
- Delete(cn);
- Delete(go_type_name);
- Delete(director_struct_name);
- Delete(interface_name);
- Delete(upcall_name);
- Delete(callback_wname);
- Delete(go_name);
- DelWrapper(w);
+ Printv(w->code, " ", NULL);
+ if (SwigType_type(result) != T_VOID) {
+ Printv(w->code, Swig_cresult_name(), " = ", NULL);
+ }
+ Printv(w->code, callback_name, "(go_val", args, ");\n", NULL);
+
+ /* Marshal outputs */
+ for (p = parms; p; ) {
+ String *tm;
+ if ((tm = Getattr(p, "tmap:directorargout"))) {
+ tm = Copy(tm);
+ Replaceall(tm, "$result", "jresult");
+ Replaceall(tm, "$input", Getattr(p, "emit:directorinput"));
+ Printv(w->code, tm, "\n", NULL);
+ Delete(tm);
+ p = Getattr(p, "tmap:directorargout:next");
+ } else {
+ p = nextSibling(p);
+ }
+ }
- return SWIG_OK;
+ if (SwigType_type(result) != T_VOID) {
+ String *result_str = NewString("c_result");
+ String *tm = Swig_typemap_lookup("directorout", n, result_str, NULL);
+ if (!tm) {
+ Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
+ "Unable to use type %s as director method result\n", SwigType_str(result, 0));
+ } else {
+ tm = Copy(tm);
+ Replaceall(tm, "$input", Swig_cresult_name());
+ Replaceall(tm, "$result", "c_result");
+ Printv(w->code, " ", tm, "\n", NULL);
+ String *retstr = SwigType_rcaststr(result, "c_result");
+ Printv(w->code, " return ", retstr, ";\n", NULL);
+ Delete(retstr);
+ Delete(tm);
+ }
+ Delete(result_str);
+ }
}
+
/* ------------------------------------------------------------
* classDirectorEnd
*
(void) n;
Printv(f_c_directors_h, " private:\n", NULL);
- Printv(f_c_directors_h, " void *go_val;\n", NULL);
+ Printv(f_c_directors_h, " intgo go_val;\n", NULL);
+ Printv(f_c_directors_h, " Swig_memory *swig_mem;\n", NULL);
Printv(f_c_directors_h, "};\n\n", NULL);
class_name = NULL;
break;
}
- // If all the wrappers have the same type in this position,
+ // If all the overloads have the same type in this position,
// we can omit the check.
- SwigType *tm = goWrapperType(pj, Getattr(pj, "type"), true);
+ SwigType *tm = goOverloadType(pj, Getattr(pj, "type"));
bool emitcheck = false;
for (int k = 0; k < Len(coll) && !emitcheck; ++k) {
Node *nk = Getitem(coll, k);
break;
}
if (l == j) {
- SwigType *tml = goWrapperType(pl, Getattr(pl, "type"), true);
+ SwigType *tml = goOverloadType(pl, Getattr(pl, "type"));
if (Cmp(tm, tml) != 0) {
emitcheck = true;
}
* ---------------------------------------------------------------------- */
String *goType(Node *n, SwigType *type) {
- return goTypeWithInfo(n, type, NULL);
+ return goTypeWithInfo(n, type, false, NULL);
+ }
+
+ /* ----------------------------------------------------------------------
+ * goImType()
+ *
+ * Given a SWIG type, return a string for the intermediate Go type
+ * to pass to C/C++. This is like goType except that it looks for
+ * an imtype typemap entry first.
+ * ---------------------------------------------------------------------- */
+
+ String *goImType(Node *n, SwigType *type) {
+ return goTypeWithInfo(n, type, true, NULL);
}
/* ----------------------------------------------------------------------
*
* Like goType, but return some more information.
*
+ * If use_imtype is true, this look for a imtype typemap entry.
+ *
* If the p_is_interface parameter is not NULL, this sets
* *p_is_interface to indicate whether this type is going to be
* represented by a Go interface type. These are cases where the Go
* forth with C/C++.
* ---------------------------------------------------------------------- */
- String *goTypeWithInfo(Node *n, SwigType *type, bool *p_is_interface) {
+ String *goTypeWithInfo(Node *n, SwigType *type, bool use_imtype, bool *p_is_interface) {
if (p_is_interface) {
*p_is_interface = false;
}
- String *ret;
- if (n && Cmp(type, Getattr(n, "type")) == 0) {
- ret = NULL;
- if (Strcmp(Getattr(n, "nodeType"), "parm") == 0) {
- ret = Getattr(n, "tmap:gotype");
+ String *ret = NULL;
+ if (use_imtype) {
+ if (n && Cmp(type, Getattr(n, "type")) == 0) {
+ if (Strcmp(Getattr(n, "nodeType"), "parm") == 0) {
+ ret = Getattr(n, "tmap:imtype");
+ }
+ if (!ret) {
+ ret = Swig_typemap_lookup("imtype", n, "", NULL);
+ }
+ } else {
+ Parm *p = NewParm(type, "goImType", n);
+ ret = Swig_typemap_lookup("imtype", p, "", NULL);
+ Delete(p);
}
- if (!ret) {
- ret = Swig_typemap_lookup("gotype", n, "", NULL);
+ }
+ if (!ret) {
+ if (n && Cmp(type, Getattr(n, "type")) == 0) {
+ if (Strcmp(Getattr(n, "nodeType"), "parm") == 0) {
+ ret = Getattr(n, "tmap:gotype");
+ }
+ if (!ret) {
+ ret = Swig_typemap_lookup("gotype", n, "", NULL);
+ }
+ } else {
+ Parm *p = NewParm(type, "goType", n);
+ ret = Swig_typemap_lookup("gotype", p, "", NULL);
+ Delete(p);
}
- } else {
- Parm *p = NewParm(type, "goType", n);
- ret = Swig_typemap_lookup("gotype", p, "", NULL);
- Delete(p);
}
if (ret && Strstr(ret, "$gotypename") != 0) {
SwigType *t = SwigType_typedef_resolve_all(type);
- Node *e = Language::enumLookup(t);
- if (e) {
- ret = goEnumName(e);
- } else if (Strcmp(t, "enum ") == 0) {
- ret = NewString("int");
+ if (SwigType_isenum(t)) {
+ Node *e = Language::enumLookup(t);
+ if (e) {
+ ret = goEnumName(e);
+ } else if (Strcmp(t, "enum ") == 0) {
+ ret = NewString("int");
+ } else {
+ // An unknown enum - one that has not been parsed (neither a C enum forward reference nor a definition) or an ignored enum
+ String *tt = Copy(t);
+ Replace(tt, "enum ", "", DOH_REPLACE_ANY);
+ ret = exportedName(tt);
+ Setattr(undefined_enum_types, t, ret);
+ Delete(tt);
+ }
} else if (SwigType_isfunctionpointer(type) || SwigType_isfunction(type)) {
ret = NewString("_swig_fnptr");
} else if (SwigType_ismemberpointer(type)) {
Setattr(undefined_types, t, t);
} else {
String *nw = NewString("");
- Printv(nw, Getattr(cnmod, "name"), ".", ret, NULL);
+ Printv(nw, getModuleName(Getattr(cnmod, "name")), ".", ret, NULL);
Delete(ret);
ret = nw;
}
ret = NewString("uintptr");
} else {
bool is_interface;
- String *base = goTypeWithInfo(n, r, &is_interface);
+ String *base = goTypeWithInfo(n, r, false, &is_interface);
// At the Go level, an unknown or class type is handled as an
// interface wrapping a pointer. This means that if a
if (add_pointer) {
SwigType_add_pointer(r);
}
- ret = goTypeWithInfo(n, r, p_is_interface);
+ ret = goTypeWithInfo(n, r, false, p_is_interface);
Delete(r);
} else if (SwigType_isqualifier(t)) {
SwigType *r = Copy(t);
SwigType_del_qualifier(r);
- ret = goTypeWithInfo(n, r, p_is_interface);
+ ret = goTypeWithInfo(n, r, false, p_is_interface);
Delete(r);
} else if (SwigType_isvarargs(t)) {
ret = NewString("[]interface{}");
}
/* ----------------------------------------------------------------------
+ * cgoTypeForGoValue()
+ *
+ * Given a SWIG type, return a string for the C type to use for the
+ * cgo wrapper code. This always returns a simple identifier, since
+ * it is used in Go code as C.name.
+ *
+ * This sets *c_struct_type if the C type uses a struct where the Go
+ * type uses a simple type. This is true for strings and slices.
+ * When this is true the Go code has to jump through unsafe hoops to
+ * pass the type checker.
+ * ---------------------------------------------------------------------- */
+
+ String *cgoTypeForGoValue(Node *n, SwigType *type, bool *c_struct_type) {
+ *c_struct_type = false;
+
+ bool is_interface;
+ String *go_type = goTypeWithInfo(n, type, true, &is_interface);
+ if (is_interface) {
+ Delete(go_type);
+ return NewString("uintptr_t");
+ }
+ if (Strcmp(go_type, "uintptr") == 0) {
+ Delete(go_type);
+ return NewString("uintptr_t");
+ }
+ if (((char*)Char(go_type))[0] == '*') {
+ // Treat all pointers as void*. There is no meaningful type
+ // checking going on here anyhow, and that lets us avoid
+ // worrying about defining the base type of the pointer.
+ Delete(go_type);
+ return NewString("swig_voidp");
+ }
+
+ // Check for some Go types that are really pointers under the covers.
+ bool is_hidden_pointer = Strncmp(go_type, "func(", 5) == 0 || Strncmp(go_type, "map[", 4) == 0 || Strncmp(go_type, "chan ", 5) == 0;
+
+ Delete(go_type);
+
+ String *ct = Getattr(n, "emit:cgotype");
+ if (ct) {
+ *c_struct_type = Getattr(n, "emit:cgotypestruct") ? true : false;
+ return Copy(ct);
+ }
+
+ String *t = Copy(type);
+ if (SwigType_isarray(t)) {
+ SwigType_del_array(t);
+ SwigType_add_pointer(t);
+ }
+
+ bool add_typedef = true;
+
+ static int count;
+ ++count;
+ ct = NewStringf("swig_type_%d", count);
+
+ String *gct = gcCTypeForGoValue(n, t, ct);
+ Delete(t);
+
+ if (Strncmp(gct, "_gostring_", 10) == 0 || Strncmp(gct, "_goslice_", 9) == 0) {
+ *c_struct_type = true;
+ Setattr(n, "emit:cgotypestruct", type);
+ } else {
+ char *p = Strstr(gct, ct);
+ if (p != NULL && p > (char*)Char(gct) && p[-1] == '*' && p[Len(ct)] == '\0') {
+ // Treat all pointers as void*. See above.
+ Delete(ct);
+ --count;
+ ct = NewString("swig_voidp");
+ add_typedef = false;
+ if (is_hidden_pointer) {
+ // A Go type that is really a pointer, like func, map, chan,
+ // is being represented in C by a pointer. This is fine,
+ // but we have to memcpy the type rather than simply
+ // converting it.
+ *c_struct_type = true;
+ Setattr(n, "emit:cgotypestruct", type);
+ }
+ }
+
+ if (Strncmp(gct, "bool ", 5) == 0) {
+ // Change the C++ type bool to the C type _Bool.
+ Replace(gct, "bool", "_Bool", DOH_REPLACE_FIRST);
+ }
+ if (Strncmp(gct, "intgo ", 6) == 0) {
+ // We #define intgo to swig_intgo for the cgo comment.
+ Replace(gct, "intgo", "swig_intgo", DOH_REPLACE_FIRST);
+ }
+ p = Strstr(gct, ct);
+ if (p != NULL && p > (char*)Char(gct) && p[-1] == ' ' && p[Len(ct)] == '\0') {
+ String *q = NewStringWithSize(gct, Len(gct) - Len(ct) - 1);
+ if (validIdentifier(q)) {
+ // This is a simple type name, and we can use it directly.
+ Delete(ct);
+ --count;
+ ct = q;
+ add_typedef = false;
+ }
+ }
+ }
+ if (add_typedef) {
+ Printv(f_cgo_comment_typedefs, "typedef ", gct, ";\n", NULL);
+ }
+
+ Setattr(n, "emit:cgotype", ct);
+
+ Delete(gct);
+
+ return Copy(ct);
+ }
+
+ /* ----------------------------------------------------------------------
* goWrapperType()
*
* Given a type, return a string for the type to use for the wrapped
String *goWrapperType(Node *n, SwigType *type, bool is_result) {
bool is_interface;
- String *ret = goTypeWithInfo(n, type, &is_interface);
+ String *ret = goTypeWithInfo(n, type, true, &is_interface);
// If this is an interface, we want to pass the real type.
if (is_interface) {
}
/* ----------------------------------------------------------------------
+ * goOverloadType()
+ *
+ * Given a type, return the Go type to use when dispatching of
+ * overloaded functions. This is normally just the usual Go type.
+ * However, for a C++ class, the usual Go type is an interface type.
+ * And if that interface type represents a C++ type that SWIG does
+ * not know about, then the interface type generated for any C++
+ * class will match that interface. So for that case, we match on
+ * the underlying integer type.
+ *
+ * It has to work this way so that we can handle a derived type of a
+ * %ignore'd type. It's unlikely that anybody will have a value of
+ * an undefined type, but we support it because it worked in the
+ * past.
+ * ---------------------------------------------------------------------- */
+
+ String *goOverloadType(Node *n, SwigType *type) {
+ SwigType *ty = SwigType_typedef_resolve_all(type);
+ while (true) {
+ if (SwigType_ispointer(ty)) {
+ SwigType_del_pointer(ty);
+ } else if (SwigType_isarray(ty)) {
+ SwigType_del_array(ty);
+ } else if (SwigType_isreference(ty)) {
+ SwigType_del_reference(ty);
+ } else if (SwigType_isqualifier(ty)) {
+ SwigType_del_qualifier(ty);
+ } else {
+ break;
+ }
+ }
+
+ if (Getattr(undefined_types, ty) && !Getattr(defined_types, ty)) {
+ return goWrapperType(n, type, true);
+ }
+
+ return goType(n, type);
+ }
+
+ /* ----------------------------------------------------------------------
* goCPointerType()
*
* Return the name of the Go type to use for the C pointer value.
Append(ret, ex);
} else {
ret = NewString("");
- Printv(ret, Getattr(cnmod, "name"), ".Swigcptr", ex, NULL);
+ Printv(ret, getModuleName(Getattr(cnmod, "name")), ".Swigcptr", ex, NULL);
}
}
Delete(ty);
String *gcCTypeForGoValue(Node *n, SwigType *type, String *name) {
bool is_interface;
- String *gt = goTypeWithInfo(n, type, &is_interface);
+ String *gt = goTypeWithInfo(n, type, true, &is_interface);
+
+ String *tail = NewString("");
+ SwigType *t = SwigType_typedef_resolve_all(type);
+ if (!SwigType_isreference(t)) {
+ while (Strncmp(gt, "*", 1) == 0) {
+ Replace(gt, "*", "", DOH_REPLACE_FIRST);
+ Printv(tail, "*", NULL);
+ }
+ }
+ Delete(t);
+
bool is_string = Strcmp(gt, "string") == 0;
bool is_slice = Strncmp(gt, "[]", 2) == 0;
bool is_function = Strcmp(gt, "_swig_fnptr") == 0;
bool is_member = Strcmp(gt, "_swig_memberptr") == 0;
bool is_complex64 = Strcmp(gt, "complex64") == 0;
bool is_complex128 = Strcmp(gt, "complex128") == 0;
+ bool is_bool = false;
bool is_int8 = false;
bool is_int16 = false;
bool is_int = Strcmp(gt, "int") == 0 || Strcmp(gt, "uint") == 0;
bool is_int64 = false;
bool is_float32 = false;
bool is_float64 = false;
- if ((n != NULL && Getattr(n, "tmap:gotype") != NULL) || hasGoTypemap(n, type)) {
+
+ bool has_typemap = (n != NULL && Getattr(n, "tmap:gotype") != NULL) || hasGoTypemap(n, type);
+ if (has_typemap) {
+ is_bool = Strcmp(gt, "bool") == 0;
is_int8 = Strcmp(gt, "int8") == 0 || Strcmp(gt, "uint8") == 0 || Strcmp(gt, "byte") == 0;
is_int16 = Strcmp(gt, "int16") == 0 || Strcmp(gt, "uint16") == 0;
is_int32 = Strcmp(gt, "int32") == 0 || Strcmp(gt, "uint32") == 0;
if (is_string) {
// Note that we don't turn a reference to a string into a
// pointer to a string. Strings are immutable anyhow.
- ret = NewString("_gostring_ ");
- Append(ret, name);
+ ret = NewString("");
+ Printv(ret, "_gostring_", tail, " ", name, NULL);
+ Delete(tail);
return ret;
} else if (is_slice) {
// Slices are always passed as a _goslice_, whether or not references
// are involved.
- ret = NewString("_goslice_ ");
- Append(ret, name);
+ ret = NewString("");
+ Printv(ret, "_goslice_", tail, " ", name, NULL);
+ Delete(tail);
return ret;
} else if (is_function || is_member) {
- ret = NewString("void *");
- Append(ret, name);
+ ret = NewString("");
+ Printv(ret, "void*", tail, " ", name, NULL);
+ Delete(tail);
return ret;
} else if (is_complex64) {
ret = NewString("_Complex float ");
ret = NewString("_Complex double ");
} else if (is_interface) {
SwigType *t = SwigType_typedef_resolve_all(type);
- SwigType_strip_qualifiers(t);
if (SwigType_ispointer(t)) {
SwigType_del_pointer(t);
- SwigType_strip_qualifiers(t);
}
if (SwigType_isreference(t)) {
SwigType_del_reference(t);
- SwigType_strip_qualifiers(t);
}
SwigType_add_pointer(t);
ret = SwigType_lstr(t, name);
Delete(t);
+ Delete(tail);
return ret;
} else {
SwigType *t = SwigType_typedef_resolve_all(type);
- if (SwigType_isreference(t)) {
+ if (!has_typemap && SwigType_isreference(t)) {
// A const reference to a known type, or to a pointer, is not
// mapped to a pointer.
SwigType_del_reference(t);
if (is_int) {
ret = NewString("intgo ");
Append(ret, name);
+ } else if (is_int64) {
+ ret = NewString("long long ");
+ Append(ret, name);
} else {
ret = SwigType_lstr(t, name);
}
Delete(q);
Delete(t);
+ Delete(tail);
return ret;
}
}
}
}
- if (Language::enumLookup(t) != NULL || Strcmp(t, "enum ") == 0) {
+ if (Language::enumLookup(t) != NULL) {
is_int = true;
+ } else {
+ SwigType *tstripped = SwigType_strip_qualifiers(t);
+ if (SwigType_isenum(tstripped))
+ is_int = true;
+ Delete(tstripped);
}
Delete(t);
- if (is_int8) {
+ if (is_bool) {
+ ret = NewString("bool ");
+ } else if (is_int8) {
ret = NewString("char ");
} else if (is_int16) {
ret = NewString("short ");
} else if (is_float64) {
ret = NewString("double ");
} else {
+ Delete(tail);
return SwigType_lstr(type, name);
}
}
- if (SwigType_isreference(type)) {
+ Append(ret, tail);
+ if (!has_typemap && SwigType_isreference(type)) {
Append(ret, "* ");
}
Append(ret, name);
+ Delete(tail);
return ret;
}
bool goTypeIsInterface(Node *n, SwigType *type) {
bool is_interface;
- Delete(goTypeWithInfo(n, type, &is_interface));
+ Delete(goTypeWithInfo(n, type, false, &is_interface));
return is_interface;
}
bool isStatic(Node *n) {
String *storage = Getattr(n, "storage");
- return (storage && (Strcmp(storage, "static") == 0 || Strcmp(storage, "friend") == 0) && (!SmartPointer || !Getattr(n, "allocate:smartpointeraccess")));
+ return (storage && (Swig_storage_isstatic(n) || Strcmp(storage, "friend") == 0) && (!SmartPointer || !Getattr(n, "allocate:smartpointeraccess")));
}
/* ----------------------------------------------------------------------
return storage && Strcmp(storage, "friend") == 0;
}
+ /* ----------------------------------------------------------------------
+ * goGetattr
+ *
+ * Fetch an attribute from a node but return NULL if it is the empty string.
+ * ---------------------------------------------------------------------- */
+ Node *goGetattr(Node *n, const char *name) {
+ Node *ret = Getattr(n, name);
+ if (ret != NULL && Len(ret) == 0) {
+ ret = NULL;
+ }
+ return ret;
+ }
+
+ /* ----------------------------------------------------------------------
+ * goTypemapLookup
+ *
+ * Look up a typemap but return NULL if it is the empty string.
+ * ---------------------------------------------------------------------- */
+ String *goTypemapLookup(const char *name, Node *node, const char *lname) {
+ String *ret = Swig_typemap_lookup(name, node, lname, NULL);
+ if (ret != NULL && Len(ret) == 0) {
+ ret = NULL;
+ }
+ return ret;
+ }
+
+ /* ----------------------------------------------------------------------
+ * getModuleName
+ *
+ * Return the name of a module. This is different from module path:
+ * "some/path/to/module" -> "module".
+ * ---------------------------------------------------------------------- */
+
+ String *getModuleName(String *module_path) {
+ char *suffix = strrchr(Char(module_path), '/');
+ if (suffix == NULL) {
+ return module_path;
+ }
+ return Str(suffix + 1);
+ }
+
}; /* class GO */
/* -----------------------------------------------------------------------------
* ----------------------------------------------------------------------------- */
// Usage message.
-const char * const GO::usage = (char *) "\
+const char * const GO::usage = "\
Go Options (available with -go)\n\
+ -cgo - Generate cgo input files\n\
-gccgo - Generate code for gccgo rather than 6g/8g\n\
+ -go-pkgpath <p> - Like gccgo -fgo-pkgpath option\n\
-go-prefix <p> - Like gccgo -fgo-prefix option\n\
- -longsize <s> - Set size of C/C++ long type--32 or 64 bits\n\
-intgosize <s> - Set size of Go int type--32 or 64 bits\n\
-package <name> - Set name of the Go package to <name>\n\
+ -use-shlib - Force use of a shared library\n\
-soname <name> - Set shared library holding C/C++ code to <name>\n\
\n";
#include <ctype.h>
// Note string broken in half for compilers that can't handle long strings
-static const char *usage = (char *) "\
+static const char *usage = "\
Guile Options (available with -guile)\n\
-emitsetters - Emit procedures-with-setters for variables\n\
and structure slots.\n\
-exportprimitive - Add the (export ...) code from scmstub into the\n\
GOOPS file.\n\
-goopsprefix <prefix> - Prepend <prefix> to all goops identifiers\n\
- -linkage <lstyle> - Use linkage protocol <lstyle> (default `simple')\n\
+ -Linkage <lstyle> - Use linkage protocol <lstyle> (default `simple')\n\
Use `module' for native Guile module linking\n\
(requires Guile >= 1.5.0). Use `passive' for\n\
passive linking (no C-level module-handling code),\n\
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGGUILE\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGGUILE\n#define SWIGGUILE\n#endif\n\n");
/* Write out directives and declarations */
if (in_class)
goops_name = NewString(memberfunction_name);
else
- goops_name = goopsNameMapping(proc_name, (char *) "");
+ goops_name = goopsNameMapping(proc_name, "");
String *primitive_name = NewString("");
if (primRenamer)
Printv(primitive_name, "primitive:", proc_name, NIL);
// export wrapper into goops file
if (!in_class) { // only if the variable is not part of a class
String *class_name = SwigType_typedef_resolve_all(SwigType_base(t));
- String *goops_name = goopsNameMapping(proc_name, (char *) "");
+ String *goops_name = goopsNameMapping(proc_name, "");
String *primitive_name = NewString("");
if (primRenamer)
Printv(primitive_name, "primitive:", NIL);
char *name = GetChar(n, "name");
char *iname = GetChar(n, "sym:name");
SwigType *type = Getattr(n, "type");
- String *value = Getattr(n, "value");
+ String *rawval = Getattr(n, "rawval");
+ String *value = rawval ? rawval : Getattr(n, "value");
int constasvar = GetFlag(n, "feature:constasvar");
String *proc_name;
String *var_name;
- String *rvalue;
Wrapper *f;
SwigType *nctype;
String *tm;
}
// See if there's a typemap
- bool is_enum_item = (Cmp(nodeType(n), "enumitem") == 0);
- if (SwigType_type(nctype) == T_STRING) {
- rvalue = NewStringf("\"%s\"", value);
- } else if (SwigType_type(nctype) == T_CHAR && !is_enum_item) {
- rvalue = NewStringf("\'%s\'", value);
- } else {
- rvalue = NewString(value);
- }
-
if ((tm = Swig_typemap_lookup("constant", n, name, 0))) {
- Replaceall(tm, "$source", rvalue);
- Replaceall(tm, "$value", rvalue);
+ Replaceall(tm, "$source", value);
+ Replaceall(tm, "$value", value);
Replaceall(tm, "$target", name);
Printv(f_header, tm, "\n", NIL);
} else {
// Create variable and assign it a value
- Printf(f_header, "static %s = %s;\n", SwigType_lstr(nctype, var_name), rvalue);
+ Printf(f_header, "static %s = (%s)(%s);\n", SwigType_str(type, var_name), SwigType_str(type, 0), value);
}
{
/* Hack alert: will cleanup later -- Dave */
Delete(var_name);
Delete(nctype);
Delete(proc_name);
- Delete(rvalue);
DelWrapper(f);
return SWIG_OK;
}
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * This file is part of SWIG, which is licensed as a whole under version 3
+ * (or any later version) of the GNU General Public License. Some additional
+ * terms also apply to certain portions of SWIG. The full details of the SWIG
+ * license and copyrights can be found in the LICENSE and COPYRIGHT files
+ * included with the SWIG source code as distributed by the SWIG developers
+ * and at http://www.swig.org/legal.html.
+ *
+ * interface.cxx
+ *
+ * This module contains support for the interface feature.
+ * This feature is used in language modules where the target language does not
+ * naturally support C++ style multiple inheritance, but does support inheritance
+ * from multiple interfaces.
+ * ----------------------------------------------------------------------------- */
+
+#include "swigmod.h"
+
+static bool interface_feature_enabled = false;
+
+/* -----------------------------------------------------------------------------
+ * collect_interface_methods()
+ *
+ * Create a list of all the methods from the base classes of class n that are
+ * marked as an interface. The resulting list is thus the list of methods that
+ * need to be implemented in order for n to be non-abstract.
+ * ----------------------------------------------------------------------------- */
+
+static List *collect_interface_methods(Node *n) {
+ List *methods = NewList();
+ if (Hash *bases = Getattr(n, "interface:bases")) {
+ List *keys = Keys(bases);
+ for (Iterator base = First(keys); base.item; base = Next(base)) {
+ Node *cls = Getattr(bases, base.item);
+ if (cls == n)
+ continue;
+ for (Node *child = firstChild(cls); child; child = nextSibling(child)) {
+ if (Cmp(nodeType(child), "cdecl") == 0) {
+ if (GetFlag(child, "feature:ignore") || Getattr(child, "interface:owner"))
+ continue; // skip methods propagated to bases
+ Node *m = Copy(child);
+ set_nextSibling(m, NIL);
+ set_previousSibling(m, NIL);
+ Setattr(m, "interface:owner", cls);
+ Append(methods, m);
+ }
+ }
+ }
+ Delete(keys);
+ }
+ return methods;
+}
+
+/* -----------------------------------------------------------------------------
+ * collect_interface_bases
+ * ----------------------------------------------------------------------------- */
+
+static void collect_interface_bases(Hash *bases, Node *n) {
+ if (Getattr(n, "feature:interface")) {
+ String *name = Getattr(n, "interface:name");
+ if (!Getattr(bases, name))
+ Setattr(bases, name, n);
+ }
+
+ if (List *baselist = Getattr(n, "bases")) {
+ for (Iterator base = First(baselist); base.item; base = Next(base)) {
+ if (!GetFlag(base.item, "feature:ignore")) {
+ if (Getattr(base.item, "feature:interface"))
+ collect_interface_bases(bases, base.item);
+ }
+ }
+ }
+}
+
+/* -----------------------------------------------------------------------------
+ * collect_interface_base_classes()
+ *
+ * Create a hash containing all the classes up the inheritance hierarchy
+ * marked with feature:interface (including this class n).
+ * Stops going up the inheritance chain as soon as a class is found without
+ * feature:interface.
+ * The idea is to find all the base interfaces that a class must implement.
+ * ----------------------------------------------------------------------------- */
+
+static void collect_interface_base_classes(Node *n) {
+ if (Getattr(n, "feature:interface")) {
+ // check all bases are also interfaces
+ if (List *baselist = Getattr(n, "bases")) {
+ for (Iterator base = First(baselist); base.item; base = Next(base)) {
+ if (!GetFlag(base.item, "feature:ignore")) {
+ if (!Getattr(base.item, "feature:interface")) {
+ Swig_error(Getfile(n), Getline(n), "Base class '%s' of '%s' is not similarly marked as an interface.\n", SwigType_namestr(Getattr(base.item, "name")), SwigType_namestr(Getattr(n, "name")));
+ SWIG_exit(EXIT_FAILURE);
+ }
+ }
+ }
+ }
+ }
+
+ Hash *interface_bases = NewHash();
+ collect_interface_bases(interface_bases, n);
+ if (Len(interface_bases) == 0)
+ Delete(interface_bases);
+ else
+ Setattr(n, "interface:bases", interface_bases);
+}
+
+/* -----------------------------------------------------------------------------
+ * process_interface_name()
+ * ----------------------------------------------------------------------------- */
+
+static void process_interface_name(Node *n) {
+ if (Getattr(n, "feature:interface")) {
+ String *interface_name = Getattr(n, "feature:interface:name");
+ if (!Len(interface_name)) {
+ Swig_error(Getfile(n), Getline(n), "The interface feature for '%s' is missing the name attribute.\n", SwigType_namestr(Getattr(n, "name")));
+ SWIG_exit(EXIT_FAILURE);
+ }
+ if (Strchr(interface_name, '%')) {
+ String *name = NewStringf(interface_name, Getattr(n, "sym:name"));
+ Setattr(n, "interface:name", name);
+ } else {
+ Setattr(n, "interface:name", interface_name);
+ }
+ }
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_interface_propagate_methods()
+ *
+ * Find all the base classes marked as an interface (with feature:interface) for
+ * class node n. For each of these, add all of its methods as methods of n so that
+ * n is not abstract. If class n is also marked as an interface, it will remain
+ * abstract and not have any methods added.
+ * ----------------------------------------------------------------------------- */
+
+void Swig_interface_propagate_methods(Node *n) {
+ if (interface_feature_enabled) {
+ process_interface_name(n);
+ collect_interface_base_classes(n);
+ List *methods = collect_interface_methods(n);
+ bool is_interface = Getattr(n, "feature:interface") != 0;
+ for (Iterator mi = First(methods); mi.item; mi = Next(mi)) {
+ if (!is_interface && GetFlag(mi.item, "abstract"))
+ continue;
+ String *this_decl = Getattr(mi.item, "decl");
+ String *this_decl_resolved = SwigType_typedef_resolve_all(this_decl);
+ bool identically_overloaded_method = false; // true when a base class' method is implemented in n
+ if (SwigType_isfunction(this_decl_resolved)) {
+ String *name = Getattr(mi.item, "name");
+ for (Node *child = firstChild(n); child; child = nextSibling(child)) {
+ if (Getattr(child, "interface:owner"))
+ break; // at the end of the list are newly appended methods
+ if (checkAttribute(child, "name", name)) {
+ String *decl = SwigType_typedef_resolve_all(Getattr(child, "decl"));
+ identically_overloaded_method = Strcmp(decl, this_decl_resolved) == 0;
+ Delete(decl);
+ if (identically_overloaded_method)
+ break;
+ }
+ }
+ }
+ Delete(this_decl_resolved);
+ if (!identically_overloaded_method) {
+ // TODO: Fix if the method is overloaded with different arguments / has default args
+ appendChild(n, mi.item);
+ } else {
+ Delete(mi.item);
+ }
+ }
+ Delete(methods);
+ }
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_interface_feature_enable()
+ *
+ * Turn on interface feature support
+ * ----------------------------------------------------------------------------- */
+
+void Swig_interface_feature_enable() {
+ interface_feature_enabled = true;
+}
String *imclass_class_code; // intermediary class code
String *proxy_class_def;
String *proxy_class_code;
+ String *interface_class_code; // if %feature("interface") was declared for a class, here goes the interface declaration
String *module_class_code;
String *proxy_class_name; // proxy class name
String *full_proxy_class_name;// fully qualified proxy class name when using nspace feature, otherwise same as proxy_class_name
int n_directors;
int first_class_dmethod;
int curr_class_dmethod;
+ int nesting_depth;
enum EnumFeature { SimpleEnum, TypeunsafeEnum, TypesafeEnum, ProperEnum };
imclass_class_code(NULL),
proxy_class_def(NULL),
proxy_class_code(NULL),
+ interface_class_code(NULL),
module_class_code(NULL),
proxy_class_name(NULL),
full_proxy_class_name(NULL),
n_dmethods(0),
n_directors(0),
first_class_dmethod(0),
- curr_class_dmethod(0) {
+ curr_class_dmethod(0),
+ nesting_depth(0){
/* for now, multiple inheritance in directors is disabled, this
should be easy to implement though */
director_multiple_inheritance = 0;
*
* Test to see if a type corresponds to something wrapped with a proxy class.
* Return NULL if not otherwise the proxy class name, fully qualified with
- * package name if the nspace feature is used.
+ * package name if the nspace feature is used, unless jnidescriptor is true as
+ * the package name is handled differently (unfortunately for legacy reasons).
* ----------------------------------------------------------------------------- */
- String *getProxyName(SwigType *t) {
+ String *getProxyName(SwigType *t, bool jnidescriptor = false) {
String *proxyname = NULL;
if (proxy_flag) {
Node *n = classLookup(t);
if (n) {
proxyname = Getattr(n, "proxyname");
- if (!proxyname) {
+ if (!proxyname || jnidescriptor) {
String *nspace = Getattr(n, "sym:nspace");
- String *symname = Getattr(n, "sym:name");
+ String *symname = Copy(Getattr(n, "sym:name"));
+ if (symname && !GetFlag(n, "feature:flatnested")) {
+ for (Node *outer_class = Getattr(n, "nested:outer"); outer_class; outer_class = Getattr(outer_class, "nested:outer")) {
+ Push(symname, jnidescriptor ? "$" : ".");
+ Push(symname, Getattr(outer_class, "sym:name"));
+ }
+ }
if (nspace) {
- if (package)
+ if (package && !jnidescriptor)
proxyname = NewStringf("%s.%s.%s", package, nspace, symname);
else
proxyname = NewStringf("%s.%s", nspace, symname);
} else {
proxyname = Copy(symname);
}
- Setattr(n, "proxyname", proxyname);
- Delete(proxyname);
+ if (!jnidescriptor) {
+ Setattr(n, "proxyname", proxyname); // Cache it
+ Delete(proxyname);
+ }
+ Delete(symname);
}
}
}
SWIG_config_file("java.swg");
allow_overloading();
+ Swig_interface_feature_enable();
}
/* ---------------------------------------------------------------------
Swig_banner(f_begin);
- Printf(f_runtime, "\n#define SWIGJAVA\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGJAVA\n#define SWIGJAVA\n#endif\n\n");
if (directorsEnabled()) {
Printf(f_runtime, "#define SWIG_DIRECTORS\n");
if (directorsEnabled()) {
// Insert director runtime into the f_runtime file (make it occur before %header section)
+ Swig_insert_file("director_common.swg", f_runtime);
Swig_insert_file("director.swg", f_runtime);
}
// Generate the intermediary class
bool is_destructor = (Cmp(Getattr(n, "nodeType"), "destructor") == 0);
if (!Getattr(n, "sym:overloaded")) {
- if (!addSymbol(Getattr(n, "sym:name"), n, imclass_name))
+ if (!addSymbol(symname, n, imclass_name))
return SWIG_ERROR;
}
}
}
+ // Now write code to make the function call
if (!native_function_flag) {
- if (Cmp(nodeType(n), "constant") == 0) {
- // Wrapping a constant hack
- Swig_save("functionWrapper", n, "wrap:action", NIL);
-
- // below based on Swig_VargetToFunction()
- SwigType *ty = Swig_wrapped_var_type(Getattr(n, "type"), use_naturalvar_mode(n));
- Setattr(n, "wrap:action", NewStringf("%s = (%s)(%s);", Swig_cresult_name(), SwigType_lstr(ty, 0), Getattr(n, "value")));
- }
- // Now write code to make the function call
Swig_director_emit_dynamic_cast(n, f);
String *actioncode = emit_action(n);
// Handle exception classes specified in the "except" feature's "throws" attribute
addThrows(n, "feature:except", n);
- if (Cmp(nodeType(n), "constant") == 0)
- Swig_restore(n);
-
/* Return value if necessary */
if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) {
addThrows(n, "tmap:out", n);
*/
if (proxy_flag && wrapping_member_flag && !enum_constant_flag) {
// Capitalize the first letter in the variable to create a JavaBean type getter/setter function name
- bool getter_flag = Cmp(symname, Swig_name_set(getNSpace(), Swig_name_member(0, proxy_class_name, variable_name))) != 0;
+ bool getter_flag = Cmp(symname, Swig_name_set(getNSpace(), Swig_name_member(0, getClassPrefix(), variable_name))) != 0;
String *getter_setter_name = NewString("");
if (!getter_flag)
return ret;
}
+ String *getCurrentScopeName(String *nspace) {
+ String *scope = 0;
+ if (nspace || getCurrentClass()) {
+ scope = NewString("");
+ if (nspace)
+ Printf(scope, "%s", nspace);
+ if (Node* cls = getCurrentClass()) {
+ if (Node *outer = Getattr(cls, "nested:outer")) {
+ String *outerClassesPrefix = Copy(Getattr(outer, "sym:name"));
+ for (outer = Getattr(outer, "nested:outer"); outer != 0; outer = Getattr(outer, "nested:outer")) {
+ Push(outerClassesPrefix, ".");
+ Push(outerClassesPrefix, Getattr(outer, "sym:name"));
+ }
+ Printv(scope, nspace ? "." : "", outerClassesPrefix, ".", proxy_class_name, NIL);
+ Delete(outerClassesPrefix);
+ } else
+ Printv(scope, nspace ? "." : "", proxy_class_name, NIL);
+ }
+ }
+ return scope;
+ }
+
/* ----------------------------------------------------------------------
* enumDeclaration()
*
if ((enum_feature != SimpleEnum) && symname && typemap_lookup_type) {
// Wrap (non-anonymous) C/C++ enum within a typesafe, typeunsafe or proper Java enum
- String *scope = 0;
- if (nspace || proxy_class_name) {
- scope = NewString("");
- if (nspace)
- Printf(scope, "%s", nspace);
- if (proxy_class_name)
- Printv(scope, nspace ? "." : "", proxy_class_name, NIL);
- }
+ String *scope = getCurrentScopeName(nspace);
if (!addSymbol(symname, n, scope))
return SWIG_ERROR;
// Add extra indentation
Replaceall(enum_code, "\n", "\n ");
Replaceall(enum_code, " \n", "\n");
-
- Printv(proxy_class_constants_code, " ", enum_code, "\n\n", NIL);
+ if (GetFlag(getCurrentClass(), "feature:interface"))
+ Printv(interface_class_code, " ", enum_code, "\n\n", NIL);
+ else
+ Printv(proxy_class_constants_code, " ", enum_code, "\n\n", NIL);
} else {
// Global enums are defined in their own file
String *output_directory = outputDirectory(nspace);
int unnamedinstance = GetFlag(parent, "unnamedinstance");
String *parent_name = Getattr(parent, "name");
String *nspace = getNSpace();
+ String *newsymname = 0;
String *tmpValue;
// Strange hack from parent method
const char *val = Equal(Getattr(n, "enumvalue"), "true") ? "1" : "0";
Setattr(n, "enumvalue", val);
} else if (swigtype == T_CHAR) {
- String *val = NewStringf("'%s'", Getattr(n, "enumvalue"));
+ String *val = NewStringf("'%(escape)s'", Getattr(n, "enumvalue"));
Setattr(n, "enumvalue", val);
Delete(val);
}
{
EnumFeature enum_feature = decodeEnumFeature(parent);
+ if ((enum_feature == SimpleEnum) && GetFlag(parent, "scopedenum")) {
+ newsymname = Swig_name_member(0, Getattr(parent, "sym:name"), symname);
+ symname = newsymname;
+ }
+
// Add to language symbol table
String *scope = 0;
if (unnamedinstance || !parent_name || enum_feature == SimpleEnum) {
- if (proxy_class_name) {
+ String *enumClassPrefix = getEnumClassPrefix();
+ if (enumClassPrefix) {
scope = NewString("");
if (nspace)
Printf(scope, "%s.", nspace);
- Printf(scope, "%s", proxy_class_name);
+ Printf(scope, "%s", enumClassPrefix);
} else {
scope = Copy(constants_interface_name);
}
} else {
- scope = NewString("");
- if (nspace)
- Printf(scope, "%s.", nspace);
- if (proxy_class_name)
- Printf(scope, "%s.", proxy_class_name);
- Printf(scope, "%s",Getattr(parent, "sym:name"));
+ scope = getCurrentScopeName(nspace);
+ if (!scope)
+ scope = Copy(Getattr(parent, "sym:name"));
+ else
+ Printf(scope, ".%s", Getattr(parent, "sym:name"));
}
- if (!addSymbol(name, n, scope))
+ if (!addSymbol(symname, n, scope))
return SWIG_ERROR;
if ((enum_feature == ProperEnum) && parent_name && !unnamedinstance) {
Delete(scope);
}
+ Delete(newsymname);
Delete(tmpValue);
Swig_restore(n);
return SWIG_OK;
virtual int constantWrapper(Node *n) {
String *symname = Getattr(n, "sym:name");
SwigType *t = Getattr(n, "type");
+ SwigType *valuetype = Getattr(n, "valuetype");
ParmList *l = Getattr(n, "parms");
String *tm;
String *return_type = NewString("");
} else {
// Alternative constant handling will use the C syntax to make a true Java constant and hope that it compiles as Java code
if (Getattr(n, "wrappedasconstant")) {
- if (SwigType_type(t) == T_CHAR)
- Printf(constants_code, "\'%s\';\n", Getattr(n, "staticmembervariableHandler:value"));
+ if (SwigType_type(valuetype) == T_CHAR)
+ Printf(constants_code, "\'%(escape)s\';\n", Getattr(n, "staticmembervariableHandler:value"));
else
Printf(constants_code, "%s;\n", Getattr(n, "staticmembervariableHandler:value"));
} else {
}
/* -----------------------------------------------------------------------------
+ * getQualifiedInterfaceName()
+ * ----------------------------------------------------------------------------- */
+
+ String *getQualifiedInterfaceName(Node *n) {
+ String *ret = Getattr(n, "interface:qname");
+ if (!ret) {
+ String *nspace = Getattr(n, "sym:nspace");
+ String *symname = Getattr(n, "interface:name");
+ if (nspace) {
+ if (package)
+ ret = NewStringf("%s.%s.%s", package, nspace, symname);
+ else
+ ret = NewStringf("%s.%s", nspace, symname);
+ } else {
+ ret = Copy(symname);
+ }
+ Setattr(n, "interface:qname", ret);
+ }
+ return ret;
+ }
+
+ /* -----------------------------------------------------------------------------
+ * getInterfaceName()
+ * ----------------------------------------------------------------------------- */
+
+ String *getInterfaceName(SwigType *t, bool qualified) {
+ String *interface_name = NULL;
+ if (proxy_flag) {
+ Node *n = classLookup(t);
+ if (n && Getattr(n, "interface:name"))
+ interface_name = qualified ? getQualifiedInterfaceName(n) : Getattr(n, "interface:name");
+ }
+ return interface_name;
+ }
+
+ /* -----------------------------------------------------------------------------
+ * addInterfaceNameAndUpcasts()
+ * ----------------------------------------------------------------------------- */
+
+ void addInterfaceNameAndUpcasts(SwigType *smart, String *interface_list, String *interface_upcasts, Hash *base_list, String *c_classname) {
+ List *keys = Keys(base_list);
+ for (Iterator it = First(keys); it.item; it = Next(it)) {
+ Node *base = Getattr(base_list, it.item);
+ String *c_baseclass = SwigType_namestr(Getattr(base, "name"));
+ String *interface_name = Getattr(base, "interface:name");
+ if (Len(interface_list))
+ Append(interface_list, ", ");
+ Append(interface_list, interface_name);
+
+ Node *attributes = NewHash();
+ String *interface_code = Copy(typemapLookup(base, "javainterfacecode", Getattr(base, "classtypeobj"), WARN_JAVA_TYPEMAP_INTERFACECODE_UNDEF, attributes));
+ String *cptr_method_name = 0;
+ if (interface_code) {
+ Replaceall(interface_code, "$interfacename", interface_name);
+ Printv(interface_upcasts, interface_code, NIL);
+ cptr_method_name = Copy(Getattr(attributes, "tmap:javainterfacecode:cptrmethod"));
+ }
+ if (!cptr_method_name)
+ cptr_method_name = NewStringf("%s_GetInterfaceCPtr", interface_name);
+ Replaceall(cptr_method_name, ".", "_");
+ Replaceall(cptr_method_name, "$interfacename", interface_name);
+
+ String *upcast_method_name = Swig_name_member(getNSpace(), proxy_class_name, cptr_method_name);
+ upcastsCode(smart, upcast_method_name, c_classname, c_baseclass);
+ Delete(upcast_method_name);
+ Delete(cptr_method_name);
+ Delete(interface_code);
+ Delete(c_baseclass);
+ }
+ Delete(keys);
+ }
+
+ /* -----------------------------------------------------------------------------
+ * upcastsCode()
+ *
+ * Add code for C++ casting to base class
+ * ----------------------------------------------------------------------------- */
+
+ void upcastsCode(SwigType *smart, String *upcast_method_name, String *c_classname, String *c_baseclass) {
+ String *jniname = makeValidJniName(upcast_method_name);
+ String *wname = Swig_name_wrapper(jniname);
+ Printf(imclass_cppcasts_code, " public final static native long %s(long jarg1);\n", upcast_method_name);
+ if (smart) {
+ SwigType *bsmart = Copy(smart);
+ SwigType *rclassname = SwigType_typedef_resolve_all(c_classname);
+ SwigType *rbaseclass = SwigType_typedef_resolve_all(c_baseclass);
+ Replaceall(bsmart, rclassname, rbaseclass);
+ Delete(rclassname);
+ Delete(rbaseclass);
+ String *smartnamestr = SwigType_namestr(smart);
+ String *bsmartnamestr = SwigType_namestr(bsmart);
+ Printv(upcasts_code,
+ "SWIGEXPORT jlong JNICALL ", wname, "(JNIEnv *jenv, jclass jcls, jlong jarg1) {\n",
+ " jlong baseptr = 0;\n"
+ " ", smartnamestr, " *argp1;\n"
+ " (void)jenv;\n"
+ " (void)jcls;\n"
+ " argp1 = *(", smartnamestr, " **)&jarg1;\n"
+ " *(", bsmartnamestr, " **)&baseptr = argp1 ? new ", bsmartnamestr, "(*argp1) : 0;\n"
+ " return baseptr;\n"
+ "}\n", "\n", NIL);
+ Delete(bsmartnamestr);
+ Delete(smartnamestr);
+ Delete(bsmart);
+ } else {
+ Printv(upcasts_code,
+ "SWIGEXPORT jlong JNICALL ", wname, "(JNIEnv *jenv, jclass jcls, jlong jarg1) {\n",
+ " jlong baseptr = 0;\n"
+ " (void)jenv;\n"
+ " (void)jcls;\n"
+ " *(", c_baseclass, " **)&baseptr = *(", c_classname, " **)&jarg1;\n"
+ " return baseptr;\n"
+ "}\n", "\n", NIL);
+ }
+ Delete(wname);
+ Delete(jniname);
+ }
+
+ /* -----------------------------------------------------------------------------
* emitProxyClassDefAndCPPCasts()
* ----------------------------------------------------------------------------- */
String *c_baseclass = NULL;
String *baseclass = NULL;
String *c_baseclassname = NULL;
+ String *interface_list = NewStringEmpty();
+ String *interface_upcasts = NewStringEmpty();
SwigType *typemap_lookup_type = Getattr(n, "classtypeobj");
bool feature_director = Swig_directorclass(n) ? true : false;
+ bool has_outerclass = Getattr(n, "nested:outer") != 0 && !GetFlag(n, "feature:flatnested");
+ SwigType *smart = Swig_cparse_smartptr(n);
// Inheritance from pure Java classes
Node *attributes = NewHash();
if (!purebase_replace) {
List *baselist = Getattr(n, "bases");
if (baselist) {
- Iterator base = First(baselist);
- while (base.item && GetFlag(base.item, "feature:ignore")) {
- base = Next(base);
- }
- if (base.item) {
- c_baseclassname = Getattr(base.item, "name");
- baseclass = Copy(getProxyName(c_baseclassname));
- if (baseclass)
- c_baseclass = SwigType_namestr(Getattr(base.item, "name"));
- base = Next(base);
- /* Warn about multiple inheritance for additional base class(es) */
- while (base.item) {
- if (GetFlag(base.item, "feature:ignore")) {
- base = Next(base);
- continue;
- }
- String *proxyclassname = Getattr(n, "classtypeobj");
- String *baseclassname = Getattr(base.item, "name");
- Swig_warning(WARN_JAVA_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
- "Warning for %s proxy: Base %s ignored. Multiple inheritance is not supported in Java.\n", SwigType_namestr(proxyclassname), SwigType_namestr(baseclassname));
- base = Next(base);
- }
- }
+ Iterator base = First(baselist);
+ while (base.item) {
+ if (!(GetFlag(base.item, "feature:ignore") || Getattr(base.item, "feature:interface"))) {
+ String *baseclassname = Getattr(base.item, "name");
+ if (!c_baseclassname) {
+ c_baseclassname = baseclassname;
+ baseclass = Copy(getProxyName(baseclassname));
+ if (baseclass)
+ c_baseclass = SwigType_namestr(baseclassname);
+ } else {
+ /* Warn about multiple inheritance for additional base class(es) */
+ String *proxyclassname = Getattr(n, "classtypeobj");
+ Swig_warning(WARN_JAVA_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
+ "Warning for %s, base %s ignored. Multiple inheritance is not supported in Java.\n", SwigType_namestr(proxyclassname), SwigType_namestr(baseclassname));
+ }
+ }
+ base = Next(base);
+ }
}
}
+ Hash *interface_bases = Getattr(n, "interface:bases");
+ if (interface_bases)
+ addInterfaceNameAndUpcasts(smart, interface_list, interface_upcasts, interface_bases, c_classname);
+
bool derived = baseclass && getProxyName(c_baseclassname);
if (derived && purebase_notderived)
pure_baseclass = empty_string;
Swig_error(Getfile(n), Getline(n), "The javabase typemap for proxy %s must contain just one of the 'replace' or 'notderived' attributes.\n", typemap_lookup_type);
} else if (Len(pure_baseclass) > 0 && Len(baseclass) > 0) {
Swig_warning(WARN_JAVA_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
- "Warning for %s proxy: Base %s ignored. Multiple inheritance is not supported in Java. "
- "Perhaps you need one of the 'replace' or 'notderived' attributes in the csbase typemap?\n", typemap_lookup_type, pure_baseclass);
+ "Warning for %s, base %s ignored. Multiple inheritance is not supported in Java. "
+ "Perhaps you need one of the 'replace' or 'notderived' attributes in the javabase typemap?\n", typemap_lookup_type, pure_baseclass);
}
// Pure Java interfaces
const String *pure_interfaces = typemapLookup(n, "javainterfaces", typemap_lookup_type, WARN_NONE);
-
+ if (*Char(interface_list) && *Char(pure_interfaces))
+ Append(interface_list, ", ");
+ Append(interface_list, pure_interfaces);
// Start writing the proxy class
- Printv(proxy_class_def, typemapLookup(n, "javaimports", typemap_lookup_type, WARN_NONE), // Import statements
- "\n", typemapLookup(n, "javaclassmodifiers", typemap_lookup_type, WARN_JAVA_TYPEMAP_CLASSMOD_UNDEF), // Class modifiers
+ if (!has_outerclass) // Import statements
+ Printv(proxy_class_def, typemapLookup(n, "javaimports", typemap_lookup_type, WARN_NONE),"\n", NIL);
+ else
+ Printv(proxy_class_def, "static ", NIL); // C++ nested classes correspond to static java classes
+ Printv(proxy_class_def, typemapLookup(n, "javaclassmodifiers", typemap_lookup_type, WARN_JAVA_TYPEMAP_CLASSMOD_UNDEF), // Class modifiers
" $javaclassname", // Class name and bases
- (*Char(wanted_base)) ? " extends " : "", wanted_base, *Char(pure_interfaces) ? // Pure Java interfaces
- " implements " : "", pure_interfaces, " {", derived ? typemapLookup(n, "javabody_derived", typemap_lookup_type, WARN_JAVA_TYPEMAP_JAVABODY_UNDEF) : // main body of class
+ (*Char(wanted_base)) ? " extends " : "", wanted_base, *Char(interface_list) ? // Pure Java interfaces
+ " implements " : "", interface_list, " {", derived ? typemapLookup(n, "javabody_derived", typemap_lookup_type, WARN_JAVA_TYPEMAP_JAVABODY_UNDEF) : // main body of class
typemapLookup(n, "javabody", typemap_lookup_type, WARN_JAVA_TYPEMAP_JAVABODY_UNDEF), // main body of class
NIL);
if (*Char(destruct))
Printv(proxy_class_def, "\n ", destruct_methodmodifiers, " void ", destruct_methodname, "()", destructor_throws_clause, " ", destruct, "\n", NIL);
}
+ if (*Char(interface_upcasts))
+ Printv(proxy_class_def, interface_upcasts, NIL);
/* Insert directordisconnect typemap, if this class has directors enabled */
/* Also insert the swigTakeOwnership and swigReleaseOwnership methods */
if (feature_director) {
String *destruct_jnicall, *release_jnicall, *take_jnicall;
- String *changeown_method_name = Swig_name_member(getNSpace(), proxy_class_name, "change_ownership");
+ String *changeown_method_name = Swig_name_member(getNSpace(), getClassPrefix(), "change_ownership");
destruct_jnicall = NewStringf("%s()", destruct_methodname);
release_jnicall = NewStringf("%s.%s(this, swigCPtr, false)", full_imclass_name, changeown_method_name);
Delete(take_jnicall);
}
+ Delete(interface_upcasts);
+ Delete(interface_list);
Delete(attributes);
Delete(destruct);
Printv(proxy_class_def, typemapLookup(n, "javacode", typemap_lookup_type, WARN_NONE), // extra Java code
"\n", NIL);
- // Add code to do C++ casting to base class (only for classes in an inheritance hierarchy)
if (derived) {
- String *smartptr = Getattr(n, "feature:smartptr");
- String *upcast_method = Swig_name_member(getNSpace(), proxy_class_name, smartptr != 0 ? "SWIGSmartPtrUpcast" : "SWIGUpcast");
- String *jniname = makeValidJniName(upcast_method);
- String *wname = Swig_name_wrapper(jniname);
- Printf(imclass_cppcasts_code, " public final static native long %s(long jarg1);\n", upcast_method);
- if (smartptr) {
- SwigType *spt = Swig_cparse_type(smartptr);
- if (spt) {
- SwigType *smart = SwigType_typedef_resolve_all(spt);
- Delete(spt);
- SwigType *bsmart = Copy(smart);
- SwigType *rclassname = SwigType_typedef_resolve_all(c_classname);
- SwigType *rbaseclass = SwigType_typedef_resolve_all(c_baseclass);
- Replaceall(bsmart, rclassname, rbaseclass);
- Delete(rclassname);
- Delete(rbaseclass);
- String *smartnamestr = SwigType_namestr(smart);
- String *bsmartnamestr = SwigType_namestr(bsmart);
- Printv(upcasts_code,
- "SWIGEXPORT jlong JNICALL ", wname, "(JNIEnv *jenv, jclass jcls, jlong jarg1) {\n",
- " jlong baseptr = 0;\n"
- " ", smartnamestr, " *argp1;\n"
- " (void)jenv;\n"
- " (void)jcls;\n"
- " argp1 = *(", smartnamestr, " **)&jarg1;\n"
- " *(", bsmartnamestr, " **)&baseptr = argp1 ? new ", bsmartnamestr, "(*argp1) : 0;\n"
- " return baseptr;\n"
- "}\n", "\n", NIL);
- Delete(bsmartnamestr);
- Delete(smartnamestr);
- Delete(bsmart);
- } else {
- Swig_error(Getfile(n), Getline(n), "Invalid type (%s) in 'smartptr' feature for class %s.\n", smartptr, c_classname);
- }
- } else {
- Printv(upcasts_code,
- "SWIGEXPORT jlong JNICALL ", wname, "(JNIEnv *jenv, jclass jcls, jlong jarg1) {\n",
- " jlong baseptr = 0;\n"
- " (void)jenv;\n"
- " (void)jcls;\n"
- " *(", c_baseclass, " **)&baseptr = *(", c_classname, " **)&jarg1;\n"
- " return baseptr;\n"
- "}\n", "\n", NIL);
- }
- Delete(wname);
- Delete(jniname);
- Delete(upcast_method);
+ String *upcast_method_name = Swig_name_member(getNSpace(), getClassPrefix(), smart != 0 ? "SWIGSmartPtrUpcast" : "SWIGUpcast");
+ upcastsCode(smart, upcast_method_name, c_classname, c_baseclass);
+ Delete(upcast_method_name);
}
+
+ Delete(smart);
Delete(baseclass);
}
/* ----------------------------------------------------------------------
- * classHandler()
+ * emitInterfaceDeclaration()
* ---------------------------------------------------------------------- */
- virtual int classHandler(Node *n) {
+ void emitInterfaceDeclaration(Node *n, String *interface_name, File *f_interface, String *nspace) {
+ if (package || nspace) {
+ Printf(f_interface, "package ");
+ if (package)
+ Printv(f_interface, package, nspace ? "." : "", NIL);
+ if (nspace)
+ Printv(f_interface, nspace, NIL);
+ Printf(f_interface, ";\n");
+ }
+
+ Printv(f_interface, typemapLookup(n, "javaimports", Getattr(n, "classtypeobj"), WARN_NONE), "\n", NIL);
+ Printf(f_interface, "public interface %s", interface_name);
+ if (List *baselist = Getattr(n, "bases")) {
+ String *bases = 0;
+ for (Iterator base = First(baselist); base.item; base = Next(base)) {
+ if (GetFlag(base.item, "feature:ignore") || !Getattr(base.item, "feature:interface"))
+ continue; // TODO: warn about skipped non-interface bases
+ String *base_iname = Getattr(base.item, "interface:name");
+ if (!bases)
+ bases = Copy(base_iname);
+ else {
+ Append(bases, ", ");
+ Append(bases, base_iname);
+ }
+ }
+ if (bases) {
+ Printv(f_interface, " extends ", bases, NIL);
+ Delete(bases);
+ }
+ }
+ Printf(f_interface, " {\n");
+ Node *attributes = NewHash();
+ String *interface_code = Copy(typemapLookup(n, "javainterfacecode", Getattr(n, "classtypeobj"), WARN_JAVA_TYPEMAP_INTERFACECODE_UNDEF, attributes));
+ if (interface_code) {
+ String *interface_declaration = Copy(Getattr(attributes, "tmap:javainterfacecode:declaration"));
+ if (interface_declaration) {
+ Replaceall(interface_declaration, "$interfacename", interface_name);
+ Printv(f_interface, interface_declaration, NIL);
+ Delete(interface_declaration);
+ }
+ Delete(interface_code);
+ }
+ }
+
+ /* ----------------------------------------------------------------------
+ * classDeclaration()
+ * ---------------------------------------------------------------------- */
+
+ int classDeclaration(Node *n) {
+ return Language::classDeclaration(n);
+ }
+
+ /* ----------------------------------------------------------------------
+ * classHandler()
+ * ---------------------------------------------------------------------- */
+
+ virtual int classHandler(Node *n) {
File *f_proxy = NULL;
+ File *f_interface = NULL;
+ String *old_proxy_class_name = proxy_class_name;
+ String *old_full_proxy_class_name = full_proxy_class_name;
+ String *old_full_imclass_name = full_imclass_name;
+ String *old_destructor_call = destructor_call;
+ String *old_destructor_throws_clause = destructor_throws_clause;
+ String *old_proxy_class_constants_code = proxy_class_constants_code;
+ String *old_proxy_class_def = proxy_class_def;
+ String *old_proxy_class_code = proxy_class_code;
+ bool has_outerclass = Getattr(n, "nested:outer") && !GetFlag(n, "feature:flatnested");
+ String *old_interface_class_code = interface_class_code;
+ interface_class_code = 0;
+
if (proxy_flag) {
proxy_class_name = NewString(Getattr(n, "sym:name"));
String *nspace = getNSpace();
constructIntermediateClassName(n);
+ String *outerClassesPrefix = 0;
+ if (Node *outer = Getattr(n, "nested:outer")) {
+ outerClassesPrefix = Copy(Getattr(outer, "sym:name"));
+ for (outer = Getattr(outer, "nested:outer"); outer != 0; outer = Getattr(outer, "nested:outer")) {
+ Push(outerClassesPrefix, ".");
+ Push(outerClassesPrefix, Getattr(outer, "sym:name"));
+ }
+ }
if (!nspace) {
- full_proxy_class_name = NewStringf("%s", proxy_class_name);
+ full_proxy_class_name = outerClassesPrefix ? NewStringf("%s.%s", outerClassesPrefix, proxy_class_name) : NewStringf("%s", proxy_class_name);
if (Cmp(proxy_class_name, imclass_name) == 0) {
Printf(stderr, "Class name cannot be equal to intermediary class name: %s\n", proxy_class_name);
SWIG_exit(EXIT_FAILURE);
}
} else {
- if (package)
- full_proxy_class_name = NewStringf("%s.%s.%s", package, nspace, proxy_class_name);
- else
- full_proxy_class_name = NewStringf("%s.%s", nspace, proxy_class_name);
+ if (outerClassesPrefix) {
+ if (package)
+ full_proxy_class_name = NewStringf("%s.%s.%s.%s", package, nspace, outerClassesPrefix, proxy_class_name);
+ else
+ full_proxy_class_name = NewStringf("%s.%s.%s", nspace, outerClassesPrefix, proxy_class_name);
+ } else {
+ if (package)
+ full_proxy_class_name = NewStringf("%s.%s.%s", package, nspace, proxy_class_name);
+ else
+ full_proxy_class_name = NewStringf("%s.%s", nspace, proxy_class_name);
+ }
}
- if (!addSymbol(proxy_class_name, n, nspace))
- return SWIG_ERROR;
-
- String *output_directory = outputDirectory(nspace);
- String *filen = NewStringf("%s%s.java", output_directory, proxy_class_name);
- f_proxy = NewFile(filen, "w", SWIG_output_files());
- if (!f_proxy) {
- FileErrorDisplay(filen);
- SWIG_exit(EXIT_FAILURE);
+ String *interface_name = Getattr(n, "feature:interface") ? Getattr(n, "interface:name") : 0;
+ if (outerClassesPrefix) {
+ String *fnspace = nspace ? NewStringf("%s.%s", nspace, outerClassesPrefix) : outerClassesPrefix;
+ if (!addSymbol(proxy_class_name, n, fnspace))
+ return SWIG_ERROR;
+ if (interface_name && !addInterfaceSymbol(interface_name, n, fnspace))
+ return SWIG_ERROR;
+ if (nspace)
+ Delete(fnspace);
+ Delete(outerClassesPrefix);
+ } else {
+ if (!addSymbol(proxy_class_name, n, nspace))
+ return SWIG_ERROR;
+ if (interface_name && !addInterfaceSymbol(interface_name, n, nspace))
+ return SWIG_ERROR;
}
- Append(filenames_list, Copy(filen));
- Delete(filen);
- filen = NULL;
- // Start writing out the proxy class file
- emitBanner(f_proxy);
+ // Each outer proxy class goes into a separate file
+ if (!has_outerclass) {
+ String *output_directory = outputDirectory(nspace);
+ String *filen = NewStringf("%s%s.java", output_directory, proxy_class_name);
+ f_proxy = NewFile(filen, "w", SWIG_output_files());
+ if (!f_proxy) {
+ FileErrorDisplay(filen);
+ SWIG_exit(EXIT_FAILURE);
+ }
+ Append(filenames_list, Copy(filen));
+ Delete(filen);
+ Delete(output_directory);
- if (package || nspace) {
- Printf(f_proxy, "package ");
- if (package)
- Printv(f_proxy, package, nspace ? "." : "", NIL);
- if (nspace)
- Printv(f_proxy, nspace, NIL);
- Printf(f_proxy, ";\n");
- }
+ // Start writing out the proxy class file
+ emitBanner(f_proxy);
- Clear(proxy_class_def);
- Clear(proxy_class_code);
+ if (package || nspace) {
+ Printf(f_proxy, "package ");
+ if (package)
+ Printv(f_proxy, package, nspace ? "." : "", NIL);
+ if (nspace)
+ Printv(f_proxy, nspace, NIL);
+ Printf(f_proxy, ";\n");
+ }
+ }
+ else
+ ++nesting_depth;
+ proxy_class_def = NewString("");
+ proxy_class_code = NewString("");
destructor_call = NewString("");
destructor_throws_clause = NewString("");
proxy_class_constants_code = NewString("");
- Delete(output_directory);
+
+ if (Getattr(n, "feature:interface")) {
+ interface_class_code = NewString("");
+ String *output_directory = outputDirectory(nspace);
+ String *filen = NewStringf("%s%s.java", output_directory, interface_name);
+ f_interface = NewFile(filen, "w", SWIG_output_files());
+ if (!f_interface) {
+ FileErrorDisplay(filen);
+ SWIG_exit(EXIT_FAILURE);
+ }
+ Append(filenames_list, filen); // file name ownership goes to the list
+ emitBanner(f_interface);
+ emitInterfaceDeclaration(n, interface_name, interface_class_code, nspace);
+ Delete(filen);
+ Delete(output_directory);
+ }
}
Language::classHandler(n);
if (proxy_flag) {
-
emitProxyClassDefAndCPPCasts(n);
- String *javaclazzname = Swig_name_member(getNSpace(), proxy_class_name, ""); // mangled full proxy class name
+ String *javaclazzname = Swig_name_member(getNSpace(), getClassPrefix(), ""); // mangled full proxy class name
Replaceall(proxy_class_def, "$javaclassname", proxy_class_name);
Replaceall(proxy_class_code, "$javaclassname", proxy_class_name);
Replaceall(proxy_class_constants_code, "$javaclassname", proxy_class_name);
+ Replaceall(interface_class_code, "$javaclassname", proxy_class_name);
Replaceall(proxy_class_def, "$javaclazzname", javaclazzname);
Replaceall(proxy_class_code, "$javaclazzname", javaclazzname);
Replaceall(proxy_class_constants_code, "$javaclazzname", javaclazzname);
+ Replaceall(interface_class_code, "$javaclazzname", javaclazzname);
Replaceall(proxy_class_def, "$module", module_class_name);
Replaceall(proxy_class_code, "$module", module_class_name);
Replaceall(proxy_class_constants_code, "$module", module_class_name);
+ Replaceall(interface_class_code, "$module", module_class_name);
Replaceall(proxy_class_def, "$imclassname", full_imclass_name);
Replaceall(proxy_class_code, "$imclassname", full_imclass_name);
Replaceall(proxy_class_constants_code, "$imclassname", full_imclass_name);
-
- Printv(f_proxy, proxy_class_def, proxy_class_code, NIL);
+ Replaceall(interface_class_code, "$imclassname", full_imclass_name);
+
+ if (!has_outerclass)
+ Printv(f_proxy, proxy_class_def, proxy_class_code, NIL);
+ else {
+ Swig_offset_string(proxy_class_def, nesting_depth);
+ Append(old_proxy_class_code, proxy_class_def);
+ Swig_offset_string(proxy_class_code, nesting_depth);
+ Append(old_proxy_class_code, proxy_class_code);
+ }
// Write out all the constants
- if (Len(proxy_class_constants_code) != 0)
- Printv(f_proxy, proxy_class_constants_code, NIL);
+ if (Len(proxy_class_constants_code) != 0) {
+ if (!has_outerclass)
+ Printv(f_proxy, proxy_class_constants_code, NIL);
+ else {
+ Swig_offset_string(proxy_class_constants_code, nesting_depth);
+ Append(old_proxy_class_code, proxy_class_constants_code);
+ }
+ }
- Printf(f_proxy, "}\n");
- Delete(f_proxy);
- f_proxy = NULL;
+ if (!has_outerclass) {
+ Printf(f_proxy, "}\n");
+ Delete(f_proxy);
+ f_proxy = NULL;
+ } else {
+ for (int i = 0; i < nesting_depth; ++i)
+ Append(old_proxy_class_code, " ");
+ Append(old_proxy_class_code, "}\n\n");
+ --nesting_depth;
+ }
/* Output the downcast method, if necessary. Note: There's no other really
good place to put this code, since Abstract Base Classes (ABCs) can and should have
downcasts, making the constructorHandler() a bad place (because ABCs don't get to
have constructors emitted.) */
if (GetFlag(n, "feature:javadowncast")) {
- String *downcast_method = Swig_name_member(getNSpace(), proxy_class_name, "SWIGDowncast");
+ String *downcast_method = Swig_name_member(getNSpace(), getClassPrefix(), "SWIGDowncast");
String *jniname = makeValidJniName(downcast_method);
String *wname = Swig_name_wrapper(jniname);
Delete(downcast_method);
}
+ if (f_interface) {
+ Printv(f_interface, interface_class_code, "}\n", NIL);
+ Delete(f_interface);
+ f_interface = 0;
+ }
+
emitDirectorExtraMethods(n);
+ Delete(interface_class_code);
+ interface_class_code = old_interface_class_code;
Delete(javaclazzname);
Delete(proxy_class_name);
- proxy_class_name = NULL;
+ proxy_class_name = old_proxy_class_name;
Delete(full_proxy_class_name);
- full_proxy_class_name = NULL;
+ full_proxy_class_name = old_full_proxy_class_name;
Delete(full_imclass_name);
- full_imclass_name = NULL;
+ full_imclass_name = old_full_imclass_name;
Delete(destructor_call);
- destructor_call = NULL;
+ destructor_call = old_destructor_call;
Delete(destructor_throws_clause);
- destructor_throws_clause = NULL;
+ destructor_throws_clause = old_destructor_throws_clause;
Delete(proxy_class_constants_code);
- proxy_class_constants_code = NULL;
+ proxy_class_constants_code = old_proxy_class_constants_code;
+ Delete(proxy_class_def);
+ proxy_class_def = old_proxy_class_def;
+ Delete(proxy_class_code);
+ proxy_class_code = old_proxy_class_code;
}
return SWIG_OK;
if (proxy_flag) {
String *overloaded_name = getOverloadedName(n);
- String *intermediary_function_name = Swig_name_member(getNSpace(), proxy_class_name, overloaded_name);
+ String *intermediary_function_name = Swig_name_member(getNSpace(), getClassPrefix(), overloaded_name);
Setattr(n, "proxyfuncname", Getattr(n, "sym:name"));
Setattr(n, "imfuncname", intermediary_function_name);
proxyClassFunctionHandler(n);
if (proxy_flag) {
String *overloaded_name = getOverloadedName(n);
- String *intermediary_function_name = Swig_name_member(getNSpace(), proxy_class_name, overloaded_name);
+ String *intermediary_function_name = Swig_name_member(getNSpace(), getClassPrefix(), overloaded_name);
Setattr(n, "proxyfuncname", Getattr(n, "sym:name"));
Setattr(n, "imfuncname", intermediary_function_name);
proxyClassFunctionHandler(n);
bool setter_flag = false;
String *pre_code = NewString("");
String *post_code = NewString("");
+ bool is_interface = Getattr(parentNode(n), "feature:interface") != 0
+ && !static_flag && Getattr(n, "interface:owner") == 0;
if (!proxy_flag)
return;
if (wrapping_member_flag && !enum_constant_flag) {
// For wrapping member variables (Javabean setter)
- setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(getNSpace(), Swig_name_member(0, proxy_class_name, variable_name))) == 0);
+ setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(getNSpace(), Swig_name_member(0, getClassPrefix(), variable_name))) == 0);
}
/* Start generating the proxy function */
if (static_flag)
Printf(function_code, "static ");
Printf(function_code, "%s %s(", return_type, proxy_function_name);
+
+ if (is_interface)
+ Printf(interface_class_code, " %s %s(", return_type, proxy_function_name);
Printv(imcall, full_imclass_name, ".$imfuncname(", NIL);
if (!static_flag) {
Printf(imcall, "swigCPtr");
String *this_type = Copy(getClassType());
- String *name = NewString("self");
+ String *name = NewString("jself");
String *qualifier = Getattr(n, "qualifier");
if (qualifier)
SwigType_push(this_type, qualifier);
}
/* Add parameter to proxy function */
- if (gencomma >= 2)
+ if (gencomma >= 2) {
Printf(function_code, ", ");
+ if (is_interface)
+ Printf(interface_class_code, ", ");
+ }
gencomma = 2;
Printf(function_code, "%s %s", param_type, arg);
+ if (is_interface)
+ Printf(interface_class_code, "%s %s", param_type, arg);
if (prematureGarbageCollectionPreventionParameter(pt, p)) {
String *pgcppname = Getattr(p, "tmap:javain:pgcppname");
Printf(imcall, ")");
Printf(function_code, ")");
+ if (is_interface)
+ Printf(interface_class_code, ");\n");
// Transform return type used in JNI function (in intermediary class) to type used in Java wrapper function (in proxy class)
if ((tm = Swig_typemap_lookup("javaout", n, "", 0))) {
Node *explicit_n = Getattr(n, "explicitcallnode");
if (explicit_n) {
String *ex_overloaded_name = getOverloadedName(explicit_n);
- String *ex_intermediary_function_name = Swig_name_member(getNSpace(), proxy_class_name, ex_overloaded_name);
+ String *ex_intermediary_function_name = Swig_name_member(getNSpace(), getClassPrefix(), ex_overloaded_name);
String *ex_imcall = Copy(imcall);
Replaceall(ex_imcall, "$imfuncname", ex_intermediary_function_name);
// Use the C syntax to make a true Java constant and hope that it compiles as Java code
value = Getattr(n, "enumvalue") ? Copy(Getattr(n, "enumvalue")) : Copy(Getattr(n, "enumvalueex"));
} else {
+ String *newsymname = 0;
+ if (!getCurrentClass() || !proxy_flag) {
+ String *enumClassPrefix = getEnumClassPrefix();
+ if (enumClassPrefix) {
+ // A global scoped enum
+ newsymname = Swig_name_member(0, enumClassPrefix, symname);
+ symname = newsymname;
+ }
+ }
+
// Get the enumvalue from a JNI call
if (!getCurrentClass() || !cparse_cplusplus || !proxy_flag) {
// Strange hack to change the name
value = NewStringf("%s.%s()", full_imclass_name ? full_imclass_name : imclass_name, Swig_name_get(getNSpace(), symname));
} else {
memberconstantHandler(n);
- value = NewStringf("%s.%s()", full_imclass_name ? full_imclass_name : imclass_name, Swig_name_get(getNSpace(), Swig_name_member(0, proxy_class_name, symname)));
+ value = NewStringf("%s.%s()", full_imclass_name ? full_imclass_name : imclass_name, Swig_name_get(getNSpace(), Swig_name_member(0, getEnumClassPrefix(), symname)));
}
+ Delete(newsymname);
}
}
return value;
* getEnumName()
*
* If jnidescriptor is set, inner class names are separated with '$' otherwise a '.'
+ * and the package is also not added to the name.
* ----------------------------------------------------------------------------- */
String *getEnumName(SwigType *t, bool jnidescriptor) {
String *scopename_prefix = Swig_scopename_prefix(Getattr(n, "name"));
String *proxyname = 0;
if (scopename_prefix) {
- proxyname = getProxyName(scopename_prefix);
+ proxyname = getProxyName(scopename_prefix, jnidescriptor);
}
if (proxyname) {
const char *class_separator = jnidescriptor ? "$" : ".";
// global enum or enum in a namespace
String *nspace = Getattr(n, "sym:nspace");
if (nspace) {
- if (package)
+ if (package && !jnidescriptor)
enumname = NewStringf("%s.%s.%s", package, nspace, symname);
else
enumname = NewStringf("%s.%s", nspace, symname);
enumname = Copy(symname);
}
}
- if (!jnidescriptor) { // not cached
- Setattr(n, "enumname", enumname);
+ if (!jnidescriptor) {
+ Setattr(n, "enumname", enumname); // Cache it
Delete(enumname);
}
Delete(scopename_prefix);
* that SWIG knows about. Also substitutes enums with enum name.
* Otherwise use the $descriptor name for the Java class name. Note that the $&javaclassname substitution
* is the same as a $&descriptor substitution, ie one pointer added to descriptor name.
+ * Note that the path separator is a '.' unless jnidescriptor is set.
* Inputs:
* pt - parameter type
* tm - typemap contents that might contain the special variable to be replaced
- * jnidescriptor - if set, inner class names are separated with '$' otherwise a '.'
+ * jnidescriptor - if set, inner class names are separated with '$' otherwise a '/' is used for the path separator
* Outputs:
* tm - typemap contents complete with the special variable substitution
* Return:
substitution_performed = true;
Delete(classnametype);
}
+ if (Strstr(tm, "$javainterfacename")) {
+ SwigType *interfacenametype = Copy(strippedtype);
+ substituteInterfacenameSpecialVariable(interfacenametype, tm, "$javainterfacename", jnidescriptor, true);
+ substitution_performed = true;
+ Delete(interfacenametype);
+ }
+ if (Strstr(tm, "$*javainterfacename")) {
+ SwigType *interfacenametype = Copy(strippedtype);
+ Delete(SwigType_pop(interfacenametype));
+ if (Len(interfacenametype) > 0) {
+ substituteInterfacenameSpecialVariable(interfacenametype, tm, "$*javainterfacename", jnidescriptor, true);
+ substitution_performed = true;
+ }
+ Delete(interfacenametype);
+ }
+ if (Strstr(tm, "$&javainterfacename")) {
+ SwigType *interfacenametype = Copy(strippedtype);
+ SwigType_add_pointer(interfacenametype);
+ substituteInterfacenameSpecialVariable(interfacenametype, tm, "$&javainterfacename", jnidescriptor, true);
+ substitution_performed = true;
+ Delete(interfacenametype);
+ }
+ if (Strstr(tm, "$interfacename")) {
+ SwigType *interfacenametype = Copy(strippedtype);
+ substituteInterfacenameSpecialVariable(interfacenametype, tm, "$interfacename", jnidescriptor, false);
+ substitution_performed = true;
+ Delete(interfacenametype);
+ }
+ if (Strstr(tm, "$*interfacename")) {
+ SwigType *interfacenametype = Copy(strippedtype);
+ Delete(SwigType_pop(interfacenametype));
+ if (Len(interfacenametype) > 0) {
+ substituteInterfacenameSpecialVariable(interfacenametype, tm, "$*interfacename", jnidescriptor, false);
+ substitution_performed = true;
+ }
+ Delete(interfacenametype);
+ }
+ if (Strstr(tm, "$&interfacename")) {
+ SwigType *interfacenametype = Copy(strippedtype);
+ SwigType_add_pointer(interfacenametype);
+ substituteInterfacenameSpecialVariable(interfacenametype, tm, "$&interfacename", jnidescriptor, false);
+ substitution_performed = true;
+ Delete(interfacenametype);
+ }
Delete(strippedtype);
Delete(type);
* ----------------------------------------------------------------------------- */
void substituteClassnameSpecialVariable(SwigType *classnametype, String *tm, const char *classnamespecialvariable, bool jnidescriptor) {
+ String *replacementname;
+
if (SwigType_isenum(classnametype)) {
String *enumname = getEnumName(classnametype, jnidescriptor);
- if (enumname)
- Replaceall(tm, classnamespecialvariable, enumname);
- else
- Replaceall(tm, classnamespecialvariable, NewStringf("int"));
+ if (enumname) {
+ replacementname = Copy(enumname);
+ } else {
+ bool anonymous_enum = (Cmp(classnametype, "enum ") == 0);
+ if (anonymous_enum) {
+ replacementname = NewString("int");
+ } else {
+ // An unknown enum - one that has not been parsed (neither a C enum forward reference nor a definition) or an ignored enum
+ replacementname = NewStringf("SWIGTYPE%s", SwigType_manglestr(classnametype));
+ Replace(replacementname, "enum ", "", DOH_REPLACE_ANY);
+ Setattr(swig_types_hash, replacementname, classnametype);
+ }
+ }
} else {
- String *classname = getProxyName(classnametype);
+ String *classname = getProxyName(classnametype, jnidescriptor); // getProxyName() works for pointers to classes too
if (classname) {
- Replaceall(tm, classnamespecialvariable, classname); // getProxyName() works for pointers to classes too
- } else { // use $descriptor if SWIG does not know anything about this type. Note that any typedefs are resolved.
- String *descriptor = NewStringf("SWIGTYPE%s", SwigType_manglestr(classnametype));
- Replaceall(tm, classnamespecialvariable, descriptor);
+ replacementname = Copy(classname);
+ } else {
+ // use $descriptor if SWIG does not know anything about this type. Note that any typedefs are resolved.
+ replacementname = NewStringf("SWIGTYPE%s", SwigType_manglestr(classnametype));
// Add to hash table so that the type wrapper classes can be created later
- Setattr(swig_types_hash, descriptor, classnametype);
- Delete(descriptor);
+ Setattr(swig_types_hash, replacementname, classnametype);
}
}
+ if (jnidescriptor)
+ Replaceall(replacementname,".","/");
+ Replaceall(tm, classnamespecialvariable, replacementname);
+
+ Delete(replacementname);
}
/* -----------------------------------------------------------------------------
- * makeParameterName()
- *
- * Inputs:
- * n - Node
- * p - parameter node
- * arg_num - parameter argument number
- * setter - set this flag when wrapping variables
- * Return:
- * arg - a unique parameter name
+ * substituteInterfacenameSpecialVariable()
* ----------------------------------------------------------------------------- */
- String *makeParameterName(Node *n, Parm *p, int arg_num, bool setter) {
+ void substituteInterfacenameSpecialVariable(SwigType *interfacenametype, String *tm, const char *interfacenamespecialvariable, bool jnidescriptor, bool qualified) {
- String *arg = 0;
- String *pn = Getattr(p, "name");
+ String *interfacename = getInterfaceName(interfacenametype/*, jnidescriptor*/, qualified);
+ if (interfacename) {
+ String *replacementname = Copy(interfacename);
- // Use C parameter name unless it is a duplicate or an empty parameter name
- int count = 0;
- ParmList *plist = Getattr(n, "parms");
- while (plist) {
- if ((Cmp(pn, Getattr(plist, "name")) == 0))
- count++;
- plist = nextSibling(plist);
- }
- String *wrn = pn ? Swig_name_warning(p, 0, pn, 0) : 0;
- arg = (!pn || (count > 1) || wrn) ? NewStringf("arg%d", arg_num) : Copy(pn);
+ if (jnidescriptor)
+ Replaceall(replacementname,".","/");
+ Replaceall(tm, interfacenamespecialvariable, replacementname);
- if (setter && Cmp(arg, "self") != 0) {
- // Note that for setters the parameter name is always set but sometimes includes C++
- // scope resolution, so we need to strip off the scope resolution to make a valid name.
- Delete(arg);
- arg = NewString("value"); //Swig_scopename_last(pn);
+ Delete(replacementname);
}
-
- return arg;
}
/* -----------------------------------------------------------------------------
Replaceall(swigtype, "$javaclassname", classname);
Replaceall(swigtype, "$module", module_class_name);
Replaceall(swigtype, "$imclassname", imclass_name);
+
+ // For unknown enums
+ Replaceall(swigtype, "$static ", "");
+ Replaceall(swigtype, "$enumvalues", "");
+
Printv(f_swigtype, swigtype, NIL);
Delete(f_swigtype);
* ----------------------------------------------------------------------------- */
String *prematureGarbageCollectionPreventionParameter(SwigType *t, Parm *p) {
- String *proxyClassName = 0;
+ String *pgcpp_java_type = 0;
String *jtype = NewString(Getattr(p, "tmap:jtype"));
// Strip C comments
if (Cmp(jtype, "long") == 0) {
if (proxy_flag) {
if (!GetFlag(p, "tmap:jtype:nopgcpp") && !nopgcpp_flag) {
- String *proxyname = getProxyName(t);
- if (proxyname) {
- // Found a struct/class parameter passed by value, reference, pointer, or pointer reference
- proxyClassName = proxyname;
- } else {
+ String *interface_name = getInterfaceName(t, true);
+ pgcpp_java_type = interface_name ? interface_name : getProxyName(t);
+ if (!pgcpp_java_type) {
// Look for proxy class parameters passed to C++ layer using non-default typemaps, ie not one of above types
String *jstype = NewString(Getattr(p, "tmap:jstype"));
if (jstype) {
if (cls && !Getattr(cls, "feature:ignore")) {
String *symname = Getattr(cls, "sym:name");
if (symname && Strcmp(symname, jstype) == 0) {
- proxyClassName = symname;
+ pgcpp_java_type = symname;
}
}
}
}
}
Delete(jtype);
- return proxyClassName;
+ return pgcpp_java_type;
}
/* -----------------------------------------------------------------------------
Printf(f_runtime, "namespace Swig {\n");
Printf(f_runtime, " namespace {\n");
Printf(f_runtime, " jclass jclass_%s = NULL;\n", imclass_name);
- Printf(f_runtime, " jmethodID director_methids[%d];\n", n_methods);
+ Printf(f_runtime, " jmethodID director_method_ids[%d];\n", n_methods);
Printf(f_runtime, " }\n");
Printf(f_runtime, "}\n");
Printf(w->code, "Swig::jclass_%s = (jclass) jenv->NewGlobalRef(jcls);\n", imclass_name);
Printf(w->code, "if (!Swig::jclass_%s) return;\n", imclass_name);
Printf(w->code, "for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) {\n");
- Printf(w->code, " Swig::director_methids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);\n");
- Printf(w->code, " if (!Swig::director_methids[i]) return;\n");
+ Printf(w->code, " Swig::director_method_ids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);\n");
+ Printf(w->code, " if (!Swig::director_method_ids[i]) return;\n");
Printf(w->code, "}\n");
Printf(w->code, "}\n");
// Output the director connect method:
String *jni_imclass_name = makeValidJniName(imclass_name);
String *norm_name = SwigType_namestr(Getattr(n, "name"));
- String *swig_director_connect = Swig_name_member(getNSpace(), proxy_class_name, "director_connect");
+ String *swig_director_connect = Swig_name_member(getNSpace(), getClassPrefix(), "director_connect");
String *swig_director_connect_jni = makeValidJniName(swig_director_connect);
String *smartptr = Getattr(n, "feature:smartptr");
String *dirClassName = directorClassName(n);
"SWIGEXPORT void JNICALL Java_%s%s_%s(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, "
"jboolean jweak_global) {\n", jnipackage, jni_imclass_name, swig_director_connect_jni);
- if (Len(smartptr)) {
+ if (smartptr) {
Printf(code_wrap->code, " %s *obj = *((%s **)&objarg);\n", smartptr, smartptr);
Printf(code_wrap->code, " (void)jcls;\n");
Printf(code_wrap->code, " // Keep a local instance of the smart pointer around while we are using the raw pointer\n");
Delete(swig_director_connect);
// Output the swigReleaseOwnership, swigTakeOwnership methods:
- String *changeown_method_name = Swig_name_member(getNSpace(), proxy_class_name, "change_ownership");
+ String *changeown_method_name = Swig_name_member(getNSpace(), getClassPrefix(), "change_ownership");
String *changeown_jnimethod_name = makeValidJniName(changeown_method_name);
Printf(imclass_class_code, " public final static native void %s(%s obj, long cptr, boolean take_or_release);\n", changeown_method_name, full_proxy_class_name);
// Delete(method_attr);
}
+ /* -----------------------------------------------------------------------------
+ * substitutePackagePath()
+ *
+ * Replace $packagepath using the javapackage typemap associated with passed
+ * parm or global package if p is 0. "$packagepath/" is replaced with "" if
+ * no package is set. Note that the path separator is a '/'.
+ * ----------------------------------------------------------------------------- */
+
+ void substitutePackagePath(String *text, Parm *p) {
+ String *pkg_path= 0;
+
+ if (p)
+ pkg_path = Swig_typemap_lookup("javapackage", p, "", 0);
+ if (!pkg_path || Len(pkg_path) == 0)
+ pkg_path = Copy(package_path);
+
+ if (Len(pkg_path) > 0) {
+ Replaceall(pkg_path, ".", "/");
+ Replaceall(text, "$packagepath", pkg_path);
+ } else {
+ Replaceall(text, "$packagepath/", empty_string);
+ Replaceall(text, "$packagepath", empty_string);
+ }
+ Delete(pkg_path);
+ }
+
/* ---------------------------------------------------------------
* Canonicalize the JNI field descriptor
*
- * Replace the $javapackage and $javaclassname family of special
+ * Replace the $packagepath and $javaclassname family of special
* variables with the desired package and Java proxy name as
* required in the JNI field descriptors.
*
* --------------------------------------------------------------- */
String *canonicalizeJNIDescriptor(String *descriptor_in, Parm *p) {
- String *pkg_path = Swig_typemap_lookup("javapackage", p, "", 0);
SwigType *type = Getattr(p, "type");
-
- if (!pkg_path || Len(pkg_path) == 0)
- pkg_path = package_path;
-
String *descriptor_out = Copy(descriptor_in);
substituteClassname(type, descriptor_out, true);
-
- if (Len(pkg_path) > 0 && Strchr(descriptor_out, '.') == NULL) {
- Replaceall(descriptor_out, "$packagepath", pkg_path);
- } else {
- Replaceall(descriptor_out, "$packagepath/", empty_string);
- Replaceall(descriptor_out, "$packagepath", empty_string);
- }
-
- Replaceall(descriptor_out, ".", "/");
-
- if (pkg_path != package_path)
- Delete(pkg_path);
+ substitutePackagePath(descriptor_out, p);
return descriptor_out;
}
* --------------------------------------------------------------- */
int classDirectorMethod(Node *n, Node *parent, String *super) {
- String *classname = Getattr(parent, "sym:name");
String *c_classname = Getattr(parent, "name");
String *name = Getattr(n, "name");
String *symname = Getattr(n, "sym:name");
String *imcall_args = NewString("");
int classmeth_off = curr_class_dmethod - first_class_dmethod;
bool ignored_method = GetFlag(n, "feature:ignore") ? true : false;
- String *qualified_classname = Copy(classname);
- String *nspace = getNSpace();
-
- if (nspace && package)
- Insert(qualified_classname, 0, NewStringf("%s.%s.", package, nspace));
- else if(nspace)
- Insert(qualified_classname, 0, NewStringf("%s.", nspace));
-
+ String *qualified_classname = getProxyName(getClassName());
// Kludge Alert: functionWrapper sets sym:overload properly, but it
// isn't at this point, so we have to manufacture it ourselves. At least
/* Create the intermediate class wrapper */
tm = Swig_typemap_lookup("jtype", n, "", 0);
if (tm) {
- Printf(callback_def, " public static %s %s(%s self", tm, imclass_dmethod, qualified_classname);
+ Printf(callback_def, " public static %s %s(%s jself", tm, imclass_dmethod, qualified_classname);
} else {
Swig_warning(WARN_JAVA_TYPEMAP_JTYPE_UNDEF, input_file, line_number, "No jtype typemap defined for %s\n", SwigType_str(returntype, 0));
}
}
Delete(adjustedreturntypeparm);
- Delete(qualified_classname);
Swig_director_parms_fixup(l);
Printf(w->code, "if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\n");
}
- /* Start the Java field descriptor for the intermediate class's upcall (insert self object) */
+ /* Start the Java field descriptor for the intermediate class's upcall (insert jself object) */
Parm *tp = NewParmNode(c_classname, n);
String *jdesc;
// Get any Java exception classes in the throws typemap
ParmList *throw_parm_list = NULL;
+ // May need to add Java throws clause to director methods if %catches defined
+ // Get any Java exception classes in the throws typemap
+ ParmList *catches_list = Getattr(n, "catchlist");
+ if (catches_list) {
+ Swig_typemap_attach_parms("throws", catches_list, 0);
+ Swig_typemap_attach_parms("directorthrows", catches_list, 0);
+ for (p = catches_list; p; p = nextSibling(p)) {
+ addThrows(n, "tmap:throws", p);
+ }
+ }
+
if ((throw_parm_list = Getattr(n, "throws")) || Getattr(n, "throw")) {
int gencomma = 0;
Append(w->def, " throw(");
Append(declaration, " throw(");
- if (throw_parm_list)
+ if (throw_parm_list) {
Swig_typemap_attach_parms("throws", throw_parm_list, 0);
+ Swig_typemap_attach_parms("directorthrows", throw_parm_list, 0);
+ }
for (p = throw_parm_list; p; p = nextSibling(p)) {
if (Getattr(p, "tmap:throws")) {
- addThrows(n, "tmap:throws", p);
+ // %catches replaces the specified exception specification
+ if (!catches_list) {
+ addThrows(n, "tmap:throws", p);
+ }
if (gencomma++) {
Append(w->def, ", ");
/* Emit the intermediate class's upcall to the actual class */
- String *upcall = NewStringf("self.%s(%s)", symname, imcall_args);
+ String *upcall = NewStringf("jself.%s(%s)", symname, imcall_args);
// Handle exception classes specified in the "except" feature's "throws" attribute
addThrows(n, "feature:except", n);
if (!is_void)
Printf(w->code, "jresult = (%s) ", c_ret_type);
- Printf(w->code, "jenv->%s(Swig::jclass_%s, Swig::director_methids[%s], %s);\n", methop, imclass_name, methid, jupcall_args);
+ Printf(w->code, "jenv->%s(Swig::jclass_%s, Swig::director_method_ids[%s], %s);\n", methop, imclass_name, methid, jupcall_args);
- Printf(w->code, "if (jenv->ExceptionCheck() == JNI_TRUE) return $null;\n");
+ // Generate code to handle any Java exception thrown by director delegation
+ directorExceptHandler(n, catches_list ? catches_list : throw_parm_list, w);
if (!is_void) {
String *jresult_str = NewString("jresult");
/* Terminate wrapper code */
Printf(w->code, "} else {\n");
- Printf(w->code, "SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, \"null upcall object\");\n");
+ Printf(w->code, "SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, \"null upcall object in %s::%s \");\n",
+ SwigType_namestr(c_classname), SwigType_namestr(name));
Printf(w->code, "}\n");
Printf(w->code, "if (swigjobj) jenv->DeleteLocalRef(swigjobj);\n");
}
/* ------------------------------------------------------------
+ * directorExceptHandler()
+ *
+ * Emit code to map Java exceptions back to C++ exceptions when
+ * feature("director:except") is applied to a method node.
+ * This is generated after the Java method upcall.
+ * ------------------------------------------------------------ */
+
+ void directorExceptHandler(Node *n, ParmList *throw_parm_list, Wrapper *w) {
+
+ String *directorexcept = Getattr(n, "feature:director:except");
+ if (!directorexcept) {
+ directorexcept = NewString("");
+ Printf(directorexcept, "jthrowable $error = jenv->ExceptionOccurred();\n");
+ Printf(directorexcept, "if ($error) {\n");
+ Printf(directorexcept, " jenv->ExceptionClear();$directorthrowshandlers\n");
+ Printf(directorexcept, " throw Swig::DirectorException(jenv, $error);\n");
+ Printf(directorexcept, "}\n");
+ } else {
+ directorexcept = Copy(directorexcept);
+ }
+
+ // Can explicitly disable director:except by setting to "" or "0"
+ if (Len(directorexcept) > 0 && Cmp(directorexcept, "0") != 0) {
+
+ // Replace $packagepath
+ substitutePackagePath(directorexcept, 0);
+
+ // Replace $directorthrowshandlers with any defined typemap handlers (or nothing)
+ if (Strstr(directorexcept, "$directorthrowshandlers")) {
+ String *directorthrowshandlers_code = NewString("");
+
+ for (Parm *p = throw_parm_list; p; p = nextSibling(p)) {
+ String *tm = Getattr(p, "tmap:directorthrows");
+
+ if (tm) {
+ // replace $packagepath/$javaclassname
+ String *directorthrows = canonicalizeJNIDescriptor(tm, p);
+ Printv(directorthrowshandlers_code, directorthrows, NIL);
+ Delete(directorthrows);
+ } else {
+ String *t = Getattr(p,"type");
+ Swig_warning(WARN_TYPEMAP_DIRECTORTHROWS_UNDEF, Getfile(n), Getline(n), "No directorthrows typemap defined for %s\n", SwigType_str(t, 0));
+ }
+ }
+ Replaceall(directorexcept, "$directorthrowshandlers", directorthrowshandlers_code);
+ Delete(directorthrowshandlers_code);
+ }
+
+ Replaceall(directorexcept, "$error", "swigerror");
+ Printf(w->code, " %s\n", directorexcept);
+ }
+ Delete(directorexcept);
+ }
+
+ /* ------------------------------------------------------------
* directorPrefixArgs()
* ------------------------------------------------------------ */
* ------------------------------------------------------------ */
int classDirectorEnd(Node *n) {
- String *classname = Getattr(n, "sym:name");
+ String *full_classname = Getattr(n, "name");
+ String *classname = getProxyName(full_classname, true);
String *director_classname = directorClassName(n);
String *internal_classname;
Wrapper *w = NewWrapper();
- if (Len(package_path) > 0 && Len(getNSpace()) > 0)
- internal_classname = NewStringf("%s/%s/%s", package_path, getNSpace(), classname);
- else if (Len(package_path) > 0)
+ if (Len(package_path) > 0)
internal_classname = NewStringf("%s/%s", package_path, classname);
- else if (Len(getNSpace()) > 0)
- internal_classname = NewStringf("%s/%s", getNSpace(), classname);
else
internal_classname = NewStringf("%s", classname);
Printf(f_directors_h, " return (n < %d ? swig_override[n] : false);\n", n_methods);
Printf(f_directors_h, " }\n");
Printf(f_directors_h, "protected:\n");
- Printf(f_directors_h, " bool swig_override[%d];\n", n_methods);
+ Printf(f_directors_h, " Swig::BoolArray<%d> swig_override;\n", n_methods);
/* Emit the code to look up the class's methods, initialize the override array */
/*----------------------------------------------------------------------
* extraDirectorProtectedCPPMethodsRequired()
*--------------------------------------------------------------------*/
+
bool extraDirectorProtectedCPPMethodsRequired() const {
return false;
}
Setattr(n, "director:ctor", class_ctor);
}
+ /*----------------------------------------------------------------------
+ * nestedClassesSupport()
+ *--------------------------------------------------------------------*/
+
+ NestedClassSupport nestedClassesSupport() const {
+ return NCS_Full;
+ }
}; /* class JAVA */
/* -----------------------------------------------------------------------------
* Static member variables
* ----------------------------------------------------------------------------- */
-const char *JAVA::usage = (char *) "\
+const char *JAVA::usage = "\
Java Options (available with -java)\n\
-nopgcpp - Suppress premature garbage collection prevention parameter\n\
-noproxy - Generate the low-level functional interface instead\n\
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * This file is part of SWIG, which is licensed as a whole under version 3
+ * (or any later version) of the GNU General Public License. Some additional
+ * terms also apply to certain portions of SWIG. The full details of the SWIG
+ * license and copyrights can be found in the LICENSE and COPYRIGHT files
+ * included with the SWIG source code as distributed by the SWIG developers
+ * and at http://www.swig.org/legal.html.
+ *
+ * javascript.cxx
+ *
+ * Javascript language module for SWIG.
+ * ----------------------------------------------------------------------------- */
+
+#include "swigmod.h"
+#include "cparse.h"
+
+/**
+ * Enables extra debugging information in typemaps.
+ */
+static bool js_template_enable_debug = false;
+
+#define ERR_MSG_ONLY_ONE_ENGINE_PLEASE "Only one engine can be specified at a time."
+
+// keywords used for state variables
+#define NAME "name"
+#define NAME_MANGLED "name_mangled"
+#define TYPE "type"
+#define TYPE_MANGLED "type_mangled"
+#define WRAPPER_NAME "wrapper"
+#define IS_IMMUTABLE "is_immutable"
+#define IS_STATIC "is_static"
+#define IS_ABSTRACT "is_abstract"
+#define GETTER "getter"
+#define SETTER "setter"
+#define PARENT "parent"
+#define CTOR "ctor"
+#define CTOR_WRAPPERS "ctor_wrappers"
+#define CTOR_DISPATCHERS "ctor_dispatchers"
+#define DTOR "dtor"
+#define ARGCOUNT "wrap:argc"
+#define HAS_TEMPLATES "has_templates"
+#define FORCE_CPP "force_cpp"
+#define RESET true
+
+// keys for global state variables
+#define CREATE_NAMESPACES "create_namespaces"
+#define REGISTER_NAMESPACES "register_namespaces"
+#define INITIALIZER "initializer"
+
+// keys for class scoped state variables
+#define MEMBER_VARIABLES "member_variables"
+#define MEMBER_FUNCTIONS "member_functions"
+#define STATIC_FUNCTIONS "static_functions"
+#define STATIC_VARIABLES "static_variables"
+
+
+/**
+ * A convenience class to manage state variables for emitters.
+ * The implementation delegates to SWIG Hash DOHs and provides
+ * named sub-hashes for class, variable, and function states.
+ */
+class JSEmitterState {
+
+public:
+ JSEmitterState();
+ ~JSEmitterState();
+ DOH *globals();
+ DOH *globals(const char *key, DOH *initial = 0);
+ DOH *clazz(bool reset = false);
+ DOH *clazz(const char *key, DOH *initial = 0);
+ DOH *function(bool reset = false);
+ DOH *function(const char *key, DOH *initial = 0);
+ DOH *variable(bool reset = false);
+ DOH *variable(const char *key, DOH *initial = 0);
+ static int IsSet(DOH *val);
+
+private:
+ DOH *getState(const char *key, bool reset = false);
+ Hash *globalHash;
+};
+
+/**
+ * A convenience class that wraps a code snippet used as template
+ * for code generation.
+ */
+class Template {
+
+public:
+ Template(const String *code);
+ Template(const String *code, const String *templateName);
+ Template(const Template & other);
+ ~Template();
+ String *str();
+ Template & replace(const String *pattern, const String *repl);
+ Template & print(DOH *doh);
+ Template & pretty_print(DOH *doh);
+ void operator=(const Template & t);
+ Template & trim();
+
+private:
+ String *code;
+ String *templateName;
+};
+
+/**
+ * JSEmitter represents an abstraction of javascript code generators
+ * for different javascript engines.
+ **/
+class JSEmitter {
+
+protected:
+
+ typedef JSEmitterState State;
+
+ enum MarshallingMode {
+ Setter,
+ Getter,
+ Ctor,
+ Function
+ };
+
+public:
+
+ enum JSEngine {
+ JavascriptCore,
+ V8,
+ NodeJS
+ };
+
+ JSEmitter(JSEngine engine);
+
+ virtual ~ JSEmitter();
+
+ /**
+ * Opens output files and temporary output DOHs.
+ */
+ virtual int initialize(Node *n);
+
+ /**
+ * Writes all collected code into the output file(s).
+ */
+ virtual int dump(Node *n) = 0;
+
+ /**
+ * Cleans up all open output DOHs.
+ */
+ virtual int close() = 0;
+
+ /**
+ * Switches the context for code generation.
+ *
+ * Classes, global variables and global functions may need to
+ * be registered in certain static tables.
+ * This method should be used to switch output DOHs correspondingly.
+ */
+ virtual int switchNamespace(Node *);
+
+ /**
+ * Invoked at the beginning of the classHandler.
+ */
+ virtual int enterClass(Node *);
+
+ /**
+ * Invoked at the end of the classHandler.
+ */
+ virtual int exitClass(Node *) {
+ return SWIG_OK;
+ };
+
+ /**
+ * Invoked at the beginning of the variableHandler.
+ */
+ virtual int enterVariable(Node *);
+
+ /**
+ * Invoked at the end of the variableHandler.
+ */
+ virtual int exitVariable(Node *) {
+ return SWIG_OK;
+ };
+
+ /**
+ * Invoked at the beginning of the functionHandler.
+ */
+ virtual int enterFunction(Node *);
+
+ /**
+ * Invoked at the end of the functionHandler.
+ */
+ virtual int exitFunction(Node *) {
+ return SWIG_OK;
+ };
+
+ /**
+ * Invoked by functionWrapper callback after call to Language::functionWrapper.
+ */
+ virtual int emitWrapperFunction(Node *n);
+
+ /**
+ * Invoked from constantWrapper after call to Language::constantWrapper.
+ **/
+ virtual int emitConstant(Node *n);
+
+ /**
+ * Registers a given code snippet for a given key name.
+ *
+ * This method is called by the fragmentDirective handler
+ * of the JAVASCRIPT language module.
+ **/
+ int registerTemplate(const String *name, const String *code);
+
+ /**
+ * Retrieve the code template registered for a given name.
+ */
+ Template getTemplate(const String *name);
+
+ State & getState();
+
+protected:
+
+ /**
+ * Generates code for a constructor function.
+ */
+ virtual int emitCtor(Node *n);
+
+ /**
+ * Generates code for a destructor function.
+ */
+ virtual int emitDtor(Node *n);
+
+ /**
+ * Generates code for a function.
+ */
+ virtual int emitFunction(Node *n, bool is_member, bool is_static);
+
+ virtual int emitFunctionDispatcher(Node *n, bool /*is_member */ );
+
+ /**
+ * Generates code for a getter function.
+ */
+ virtual int emitGetter(Node *n, bool is_member, bool is_static);
+
+ /**
+ * Generates code for a setter function.
+ */
+ virtual int emitSetter(Node *n, bool is_member, bool is_static);
+
+ virtual void marshalInputArgs(Node *n, ParmList *parms, Wrapper *wrapper, MarshallingMode mode, bool is_member, bool is_static) = 0;
+
+ virtual String *emitInputTypemap(Node *n, Parm *params, Wrapper *wrapper, String *arg);
+
+ virtual void marshalOutput(Node *n, ParmList *params, Wrapper *wrapper, String *actioncode, const String *cresult = 0, bool emitReturnVariable = true);
+
+ virtual void emitCleanupCode(Node *n, Wrapper *wrapper, ParmList *params);
+
+ /**
+ * Helper function to retrieve the first parent class node.
+ */
+ Node *getBaseClass(Node *n);
+
+ Parm *skipIgnoredArgs(Parm *p);
+
+ virtual int createNamespace(String *scope);
+
+ virtual Hash *createNamespaceEntry(const char *name, const char *parent);
+
+ virtual int emitNamespaces() = 0;
+
+
+protected:
+
+ JSEngine engine;
+ Hash *templates;
+ State state;
+
+ // contains context specific data (DOHs)
+ // to allow generation of namespace related code
+ // which are switched on namespace change
+ Hash *namespaces;
+ Hash *current_namespace;
+ String *defaultResultName;
+ File *f_wrappers;
+};
+
+/* factory methods for concrete JSEmitters: */
+
+JSEmitter *swig_javascript_create_JSCEmitter();
+JSEmitter *swig_javascript_create_V8Emitter();
+JSEmitter *swig_javascript_create_NodeJSEmitter();
+
+/**********************************************************************
+ * JAVASCRIPT: SWIG module implementation
+ **********************************************************************/
+
+class JAVASCRIPT:public Language {
+
+public:
+
+ JAVASCRIPT():emitter(NULL) {
+ }
+ ~JAVASCRIPT() {
+ delete emitter;
+ }
+
+ virtual int functionHandler(Node *n);
+ virtual int globalfunctionHandler(Node *n);
+ virtual int variableHandler(Node *n);
+ virtual int globalvariableHandler(Node *n);
+ virtual int staticmemberfunctionHandler(Node *n);
+ virtual int classHandler(Node *n);
+ virtual int functionWrapper(Node *n);
+ virtual int constantWrapper(Node *n);
+ virtual void main(int argc, char *argv[]);
+ virtual int top(Node *n);
+
+ /**
+ * Registers all %fragments assigned to section "templates".
+ **/
+ virtual int fragmentDirective(Node *n);
+
+public:
+
+ virtual String *getNSpace() const;
+
+private:
+
+ JSEmitter *emitter;
+};
+
+/* ---------------------------------------------------------------------
+ * functionWrapper()
+ *
+ * Low level code generator for functions
+ * --------------------------------------------------------------------- */
+
+int JAVASCRIPT::functionWrapper(Node *n) {
+
+ // note: the default implementation only prints a message
+ // Language::functionWrapper(n);
+ emitter->emitWrapperFunction(n);
+
+ return SWIG_OK;
+}
+
+/* ---------------------------------------------------------------------
+ * functionHandler()
+ *
+ * Function handler for generating wrappers for functions
+ * --------------------------------------------------------------------- */
+int JAVASCRIPT::functionHandler(Node *n) {
+
+ if (GetFlag(n, "isextension") == 1) {
+ SetFlag(n, "ismember");
+ }
+
+ emitter->enterFunction(n);
+ Language::functionHandler(n);
+ emitter->exitFunction(n);
+
+ return SWIG_OK;
+}
+
+/* ---------------------------------------------------------------------
+ * globalfunctionHandler()
+ *
+ * Function handler for generating wrappers for functions
+ * --------------------------------------------------------------------- */
+
+int JAVASCRIPT::globalfunctionHandler(Node *n) {
+ emitter->switchNamespace(n);
+ Language::globalfunctionHandler(n);
+
+ return SWIG_OK;
+}
+
+/* ---------------------------------------------------------------------
+ * staticmemberfunctionHandler()
+ *
+ * Function handler for generating wrappers for static member functions
+ * --------------------------------------------------------------------- */
+
+int JAVASCRIPT::staticmemberfunctionHandler(Node *n) {
+ /*
+ * Note: storage=static is removed by Language::staticmemberfunctionHandler.
+ * So, don't rely on that after here. Instead use the state variable which is
+ * set by JSEmitter::enterFunction().
+ */
+ Language::staticmemberfunctionHandler(n);
+ return SWIG_OK;
+}
+
+/* ---------------------------------------------------------------------
+ * variableHandler()
+ *
+ * Function handler for generating wrappers for variables
+ * --------------------------------------------------------------------- */
+
+int JAVASCRIPT::variableHandler(Node *n) {
+
+ emitter->enterVariable(n);
+ Language::variableHandler(n);
+ emitter->exitVariable(n);
+
+ return SWIG_OK;
+}
+
+/* ---------------------------------------------------------------------
+ * globalvariableHandler()
+ *
+ * Function handler for generating wrappers for global variables
+ * --------------------------------------------------------------------- */
+
+int JAVASCRIPT::globalvariableHandler(Node *n) {
+ emitter->switchNamespace(n);
+ Language::globalvariableHandler(n);
+
+ return SWIG_OK;
+}
+
+/* ---------------------------------------------------------------------
+ * constantHandler()
+ *
+ * Function handler for generating wrappers for constants
+ * --------------------------------------------------------------------- */
+
+int JAVASCRIPT::constantWrapper(Node *n) {
+ emitter->switchNamespace(n);
+
+ // Note: callbacks trigger this wrapper handler
+ // TODO: handle callback declarations
+ if (Equal(Getattr(n, "kind"), "function")) {
+ return SWIG_OK;
+ }
+ // TODO: the emitter for constants must be implemented in a cleaner way
+ // currently we treat it like a read-only variable
+ // however, there is a remaining bug with function pointer constants
+ // which could be fixed with a cleaner approach
+ emitter->emitConstant(n);
+
+ return SWIG_OK;
+}
+
+/* ---------------------------------------------------------------------
+ * classHandler()
+ *
+ * Function handler for generating wrappers for class
+ * --------------------------------------------------------------------- */
+
+int JAVASCRIPT::classHandler(Node *n) {
+ emitter->switchNamespace(n);
+
+ emitter->enterClass(n);
+ Language::classHandler(n);
+ emitter->exitClass(n);
+
+ return SWIG_OK;
+}
+
+int JAVASCRIPT::fragmentDirective(Node *n) {
+
+ // catch all fragment directives that have "templates" as location
+ // and register them at the emitter.
+ String *section = Getattr(n, "section");
+
+ if (Equal(section, "templates")) {
+ emitter->registerTemplate(Getattr(n, "value"), Getattr(n, "code"));
+ } else {
+ Swig_fragment_register(n);
+ }
+
+ return SWIG_OK;
+}
+
+String *JAVASCRIPT::getNSpace() const {
+ return Language::getNSpace();
+}
+
+/* ---------------------------------------------------------------------
+ * top()
+ *
+ * Function handler for processing top node of the parse tree
+ * Wrapper code generation essentially starts from here
+ * --------------------------------------------------------------------- */
+
+int JAVASCRIPT::top(Node *n) {
+ emitter->initialize(n);
+
+ Language::top(n);
+
+ emitter->dump(n);
+ emitter->close();
+
+ return SWIG_OK;
+}
+
+static const char *usage = (char *) "\
+Javascript Options (available with -javascript)\n\
+ -jsc - creates a JavascriptCore extension \n\
+ -v8 - creates a v8 extension \n\
+ -node - creates a node.js extension \n\
+ -debug-codetemplates - generates information about the origin of code templates\n";
+
+
+/* ---------------------------------------------------------------------
+ * main()
+ *
+ * Entry point for the JAVASCRIPT module
+ * --------------------------------------------------------------------- */
+
+void JAVASCRIPT::main(int argc, char *argv[]) {
+ // Set javascript subdirectory in SWIG library
+ SWIG_library_directory("javascript");
+
+ int engine = -1;
+
+ for (int i = 1; i < argc; i++) {
+ if (argv[i]) {
+ if (strcmp(argv[i], "-v8") == 0) {
+ if (engine != -1) {
+ Printf(stderr, ERR_MSG_ONLY_ONE_ENGINE_PLEASE);
+ SWIG_exit(-1);
+ }
+ Swig_mark_arg(i);
+ engine = JSEmitter::V8;
+ } else if (strcmp(argv[i], "-jsc") == 0) {
+ if (engine != -1) {
+ Printf(stderr, ERR_MSG_ONLY_ONE_ENGINE_PLEASE);
+ SWIG_exit(-1);
+ }
+ Swig_mark_arg(i);
+ engine = JSEmitter::JavascriptCore;
+ } else if (strcmp(argv[i], "-node") == 0) {
+ if (engine != -1) {
+ Printf(stderr, ERR_MSG_ONLY_ONE_ENGINE_PLEASE);
+ SWIG_exit(-1);
+ }
+ Swig_mark_arg(i);
+ engine = JSEmitter::NodeJS;
+ } else if (strcmp(argv[i], "-debug-codetemplates") == 0) {
+ Swig_mark_arg(i);
+ js_template_enable_debug = true;
+ } else if (strcmp(argv[i], "-help") == 0) {
+ fputs(usage, stdout);
+ return;
+ }
+ }
+ }
+
+ switch (engine) {
+ case JSEmitter::V8:
+ {
+ emitter = swig_javascript_create_V8Emitter();
+ Preprocessor_define("SWIG_JAVASCRIPT_V8 1", 0);
+ SWIG_library_directory("javascript/v8");
+ // V8 API is C++, so output must be C++ compatibile even when wrapping C code
+ if (!cparse_cplusplus) {
+ Swig_cparse_cplusplusout(1);
+ }
+ break;
+ }
+ case JSEmitter::JavascriptCore:
+ {
+ emitter = swig_javascript_create_JSCEmitter();
+ Preprocessor_define("SWIG_JAVASCRIPT_JSC 1", 0);
+ SWIG_library_directory("javascript/jsc");
+ break;
+ }
+ case JSEmitter::NodeJS:
+ {
+ emitter = swig_javascript_create_V8Emitter();
+ Preprocessor_define("SWIG_JAVASCRIPT_V8 1", 0);
+ Preprocessor_define("BUILDING_NODE_EXTENSION 1", 0);
+ SWIG_library_directory("javascript/v8");
+ break;
+ }
+ default:
+ {
+ Printf(stderr, "SWIG Javascript: Unknown engine. Please specify one of '-jsc', '-v8' or '-node'.\n");
+ SWIG_exit(-1);
+ break;
+ }
+ }
+
+ // Add a symbol to the parser for conditional compilation
+ Preprocessor_define("SWIGJAVASCRIPT 1", 0);
+
+ // Add typemap definitions
+ SWIG_typemap_lang("javascript");
+
+ // Set configuration file
+ SWIG_config_file("javascript.swg");
+
+ allow_overloading();
+}
+
+/* -----------------------------------------------------------------------------
+ * swig_javascript() - Instantiate module
+ * ----------------------------------------------------------------------------- */
+
+static Language *new_swig_javascript() {
+ return new JAVASCRIPT();
+}
+
+extern "C" Language *swig_javascript(void) {
+ return new_swig_javascript();
+}
+
+/**********************************************************************
+ * Emitter implementations
+ **********************************************************************/
+
+/* -----------------------------------------------------------------------------
+ * JSEmitter()
+ * ----------------------------------------------------------------------------- */
+
+JSEmitter::JSEmitter(JSEmitter::JSEngine engine)
+: engine(engine), templates(NewHash()), namespaces(NULL), current_namespace(NULL), defaultResultName(NewString("result")), f_wrappers(NULL) {
+}
+
+/* -----------------------------------------------------------------------------
+ * ~JSEmitter()
+ * ----------------------------------------------------------------------------- */
+
+JSEmitter::~JSEmitter() {
+ Delete(templates);
+}
+
+/* -----------------------------------------------------------------------------
+ * JSEmitter::RegisterTemplate() : Registers a code template
+ *
+ * Note: this is used only by JAVASCRIPT::fragmentDirective().
+ * ----------------------------------------------------------------------------- */
+
+int JSEmitter::registerTemplate(const String *name, const String *code) {
+ if (!State::IsSet(state.globals(HAS_TEMPLATES))) {
+ SetFlag(state.globals(), HAS_TEMPLATES);
+ }
+ return Setattr(templates, name, code);
+}
+
+/* -----------------------------------------------------------------------------
+ * JSEmitter::getTemplate() : Provides a registered code template
+ * ----------------------------------------------------------------------------- */
+
+Template JSEmitter::getTemplate(const String *name) {
+ String *templ = Getattr(templates, name);
+
+ if (!templ) {
+ Printf(stderr, "Could not find template %s\n.", name);
+ SWIG_exit(EXIT_FAILURE);
+ }
+
+ Template t(templ, name);
+ return t;
+}
+
+JSEmitterState & JSEmitter::getState() {
+ return state;
+}
+
+int JSEmitter::initialize(Node * /*n */ ) {
+
+ if (namespaces != NULL) {
+ Delete(namespaces);
+ }
+ namespaces = NewHash();
+ Hash *global_namespace = createNamespaceEntry("exports", 0);
+
+ Setattr(namespaces, "::", global_namespace);
+ current_namespace = global_namespace;
+
+ f_wrappers = NewString("");
+
+ return SWIG_OK;
+}
+
+/* ---------------------------------------------------------------------
+ * skipIgnoredArgs()
+ * --------------------------------------------------------------------- */
+
+Parm *JSEmitter::skipIgnoredArgs(Parm *p) {
+ while (checkAttribute(p, "tmap:in:numinputs", "0")) {
+ p = Getattr(p, "tmap:in:next");
+ }
+ return p;
+}
+
+/* -----------------------------------------------------------------------------
+ * JSEmitter::getBaseClass() : the node of the base class or NULL
+ *
+ * Note: the first base class is provided. Multiple inheritance is not
+ * supported.
+ * ----------------------------------------------------------------------------- */
+
+Node *JSEmitter::getBaseClass(Node *n) {
+ // retrieve the first base class that is not %ignored
+ List *baselist = Getattr(n, "bases");
+ if (baselist) {
+ Iterator base = First(baselist);
+ while (base.item && GetFlag(base.item, "feature:ignore")) {
+ base = Next(base);
+ }
+ return base.item;
+ }
+ return NULL;
+}
+
+ /* -----------------------------------------------------------------------------
+ * JSEmitter::emitWrapperFunction() : dispatches emitter functions.
+ *
+ * This allows to have small sized, dedicated emitting functions.
+ * All state dependent branching is done here.
+ * ----------------------------------------------------------------------------- */
+
+int JSEmitter::emitWrapperFunction(Node *n) {
+ int ret = SWIG_OK;
+
+ String *kind = Getattr(n, "kind");
+
+ if (kind) {
+
+ if (Equal(kind, "function")
+ // HACK: sneaky.ctest revealed that typedef'd (global) functions must be
+ // detected via the 'view' attribute.
+ || (Equal(kind, "variable") && Equal(Getattr(n, "view"), "globalfunctionHandler"))
+ ) {
+ bool is_member = GetFlag(n, "ismember") != 0 || GetFlag(n, "feature:extend") != 0;
+ bool is_static = GetFlag(state.function(), IS_STATIC) != 0;
+ ret = emitFunction(n, is_member, is_static);
+ } else if (Cmp(kind, "variable") == 0) {
+ bool is_static = GetFlag(state.variable(), IS_STATIC) != 0;
+ // HACK: smartpointeraccessed static variables are not treated as statics
+ if (GetFlag(n, "allocate:smartpointeraccess")) {
+ is_static = false;
+ }
+
+ bool is_member = GetFlag(n, "ismember") != 0;
+ bool is_setter = GetFlag(n, "memberset") != 0 || GetFlag(n, "varset") != 0;
+ bool is_getter = GetFlag(n, "memberget") != 0 || GetFlag(n, "varget") != 0;
+ if (is_setter) {
+ ret = emitSetter(n, is_member, is_static);
+ } else if (is_getter) {
+ ret = emitGetter(n, is_member, is_static);
+ } else {
+ Swig_print_node(n);
+ }
+
+ } else {
+ Printf(stderr, "Warning: unsupported wrapper function type\n");
+ Swig_print_node(n);
+ ret = SWIG_ERROR;
+ }
+ } else {
+ String *view = Getattr(n, "view");
+
+ if (Cmp(view, "constructorHandler") == 0) {
+ ret = emitCtor(n);
+ } else if (Cmp(view, "destructorHandler") == 0) {
+ ret = emitDtor(n);
+ } else {
+ Printf(stderr, "Warning: unsupported wrapper function type");
+ Swig_print_node(n);
+ ret = SWIG_ERROR;
+ }
+ }
+
+ return ret;
+}
+
+int JSEmitter::enterClass(Node *n) {
+ state.clazz(RESET);
+ state.clazz(NAME, Getattr(n, "sym:name"));
+ state.clazz("nspace", current_namespace);
+
+ // Creating a mangled name using the current namespace and the symbol name
+ String *mangled_name = NewString("");
+ Printf(mangled_name, "%s_%s", Getattr(current_namespace, NAME_MANGLED), Getattr(n, "sym:name"));
+ state.clazz(NAME_MANGLED, SwigType_manglestr(mangled_name));
+ Delete(mangled_name);
+
+ state.clazz(TYPE, NewString(Getattr(n, "classtype")));
+
+ String *type = SwigType_manglestr(Getattr(n, "classtypeobj"));
+ String *classtype_mangled = NewString("");
+ Printf(classtype_mangled, "p%s", type);
+ state.clazz(TYPE_MANGLED, classtype_mangled);
+ Delete(type);
+
+ String *ctor_wrapper = NewString("_wrap_new_veto_");
+ Append(ctor_wrapper, state.clazz(NAME));
+ state.clazz(CTOR, ctor_wrapper);
+ state.clazz(CTOR_DISPATCHERS, NewString(""));
+ state.clazz(DTOR, NewString("0"));
+
+ // HACK: assume that a class is abstract
+ // this is resolved by emitCtor (which is only called for non abstract classes)
+ SetFlag(state.clazz(), IS_ABSTRACT);
+
+ return SWIG_OK;
+}
+
+int JSEmitter::enterFunction(Node *n) {
+ state.function(RESET);
+ state.function(NAME, Getattr(n, "sym:name"));
+ if (Equal(Getattr(n, "storage"), "static")) {
+ SetFlag(state.function(), IS_STATIC);
+ }
+ return SWIG_OK;
+}
+
+int JSEmitter::enterVariable(Node *n) {
+ // reset the state information for variables.
+ state.variable(RESET);
+
+ // Retrieve a pure symbol name. Using 'sym:name' as a basis, as it considers %renamings.
+ if (Equal(Getattr(n, "view"), "memberconstantHandler")) {
+ // Note: this is kind of hacky/experimental
+ // For constants/enums 'sym:name' contains e.g., 'Foo_Hello' instead of 'Hello'
+ state.variable(NAME, Getattr(n, "memberconstantHandler:sym:name"));
+ } else {
+ state.variable(NAME, Swig_scopename_last(Getattr(n, "sym:name")));
+ }
+
+ if (Equal(Getattr(n, "storage"), "static")) {
+ SetFlag(state.variable(), IS_STATIC);
+ }
+
+ if (!Language::instance()->is_assignable(n)) {
+ SetFlag(state.variable(), IS_IMMUTABLE);
+ }
+ // FIXME: test "arrays_global" does not compile with that as it is not allowed to assign to char[]
+ if (Equal(Getattr(n, "type"), "a().char")) {
+ SetFlag(state.variable(), IS_IMMUTABLE);
+ }
+
+ return SWIG_OK;
+}
+
+int JSEmitter::emitCtor(Node *n) {
+
+ Wrapper *wrapper = NewWrapper();
+
+ bool is_overloaded = GetFlag(n, "sym:overloaded") != 0;
+
+ Template t_ctor(getTemplate("js_ctor"));
+
+ String *wrap_name = Swig_name_wrapper(Getattr(n, "sym:name"));
+ if (is_overloaded) {
+ t_ctor = getTemplate("js_overloaded_ctor");
+ Append(wrap_name, Getattr(n, "sym:overname"));
+ }
+ Setattr(n, "wrap:name", wrap_name);
+ // note: we can remove the is_abstract flag now, as this
+ // is called for non-abstract classes only.
+ Setattr(state.clazz(), IS_ABSTRACT, 0);
+
+ ParmList *params = Getattr(n, "parms");
+ emit_parameter_variables(params, wrapper);
+ emit_attach_parmmaps(params, wrapper);
+ // HACK: in test-case `ignore_parameter` emit_attach_parmmaps generated an extra line of applied typemaps.
+ // Deleting wrapper->code here, to reset, and as it seemed to have no side effect elsewhere
+ Delete(wrapper->code);
+ wrapper->code = NewString("");
+
+ Printf(wrapper->locals, "%sresult;", SwigType_str(Getattr(n, "type"), 0));
+
+ marshalInputArgs(n, params, wrapper, Ctor, true, false);
+ String *action = emit_action(n);
+ Printv(wrapper->code, action, "\n", 0);
+
+ emitCleanupCode(n, wrapper, params);
+
+ t_ctor.replace("$jswrapper", wrap_name)
+ .replace("$jsmangledtype", state.clazz(TYPE_MANGLED))
+ .replace("$jslocals", wrapper->locals)
+ .replace("$jscode", wrapper->code)
+ .replace("$jsargcount", Getattr(n, ARGCOUNT))
+ .pretty_print(f_wrappers);
+
+ Template t_ctor_case(getTemplate("js_ctor_dispatch_case"));
+ t_ctor_case.replace("$jswrapper", wrap_name)
+ .replace("$jsargcount", Getattr(n, ARGCOUNT));
+ Append(state.clazz(CTOR_DISPATCHERS), t_ctor_case.str());
+
+ DelWrapper(wrapper);
+
+ // create a dispatching ctor
+ if (is_overloaded) {
+ if (!Getattr(n, "sym:nextSibling")) {
+ String *wrap_name = Swig_name_wrapper(Getattr(n, "sym:name"));
+ Template t_mainctor(getTemplate("js_ctor_dispatcher"));
+ t_mainctor.replace("$jswrapper", wrap_name)
+ .replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .replace("$jsdispatchcases", state.clazz(CTOR_DISPATCHERS))
+ .pretty_print(f_wrappers);
+ state.clazz(CTOR, wrap_name);
+ }
+ } else {
+ state.clazz(CTOR, wrap_name);
+ }
+
+ return SWIG_OK;
+}
+
+int JSEmitter::emitDtor(Node *n) {
+
+ String *wrap_name = Swig_name_wrapper(Getattr(n, "sym:name"));
+
+ SwigType *type = state.clazz(TYPE);
+ String *p_classtype = SwigType_add_pointer(state.clazz(TYPE));
+ String *ctype = SwigType_lstr(p_classtype, "");
+ String *free = NewString("");
+
+ // (Taken from JSCore implementation.)
+ /* The if (Extend) block was taken from the Ruby implementation.
+ * The problem is that in the case of an %extend to create a destructor for a struct to coordinate automatic memory cleanup with the Javascript collector,
+ * the SWIG function was not being generated. More specifically:
+ struct MyData {
+ %extend {
+ ~MyData() {
+ FreeData($self);
+ }
+ }
+ };
+ %newobject CreateData;
+ struct MyData* CreateData(void);
+ %delobject FreeData;
+ void FreeData(struct MyData* the_data);
+
+ where the use case is something like:
+ var my_data = example.CreateData();
+ my_data = null;
+
+ This function was not being generated:
+ SWIGINTERN void delete_MyData(struct MyData *self){
+ FreeData(self);
+ }
+
+ I don't understand fully why it wasn't being generated. It just seems to happen in the Lua generator.
+ There is a comment about staticmemberfunctionHandler having an inconsistency and I tracked down dome of the SWIGINTERN void delete_*
+ code to that function in the Language base class.
+ The Ruby implementation seems to have an explicit check for if(Extend) and explicitly generates the code, so that's what I'm doing here.
+ The Ruby implementation does other stuff which I omit.
+ */
+ if (Extend) {
+ String *wrap = Getattr(n, "wrap:code");
+ if (wrap) {
+ Printv(f_wrappers, wrap, NIL);
+ }
+ }
+ // HACK: this is only for the v8 emitter. maybe set an attribute wrap:action of node
+ // TODO: generate dtors more similar to other wrappers
+ // EW: I think this is wrong. delete should only be used when new was used to create. If malloc was used, free needs to be used.
+ if (SwigType_isarray(type)) {
+ Printf(free, "delete [] (%s)", ctype);
+ } else {
+ Printf(free, "delete (%s)", ctype);
+ }
+
+ String *destructor_action = Getattr(n, "wrap:action");
+ // Adapted from the JSCore implementation.
+ /* The next challenge is to generate the correct finalize function for JavaScriptCore to call.
+ Originally, it would use this fragment from javascriptcode.swg
+ %fragment ("JS_destructordefn", "templates")
+ %{
+ void _wrap_${classname_mangled}_finalize(JSObjectRef thisObject)
+ {
+ SWIG_PRV_DATA* t = (SWIG_PRV_DATA*)JSObjectGetPrivate(thisObject);
+ if(t && t->swigCMemOwn) free ((${type}*)t->swigCObject);
+ if(t) free(t);
+ }
+ %}
+
+ But for the above example case of %extend to define a destructor on a struct, we need to override the system to not call
+ free ((${type}*)t->swigCObject);
+ and substitute it with what the user has provided.
+ To solve this, I created a variation fragment called JS_destructoroverridedefn:
+ SWIG_PRV_DATA* t = (SWIG_PRV_DATA*)JSObjectGetPrivate(thisObject);
+ if(t && t->swigCMemOwn) {
+ ${type}* arg1 = (${type}*)t->swigCObject;
+ ${destructor_action}
+ }
+ if(t) free(t);
+
+ Based on what I saw in the Lua and Ruby modules, I use Getattr(n, "wrap:action")
+ to decide if the user has a preferred destructor action.
+ Based on that, I decide which fragment to use.
+ And in the case of the custom action, I substitute that action in.
+ I noticed that destructor_action has the form
+ delete_MyData(arg1);
+ The explicit arg1 is a little funny, so I structured the fragment to create a temporary variable called arg1 to make the generation easier.
+ This might suggest this solution misunderstands a more complex case.
+
+ Also, there is a problem where destructor_action is always true for me, even when not requesting %extend as above.
+ So this code doesn't actually quite work as I expect. The end result is that the code still works because
+ destructor_action calls free like the original template. The one caveat is the string in destructor_action casts to char* which is wierd.
+ I think there is a deeper underlying SWIG issue because I don't think it should be char*. However, it doesn't really matter for free.
+
+ Maybe the fix for the destructor_action always true problem is that this is supposed to be embedded in the if(Extend) block above.
+ But I don't fully understand the conditions of any of these things, and since it works for the moment, I don't want to break more stuff.
+ */
+ if (destructor_action) {
+ Template t_dtor = getTemplate("js_dtoroverride");
+ state.clazz(DTOR, wrap_name);
+ t_dtor.replace("${classname_mangled}", state.clazz(NAME_MANGLED))
+ .replace("$jswrapper", wrap_name)
+ .replace("$jsfree", free)
+ .replace("$jstype", ctype);
+
+ t_dtor.replace("${destructor_action}", destructor_action);
+ Wrapper_pretty_print(t_dtor.str(), f_wrappers);
+ } else {
+ Template t_dtor = getTemplate("js_dtor");
+ state.clazz(DTOR, wrap_name);
+ t_dtor.replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .replace("$jswrapper", wrap_name)
+ .replace("$jsfree", free)
+ .replace("$jstype", ctype)
+ .pretty_print(f_wrappers);
+ }
+
+ Delete(p_classtype);
+ Delete(ctype);
+ Delete(free);
+
+ return SWIG_OK;
+}
+
+int JSEmitter::emitGetter(Node *n, bool is_member, bool is_static) {
+ Wrapper *wrapper = NewWrapper();
+ Template t_getter(getTemplate("js_getter"));
+
+ // prepare wrapper name
+ String *wrap_name = Swig_name_wrapper(Getattr(n, "sym:name"));
+ Setattr(n, "wrap:name", wrap_name);
+ state.variable(GETTER, wrap_name);
+
+ // prepare local variables
+ ParmList *params = Getattr(n, "parms");
+ emit_parameter_variables(params, wrapper);
+ emit_attach_parmmaps(params, wrapper);
+
+ // prepare code part
+ String *action = emit_action(n);
+ marshalInputArgs(n, params, wrapper, Getter, is_member, is_static);
+ marshalOutput(n, params, wrapper, action);
+
+ emitCleanupCode(n, wrapper, params);
+
+ t_getter.replace("$jswrapper", wrap_name)
+ .replace("$jslocals", wrapper->locals)
+ .replace("$jscode", wrapper->code)
+ .pretty_print(f_wrappers);
+
+ DelWrapper(wrapper);
+
+ return SWIG_OK;
+}
+
+int JSEmitter::emitSetter(Node *n, bool is_member, bool is_static) {
+
+ // skip variables that are immutable
+ if (State::IsSet(state.variable(IS_IMMUTABLE))) {
+ return SWIG_OK;
+ }
+
+ Wrapper *wrapper = NewWrapper();
+
+ Template t_setter(getTemplate("js_setter"));
+
+ // prepare wrapper name
+ String *wrap_name = Swig_name_wrapper(Getattr(n, "sym:name"));
+ Setattr(n, "wrap:name", wrap_name);
+ state.variable(SETTER, wrap_name);
+
+ // prepare local variables
+ ParmList *params = Getattr(n, "parms");
+ emit_parameter_variables(params, wrapper);
+ emit_attach_parmmaps(params, wrapper);
+
+ // prepare code part
+ String *action = emit_action(n);
+ marshalInputArgs(n, params, wrapper, Setter, is_member, is_static);
+ Append(wrapper->code, action);
+
+ emitCleanupCode(n, wrapper, params);
+
+ t_setter.replace("$jswrapper", wrap_name)
+ .replace("$jslocals", wrapper->locals)
+ .replace("$jscode", wrapper->code)
+ .pretty_print(f_wrappers);
+
+ DelWrapper(wrapper);
+
+ return SWIG_OK;
+}
+
+/* -----------------------------------------------------------------------------
+ * JSEmitter::emitConstant() : triggers code generation for constants
+ * ----------------------------------------------------------------------------- */
+
+int JSEmitter::emitConstant(Node *n) {
+ // HACK: somehow it happened under Mac OS X that before everything started
+ // a lot of SWIG internal constants were emitted
+ // This didn't happen on other platforms yet...
+ // we ignore those premature definitions
+ if (!State::IsSet(state.globals(HAS_TEMPLATES))) {
+ return SWIG_ERROR;
+ }
+
+ Wrapper *wrapper = NewWrapper();
+ SwigType *type = Getattr(n, "type");
+ String *name = Getattr(n, "name");
+ String *iname = Getattr(n, "sym:name");
+ String *wname = Swig_name_wrapper(name);
+ String *rawval = Getattr(n, "rawval");
+ String *value = rawval ? rawval : Getattr(n, "value");
+
+ // HACK: forcing usage of cppvalue for v8 (which turned out to fix typdef_struct.i, et. al)
+ if (State::IsSet(state.globals(FORCE_CPP)) && Getattr(n, "cppvalue") != NULL) {
+ value = Getattr(n, "cppvalue");
+ }
+
+ Template t_getter(getTemplate("js_getter"));
+
+ // call the variable methods as a constants are
+ // registred in same way
+ enterVariable(n);
+ state.variable(GETTER, wname);
+ // TODO: why do we need this?
+ Setattr(n, "wrap:name", wname);
+
+ // special treatment of member pointers
+ if (SwigType_type(type) == T_MPOINTER) {
+ // TODO: this could go into a code-template
+ String *mpointer_wname = NewString("");
+ Printf(mpointer_wname, "_wrapConstant_%s", iname);
+ Setattr(n, "memberpointer:constant:wrap:name", mpointer_wname);
+ String *str = SwigType_str(type, mpointer_wname);
+ Printf(f_wrappers, "static %s = %s;\n", str, value);
+ Delete(str);
+ value = mpointer_wname;
+ }
+
+ marshalOutput(n, 0, wrapper, NewString(""), value, false);
+
+ t_getter.replace("$jswrapper", wname)
+ .replace("$jslocals", wrapper->locals)
+ .replace("$jscode", wrapper->code)
+ .pretty_print(f_wrappers);
+
+ exitVariable(n);
+
+ DelWrapper(wrapper);
+
+ return SWIG_OK;
+}
+
+int JSEmitter::emitFunction(Node *n, bool is_member, bool is_static) {
+ Wrapper *wrapper = NewWrapper();
+ Template t_function(getTemplate("js_function"));
+
+ bool is_overloaded = GetFlag(n, "sym:overloaded") != 0;
+
+ // prepare the function wrapper name
+ String *iname = Getattr(n, "sym:name");
+ String *wrap_name = Swig_name_wrapper(iname);
+ if (is_overloaded) {
+ t_function = getTemplate("js_overloaded_function");
+ Append(wrap_name, Getattr(n, "sym:overname"));
+ }
+ Setattr(n, "wrap:name", wrap_name);
+ state.function(WRAPPER_NAME, wrap_name);
+
+ // prepare local variables
+ ParmList *params = Getattr(n, "parms");
+ emit_parameter_variables(params, wrapper);
+ emit_attach_parmmaps(params, wrapper);
+
+ // HACK: in test-case `ignore_parameter` emit_attach_parmmaps generates an extra line of applied typemap.
+ // Deleting wrapper->code here fixes the problem, and seems to have no side effect elsewhere
+ Delete(wrapper->code);
+ wrapper->code = NewString("");
+
+ marshalInputArgs(n, params, wrapper, Function, is_member, is_static);
+ String *action = emit_action(n);
+ marshalOutput(n, params, wrapper, action);
+ emitCleanupCode(n, wrapper, params);
+ Replaceall(wrapper->code, "$symname", iname);
+
+ t_function.replace("$jswrapper", wrap_name)
+ .replace("$jslocals", wrapper->locals)
+ .replace("$jscode", wrapper->code)
+ .replace("$jsargcount", Getattr(n, ARGCOUNT))
+ .pretty_print(f_wrappers);
+
+
+ DelWrapper(wrapper);
+
+ return SWIG_OK;
+}
+
+int JSEmitter::emitFunctionDispatcher(Node *n, bool /*is_member */ ) {
+ Wrapper *wrapper = NewWrapper();
+
+ // Generate call list, go to first node
+ Node *sibl = n;
+
+ while (Getattr(sibl, "sym:previousSibling"))
+ sibl = Getattr(sibl, "sym:previousSibling"); // go all the way up
+
+ do {
+ String *siblname = Getattr(sibl, "wrap:name");
+
+ if (siblname) {
+ // handle function overloading
+ Template t_dispatch_case = getTemplate("js_function_dispatch_case");
+ t_dispatch_case.replace("$jswrapper", siblname)
+ .replace("$jsargcount", Getattr(sibl, ARGCOUNT));
+
+ Append(wrapper->code, t_dispatch_case.str());
+ }
+
+ } while ((sibl = Getattr(sibl, "sym:nextSibling")));
+
+ Template t_function(getTemplate("js_function_dispatcher"));
+
+ // Note: this dispatcher function gets called after the last overloaded function has been created.
+ // At this time, n.wrap:name contains the name of the last wrapper function.
+ // To get a valid function name for the dispatcher function we take the last wrapper name and
+ // substract the extension "sym:overname",
+ String *wrap_name = NewString(Getattr(n, "wrap:name"));
+ String *overname = Getattr(n, "sym:overname");
+
+ Node *methodclass = Swig_methodclass(n);
+ String *class_name = Getattr(methodclass, "sym:name");
+
+ int l1 = Len(wrap_name);
+ int l2 = Len(overname);
+ Delslice(wrap_name, l1 - l2, l1);
+
+ String *new_string = NewStringf("%s_%s", class_name, wrap_name);
+ String *final_wrap_name = Swig_name_wrapper(new_string);
+
+ Setattr(n, "wrap:name", final_wrap_name);
+ state.function(WRAPPER_NAME, final_wrap_name);
+
+
+
+ t_function.replace("$jslocals", wrapper->locals)
+ .replace("$jscode", wrapper->code);
+
+ // call this here, to replace all variables
+ t_function.replace("$jswrapper", final_wrap_name)
+ .replace("$jsname", state.function(NAME))
+ .pretty_print(f_wrappers);
+
+ // Delete the state variable
+ DelWrapper(wrapper);
+
+ return SWIG_OK;
+}
+
+String *JSEmitter::emitInputTypemap(Node *n, Parm *p, Wrapper *wrapper, String *arg) {
+ // Get input typemap for current param
+ String *tm = Getattr(p, "tmap:in");
+ SwigType *type = Getattr(p, "type");
+
+ if (tm != NULL) {
+ Replaceall(tm, "$input", arg);
+ Setattr(p, "emit:input", arg);
+ // do replacements for built-in variables
+ if (Getattr(p, "wrap:disown") || (Getattr(p, "tmap:in:disown"))) {
+ Replaceall(tm, "$disown", "SWIG_POINTER_DISOWN");
+ } else {
+ Replaceall(tm, "$disown", "0");
+ }
+ Replaceall(tm, "$symname", Getattr(n, "sym:name"));
+ Printf(wrapper->code, "%s\n", tm);
+ } else {
+ Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument.\n", SwigType_str(type, 0));
+ }
+
+ return tm;
+}
+
+void JSEmitter::marshalOutput(Node *n, ParmList *params, Wrapper *wrapper, String *actioncode, const String *cresult, bool emitReturnVariable) {
+ SwigType *type = Getattr(n, "type");
+ String *tm;
+ Parm *p;
+
+ // adds a declaration for the result variable
+ if (emitReturnVariable)
+ emit_return_variable(n, type, wrapper);
+ // if not given, use default result identifier ('result') for output typemap
+ if (cresult == 0)
+ cresult = defaultResultName;
+
+ tm = Swig_typemap_lookup_out("out", n, cresult, wrapper, actioncode);
+ bool should_own = GetFlag(n, "feature:new") != 0;
+
+ if (tm) {
+ Replaceall(tm, "$objecttype", Swig_scopename_last(SwigType_str(SwigType_strip_qualifiers(type), 0)));
+
+ if (should_own) {
+ Replaceall(tm, "$owner", "SWIG_POINTER_OWN");
+ } else {
+ Replaceall(tm, "$owner", "0");
+ }
+ Append(wrapper->code, tm);
+
+ if (Len(tm) > 0) {
+ Printf(wrapper->code, "\n");
+ }
+ } else {
+ Swig_warning(WARN_TYPEMAP_OUT_UNDEF, input_file, line_number, "Unable to use return type %s in function %s.\n", SwigType_str(type, 0), Getattr(n, "name"));
+ }
+
+ if (params) {
+ for (p = params; p;) {
+ if ((tm = Getattr(p, "tmap:argout"))) {
+ Replaceall(tm, "$input", Getattr(p, "emit:input"));
+ Printv(wrapper->code, tm, "\n", NIL);
+ p = Getattr(p, "tmap:argout:next");
+ } else {
+ p = nextSibling(p);
+ }
+ }
+ }
+
+ Replaceall(wrapper->code, "$result", "jsresult");
+}
+
+void JSEmitter::emitCleanupCode(Node *n, Wrapper *wrapper, ParmList *params) {
+ Parm *p;
+ String *tm;
+
+ for (p = params; p;) {
+ if ((tm = Getattr(p, "tmap:freearg"))) {
+ //addThrows(n, "tmap:freearg", p);
+ Replaceall(tm, "$input", Getattr(p, "emit:input"));
+ Printv(wrapper->code, tm, "\n", NIL);
+ p = Getattr(p, "tmap:freearg:next");
+ } else {
+ p = nextSibling(p);
+ }
+ }
+
+ if (GetFlag(n, "feature:new")) {
+ tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0);
+ if (tm != NIL) {
+ //addThrows(throws_hash, "newfree", n);
+ Printv(wrapper->code, tm, "\n", NIL);
+ }
+ }
+
+}
+
+int JSEmitter::switchNamespace(Node *n) {
+ // HACK: somehow this gets called for member functions.
+ // We can safely ignore them, as members are not associated to a namespace (only their class)
+ if (GetFlag(n, "ismember")) {
+ return SWIG_OK;
+ }
+
+ // if nspace is deactivated, everything goes into the global scope
+ if (!GetFlag(n, "feature:nspace")) {
+ current_namespace = Getattr(namespaces, "::");
+ return SWIG_OK;
+ }
+
+// EXPERIMENTAL: we want to use Language::getNSpace() here
+// However, it is not working yet.
+// For namespace functions Language::getNSpace() does not give a valid result
+#if 0
+ JAVASCRIPT *lang = static_cast<JAVASCRIPT*>(Language::instance());
+ String *_nspace = lang->getNSpace();
+ if (!Equal(nspace, _nspace)) {
+ Printf(stdout, "##### Custom vs Language::getNSpace(): %s | %s\n", nspace, _nspace);
+ Swig_print_node(n);
+ }
+#endif
+
+ String *nspace = Getattr(n, "sym:nspace");
+
+ if (nspace == NULL) {
+ // It seems that only classes have 'sym:nspace' set.
+ // We try to get the namespace from the qualified name (i.e., everything before the last '::')
+ nspace = Swig_scopename_prefix(Getattr(n, "name"));
+ }
+
+ // If there is not even a scopename prefix then it must be global scope
+ if (nspace == NULL) {
+ current_namespace = Getattr(namespaces, "::");
+ return SWIG_OK;
+ }
+
+ String *scope = NewString(nspace);
+ // replace "." with "::" that we can use Swig_scopename_last
+ Replaceall(scope, ".", "::");
+
+ // if the scope is not yet registered
+ // create (parent) namespaces recursively
+ if (!Getattr(namespaces, scope)) {
+ createNamespace(scope);
+ }
+ current_namespace = Getattr(namespaces, scope);
+
+ return SWIG_OK;
+}
+
+int JSEmitter::createNamespace(String *scope) {
+
+ String *parent_scope = Swig_scopename_prefix(scope);
+ Hash *parent_namespace;
+ if (parent_scope == 0) {
+ parent_namespace = Getattr(namespaces, "::");
+ } else if (!Getattr(namespaces, parent_scope)) {
+ createNamespace(parent_scope);
+ parent_namespace = Getattr(namespaces, parent_scope);
+ } else {
+ parent_namespace = Getattr(namespaces, parent_scope);
+ }
+ assert(parent_namespace != 0);
+
+ Hash *new_namespace = createNamespaceEntry(Char(scope), Char(Getattr(parent_namespace, "name")));
+ Setattr(namespaces, scope, new_namespace);
+
+ Delete(parent_scope);
+ return SWIG_OK;
+}
+
+Hash *JSEmitter::createNamespaceEntry(const char *_name, const char *parent) {
+ Hash *entry = NewHash();
+ String *name = NewString(_name);
+ Setattr(entry, NAME, Swig_scopename_last(name));
+ Setattr(entry, NAME_MANGLED, Swig_name_mangle(name));
+ Setattr(entry, PARENT, NewString(parent));
+
+ Delete(name);
+ return entry;
+}
+
+/**********************************************************************
+ * JavascriptCore: JSEmitter implementation for JavascriptCore engine
+ **********************************************************************/
+
+class JSCEmitter:public JSEmitter {
+
+public:
+ JSCEmitter();
+ virtual ~ JSCEmitter();
+ virtual int initialize(Node *n);
+ virtual int dump(Node *n);
+ virtual int close();
+
+protected:
+ virtual int enterVariable(Node *n);
+ virtual int exitVariable(Node *n);
+ virtual int enterFunction(Node *n);
+ virtual int exitFunction(Node *n);
+ virtual int enterClass(Node *n);
+ virtual int exitClass(Node *n);
+ virtual void marshalInputArgs(Node *n, ParmList *parms, Wrapper *wrapper, MarshallingMode mode, bool is_member, bool is_static);
+ virtual Hash *createNamespaceEntry(const char *name, const char *parent);
+ virtual int emitNamespaces();
+
+private:
+
+ String *NULL_STR;
+ String *VETO_SET;
+
+ // output file and major code parts
+ File *f_wrap_cpp;
+ File *f_runtime;
+ File *f_header;
+ File *f_init;
+
+};
+
+JSCEmitter::JSCEmitter()
+: JSEmitter(JSEmitter::JavascriptCore), NULL_STR(NewString("NULL")), VETO_SET(NewString("JS_veto_set_variable")), f_wrap_cpp(NULL), f_runtime(NULL), f_header(NULL), f_init(NULL) {
+}
+
+JSCEmitter::~JSCEmitter() {
+ Delete(NULL_STR);
+ Delete(VETO_SET);
+}
+
+
+/* ---------------------------------------------------------------------
+ * marshalInputArgs()
+ *
+ * Process all of the arguments passed into the argv array
+ * and convert them into C/C++ function arguments using the
+ * supplied typemaps.
+ * --------------------------------------------------------------------- */
+
+void JSCEmitter::marshalInputArgs(Node *n, ParmList *parms, Wrapper *wrapper, MarshallingMode mode, bool is_member, bool is_static) {
+ Parm *p;
+ String *tm;
+
+ // determine an offset index, as members have an extra 'this' argument
+ // except: static members and ctors.
+ int startIdx = 0;
+ if (is_member && !is_static && mode != Ctor) {
+ startIdx = 1;
+ }
+ // store number of arguments for argument checks
+ int num_args = emit_num_arguments(parms) - startIdx;
+ String *argcount = NewString("");
+ Printf(argcount, "%d", num_args);
+ Setattr(n, ARGCOUNT, argcount);
+
+ // process arguments
+ int i = 0;
+ for (p = parms; p; i++) {
+ String *arg = NewString("");
+ String *type = Getattr(p, "type");
+
+ // ignore varargs
+ if (SwigType_isvarargs(type))
+ break;
+
+ switch (mode) {
+ case Getter:
+ case Function:
+ if (is_member && !is_static && i == 0) {
+ Printv(arg, "thisObject", 0);
+ } else {
+ Printf(arg, "argv[%d]", i - startIdx);
+ }
+ break;
+ case Setter:
+ if (is_member && !is_static && i == 0) {
+ Printv(arg, "thisObject", 0);
+ } else {
+ Printv(arg, "value", 0);
+ }
+ break;
+ case Ctor:
+ Printf(arg, "argv[%d]", i);
+ break;
+ default:
+ throw "Illegal state.";
+ }
+ tm = emitInputTypemap(n, p, wrapper, arg);
+ Delete(arg);
+ if (tm) {
+ p = Getattr(p, "tmap:in:next");
+ } else {
+ p = nextSibling(p);
+ }
+ }
+}
+
+int JSCEmitter::initialize(Node *n) {
+
+ JSEmitter::initialize(n);
+
+ /* Get the output file name */
+ String *outfile = Getattr(n, "outfile");
+
+ /* Initialize I/O */
+ f_wrap_cpp = NewFile(outfile, "w", SWIG_output_files());
+ if (!f_wrap_cpp) {
+ FileErrorDisplay(outfile);
+ SWIG_exit(EXIT_FAILURE);
+ }
+
+ /* Initialization of members */
+ f_runtime = NewString("");
+ f_init = NewString("");
+ f_header = NewString("");
+
+ state.globals(CREATE_NAMESPACES, NewString(""));
+ state.globals(REGISTER_NAMESPACES, NewString(""));
+ state.globals(INITIALIZER, NewString(""));
+
+ /* Register file targets with the SWIG file handler */
+ Swig_register_filebyname("begin", f_wrap_cpp);
+ Swig_register_filebyname("header", f_header);
+ Swig_register_filebyname("wrapper", f_wrappers);
+ Swig_register_filebyname("runtime", f_runtime);
+ Swig_register_filebyname("init", f_init);
+
+ Swig_banner(f_wrap_cpp);
+
+ return SWIG_OK;
+}
+
+int JSCEmitter::dump(Node *n) {
+ /* Get the module name */
+ String *module = Getattr(n, "name");
+
+ Template initializer_define(getTemplate("js_initializer_define"));
+ initializer_define.replace("$jsname", module).pretty_print(f_header);
+
+ SwigType_emit_type_table(f_runtime, f_wrappers);
+
+ Printv(f_wrap_cpp, f_runtime, "\n", 0);
+ Printv(f_wrap_cpp, f_header, "\n", 0);
+ Printv(f_wrap_cpp, f_wrappers, "\n", 0);
+
+ emitNamespaces();
+
+ // compose the initializer function using a template
+ Template initializer(getTemplate("js_initializer"));
+ initializer.replace("$jsname", module)
+ .replace("$jsregisterclasses", state.globals(INITIALIZER))
+ .replace("$jscreatenamespaces", state.globals(CREATE_NAMESPACES))
+ .replace("$jsregisternamespaces", state.globals(REGISTER_NAMESPACES))
+ .pretty_print(f_init);
+
+ Printv(f_wrap_cpp, f_init, 0);
+
+ return SWIG_OK;
+}
+
+int JSCEmitter::close() {
+ Delete(f_runtime);
+ Delete(f_header);
+ Delete(f_wrappers);
+ Delete(f_init);
+ Delete(namespaces);
+ Delete(f_wrap_cpp);
+ return SWIG_OK;
+}
+
+int JSCEmitter::enterFunction(Node *n) {
+
+ JSEmitter::enterFunction(n);
+
+ return SWIG_OK;
+}
+
+int JSCEmitter::exitFunction(Node *n) {
+ Template t_function = getTemplate("jsc_function_declaration");
+
+ bool is_member = GetFlag(n, "ismember") != 0 || GetFlag(n, "feature:extend") != 0;
+ bool is_overloaded = GetFlag(n, "sym:overloaded") != 0;
+
+ // handle overloaded functions
+ if (is_overloaded) {
+ if (!Getattr(n, "sym:nextSibling")) {
+ //state.function(WRAPPER_NAME, Swig_name_wrapper(Getattr(n, "name")));
+ // create dispatcher
+ emitFunctionDispatcher(n, is_member);
+ } else {
+ //don't register wrappers of overloaded functions in function tables
+ return SWIG_OK;
+ }
+ }
+
+ t_function.replace("$jsname", state.function(NAME))
+ .replace("$jswrapper", state.function(WRAPPER_NAME));
+
+ if (is_member) {
+ if (GetFlag(state.function(), IS_STATIC)) {
+ t_function.pretty_print(state.clazz(STATIC_FUNCTIONS));
+ } else {
+ t_function.pretty_print(state.clazz(MEMBER_FUNCTIONS));
+ }
+ } else {
+ t_function.pretty_print(Getattr(current_namespace, "functions"));
+ }
+
+ return SWIG_OK;
+}
+
+int JSCEmitter::enterVariable(Node *n) {
+ JSEmitter::enterVariable(n);
+ state.variable(GETTER, NULL_STR);
+ state.variable(SETTER, VETO_SET);
+ return SWIG_OK;
+}
+
+int JSCEmitter::exitVariable(Node *n) {
+ Template t_variable(getTemplate("jsc_variable_declaration"));
+ t_variable.replace("$jsname", state.variable(NAME))
+ .replace("$jsgetter", state.variable(GETTER))
+ .replace("$jssetter", state.variable(SETTER));
+
+ if (GetFlag(n, "ismember")) {
+ if (GetFlag(state.variable(), IS_STATIC)
+ || Equal(Getattr(n, "nodeType"), "enumitem")) {
+ t_variable.pretty_print(state.clazz(STATIC_VARIABLES));
+ } else {
+ t_variable.pretty_print(state.clazz(MEMBER_VARIABLES));
+ }
+ } else {
+ t_variable.pretty_print(Getattr(current_namespace, "values"));
+ }
+
+ return SWIG_OK;
+}
+
+int JSCEmitter::enterClass(Node *n) {
+ JSEmitter::enterClass(n);
+ state.clazz(MEMBER_VARIABLES, NewString(""));
+ state.clazz(MEMBER_FUNCTIONS, NewString(""));
+ state.clazz(STATIC_VARIABLES, NewString(""));
+ state.clazz(STATIC_FUNCTIONS, NewString(""));
+
+ Template t_class_decl = getTemplate("jsc_class_declaration");
+ t_class_decl.replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .pretty_print(f_wrappers);
+
+ return SWIG_OK;
+}
+
+int JSCEmitter::exitClass(Node *n) {
+ Template t_class_tables(getTemplate("jsc_class_tables"));
+ t_class_tables.replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .replace("$jsclassvariables", state.clazz(MEMBER_VARIABLES))
+ .replace("$jsclassfunctions", state.clazz(MEMBER_FUNCTIONS))
+ .replace("$jsstaticclassfunctions", state.clazz(STATIC_FUNCTIONS))
+ .replace("$jsstaticclassvariables", state.clazz(STATIC_VARIABLES))
+ .pretty_print(f_wrappers);
+
+ /* adds the ctor wrappers at this position */
+ // Note: this is necessary to avoid extra forward declarations.
+ //Append(f_wrappers, state.clazz(CTOR_WRAPPERS));
+
+ // for abstract classes add a vetoing ctor
+ if (GetFlag(state.clazz(), IS_ABSTRACT)) {
+ Template t_veto_ctor(getTemplate("js_veto_ctor"));
+ t_veto_ctor.replace("$jswrapper", state.clazz(CTOR))
+ .replace("$jsname", state.clazz(NAME))
+ .pretty_print(f_wrappers);
+ }
+
+ /* adds a class template statement to initializer function */
+ Template t_classtemplate(getTemplate("jsc_class_definition"));
+
+ /* prepare registration of base class */
+ String *jsclass_inheritance = NewString("");
+ Node *base_class = getBaseClass(n);
+ if (base_class != NULL) {
+ Template t_inherit(getTemplate("jsc_class_inherit"));
+ t_inherit.replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .replace("$jsbaseclassmangled", SwigType_manglestr(Getattr(base_class, "name")))
+ .pretty_print(jsclass_inheritance);
+ } else {
+ Template t_inherit(getTemplate("jsc_class_noinherit"));
+ t_inherit.replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .pretty_print(jsclass_inheritance);
+ }
+
+ t_classtemplate.replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .replace("$jsmangledtype", state.clazz(TYPE_MANGLED))
+ .replace("$jsclass_inheritance", jsclass_inheritance)
+ .replace("$jsctor", state.clazz(CTOR))
+ .replace("$jsdtor", state.clazz(DTOR))
+ .pretty_print(state.globals(INITIALIZER));
+ Delete(jsclass_inheritance);
+
+ /* Note: this makes sure that there is a swig_type added for this class */
+ SwigType_remember_clientdata(state.clazz(TYPE_MANGLED), NewString("0"));
+
+ /* adds a class registration statement to initializer function */
+ Template t_registerclass(getTemplate("jsc_class_registration"));
+ t_registerclass.replace("$jsname", state.clazz(NAME))
+ .replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .replace("$jsnspace", Getattr(state.clazz("nspace"), NAME_MANGLED))
+ .pretty_print(state.globals(INITIALIZER));
+
+ return SWIG_OK;
+}
+
+Hash *JSCEmitter::createNamespaceEntry(const char *name, const char *parent) {
+ Hash *entry = JSEmitter::createNamespaceEntry(name, parent);
+ Setattr(entry, "functions", NewString(""));
+ Setattr(entry, "values", NewString(""));
+ return entry;
+}
+
+int JSCEmitter::emitNamespaces() {
+ Iterator it;
+ for (it = First(namespaces); it.item; it = Next(it)) {
+ Hash *entry = it.item;
+ String *name = Getattr(entry, NAME);
+ String *name_mangled = Getattr(entry, NAME_MANGLED);
+ String *parent = Getattr(entry, PARENT);
+ String *parent_mangled = Swig_name_mangle(parent);
+ String *functions = Getattr(entry, "functions");
+ String *variables = Getattr(entry, "values");
+
+ // skip the global namespace which is given by the application
+
+ Template namespace_definition(getTemplate("jsc_nspace_declaration"));
+ namespace_definition.replace("$jsglobalvariables", variables)
+ .replace("$jsglobalfunctions", functions)
+ .replace("$jsnspace", name_mangled)
+ .replace("$jsmangledname", name_mangled)
+ .pretty_print(f_wrap_cpp);
+
+ Template t_createNamespace(getTemplate("jsc_nspace_definition"));
+ t_createNamespace.replace("$jsmangledname", name_mangled);
+ Append(state.globals(CREATE_NAMESPACES), t_createNamespace.str());
+
+ // Don't register 'exports' as namespace. It is return to the application.
+ if (!Equal("exports", name)) {
+ Template t_registerNamespace(getTemplate("jsc_nspace_registration"));
+ t_registerNamespace.replace("$jsmangledname", name_mangled)
+ .replace("$jsname", name)
+ .replace("$jsparent", parent_mangled);
+ Append(state.globals(REGISTER_NAMESPACES), t_registerNamespace.str());
+ }
+ }
+
+ return SWIG_OK;
+}
+
+JSEmitter *swig_javascript_create_JSCEmitter() {
+ return new JSCEmitter();
+}
+
+/**********************************************************************
+ * V8: JSEmitter implementation for V8 engine
+ **********************************************************************/
+
+class V8Emitter:public JSEmitter {
+
+public:
+ V8Emitter();
+
+ virtual ~ V8Emitter();
+ virtual int initialize(Node *n);
+ virtual int dump(Node *n);
+ virtual int close();
+ virtual int enterClass(Node *n);
+ virtual int exitClass(Node *n);
+ virtual int enterVariable(Node *n);
+ virtual int exitVariable(Node *n);
+ virtual int exitFunction(Node *n);
+
+protected:
+ virtual void marshalInputArgs(Node *n, ParmList *parms, Wrapper *wrapper, MarshallingMode mode, bool is_member, bool is_static);
+ virtual int emitNamespaces();
+
+protected:
+ /* built-in parts */
+ String *f_runtime;
+ String *f_header;
+ String *f_init;
+ String *f_post_init;
+
+ /* part for class templates */
+ String *f_class_templates;
+
+ /* parts for initilizer */
+ String *f_init_namespaces;
+ String *f_init_class_templates;
+ String *f_init_wrappers;
+ String *f_init_inheritance;
+ String *f_init_class_instances;
+ String *f_init_static_wrappers;
+ String *f_init_register_classes;
+ String *f_init_register_namespaces;
+
+ // the output cpp file
+ File *f_wrap_cpp;
+
+ String *NULL_STR;
+ String *VETO_SET;
+ String *moduleName;
+
+};
+
+V8Emitter::V8Emitter()
+: JSEmitter(JSEmitter::V8), NULL_STR(NewString("0")), VETO_SET(NewString("JS_veto_set_variable")) {
+}
+
+V8Emitter::~V8Emitter() {
+ Delete(NULL_STR);
+ Delete(VETO_SET);
+}
+
+int V8Emitter::initialize(Node *n) {
+ JSEmitter::initialize(n);
+
+ moduleName = Getattr(n, "name");
+
+ // Get the output file name
+ String *outfile = Getattr(n, "outfile");
+ f_wrap_cpp = NewFile(outfile, "w", SWIG_output_files());
+ if (!f_wrap_cpp) {
+ FileErrorDisplay(outfile);
+ SWIG_exit(EXIT_FAILURE);
+ }
+
+ f_runtime = NewString("");
+ f_header = NewString("");
+ f_class_templates = NewString("");
+ f_init = NewString("");
+ f_post_init = NewString("");
+
+ f_init_namespaces = NewString("");
+ f_init_class_templates = NewString("");
+ f_init_wrappers = NewString("");
+ f_init_inheritance = NewString("");
+ f_init_class_instances = NewString("");
+ f_init_static_wrappers = NewString("");
+ f_init_register_classes = NewString("");
+ f_init_register_namespaces = NewString("");
+
+ // note: this is necessary for built-in generation of SWIG runtime code
+ Swig_register_filebyname("begin", f_wrap_cpp);
+ Swig_register_filebyname("runtime", f_runtime);
+ Swig_register_filebyname("header", f_header);
+ Swig_register_filebyname("wrapper", f_wrappers);
+ Swig_register_filebyname("init", f_init);
+ Swig_register_filebyname("post-init", f_post_init);
+
+ state.globals(FORCE_CPP, NewString("1"));
+
+ Swig_banner(f_wrap_cpp);
+
+ return SWIG_OK;
+}
+
+int V8Emitter::dump(Node *n) {
+ /* Get the module name */
+ String *module = Getattr(n, "name");
+
+ Template initializer_define(getTemplate("js_initializer_define"));
+ initializer_define.replace("$jsname", module).pretty_print(f_header);
+
+ SwigType_emit_type_table(f_runtime, f_wrappers);
+
+ Printv(f_wrap_cpp, f_runtime, "\n", 0);
+ Printv(f_wrap_cpp, f_header, "\n", 0);
+ Printv(f_wrap_cpp, f_class_templates, "\n", 0);
+ Printv(f_wrap_cpp, f_wrappers, "\n", 0);
+
+ emitNamespaces();
+
+ // compose the initializer function using a template
+ // filled with sub-parts
+ Template initializer(getTemplate("js_initializer"));
+ initializer.replace("$jsname", moduleName)
+ .replace("$jsv8nspaces", f_init_namespaces)
+ .replace("$jsv8classtemplates", f_init_class_templates)
+ .replace("$jsv8wrappers", f_init_wrappers)
+ .replace("$jsv8inheritance", f_init_inheritance)
+ .replace("$jsv8classinstances", f_init_class_instances)
+ .replace("$jsv8staticwrappers", f_init_static_wrappers)
+ .replace("$jsv8registerclasses", f_init_register_classes)
+ .replace("$jsv8registernspaces", f_init_register_namespaces);
+ Printv(f_init, initializer.str(), 0);
+
+ Printv(f_wrap_cpp, f_init, 0);
+
+ Printv(f_wrap_cpp, f_post_init, 0);
+
+ return SWIG_OK;
+}
+
+int V8Emitter::close() {
+ Delete(f_runtime);
+ Delete(f_header);
+ Delete(f_class_templates);
+ Delete(f_init_namespaces);
+ Delete(f_init_class_templates);
+ Delete(f_init_wrappers);
+ Delete(f_init_inheritance);
+ Delete(f_init_class_instances);
+ Delete(f_init_static_wrappers);
+ Delete(f_init_register_classes);
+ Delete(f_init_register_namespaces);
+ Delete(f_init);
+ Delete(f_post_init);
+ Delete(f_wrap_cpp);
+ return SWIG_OK;
+}
+
+int V8Emitter::enterClass(Node *n) {
+ JSEmitter::enterClass(n);
+
+ // emit declaration of a v8 class template
+ Template t_decl_class(getTemplate("jsv8_declare_class_template"));
+ t_decl_class.replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .trim()
+ .pretty_print(f_class_templates);
+
+ return SWIG_OK;
+}
+
+int V8Emitter::exitClass(Node *n) {
+ if (GetFlag(state.clazz(), IS_ABSTRACT)) {
+ Template t_veto_ctor(getTemplate("js_veto_ctor"));
+ t_veto_ctor.replace("$jswrapper", state.clazz(CTOR))
+ .replace("$jsname", state.clazz(NAME))
+ .pretty_print(f_wrappers);
+ }
+
+ /* Note: this makes sure that there is a swig_type added for this class */
+ String *clientData = NewString("");
+ Printf(clientData, "&%s_clientData", state.clazz(NAME_MANGLED));
+
+ /* Note: this makes sure that there is a swig_type added for this class */
+ SwigType_remember_clientdata(state.clazz(TYPE_MANGLED), NewString("0"));
+
+ // emit definition of v8 class template
+ Template t_def_class = getTemplate("jsv8_define_class_template");
+ t_def_class.replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .replace("$jsname", state.clazz(NAME))
+ .replace("$jsmangledtype", state.clazz(TYPE_MANGLED))
+ .replace("$jsdtor", state.clazz(DTOR))
+ .trim()
+ .pretty_print(f_init_class_templates);
+
+ Template t_class_instance = getTemplate("jsv8_create_class_instance");
+ t_class_instance.replace("$jsname", state.clazz(NAME))
+ .replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .replace("$jsctor", state.clazz(CTOR))
+ .trim()
+ .pretty_print(f_init_class_instances);
+
+ // emit inheritance setup
+ Node *baseClass = getBaseClass(n);
+ if (baseClass) {
+ String *base_name = Getattr(baseClass, "name");
+
+ Template t_inherit = getTemplate("jsv8_inherit");
+
+ String *base_name_mangled = SwigType_manglestr(base_name);
+ t_inherit.replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .replace("$jsbaseclass", base_name_mangled)
+ .trim()
+ .pretty_print(f_init_inheritance);
+ Delete(base_name_mangled);
+ }
+ // emit registeration of class template
+ Template t_register = getTemplate("jsv8_register_class");
+ t_register.replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .replace("$jsname", state.clazz(NAME))
+ .replace("$jsparent", Getattr(state.clazz("nspace"), NAME_MANGLED))
+ .trim()
+ .pretty_print(f_init_register_classes);
+
+ return SWIG_OK;
+}
+
+int V8Emitter::enterVariable(Node *n) {
+ JSEmitter::enterVariable(n);
+
+ state.variable(GETTER, NULL_STR);
+ state.variable(SETTER, VETO_SET);
+
+ return SWIG_OK;
+}
+
+int V8Emitter::exitVariable(Node *n) {
+ if (GetFlag(n, "ismember")) {
+ if (GetFlag(state.variable(), IS_STATIC) || Equal(Getattr(n, "nodeType"), "enumitem")) {
+ Template t_register = getTemplate("jsv8_register_static_variable");
+ t_register.replace("$jsparent", state.clazz(NAME_MANGLED))
+ .replace("$jsname", state.variable(NAME))
+ .replace("$jsgetter", state.variable(GETTER))
+ .replace("$jssetter", state.variable(SETTER))
+ .trim()
+ .pretty_print(f_init_static_wrappers);
+ } else {
+ Template t_register = getTemplate("jsv8_register_member_variable");
+ t_register.replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .replace("$jsname", state.variable(NAME))
+ .replace("$jsgetter", state.variable(GETTER))
+ .replace("$jssetter", state.variable(SETTER))
+ .trim()
+ .pretty_print(f_init_wrappers);
+ }
+ } else {
+ // Note: a global variable is treated like a static variable
+ // with the parent being a nspace object (instead of class object)
+ Template t_register = getTemplate("jsv8_register_static_variable");
+ t_register.replace("$jsparent", Getattr(current_namespace, NAME_MANGLED))
+ .replace("$jsname", state.variable(NAME))
+ .replace("$jsgetter", state.variable(GETTER))
+ .replace("$jssetter", state.variable(SETTER))
+ .trim()
+ .pretty_print(f_init_wrappers);
+ }
+
+ return SWIG_OK;
+}
+
+int V8Emitter::exitFunction(Node *n) {
+ bool is_member = GetFlag(n, "ismember") != 0 || GetFlag(n, "feature:extend") != 0;
+
+ // create a dispatcher for overloaded functions
+ bool is_overloaded = GetFlag(n, "sym:overloaded") != 0;
+ if (is_overloaded) {
+ if (!Getattr(n, "sym:nextSibling")) {
+ //state.function(WRAPPER_NAME, Swig_name_wrapper(Getattr(n, "name")));
+ emitFunctionDispatcher(n, is_member);
+ } else {
+ //don't register wrappers of overloaded functions in function tables
+ return SWIG_OK;
+ }
+ }
+ // register the function at the specific context
+ if (is_member) {
+ if (GetFlag(state.function(), IS_STATIC)) {
+ Template t_register = getTemplate("jsv8_register_static_function");
+ t_register.replace("$jsparent", state.clazz(NAME_MANGLED))
+ .replace("$jsname", state.function(NAME))
+ .replace("$jswrapper", state.function(WRAPPER_NAME))
+ .trim()
+ .pretty_print(f_init_static_wrappers);
+ } else {
+ Template t_register = getTemplate("jsv8_register_member_function");
+ t_register.replace("$jsmangledname", state.clazz(NAME_MANGLED))
+ .replace("$jsname", state.function(NAME))
+ .replace("$jswrapper", state.function(WRAPPER_NAME))
+ .trim()
+ .pretty_print(f_init_wrappers);
+ }
+ } else {
+ // Note: a global function is treated like a static function
+ // with the parent being a nspace object instead of class object
+ Template t_register = getTemplate("jsv8_register_static_function");
+ t_register.replace("$jsparent", Getattr(current_namespace, NAME_MANGLED))
+ .replace("$jsname", state.function(NAME))
+ .replace("$jswrapper", state.function(WRAPPER_NAME))
+ .trim()
+ .pretty_print(f_init_static_wrappers);
+ }
+
+ return SWIG_OK;
+}
+
+void V8Emitter::marshalInputArgs(Node *n, ParmList *parms, Wrapper *wrapper, MarshallingMode mode, bool is_member, bool is_static) {
+ Parm *p;
+ String *tm;
+
+ int startIdx = 0;
+ if (is_member && !is_static && mode != Ctor) {
+ startIdx = 1;
+ }
+ // store number of arguments for argument checks
+ int num_args = emit_num_arguments(parms) - startIdx;
+ String *argcount = NewString("");
+ Printf(argcount, "%d", num_args);
+ Setattr(n, ARGCOUNT, argcount);
+
+ int i = 0;
+ for (p = parms; p; i++) {
+ String *arg = NewString("");
+ String *type = Getattr(p, "type");
+
+ // ignore varargs
+ if (SwigType_isvarargs(type))
+ break;
+
+ switch (mode) {
+ case Getter:
+ if (is_member && !is_static && i == 0) {
+ Printv(arg, "info.Holder()", 0);
+ } else {
+ Printf(arg, "args[%d]", i - startIdx);
+ }
+ break;
+ case Function:
+ if (is_member && !is_static && i == 0) {
+ Printv(arg, "args.Holder()", 0);
+ } else {
+ Printf(arg, "args[%d]", i - startIdx);
+ }
+ break;
+ case Setter:
+ if (is_member && !is_static && i == 0) {
+ Printv(arg, "info.Holder()", 0);
+ } else {
+ Printv(arg, "value", 0);
+ }
+ break;
+ case Ctor:
+ Printf(arg, "args[%d]", i);
+ break;
+ default:
+ throw "Illegal state.";
+ }
+
+ tm = emitInputTypemap(n, p, wrapper, arg);
+ Delete(arg);
+
+ if (tm) {
+ p = Getattr(p, "tmap:in:next");
+ } else {
+ p = nextSibling(p);
+ }
+ }
+}
+
+int V8Emitter::emitNamespaces() {
+ Iterator it;
+ for (it = First(namespaces); it.item; it = Next(it)) {
+ Hash *entry = it.item;
+ String *name = Getattr(entry, NAME);
+ String *name_mangled = Getattr(entry, NAME_MANGLED);
+ String *parent = Getattr(entry, PARENT);
+ String *parent_mangled = Swig_name_mangle(parent);
+
+ bool do_create = true;
+ bool do_register = true;
+
+ if (Equal(parent, "")) {
+ do_register = false;
+ }
+ // Note: 'exports' is by convention the name of the object where
+ // globals are stored into
+ if (Equal(name, "exports")) {
+ do_create = false;
+ }
+
+ if (do_create) {
+ // create namespace object and register it to the parent scope
+ Template t_create_ns = getTemplate("jsv8_create_namespace");
+ t_create_ns.replace("$jsmangledname", name_mangled)
+ .trim()
+ .pretty_print(f_init_namespaces);
+ }
+
+ if (do_register) {
+ Template t_register_ns = getTemplate("jsv8_register_namespace");
+ t_register_ns.replace("$jsmangledname", name_mangled)
+ .replace("$jsname", name)
+ .replace("$jsparent", parent_mangled)
+ .trim();
+
+ // prepend in order to achieve reversed order of registration statements
+ String *tmp_register_stmt = NewString("");
+ t_register_ns.pretty_print(tmp_register_stmt);
+ Insert(f_init_register_namespaces, 0, tmp_register_stmt);
+ Delete(tmp_register_stmt);
+ }
+ }
+
+ return SWIG_OK;
+}
+
+JSEmitter *swig_javascript_create_V8Emitter() {
+ return new V8Emitter();
+}
+
+/**********************************************************************
+ * Helper implementations
+ **********************************************************************/
+
+JSEmitterState::JSEmitterState()
+: globalHash(NewHash()) {
+ // initialize sub-hashes
+ Setattr(globalHash, "class", NewHash());
+ Setattr(globalHash, "function", NewHash());
+ Setattr(globalHash, "variable", NewHash());
+}
+
+JSEmitterState::~JSEmitterState() {
+ Delete(globalHash);
+}
+
+DOH *JSEmitterState::getState(const char *key, bool new_key) {
+ if (new_key) {
+ Hash *hash = NewHash();
+ Setattr(globalHash, key, hash);
+ }
+ return Getattr(globalHash, key);
+}
+
+DOH *JSEmitterState::globals() {
+ return globalHash;
+}
+
+DOH *JSEmitterState::globals(const char *key, DOH *initial) {
+ if (initial != 0) {
+ Setattr(globalHash, key, initial);
+ }
+ return Getattr(globalHash, key);
+}
+
+DOH *JSEmitterState::clazz(bool new_key) {
+ return getState("class", new_key);
+}
+
+DOH *JSEmitterState::clazz(const char *key, DOH *initial) {
+ DOH *c = clazz();
+ if (initial != 0) {
+ Setattr(c, key, initial);
+ }
+ return Getattr(c, key);
+}
+
+DOH *JSEmitterState::function(bool new_key) {
+ return getState("function", new_key);
+}
+
+DOH *JSEmitterState::function(const char *key, DOH *initial) {
+ DOH *f = function();
+ if (initial != 0) {
+ Setattr(f, key, initial);
+ }
+ return Getattr(f, key);
+}
+
+DOH *JSEmitterState::variable(bool new_key) {
+ return getState("variable", new_key);
+}
+
+DOH *JSEmitterState::variable(const char *key, DOH *initial) {
+ DOH *v = variable();
+ if (initial != 0) {
+ Setattr(v, key, initial);
+ }
+ return Getattr(v, key);
+}
+
+/*static*/
+int JSEmitterState::IsSet(DOH *val) {
+ if (!val) {
+ return 0;
+ } else {
+ const char *cval = Char(val);
+ if (!cval)
+ return 0;
+ return (strcmp(cval, "0") != 0) ? 1 : 0;
+ }
+}
+
+/* -----------------------------------------------------------------------------
+ * Template::Template() : creates a Template class for given template code
+ * ----------------------------------------------------------------------------- */
+
+Template::Template(const String *code_) {
+
+ if (!code_) {
+ Printf(stdout, "Template code was null. Illegal input for template.");
+ SWIG_exit(EXIT_FAILURE);
+ }
+ code = NewString(code_);
+ templateName = NewString("");
+}
+
+Template::Template(const String *code_, const String *templateName_) {
+
+ if (!code_) {
+ Printf(stdout, "Template code was null. Illegal input for template.");
+ SWIG_exit(EXIT_FAILURE);
+ }
+
+ code = NewString(code_);
+ templateName = NewString(templateName_);
+}
+
+
+/* -----------------------------------------------------------------------------
+ * Template::~Template() : cleans up of Template.
+ * ----------------------------------------------------------------------------- */
+
+Template::~Template() {
+ Delete(code);
+ Delete(templateName);
+}
+
+/* -----------------------------------------------------------------------------
+ * String* Template::str() : retrieves the current content of the template.
+ * ----------------------------------------------------------------------------- */
+
+String *Template::str() {
+ if (js_template_enable_debug) {
+ String *pre_code = NewString("");
+ String *post_code = NewString("");
+ String *debug_code = NewString("");
+ Printf(pre_code, "/* begin fragment(\"%s\") */", templateName);
+ Printf(post_code, "/* end fragment(\"%s\") */", templateName);
+ Printf(debug_code, "%s\n%s\n%s\n", pre_code, code, post_code);
+
+ Delete(code);
+ Delete(pre_code);
+ Delete(post_code);
+
+ code = debug_code;
+ }
+ return code;
+}
+
+Template & Template::trim() {
+ const char *str = Char(code);
+ if (str == 0)
+ return *this;
+
+ int length = Len(code);
+ if (length == 0)
+ return *this;
+
+ int idx;
+ for (idx = 0; idx < length; ++idx) {
+ if (str[idx] != ' ' && str[idx] != '\t' && str[idx] != '\r' && str[idx] != '\n')
+ break;
+ }
+ int start_pos = idx;
+
+ for (idx = length - 1; idx >= start_pos; --idx) {
+ if (str[idx] != ' ' && str[idx] != '\t' && str[idx] != '\r' && str[idx] != '\n')
+ break;
+ }
+ int end_pos = idx;
+
+ int new_length = end_pos - start_pos + 1;
+ char *newstr = new char[new_length + 1];
+ memcpy(newstr, str + start_pos, new_length);
+ newstr[new_length] = 0;
+
+ Delete(code);
+ code = NewString(newstr);
+ delete[]newstr;
+
+ return *this;
+}
+
+/* -----------------------------------------------------------------------------
+ * Template& Template::replace(const String* pattern, const String* repl) :
+ *
+ * replaces all occurences of a given pattern with a given replacement.
+ *
+ * - pattern: the pattern to be replaced
+ * - repl: the replacement string
+ * - returns a reference to the Template to allow chaining of methods.
+ * ----------------------------------------------------------------------------- */
+
+Template & Template::replace(const String *pattern, const String *repl) {
+ Replaceall(code, pattern, repl);
+ return *this;
+}
+
+Template & Template::print(DOH *doh) {
+ Printv(doh, str(), 0);
+ return *this;
+}
+
+Template & Template::pretty_print(DOH *doh) {
+ Wrapper_pretty_print(str(), doh);
+ return *this;
+}
+
+Template::Template(const Template & t) {
+ code = NewString(t.code);
+ templateName = NewString(t.templateName);
+}
+
+void Template::operator=(const Template & t) {
+ Delete(code);
+ Delete(templateName);
+ code = NewString(t.code);
+ templateName = NewString(t.templateName);
+}
static int director_protected_mode = 1;
static int all_protected_mode = 0;
static int naturalvar_mode = 0;
-Language* Language::this_ = 0;
+Language *Language::this_ = 0;
/* Set director_protected_mode */
void Wrapper_director_mode_set(int flag) {
/* Some status variables used during parsing */
static int InClass = 0; /* Parsing C++ or not */
static String *ClassName = 0; /* This is the real name of the current class */
+static String *EnumClassName = 0; /* Enum class name */
static String *ClassPrefix = 0; /* Class prefix */
+static String *EnumClassPrefix = 0; /* Prefix for strongly typed enums (including ClassPrefix) */
static String *NSpace = 0; /* Namespace for the nspace feature */
static String *ClassType = 0; /* Fully qualified type name to use */
static String *DirectorClassName = 0; /* Director name of the current class */
ret = namespaceDeclaration(n);
} else if (strcmp(tag, "template") == 0) {
ret = templateDeclaration(n);
+ } else if (strcmp(tag, "lambda") == 0) {
+ ret = lambdaDeclaration(n);
}
/* ===============================================================
int Dispatcher::templateDeclaration(Node *n) {
return defaultHandler(n);
}
+int Dispatcher::lambdaDeclaration(Node *n) {
+ return defaultHandler(n);
+}
int Dispatcher::classforwardDeclaration(Node *n) {
return defaultHandler(n);
}
multiinput(0),
cplus_runtime(0),
directors(0) {
- Hash *symbols = NewHash();
- Setattr(symtabs, "", symbols); // create top level/global symbol table scope
+ symbolAddScope(""); // create top level/global symbol table scope
argc_template_string = NewString("argc");
argv_template_string = NewString("argv[%d]");
String *dirclassname;
String *nspace = NewString(Getattr(n, "sym:nspace"));
const char *attrib = "director:classname";
- String *classname = Getattr(n, "sym:name");
+ String *classname = getClassPrefix();
Replace(nspace, NSPACE_SEPARATOR, "_", DOH_REPLACE_ANY);
if (Len(nspace) > 0)
}
/* --------------------------------------------------------------------------
- * use_naturalvar_mode()
+ * Language::use_naturalvar_mode()
+ *
+ * Determine whether to use const ref typemaps instead of pointer typemaps
+ * for variable access.
* -------------------------------------------------------------------------- */
-int use_naturalvar_mode(Node *n) {
+int Language::use_naturalvar_mode(Node *n) const {
if (Getattr(n, "unnamed"))
return 0;
- int nvar = naturalvar_mode || GetFlag(n, "feature:naturalvar");
- if (!nvar) {
+
+ // The naturalvar feature can be attached to either the variable name or the variable's type
+ // naturalvar on the variable name is more specific and overrides naturalvar on the variable's type
+ String *naturalvar = Getattr(n, "feature:naturalvar");
+ bool explicitly_off = naturalvar && Strcmp(naturalvar, "0") == 0;
+ int nvar = GetFlag(n, "feature:naturalvar");
+
+ if (!explicitly_off && !nvar) {
/* look for feature in the class */
SwigType *ty = Getattr(n, "type");
SwigType *fullty = SwigType_typedef_resolve_all(ty);
if (SwigType_isclass(fullty)) {
- Node *m = Copy(n);
SwigType *tys = SwigType_strip_qualifiers(fullty);
- Swig_features_get(Swig_cparse_features(), 0, tys, 0, m);
- nvar = GetFlag(m, "feature:naturalvar");
+ if (!CPlusPlus) {
+ Replaceall(tys, "struct ", "");
+ Replaceall(tys, "union ", "");
+ Replaceall(tys, "class ", "");
+ }
+ Node *typenode = Swig_symbol_clookup(tys, 0);
+ if (typenode) {
+ naturalvar = Getattr(typenode, "feature:naturalvar");
+ explicitly_off = naturalvar && Strcmp(naturalvar, "0") == 0;
+ nvar = nvar || GetFlag(typenode, "feature:naturalvar");
+ }
Delete(tys);
- Delete(m);
}
Delete(fullty);
}
- return nvar ? CWRAP_NATURAL_VAR : 0;
+ nvar = nvar || naturalvar_mode;
+ return explicitly_off ? 0 : nvar ? CWRAP_NATURAL_VAR : 0;
}
/* ----------------------------------------------------------------------
if (Getattr(options, "naturalvar")) {
naturalvar_mode = 1;
}
- if (Getattr(options, "nonaturalvar")) {
- naturalvar_mode = 0;
- }
}
}
classhash = Getattr(n, "classes");
* ---------------------------------------------------------------------- */
int Language::extendDirective(Node *n) {
- int oldam = Extend;
- AccessMode oldmode = cplus_mode;
- Extend = CWRAP_EXTEND;
- cplus_mode = PUBLIC;
-
+ save_value<int> oldam(Extend, CWRAP_EXTEND);
+ save_value<AccessMode> oldmode(cplus_mode, PUBLIC);
emit_children(n);
-
- Extend = oldam;
- cplus_mode = oldmode;
return SWIG_OK;
}
}
if (!validIdentifier(symname)) {
- Swig_warning(WARN_LANG_IDENTIFIER, input_file, line_number, "Can't wrap '%s' unless renamed to a valid identifier.\n", symname);
+ Swig_warning(WARN_LANG_IDENTIFIER, input_file, line_number, "Can't wrap '%s' unless renamed to a valid identifier.\n", SwigType_namestr(symname));
return SWIG_NOWRAP;
}
if (AddExtern) {
if (f_header) {
- if ((Cmp(storage, "extern") == 0) || (ForceExtern && !storage)) {
+ if (Swig_storage_isextern(n) || (ForceExtern && !storage)) {
/* we don't need the 'extern' part in the C/C++ declaration,
and it produces some problems when namespace and SUN
Studio is used.
}
}
Printf(f_header, ";\n");
- } else if (Cmp(storage, "externc") == 0) {
+ } else if (Swig_storage_isexternc(n)) {
/* here 'extern "C"' is needed */
String *str = SwigType_str(ty, name);
Printf(f_header, "extern \"C\" %s;\n", str);
/* Some kind of variable declaration */
String *declaration = Copy(decl);
Delattr(n, "decl");
- if (Getattr(n, "nested"))
- SetFlag(n, "feature:immutable");
if (!CurrentClass) {
- if ((Cmp(storage, "extern") == 0) || ForceExtern) {
- f_header = Swig_filebyname("header");
+ if (Swig_storage_isextern(n) || ForceExtern) {
if (AddExtern) {
+ f_header = Swig_filebyname("header");
if (f_header) {
String *str = SwigType_str(ty, name);
- Printf(f_header, "extern %s;\n", str);
+ Printf(f_header, "%s %s;\n", Getattr(n, "storage"), str);
Delete(str);
}
}
int Language::functionHandler(Node *n) {
String *storage = Getattr(n, "storage");
int isfriend = CurrentClass && Cmp(storage, "friend") == 0;
- int isstatic = CurrentClass && Cmp(storage, "static") == 0 && !(SmartPointer && Getattr(n, "allocate:smartpointeraccess"));
+ int isstatic = CurrentClass && Swig_storage_isstatic(n) && !(SmartPointer && Getattr(n, "allocate:smartpointeraccess"));
Parm *p = Getattr(n, "parms");
if (GetFlag(n, "feature:del")) {
/* the method acts like a delete operator, ie, we need to disown the parameter */
String *fname = Swig_name_member(NSpace, ClassPrefix, symname);
if (Extend && SmartPointer) {
- if (!Getattr(n, "classname")) {
- Setattr(n, "classname", Getattr(CurrentClass, "allocate:smartpointerbase"));
+ if (!Getattr(n, "extendsmartclassname")) {
+ Setattr(n, "extendsmartclassname", Getattr(CurrentClass, "allocate:smartpointerpointeeclassname"));
}
}
// Set up the type for the cast to this class for use when wrapping const director (virtual) methods.
if (!CurrentClass) {
globalvariableHandler(n);
} else {
- String *storage = Getattr(n, "storage");
Swig_save("variableHandler", n, "feature:immutable", NIL);
if (SmartPointer) {
/* If a smart-pointer and it's a constant access, we have to set immutable */
SetFlag(n, "feature:immutable");
}
}
- if ((Cmp(storage, "static") == 0) && !(SmartPointer && Getattr(n, "allocate:smartpointeraccess"))) {
+ if (Swig_storage_isstatic(n) && !(SmartPointer && Getattr(n, "allocate:smartpointeraccess"))) {
staticmembervariableHandler(n);
} else {
membervariableHandler(n);
String *target = 0;
if (!Extend) {
if (SmartPointer) {
- if (checkAttribute(n, "storage", "static")) {
+ if (Swig_storage_isstatic(n)) {
Node *sn = Getattr(n, "cplus:staticbase");
String *base = Getattr(sn, "name");
target = NewStringf("%s::%s", base, name);
tm = Swig_typemap_lookup("memberin", nin, target, 0);
Delete(nin);
}
+
int flags = Extend | SmartPointer | use_naturalvar_mode(n);
if (isNonVirtualProtectedAccess(n))
flags = flags | CWRAP_ALL_PROTECTED_ACCESS;
Setattr(n, "type", type);
Setattr(n, "name", name);
Setattr(n, "sym:name", symname);
+ Delattr(n, "memberset");
/* Delete all attached typemaps and typemap attributes */
Iterator ki;
Setattr(n, "sym:name", mrename_get);
Setattr(n, "memberget", "1");
functionWrapper(n);
+ Delattr(n, "memberget");
}
Delete(mrename_get);
Delete(mrename_set);
int Language::staticmembervariableHandler(Node *n) {
Swig_require("staticmembervariableHandler", n, "*name", "*sym:name", "*type", "?value", NIL);
String *value = Getattr(n, "value");
- String *classname = !SmartPointer ? (isNonVirtualProtectedAccess(n) ? DirectorClassName : ClassName) : Getattr(CurrentClass, "allocate:smartpointerbase");
+ String *classname = !SmartPointer ? (isNonVirtualProtectedAccess(n) ? DirectorClassName : ClassName) : Getattr(CurrentClass, "allocate:smartpointerpointeeclassname");
if (!value || !Getattr(n, "hasconsttype")) {
String *name = Getattr(n, "name");
* ---------------------------------------------------------------------- */
int Language::enumDeclaration(Node *n) {
+ if (CurrentClass && (cplus_mode != PUBLIC))
+ return SWIG_NOWRAP;
+
String *oldNSpace = NSpace;
NSpace = Getattr(n, "sym:nspace");
+ String *oldEnumClassPrefix = EnumClassPrefix;
+ if (GetFlag(n, "scopedenum")) {
+ assert(Getattr(n, "sym:name"));
+ assert(Getattr(n, "name"));
+ EnumClassPrefix = ClassPrefix ? NewStringf("%s_", ClassPrefix) : NewString("");
+ Printv(EnumClassPrefix, Getattr(n, "sym:name"), NIL);
+ EnumClassName = Copy(Getattr(n, "name"));
+ }
if (!ImportMode) {
emit_children(n);
}
+ if (GetFlag(n, "scopedenum")) {
+ Delete(EnumClassName);
+ EnumClassName = 0;
+ Delete(EnumClassPrefix);
+ EnumClassPrefix = oldEnumClassPrefix;
+ }
NSpace = oldNSpace;
return SWIG_OK;
if (CurrentClass && (cplus_mode != PUBLIC))
return SWIG_NOWRAP;
- Swig_require("enumvalueDeclaration", n, "*name", "?value", NIL);
+ Swig_require("enumvalueDeclaration", n, "*name", "*sym:name", "?value", NIL);
String *value = Getattr(n, "value");
String *name = Getattr(n, "name");
String *tmpValue;
tmpValue = NewString(name);
Setattr(n, "value", tmpValue);
+ Node *parent = parentNode(n);
+ if (GetFlag(parent, "scopedenum")) {
+ String *symname = Swig_name_member(0, Getattr(parent, "sym:name"), Getattr(n, "sym:name"));
+ Setattr(n, "sym:name", symname);
+ Delete(symname);
+ }
+
if (!CurrentClass || !cparse_cplusplus) {
Setattr(n, "name", tmpValue); /* for wrapping of enums in a namespace when emit_action is used */
constantWrapper(n);
Setattr(n, "feature:except", Getattr(n, "feature:exceptvar"));
}
+ String *enumvalue_symname = Getattr(n, "enumvalueDeclaration:sym:name"); // Only set if a strongly typed enum
String *name = Getattr(n, "name");
String *symname = Getattr(n, "sym:name");
String *value = Getattr(n, "value");
- String *mrename = Swig_name_member(0, ClassPrefix, symname);
+ String *mrename = Swig_name_member(0, EnumClassPrefix, enumvalue_symname ? enumvalue_symname : symname);
Setattr(n, "sym:name", mrename);
String *new_name = 0;
if (Extend)
new_name = Copy(value);
+ else if (EnumClassName)
+ new_name = NewStringf("%s::%s", isNonVirtualProtectedAccess(n) ? DirectorClassName : EnumClassName, name);
else
new_name = NewStringf("%s::%s", isNonVirtualProtectedAccess(n) ? DirectorClassName : ClassName, name);
Setattr(n, "name", new_name);
needed, since there is a public constructor already defined.
(scottm) This code is needed here to make the director_abstract +
- test generate compileable code (Example2 in director_abastract.i).
+ test generate compilable code (Example2 in director_abastract.i).
(mmatus) This is very strange, since swig compiled with gcc3.2.3
doesn't need it here....
return SWIG_NOWRAP;
}
+ // save class local variables for nested classes support
+ int oldInClass = InClass;
+ String *oldClassType = ClassType;
+ String *oldClassPrefix = ClassPrefix;
+ String *oldEnumClassPrefix = EnumClassPrefix;
+ String *oldClassName = ClassName;
+ String *oldDirectorClassName = DirectorClassName;
+ String *oldNSpace = NSpace;
+ Node *oldCurrentClass = CurrentClass;
+ int dir = 0;
+
String *kind = Getattr(n, "kind");
String *name = Getattr(n, "name");
String *tdname = Getattr(n, "tdname");
int strip = CPlusPlus ? 1 : unnamed && tdname;
+ if (cplus_mode != PUBLIC)
+ return SWIG_NOWRAP;
if (!name) {
Swig_warning(WARN_LANG_CLASS_UNNAMED, input_file, line_number, "Can't generate wrappers for unnamed struct/class.\n");
return SWIG_NOWRAP;
Swig_warning(WARN_LANG_IDENTIFIER, input_file, line_number, "Can't wrap class %s unless renamed to a valid identifier.\n", SwigType_namestr(symname));
return SWIG_NOWRAP;
}
-
+ AccessMode oldAccessMode = cplus_mode;
+ Node *outerClass = Getattr(n, "nested:outer");
+ if (outerClass && oldAccessMode != PUBLIC)
+ return SWIG_NOWRAP;
+ ClassName = Copy(name);
+ ClassPrefix = Copy(symname);
if (Cmp(kind, "class") == 0) {
cplus_mode = PRIVATE;
} else {
cplus_mode = PUBLIC;
}
-
- ClassName = Copy(name);
- ClassPrefix = Copy(symname);
+ for (; outerClass; outerClass = Getattr(outerClass, "nested:outer")) {
+ Push(ClassPrefix, "_");
+ Push(ClassPrefix, Getattr(outerClass, "sym:name"));
+ }
+ EnumClassPrefix = Copy(ClassPrefix);
if (strip) {
ClassType = Copy(name);
} else {
InClass = 1;
CurrentClass = n;
-
- String *oldNSpace = NSpace;
NSpace = Getattr(n, "sym:nspace");
+ int oldAbstract = Abstract;
/* Call classHandler() here */
if (!ImportMode) {
- int dir = 0;
if (directorsEnabled()) {
int ndir = GetFlag(n, "feature:director");
int nndir = GetFlag(n, "feature:nodirector");
classDirector(n);
}
/* check for abstract after resolving directors */
- Abstract = abstractClassTest(n);
+ Abstract = abstractClassTest(n);
classHandler(n);
} else {
Abstract = abstractClassTest(n);
Language::classHandler(n);
}
+ Abstract = oldAbstract;
+ cplus_mode = oldAccessMode;
NSpace = oldNSpace;
- InClass = 0;
- CurrentClass = 0;
+ InClass = oldInClass;
+ CurrentClass = oldCurrentClass;
Delete(ClassType);
- ClassType = 0;
+ ClassType = oldClassType;
+ Delete(EnumClassPrefix);
+ EnumClassPrefix = oldEnumClassPrefix;
Delete(ClassPrefix);
- ClassPrefix = 0;
+ ClassPrefix = oldClassPrefix;
Delete(ClassName);
- ClassName = 0;
- Delete(DirectorClassName);
- DirectorClassName = 0;
+ ClassName = oldClassName;
+ if (dir) {
+ Delete(DirectorClassName);
+ }
+ DirectorClassName = oldDirectorClassName;
return SWIG_OK;
}
* ---------------------------------------------------------------------- */
int Language::classHandler(Node *n) {
-
+ save_value<int> oldExtend(Extend);
+ if (Getattr(n, "template"))
+ Extend = 0;
bool hasDirector = Swig_directorclass(n) ? true : false;
/* Emit all of the class members */
if (dirprot_mode() && extraDirectorProtectedCPPMethodsRequired()) {
Node *vtable = Getattr(n, "vtable");
String *symname = Getattr(n, "sym:name");
- AccessMode old_mode = cplus_mode;
+ save_value<AccessMode> old_mode(cplus_mode);
cplus_mode = PROTECTED;
int len = Len(vtable);
for (int i = 0; i < len; i++) {
Setattr(m, "parentNode", n);
/*
* There is a bug that needs fixing still...
- * This area of code is creating methods which have not been overidden in a derived class (director methods that are protected in the base)
+ * This area of code is creating methods which have not been overridden in a derived class (director methods that are protected in the base)
* If the method is overloaded, then Swig_overload_dispatch() incorrectly generates a call to the base wrapper, _wrap_xxx method
* See director_protected_overloaded.i - Possibly sym:overname needs correcting here.
Printf(stdout, "new method: %s::%s(%s)\n", Getattr(parentNode(m), "name"), Getattr(m, "name"), ParmList_str_defaultargs(Getattr(m, "parms")));
}
Delete(wrapname);
}
- cplus_mode = old_mode;
}
}
String *scope = Swig_scopename_check(ClassName) ? Swig_scopename_prefix(ClassName) : 0;
String *actual_name = scope ? NewStringf("%s::%s", scope, name) : NewString(name);
Delete(scope);
- if (!Equal(actual_name, expected_name) && !(Getattr(n, "template"))) {
+ if (!Equal(actual_name, expected_name) && !SwigType_istemplate(expected_name) && !SwigType_istemplate(actual_name)) {
+ // Checking templates is skipped but they ought to be checked... they are just somewhat more tricky to check correctly
bool illegal_name = true;
if (Extend) {
// Check for typedef names used as a constructor name in %extend. This is deprecated except for anonymous
Setattr(n, "handled_as_constructor", "1");
}
- Swig_ConstructorToFunction(n, NSpace, ClassType, none_comparison, director_ctor, CPlusPlus, Getattr(n, "template") ? 0 : Extend);
+ Swig_ConstructorToFunction(n, NSpace, ClassType, none_comparison, director_ctor, CPlusPlus, Getattr(n, "template") ? 0 : Extend, DirectorClassName);
Setattr(n, "sym:name", mrename);
functionWrapper(n);
Delete(mrename);
String *director_ctor = get_director_ctor_code(n, director_ctor_code,
director_prot_ctor_code,
abstracts);
- Swig_ConstructorToFunction(n, NSpace, ClassType, none_comparison, director_ctor, CPlusPlus, Getattr(n, "template") ? 0 : Extend);
+ Swig_ConstructorToFunction(n, NSpace, ClassType, none_comparison, director_ctor, CPlusPlus, Getattr(n, "template") ? 0 : Extend, DirectorClassName);
Setattr(n, "sym:name", mrename);
functionWrapper(n);
Delete(mrename);
* ---------------------------------------------------------------------- */
int Language::variableWrapper(Node *n) {
- Swig_require("variableWrapper", n, "*name", "*sym:name", "*type", "?parms", NIL);
+ Swig_require("variableWrapper", n, "*name", "*sym:name", "*type", "?parms", "?varset", "?varget", NIL);
String *symname = Getattr(n, "sym:name");
SwigType *type = Getattr(n, "type");
String *name = Getattr(n, "name");
+ Delattr(n,"varset");
+ Delattr(n,"varget");
+
+ String *newsymname = 0;
+ if (!CurrentClass && EnumClassPrefix) {
+ newsymname = Swig_name_member(0, EnumClassPrefix, symname);
+ symname = newsymname;
+ }
+
/* If no way to set variables. We simply create functions */
int assignable = is_assignable(n);
int flags = use_naturalvar_mode(n);
Delete(pname0);
}
if (make_set_wrapper) {
+ Setattr(n, "varset", "1");
functionWrapper(n);
+ } else {
+ SetFlag(n, "feature:immutable");
}
/* Restore parameters */
Setattr(n, "sym:name", symname);
Setattr(n, "type", type);
Setattr(n, "name", name);
+ Delattr(n, "varset");
/* Delete all attached typemaps and typemap attributes */
Iterator ki;
String *gname = Swig_name_get(NSpace, symname);
Setattr(n, "sym:name", gname);
Delete(gname);
+ Setattr(n, "varget", "1");
functionWrapper(n);
+ Delattr(n, "varget");
Swig_restore(n);
+ Delete(newsymname);
return SWIG_OK;
}
* ----------------------------------------------------------------------------- */
int Language::addSymbol(const String *s, const Node *n, const_String_or_char_ptr scope) {
+ //Printf( stdout, "addSymbol: %s %s\n", s, scope );
Hash *symbols = Getattr(symtabs, scope ? scope : "");
if (!symbols) {
- // New scope which has not been added by the target language - lazily created.
- symbols = NewHash();
- Setattr(symtabs, scope, symbols);
-
- // Add the new scope as a symbol in the top level scope.
- // Alternatively the target language must add it in before attempting to add symbols into the scope.
- const_String_or_char_ptr top_scope = "";
- Hash *topscope_symbols = Getattr(symtabs, top_scope);
- Setattr(topscope_symbols, scope, NewHash());
+ symbols = symbolAddScope(scope);
} else {
Node *c = Getattr(symbols, s);
if (c && (c != n)) {
}
/* -----------------------------------------------------------------------------
+ * Language::addInterfaceSymbol()
+ *
+ * Adds a symbol entry into the target language symbol tables - for the interface
+ * feature only.
+ * Returns 1 if the symbol is added successfully.
+ * The scope is as per addSymbol.
+ * ----------------------------------------------------------------------------- */
+
+int Language::addInterfaceSymbol(const String *interface_name, Node *n, const_String_or_char_ptr scope) {
+ if (interface_name) {
+ Node *existing_symbol = symbolLookup(interface_name, scope);
+ if (existing_symbol) {
+ String *proxy_class_name = Getattr(n, "sym:name");
+ Swig_error(input_file, line_number, "The interface feature name '%s' for proxy class '%s' is already defined in the generated target language module in scope '%s'.\n",
+ interface_name, proxy_class_name, scope);
+ Swig_error(Getfile(existing_symbol), Getline(existing_symbol), "Previous declaration of '%s'\n", interface_name);
+ return 0;
+ }
+ if (!addSymbol(interface_name, n, scope))
+ return 0;
+ }
+ return 1;
+}
+
+/* -----------------------------------------------------------------------------
+ * Language::symbolAddScope()
+ *
+ * Creates a scope (symbols Hash) for given name. This method is auxiliary,
+ * you don't have to call it - addSymbols will lazily create scopes automatically.
+ * If scope with given name already exists, then do nothing.
+ * Returns newly created (or already existing) scope.
+ * ----------------------------------------------------------------------------- */
+Hash* Language::symbolAddScope(const_String_or_char_ptr scope) {
+ Hash *symbols = symbolScopeLookup(scope);
+ if(!symbols) {
+ // The order in which the following code is executed is important. In the Language
+ // constructor addScope("") is called to create a top level scope.
+ // Thus we must first add a symbols hash to symtab and only then add pseudo
+ // symbols to the top-level scope.
+
+ // New scope which has not been added by the target language - lazily created.
+ symbols = NewHash();
+ Setattr(symtabs, scope, symbols);
+
+ // Add the new scope as a symbol in the top level scope.
+ // Alternatively the target language must add it in before attempting to add symbols into the scope.
+ const_String_or_char_ptr top_scope = "";
+ Hash *topscope_symbols = Getattr(symtabs, top_scope);
+ Hash *pseudo_symbol = NewHash();
+ Setattr(pseudo_symbol, "sym:scope", "1");
+ Setattr(topscope_symbols, scope, pseudo_symbol);
+ }
+ return symbols;
+}
+
+/* -----------------------------------------------------------------------------
+ * Language::symbolScopeLookup()
+ *
+ * Lookup and returns a symtable (hash) representing given scope. Hash contains
+ * all symbols in this scope.
+ * ----------------------------------------------------------------------------- */
+Hash* Language::symbolScopeLookup( const_String_or_char_ptr scope ) {
+ Hash *symbols = Getattr(symtabs, scope ? scope : "");
+ return symbols;
+}
+
+/* -----------------------------------------------------------------------------
+ * Language::symbolScopePseudoSymbolLookup()
+ *
+ * For every scope there is a special pseudo-symbol in the top scope (""). It
+ * exists solely to detect name clashes. This pseudo symbol may contain a few properties,
+ * but more could be added. This is also true for the top level scope ("").
+ * It contains a pseudo symbol with name "" (empty). Pseudo symbol contains the
+ * following properties:
+ * sym:scope = "1" - a flag that this is a scope pseudo symbol
+ *
+ * Pseudo symbols are a Hash*, not a Node*.
+ * There is no difference from symbolLookup() method except for signature
+ * and return type.
+ * ----------------------------------------------------------------------------- */
+Hash* Language::symbolScopePseudoSymbolLookup( const_String_or_char_ptr scope )
+{
+ /* Getting top scope */
+ const_String_or_char_ptr top_scope = "";
+ Hash *symbols = Getattr(symtabs, top_scope);
+ return Getattr(symbols, scope);
+}
+
+/* -----------------------------------------------------------------------------
* Language::dumpSymbols()
* ----------------------------------------------------------------------------- */
* Language::symbolLookup()
* ----------------------------------------------------------------------------- */
-Node *Language::symbolLookup(String *s, const_String_or_char_ptr scope) {
+Node *Language::symbolLookup(const String *s, const_String_or_char_ptr scope) {
Hash *symbols = Getattr(symtabs, scope ? scope : "");
if (!symbols) {
return NULL;
* Tries to locate a class from a type definition
* ----------------------------------------------------------------------------- */
-Node *Language::classLookup(const SwigType *s) {
+Node *Language::classLookup(const SwigType *s) const {
Node *n = 0;
/* Look in hash of cached values */
(Len(prefix) == 0) || // simple type (pass by value)
(Strcmp(prefix, "p.") == 0) || // pointer
(Strcmp(prefix, "r.") == 0) || // reference
+ (Strcmp(prefix, "z.") == 0) || // rvalue reference
SwigType_prefix_is_simple_1D_array(prefix); // Simple 1D array (not arrays of pointers/references)
// Also accept pointer by const reference, not non-const pointer reference
if (!acceptable_prefix && (Strcmp(prefix, "r.p.") == 0)) {
}
/* -----------------------------------------------------------------------------
+ * Language::makeParameterName()
+ *
+ * Inputs:
+ * n - Node
+ * p - parameter node
+ * arg_num - parameter argument number
+ * setter - set this flag when wrapping variables
+ * Return:
+ * arg - a unique parameter name
+ * ----------------------------------------------------------------------------- */
+String *Language::makeParameterName(Node *n, Parm *p, int arg_num, bool setter) const {
+
+ String *arg = 0;
+ String *pn = Getattr(p, "name");
+
+ // Use C parameter name unless it is a duplicate or an empty parameter name
+ int count = 0;
+ ParmList *plist = Getattr(n, "parms");
+ while (plist) {
+ if ((Cmp(pn, Getattr(plist, "name")) == 0))
+ count++;
+ plist = nextSibling(plist);
+ }
+ String *wrn = pn ? Swig_name_warning(p, 0, pn, 0) : 0;
+ arg = (!pn || (count > 1) || wrn) ? NewStringf("arg%d", arg_num) : Copy(pn);
+
+ if (setter && Cmp(arg, "self") != 0) {
+ // Some languages (C#) insist on calling the input variable "value" while
+ // others (D, Java) could, in principle, use something different but this
+ // would require more work, and so we just use "value" for them too.
+ // For setters the parameter name sometimes includes C++ scope resolution which needs removing.
+ Delete(arg);
+ arg = NewString("value");
+ }
+
+ return arg;
+}
+
+/* -----------------------------------------------------------------------------
* Language::()
* ----------------------------------------------------------------------------- */
}
/* -----------------------------------------------------------------------------
+ * Language::nestedClassesSupport()
+ * ----------------------------------------------------------------------------- */
+
+Language::NestedClassSupport Language::nestedClassesSupport() const {
+ return NCS_Unknown;
+}
+
+/* -----------------------------------------------------------------------------
+ * Language::kwargsSupport()
+ * ----------------------------------------------------------------------------- */
+
+bool Language::kwargsSupport() const {
+ return false;
+}
+
+/* -----------------------------------------------------------------------------
* Language::is_wrapping_class()
* ----------------------------------------------------------------------------- */
}
/* -----------------------------------------------------------------------------
+ * Language::getEnumClassPrefix()
+ * ----------------------------------------------------------------------------- */
+
+String *Language::getEnumClassPrefix() const {
+ return EnumClassPrefix;
+}
+
+/* -----------------------------------------------------------------------------
* Language::getClassType()
* ----------------------------------------------------------------------------- */
return 0;
if (Getattr(n, "allocate:nonew"))
return 1;
+
+ // A class cannot be instantiated if one of its bases has a private destructor
+ // Note that if the above does not hold the class can be instantiated if its own destructor is private
+ List *bases = Getattr(n, "bases");
+ if (bases) {
+ for (int i = 0; i < Len(bases); i++) {
+ Node *b = Getitem(bases, i);
+ if (GetFlag(b, "allocate:private_destructor"))
+ return 1;
+ }
+ }
+
/* now check for the rest */
List *abstracts = Getattr(n, "abstracts");
if (!abstracts)
return 0;
int labs = Len(abstracts);
#ifdef SWIG_DEBUG
- List *bases = Getattr(n, "allbases");
- Printf(stderr, "testing %s %d %d\n", Getattr(n, "name"), labs, Len(bases));
+ List *allbases = Getattr(n, "allbases");
+ Printf(stderr, "testing %s %d %d\n", Getattr(n, "name"), labs, Len(allbases));
#endif
if (!labs)
return 0; /*strange, but need to be fixed */
/* -----------------------------------------------------------------------------
* Language::replaceSpecialVariables()
+ *
* Language modules should implement this if special variables are to be handled
* correctly in the $typemap(...) special variable macro.
* method - typemap method name
Hash *Language::getClassHash() const {
return classhash;
}
+
*/
#define REPORT(T,D) // no info:
//#define REPORT(T,D) {Printf(stdout,T"\n");} // only title
-//#define REPORT(T,D) {Printf(stdout,T" %p\n",n);} // title & pointer
+//#define REPORT(T,D) {Printf(stdout,T" %p\n",n);} // title & pointer
//#define REPORT(T,D) {Printf(stdout,T"\n");display_mapping(D);} // the works
//#define REPORT(T,D) {Printf(stdout,T"\n");if(D)Swig_print_node(D);} // the works
}
}
+extern "C"
+{
+ static int compareByLen(const DOH *f, const DOH *s) {
+ return Len(s) - Len(f);
+ }
+}
/* NEW LANGUAGE NOTE:***********************************************
you can add new ones here
(though for now I have not bothered)
NEW LANGUAGE NOTE:END ************************************************/
-static const char *usage = (char *) "\
+static const char *usage = "\
Lua Options (available with -lua)\n\
-elua - Generates LTR compatible wrappers for smaller devices running elua\n\
-eluac - LTR compatible wrappers in \"crass compress\" mode for elua\n\
+ -elua-emulate - Emulates behaviour of eLua. Useful only for testing.\n\
+ Incompatible with -elua/-eluac options.\n\
-nomoduleglobal - Do not register the module name as a global variable \n\
but return the module table from calls to require.\n\
+ -no-old-metatable-bindings\n\
+ - Disable support for old-style bindings name generation, some\n\
+ old-style members scheme etc.\n\
+ -squash-bases - Squashes symbols from all inheritance tree of a given class\n\
+ into itself. Emulates pre-SWIG3.0 inheritance. Insignificantly\n\
+ speeds things up, but increases memory consumption.\n\
\n";
static int nomoduleglobal = 0;
static int elua_ltr = 0;
static int eluac_ltr = 0;
+static int elua_emulate = 0;
+static int squash_bases = 0;
+/* The new metatable bindings were introduced in SWIG 3.0.0.
+ * old_metatable_bindings in v2:
+ * 1. static methods will be put into the scope their respective class
+ * belongs to as well as into the class scope itself. (only for classes without %nspace given)
+ * 2. The layout in elua mode is somewhat different
+ */
+static int old_metatable_bindings = 1;
+static int old_compatible_names = 1; // This flag can temporarily disable backward compatible names generation if old_metatable_bindings is enabled
/* NEW LANGUAGE NOTE:***********************************************
To add a new language, you need to derive your class from
File *f_wrappers;
File *f_init;
File *f_initbeforefunc;
- String *s_cmd_tab; // table of command names
- String *s_var_tab; // table of global variables
- String *s_const_tab; // table of global constants
- String *s_methods_tab; // table of class methods
- String *s_attr_tab; // table of class attributes
- String *s_cls_attr_tab; // table of class static attributes
- String *s_cls_methods_tab; // table of class static methods
- String *s_cls_const_tab; // tables of class constants(including enums)
String *s_luacode; // luacode to be called during init
- String *s_dot_get; // table of variable 'get' functions
- String *s_dot_set; // table of variable 'set' functions
- String *s_vars_meta_tab; // metatable for variables
+ String *module; //name of the module
+ // Parameters for current class. NIL if not parsing class
int have_constructor;
int have_destructor;
String *destructor_action;
- String *class_name;
+ // This variable holds the name of the current class in Lua. Usually it is
+ // the same as C++ class name, but rename directives can change it.
+ String *proxy_class_name;
+ // This is a so calld fully qualified symname - the above proxy class name
+ // prepended with class namespace. If class Lua name is the same as class C++ name,
+ // then it is basically C++ fully qualified name with colons replaced with dots.
+ String *full_proxy_class_name;
+ // All static methods and/or variables are treated as if they were in the
+ // special C++ namespace $(classname).SwigStatic. This is internal mechanism only
+ // and is not visible to user in any manner. This variable holds the name
+ // of such pseudo-namespace a.k.a the result of above expression evaluation
+ String *class_static_nspace;
+ // This variable holds the name of generated C function that acts as a constructor
+ // for the currently parsed class.
String *constructor_name;
- enum {
+ // Many wrappers forward calls to each other, for example staticmembervariableHandler
+ // forwards calls to variableHandler, which, in turn, makes to call to functionWrapper.
+ // In order to access information about whether it is a static member of class or just
+ // a plain old variable, the current array is kept and used as a 'log' of the call stack.
+ enum TState {
NO_CPP,
VARIABLE,
+ GLOBAL_FUNC,
+ GLOBAL_VAR,
MEMBER_FUNC,
CONSTRUCTOR,
DESTRUCTOR,
MEMBER_VAR,
- CLASS_CONST,
STATIC_FUNC,
- STATIC_VAR
- }current;
+ STATIC_VAR,
+ STATIC_CONST, // enums and things like static const int x = 5;
+ ENUM_CONST, // This is only needed for backward compatibility in C mode
+
+ STATES_COUNT
+ };
+ bool current[STATES_COUNT];
public:
* Initialize member data
* --------------------------------------------------------------------- */
- LUA() :
- f_begin(0),
- f_runtime(0),
- f_header(0),
- f_wrappers(0),
- f_init(0),
- f_initbeforefunc(0),
- s_cmd_tab(0),
- s_var_tab(0),
- s_const_tab(0),
- s_methods_tab(0),
- s_attr_tab(0),
- s_cls_attr_tab(0),
- s_cls_methods_tab(0),
- s_cls_const_tab(0),
- s_luacode(0),
- s_dot_get(0),
- s_dot_set(0),
- s_vars_meta_tab(0),
- have_constructor(0),
- have_destructor(0),
- destructor_action(0),
- class_name(0),
- constructor_name(0),
- current(NO_CPP) {
+ LUA():
+ f_begin(0),
+ f_runtime(0),
+ f_header(0),
+ f_wrappers(0),
+ f_init(0),
+ f_initbeforefunc(0),
+ s_luacode(0),
+ module(0),
+ have_constructor(0),
+ have_destructor(0),
+ destructor_action(0),
+ proxy_class_name(0),
+ full_proxy_class_name(0),
+ class_static_nspace(0),
+ constructor_name(0) {
+ for (int i = 0; i < STATES_COUNT; i++)
+ current[i] = false;
}
/* NEW LANGUAGE NOTE:***********************************************
- This is called to initalise the system & read any command line args
+ This is called to initialise the system & read any command line args
most of this is boilerplate code, except the command line args
which depends upon what args your code supports
- NEW LANGUAGE NOTE:END ************************************************/
+ NEW LANGUAGE NOTE:END *********************************************** */
/* ---------------------------------------------------------------------
- * main()
- *
- * Parse command line options and initializes variables.
- * --------------------------------------------------------------------- */
+ * main()
+ *
+ * Parse command line options and initializes variables.
+ * --------------------------------------------------------------------- */
virtual void main(int argc, char *argv[]) {
/* Look for certain command line options */
for (int i = 1; i < argc; i++) {
if (argv[i]) {
- if (strcmp(argv[i], "-help") == 0) { // usage flags
- fputs(usage, stdout);
- } else if (strcmp(argv[i], "-nomoduleglobal") == 0) {
- nomoduleglobal = 1;
- Swig_mark_arg(i);
- } else if(strcmp(argv[i], "-elua") == 0) {
- elua_ltr = 1;
- Swig_mark_arg(i);
- } else if(strcmp(argv[i], "-eluac") == 0) {
- eluac_ltr = 1;
- Swig_mark_arg(i);
- }
+ if (strcmp(argv[i], "-help") == 0) { // usage flags
+ fputs(usage, stdout);
+ } else if (strcmp(argv[i], "-nomoduleglobal") == 0) {
+ nomoduleglobal = 1;
+ Swig_mark_arg(i);
+ } else if (strcmp(argv[i], "-elua") == 0) {
+ elua_ltr = 1;
+ Swig_mark_arg(i);
+ } else if (strcmp(argv[i], "-eluac") == 0) {
+ eluac_ltr = 1;
+ Swig_mark_arg(i);
+ } else if (strcmp(argv[i], "-no-old-metatable-bindings") == 0) {
+ Swig_mark_arg(i);
+ old_metatable_bindings = 0;
+ } else if (strcmp(argv[i], "-squash-bases") == 0) {
+ Swig_mark_arg(i);
+ squash_bases = 1;
+ } else if (strcmp(argv[i], "-elua-emulate") == 0) {
+ Swig_mark_arg(i);
+ elua_emulate = 1;
+ }
}
}
+ if (elua_emulate && (eluac_ltr || elua_ltr )) {
+ Printf(stderr, "Cannot have -elua-emulate with either -eluac or -elua\n");
+ Swig_arg_error();
+ }
+
+ // Set elua_ltr if elua_emulate is requested
+ if(elua_emulate)
+ elua_ltr = 1;
+
/* NEW LANGUAGE NOTE:***********************************************
- This is the boilerplate code, setting a few #defines
- and which lib directory to use
- the SWIG_library_directory() is also boilerplate code
- but it always seems to be the first line of code
- NEW LANGUAGE NOTE:END ************************************************/
+ This is the boilerplate code, setting a few #defines
+ and which lib directory to use
+ the SWIG_library_directory() is also boilerplate code
+ but it always seems to be the first line of code
+ NEW LANGUAGE NOTE:END *********************************************** */
/* Add a symbol to the parser for conditional compilation */
Preprocessor_define("SWIGLUA 1", 0);
/* NEW LANGUAGE NOTE:***********************************************
- After calling main, SWIG parses the code to wrap (I believe)
- then calls top()
- in this is more boilerplate code to set everything up
- and a call to Language::top()
- which begins the code generations by calling the member fns
- after all that is more boilerplate code to close all down
- (overall there is virtually nothing here that needs to be edited
- just use as is)
- NEW LANGUAGE NOTE:END ************************************************/
+ After calling main, SWIG parses the code to wrap (I believe)
+ then calls top()
+ in this is more boilerplate code to set everything up
+ and a call to Language::top()
+ which begins the code generations by calling the member fns
+ after all that is more boilerplate code to close all down
+ (overall there is virtually nothing here that needs to be edited
+ just use as is)
+ NEW LANGUAGE NOTE:END *********************************************** */
/* ---------------------------------------------------------------------
* top()
* --------------------------------------------------------------------- */
virtual int top(Node *n) {
/* Get the module name */
- String *module = Getattr(n, "name");
+ module = Getattr(n, "name");
/* Get the output file name */
String *outfile = Getattr(n, "outfile");
Swig_register_filebyname("init", f_init);
Swig_register_filebyname("initbeforefunc", f_initbeforefunc);
- /* NEW LANGUAGE NOTE:***********************************************
- s_cmd_tab,s_var_tab & s_const_tab hold the names of the fns for
- registering with SWIG.
- These will be filled in when the functions/variables are wrapped &
- then added to the end of the wrappering code
- just before it is written to file
- NEW LANGUAGE NOTE:END ************************************************/
- // Initialize some variables for the object interface
- s_cmd_tab = NewString("");
- s_var_tab = NewString("");
- // s_methods_tab = NewString("");
- s_const_tab = NewString("");
-
- s_dot_get = NewString("");
- s_dot_set = NewString("");
- s_vars_meta_tab = NewString("");
-
+
s_luacode = NewString("");
Swig_register_filebyname("luacode", s_luacode);
-
- current=NO_CPP;
+
+ current[NO_CPP] = true;
/* Standard stuff for the SWIG runtime section */
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGLUA\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGLUA\n#define SWIGLUA\n#endif\n\n");
emitLuaFlavor(f_runtime);
} else {
Printf(f_runtime, "#define SWIG_LUA_MODULE_GLOBAL\n");
}
+ if (squash_bases)
+ Printf(f_runtime, "#define SWIG_LUA_SQUASH_BASES\n");
// if (NoInclude) {
// Printf(f_runtime, "#define SWIG_NOINCLUDE\n");
Printf(f_header, "#define SWIG_init_user luaopen_%s_user\n\n", module);
Printf(f_header, "#define SWIG_LUACODE luaopen_%s_luacode\n", module);
- if (elua_ltr || eluac_ltr)
- Printf(f_header, "#define swig_commands %s_map\n\n", module);
-
- if (elua_ltr || eluac_ltr) {
- Printf(s_cmd_tab, "\n#define MIN_OPT_LEVEL 2\n#include \"lrodefs.h\"\n");
- Printf(s_cmd_tab, "#include \"lrotable.h\"\n");
- Printf(s_cmd_tab, "\nconst LUA_REG_TYPE swig_constants[];\n");
- if (elua_ltr)
- Printf(s_cmd_tab, "const LUA_REG_TYPE mt[];\n");
-
- Printf(s_cmd_tab, "\nconst LUA_REG_TYPE swig_commands[] = {\n");
- Printf(s_const_tab, "\nconst LUA_REG_TYPE swig_constants[] = {\n");
- Printf(f_wrappers, "#ifdef __cplusplus\nextern \"C\" {\n#endif\n");
- if (elua_ltr) {
- Printf(s_dot_get, "\nconst LUA_REG_TYPE dot_get[] = {\n");
- Printf(s_dot_set, "\nconst LUA_REG_TYPE dot_set[] = {\n");
- }
- } else {
- Printf(s_cmd_tab, "\nstatic const struct luaL_Reg swig_commands[] = {\n");
- Printf(s_var_tab, "\nstatic swig_lua_var_info swig_variables[] = {\n");
- Printf(s_const_tab, "\nstatic swig_lua_const_info swig_constants[] = {\n");
- Printf(f_wrappers, "#ifdef __cplusplus\nextern \"C\" {\n#endif\n");
- }
+ Printf(f_wrappers, "#ifdef __cplusplus\nextern \"C\" {\n#endif\n");
/* %init code inclusion, effectively in the SWIG_init function */
Printf(f_init, "void SWIG_init_user(lua_State* L)\n{\n");
Language::top(n);
- Printf(f_init,"/* exec Lua code if applicable */\nSWIG_Lua_dostring(L,SWIG_LUACODE);\n");
+ Printf(f_init, "/* exec Lua code if applicable */\nSWIG_Lua_dostring(L,SWIG_LUACODE);\n");
Printf(f_init, "}\n");
- Printf(f_wrappers, "#ifdef __cplusplus\n}\n#endif\n");
-
// Done. Close up the module & write to the wrappers
- if (elua_ltr || eluac_ltr) {
- Printv(s_cmd_tab, tab4, "{LSTRKEY(\"const\"), LROVAL(swig_constants)},\n", NIL);
- if (elua_ltr)
- Printv(s_cmd_tab, tab4, "{LSTRKEY(\"__metatable\"), LROVAL(mt)},\n", NIL);
- Printv(s_cmd_tab, tab4, "{LNILKEY, LNILVAL}\n", "};\n", NIL);
- Printv(s_const_tab, tab4, "{LNILKEY, LNILVAL}\n", "};\n", NIL);
- } else {
- Printv(s_cmd_tab, tab4, "{0,0}\n", "};\n", NIL);
- Printv(s_var_tab, tab4, "{0,0,0}\n", "};\n", NIL);
- Printv(s_const_tab, tab4, "{0,0,0,0,0,0}\n", "};\n", NIL);
- }
-
- if (elua_ltr) {
- /* Generate the metatable */
- Printf(s_vars_meta_tab, "\nconst LUA_REG_TYPE mt[] = {\n");
- Printv(s_vars_meta_tab, tab4, "{LSTRKEY(\"__index\"), LFUNCVAL(SWIG_Lua_module_get)},\n", NIL);
- Printv(s_vars_meta_tab, tab4, "{LSTRKEY(\"__newindex\"), LFUNCVAL(SWIG_Lua_module_set)},\n", NIL);
- Printv(s_vars_meta_tab, tab4, "{LSTRKEY(\".get\"), LROVAL(dot_get)},\n", NIL);
- Printv(s_vars_meta_tab, tab4, "{LSTRKEY(\".set\"), LROVAL(dot_set)},\n", NIL);
- Printv(s_vars_meta_tab, tab4, "{LNILKEY, LNILVAL}\n};\n", NIL);
-
- Printv(s_dot_get, tab4, "{LNILKEY, LNILVAL}\n};\n", NIL);
- Printv(s_dot_set, tab4, "{LNILKEY, LNILVAL}\n};\n", NIL);
- }
+ closeNamespaces(f_wrappers);
+ Printf(f_wrappers, "#ifdef __cplusplus\n}\n#endif\n");
- if (elua_ltr || eluac_ltr) {
- /* Final close up of wrappers */
- Printv(f_wrappers, s_cmd_tab, s_dot_get, s_dot_set, s_vars_meta_tab, s_var_tab, s_const_tab, NIL);
- SwigType_emit_type_table(f_runtime, f_wrappers);
- } else {
- Printv(f_wrappers, s_cmd_tab, s_var_tab, s_const_tab, NIL);
- SwigType_emit_type_table(f_runtime, f_wrappers);
- }
+ SwigType_emit_type_table(f_runtime, f_wrappers);
/* NEW LANGUAGE NOTE:***********************************************
- this basically combines several of the strings together
- and then writes it all to a file
- NEW LANGUAGE NOTE:END ************************************************/
+ this basically combines several of the strings together
+ and then writes it all to a file
+ NEW LANGUAGE NOTE:END *********************************************** */
Dump(f_runtime, f_begin);
Dump(f_header, f_begin);
Dump(f_wrappers, f_begin);
Dump(f_initbeforefunc, f_begin);
- /* for the Lua code it needs to be properly excaped to be added into the C/C++ code */
- EscapeCode(s_luacode);
- Printf(f_begin, "const char* SWIG_LUACODE=\n \"%s\";\n\n",s_luacode);
+ /* for the Lua code it needs to be properly escaped to be added into the C/C++ code */
+ escapeCode(s_luacode);
+ Printf(f_begin, "const char* SWIG_LUACODE=\n \"%s\";\n\n", s_luacode);
Wrapper_pretty_print(f_init, f_begin);
/* Close all of the files */
Delete(s_luacode);
- Delete(s_cmd_tab);
- Delete(s_var_tab);
- Delete(s_const_tab);
Delete(f_header);
Delete(f_wrappers);
Delete(f_init);
Delete(f_initbeforefunc);
Delete(f_runtime);
Delete(f_begin);
- Delete(s_dot_get);
- Delete(s_dot_set);
- Delete(s_vars_meta_tab);
/* Done */
return SWIG_OK;
return Language::importDirective(n);
}
+ /* ------------------------------------------------------------
+ * cDeclaration()
+ * It copies sym:name to lua:name to preserve its original value
+ * ------------------------------------------------------------ */
+
+ virtual int cDeclaration(Node *n) {
+ // class 'Language' is messing with symname in a really heavy way.
+ // Although documentation states that sym:name is a name in
+ // the target language space, it is not true. sym:name and
+ // its derivatives are used in various places, including
+ // behind-the-scene C code generation. The best way is not to
+ // touch it at all.
+ // But we need to know what was the name of function/variable
+ // etc that user desired, that's why we store correct symname
+ // as lua:name
+ String *symname = Getattr(n, "sym:name");
+ if (symname)
+ Setattr(n, "lua:name", symname);
+ return Language::cDeclaration(n);
+ }
+ virtual int constructorDeclaration(Node *n) {
+ Setattr(n, "lua:name", Getattr(n, "sym:name"));
+ return Language::constructorDeclaration(n);
+ }
+ virtual int destructorDeclaration(Node *n) {
+ Setattr(n, "lua:name", Getattr(n, "sym:name"));
+ return Language::destructorDeclaration(n);
+ }
/* NEW LANGUAGE NOTE:***********************************************
- This is it!
- you get this one right, and most of your work is done
- but its going to take soem file to get it working right
- quite a bit of this is generally boilerplate code
- (or stuff I dont understand)
- that which matters will have extra added comments
- NEW LANGUAGE NOTE:END ************************************************/
+ This is it!
+ you get this one right, and most of your work is done
+ but its going to take some file to get it working right
+ quite a bit of this is generally boilerplate code
+ (or stuff I don't understand)
+ that which matters will have extra added comments
+ NEW LANGUAGE NOTE:END *********************************************** */
/* ---------------------------------------------------------------------
* functionWrapper()
*
* Create a function declaration and register it with the interpreter.
* --------------------------------------------------------------------- */
+ /* -----------------------------------------------------------------------
+ * registerMethod()
+ *
+ * Determines wrap name of a method, its scope etc and calls
+ * registerMethod overload with correct arguments
+ * Overloaded variant adds method to the "methods" array of specified lua scope/class
+ * ---------------------------------------------------------------------- */
+
+ void registerMethod(Node *n, bool overwrite = false, String *overwriteLuaScope = 0) {
+ String *symname = Getattr(n, "sym:name");
+ assert(symname);
+
+ if (Getattr(n, "sym:nextSibling"))
+ return;
+
+ // Lua scope. It is not symbol NSpace, it is the actual key to retrieve getCArraysHash.
+ String *luaScope = luaCurrentSymbolNSpace();
+ if (overwrite)
+ luaScope = overwriteLuaScope;
+
+ String *wrapname = 0;
+ String *mrename;
+ if (current[NO_CPP] || !getCurrentClass()) {
+ mrename = symname;
+ } else {
+ assert(!current[NO_CPP]);
+ if (current[STATIC_FUNC] || current[MEMBER_FUNC]) {
+ mrename = Swig_name_member(getNSpace(), getClassPrefix(), symname);
+ } else {
+ mrename = symname;
+ }
+ }
+ wrapname = Swig_name_wrapper(mrename);
+ registerMethod(n, wrapname, luaScope);
+ }
+
+ /* -----------------------------------------------------------------------
+ * registerMethod()
+ *
+ * Add method to the "methods" C array of given namespace/class
+ * ---------------------------------------------------------------------- */
+
+ void registerMethod(Node *n, String* wname, String *luaScope) {
+ assert(n);
+ Hash *nspaceHash = getCArraysHash(luaScope);
+ String *s_ns_methods_tab = Getattr(nspaceHash, "methods");
+ String *lua_name = Getattr(n, "lua:name");
+ if (elua_ltr || eluac_ltr)
+ Printv(s_ns_methods_tab, tab4, "{LSTRKEY(\"", lua_name, "\")", ", LFUNCVAL(", wname, ")", "},\n", NIL);
+ else
+ Printv(s_ns_methods_tab, tab4, "{ \"", lua_name, "\", ", wname, "},\n", NIL);
+ // Add to the metatable if method starts with '__'
+ const char * tn = Char(lua_name);
+ if (tn[0]=='_' && tn[1] == '_' && !eluac_ltr) {
+ String *metatable_tab = Getattr(nspaceHash, "metatable");
+ assert(metatable_tab);
+ if (elua_ltr)
+ Printv(metatable_tab, tab4, "{LSTRKEY(\"", lua_name, "\")", ", LFUNCVAL(", wname, ")", "},\n", NIL);
+ else
+ Printv(metatable_tab, tab4, "{ \"", lua_name, "\", ", wname, "},\n", NIL);
+ }
+ }
+
virtual int functionWrapper(Node *n) {
- REPORT("functionWrapper",n);
+ REPORT("functionWrapper", n);
String *name = Getattr(n, "name");
String *iname = Getattr(n, "sym:name");
+ String *lua_name = Getattr(n, "lua:name");
+ assert(lua_name);
SwigType *d = Getattr(n, "type");
ParmList *l = Getattr(n, "parms");
- //Printf(stdout,"functionWrapper %s %s\n",name,iname);
Parm *p;
String *tm;
int i;
//Printf(stdout,"functionWrapper %s %s %d\n",name,iname,current);
- // int returnval=0; // number of arguments returned
String *overname = 0;
if (Getattr(n, "sym:overloaded")) {
overname = Getattr(n, "sym:overname");
} else {
- if (!addSymbol(iname, n)) {
- Printf(stderr,"addSymbol(%s) failed\n",iname);
- return SWIG_ERROR;
+ if (!luaAddSymbol(lua_name, n)) {
+ return SWIG_ERROR;
}
}
/* NEW LANGUAGE NOTE:***********************************************
- the wrapper object holds all the wrappering code
- we need to add a couple of local variables
- NEW LANGUAGE NOTE:END ************************************************/
+ the wrapper object holds all the wrapper code
+ we need to add a couple of local variables
+ NEW LANGUAGE NOTE:END *********************************************** */
Wrapper *f = NewWrapper();
Wrapper_add_local(f, "SWIG_arg", "int SWIG_arg = 0");
if (overname) {
Append(wname, overname);
}
+ if (current[CONSTRUCTOR]) {
+ if (constructor_name != 0)
+ Delete(constructor_name);
+ constructor_name = Copy(wname);
+ }
/* NEW LANGUAGE NOTE:***********************************************
the format of a lua fn is:
- static int wrap_XXX(lua_State* L){...}
- this line adds this into the wrappering code
- NEW LANGUAGE NOTE:END ************************************************/
+ static int wrap_XXX(lua_State* L){...}
+ this line adds this into the wrapper code
+ NEW LANGUAGE NOTE:END *********************************************** */
Printv(f->def, "static int ", wname, "(lua_State* L) {", NIL);
/* NEW LANGUAGE NOTE:***********************************************
this prints the list of args, eg for a C fn
int gcd(int x,int y);
it will print
- int arg1;
- int arg2;
- NEW LANGUAGE NOTE:END ************************************************/
+ int arg1;
+ int arg2;
+ NEW LANGUAGE NOTE:END *********************************************** */
/* Write code to extract function parameters. */
emit_parameter_variables(l, f);
}
- /* Which input argument to start with? */
- // int start = (current == MEMBER_FUNC || current == MEMBER_VAR || current == DESTRUCTOR) ? 1 : 0;
-
- /* Offset to skip over the attribute name */
- // int offset = (current == MEMBER_VAR) ? 1 : 0;
-
/* NEW LANGUAGE NOTE:***********************************************
from here on in, it gets rather hairy
this is the code to convert from the scripting language to C/C++
some of the stuff will refer to the typemaps code written in your swig file
(lua.swg), and some is done in the code here
- I suppose you could do all the conversion on C, but it would be a nightmare to do
- NEW LANGUAGE NOTE:END ************************************************/
+ I suppose you could do all the conversion in C, but it would be a nightmare to do
+ NEW LANGUAGE NOTE:END *********************************************** */
/* Generate code for argument marshalling */
// String *description = NewString("");
/* NEW LANGUAGE NOTE:***********************************************
argument_check is a new feature I added to check types of arguments:
eg for int gcd(int,int)
I want to check that arg1 & arg2 really are integers
- NEW LANGUAGE NOTE:END ************************************************/
+ NEW LANGUAGE NOTE:END *********************************************** */
String *argument_check = NewString("");
String *argument_parse = NewString("");
String *checkfn = NULL;
char source[64];
- Printf(argument_check, "SWIG_check_num_args(\"%s\",%d,%d)\n",Swig_name_str(n),num_required+args_to_ignore,num_arguments+args_to_ignore);
+ Printf(argument_check, "SWIG_check_num_args(\"%s\",%d,%d)\n", Swig_name_str(n), num_required + args_to_ignore, num_arguments + args_to_ignore);
for (i = 0, p = l; i < num_arguments; i++) {
while (checkAttribute(p, "tmap:in:numinputs", "0")) {
- p = Getattr(p, "tmap:in:next");
+ p = Getattr(p, "tmap:in:next");
}
SwigType *pt = Getattr(p, "type");
/* Look for an input typemap */
sprintf(source, "%d", i + 1);
if ((tm = Getattr(p, "tmap:in"))) {
- Replaceall(tm, "$source", source);
- Replaceall(tm, "$target", ln);
- Replaceall(tm, "$input", source);
- Setattr(p, "emit:input", source);
- if (Getattr(p, "wrap:disown") || (Getattr(p, "tmap:in:disown"))) {
- Replaceall(tm, "$disown", "SWIG_POINTER_DISOWN");
- } else {
- Replaceall(tm, "$disown", "0");
- }
- /* NEW LANGUAGE NOTE:***********************************************
- look for a 'checkfn' typemap
- this an additional parameter added to the in typemap
- if found the type will be tested for
- this will result in code either in the
- argument_check or argument_parse string
- NEW LANGUAGE NOTE:END ************************************************/
- if ((checkfn = Getattr(p, "tmap:in:checkfn"))) {
- if (i < num_required) {
- Printf(argument_check, "if(!%s(L,%s))", checkfn, source);
- } else {
- Printf(argument_check, "if(lua_gettop(L)>=%s && !%s(L,%s))", source, checkfn, source);
- }
- Printf(argument_check, " SWIG_fail_arg(\"%s\",%s,\"%s\");\n", Swig_name_str(n), source, SwigType_str(pt, 0));
- }
- /* NEW LANGUAGE NOTE:***********************************************
- lua states the number of arguments passed to a function using the fn
- lua_gettop()
- we can use this to deal with default arguments
- NEW LANGUAGE NOTE:END ************************************************/
- if (i < num_required) {
- Printf(argument_parse, "%s\n", tm);
- } else {
- Printf(argument_parse, "if(lua_gettop(L)>=%s){%s}\n", source, tm);
- }
- p = Getattr(p, "tmap:in:next");
- continue;
+ Replaceall(tm, "$source", source);
+ Replaceall(tm, "$target", ln);
+ Replaceall(tm, "$input", source);
+ Setattr(p, "emit:input", source);
+ if (Getattr(p, "wrap:disown") || (Getattr(p, "tmap:in:disown"))) {
+ Replaceall(tm, "$disown", "SWIG_POINTER_DISOWN");
+ } else {
+ Replaceall(tm, "$disown", "0");
+ }
+ /* NEW LANGUAGE NOTE:***********************************************
+ look for a 'checkfn' typemap
+ this an additional parameter added to the in typemap
+ if found the type will be tested for
+ this will result in code either in the
+ argument_check or argument_parse string
+ NEW LANGUAGE NOTE:END *********************************************** */
+ if ((checkfn = Getattr(p, "tmap:in:checkfn"))) {
+ if (i < num_required) {
+ Printf(argument_check, "if(!%s(L,%s))", checkfn, source);
+ } else {
+ Printf(argument_check, "if(lua_gettop(L)>=%s && !%s(L,%s))", source, checkfn, source);
+ }
+ Printf(argument_check, " SWIG_fail_arg(\"%s\",%s,\"%s\");\n", Swig_name_str(n), source, SwigType_str(pt, 0));
+ }
+ /* NEW LANGUAGE NOTE:***********************************************
+ lua states the number of arguments passed to a function using the fn
+ lua_gettop()
+ we can use this to deal with default arguments
+ NEW LANGUAGE NOTE:END *********************************************** */
+ if (i < num_required) {
+ Printf(argument_parse, "%s\n", tm);
+ } else {
+ Printf(argument_parse, "if(lua_gettop(L)>=%s){%s}\n", source, tm);
+ }
+ p = Getattr(p, "tmap:in:next");
+ continue;
} else {
- /* NEW LANGUAGE NOTE:***********************************************
- // why is this code not called when I dont have a typemap?
- // instead of giving a warning, no code is generated
- NEW LANGUAGE NOTE:END ************************************************/
- Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument.\n", SwigType_str(pt, 0));
- break;
+ /* NEW LANGUAGE NOTE:***********************************************
+ // why is this code not called when I don't have a typemap?
+ // instead of giving a warning, no code is generated
+ NEW LANGUAGE NOTE:END *********************************************** */
+ Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument.\n", SwigType_str(pt, 0));
+ break;
}
}
/* Check for trailing varargs */
if (varargs) {
if (p && (tm = Getattr(p, "tmap:in"))) {
- Replaceall(tm, "$input", "varargs");
- Printv(f->code, tm, "\n", NIL);
+ Replaceall(tm, "$input", "varargs");
+ Printv(f->code, tm, "\n", NIL);
}
}
/* Insert constraint checking code */
for (p = l; p;) {
if ((tm = Getattr(p, "tmap:check"))) {
- Replaceall(tm, "$target", Getattr(p, "lname"));
- Printv(f->code, tm, "\n", NIL);
- p = Getattr(p, "tmap:check:next");
+ Replaceall(tm, "$target", Getattr(p, "lname"));
+ Printv(f->code, tm, "\n", NIL);
+ p = Getattr(p, "tmap:check:next");
} else {
- p = nextSibling(p);
+ p = nextSibling(p);
}
}
String *cleanup = NewString("");
for (p = l; p;) {
if ((tm = Getattr(p, "tmap:freearg"))) {
- Replaceall(tm, "$source", Getattr(p, "lname"));
- Printv(cleanup, tm, "\n", NIL);
- p = Getattr(p, "tmap:freearg:next");
+ Replaceall(tm, "$source", Getattr(p, "lname"));
+ Printv(cleanup, tm, "\n", NIL);
+ p = Getattr(p, "tmap:freearg:next");
} else {
- p = nextSibling(p);
+ p = nextSibling(p);
}
}
String *outarg = NewString("");
for (p = l; p;) {
if ((tm = Getattr(p, "tmap:argout"))) {
- // // managing the number of returning variables
- // if (numoutputs=Getattr(p,"tmap:argout:numoutputs")){
- // int i=GetInt(p,"tmap:argout:numoutputs");
- // printf("got argout:numoutputs of %d\n",i);
- // returnval+=GetInt(p,"tmap:argout:numoutputs");
- // }
- // else returnval++;
- Replaceall(tm, "$source", Getattr(p, "lname"));
- Replaceall(tm, "$target", Swig_cresult_name());
- Replaceall(tm, "$arg", Getattr(p, "emit:input"));
- Replaceall(tm, "$input", Getattr(p, "emit:input"));
- Printv(outarg, tm, "\n", NIL);
- p = Getattr(p, "tmap:argout:next");
+ // // managing the number of returning variables
+ // if (numoutputs=Getattr(p,"tmap:argout:numoutputs")){
+ // int i=GetInt(p,"tmap:argout:numoutputs");
+ // printf("got argout:numoutputs of %d\n",i);
+ // returnval+=GetInt(p,"tmap:argout:numoutputs");
+ // }
+ // else returnval++;
+ Replaceall(tm, "$source", Getattr(p, "lname"));
+ Replaceall(tm, "$target", Swig_cresult_name());
+ Replaceall(tm, "$arg", Getattr(p, "emit:input"));
+ Replaceall(tm, "$input", Getattr(p, "emit:input"));
+ Printv(outarg, tm, "\n", NIL);
+ p = Getattr(p, "tmap:argout:next");
} else {
- p = nextSibling(p);
+ p = nextSibling(p);
}
}
+ // Remember C name of the wrapping function
Setattr(n, "wrap:name", wname);
/* Emit the function call */
String *actioncode = emit_action(n);
/* NEW LANGUAGE NOTE:***********************************************
- FIXME:
- returns 1 if there is a void return type
- this is because there is a typemap for void
- NEW LANGUAGE NOTE:END ************************************************/
+ FIXME:
+ returns 1 if there is a void return type
+ this is because there is a typemap for void
+ NEW LANGUAGE NOTE:END *********************************************** */
// Return value if necessary
if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) {
// managing the number of returning variables
// else returnval++;
Replaceall(tm, "$source", Swig_cresult_name());
if (GetFlag(n, "feature:new")) {
- Replaceall(tm, "$owner", "1");
+ Replaceall(tm, "$owner", "1");
} else {
- Replaceall(tm, "$owner", "0");
+ Replaceall(tm, "$owner", "0");
}
Printf(f->code, "%s\n", tm);
// returnval++;
/* Look to see if there is any newfree cleanup code */
if (GetFlag(n, "feature:new")) {
if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) {
- Replaceall(tm, "$source", Swig_cresult_name());
- Printf(f->code, "%s\n", tm);
+ Replaceall(tm, "$source", Swig_cresult_name());
+ Printf(f->code, "%s\n", tm);
}
}
Replaceall(f->code, "$result", Swig_cresult_name());
/* Dump the function out */
- /* in Lua we will not emit the destructor as a wrappered function,
- Lua will automatically call the destructor when the object is free'd
- However: you cannot just skip this function as it will not emit
- any custom destructor (using %extend), as you need to call emit_action()
- Therefore we go though the whole function,
- but do not write the code into the wrapper
- */
- if(current!=DESTRUCTOR) {
- Wrapper_print(f, f_wrappers);
+ /* in Lua we will not emit the destructor as a wrapper function,
+ Lua will automatically call the destructor when the object is free'd
+ However: you cannot just skip this function as it will not emit
+ any custom destructor (using %extend), as you need to call emit_action()
+ Therefore we go though the whole function,
+ but do not write the code into the wrapper
+ */
+ if (!current[DESTRUCTOR]) {
+ Wrapper_print(f, f_wrappers);
}
-
+
/* NEW LANGUAGE NOTE:***********************************************
- register the function in SWIG
- different language mappings seem to use different ideas
- NEW LANGUAGE NOTE:END ************************************************/
+ register the function in SWIG
+ different language mappings seem to use different ideas
+ NEW LANGUAGE NOTE:END *********************************************** */
/* Now register the function with the interpreter. */
- if (!Getattr(n, "sym:overloaded")) {
- //REPORT("dispatchFunction", n);
- // add_method(n, iname, wname, description);
- if (current==NO_CPP || current==STATIC_FUNC) { // emit normal fns & static fns
- String *wrapname = Swig_name_wrapper(iname);
- if(elua_ltr || eluac_ltr)
- Printv(s_cmd_tab, tab4, "{LSTRKEY(\"", iname, "\")", ", LFUNCVAL(", Swig_name_wrapper(iname), ")", "},\n", NIL);
- else
- Printv(s_cmd_tab, tab4, "{ \"", iname, "\", ", Swig_name_wrapper(iname), "},\n", NIL);
- // Printv(s_cmd_tab, tab4, "{ SWIG_prefix \"", iname, "\", (swig_wrapper_func) ", Swig_name_wrapper(iname), "},\n", NIL);
- if (getCurrentClass()) {
- Setattr(n,"luaclassobj:wrap:name", wrapname);
- }
- }
- } else {
+ int result = SWIG_OK;
+ if (Getattr(n, "sym:overloaded")) {
if (!Getattr(n, "sym:nextSibling")) {
- dispatchFunction(n);
+ result = dispatchFunction(n);
}
}
Delete(cleanup);
Delete(outarg);
// Delete(description);
- Delete(wname);
DelWrapper(f);
- return SWIG_OK;
+ return result;
}
/* ------------------------------------------------------------
* ------------------------------------------------------------ */
/* NEW LANGUAGE NOTE:***********************************************
- This is an extra function used for overloading of functions
- it checks the args & then calls the relevant fn
- nost of the real work in again typemaps:
- look for %typecheck(SWIG_TYPECHECK_*) in the .swg file
- NEW LANGUAGE NOTE:END ************************************************/
- void dispatchFunction(Node *n) {
+ This is an extra function used for overloading of functions
+ it checks the args & then calls the relevant fn
+ most of the real work in again typemaps:
+ look for %typecheck(SWIG_TYPECHECK_*) in the .swg file
+ NEW LANGUAGE NOTE:END *********************************************** */
+ int dispatchFunction(Node *n) {
//REPORT("dispatchFunction", n);
/* Last node in overloaded chain */
Wrapper *f = NewWrapper();
String *symname = Getattr(n, "sym:name");
+ String *lua_name = Getattr(n, "lua:name");
+ assert(lua_name);
String *wname = Swig_name_wrapper(symname);
//Printf(stdout,"Swig_overload_dispatch %s %s '%s' %d\n",symname,wname,dispatch,maxargs);
+ if (!luaAddSymbol(lua_name, n)) {
+ return SWIG_ERROR;
+ }
+
Printv(f->def, "static int ", wname, "(lua_State* L) {", NIL);
Wrapper_add_local(f, "argc", "int argc");
Printf(tmp, "int argv[%d]={1", maxargs + 1);
Replaceall(dispatch, "$args", "self,args");
Printv(f->code, dispatch, "\n", NIL);
-
+
Node *sibl = n;
while (Getattr(sibl, "sym:previousSibling"))
sibl = Getattr(sibl, "sym:previousSibling"); // go all the way up
Delete(fulldecl);
} while ((sibl = Getattr(sibl, "sym:nextSibling")));
Printf(f->code, "SWIG_Lua_pusherrstring(L,\"Wrong arguments for overloaded function '%s'\\n\"\n"
- "\" Possible C/C++ prototypes are:\\n\"%s);\n",symname,protoTypes);
+ "\" Possible C/C++ prototypes are:\\n\"%s);\n", symname, protoTypes);
Delete(protoTypes);
Printf(f->code, "lua_error(L);return 0;\n");
Printv(f->code, "}\n", NIL);
Wrapper_print(f, f_wrappers);
- //add_method(symname,wname,0);
- if (current==NO_CPP || current==STATIC_FUNC) // emit normal fns & static fns
- Printv(s_cmd_tab, tab4, "{ \"", symname, "\",", wname, "},\n", NIL);
- if (getCurrentClass())
- Setattr(n,"luaclassobj:wrap:name", wname);
- else
- Delete(wname);
+ // Remember C name of the wrapping function
+ Setattr(n, "wrap:name", wname);
+
+ if (current[CONSTRUCTOR]) {
+ if (constructor_name != 0)
+ Delete(constructor_name);
+ constructor_name = Copy(wname);
+ }
DelWrapper(f);
Delete(dispatch);
Delete(tmp);
+
+ return SWIG_OK;
}
+ /* ------------------------------------------------------------
+ * Add variable to "attributes" C arrays of given namespace or class.
+ * Input is node. Based on the state of "current" array it determines
+ * the name of the getter function, setter function etc and calls
+ * registerVariable overload with necessary params.
+ * Lua scope could be overwritten. (Used only for backward compatibility)
+ * ------------------------------------------------------------ */
+
+ void registerVariable(Node *n, bool overwrite = false, String *overwriteLuaScope = 0) {
+ int assignable = is_assignable(n);
+ String *symname = Getattr(n, "sym:name");
+ assert(symname);
+
+ // Lua scope. It is not symbol NSpace, it is the actual key to retrieve getCArraysHash.
+ String *luaScope = luaCurrentSymbolNSpace();
+ if (overwrite)
+ luaScope = overwriteLuaScope;
+
+ // Getter and setter
+ String *getName = 0;
+ String *setName = 0;
+ String *mrename = 0;
+ if (current[NO_CPP] || !getCurrentClass()) {
+ // Global variable
+ getName = Swig_name_get(getNSpace(), symname);
+ if (assignable)
+ setName = Swig_name_set(getNSpace(), symname);
+ } else {
+ assert(!current[NO_CPP]);
+ if (current[STATIC_VAR] ) {
+ mrename = Swig_name_member(getNSpace(), getClassPrefix(), symname);
+ getName = Swig_name_get(0, mrename);
+ if (assignable)
+ setName = Swig_name_set(0, mrename);
+ } else if (current[MEMBER_VAR]) {
+ mrename = Swig_name_member(0, getClassPrefix(), symname);
+ getName = Swig_name_get(getNSpace(), mrename);
+ if (assignable)
+ setName = Swig_name_set(getNSpace(), mrename);
+ } else {
+ assert(false);
+ }
+ }
+
+ getName = Swig_name_wrapper(getName);
+ if (setName)
+ setName = Swig_name_wrapper(setName);
+ registerVariable(luaScope, n, getName, setName);
+ }
+
+ /* ------------------------------------------------------------
+ * registerVariable()
+ *
+ * Add variable to the "attributes" (or "get"/"set" in
+ * case of elua_ltr) C arrays of given namespace or class
+ * ------------------------------------------------------------ */
+
+ void registerVariable(String *lua_nspace_or_class_name, Node *n, String *getName, String *setName) {
+ String *unassignable = NewString("SWIG_Lua_set_immutable");
+ if (setName == 0 || GetFlag(n, "feature:immutable")) {
+ setName = unassignable;
+ }
+ Hash *nspaceHash = getCArraysHash(lua_nspace_or_class_name);
+ String *s_ns_methods_tab = Getattr(nspaceHash, "methods");
+ String *s_ns_var_tab = Getattr(nspaceHash, "attributes");
+ String *lua_name = Getattr(n, "lua:name");
+ if (elua_ltr) {
+ String *s_ns_dot_get = Getattr(nspaceHash, "get");
+ String *s_ns_dot_set = Getattr(nspaceHash, "set");
+ Printf(s_ns_dot_get, "%s{LSTRKEY(\"%s\"), LFUNCVAL(%s)},\n", tab4, lua_name, getName);
+ Printf(s_ns_dot_set, "%s{LSTRKEY(\"%s\"), LFUNCVAL(%s)},\n", tab4, lua_name, setName);
+ } else if (eluac_ltr) {
+ Printv(s_ns_methods_tab, tab4, "{LSTRKEY(\"", lua_name, "_get", "\")", ", LFUNCVAL(", getName, ")", "},\n", NIL);
+ Printv(s_ns_methods_tab, tab4, "{LSTRKEY(\"", lua_name, "_set", "\")", ", LFUNCVAL(", setName, ")", "},\n", NIL);
+ } else {
+ Printf(s_ns_var_tab, "%s{ \"%s\", %s, %s },\n", tab4, lua_name, getName, setName);
+ }
+ }
/* ------------------------------------------------------------
* variableWrapper()
virtual int variableWrapper(Node *n) {
/* NEW LANGUAGE NOTE:***********************************************
- Language::variableWrapper(n) will generate two wrapper fns
- Foo_get & Foo_set by calling functionWrapper()
- so we will just add these into the variable lists
- ideally we should not have registered these as functions,
- only WRT this variable will look into this later.
- NEW LANGUAGE NOTE:END ************************************************/
+ Language::variableWrapper(n) will generate two wrapper fns
+ Foo_get & Foo_set by calling functionWrapper()
+ so we will just add these into the variable lists
+ ideally we should not have registered these as functions,
+ only WRT this variable will look into this later.
+ NEW LANGUAGE NOTE:END *********************************************** */
// REPORT("variableWrapper", n);
- String *iname = Getattr(n, "sym:name");
- current=VARIABLE;
+ String *lua_name = Getattr(n, "lua:name");
+ assert(lua_name);
+ current[VARIABLE] = true;
// let SWIG generate the wrappers
int result = Language::variableWrapper(n);
- current=NO_CPP;
- // normally SWIG will generate 2 wrappers, a get and a set
- // but in certain scenarios (immutable, or if its arrays), it will not
- String *getName = Swig_name_wrapper(Swig_name_get(NSPACE_TODO, iname));
- String *setName = 0;
- // checking whether it can be set to or not appears to be a very error prone issue
- // I referred to the Language::variableWrapper() to find this out
- bool assignable=is_assignable(n) ? true : false;
- SwigType *type = Getattr(n, "type");
- String *tm = Swig_typemap_lookup("globalin", n, iname, 0);
- if (!tm && SwigType_isarray(type))
- assignable=false;
- Delete(tm);
+
+ // It is impossible to use registerVariable, because sym:name of the Node is currently
+ // in an undefined state - the callees of this function may have modified it.
+ // registerVariable should be used from respective callees.*
+ current[VARIABLE] = false;
+ return result;
+ }
- if (assignable) {
- setName = Swig_name_wrapper(Swig_name_set(NSPACE_TODO, iname));
- } else {
- // how about calling a 'this is not settable' error message?
- setName = NewString("SWIG_Lua_set_immutable"); // error message
- //setName = NewString("0");
- }
- // register the variable
- if (elua_ltr) {
- Printf(s_dot_get, "%s{LSTRKEY(\"%s\"), LFUNCVAL(%s)},\n", tab4, iname, getName);
- Printf(s_dot_set, "%s{LSTRKEY(\"%s\"), LFUNCVAL(%s)},\n", tab4, iname, setName);
- } else if (eluac_ltr) {
- Printv(s_cmd_tab, tab4, "{LSTRKEY(\"", iname, "_get", "\")", ", LFUNCVAL(", getName, ")", "},\n", NIL);
- Printv(s_cmd_tab, tab4, "{LSTRKEY(\"", iname, "_set", "\")", ", LFUNCVAL(", setName, ")", "},\n", NIL);
- } else {
- Printf(s_var_tab, "%s{ \"%s\", %s, %s },\n", tab4, iname, getName, setName);
- }
- if (getCurrentClass()) {
- Setattr(n, "luaclassobj:wrap:get", getName);
- Setattr(n, "luaclassobj:wrap:set", setName);
- } else {
- Delete(getName);
- Delete(setName);
+ /* ------------------------------------------------------------
+ * Add constant to appropriate C array. constantRecord is an array record.
+ * Actually, in current implementation it is resolved consttab typemap
+ * ------------------------------------------------------------ */
+
+ void registerConstant(String *nspace, String *constantRecord) {
+ Hash *nspaceHash = getCArraysHash(nspace);
+ String *s_const_tab = 0;
+ if (eluac_ltr || elua_ltr)
+ // In elua everything goes to "methods" tab
+ s_const_tab = Getattr(nspaceHash, "methods");
+ else
+ s_const_tab = Getattr(nspaceHash, "constants");
+
+ assert(s_const_tab);
+ Printf(s_const_tab, " %s,\n", constantRecord);
+
+ if ((eluac_ltr || elua_ltr) && old_metatable_bindings) {
+ s_const_tab = Getattr(nspaceHash, "constants");
+ assert(s_const_tab);
+ Printf(s_const_tab, " %s,\n", constantRecord);
}
- return result;
+
}
/* ------------------------------------------------------------
* constantWrapper()
* ------------------------------------------------------------ */
+
virtual int constantWrapper(Node *n) {
REPORT("constantWrapper", n);
String *name = Getattr(n, "name");
String *iname = Getattr(n, "sym:name");
+ String *lua_name = Getattr(n, "lua:name");
+ if (lua_name == 0)
+ lua_name = iname;
String *nsname = Copy(iname);
SwigType *type = Getattr(n, "type");
String *rawval = Getattr(n, "rawval");
String *value = rawval ? rawval : Getattr(n, "value");
String *tm;
+ String *lua_name_v2 = 0;
+ String *tm_v2 = 0;
+ String *iname_v2 = 0;
+ Node *n_v2 = 0;
- if (!addSymbol(iname, n))
+ if (!luaAddSymbol(lua_name, n))
return SWIG_ERROR;
+ Swig_save("lua_constantMember", n, "sym:name", NIL);
+ Setattr(n, "sym:name", lua_name);
/* Special hook for member pointer */
if (SwigType_type(type) == T_MPOINTER) {
String *wname = Swig_name_wrapper(iname);
if ((tm = Swig_typemap_lookup("consttab", n, name, 0))) {
Replaceall(tm, "$source", value);
- Replaceall(tm, "$target", name);
+ Replaceall(tm, "$target", lua_name);
Replaceall(tm, "$value", value);
Replaceall(tm, "$nsname", nsname);
- Printf(s_const_tab, " %s,\n", tm);
+ registerConstant(luaCurrentSymbolNSpace(), tm);
} else if ((tm = Swig_typemap_lookup("constcode", n, name, 0))) {
Replaceall(tm, "$source", value);
- Replaceall(tm, "$target", name);
+ Replaceall(tm, "$target", lua_name);
Replaceall(tm, "$value", value);
Replaceall(tm, "$nsname", nsname);
Printf(f_init, "%s\n", tm);
} else {
Delete(nsname);
+ nsname = 0;
Swig_warning(WARN_TYPEMAP_CONST_UNDEF, input_file, line_number, "Unsupported constant value.\n");
+ Swig_restore(n);
return SWIG_NOWRAP;
}
- if (cparse_cplusplus && getCurrentClass()) {
- // Additionally add to class constants
- Swig_require("luaclassobj_constantWrapper", n, "*sym:name", "luaclassobj:symname", NIL);
- Setattr(n, "sym:name", Getattr(n, "luaclassobj:symname"));
- String *cls_nsname = Getattr(n, "sym:name");
- if ((tm = Swig_typemap_lookup("consttab", n, name, 0))) {
- Replaceall(tm, "$source", value);
- Replaceall(tm, "$target", name);
- Replaceall(tm, "$value", value);
- Replaceall(tm, "$nsname", cls_nsname);
- Printf(s_cls_const_tab, " %s,\n", tm);
+
+ bool make_v2_compatible = old_metatable_bindings && getCurrentClass() && old_compatible_names;
+
+ if (make_v2_compatible) {
+ // Don't do anything for enums in C mode - they are already
+ // wrapped correctly
+ if (CPlusPlus || !current[ENUM_CONST]) {
+ lua_name_v2 = Swig_name_member(0, proxy_class_name, lua_name);
+ iname_v2 = Swig_name_member(0, proxy_class_name, iname);
+ n_v2 = Copy(n);
+ if (!luaAddSymbol(iname_v2, n, getNSpace())) {
+ Swig_restore(n);
+ return SWIG_ERROR;
+ }
+
+ Setattr(n_v2, "sym:name", lua_name_v2);
+ tm_v2 = Swig_typemap_lookup("consttab", n_v2, name, 0);
+ if (tm_v2) {
+ Replaceall(tm_v2, "$source", value);
+ Replaceall(tm_v2, "$target", lua_name_v2);
+ Replaceall(tm_v2, "$value", value);
+ Replaceall(tm_v2, "$nsname", nsname);
+ registerConstant(getNSpace(), tm_v2);
+ } else {
+ tm_v2 = Swig_typemap_lookup("constcode", n_v2, name, 0);
+ if (!tm_v2) {
+ // This can't be.
+ assert(false);
+ Swig_restore(n);
+ return SWIG_ERROR;
+ }
+ Replaceall(tm_v2, "$source", value);
+ Replaceall(tm_v2, "$target", lua_name_v2);
+ Replaceall(tm_v2, "$value", value);
+ Replaceall(tm_v2, "$nsname", nsname);
+ Printf(f_init, "%s\n", tm_v2);
+ }
+ Delete(n_v2);
}
- Swig_restore(n);
}
+
+ Swig_restore(n);
Delete(nsname);
return SWIG_OK;
}
// REPORT("nativeWrapper", n);
String *symname = Getattr(n, "sym:name");
String *wrapname = Getattr(n, "wrap:name");
- if (!addSymbol(wrapname, n))
+ if (!luaAddSymbol(wrapname, n))
return SWIG_ERROR;
- Printv(s_cmd_tab, tab4, "{ \"", symname, "\",", wrapname, "},\n", NIL);
+ Hash *nspaceHash = getCArraysHash(getNSpace());
+ String *s_ns_methods_tab = Getattr(nspaceHash, "methods");
+ Printv(s_ns_methods_tab, tab4, "{ \"", symname, "\",", wrapname, "},\n", NIL);
// return Language::nativeWrapper(n); // this does nothing...
return SWIG_OK;
}
* ------------------------------------------------------------ */
virtual int enumDeclaration(Node *n) {
- return Language::enumDeclaration(n);
+ if (getCurrentClass() && (cplus_mode != PUBLIC))
+ return SWIG_NOWRAP;
+
+ current[STATIC_CONST] = true;
+ current[ENUM_CONST] = true;
+ // There is some slightly specific behaviour with enums. Basically,
+ // their NSpace may be tracked separately. The code below tries to work around
+ // this issue to some degree.
+ // The idea is the same as in classHandler - to drop old names generation if
+ // enum is in class in namespace.
+ const int old_compatible_names_saved = old_compatible_names;
+ if (getNSpace() || ( Getattr(n, "sym:nspace") != 0 && Len(Getattr(n, "sym:nspace")) > 0 ) ) {
+ old_compatible_names = 0;
+ }
+ int result = Language::enumDeclaration(n);
+ current[STATIC_CONST] = false;
+ current[ENUM_CONST] = false;
+ old_compatible_names = old_compatible_names_saved;
+ return result;
}
/* ------------------------------------------------------------
* ------------------------------------------------------------ */
virtual int enumvalueDeclaration(Node *n) {
- return Language::enumvalueDeclaration(n);
+ if (getCurrentClass() && (cplus_mode != PUBLIC))
+ return SWIG_NOWRAP;
+
+ Swig_require("enumvalueDeclaration", n, "*name", "?value", "*sym:name", NIL);
+ String *symname = Getattr(n, "sym:name");
+ String *value = Getattr(n, "value");
+ String *name = Getattr(n, "name");
+ String *tmpValue;
+ Node *parent = parentNode(n);
+
+ if (value)
+ tmpValue = NewString(value);
+ else
+ tmpValue = NewString(name);
+ Setattr(n, "value", tmpValue);
+
+ Setattr(n, "name", tmpValue); /* for wrapping of enums in a namespace when emit_action is used */
+
+ if (GetFlag(parent, "scopedenum")) {
+ symname = Swig_name_member(0, Getattr(parent, "sym:name"), symname);
+ Setattr(n, "sym:name", symname);
+ Delete(symname);
+ }
+
+ int result = constantWrapper(n);
+
+ Delete(tmpValue);
+ Swig_restore(n);
+ return result;
}
/* ------------------------------------------------------------
return Language::classDeclaration(n);
}
+
+ /* ------------------------------------------------------------
+ * Helper function that adds record to appropriate C arrays
+ * ------------------------------------------------------------ */
+
+ void registerClass(String *scope, String *wrap_class) {
+ assert(wrap_class);
+ Hash *nspaceHash = getCArraysHash(scope);
+ String *ns_classes = Getattr(nspaceHash, "classes");
+ Printv(ns_classes, "&", wrap_class, ",\n", NIL);
+ if (elua_ltr || eluac_ltr) {
+ String *ns_methods = Getattr(nspaceHash, "methods");
+ Hash *class_hash = getCArraysHash(class_static_nspace);
+ assert(class_hash);
+ String *cls_methods = Getattr(class_hash, "methods:name");
+ assert(cls_methods);
+ Printv(ns_methods, tab4, "{LSTRKEY(\"", proxy_class_name, "\")", ", LROVAL(", cls_methods, ")", "},\n", NIL);
+ }
+ }
+
/* ------------------------------------------------------------
* classHandler()
* ------------------------------------------------------------ */
virtual int classHandler(Node *n) {
//REPORT("classHandler", n);
- String *mangled_classname = 0;
- String *real_classname = 0;
+ String *mangled_full_proxy_class_name = 0;
+ String *destructor_name = 0;
+ String *nspace = getNSpace();
constructor_name = 0;
have_constructor = 0;
have_destructor = 0;
destructor_action = 0;
+ assert(class_static_nspace == 0);
+ assert(full_proxy_class_name == 0);
+ assert(proxy_class_name == 0);
- class_name = Getattr(n, "sym:name");
- if (!addSymbol(class_name, n))
+ current[NO_CPP] = false;
+
+ proxy_class_name = Getattr(n, "sym:name");
+ // We have to enforce nspace here, because technically we are already
+ // inside class parsing (getCurrentClass != 0), but we should register
+ // class in its parent namespace
+ if (!luaAddSymbol(proxy_class_name, n, nspace))
return SWIG_ERROR;
- real_classname = Getattr(n, "name");
- mangled_classname = Swig_name_mangle(real_classname);
+ if (nspace == 0)
+ full_proxy_class_name = NewStringf("%s", proxy_class_name);
+ else
+ full_proxy_class_name = NewStringf("%s.%s", nspace, proxy_class_name);
+
+ assert(full_proxy_class_name);
+ mangled_full_proxy_class_name = Swig_name_mangle(full_proxy_class_name);
+ SwigType *t = Copy(Getattr(n, "name"));
+ SwigType *fr_t = SwigType_typedef_resolve_all(t); /* Create fully resolved type */
+ SwigType *t_tmp = 0;
+ t_tmp = SwigType_typedef_qualified(fr_t); // Temporal variable
+ Delete(fr_t);
+ fr_t = SwigType_strip_qualifiers(t_tmp);
+ String *mangled_fr_t = 0;
+ mangled_fr_t = SwigType_manglestr(fr_t);
// not sure exactly how this works,
// but tcl has a static hashtable of all classes emitted and then only emits code for them once.
// this fixes issues in test suites: template_default2 & template_specialization
// * consider effect on template_specialization_defarg
static Hash *emitted = NewHash();
- if (Getattr(emitted, mangled_classname))
+ if (GetFlag(emitted, mangled_fr_t)) {
+ full_proxy_class_name = 0;
+ proxy_class_name = 0;
return SWIG_NOWRAP;
- Setattr(emitted, mangled_classname, "1");
-
- s_attr_tab = NewString("");
- Printf(s_attr_tab, "static swig_lua_attribute swig_");
- Printv(s_attr_tab, mangled_classname, "_attributes[] = {\n", NIL);
-
- s_methods_tab = NewString("");
- Printf(s_methods_tab, "static swig_lua_method swig_");
- Printv(s_methods_tab, mangled_classname, "_methods[] = {\n", NIL);
-
- s_cls_methods_tab = NewString("");
- Printf(s_cls_methods_tab, "static swig_lua_method swig_");
- Printv(s_cls_methods_tab, mangled_classname, "_cls_methods[] = {\n", NIL);
-
- s_cls_attr_tab = NewString("");
- Printf(s_cls_attr_tab, "static swig_lua_attribute swig_");
- Printv(s_cls_attr_tab, mangled_classname, "_cls_attributes[] = {\n", NIL);
-
- s_cls_const_tab = NewString("");
- Printf(s_cls_const_tab, "static swig_lua_const_info swig_");
- Printv(s_cls_const_tab, mangled_classname, "_cls_constants[] = {\n", NIL);
-
+ }
+ SetFlag(emitted, mangled_fr_t);
+
+ // We treat class T as both 'class' and 'namespace'. All static members, attributes
+ // and constants are considered part of namespace T, all members - part of the 'class'
+ // Now, here is a trick. Static methods, attributes and non-static methods and attributes
+ // are described with same structures - swig_lua_attribute/swig_lua_method. Instead of calling
+ // getCArraysHash(class name) to initialize things for static methods/attributes and then
+ // manually doing same initialization for non-static methods, we call getCArraysHash 2 times:
+ // 1) With name "class name" + "." + "SwigStatic" to initialize static things
+ // 2) With "class name" to initialize non-static things
+ Hash *instance_cls = getCArraysHash(full_proxy_class_name, false);
+ assert(instance_cls);
+ String *s_attr_tab_name = Getattr(instance_cls, "attributes:name");
+ String *s_methods_tab_name = Getattr(instance_cls, "methods:name");
+ SetFlag(instance_cls, "lua:no_namespaces");
+ SetFlag(instance_cls, "lua:no_classes");
+ SetFlag(instance_cls, "lua:class_instance");
+
+ /* There is no use for "constants", "classes" and "namespaces" arrays.
+ * All constants are considered part of static part of class.
+ */
+
+ class_static_nspace = NewStringf("%s%sSwigStatic", full_proxy_class_name, NSPACE_SEPARATOR);
+ Hash *static_cls = getCArraysHash(class_static_nspace, false);
+ assert(static_cls);
+ SetFlag(static_cls, "lua:no_namespaces");
+ SetFlag(static_cls, "lua:class_static");
+
+ // Notifying instance_cls and static_cls hashes about each other
+ Setattr(instance_cls, "lua:class_instance:static_hash", static_cls);
+ Setattr(static_cls, "lua:class_static:instance_hash", instance_cls);
+
+ const int old_compatible_names_saved = old_compatible_names;
+ // If class has %nspace enabled, then generation of backward compatible names
+ // should be disabled
+ if (getNSpace()) {
+ old_compatible_names = 0;
+ }
+ /* There is no use for "classes" and "namespaces" arrays. Subclasses are not supported
+ * by SWIG and namespaces couldn't be nested inside classes (C++ Standard)
+ */
// Generate normal wrappers
Language::classHandler(n);
- SwigType *t = Copy(Getattr(n, "name"));
+ old_compatible_names = old_compatible_names_saved;
+
SwigType_add_pointer(t);
// Catch all: eg. a class with only static functions and/or variables will not have 'remembered'
- String *wrap_class = NewStringf("&_wrap_class_%s", mangled_classname);
+ String *wrap_class_name = Swig_name_wrapper(NewStringf("class_%s", mangled_full_proxy_class_name));
+ String *wrap_class = NewStringf("&%s", wrap_class_name);
SwigType_remember_clientdata(t, wrap_class);
String *rt = Copy(getClassType());
SwigType_add_pointer(rt);
+ // Adding class to apropriate namespace
+ registerClass(nspace, wrap_class_name);
+ Hash *nspaceHash = getCArraysHash(nspace);
+
// Register the class structure with the type checker
- // Printf(f_init,"SWIG_TypeClientData(SWIGTYPE%s, (void *) &_wrap_class_%s);\n", SwigType_manglestr(t), mangled_classname);
-
+ // Printf(f_init,"SWIG_TypeClientData(SWIGTYPE%s, (void *) &_wrap_class_%s);\n", SwigType_manglestr(t), mangled_full_proxy_class_name);
+
// emit a function to be called to delete the object
if (have_destructor) {
- Printv(f_wrappers, "static void swig_delete_", class_name, "(void *obj) {\n", NIL);
+ destructor_name = NewStringf("swig_delete_%s", mangled_full_proxy_class_name);
+ Printv(f_wrappers, "static void ", destructor_name, "(void *obj) {\n", NIL);
if (destructor_action) {
- Printv(f_wrappers, SwigType_str(rt, "arg1"), " = (", SwigType_str(rt, 0), ") obj;\n", NIL);
- Printv(f_wrappers, destructor_action, "\n", NIL);
+ Printv(f_wrappers, SwigType_str(rt, "arg1"), " = (", SwigType_str(rt, 0), ") obj;\n", NIL);
+ Printv(f_wrappers, destructor_action, "\n", NIL);
} else {
- if (CPlusPlus) {
- Printv(f_wrappers, " delete (", SwigType_str(rt, 0), ") obj;\n", NIL);
- } else {
- Printv(f_wrappers, " free((char *) obj);\n", NIL);
- }
+ if (CPlusPlus) {
+ Printv(f_wrappers, " delete (", SwigType_str(rt, 0), ") obj;\n", NIL);
+ } else {
+ Printv(f_wrappers, " free((char *) obj);\n", NIL);
+ }
}
Printf(f_wrappers, "}\n");
}
+ // Wrap constructor wrapper into one more proxy function. It will be used as class namespace __call method, thus
+ // allowing both
+ // Module.ClassName.StaticMethod to access static method/variable/constant
+ // Module.ClassName() to create new object
+ if (have_constructor) {
+ assert(constructor_name);
+ String *constructor_proxy_name = NewStringf("_proxy_%s", constructor_name);
+ Printv(f_wrappers, "static int ", constructor_proxy_name, "(lua_State *L) {\n", NIL);
+ Printv(f_wrappers,
+ tab4, "assert(lua_istable(L,1));\n",
+ tab4, "lua_pushcfunction(L,", constructor_name, ");\n",
+ tab4, "assert(!lua_isnil(L,-1));\n",
+ tab4, "lua_replace(L,1); /* replace our table with real constructor */\n",
+ tab4, "lua_call(L,lua_gettop(L)-1,1);\n",
+ tab4, "return 1;\n}\n", NIL);
+ Delete(constructor_name);
+ constructor_name = constructor_proxy_name;
+ if (elua_ltr) {
+ String *static_cls_metatable_tab = Getattr(static_cls, "metatable");
+ assert(static_cls_metatable_tab);
+ Printf(static_cls_metatable_tab, " {LSTRKEY(\"__call\"), LFUNCVAL(%s)},\n", constructor_name);
+ } else if (eluac_ltr) {
+ String *ns_methods_tab = Getattr(nspaceHash, "methods");
+ assert(ns_methods_tab);
+ Printv(ns_methods_tab, tab4, "{LSTRKEY(\"", "new_", proxy_class_name, "\")", ", LFUNCVAL(", constructor_name, ")", "},\n", NIL);
+ }
+ }
+ if (have_destructor) {
+ if (eluac_ltr) {
+ String *ns_methods_tab = Getattr(nspaceHash, "methods");
+ assert(ns_methods_tab);
+ Printv(ns_methods_tab, tab4, "{LSTRKEY(\"", "free_", mangled_full_proxy_class_name, "\")", ", LFUNCVAL(", destructor_name, ")", "},\n", NIL);
+ }
+ }
- Printf(s_methods_tab, " {0,0}\n};\n");
- Printv(f_wrappers, s_methods_tab, NIL);
-
- Printf(s_attr_tab, " {0,0,0}\n};\n");
- Printv(f_wrappers, s_attr_tab, NIL);
-
- Printf(s_cls_attr_tab, " {0,0,0}\n};\n");
- Printv(f_wrappers, s_cls_attr_tab, NIL);
-
- Printf(s_cls_methods_tab, " {0,0}\n};\n");
- Printv(f_wrappers, s_cls_methods_tab, NIL);
-
- Printf(s_cls_const_tab, " {0,0,0,0,0,0}\n};\n");
- Printv(f_wrappers, s_cls_const_tab, NIL);
-
+ closeCArraysHash(full_proxy_class_name, f_wrappers);
+ closeCArraysHash(class_static_nspace, f_wrappers);
- Delete(s_methods_tab);
- Delete(s_attr_tab);
- Delete(s_cls_methods_tab);
- Delete(s_cls_attr_tab);
- Delete(s_cls_const_tab);
// Handle inheritance
// note: with the idea of class hierarchies spread over multiple modules
int index = 0;
b = First(baselist);
while (b.item) {
- String *bname = Getattr(b.item, "name");
- if ((!bname) || GetFlag(b.item, "feature:ignore") || (!Getattr(b.item, "module"))) {
- b = Next(b);
- continue;
- }
- // old code: (used the pointer to the base class)
- //String *bmangle = Swig_name_mangle(bname);
- //Printf(base_class, "&_wrap_class_%s", bmangle);
- //Putc(',', base_class);
- //Delete(bmangle);
- // new code: stores a null pointer & the name
- Printf(base_class, "0,");
- Printf(base_class_names, "\"%s *\",", SwigType_namestr(bname));
-
- b = Next(b);
- index++;
+ String *bname = Getattr(b.item, "name");
+ if ((!bname) || GetFlag(b.item, "feature:ignore") || (!Getattr(b.item, "module"))) {
+ b = Next(b);
+ continue;
+ }
+ // stores a null pointer & the name
+ Printf(base_class, "0,");
+ Printf(base_class_names, "\"%s *\",", SwigType_namestr(bname));
+
+ b = Next(b);
+ index++;
}
}
-
- Printv(f_wrappers, "static swig_lua_class *swig_", mangled_classname, "_bases[] = {", base_class, "0};\n", NIL);
+ // First, print class static part
+ printCArraysDefinition(class_static_nspace, proxy_class_name, f_wrappers);
+
+ assert(mangled_full_proxy_class_name);
+ assert(base_class);
+ assert(base_class_names);
+ assert(proxy_class_name);
+ assert(full_proxy_class_name);
+
+ // Then print class isntance part
+ Printv(f_wrappers, "static swig_lua_class *swig_", mangled_full_proxy_class_name, "_bases[] = {", base_class, "0};\n", NIL);
Delete(base_class);
- Printv(f_wrappers, "static const char *swig_", mangled_classname, "_base_names[] = {", base_class_names, "0};\n", NIL);
+ Printv(f_wrappers, "static const char *swig_", mangled_full_proxy_class_name, "_base_names[] = {", base_class_names, "0};\n", NIL);
Delete(base_class_names);
- Printv(f_wrappers, "static swig_lua_class _wrap_class_", mangled_classname, " = { \"", class_name, "\", &SWIGTYPE", SwigType_manglestr(t), ",", NIL);
+ Printv(f_wrappers, "static swig_lua_class _wrap_class_", mangled_full_proxy_class_name, " = { \"", proxy_class_name, "\", \"", full_proxy_class_name, "\", &SWIGTYPE",
+ SwigType_manglestr(t), ",", NIL);
if (have_constructor) {
- if (elua_ltr) {
- Printf(s_cmd_tab, " {LSTRKEY(\"%s\"), LFUNCVAL(%s)},\n", class_name, \
- Swig_name_wrapper(Swig_name_construct(NSPACE_TODO, constructor_name)));
- Printf(f_wrappers, "%s", Swig_name_wrapper(Swig_name_construct(NSPACE_TODO, constructor_name)));
- } else if (eluac_ltr) {
- Printv(s_cmd_tab, tab4, "{LSTRKEY(\"", "new_", class_name, "\")", ", LFUNCVAL(", \
- Swig_name_wrapper(Swig_name_construct(NSPACE_TODO, constructor_name)), ")", "},\n", NIL);
- Printf(f_wrappers, "%s", Swig_name_wrapper(Swig_name_construct(NSPACE_TODO, constructor_name)));
- } else {
- Printf(f_wrappers, "%s", Swig_name_wrapper(Swig_name_construct(NSPACE_TODO, constructor_name)));
- }
+ Printv(f_wrappers, constructor_name, NIL);
Delete(constructor_name);
constructor_name = 0;
} else {
}
if (have_destructor) {
- if (eluac_ltr) {
- Printv(s_cmd_tab, tab4, "{LSTRKEY(\"", "free_", class_name, "\")", ", LFUNCVAL(", "swig_delete_", class_name, ")", "},\n", NIL);
- Printv(f_wrappers, ", swig_delete_", class_name, NIL);
- } else {
- Printv(f_wrappers, ", swig_delete_", class_name, NIL);
- }
+ Printv(f_wrappers, ", ", destructor_name, NIL);
} else {
Printf(f_wrappers, ",0");
}
- Printf(f_wrappers, ", swig_%s_methods, swig_%s_attributes, { \"%s\", swig_%s_cls_methods, swig_%s_cls_attributes, swig_%s_cls_constants }, swig_%s_bases, swig_%s_base_names };\n\n",
- mangled_classname, mangled_classname,
- class_name, mangled_classname, mangled_classname, mangled_classname,
- mangled_classname, mangled_classname);
-
- // Printv(f_wrappers, ", swig_", mangled_classname, "_methods, swig_", mangled_classname, "_attributes, swig_", mangled_classname, "_bases };\n\n", NIL);
- // Printv(s_cmd_tab, tab4, "{ SWIG_prefix \"", class_name, "\", (swig_wrapper_func) SWIG_ObjectConstructor, &_wrap_class_", mangled_classname, "},\n", NIL);
- Delete(t);
- Delete(mangled_classname);
+ Printf(f_wrappers, ", %s, %s, &%s", s_methods_tab_name, s_attr_tab_name, Getattr(static_cls, "cname"));
+
+ if (!eluac_ltr) {
+ Printf(f_wrappers, ", %s", Getattr(instance_cls,"metatable:name"));
+ }
+ else
+ Printf(f_wrappers, ", 0");
+
+ Printf(f_wrappers, ", swig_%s_bases, swig_%s_base_names };\n\n", mangled_full_proxy_class_name, mangled_full_proxy_class_name);
+
+ current[NO_CPP] = true;
+ Delete(class_static_nspace);
+ class_static_nspace = 0;
+ Delete(mangled_full_proxy_class_name);
+ mangled_full_proxy_class_name = 0;
+ Delete(destructor_name);
+ destructor_name = 0;
+ Delete(full_proxy_class_name);
+ full_proxy_class_name = 0;
+ proxy_class_name = 0;
return SWIG_OK;
}
* ------------------------------------------------------------ */
virtual int memberfunctionHandler(Node *n) {
- String *name = Getattr(n, "name");
- String *iname = GetChar(n, "sym:name");
+ String *symname = GetChar(n, "sym:name");
//Printf(stdout,"memberfunctionHandler %s %s\n",name,iname);
// Special case unary minus: LUA passes two parameters for the
// wrapper function while we want only one. Tell our
// functionWrapper to ignore a parameter.
- if (Cmp(Getattr(n, "sym:name"), "__unm") == 0) {
+ if (Cmp(symname, "__unm") == 0) {
//Printf(stdout, "unary minus: ignore one argument\n");
SetInt(n, "lua:ignore_args", 1);
}
- String *realname, *rname;
-
- current = MEMBER_FUNC;
+ current[MEMBER_FUNC] = true;
Language::memberfunctionHandler(n);
- current = NO_CPP;
- realname = iname ? iname : name;
- rname = Swig_name_wrapper(Swig_name_member(NSPACE_TODO, class_name, realname));
- if (!Getattr(n, "sym:nextSibling")) {
- Printv(s_methods_tab, tab4, "{\"", realname, "\", ", rname, "}, \n", NIL);
- }
- Delete(rname);
+ registerMethod(n);
+ current[MEMBER_FUNC] = false;
return SWIG_OK;
}
virtual int membervariableHandler(Node *n) {
// REPORT("membervariableHandler",n);
- String *symname = Getattr(n, "sym:name");
- String *gname, *sname;
-
- current = MEMBER_VAR;
+ current[MEMBER_VAR] = true;
Language::membervariableHandler(n);
- current = NO_CPP;
- gname = Swig_name_wrapper(Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname)));
- if (!GetFlag(n, "feature:immutable")) {
- sname = Swig_name_wrapper(Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname)));
- } else {
- //sname = NewString("0");
- sname = NewString("SWIG_Lua_set_immutable"); // error message
- }
- Printf(s_attr_tab,"%s{ \"%s\", %s, %s},\n",tab4,symname,gname,sname);
- if (eluac_ltr) {
- Printv(s_cmd_tab, tab4, "{LSTRKEY(\"", class_name, "_", symname, "_get", "\")", \
- ", LFUNCVAL(", gname, ")", "},\n", NIL);
- Printv(s_cmd_tab, tab4, "{LSTRKEY(\"", class_name, "_", symname, "_set", "\")", \
- ", LFUNCVAL(", sname, ")", "},\n", NIL);
- }
- Delete(gname);
- Delete(sname);
+ registerVariable(n);
+ current[MEMBER_VAR] = false;
return SWIG_OK;
}
virtual int constructorHandler(Node *n) {
// REPORT("constructorHandler", n);
- current = CONSTRUCTOR;
+ current[CONSTRUCTOR] = true;
Language::constructorHandler(n);
- current = NO_CPP;
- constructor_name = NewString(Getattr(n, "sym:name"));
+ current[CONSTRUCTOR] = false;
+ //constructor_name = NewString(Getattr(n, "sym:name"));
have_constructor = 1;
return SWIG_OK;
}
virtual int destructorHandler(Node *n) {
REPORT("destructorHandler", n);
- current = DESTRUCTOR;
+ current[DESTRUCTOR] = true;
Language::destructorHandler(n);
- current = NO_CPP;
+ current[DESTRUCTOR] = false;
have_destructor = 1;
destructor_action = Getattr(n, "wrap:action");
return SWIG_OK;
}
+ /* ----------------------------------------------------------------------
+ * globalfunctionHandler()
+ *
+ * It can be called:
+ * 1. Usual C/C++ global function.
+ * 2. During class parsing for functions declared/defined as friend
+ * 3. During class parsing from staticmemberfunctionHandler
+ * ---------------------------------------------------------------------- */
+
+ virtual int globalfunctionHandler(Node *n) {
+ bool oldVal = current[NO_CPP];
+ if (!current[STATIC_FUNC]) // If static function, don't switch to NO_CPP
+ current[NO_CPP] = true;
+ const int result = Language::globalfunctionHandler(n);
+
+ if (!current[STATIC_FUNC]) // Register only if not called from static function handler
+ registerMethod(n);
+ current[NO_CPP] = oldVal;
+ return result;
+ }
+
+ /* ----------------------------------------------------------------------
+ * globalvariableHandler()
+ *
+ * Sets "current" array correctly
+ * ---------------------------------------------------------------------- */
+
+ virtual int globalvariableHandler(Node *n) {
+ bool oldVal = current[NO_CPP];
+ current[GLOBAL_VAR] = true;
+ current[NO_CPP] = true;
+
+ const int result = Language::globalvariableHandler(n);
+ registerVariable(n);
+
+ current[GLOBAL_VAR] = false;
+ current[NO_CPP] = oldVal;
+ return result;
+ }
+
+
/* -----------------------------------------------------------------------
* staticmemberfunctionHandler()
*
virtual int staticmemberfunctionHandler(Node *n) {
REPORT("staticmemberfunctionHandler", n);
- current = STATIC_FUNC;
- String *symname = Getattr(n, "sym:name");
- int result = Language::staticmemberfunctionHandler(n);
-
- if (cparse_cplusplus && getCurrentClass()) {
+ current[STATIC_FUNC] = true;
+
+ const int result = Language::staticmemberfunctionHandler(n);
+ registerMethod(n);
+
+ if (old_metatable_bindings && result == SWIG_OK && old_compatible_names) {
+ Swig_require("lua_staticmemberfunctionHandler", n, "*lua:name", NIL);
+ String *lua_name = Getattr(n, "lua:name");
+ // Although this function uses Swig_name_member, it actually generates the Lua name,
+ // not the C++ name. This is because an earlier version used such a scheme for static function
+ // name generation and we have to maintain backward compatibility.
+ String *compat_name = Swig_name_member(0, proxy_class_name, lua_name);
+ Setattr(n, "lua:name", compat_name);
+ registerMethod(n, true, getNSpace());
+ Delete(compat_name);
Swig_restore(n);
}
- current = NO_CPP;
- if (result != SWIG_OK)
- return result;
- if (Getattr(n, "sym:nextSibling"))
- return SWIG_OK;
-
- Swig_require("luaclassobj_staticmemberfunctionHandler", n, "luaclassobj:wrap:name", NIL);
- String *name = Getattr(n, "name");
- String *rname, *realname;
- realname = symname ? symname : name;
- rname = Getattr(n, "luaclassobj:wrap:name");
- Printv(s_cls_methods_tab, tab4, "{\"", realname, "\", ", rname, "}, \n", NIL);
- Swig_restore(n);
-
- return SWIG_OK;
+ current[STATIC_FUNC] = false;;
+ return result;
}
/* ------------------------------------------------------------
* ------------------------------------------------------------ */
virtual int memberconstantHandler(Node *n) {
- REPORT("memberconstantHandler",n);
- String *symname = Getattr(n, "sym:name");
- if (cparse_cplusplus && getCurrentClass()) {
- Swig_save("luaclassobj_memberconstantHandler", n, "luaclassobj:symname", NIL);
- Setattr(n, "luaclassobj:symname", symname);
- }
+ REPORT("memberconstantHandler", n);
int result = Language::memberconstantHandler(n);
- if (cparse_cplusplus && getCurrentClass())
- Swig_restore(n);
return result;
}
* --------------------------------------------------------------------- */
virtual int staticmembervariableHandler(Node *n) {
- REPORT("staticmembervariableHandler",n);
- current = STATIC_VAR;
- String *symname = Getattr(n, "sym:name");
+ REPORT("staticmembervariableHandler", n);
+ current[STATIC_VAR] = true;
+ //String *symname = Getattr(n, "sym:name");
int result = Language::staticmembervariableHandler(n);
+ if (!GetFlag(n, "wrappedasconstant")) {
+ registerVariable(n);
+ }
- if (result != SWIG_OK)
- return result;
-
-
- if (Getattr(n, "wrappedasconstant"))
- return SWIG_OK;
+ if (result == SWIG_OK) {
+ // This will add static member variable to the class namespace with name ClassName_VarName
+ if (old_metatable_bindings && old_compatible_names) {
+ Swig_save("lua_staticmembervariableHandler", n, "lua:name", NIL);
+ String *lua_name = Getattr(n, "lua:name");
+ // Although this function uses Swig_name_member, it actually generates the Lua name,
+ // not the C++ name. This is because an earlier version used such a scheme for static function
+ // name generation and we have to maintain backward compatibility.
+ String *v2_name = Swig_name_member(NIL, proxy_class_name, lua_name);
+ if (!GetFlag(n, "wrappedasconstant")) {
+ Setattr(n, "lua:name", v2_name);
+ // Registering static var in the class parent nspace
+ registerVariable(n, true, getNSpace());
+ }
+ // If static member variable was wrapped as a constant, then
+ // constant wrapper has already performed all actions necessary for old_metatable_bindings
+ Delete(v2_name);
+ Swig_restore(n);
+ }
+ }
+ current[STATIC_VAR] = false;
- Swig_require("luaclassobj_staticmembervariableHandler", n, "luaclassobj:wrap:get", "luaclassobj:wrap:set", NIL);
- Printf(s_cls_attr_tab,"%s{ \"%s\", %s, %s},\n",tab4,symname,Getattr(n,"luaclassobj:wrap:get"), Getattr(n,"luaclassobj:wrap:set"));
- Swig_restore(n);
- return SWIG_OK;
+ return result;
}
+
/* ---------------------------------------------------------------------
* external runtime generation
* --------------------------------------------------------------------- */
*/
String *runtimeCode() {
String *s = NewString("");
- const char *filenames[] = { "luarun.swg", 0 } ; // must be 0 terminated
+ const char *filenames[] = { "luarun.swg", 0 }; // must be 0 terminated
emitLuaFlavor(s);
- String *sfile;
+ String *sfile = 0;
for (int i = 0; filenames[i] != 0; i++) {
sfile = Swig_include_sys(filenames[i]);
if (!sfile) {
- Printf(stderr, "*** Unable to open '%s'\n", filenames[i]);
+ Printf(stderr, "*** Unable to open '%s'\n", filenames[i]);
} else {
- Append(s, sfile);
- Delete(sfile);
+ Append(s, sfile);
+ Delete(sfile);
}
}
String *defaultExternalRuntimeFilename() {
return NewString("swigluarun.h");
}
-
+
/* ---------------------------------------------------------------------
* helpers
* --------------------------------------------------------------------- */
void emitLuaFlavor(String *s) {
- if (elua_ltr)
+ if (elua_emulate) {
+ Printf(s, "/*This is only emulation!*/\n");
+ Printf(s, "#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_ELUA\n");
+ Printf(s, "#define SWIG_LUA_ELUA_EMULATE\n");
+ } else if (elua_ltr)
Printf(s, "#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_ELUA\n");
else if (eluac_ltr)
Printf(s, "#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_ELUAC\n");
else
Printf(s, "#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA\n");
}
-
- /* This is to convert the string of Lua code into a proper string, which can then be
- emitted into the C/C++ code.
- Basically is is a lot of search & replacing of odd sequences
- */
- void EscapeCode(String* str)
- {
+
+ /* -----------------------------------------------------------------------------
+ * escapeCode()
+ *
+ * This is to convert the string of Lua code into a proper string, which can then be
+ * emitted into the C/C++ code.
+ * Basically is is a lot of search & replacing of odd sequences
+ * ---------------------------------------------------------------------------- */
+
+ void escapeCode(String *str) {
//Printf(f_runtime,"/* original luacode:[[[\n%s\n]]]\n*/\n",str);
- Chop(str); // trim
- Replace(str,"\\","\\\\",DOH_REPLACE_ANY); // \ to \\ (this must be done first)
- Replace(str,"\"","\\\"",DOH_REPLACE_ANY); // " to \"
- Replace(str,"\n","\\n\"\n \"",DOH_REPLACE_ANY); // \n to \n"\n" (ie quoting every line)
+ Chop(str); // trim
+ Replace(str, "\\", "\\\\", DOH_REPLACE_ANY); // \ to \\ (this must be done first)
+ Replace(str, "\"", "\\\"", DOH_REPLACE_ANY); // " to \"
+ Replace(str, "\n", "\\n\"\n \"", DOH_REPLACE_ANY); // \n to \n"\n" (ie quoting every line)
//Printf(f_runtime,"/* hacked luacode:[[[\n%s\n]]]\n*/\n",str);
- }
+ }
+
+ /* -----------------------------------------------------------------------------
+ * rawGetCArraysHash(String *name)
+ *
+ * A small helper to hide impelementation of how CArrays hashes are stored
+ * ---------------------------------------------------------------------------- */
+
+ Hash *rawGetCArraysHash(const_String_or_char_ptr name) {
+ Hash *scope = symbolScopeLookup( name ? name : "" );
+ if(!scope)
+ return 0;
+
+ Hash *carrays_hash = Getattr(scope, "lua:cdata");
+ return carrays_hash;
+ }
+
+ /* -----------------------------------------------------------------------------
+ * getCArraysHash()
+ *
+ * Each namespace can be described with a hash that stores C arrays
+ * where members of the namespace should be added. All these hashes are stored
+ * inside the symbols table, in pseudo-symbol for every namespace.
+ * nspace could be NULL (NSPACE_TODO), that means functions and variables and classes
+ * that are not in any namespace (this is default for SWIG unless %nspace feature is used).
+ * You can later set some attributes that will affect behaviour of functions that use this hash:
+ * "lua:no_namespaces" will disable "namespaces" array.
+ * "lua:no_classes" will disable "classes" array.
+ * For every component ("attributes", "methods", etc) there are subcomponents:
+ * XXX:name - name of the C array that stores data for component
+ * XXX:decl - statement with forward declaration of this array;
+ * Namespace could be automatically registered to its parent if 'reg' == true. This can only be
+ * done during the first call (a.k.a when nspace is created).
+ * ---------------------------------------------------------------------------- */
+
+ Hash *getCArraysHash(String *nspace, bool reg = true) {
+ Hash *scope = symbolScopeLookup(nspace ? nspace : "");
+ if(!scope) {
+ symbolAddScope( nspace ? nspace : "" );
+ scope = symbolScopeLookup(nspace ? nspace : "");
+ assert(scope);
+ }
+ Hash *carrays_hash = Getattr(scope, "lua:cdata");
+ if (carrays_hash != 0)
+ return carrays_hash;
+ carrays_hash = NewHash();
+ String *mangled_name = 0;
+ if (nspace == 0 || Len(nspace) == 0)
+ mangled_name = NewString("SwigModule");
+ else
+ mangled_name = Swig_name_mangle(nspace);
+ String *cname = NewStringf("swig_%s", mangled_name);
+
+ Setattr(carrays_hash, "cname", cname);
+
+ String *attr_tab = NewString("");
+ String *attr_tab_name = NewStringf("swig_%s_attributes", mangled_name);
+ String *attr_tab_decl = NewString("");
+ Printv(attr_tab, "static swig_lua_attribute ", NIL);
+ Printv(attr_tab, attr_tab_name, "[]", NIL);
+ Printv(attr_tab_decl, attr_tab, ";\n", NIL);
+ Printv(attr_tab, " = {\n", NIL);
+ Setattr(carrays_hash, "attributes", attr_tab);
+ Setattr(carrays_hash, "attributes:name", attr_tab_name);
+ Setattr(carrays_hash, "attributes:decl", attr_tab_decl);
+
+ String *methods_tab = NewString("");
+ String *methods_tab_name = NewStringf("swig_%s_methods", mangled_name);
+ String *methods_tab_decl = NewString("");
+ if (elua_ltr || eluac_ltr) // In this case methods array also acts as namespace rotable
+ Printf(methods_tab, "const LUA_REG_TYPE ");
+ else
+ Printf(methods_tab, "static swig_lua_method ");
+ Printv(methods_tab, methods_tab_name, "[]", NIL);
+ Printv(methods_tab_decl, methods_tab, ";\n", NIL);
+ Printv(methods_tab, "= {\n", NIL);
+ Setattr(carrays_hash, "methods", methods_tab);
+ Setattr(carrays_hash, "methods:name", methods_tab_name);
+ Setattr(carrays_hash, "methods:decl", methods_tab_decl);
+
+ String *const_tab = NewString("");
+ String *const_tab_name = NewStringf("swig_%s_constants", mangled_name);
+ String *const_tab_decl = NewString("");
+ if (elua_ltr || eluac_ltr) // In this case const array holds rotable with namespace constants
+ Printf(const_tab, "const LUA_REG_TYPE ");
+ else
+ Printf(const_tab, "static swig_lua_const_info ");
+ Printv(const_tab, const_tab_name, "[]", NIL);
+ Printv(const_tab_decl, const_tab, ";", NIL);
+ Printv(const_tab, "= {\n", NIL);
+ Setattr(carrays_hash, "constants", const_tab);
+ Setattr(carrays_hash, "constants:name", const_tab_name);
+ Setattr(carrays_hash, "constants:decl", const_tab_decl);
+
+ String *classes_tab = NewString("");
+ String *classes_tab_name = NewStringf("swig_%s_classes", mangled_name);
+ String *classes_tab_decl = NewString("");
+ Printf(classes_tab, "static swig_lua_class* ");
+ Printv(classes_tab, classes_tab_name, "[]", NIL);
+ Printv(classes_tab_decl, classes_tab, ";", NIL);
+ Printv(classes_tab, "= {\n", NIL);
+ Setattr(carrays_hash, "classes", classes_tab);
+ Setattr(carrays_hash, "classes:name", classes_tab_name);
+ Setattr(carrays_hash, "classes:decl", classes_tab_decl);
+
+ String *namespaces_tab = NewString("");
+ String *namespaces_tab_name = NewStringf("swig_%s_namespaces", mangled_name);
+ String *namespaces_tab_decl = NewString("");
+ Printf(namespaces_tab, "static swig_lua_namespace* ");
+ Printv(namespaces_tab, namespaces_tab_name, "[]", NIL);
+ Printv(namespaces_tab_decl, namespaces_tab, ";", NIL);
+ Printv(namespaces_tab, " = {\n", NIL);
+ Setattr(carrays_hash, "namespaces", namespaces_tab);
+ Setattr(carrays_hash, "namespaces:name", namespaces_tab_name);
+ Setattr(carrays_hash, "namespaces:decl", namespaces_tab_decl);
+
+ if (elua_ltr) {
+ String *get_tab = NewString("");
+ String *get_tab_name = NewStringf("swig_%s_get", mangled_name);
+ String *get_tab_decl = NewString("");
+ Printv(get_tab, "const LUA_REG_TYPE ", get_tab_name, "[]", NIL);
+ Printv(get_tab_decl, get_tab, ";", NIL);
+ Printv(get_tab, " = {\n", NIL);
+ Setattr(carrays_hash, "get", get_tab);
+ Setattr(carrays_hash, "get:name", get_tab_name);
+ Setattr(carrays_hash, "get:decl", get_tab_decl);
+
+ String *set_tab = NewString("");
+ String *set_tab_name = NewStringf("swig_%s_set", mangled_name);
+ String *set_tab_decl = NewString("");
+ Printv(set_tab, "const LUA_REG_TYPE ", set_tab_name, "[]", NIL);
+ Printv(set_tab_decl, set_tab, ";", NIL);
+ Printv(set_tab, " = {\n", NIL);
+ Setattr(carrays_hash, "set", set_tab);
+ Setattr(carrays_hash, "set:name", set_tab_name);
+ Setattr(carrays_hash, "set:decl", set_tab_decl);
+
+ }
+ if (!eluac_ltr) {
+ String *metatable_tab = NewString("");
+ String *metatable_tab_name = NewStringf("swig_%s_meta", mangled_name);
+ String *metatable_tab_decl = NewString("");
+ if (elua_ltr) // In this case const array holds rotable with namespace constants
+ Printf(metatable_tab, "const LUA_REG_TYPE ");
+ else
+ Printf(metatable_tab, "static swig_lua_method ");
+ Printv(metatable_tab, metatable_tab_name, "[]", NIL);
+ Printv(metatable_tab_decl, metatable_tab, ";", NIL);
+ Printv(metatable_tab, " = {\n", NIL);
+ Setattr(carrays_hash, "metatable", metatable_tab);
+ Setattr(carrays_hash, "metatable:name", metatable_tab_name);
+ Setattr(carrays_hash, "metatable:decl", metatable_tab_decl);
+ }
+
+ Setattr(scope, "lua:cdata", carrays_hash);
+ assert(rawGetCArraysHash(nspace));
+
+ if (reg && nspace != 0 && Len(nspace) != 0 && GetFlag(carrays_hash, "lua:no_reg") == 0) {
+ // Split names into components
+ List *components = Split(nspace, '.', -1);
+ String *parent_path = NewString("");
+ int len = Len(components);
+ String *name = Copy(Getitem(components, len - 1));
+ for (int i = 0; i < len - 1; i++) {
+ if (i > 0)
+ Printv(parent_path, NSPACE_SEPARATOR, NIL);
+ String *item = Getitem(components, i);
+ Printv(parent_path, item, NIL);
+ }
+ Hash *parent = getCArraysHash(parent_path, true);
+ String *namespaces_tab = Getattr(parent, "namespaces");
+ Printv(namespaces_tab, "&", cname, ",\n", NIL);
+ if (elua_ltr || eluac_ltr) {
+ String *methods_tab = Getattr(parent, "methods");
+ Printv(methods_tab, tab4, "{LSTRKEY(\"", name, "\")", ", LROVAL(", methods_tab_name, ")", "},\n", NIL);
+ }
+ Setattr(carrays_hash, "name", name);
+
+ Delete(components);
+ Delete(parent_path);
+ } else if (!reg) // This namespace shouldn't be registered. Lets remember it.
+ SetFlag(carrays_hash, "lua:no_reg");
+
+ Delete(mangled_name);
+ mangled_name = 0;
+ return carrays_hash;
+ }
+
+ /* -----------------------------------------------------------------------------
+ * closeCArraysHash()
+ *
+ * Functions add end markers {0,0,...,0} to all arrays, prints them to
+ * output and marks hash as closed (lua:closed). Consequent attempts to
+ * close the same hash will result in an error.
+ * closeCArraysHash DOES NOT print structure that describes namespace, it only
+ * prints array. You can use printCArraysDefinition to print structure.
+ * if "lua:no_namespaces" is set, then array for "namespaces" won't be printed
+ * if "lua:no_classes" is set, then array for "classes" won't be printed
+ * ----------------------------------------------------------------------------- */
+
+ void closeCArraysHash(String *nspace, File *output) {
+ Hash *carrays_hash = rawGetCArraysHash(nspace);
+ assert(carrays_hash);
+ assert(GetFlag(carrays_hash, "lua:closed") == 0);
+
+ SetFlag(carrays_hash, "lua:closed");
+
+ // Do arrays describe class instance part or class static part
+ const int is_instance = GetFlag(carrays_hash, "lua:class_instance");
+
+
+ String *attr_tab = Getattr(carrays_hash, "attributes");
+ Printf(attr_tab, " {0,0,0}\n};\n");
+ Printv(output, attr_tab, NIL);
+
+ String *const_tab = Getattr(carrays_hash, "constants");
+ String *const_tab_name = Getattr(carrays_hash, "constants:name");
+ if (elua_ltr || eluac_ltr)
+ Printv(const_tab, tab4, "{LNILKEY, LNILVAL}\n", "};\n", NIL);
+ else
+ Printf(const_tab, " {0,0,0,0,0,0}\n};\n");
+
+ // For the sake of compiling with -Wall -Werror we print constants
+ // only when necessary
+ int need_constants = 0;
+ if ( (elua_ltr || eluac_ltr) && (old_metatable_bindings) )
+ need_constants = 1;
+ else if (!is_instance) // static part need constants tab
+ need_constants = 1;
+
+ if (need_constants)
+ Printv(output, const_tab, NIL);
+
+ if (elua_ltr) {
+ // Put forward declaration of metatable array
+ Printv(output, "extern ", Getattr(carrays_hash, "metatable:decl"), "\n", NIL);
+ }
+ String *methods_tab = Getattr(carrays_hash, "methods");
+ String *metatable_tab_name = Getattr(carrays_hash, "metatable:name");
+ if (elua_ltr || eluac_ltr) {
+ if (old_metatable_bindings)
+ Printv(methods_tab, tab4, "{LSTRKEY(\"const\"), LROVAL(", const_tab_name, ")},\n", NIL);
+ if (elua_ltr) {
+ Printv(methods_tab, tab4, "{LSTRKEY(\"__metatable\"), LROVAL(", metatable_tab_name, ")},\n", NIL);
+ }
+
+ Printv(methods_tab, tab4, "{LSTRKEY(\"__disown\"), LFUNCVAL(SWIG_Lua_class_disown)},\n", NIL);
+ Printv(methods_tab, tab4, "{LNILKEY, LNILVAL}\n};\n", NIL);
+ } else
+ Printf(methods_tab, " {0,0}\n};\n");
+ Printv(output, methods_tab, NIL);
+
+ if (!GetFlag(carrays_hash, "lua:no_classes")) {
+ String *classes_tab = Getattr(carrays_hash, "classes");
+ Printf(classes_tab, " 0\n};\n");
+ Printv(output, classes_tab, NIL);
+ }
+
+ if (!GetFlag(carrays_hash, "lua:no_namespaces")) {
+ String *namespaces_tab = Getattr(carrays_hash, "namespaces");
+ Printf(namespaces_tab, " 0\n};\n");
+ Printv(output, namespaces_tab, NIL);
+ }
+ if (elua_ltr) {
+ String *get_tab = Getattr(carrays_hash, "get");
+ String *set_tab = Getattr(carrays_hash, "set");
+ Printv(get_tab, tab4, "{LNILKEY, LNILVAL}\n};\n", NIL);
+ Printv(set_tab, tab4, "{LNILKEY, LNILVAL}\n};\n", NIL);
+ Printv(output, get_tab, NIL);
+ Printv(output, set_tab, NIL);
+ }
+
+ // Heuristic whether we need to print metatable or not.
+ // For the sake of compiling with -Wall -Werror we don't print
+ // metatable for static part.
+ int need_metatable = 0;
+ if (eluac_ltr)
+ need_metatable = 0;
+ else if(!is_instance)
+ need_metatable = 0;
+ else
+ need_metatable = 1;
+
+ if (need_metatable) {
+ String *metatable_tab = Getattr(carrays_hash, "metatable");
+ assert(metatable_tab);
+ if (elua_ltr) {
+ String *get_tab_name = Getattr(carrays_hash, "get:name");
+ String *set_tab_name = Getattr(carrays_hash, "set:name");
+
+ if (GetFlag(carrays_hash, "lua:class_instance")) {
+ Printv(metatable_tab, tab4, "{LSTRKEY(\"__index\"), LFUNCVAL(SWIG_Lua_class_get)},\n", NIL);
+ Printv(metatable_tab, tab4, "{LSTRKEY(\"__newindex\"), LFUNCVAL(SWIG_Lua_class_set)},\n", NIL);
+ } else {
+ Printv(metatable_tab, tab4, "{LSTRKEY(\"__index\"), LFUNCVAL(SWIG_Lua_namespace_get)},\n", NIL);
+ Printv(metatable_tab, tab4, "{LSTRKEY(\"__newindex\"), LFUNCVAL(SWIG_Lua_namespace_set)},\n", NIL);
+ }
+
+ Printv(metatable_tab, tab4, "{LSTRKEY(\"__gc\"), LFUNCVAL(SWIG_Lua_class_destruct)},\n", NIL);
+ Printv(metatable_tab, tab4, "{LSTRKEY(\".get\"), LROVAL(", get_tab_name, ")},\n", NIL);
+ Printv(metatable_tab, tab4, "{LSTRKEY(\".set\"), LROVAL(", set_tab_name, ")},\n", NIL);
+ Printv(metatable_tab, tab4, "{LSTRKEY(\".fn\"), LROVAL(", Getattr(carrays_hash, "methods:name"), ")},\n", NIL);
+
+ if (GetFlag(carrays_hash, "lua:class_instance")) {
+ String *static_cls = Getattr(carrays_hash, "lua:class_instance:static_hash");
+ assert(static_cls);
+ // static_cls is swig_lua_namespace. This structure can't be use with eLua(LTR)
+ // Instead structure describing its methods isused
+ String *static_cls_cname = Getattr(static_cls, "methods:name");
+ assert(static_cls_cname);
+ Printv(metatable_tab, tab4, "{LSTRKEY(\".static\"), LROVAL(", static_cls_cname, ")},\n", NIL);
+ // Put forward declaration of this array
+ Printv(output, "extern ", Getattr(static_cls, "methods:decl"), "\n", NIL);
+ } else if (GetFlag(carrays_hash, "lua:class_static")) {
+ Hash *instance_cls = Getattr(carrays_hash, "lua:class_static:instance_hash");
+ assert(instance_cls);
+ String *instance_cls_metatable_name = Getattr(instance_cls, "metatable:name");
+ assert(instance_cls_metatable_name);
+ Printv(metatable_tab, tab4, "{LSTRKEY(\".instance\"), LROVAL(", instance_cls_metatable_name, ")},\n", NIL);
+ }
+
+ Printv(metatable_tab, tab4, "{LNILKEY, LNILVAL}\n};\n", NIL);
+ } else {
+ Printf(metatable_tab, " {0,0}\n};\n");
+ }
+
+ Printv(output, metatable_tab, NIL);
+ }
+
+ Printv(output, "\n", NIL);
+ }
+
+ /* -----------------------------------------------------------------------------
+ * closeNamespaces()
+ *
+ * Recursively close all non-closed namespaces. Prints data to dataOutput.
+ * ----------------------------------------------------------------------------- */
+
+ void closeNamespaces(File *dataOutput) {
+ // Special handling for empty module.
+ if (symbolScopeLookup("") == 0 || rawGetCArraysHash("") == 0) {
+ // Module is empty. Create hash for global scope in order to have swig_SwigModule
+ // variable in resulting file
+ getCArraysHash(0);
+ }
+ // Because we cant access directly 'symtabs', instead we access
+ // top-level scope and look on all scope pseudo-symbols in it.
+ Hash *top_scope = symbolScopeLookup("");
+ assert(top_scope);
+ Iterator ki = First(top_scope);
+ List *to_close = NewList();
+ while (ki.key) {
+ assert(ki.item);
+ if (Getattr(ki.item, "sym:scope")) {
+ // We have a pseudo symbol. Lets get actual scope for this pseudo symbol
+ Hash *carrays_hash = rawGetCArraysHash(ki.key);
+ assert(carrays_hash);
+ if (GetFlag(carrays_hash, "lua:closed") == 0)
+ Append(to_close, ki.key);
+ }
+ ki = Next(ki);
+ }
+ SortList(to_close, &compareByLen);
+ int len = Len(to_close);
+ for (int i = 0; i < len; i++) {
+ String *key = Getitem(to_close, i);
+ closeCArraysHash(key, dataOutput);
+ Hash *carrays_hash = rawGetCArraysHash(key);
+ String *name = 0; // name - name of the namespace as it should be visible in Lua
+ if (DohLen(key) == 0) // This is global module
+ name = module;
+ else
+ name = Getattr(carrays_hash, "name");
+ assert(name);
+ printCArraysDefinition(key, name, dataOutput);
+ }
+ Delete(to_close);
+ }
+
+ /* -----------------------------------------------------------------------------
+ * printCArraysDefinition()
+ *
+ * This function prints to output a definition of namespace in form
+ * swig_lua_namespace $cname = { attr_array, methods_array, ... , namespaces_array };
+ * You can call this function as many times as is necessary.
+ * 'name' is a user-visible name that this namespace will have in Lua. It shouldn't
+ * be a fully qualified name, just its own name.
+ * ----------------------------------------------------------------------------- */
+
+ void printCArraysDefinition(String *nspace, String *name, File *output) {
+ Hash *carrays_hash = getCArraysHash(nspace, false);
+
+ String *cname = Getattr(carrays_hash, "cname"); // cname - name of the C structure that describes namespace
+ assert(cname);
+ Printv(output, "static swig_lua_namespace ", cname, " = ", NIL);
+
+ String *null_string = NewString("0");
+ String *attr_tab_name = Getattr(carrays_hash, "attributes:name");
+ String *methods_tab_name = Getattr(carrays_hash, "methods:name");
+ String *const_tab_name = Getattr(carrays_hash, "constants:name");
+ String *classes_tab_name = Getattr(carrays_hash, "classes:name");
+ String *namespaces_tab_name = Getattr(carrays_hash, "namespaces:name");
+ bool has_classes = GetFlag(carrays_hash, "lua:no_classes") == 0;
+ bool has_namespaces = GetFlag(carrays_hash, "lua:no_namespaces") == 0;
+
+ Printv(output, "{\n",
+ tab4, "\"", name, "\",\n",
+ tab4, methods_tab_name, ",\n",
+ tab4, attr_tab_name, ",\n",
+ tab4, const_tab_name, ",\n",
+ tab4, (has_classes) ? classes_tab_name : null_string, ",\n",
+ tab4, (has_namespaces) ? namespaces_tab_name : null_string, "\n};\n", NIL);
+ Delete(null_string);
+ }
+
+ /* -----------------------------------------------------------------------------
+ * luaCurrentSymbolNSpace()
+ *
+ * This function determines actual namespace/scope where any symbol at the
+ * current moment should be placed. It looks at the 'current' array
+ * and depending on where are we - static class member/function,
+ * instance class member/function or just global functions decides
+ * where symbol should be put.
+ * The namespace/scope doesn't depend from symbol, only from 'current'
+ * ----------------------------------------------------------------------------- */
+
+ String *luaCurrentSymbolNSpace() {
+ String *scope = 0;
+ // If ouside class, than NSpace is used.
+ // If inside class, but current[NO_CPP], then this is friend function. It belongs to NSpace
+ if (!getCurrentClass() || current[NO_CPP]) {
+ scope = getNSpace();
+ } else if (current[ENUM_CONST] && !CPlusPlus ) {
+ // Enums in C mode go to NSpace
+ scope = getNSpace();
+ } else {
+ // If inside class, then either class static namespace or class fully qualified name is used
+ assert(!current[NO_CPP]);
+ if (current[STATIC_FUNC] || current[STATIC_VAR] || current[STATIC_CONST]) {
+ scope = class_static_nspace;
+ } else if (current[MEMBER_VAR] || current[CONSTRUCTOR] || current[DESTRUCTOR]
+ || current[MEMBER_FUNC]) {
+ scope = full_proxy_class_name;
+ } else { // Friend functions are handled this way
+ scope = class_static_nspace;
+ }
+ assert(scope);
+ }
+ return scope;
+ }
+
+ /* -----------------------------------------------------------------------------
+ * luaAddSymbol()
+ *
+ * Our implementation of addSymbol. Determines scope correctly, then
+ * forwards to Language::addSymbol
+ * ----------------------------------------------------------------------------- */
+
+ int luaAddSymbol(const String *s, const Node *n) {
+ String *scope = luaCurrentSymbolNSpace();
+ return luaAddSymbol(s, n, scope);
+ }
+
+ /* -----------------------------------------------------------------------------
+ * luaAddSymbol()
+ *
+ * Overload. Enforces given scope. Actually, it simply forwards call to Language::addSymbol
+ * ----------------------------------------------------------------------------- */
+
+ int luaAddSymbol(const String *s, const Node *n, const_String_or_char_ptr scope) {
+ int result = Language::addSymbol(s, n, scope);
+ if (!result)
+ Printf(stderr, "addSymbol(%s to scope %s) failed\n", s, scope);
+ return result;
+ }
+
};
/* NEW LANGUAGE NOTE:***********************************************
extern "C" {
extern String *ModuleName;
+ extern int ignore_nested_classes;
+ extern int kwargs_supported;
}
/* usage string split into multiple parts otherwise string is too big for some compilers */
-co <file> - Check <file> out of the SWIG library\n\
-copyctor - Automatically generate copy constructors wherever possible\n\
-cpperraswarn - Treat the preprocessor #error statement as #warning (default)\n\
+ -cppext <ext> - Change file extension of generated C++ files to <ext>\n\
+ (default is cxx, except for PHP which uses cpp)\n\
-copyright - Display copyright notices\n\
-debug-classes - Display information about the classes found in the interface\n\
-debug-module <n>- Display module parse tree at stages 1-4, <n> is a csv list of stages\n\
-directors - Turn on director mode for all the classes, mainly for testing\n\
-dirprot - Turn on wrapping of protected members for director classes (default)\n\
-D<symbol> - Define a symbol <symbol> (for conditional compilation)\n\
+";
+
+static const char *usage2 = (const char *) "\
-E - Preprocess only, does not generate wrapper code\n\
-external-runtime [file] - Export the SWIG runtime stack\n\
-fakeversion <v>- Make SWIG fake the program version number to <v>\n\
-features <list>- Set global features, where <list> is a comma separated list of\n\
features, eg -features directors,autodoc=1\n\
If no explicit value is given to the feature, a default of 1 is used\n\
-";
-
-static const char *usage2 = (const char *) "\
-fastdispatch - Enable fast dispatch mode to produce faster overload dispatcher code\n\
-Fmicrosoft - Display error/warning messages in Microsoft format\n\
-Fstandard - Display error/warning messages in commonly used format\n\
-importall - Follow all #include statements as imports\n\
-includeall - Follow all #include statements\n\
-l<ifile> - Include SWIG library file <ifile>\n\
+";
+
+static const char *usage3 = (const char *) "\
-macroerrors - Report errors inside macros\n\
-makedefault - Create default constructors/destructors (the default)\n\
-M - List all dependencies\n\
-noexcept - Do not wrap exception specifiers\n\
-nofastdispatch - Disable fast dispatch mode (default)\n\
-nopreprocess - Skip the preprocessor step\n\
+ -notemplatereduce - Disable reduction of the typedefs in templates\n\
";
-static const char *usage3 = (const char *) "\
- -notemplatereduce - Disable reduction of the typedefs in templates\n\
+static const char *usage4 = (const char *) "\
-O - Enable the optimization options: \n\
-fastdispatch -fvirtual \n\
- -o <outfile> - Set name of the output file to <outfile>\n\
- -oh <headfile> - Set name of the output header file to <headfile>\n\
+ -o <outfile> - Set name of C/C++ output file to <outfile>\n\
+ -oh <headfile> - Set name of C++ output header file for directors to <headfile>\n\
-outcurrentdir - Set default output dir to current dir instead of input file's path\n\
-outdir <dir> - Set language specific files output directory to <dir>\n\
-pcreversion - Display PCRE version information\n\
static String *SwigLibWinUnix = 0; // Extra library directory on Windows
static int freeze = 0;
static String *lang_config = 0;
-static char *hpp_extension = (char *) "h";
-static char *cpp_extension = (char *) "cxx";
-static char *depends_extension = (char *) "d";
+static const char *hpp_extension = "h";
+static const char *cpp_extension = "cxx";
+static const char *depends_extension = "d";
static String *outdir = 0;
static String *xmlout = 0;
static int outcurrentdir = 0;
}
void SWIG_config_cppext(const char *ext) {
- cpp_extension = (char *) ext;
+ cpp_extension = ext;
}
List *SWIG_output_files() {
Swig_mark_arg(i);
} else if (strncmp(argv[i], "-D", 2) == 0) {
String *d = NewString(argv[i] + 2);
- Replace(d, (char *) "=", (char *) " ", DOH_REPLACE_ANY | DOH_REPLACE_FIRST);
+ Replace(d, "=", " ", DOH_REPLACE_ANY | DOH_REPLACE_FIRST);
Preprocessor_define((DOH *) d, 0);
Delete(d);
// Create a symbol
Preprocessor_define((DOH *) "__cplusplus __cplusplus", 0);
Swig_cparse_cplusplus(1);
Swig_mark_arg(i);
+ } else if (strcmp(argv[i], "-c++out") == 0) {
+ // Undocumented
+ Swig_cparse_cplusplusout(1);
+ Swig_mark_arg(i);
} else if (strcmp(argv[i], "-fcompact") == 0) {
Wrapper_compact_print_mode_set(1);
Swig_mark_arg(i);
} else if (strcmp(argv[i], "-naturalvar") == 0) {
Wrapper_naturalvar_mode_set(1);
Swig_mark_arg(i);
- } else if (strcmp(argv[i], "-nonaturalvar") == 0) {
- Wrapper_naturalvar_mode_set(0);
- Swig_mark_arg(i);
} else if (strcmp(argv[i], "-directors") == 0) {
SWIG_setfeature("feature:director", "1");
Wrapper_director_mode_set(1);
Swig_filename_correct(outfile_name);
if (!outfile_name_h || !dependencies_file) {
char *ext = strrchr(Char(outfile_name), '.');
- String *basename = ext ? NewStringWithSize(Char(outfile_name), Char(ext) - Char(outfile_name)) : NewString(outfile_name);
+ String *basename = ext ? NewStringWithSize(Char(outfile_name), (int)(Char(ext) - Char(outfile_name))) : NewString(outfile_name);
if (!dependencies_file) {
dependencies_file = NewStringf("%s.%s", basename, depends_extension);
}
} else if (strcmp(argv[i], "-nocpperraswarn") == 0) {
Preprocessor_error_as_warning(0);
Swig_mark_arg(i);
+ } else if (strcmp(argv[i], "-cppext") == 0) {
+ Swig_mark_arg(i);
+ if (argv[i + 1]) {
+ SWIG_config_cppext(argv[i + 1]);
+ Swig_mark_arg(i + 1);
+ i++;
+ } else {
+ Swig_arg_error();
+ }
} else if ((strcmp(argv[i], "-debug-typemap") == 0) || (strcmp(argv[i], "-debug_typemap") == 0) || (strcmp(argv[i], "-tm_debug") == 0)) {
tm_debug = 1;
Swig_mark_arg(i);
fputs(usage1, stdout);
fputs(usage2, stdout);
fputs(usage3, stdout);
+ fputs(usage4, stdout);
Swig_mark_arg(i);
help = 1;
}
}
}
-
-
-
-
int SWIG_main(int argc, char *argv[], Language *l) {
char *c;
String *vers = NewString("SWIG_VERSION 0x");
int count = 0;
while (token) {
- int len = strlen(token);
+ int len = (int)strlen(token);
assert(len == 1 || len == 2);
Printf(vers, "%s%s", (len == 1) ? "0" : "", token);
token = strtok(NULL, ".");
Wrapper_director_mode_set(0);
Wrapper_director_protected_mode_set(1);
+ // Inform the parser if the nested classes should be ignored unless explicitly told otherwise via feature:flatnested
+ ignore_nested_classes = l->nestedClassesSupport() == Language::NCS_Unknown ? 1 : 0;
+
+ kwargs_supported = l->kwargsSupport() ? 1 : 0;
+
// Create Library search directories
// Check for SWIG_LIB environment variable
// Don't check for an input file if -external-runtime is passed
Swig_check_options(external_runtime ? 0 : 1);
+ if (CPlusPlus && cparse_cplusplusout) {
+ Printf(stderr, "The -c++out option is for C input but C++ input has been requested via -c++\n");
+ SWIG_exit(EXIT_FAILURE);
+ }
+
install_opts(argc, argv);
// Add language dependent directory to the search path
Printf(stdout, "debug-module stage 1\n");
Swig_print_tree(Getattr(top, "module"));
}
+ if (!CPlusPlus) {
+ if (Verbose)
+ Printf(stdout, "Processing unnamed structs...\n");
+ Swig_nested_name_unnamed_c_structs(top);
+ }
+ Swig_extend_unused_check();
if (Verbose) {
Printf(stdout, "Processing types...\n");
}
Swig_default_allocators(top);
+ if (CPlusPlus) {
+ if (Verbose)
+ Printf(stdout, "Processing nested classes...\n");
+ Swig_nested_process_classes(top);
+ }
+
if (dump_top & STAGE3) {
Printf(stdout, "debug-top stage 3\n");
Swig_print_tree(top);
}
- if (dump_module & STAGE3) {
+ if (top && (dump_module & STAGE3)) {
Printf(stdout, "debug-module stage 3\n");
Swig_print_tree(Getattr(top, "module"));
}
Printf(stdout, "Generating wrappers...\n");
}
- if (dump_classes) {
+ if (top && dump_classes) {
Hash *classes = Getattr(top, "classes");
if (classes) {
Printf(stdout, "Classes\n");
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGMODULA3\n");
- Printf(f_runtime, "\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGMODULA3\n#define SWIGMODULA3\n#endif\n\n");
Swig_name_register("wrapper", "Modula3_%f");
if (old_variable_names) {
}
}
- if (Cmp(nodeType(n), "constant") == 0) {
- // Wrapping a constant hack
- Swig_save("functionWrapper", n, "wrap:action", NIL);
-
- // below based on Swig_VargetToFunction()
- SwigType *ty = Swig_wrapped_var_type(Getattr(n, "type"), use_naturalvar_mode(n));
- Setattr(n, "wrap:action", NewStringf("%s = (%s)(%s);", Swig_cresult_name(), SwigType_lstr(ty, 0), Getattr(n, "value")));
- }
-
Setattr(n, "wrap:name", wname);
// Now write code to make the function call
if (!native_function_flag) {
String *actioncode = emit_action(n);
- if (Cmp(nodeType(n), "constant") == 0) {
- Swig_restore(n);
- }
-
/* Return value if necessary */
String *tm;
if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) {
/* Deal with inheritance */
List *baselist = Getattr(n, "bases");
- if (baselist != NIL) {
+ if (baselist) {
Iterator base = First(baselist);
- if (base.item) {
- c_baseclassname = Getattr(base.item, "name");
- baseclass = Copy(getProxyName(c_baseclassname));
- if (baseclass) {
- c_baseclass = SwigType_namestr(Getattr(base.item, "name"));
+ while (base.item) {
+ if (!GetFlag(base.item, "feature:ignore")) {
+ String *baseclassname = Getattr(base.item, "name");
+ if (!c_baseclassname) {
+ c_baseclassname = baseclassname;
+ baseclass = Copy(getProxyName(baseclassname));
+ if (baseclass)
+ c_baseclass = SwigType_namestr(baseclassname);
+ } else {
+ /* Warn about multiple inheritance for additional base class(es) */
+ String *proxyclassname = Getattr(n, "classtypeobj");
+ Swig_warning(WARN_MODULA3_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
+ "Warning for %s, base %s ignored. Multiple inheritance is not supported in Modula 3.\n", SwigType_namestr(proxyclassname), SwigType_namestr(baseclassname));
+ }
}
base = Next(base);
- if (base.item != NIL) {
- Swig_warning(WARN_MODULA3_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
- "Warning for %s proxy: Base %s ignored. Multiple inheritance is not supported in Modula 3.\n",
- name, Getattr(base.item, "name"));
- }
}
}
const String *pure_baseclass = typemapLookup(n, "m3base", name, WARN_NONE);
if (hasContent(pure_baseclass) && hasContent(baseclass)) {
Swig_warning(WARN_MODULA3_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
- "Warning for %s proxy: Base %s ignored. Multiple inheritance is not supported in Modula 3.\n", name, pure_baseclass);
+ "Warning for %s, base %s ignored. Multiple inheritance is not supported in Modula 3.\n", name, pure_baseclass);
}
// Pure Modula 3 interfaces
const String *pure_interfaces = typemapLookup(n, derived ? "m3interfaces_derived" : "m3interfaces",
base = Next(base);
if (base.item) {
Swig_warning(WARN_MODULA3_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
- "Warning for %s proxy: Base %s ignored. Multiple inheritance is not supported in Modula 3.\n",
+ "Warning for %s, base %s ignored. Multiple inheritance is not supported in Modula 3.\n",
proxy_class_name, Getattr(base.item, "name"));
}
}
}
/* -----------------------------------------------------------------------------
- * makeParameterName()
- *
- * Inputs:
- * n - Node
- * p - parameter node
- * arg_num - parameter argument number
- * Return:
- * arg - a unique parameter name
- * ----------------------------------------------------------------------------- */
-
- String *makeParameterName(Node *n, Parm *p, int arg_num) {
-
- // Use C parameter name unless it is a duplicate or an empty parameter name
- String *pn = Getattr(p, "name");
- int count = 0;
- ParmList *plist = Getattr(n, "parms");
- while (plist) {
- if ((Cmp(pn, Getattr(plist, "name")) == 0))
- count++;
- plist = nextSibling(plist);
- }
- String *arg = (!pn || (count > 1)) ? NewStringf("arg%d",
- arg_num) : Copy(Getattr(p,
- "name"));
-
- return arg;
- }
-
- /* -----------------------------------------------------------------------------
* attachParameterNames()
*
* Inputs:
* Static member variables
* ----------------------------------------------------------------------------- */
-const char *MODULA3::usage = (char *) "\
+const char *MODULA3::usage = "\
Modula 3 Options (available with -modula3)\n\
-generateconst <file> - Generate code for computing numeric values of constants\n\
-generaterename <file> - Generate suggestions for %rename\n\
#include <ctype.h>
-static const char *usage = (char *) "\
+static const char *usage = "\
Mzscheme Options (available with -mzscheme)\n\
-declaremodule - Create extension that declares a module\n\
-dynamic-load <library>,[library,...] - Do not link with these libraries, dynamic load\n\
static bool noinit = false;
static String *load_libraries = NULL;
static String *module = 0;
-static char *mzscheme_path = (char *) "mzscheme";
+static const char *mzscheme_path = "mzscheme";
static String *init_func_def = 0;
static File *f_begin = 0;
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGMZSCHEME\n");
- Printf(f_runtime, "\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGMZSCHEME\n#define SWIGMZSCHEME\n#endif\n\n");
module = Getattr(n, "name");
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * This file is part of SWIG, which is licensed as a whole under version 3
+ * (or any later version) of the GNU General Public License. Some additional
+ * terms also apply to certain portions of SWIG. The full details of the SWIG
+ * license and copyrights can be found in the LICENSE and COPYRIGHT files
+ * included with the SWIG source code as distributed by the SWIG developers
+ * and at http://www.swig.org/legal.html.
+ *
+ * nested.cxx
+ *
+ * Nested structs support
+ * ----------------------------------------------------------------------------- */
+
+#include "swigmod.h"
+#include "cparse.h"
+
+// Nested classes processing section
+static Hash *classhash = 0;
+
+static String *make_name(Node *n, String *name, SwigType *decl) {
+ int destructor = name && (*(Char(name)) == '~');
+ if (String *yyrename = Getattr(n, "class_rename")) {
+ String *s = NewString(yyrename);
+ Delattr(n, "class_rename");
+ if (destructor && (*(Char(s)) != '~')) {
+ Insert(s, 0, "~");
+ }
+ return s;
+ }
+
+ if (!name)
+ return 0;
+ return Swig_name_make(n, 0, name, decl, 0);
+}
+
+// C version of add_symbols()
+static void add_symbols_c(Node *n) {
+ String *decl;
+ String *wrn = 0;
+ String *symname = 0;
+ int iscdecl = Cmp(nodeType(n), "cdecl") == 0;
+ Setattr(n, "ismember", "1");
+ Setattr(n, "access", "public");
+ if (Getattr(n, "sym:name"))
+ return;
+ decl = Getattr(n, "decl");
+ if (!SwigType_isfunction(decl)) {
+ String *name = Getattr(n, "name");
+ String *makename = Getattr(n, "parser:makename");
+ if (iscdecl) {
+ String *storage = Getattr(n, "storage");
+ if (Cmp(storage, "typedef") == 0) {
+ Setattr(n, "kind", "typedef");
+ } else {
+ SwigType *type = Getattr(n, "type");
+ String *value = Getattr(n, "value");
+ Setattr(n, "kind", "variable");
+ if (value && Len(value)) {
+ Setattr(n, "hasvalue", "1");
+ }
+ if (type) {
+ SwigType *ty;
+ SwigType *tmp = 0;
+ if (decl) {
+ ty = tmp = Copy(type);
+ SwigType_push(ty, decl);
+ } else {
+ ty = type;
+ }
+ if (!SwigType_ismutable(ty)) {
+ SetFlag(n, "hasconsttype");
+ SetFlag(n, "feature:immutable");
+ }
+ if (tmp)
+ Delete(tmp);
+ }
+ if (!type) {
+ Printf(stderr, "notype name %s\n", name);
+ }
+ }
+ }
+ Swig_features_get(Swig_cparse_features(), 0, name, 0, n);
+ if (makename) {
+ symname = make_name(n, makename, 0);
+ Delattr(n, "parser:makename"); /* temporary information, don't leave it hanging around */
+ } else {
+ makename = name;
+ symname = make_name(n, makename, 0);
+ }
+
+ if (!symname) {
+ symname = Copy(Getattr(n, "unnamed"));
+ }
+ if (symname) {
+ wrn = Swig_name_warning(n, 0, symname, 0);
+ }
+ } else {
+ String *name = Getattr(n, "name");
+ SwigType *fdecl = Copy(decl);
+ SwigType *fun = SwigType_pop_function(fdecl);
+ if (iscdecl) {
+ Setattr(n, "kind", "function");
+ }
+
+ Swig_features_get(Swig_cparse_features(), 0, name, fun, n);
+
+ symname = make_name(n, name, fun);
+ wrn = Swig_name_warning(n, 0, symname, fun);
+
+ Delete(fdecl);
+ Delete(fun);
+
+ }
+ if (!symname)
+ return;
+ if (GetFlag(n, "feature:ignore")) {
+ /* Only add to C symbol table and continue */
+ Swig_symbol_add(0, n);
+ } else if (strncmp(Char(symname), "$ignore", 7) == 0) {
+ char *c = Char(symname) + 7;
+ SetFlag(n, "feature:ignore");
+ if (strlen(c)) {
+ SWIG_WARN_NODE_BEGIN(n);
+ Swig_warning(0, Getfile(n), Getline(n), "%s\n", c + 1);
+ SWIG_WARN_NODE_END(n);
+ }
+ Swig_symbol_add(0, n);
+ } else {
+ Node *c;
+ if ((wrn) && (Len(wrn))) {
+ String *metaname = symname;
+ if (!Getmeta(metaname, "already_warned")) {
+ SWIG_WARN_NODE_BEGIN(n);
+ Swig_warning(0, Getfile(n), Getline(n), "%s\n", wrn);
+ SWIG_WARN_NODE_END(n);
+ Setmeta(metaname, "already_warned", "1");
+ }
+ }
+ c = Swig_symbol_add(symname, n);
+
+ if (c != n) {
+ /* symbol conflict attempting to add in the new symbol */
+ if (Getattr(n, "sym:weak")) {
+ Setattr(n, "sym:name", symname);
+ } else {
+ String *e = NewStringEmpty();
+ String *en = NewStringEmpty();
+ String *ec = NewStringEmpty();
+ int redefined = Swig_need_redefined_warn(n, c, true);
+ if (redefined) {
+ Printf(en, "Identifier '%s' redefined (ignored)", symname);
+ Printf(ec, "previous definition of '%s'", symname);
+ } else {
+ Printf(en, "Redundant redeclaration of '%s'", symname);
+ Printf(ec, "previous declaration of '%s'", symname);
+ }
+ if (Cmp(symname, Getattr(n, "name"))) {
+ Printf(en, " (Renamed from '%s')", SwigType_namestr(Getattr(n, "name")));
+ }
+ Printf(en, ",");
+ if (Cmp(symname, Getattr(c, "name"))) {
+ Printf(ec, " (Renamed from '%s')", SwigType_namestr(Getattr(c, "name")));
+ }
+ Printf(ec, ".");
+ SWIG_WARN_NODE_BEGIN(n);
+ if (redefined) {
+ Swig_warning(WARN_PARSE_REDEFINED, Getfile(n), Getline(n), "%s\n", en);
+ Swig_warning(WARN_PARSE_REDEFINED, Getfile(c), Getline(c), "%s\n", ec);
+ } else {
+ Swig_warning(WARN_PARSE_REDUNDANT, Getfile(n), Getline(n), "%s\n", en);
+ Swig_warning(WARN_PARSE_REDUNDANT, Getfile(c), Getline(c), "%s\n", ec);
+ }
+ SWIG_WARN_NODE_END(n);
+ Printf(e, "%s:%d:%s\n%s:%d:%s\n", Getfile(n), Getline(n), en, Getfile(c), Getline(c), ec);
+ Setattr(n, "error", e);
+ Delete(e);
+ Delete(en);
+ Delete(ec);
+ }
+ }
+ }
+ Delete(symname);
+}
+
+/* Strips C-style and C++-style comments from string in-place. */
+static void strip_comments(char *string) {
+ int state = 0;
+ /*
+ * 0 - not in comment
+ * 1 - in c-style comment
+ * 2 - in c++-style comment
+ * 3 - in string
+ * 4 - after reading / not in comments
+ * 5 - after reading * in c-style comments
+ * 6 - after reading \ in strings
+ */
+ char *c = string;
+ while (*c) {
+ switch (state) {
+ case 0:
+ if (*c == '\"')
+ state = 3;
+ else if (*c == '/')
+ state = 4;
+ break;
+ case 1:
+ if (*c == '*')
+ state = 5;
+ *c = ' ';
+ break;
+ case 2:
+ if (*c == '\n')
+ state = 0;
+ else
+ *c = ' ';
+ break;
+ case 3:
+ if (*c == '\"')
+ state = 0;
+ else if (*c == '\\')
+ state = 6;
+ break;
+ case 4:
+ if (*c == '/') {
+ *(c - 1) = ' ';
+ *c = ' ';
+ state = 2;
+ } else if (*c == '*') {
+ *(c - 1) = ' ';
+ *c = ' ';
+ state = 1;
+ } else
+ state = 0;
+ break;
+ case 5:
+ if (*c == '/')
+ state = 0;
+ else
+ state = 1;
+ *c = ' ';
+ break;
+ case 6:
+ state = 3;
+ break;
+ }
+ ++c;
+ }
+}
+
+// Create a %insert with a typedef to make a new name visible to C
+static Node *create_insert(Node *n, bool noTypedef = false) {
+ // format a typedef
+ String *ccode = Getattr(n, "code");
+ Push(ccode, " ");
+ if (noTypedef) {
+ Push(ccode, Getattr(n, "name"));
+ Push(ccode, " ");
+ Push(ccode, Getattr(n, "kind"));
+ } else {
+ Push(ccode, Getattr(n, "kind"));
+ Push(ccode, "typedef ");
+ Append(ccode, " ");
+ Append(ccode, Getattr(n, "tdname"));
+ }
+ Append(ccode, ";");
+
+ /* Strip comments - further code may break in presence of comments. */
+ strip_comments(Char(ccode));
+
+ /* Make all SWIG created typedef structs/unions/classes unnamed else
+ redefinition errors occur - nasty hack alert. */
+ if (!noTypedef) {
+ const char *types_array[3] = { "struct", "union", "class" };
+ for (int i = 0; i < 3; i++) {
+ char *code_ptr = Char(ccode);
+ while (code_ptr) {
+ /* Replace struct name (as in 'struct name {...}' ) with whitespace
+ name will be between struct and opening brace */
+
+ code_ptr = strstr(code_ptr, types_array[i]);
+ if (code_ptr) {
+ char *open_bracket_pos;
+ code_ptr += strlen(types_array[i]);
+ open_bracket_pos = strchr(code_ptr, '{');
+ if (open_bracket_pos) {
+ /* Make sure we don't have something like struct A a; */
+ char *semi_colon_pos = strchr(code_ptr, ';');
+ if (!(semi_colon_pos && (semi_colon_pos < open_bracket_pos)))
+ while (code_ptr < open_bracket_pos)
+ *code_ptr++ = ' ';
+ }
+ }
+ }
+ }
+ }
+ {
+ /* Remove SWIG directive %constant which may be left in the SWIG created typedefs */
+ char *code_ptr = Char(ccode);
+ while (code_ptr) {
+ code_ptr = strstr(code_ptr, "%constant");
+ if (code_ptr) {
+ char *directive_end_pos = strchr(code_ptr, ';');
+ if (directive_end_pos) {
+ while (code_ptr <= directive_end_pos)
+ *code_ptr++ = ' ';
+ }
+ }
+ }
+ }
+ Node *newnode = NewHash();
+ set_nodeType(newnode, "insert");
+ Setfile(newnode, Getfile(n));
+ Setline(newnode, Getline(n));
+ String *code = NewStringEmpty();
+ Wrapper_pretty_print(ccode, code);
+ Setattr(newnode, "code", code);
+ Delete(code);
+ Delattr(n, "code");
+ return newnode;
+}
+
+static void insertNodeAfter(Node *n, Node *c) {
+ Node *g = parentNode(n);
+ set_parentNode(c, g);
+ Node *ns = nextSibling(n);
+ if (Node *outer = Getattr(c, "nested:outer")) {
+ while (ns && outer == Getattr(ns, "nested:outer")) {
+ n = ns;
+ ns = nextSibling(n);
+ }
+ }
+ if (!ns) {
+ set_lastChild(g, c);
+ } else {
+ set_nextSibling(c, ns);
+ set_previousSibling(ns, c);
+ }
+ set_nextSibling(n, c);
+ set_previousSibling(c, n);
+}
+
+void Swig_nested_name_unnamed_c_structs(Node *n) {
+ if (!n)
+ return;
+ if (!classhash)
+ classhash = Getattr(n, "classes");
+ Node *c = firstChild(n);
+ while (c) {
+ Node *next = nextSibling(c);
+ if (String *declName = Getattr(c, "nested:unnamed")) {
+ if (Node *outer = Getattr(c, "nested:outer")) {
+ // generate a name
+ String *name = NewStringf("%s_%s", Getattr(outer, "name"), declName);
+ Delattr(c, "nested:unnamed");
+ // set the name to the class and symbol table
+ Setattr(c, "tdname", name);
+ Setattr(c, "name", name);
+ Swig_symbol_setscope(Getattr(c, "symtab"));
+ Swig_symbol_setscopename(name);
+ // now that we have a name - gather base symbols
+ if (List *publicBases = Getattr(c, "baselist")) {
+ List *bases = Swig_make_inherit_list(name, publicBases, 0);
+ Swig_inherit_base_symbols(bases);
+ Delete(bases);
+ }
+ Setattr(classhash, name, c);
+
+ // Merge the extension into the symbol table
+ if (Node *am = Getattr(Swig_extend_hash(), name)) {
+ Swig_extend_merge(c, am);
+ Swig_extend_append_previous(c, am);
+ Delattr(Swig_extend_hash(), name);
+ }
+ Swig_symbol_popscope();
+
+ // process declarations following this type (assign correct new type)
+ SwigType *ty = Copy(name);
+ Node *decl = nextSibling(c);
+ List *declList = NewList();
+ while (decl && Getattr(decl, "nested:unnamedtype") == c) {
+ Setattr(decl, "type", ty);
+ Append(declList, decl);
+ Delattr(decl, "nested:unnamedtype");
+ SetFlag(decl, "feature:immutable");
+ add_symbols_c(decl);
+ decl = nextSibling(decl);
+ }
+ Delete(ty);
+ Swig_symbol_setscope(Swig_symbol_global_scope());
+ add_symbols_c(c);
+
+ Node *ins = create_insert(c);
+ insertNodeAfter(c, ins);
+ removeNode(c);
+ insertNodeAfter(n, c);
+ Delete(ins);
+ Delattr(c, "nested:outer");
+ } else {
+ // global unnamed struct - ignore it and it's instances
+ SetFlag(c, "feature:ignore");
+ while (next && Getattr(next, "nested:unnamedtype") == c) {
+ SetFlag(next, "feature:ignore");
+ next = nextSibling(next);
+ }
+ c = next;
+ continue;
+ }
+ } else if (cparse_cplusplusout) {
+ if (Getattr(c, "nested:outer")) {
+ Node *ins = create_insert(c, true);
+ insertNodeAfter(c, ins);
+ Delete(ins);
+ Delattr(c, "nested:outer");
+ }
+ }
+ // process children
+ Swig_nested_name_unnamed_c_structs(c);
+ c = next;
+ }
+}
+
+static void remove_outer_class_reference(Node *n) {
+ for (Node *c = firstChild(n); c; c = nextSibling(c)) {
+ if (GetFlag(c, "feature:flatnested") || Language::instance()->nestedClassesSupport() == Language::NCS_None) {
+ Delattr(c, "nested:outer");
+ remove_outer_class_reference(c);
+ }
+ }
+}
+
+void Swig_nested_process_classes(Node *n) {
+ if (!n)
+ return;
+ Node *c = firstChild(n);
+ while (c) {
+ Node *next = nextSibling(c);
+ if (!Getattr(c, "templatetype")) {
+ if (GetFlag(c, "nested") && (GetFlag(c, "feature:flatnested") || Language::instance()->nestedClassesSupport() == Language::NCS_None)) {
+ removeNode(c);
+ if (!checkAttribute(c, "access", "public"))
+ SetFlag(c, "feature:ignore");
+ else if (Strcmp(nodeType(n),"extend") == 0 && Strcmp(nodeType(parentNode(n)),"class") == 0)
+ insertNodeAfter(parentNode(n), c);
+ else
+ insertNodeAfter(n, c);
+ }
+ Swig_nested_process_classes(c);
+ }
+ c = next;
+ }
+ remove_outer_class_reference(n);
+}
+
#include <ctype.h>
-static const char *usage = (char *) "\
+static const char *usage = "\
Ocaml Options (available with -ocaml)\n\
-oldvarnames - Old intermediary method names for variable wrappers\n\
-prefix <name> - Set a prefix <name> to be prepended to all names\n\
- -suffix <name> - Change .cxx to something else\n\
+ -suffix <name> - Deprecated alias for general option -cppext\n\
-where - Emit library location\n\
\n";
static int static_member_function = 0;
static int generate_sizeof = 0;
static String *prefix = 0;
-static char *ocaml_path = (char *) "ocaml";
+static const char *ocaml_path = "ocaml";
static bool old_variable_names = false;
static String *classname = 0;
static String *module = 0;
}
} else if (strcmp(argv[i], "-suffix") == 0) {
if (argv[i + 1]) {
+ Printf(stderr, "swig: warning: -suffix option deprecated. SWIG 3.0.4 and later provide a -cppext option which should be used instead.\n");
SWIG_config_cppext(argv[i + 1]);
Swig_mark_arg(i);
Swig_mark_arg(i + 1);
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGOCAML\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGOCAML\n#define SWIGOCAML\n#endif\n\n");
+
Printf(f_runtime, "#define SWIG_MODULE \"%s\"\n", module);
/* Module name */
Printf(f_mlbody, "let module_name = \"%s\"\n", module);
if (directorsEnabled()) {
// Insert director runtime into the f_runtime file (make it occur before %header section)
+ Swig_insert_file("director_common.swg", f_runtime);
Swig_insert_file("director.swg", f_runtime);
}
}
/* if the object is a director, and the method call originated from its
- * underlying python object, resolve the call by going up the c++
- * inheritance chain. otherwise try to resolve the method in python.
- * without this check an infinite loop is set up between the director and
+ * underlying ocaml object, resolve the call by going up the c++
+ * inheritance chain. otherwise try to resolve the method in ocaml.
+ * without this check an infinite loop is set up between the director and
* shadow class method calls.
*/
find_marker += strlen("(*Stream:");
if (next) {
- int num_chars = next - find_marker;
+ int num_chars = (int)(next - find_marker);
String *stream_name = NewString(find_marker);
Delslice(stream_name, num_chars, Len(stream_name));
File *fout = Swig_filebyname(stream_name);
if (!following)
following = next + strlen(next);
String *chunk = NewString(next);
- Delslice(chunk, following - next, Len(chunk));
+ Delslice(chunk, (int)(following - next), Len(chunk));
Printv(fout, chunk, NIL);
}
}
* typedef enum and enum are handled. I need to produce consistent names,
* which means looking up and registering by typedef and enum name. */
int enumDeclaration(Node *n) {
+ if (getCurrentClass() && (cplus_mode != PUBLIC))
+ return SWIG_NOWRAP;
+
String *name = Getattr(n, "name");
if (name) {
String *oname = NewString(name);
/*
* Modified polymorphism code for Ocaml language module.
- * Original:
- * C++/Python polymorphism demo code, copyright (C) 2002 Mark Rose
- * <mrose@stm.lbl.gov>
*
* TODO
*
/* -----------------------------------------------------------------------------
- * This file is part of SWIG, which is licensed as a whole under version 3
+ * This file is part of SWIG, which is licensed as a whole under version 3
* (or any later version) of the GNU General Public License. Some additional
* terms also apply to certain portions of SWIG. The full details of the SWIG
* license and copyrights can be found in the LICENSE and COPYRIGHT files
* ----------------------------------------------------------------------------- */
#include "swigmod.h"
+#include "cparse.h"
static String *global_name = 0;
static String *op_prefix = 0;
-static const char *usage = (char *) "\
+static const char *usage = "\
Octave Options (available with -octave)\n\
+ -cppcast - Enable C++ casting operators (default)\n\
-globals <name> - Set <name> used to access C global variables [default: 'cvar']\n\
Use '.' to load C global variables into module namespace\n\
+ -nocppcast - Disable C++ casting operators\n\
-opprefix <str> - Prefix <str> for global operator functions [default: 'op_']\n\
\n";
constructor_name(0),
docs(0)
{
- /* Add code to manage protected constructors and directors */
- director_prot_ctor_code = NewString("");
- Printv(director_prot_ctor_code,
- "if ( $comparison ) { /* subclassed */\n",
- " $director_new \n",
- "} else {\n", " error(\"accessing abstract class or protected constructor\"); \n", " SWIG_fail;\n", "}\n", NIL);
-
- enable_cplus_runtime_mode();
- allow_overloading();
- director_multiple_inheritance = 1;
- director_language = 1;
- docs = NewHash();
- }
+ /* Add code to manage protected constructors and directors */
+ director_prot_ctor_code = NewString("");
+ Printv(director_prot_ctor_code,
+ "if ( $comparison ) { /* subclassed */\n",
+ " $director_new \n",
+ "} else {\n", " error(\"accessing abstract class or protected constructor\"); \n", " SWIG_fail;\n", "}\n", NIL);
+
+ enable_cplus_runtime_mode();
+ allow_overloading();
+ director_multiple_inheritance = 1;
+ director_language = 1;
+ docs = NewHash();
+ }
virtual void main(int argc, char *argv[]) {
+ int cppcast = 1;
+
for (int i = 1; i < argc; i++) {
if (argv[i]) {
- if (strcmp(argv[i], "-help") == 0) {
- fputs(usage, stdout);
- } else if (strcmp(argv[i], "-global") == 0 ||
- strcmp(argv[i], "-noglobal") == 0) {
- Printv(stderr,
- "*** -global/-noglobal are no longer supported\n"
- "*** global load behaviour is now determined at module load\n"
- "*** see the Perl section in the manual for details.\n", NIL);
- SWIG_exit(EXIT_FAILURE);
- } else if (strcmp(argv[i], "-globals") == 0) {
- if (argv[i + 1]) {
- global_name = NewString(argv[i + 1]);
- Swig_mark_arg(i);
- Swig_mark_arg(i + 1);
- i++;
- } else {
- Swig_arg_error();
- }
- } else if (strcmp(argv[i], "-opprefix") == 0) {
- if (argv[i + 1]) {
- op_prefix = NewString(argv[i + 1]);
- Swig_mark_arg(i);
- Swig_mark_arg(i + 1);
- i++;
- } else {
- Swig_arg_error();
- }
- }
+ if (strcmp(argv[i], "-help") == 0) {
+ fputs(usage, stdout);
+ } else if (strcmp(argv[i], "-globals") == 0) {
+ if (argv[i + 1]) {
+ global_name = NewString(argv[i + 1]);
+ Swig_mark_arg(i);
+ Swig_mark_arg(i + 1);
+ i++;
+ } else {
+ Swig_arg_error();
+ }
+ } else if (strcmp(argv[i], "-opprefix") == 0) {
+ if (argv[i + 1]) {
+ op_prefix = NewString(argv[i + 1]);
+ Swig_mark_arg(i);
+ Swig_mark_arg(i + 1);
+ i++;
+ } else {
+ Swig_arg_error();
+ }
+ } else if (strcmp(argv[i], "-cppcast") == 0) {
+ cppcast = 1;
+ Swig_mark_arg(i);
+ } else if (strcmp(argv[i], "-nocppcast") == 0) {
+ cppcast = 0;
+ Swig_mark_arg(i);
+ }
}
}
global_name = NewString("cvar");
if (!op_prefix)
op_prefix = NewString("op_");
+ if(cppcast)
+ Preprocessor_define((DOH *) "SWIG_CPLUSPLUS_CAST", 0);
SWIG_library_directory("octave");
Preprocessor_define("SWIGOCTAVE 1", 0);
SWIG_config_file("octave.swg");
SWIG_typemap_lang("octave");
allow_overloading();
+
+ // Octave API is C++, so output must be C++ compatibile even when wrapping C code
+ if (!cparse_cplusplus)
+ Swig_cparse_cplusplusout(1);
}
virtual int top(Node *n) {
{
Node *mod = Getattr(n, "module");
if (mod) {
- Node *options = Getattr(mod, "options");
- if (options) {
- int dirprot = 0;
- if (Getattr(options, "dirprot")) {
- dirprot = 1;
- }
- if (Getattr(options, "nodirprot")) {
- dirprot = 0;
- }
- if (Getattr(options, "directors")) {
- allow_directors();
- if (dirprot)
- allow_dirprot();
- }
- }
+ Node *options = Getattr(mod, "options");
+ if (options) {
+ int dirprot = 0;
+ if (Getattr(options, "dirprot")) {
+ dirprot = 1;
+ }
+ if (Getattr(options, "nodirprot")) {
+ dirprot = 0;
+ }
+ if (Getattr(options, "directors")) {
+ allow_directors();
+ if (dirprot)
+ allow_dirprot();
+ }
+ }
}
}
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGOCTAVE\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGOCTAVE\n#define SWIGOCTAVE\n#endif\n\n");
+
Printf(f_runtime, "#define SWIG_name_d \"%s\"\n", module);
Printf(f_runtime, "#define SWIG_name %s\n", module);
Printf(f_runtime, "#define SWIG_DIRECTORS\n");
Swig_banner(f_directors_h);
if (dirprot_mode()) {
- // Printf(f_directors_h, "#include <map>\n");
- // Printf(f_directors_h, "#include <string>\n\n");
+ // Printf(f_directors_h, "#include <map>\n");
+ // Printf(f_directors_h, "#include <string>\n\n");
}
}
if (Len(docs))
emit_doc_texinfo();
- if (directorsEnabled())
+ if (directorsEnabled()) {
+ Swig_insert_file("director_common.swg", f_runtime);
Swig_insert_file("director.swg", f_runtime);
+ }
Printf(f_init, "return true;\n}\n");
- Printf(s_global_tab, "{0,0,0,0,0}\n};\n");
+ Printf(s_global_tab, "{0,0,0,0,0,0}\n};\n");
Printv(f_wrappers, s_global_tab, NIL);
SwigType_emit_type_table(f_runtime, f_wrappers);
String *r = NewString("");
for (int j=0;s[j];++j) {
if (s[j] == '\n') {
- Append(r, "\\n\\\n");
+ Append(r, "\\n\\\n");
} else if (s[j] == '\r') {
- Append(r, "\\r");
+ Append(r, "\\r");
} else if (s[j] == '\t') {
- Append(r, "\\t");
+ Append(r, "\\t");
} else if (s[j] == '\\') {
- Append(r, "\\\\");
+ Append(r, "\\\\");
} else if (s[j] == '\'') {
- Append(r, "\\\'");
+ Append(r, "\\\'");
} else if (s[j] == '\"') {
- Append(r, "\\\"");
+ Append(r, "\\\"");
} else
- Putc(s[j], r);
+ Putc(s[j], r);
}
return r;
}
String *escaped_doc_str = texinfo_escape(doc_str);
if (Len(doc_str)>0) {
- Printf(f_doc,"static const char* %s_texinfo = ",wrap_name);
- Printf(f_doc,"\"-*- texinfo -*-\\n\\\n%s", escaped_doc_str);
- if (Len(decl_info))
- Printf(f_doc,"\\n\\\n@end deftypefn");
- Printf(f_doc,"\";\n");
+ Printf(f_doc,"static const char* %s_texinfo = ",wrap_name);
+ Printf(f_doc,"\"-*- texinfo -*-\\n\\\n%s", escaped_doc_str);
+ if (Len(decl_info))
+ Printf(f_doc,"\\n\\\n@end deftypefn");
+ Printf(f_doc,"\";\n");
}
Delete(escaped_doc_str);
String *decl_info = Getattr(n, "decl_info");
String *cdecl_info = Getattr(n, "cdecl_info");
String *args_info = Getattr(n, "args_info");
- return !Len(synopsis) && !Len(decl_info) &&
+ return !Len(synopsis) && !Len(decl_info) &&
!Len(cdecl_info) && !Len(args_info);
}
String *texinfo_name(Node* n, const char* defval = "0") {
SwigType *type = Getattr(n, "type");
if (type && Strcmp(type, "void")) {
- Node *nn = classLookup(Getattr(n, "type"));
- String *type_str = nn ? Copy(Getattr(nn, "sym:name")) : SwigType_str(type, 0);
- Append(decl_info, "@var{retval} = ");
- Printf(args_str, "%s@var{retval} is of type %s. ", args_str, type_str);
- Delete(type_str);
+ Node *nn = classLookup(Getattr(n, "type"));
+ String *type_str = nn ? Copy(Getattr(nn, "sym:name")) : SwigType_str(type, 0);
+ Append(decl_info, "@var{retval} = ");
+ Printf(args_str, "%s@var{retval} is of type %s. ", args_str, type_str);
+ Delete(type_str);
}
Append(decl_info, name);
// strip off {} if necessary
char *t = Char(str);
if (*t == '{') {
- Delitem(str, 0);
- Delitem(str, DOH_END);
+ Delitem(str, 0);
+ Delitem(str, DOH_END);
}
// emit into synopsis section
* addMissingParameterNames()
* For functions that have not had nameless parameters set in the Language class.
*
- * Inputs:
+ * Inputs:
* plist - entire parameter list
* arg_offset - argument number for first parameter
* Side effects:
int i = arg_offset;
while (p) {
if (!Getattr(p, "lname")) {
- String *pname = Swig_cparm_name(p, i);
- Delete(pname);
+ String *pname = Swig_cparm_name(p, i);
+ Delete(pname);
}
i++;
p = nextSibling(p);
String *tm = Getattr(p, "tmap:in");
if (tm) {
- pnext = Getattr(p, "tmap:in:next");
- if (checkAttribute(p, "tmap:in:numinputs", "0")) {
- continue;
- }
+ pnext = Getattr(p, "tmap:in:next");
+ if (checkAttribute(p, "tmap:in:numinputs", "0")) {
+ continue;
+ }
} else {
- pnext = nextSibling(p);
+ pnext = nextSibling(p);
}
String *name = 0;
String *value = 0;
String *pdoc = Getattr(p, "tmap:doc");
if (pdoc) {
- name = Getattr(p, "tmap:doc:name");
- type = Getattr(p, "tmap:doc:type");
- value = Getattr(p, "tmap:doc:value");
+ name = Getattr(p, "tmap:doc:name");
+ type = Getattr(p, "tmap:doc:type");
+ value = Getattr(p, "tmap:doc:value");
}
- // Note: the generated name should be consistent with that in kwnames[]
name = name ? name : Getattr(p, "name");
name = name ? name : Getattr(p, "lname");
name = Swig_name_make(p, 0, name, 0, 0); // rename parameter if a keyword
value = value ? value : Getattr(p, "value");
if (SwigType_isvarargs(type))
- break;
+ break;
String *tex_name = NewString("");
if (name)
- Printf(tex_name, "@var{%s}", name);
+ Printf(tex_name, "@var{%s}", name);
else
- Printf(tex_name, "@var{?}");
+ Printf(tex_name, "@var{?}");
if (Len(decl_str))
- Append(decl_str, ", ");
+ Append(decl_str, ", ");
Append(decl_str, tex_name);
if (value) {
- String *new_value = convertValue(value, Getattr(p, "type"));
- if (new_value) {
- value = new_value;
- } else {
- Node *lookup = Swig_symbol_clookup(value, 0);
- if (lookup)
- value = Getattr(lookup, "sym:name");
- }
- Printf(decl_str, " = %s", value);
+ String *new_value = convertValue(value, Getattr(p, "type"));
+ if (new_value) {
+ value = new_value;
+ } else {
+ Node *lookup = Swig_symbol_clookup(value, 0);
+ if (lookup)
+ value = Getattr(lookup, "sym:name");
+ }
+ Printf(decl_str, " = %s", value);
}
Node *nn = classLookup(Getattr(p, "type"));
if (v && Len(v) > 0) {
char fc = (Char(v))[0];
if (('0' <= fc && fc <= '9') || '\'' == fc || '"' == fc) {
- /* number or string (or maybe NULL pointer) */
- if (SwigType_ispointer(t) && Strcmp(v, "0") == 0)
- return NewString("None");
- else
- return v;
+ /* number or string (or maybe NULL pointer) */
+ if (SwigType_ispointer(t) && Strcmp(v, "0") == 0)
+ return NewString("None");
+ else
+ return v;
}
- if (Strcmp(v, "NULL") == 0)
- return SwigType_ispointer(t) ? NewString("nil") : NewString("0");
+ if (Strcmp(v, "NULL") == 0 || Strcmp(v, "nullptr") == 0)
+ return SwigType_ispointer(t) ? NewString("nil") : NewString("0");
if (Strcmp(v, "true") == 0 || Strcmp(v, "TRUE") == 0)
- return NewString("true");
+ return NewString("true");
if (Strcmp(v, "false") == 0 || Strcmp(v, "FALSE") == 0)
- return NewString("false");
+ return NewString("false");
}
return 0;
}
int varargs = emit_isvarargs(l);
char source[64];
- Printf(f->code, "if (!SWIG_check_num_args(\"%s\",args.length(),%i,%i,%i)) "
- "{\n SWIG_fail;\n }\n", iname, num_arguments, num_required, varargs);
+ Printf(f->code, "if (!SWIG_check_num_args(\"%s\",args.length(),%i,%i,%i)) "
+ "{\n SWIG_fail;\n }\n", iname, num_arguments, num_required, varargs);
if (constructor && num_arguments == 1 && num_required == 1) {
if (Cmp(storage, "explicit") == 0) {
- Node *parent = Swig_methodclass(n);
- if (GetFlag(parent, "feature:implicitconv")) {
- String *desc = NewStringf("SWIGTYPE%s", SwigType_manglestr(Getattr(n, "type")));
- Printf(f->code, "if (SWIG_CheckImplicit(%s)) SWIG_fail;\n", desc);
- Delete(desc);
- }
+ Node *parent = Swig_methodclass(n);
+ if (GetFlag(parent, "feature:implicitconv")) {
+ String *desc = NewStringf("SWIGTYPE%s", SwigType_manglestr(Getattr(n, "type")));
+ Printf(f->code, "if (SWIG_CheckImplicit(%s)) SWIG_fail;\n", desc);
+ Delete(desc);
+ }
}
}
for (j = 0, p = l; j < num_arguments; ++j) {
while (checkAttribute(p, "tmap:in:numinputs", "0")) {
- p = Getattr(p, "tmap:in:next");
+ p = Getattr(p, "tmap:in:next");
}
SwigType *pt = Getattr(p, "type");
String *tm = Getattr(p, "tmap:in");
if (tm) {
- if (!tm || checkAttribute(p, "tmap:in:numinputs", "0")) {
- p = nextSibling(p);
- continue;
- }
-
- sprintf(source, "args(%d)", j);
- Setattr(p, "emit:input", source);
-
- Replaceall(tm, "$source", Getattr(p, "emit:input"));
- Replaceall(tm, "$input", Getattr(p, "emit:input"));
- Replaceall(tm, "$target", Getattr(p, "lname"));
-
- if (Getattr(p, "wrap:disown") || (Getattr(p, "tmap:in:disown"))) {
- Replaceall(tm, "$disown", "SWIG_POINTER_DISOWN");
- } else {
- Replaceall(tm, "$disown", "0");
- }
-
- if (Getattr(p, "tmap:in:implicitconv")) {
- const char *convflag = "0";
- if (!Getattr(p, "hidden")) {
- SwigType *ptype = Getattr(p, "type");
- convflag = get_implicitconv_flag(classLookup(ptype));
- }
- Replaceall(tm, "$implicitconv", convflag);
- Setattr(p, "implicitconv", convflag);
- }
-
- String *getargs = NewString("");
- if (j >= num_required)
- Printf(getargs, "if (%d<args.length()) {\n%s\n}", j, tm);
- else
- Printv(getargs, tm, NIL);
- Printv(f->code, getargs, "\n", NIL);
- Delete(getargs);
-
- p = Getattr(p, "tmap:in:next");
- continue;
+ if (!tm || checkAttribute(p, "tmap:in:numinputs", "0")) {
+ p = nextSibling(p);
+ continue;
+ }
+
+ sprintf(source, "args(%d)", j);
+ Setattr(p, "emit:input", source);
+
+ Replaceall(tm, "$source", Getattr(p, "emit:input"));
+ Replaceall(tm, "$input", Getattr(p, "emit:input"));
+ Replaceall(tm, "$target", Getattr(p, "lname"));
+
+ if (Getattr(p, "wrap:disown") || (Getattr(p, "tmap:in:disown"))) {
+ Replaceall(tm, "$disown", "SWIG_POINTER_DISOWN");
+ } else {
+ Replaceall(tm, "$disown", "0");
+ }
+
+ if (Getattr(p, "tmap:in:implicitconv")) {
+ const char *convflag = "0";
+ if (!Getattr(p, "hidden")) {
+ SwigType *ptype = Getattr(p, "type");
+ convflag = get_implicitconv_flag(classLookup(ptype));
+ }
+ Replaceall(tm, "$implicitconv", convflag);
+ Setattr(p, "implicitconv", convflag);
+ }
+
+ String *getargs = NewString("");
+ if (j >= num_required)
+
Printf(getargs, "if (%d<args.length()) {\n%s\n}", j, tm);
+ else
+ Printv(getargs, tm, NIL);
+ Printv(f->code, getargs, "\n", NIL);
+ Delete(getargs);
+
+ p = Getattr(p, "tmap:in:next");
+ continue;
} else {
- Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument.\n", SwigType_str(pt, 0));
- break;
+ Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument.\n", SwigType_str(pt, 0));
+ break;
}
}
// Check for trailing varargs
if (varargs) {
if (p && (tm = Getattr(p, "tmap:in"))) {
- Replaceall(tm, "$input", "varargs");
- Printv(f->code, tm, "\n", NIL);
+ Replaceall(tm, "$input", "varargs");
+ Printv(f->code, tm, "\n", NIL);
}
}
// Insert constraint checking code
for (p = l; p;) {
if ((tm = Getattr(p, "tmap:check"))) {
- Replaceall(tm, "$target", Getattr(p, "lname"));
- Printv(f->code, tm, "\n", NIL);
- p = Getattr(p, "tmap:check:next");
+ Replaceall(tm, "$target", Getattr(p, "lname"));
+ Printv(f->code, tm, "\n", NIL);
+ p = Getattr(p, "tmap:check:next");
} else {
- p = nextSibling(p);
+ p = nextSibling(p);
}
}
String *cleanup = NewString("");
for (p = l; p;) {
if ((tm = Getattr(p, "tmap:freearg"))) {
- if (Getattr(p, "tmap:freearg:implicitconv")) {
- const char *convflag = "0";
- if (!Getattr(p, "hidden")) {
- SwigType *ptype = Getattr(p, "type");
- convflag = get_implicitconv_flag(classLookup(ptype));
- }
- if (strcmp(convflag, "0") == 0) {
- tm = 0;
- }
- }
- if (tm && (Len(tm) != 0)) {
- Replaceall(tm, "$source", Getattr(p, "lname"));
- Printv(cleanup, tm, "\n", NIL);
- }
- p = Getattr(p, "tmap:freearg:next");
+ if (Getattr(p, "tmap:freearg:implicitconv")) {
+ const char *convflag = "0";
+ if (!Getattr(p, "hidden")) {
+ SwigType *ptype = Getattr(p, "type");
+ convflag = get_implicitconv_flag(classLookup(ptype));
+ }
+ if (strcmp(convflag, "0") == 0) {
+ tm = 0;
+ }
+ }
+ if (tm && (Len(tm) != 0)) {
+ Replaceall(tm, "$source", Getattr(p, "lname"));
+ Printv(cleanup, tm, "\n", NIL);
+ }
+ p = Getattr(p, "tmap:freearg:next");
} else {
- p = nextSibling(p);
+ p = nextSibling(p);
}
}
String *outarg = NewString("");
for (p = l; p;) {
if ((tm = Getattr(p, "tmap:argout"))) {
- Replaceall(tm, "$source", Getattr(p, "lname"));
- Replaceall(tm, "$target", "_outp");
- Replaceall(tm, "$result", "_outp");
- Replaceall(tm, "$arg", Getattr(p, "emit:input"));
- Replaceall(tm, "$input", Getattr(p, "emit:input"));
- Printv(outarg, tm, "\n", NIL);
- p = Getattr(p, "tmap:argout:next");
+ Replaceall(tm, "$source", Getattr(p, "lname"));
+ Replaceall(tm, "$target", "_outp");
+ Replaceall(tm, "$result", "_outp");
+ Replaceall(tm, "$arg", Getattr(p, "emit:input"));
+ Replaceall(tm, "$input", Getattr(p, "emit:input"));
+ Printv(outarg, tm, "\n", NIL);
+ p = Getattr(p, "tmap:argout:next");
} else {
- p = nextSibling(p);
+ p = nextSibling(p);
}
}
Replaceall(tm, "$result", "_outv");
if (GetFlag(n, "feature:new"))
- Replaceall(tm, "$owner", "1");
+ Replaceall(tm, "$owner", "1");
else
- Replaceall(tm, "$owner", "0");
+ Replaceall(tm, "$owner", "0");
Printf(f->code, "%s\n", tm);
Printf(f->code, "if (_outv.is_defined()) _outp = " "SWIG_Octave_AppendOutput(_outp, _outv);\n");
if (GetFlag(n, "feature:new")) {
if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) {
- Replaceall(tm, "$source", Swig_cresult_name());
- Printf(f->code, "%s\n", tm);
+ Replaceall(tm, "$source", Swig_cresult_name());
+ Printf(f->code, "%s\n", tm);
}
}
if (is_assignable(n)) {
Setattr(n, "wrap:name", setname);
if ((tm = Swig_typemap_lookup("varin", n, name, 0))) {
- Replaceall(tm, "$source", "args(0)");
- Replaceall(tm, "$target", name);
- Replaceall(tm, "$input", "args(0)");
- if (Getattr(n, "tmap:varin:implicitconv")) {
- Replaceall(tm, "$implicitconv", get_implicitconv_flag(n));
- }
- emit_action_code(n, setf->code, tm);
- Delete(tm);
+ Replaceall(tm, "$source", "args(0)");
+ Replaceall(tm, "$target", name);
+ Replaceall(tm, "$input", "args(0)");
+ if (Getattr(n, "tmap:varin:implicitconv")) {
+ Replaceall(tm, "$implicitconv", get_implicitconv_flag(n));
+ }
+ emit_action_code(n, setf->code, tm);
+ Delete(tm);
} else {
- Swig_warning(WARN_TYPEMAP_VARIN_UNDEF, input_file, line_number, "Unable to set variable of type %s.\n", SwigType_str(t, 0));
+ Swig_warning(WARN_TYPEMAP_VARIN_UNDEF, input_file, line_number, "Unable to set variable of type %s.\n", SwigType_str(t, 0));
}
Append(setf->code, "fail:\n");
Printf(setf->code, "return octave_value_list();\n");
SwigType *t = Copy(Getattr(n, "name"));
SwigType_add_pointer(t);
+ // Replace storing a pointer to underlying class with a smart pointer (intended for use with non-intrusive smart pointers)
+ SwigType *smart = Swig_cparse_smartptr(n);
String *wrap_class = NewStringf("&_wrap_class_%s", class_name);
+ if (smart) {
+ SwigType_add_pointer(smart);
+ SwigType_remember_clientdata(smart, wrap_class);
+ }
+ //String *wrap_class = NewStringf("&_wrap_class_%s", class_name);
SwigType_remember_clientdata(t, wrap_class);
int use_director = Swig_directorclass(n);
Delete(cnameshdw);
}
- Printf(s_members_tab, "{0,0,0,0}\n};\n");
+ Printf(s_members_tab, "{0,0,0,0,0,0}\n};\n");
Printv(f_wrappers, s_members_tab, NIL);
String *base_class_names = NewString("");
int index = 0;
b = First(baselist);
while (b.item) {
- String *bname = Getattr(b.item, "name");
- if ((!bname) || GetFlag(b.item, "feature:ignore") || (!Getattr(b.item, "module"))) {
- b = Next(b);
- continue;
- }
-
- String *bname_mangled = SwigType_manglestr(SwigType_add_pointer(Copy(bname)));
- Printf(base_class_names, "\"%s\",", bname_mangled);
- Printf(base_class, "0,");
- b = Next(b);
- index++;
- Delete(bname_mangled);
+ String *bname = Getattr(b.item, "name");
+ if ((!bname) || GetFlag(b.item, "feature:ignore") || (!Getattr(b.item, "module"))) {
+ b = Next(b);
+ continue;
+ }
+
+ String *bname_mangled = SwigType_manglestr(SwigType_add_pointer(Copy(bname)));
+ Printf(base_class_names, "\"%s\",", bname_mangled);
+ Printf(base_class, "0,");
+ b = Next(b);
+ index++;
+ Delete(bname_mangled);
}
}
Delete(base_class);
Delete(base_class_names);
+ Delete(smart);
Delete(t);
Delete(s_members_tab);
s_members_tab = 0;
bool overloaded = !!Getattr(n, "sym:overloaded");
if (overloaded)
Delslice(rname, Len(rname) - Len(Getattr(n, "sym:overname")), DOH_END);
- Printf(s_members_tab, "{\"%s\",%s,0,0,0,%s},\n",
- realname, rname, tname);
+ Printf(s_members_tab, "{\"%s\",%s,0,0,0,%s},\n",
+ realname, rname, tname);
Delete(rname);
Delete(tname);
}
Delete(name);
Setattr(self, "lname", "self_obj");
if (parms)
- set_nextSibling(self, parms);
+ set_nextSibling(self, parms);
Setattr(n, "parms", self);
Setattr(n, "wrap:self", "1");
Setattr(n, "hidden", "1");
bool overloaded = !!Getattr(n, "sym:overloaded");
if (overloaded)
Delslice(rname, Len(rname) - Len(Getattr(n, "sym:overname")), DOH_END);
- Printf(s_members_tab, "{\"%s\",%s,0,0,1,%s},\n",
- realname, rname, tname);
+ Printf(s_members_tab, "{\"%s\",%s,0,0,1,%s},\n",
+ realname, rname, tname);
Delete(rname);
Delete(tname);
}
-
+
return SWIG_OK;
}
if (!Getattr(n, "defaultargs")) {
// constructor
{
- Wrapper *w = NewWrapper();
- String *call;
- String *basetype = Getattr(parent, "classtype");
- String *target = Swig_method_decl(0, decl, classname, parms, 0, 0);
- call = Swig_csuperclass_call(0, basetype, superparms);
- Printf(w->def, "%s::%s: %s," "\nSwig::Director(static_cast<%s*>(this)) { \n", classname, target, call, basetype);
- Append(w->def, "}\n");
- Delete(target);
- Wrapper_print(w, f_directors);
- Delete(call);
- DelWrapper(w);
+ Wrapper *w = NewWrapper();
+ String *call;
+ String *basetype = Getattr(parent, "classtype");
+ String *target = Swig_method_decl(0, decl, classname, parms, 0, 0);
+ call = Swig_csuperclass_call(0, basetype, superparms);
+ Printf(w->def, "%s::%s: %s," "\nSwig::Director(static_cast<%s*>(this)) { \n", classname, target, call, basetype);
+ Append(w->def, "}\n");
+ Delete(target);
+ Wrapper_print(w, f_directors);
+ Delete(call);
+ DelWrapper(w);
}
// constructor header
{
- String *target = Swig_method_decl(0, decl, classname, parms, 0, 1);
- Printf(f_directors_h, " %s;\n", target);
- Delete(target);
+ String *target = Swig_method_decl(0, decl, classname, parms, 0, 1);
+ Printf(f_directors_h, " %s;\n", target);
+ Delete(target);
}
}
{
Wrapper *w = NewWrapper();
Printf(w->def, "SwigDirector_%s::SwigDirector_%s(void* self) :"
- "\nSwig::Director((octave_swig_type*)self,static_cast<%s*>(this)) { \n", classname, classname, classname);
+ "\nSwig::Director((octave_swig_type*)self,static_cast<%s*>(this)) { \n", classname, classname, classname);
Append(w->def, "}\n");
Wrapper_print(w, f_directors);
DelWrapper(w);
if (Cmp(storage, "virtual") == 0) {
if (Cmp(value, "0") == 0) {
- pure_virtual = true;
+ pure_virtual = true;
}
}
Append(declaration, " throw(");
if (throw_parm_list)
- Swig_typemap_attach_parms("throws", throw_parm_list, 0);
+ Swig_typemap_attach_parms("throws", throw_parm_list, 0);
for (p = throw_parm_list; p; p = nextSibling(p)) {
- if (Getattr(p, "tmap:throws")) {
- if (gencomma++) {
- Append(w->def, ", ");
- Append(declaration, ", ");
- }
- String *str = SwigType_str(Getattr(p, "type"), 0);
- Append(w->def, str);
- Append(declaration, str);
- Delete(str);
- }
+ if (Getattr(p, "tmap:throws")) {
+ if (gencomma++) {
+ Append(w->def, ", ");
+ Append(declaration, ", ");
+ }
+ String *str = SwigType_str(Getattr(p, "type"), 0);
+ Append(w->def, str);
+ Append(declaration, str);
+ Delete(str);
+ }
}
Append(w->def, ")");
Append(w->def, " {");
Append(declaration, ";\n");
- // declare method return value
+ // declare method return value
// if the return value is a reference or const reference, a specialized typemap must
// handle it, including declaration of c_result ($result).
if (!is_void) {
if (!(ignored_method && !pure_virtual)) {
- String *cres = SwigType_lstr(returntype, "c_result");
- Printf(w->code, "%s;\n", cres);
- Delete(cres);
+ String *cres = SwigType_lstr(returntype, "c_result");
+ Printf(w->code, "%s;\n", cres);
+ Delete(cres);
}
}
if (ignored_method) {
if (!pure_virtual) {
- if (!is_void)
- Printf(w->code, "return ");
- String *super_call = Swig_method_call(super, l);
- Printf(w->code, "%s;\n", super_call);
- Delete(super_call);
+ if (!is_void)
+ Printf(w->code, "return ");
+ String *super_call = Swig_method_call(super, l);
+ Printf(w->code, "%s;\n", super_call);
+ Delete(super_call);
} else {
- Printf(w->code, "Swig::DirectorPureVirtualException::raise(\"Attempted to invoke pure virtual method %s::%s\");\n", SwigType_namestr(c_classname),
- SwigType_namestr(name));
+ Printf(w->code, "Swig::DirectorPureVirtualException::raise(\"Attempted to invoke pure virtual method %s::%s\");\n", SwigType_namestr(c_classname),
+ SwigType_namestr(name));
}
} else {
- // attach typemaps to arguments (C/C++ -> Python)
+ // attach typemaps to arguments (C/C++ -> Octave)
String *parse_args = NewString("");
Swig_director_parms_fixup(l);
int outputs = 0;
if (!is_void)
- outputs++;
+ outputs++;
// build argument list and type conversion string
p = l;
while (p) {
- if (checkAttribute(p, "tmap:in:numinputs", "0")) {
- p = Getattr(p, "tmap:in:next");
- continue;
- }
-
- if (Getattr(p, "tmap:directorargout") != 0)
- outputs++;
-
- String *pname = Getattr(p, "name");
- String *ptype = Getattr(p, "type");
- Wrapper_add_local(w, "tmpv", "octave_value tmpv");
-
- if ((tm = Getattr(p, "tmap:directorin")) != 0) {
- String *parse = Getattr(p, "tmap:directorin:parse");
- if (!parse) {
- Setattr(p, "emit:directorinput", "tmpv");
- Replaceall(tm, "$input", "tmpv");
- Replaceall(tm, "$owner", "0");
- Printv(wrap_args, tm, "\n", NIL);
- Printf(wrap_args, "args.append(tmpv);\n");
- Putc('O', parse_args);
- } else {
- Append(parse_args, parse);
- Setattr(p, "emit:directorinput", pname);
- Replaceall(tm, "$input", pname);
- Replaceall(tm, "$owner", "0");
- if (Len(tm) == 0)
- Append(tm, pname);
- }
- p = Getattr(p, "tmap:directorin:next");
- continue;
- } else if (Cmp(ptype, "void")) {
- Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file, line_number,
- "Unable to use type %s as a function argument in director method %s::%s (skipping method).\n", SwigType_str(ptype, 0),
- SwigType_namestr(c_classname), SwigType_namestr(name));
- status = SWIG_NOWRAP;
- break;
- }
- p = nextSibling(p);
+ if (checkAttribute(p, "tmap:in:numinputs", "0")) {
+ p = Getattr(p, "tmap:in:next");
+ continue;
+ }
+
+ if (Getattr(p, "tmap:directorargout") != 0)
+ outputs++;
+
+ String *pname = Getattr(p, "name");
+ String *ptype = Getattr(p, "type");
+ Wrapper_add_local(w, "tmpv", "octave_value tmpv");
+
+ if ((tm = Getattr(p, "tmap:directorin")) != 0) {
+ String *parse = Getattr(p, "tmap:directorin:parse");
+ if (!parse) {
+ Setattr(p, "emit:directorinput", "tmpv");
+ Replaceall(tm, "$input", "tmpv");
+ Replaceall(tm, "$owner", "0");
+ Printv(wrap_args, tm, "\n", NIL);
+ Printf(wrap_args, "args.append(tmpv);\n");
+ Putc('O', parse_args);
+ } else {
+ Append(parse_args, parse);
+ Setattr(p, "emit:directorinput", pname);
+ Replaceall(tm, "$input", pname);
+ Replaceall(tm, "$owner", "0");
+ if (Len(tm) == 0)
+ Append(tm, pname);
+ }
+ p = Getattr(p, "tmap:directorin:next");
+ continue;
+ } else if (Cmp(ptype, "void")) {
+ Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file, line_number,
+ "Unable to use type %s as a function argument in director method %s::%s (skipping method).\n", SwigType_str(ptype, 0),
+ SwigType_namestr(c_classname), SwigType_namestr(name));
+ status = SWIG_NOWRAP;
+ break;
+ }
+ p = nextSibling(p);
}
String *method_name = Getattr(n, "sym:name");
// marshal return value
if (!is_void) {
- Printf(w->code, "if (out.length()<%d) {\n", outputs);
- Printf(w->code, "Swig::DirectorTypeMismatchException::raise(\"Octave "
- "method %s.%s failed to return the required number " "of arguments.\");\n", classname, method_name);
- Printf(w->code, "}\n");
-
- tm = Swig_typemap_lookup("directorout", n, Swig_cresult_name(), w);
- if (tm != 0) {
- char temp[24];
- sprintf(temp, "out(%d)", idx);
- Replaceall(tm, "$input", temp);
- // Replaceall(tm, "$argnum", temp);
- Replaceall(tm, "$disown", Getattr(n, "wrap:disown") ? "SWIG_POINTER_DISOWN" : "0");
- if (Getattr(n, "tmap:directorout:implicitconv")) {
- Replaceall(tm, "$implicitconv", get_implicitconv_flag(n));
- }
- Replaceall(tm, "$result", "c_result");
- Printv(w->code, tm, "\n", NIL);
- Delete(tm);
- } else {
- Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
- "Unable to use return type %s in director method %s::%s (skipping method).\n",
- SwigType_str(returntype, 0), SwigType_namestr(c_classname), SwigType_namestr(name));
- status = SWIG_ERROR;
- }
+ Printf(w->code, "if (out.length()<%d) {\n", outputs);
+ Printf(w->code, "Swig::DirectorTypeMismatchException::raise(\"Octave "
+ "method %s.%s failed to return the required number " "of arguments.\");\n", classname, method_name);
+ Printf(w->code, "}\n");
+
+ tm = Swig_typemap_lookup("directorout", n, Swig_cresult_name(), w);
+ if (tm != 0) {
+ char temp[24];
+ sprintf(temp, "out(%d)", idx);
+ Replaceall(tm, "$input", temp);
+ // Replaceall(tm, "$argnum", temp);
+ Replaceall(tm, "$disown", Getattr(n, "wrap:disown") ? "SWIG_POINTER_DISOWN" : "0");
+ if (Getattr(n, "tmap:directorout:implicitconv")) {
+ Replaceall(tm, "$implicitconv", get_implicitconv_flag(n));
+ }
+ Replaceall(tm, "$result", "c_result");
+ Printv(w->code, tm, "\n", NIL);
+ Delete(tm);
+ } else {
+ Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
+ "Unable to use return type %s in director method %s::%s (skipping method).\n",
+ SwigType_str(returntype, 0), SwigType_namestr(c_classname), SwigType_namestr(name));
+ status = SWIG_ERROR;
+ }
}
idx++;
// marshal outputs
for (p = l; p;) {
- if ((tm = Getattr(p, "tmap:directorargout")) != 0) {
- char temp[24];
- sprintf(temp, "out(%d)", idx);
- Replaceall(tm, "$result", temp);
- Replaceall(tm, "$input", Getattr(p, "emit:directorinput"));
- Printv(w->code, tm, "\n", NIL);
- p = Getattr(p, "tmap:directorargout:next");
- } else {
- p = nextSibling(p);
- }
+ if ((tm = Getattr(p, "tmap:directorargout")) != 0) {
+ char temp[24];
+ sprintf(temp, "out(%d)", idx);
+ Replaceall(tm, "$result", temp);
+ Replaceall(tm, "$input", Getattr(p, "emit:directorinput"));
+ Printv(w->code, tm, "\n", NIL);
+ p = Getattr(p, "tmap:directorargout:next");
+ } else {
+ p = nextSibling(p);
+ }
}
Delete(parse_args);
if (!is_void) {
if (!(ignored_method && !pure_virtual)) {
- String *rettype = SwigType_str(returntype, 0);
- if (!SwigType_isreference(returntype)) {
- Printf(w->code, "return (%s) c_result;\n", rettype);
- } else {
- Printf(w->code, "return (%s) *c_result;\n", rettype);
- }
- Delete(rettype);
+ String *rettype = SwigType_str(returntype, 0);
+ if (!SwigType_isreference(returntype)) {
+ Printf(w->code, "return (%s) c_result;\n", rettype);
+ } else {
+ Printf(w->code, "return (%s) *c_result;\n", rettype);
+ }
+ Delete(rettype);
}
}
Replaceall(inline_extra_method, name, extra_method_name);
Replaceall(inline_extra_method, ";\n", " {\n ");
if (!is_void)
- Printf(inline_extra_method, "return ");
+ Printf(inline_extra_method, "return ");
String *methodcall = Swig_method_call(super, l);
Printv(inline_extra_method, methodcall, ";\n }\n", NIL);
Delete(methodcall);
// emit the director method
if (status == SWIG_OK) {
if (!Getattr(n, "defaultargs")) {
- Replaceall(w->code, "$symname", symname);
- Wrapper_print(w, f_directors);
- Printv(f_directors_h, declaration, NIL);
- Printv(f_directors_h, inline_extra_method, NIL);
+ Replaceall(w->code, "$symname", symname);
+ Wrapper_print(w, f_directors);
+ Printv(f_directors_h, declaration, NIL);
+ Printv(f_directors_h, inline_extra_method, NIL);
}
}
// clean up
String *t2 = Getattr(p2, "tmap:typecheck:precedence");
if ((!t1) && (!nodes[i].error)) {
Swig_warning(WARN_TYPEMAP_TYPECHECK, Getfile(nodes[i].n), Getline(nodes[i].n),
- "Overloaded method %s not supported (no type checking rule for '%s').\n",
+ "Overloaded method %s not supported (incomplete type checking rule - no precedence level in typecheck typemap for '%s').\n",
Swig_name_decl(nodes[i].n), SwigType_str(Getattr(p1, "type"), 0));
nodes[i].error = 1;
} else if ((!t2) && (!nodes[j].error)) {
Swig_warning(WARN_TYPEMAP_TYPECHECK, Getfile(nodes[j].n), Getline(nodes[j].n),
- "Overloaded method %s not supported (no type checking rule for '%s').\n",
+ "Overloaded method %s not supported (incomplete type checking rule - no precedence level in typecheck typemap for '%s').\n",
Swig_name_decl(nodes[j].n), SwigType_str(Getattr(p2, "type"), 0));
nodes[j].error = 1;
}
#include "swigmod.h"
#include "cparse.h"
-static int treduce = SWIG_cparse_template_reduce(0);
-
#include <ctype.h>
-static const char *usage = (char *) "\
+static const char *usage = "\
Perl5 Options (available with -perl5)\n\
-compat - Compatibility mode\n\
-const - Wrap constants as constants and not variables (implies -proxy)\n\
static File *f_begin = 0;
static File *f_runtime = 0;
+static File *f_runtime_h = 0;
static File *f_header = 0;
static File *f_wrappers = 0;
+static File *f_directors = 0;
+static File *f_directors_h = 0;
static File *f_init = 0;
static File *f_pm = 0;
static String *pm; /* Package initialization code */
Printv(argc_template_string, "items", NIL);
Clear(argv_template_string);
Printv(argv_template_string, "ST(%d)", NIL);
+ director_language = 1;
}
/* Test to see if a type corresponds to something wrapped with a shadow class */
* ------------------------------------------------------------ */
virtual int top(Node *n) {
+ /* check if directors are enabled for this module. note: this
+ * is a "master" switch, without which no director code will be
+ * emitted. %feature("director") statements are also required
+ * to enable directors for individual classes or methods.
+ *
+ * use %module(directors="1") modulename at the start of the
+ * interface file to enable director generation.
+ *
+ * TODO: directors are disallowed in conjunction with many command
+ * line options. Some of them are probably safe, but it will take
+ * some effort to validate each one.
+ */
+ {
+ Node *mod = Getattr(n, "module");
+ if (mod) {
+ Node *options = Getattr(mod, "options");
+ if (options) {
+ int dirprot = 0;
+ if (Getattr(options, "dirprot"))
+ dirprot = 1;
+ if (Getattr(options, "nodirprot"))
+ dirprot = 0;
+ if (Getattr(options, "directors")) {
+ int allow = 1;
+ if (export_all) {
+ Printv(stderr, "*** directors are not supported with -exportall\n", NIL);
+ allow = 0;
+ }
+ if (staticoption) {
+ Printv(stderr, "*** directors are not supported with -static\n", NIL);
+ allow = 0;
+ }
+ if (!blessed) {
+ Printv(stderr, "*** directors are not supported with -noproxy\n", NIL);
+ allow = 0;
+ }
+ if (no_pmfile) {
+ Printv(stderr, "*** directors are not supported with -nopm\n", NIL);
+ allow = 0;
+ }
+ if (compat) {
+ Printv(stderr, "*** directors are not supported with -compat\n", NIL);
+ allow = 0;
+ }
+ if (allow) {
+ allow_directors();
+ if (dirprot)
+ allow_dirprot();
+ }
+ }
+ }
+ }
+ }
/* Initialize all of the output files */
String *outfile = Getattr(n, "outfile");
+ String *outfile_h = Getattr(n, "outfile_h");
f_begin = NewFile(outfile, "w", SWIG_output_files());
if (!f_begin) {
f_init = NewString("");
f_header = NewString("");
f_wrappers = NewString("");
+ f_directors_h = NewString("");
+ f_directors = NewString("");
+
+ if (directorsEnabled()) {
+ f_runtime_h = NewFile(outfile_h, "w", SWIG_output_files());
+ if (!f_runtime_h) {
+ FileErrorDisplay(outfile_h);
+ SWIG_exit(EXIT_FAILURE);
+ }
+ }
/* Register file targets with the SWIG file handler */
Swig_register_filebyname("header", f_header);
Swig_register_filebyname("begin", f_begin);
Swig_register_filebyname("runtime", f_runtime);
Swig_register_filebyname("init", f_init);
+ Swig_register_filebyname("director", f_directors);
+ Swig_register_filebyname("director_h", f_directors_h);
classlist = NewList();
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGPERL\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGPERL\n#define SWIGPERL\n#endif\n\n");
+
+ if (directorsEnabled()) {
+ Printf(f_runtime, "#define SWIG_DIRECTORS\n");
+ }
Printf(f_runtime, "#define SWIG_CASTRANK_MODE\n");
Printf(f_runtime, "\n");
Node *options = Getattr(mod, "options");
module = Copy(Getattr(n,"name"));
+ String *underscore_module = Copy(module);
+ Replaceall(underscore_module,":","_");
+
+ if (verbose > 0) {
+ fprintf(stdout, "top: using namespace_module: %s\n", Char(namespace_module));
+ }
+
+ if (directorsEnabled()) {
+ Swig_banner(f_directors_h);
+ Printf(f_directors_h, "\n");
+ Printf(f_directors_h, "#ifndef SWIG_%s_WRAP_H_\n", underscore_module);
+ Printf(f_directors_h, "#define SWIG_%s_WRAP_H_\n\n", underscore_module);
+ if (dirprot_mode()) {
+ Printf(f_directors_h, "#include <map>\n");
+ Printf(f_directors_h, "#include <string>\n\n");
+ }
+
+ Printf(f_directors, "\n\n");
+ Printf(f_directors, "/* ---------------------------------------------------\n");
+ Printf(f_directors, " * C++ director class methods\n");
+ Printf(f_directors, " * --------------------------------------------------- */\n\n");
+ if (outfile_h) {
+ String *filename = Swig_file_filename(outfile_h);
+ Printf(magic, "#include \"%s\"\n\n", filename);
+ Delete(filename);
+ }
+ }
+
if (verbose > 0) {
fprintf(stdout, "top: using module: %s\n", Char(module));
}
fprintf(stdout, "top: No package found\n");
}
}
- String *underscore_module = Copy(module);
- Replaceall(underscore_module,":","_");
-
- if (verbose > 0) {
- fprintf(stdout, "top: using namespace_module: %s\n", Char(namespace_module));
- }
-
/* If we're in blessed mode, change the package name to "packagec" */
if (blessed) {
/* emit wrappers */
Language::top(n);
+ if (directorsEnabled()) {
+ // Insert director runtime into the f_runtime file (make it occur before %header section)
+ Swig_insert_file("director_common.swg", f_runtime);
+ Swig_insert_file("director.swg", f_runtime);
+ }
+
String *base = NewString("");
/* Dump out variable wrappers */
/* Close all of the files */
Dump(f_runtime, f_begin);
Dump(f_header, f_begin);
+
+ if (directorsEnabled()) {
+ Dump(f_directors_h, f_runtime_h);
+ Printf(f_runtime_h, "\n");
+ Printf(f_runtime_h, "#endif\n");
+ Dump(f_directors, f_begin);
+ }
+
Dump(f_wrappers, f_begin);
Wrapper_pretty_print(f_init, f_begin);
Delete(f_header);
Delete(f_wrappers);
Delete(f_init);
+ Delete(f_directors);
+ Delete(f_directors_h);
Delete(f_runtime);
Delete(f_begin);
return SWIG_OK;
SwigType *d = Getattr(n, "type");
ParmList *l = Getattr(n, "parms");
String *overname = 0;
+ int director_method = 0;
Parm *p;
int i;
Wrapper_add_localv(f, "_saved", "SV *", temp, NIL);
}
+ director_method = is_member_director(n) && !is_smart_pointer() && 0 != Cmp(nodeType(n), "destructor");
+ if (director_method) {
+ Wrapper_add_local(f, "director", "Swig::Director *director = 0");
+ Append(f->code, "director = SWIG_DIRECTOR_CAST(arg1);\n");
+ if (dirprot_mode() && !is_public(n)) {
+ Printf(f->code, "if (!director || !(director->swig_get_inner(\"%s\"))) {\n", name);
+ Printf(f->code, "SWIG_exception_fail(SWIG_RuntimeError, \"accessing protected member %s\");\n", name);
+ Append(f->code, "}\n");
+ }
+ Wrapper_add_local(f, "upcall", "bool upcall = false");
+ Printf(f->code, "upcall = director && SvSTASH(SvRV(ST(0))) == gv_stashpv(director->swig_get_class(), 0);\n");
+ }
+
+ /* Emit the function call */
+ if (director_method) {
+ Append(f->code, "try {\n");
+ }
+
/* Now write code to make the function call */
Swig_director_emit_dynamic_cast(n, f);
String *actioncode = emit_action(n);
+ if (director_method) {
+ Append(actioncode, "} catch (Swig::DirectorException& swig_err) {\n");
+ Append(actioncode, " sv_setsv(ERRSV, swig_err.getNative());\n");
+ Append(actioncode, " SWIG_fail;\n");
+ Append(actioncode, "}\n");
+ }
+
if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) {
SwigType *t = Getattr(n, "type");
Replaceall(tm, "$source", Swig_cresult_name());
String *tt = Getattr(n, "tmap:varout:type");
if (tt) {
- String *tm = NewStringf("&SWIGTYPE%s", SwigType_manglestr(t));
- if (Replaceall(tt, "$1_descriptor", tm)) {
- SwigType_remember(t);
- }
- Delete(tm);
- SwigType *st = Copy(t);
- SwigType_add_pointer(st);
- tm = NewStringf("&SWIGTYPE%s", SwigType_manglestr(st));
- if (Replaceall(tt, "$&1_descriptor", tm)) {
- SwigType_remember(st);
- }
- Delete(tm);
- Delete(st);
+ tt = NewStringf("&%s", tt);
} else {
- tt = (String *) "0";
+ tt = NewString("0");
}
/* Now add symbol to the PERL interpreter */
if (GetFlag(n, "feature:immutable")) {
if (export_all)
Printf(exported, "$%s ", iname);
+ Delete(tt);
DelWrapper(setf);
DelWrapper(getf);
Delete(getname);
/* Output methods for managing ownership */
+ String *director_disown;
+ if (Getattr(n, "perl5:directordisown")) {
+ director_disown = NewStringf("%s%s($self);\n", tab4, Getattr(n, "perl5:directordisown"));
+ } else {
+ director_disown = NewString("");
+ }
Printv(pm,
"sub DISOWN {\n",
tab4, "my $self = shift;\n",
+ director_disown,
tab4, "my $ptr = tied(%$self);\n",
tab4, "delete $OWNER{$ptr};\n",
"}\n\n", "sub ACQUIRE {\n", tab4, "my $self = shift;\n", tab4, "my $ptr = tied(%$self);\n", tab4, "$OWNER{$ptr} = 1;\n", "}\n\n", NIL);
+ Delete(director_disown);
/* Only output the following methods if a class has member data */
Delete(operators);
operators = 0;
+ if (Swig_directorclass(n)) {
+ /* director classes need a way to recover subclass instance attributes */
+ Node *get_attr = NewHash();
+ String *mrename;
+ String *symname = Getattr(n, "sym:name");
+ mrename = Swig_name_disown(NSPACE_TODO, symname);
+ Replaceall(mrename, "disown", "swig_get_attr");
+ String *type = NewString(getClassType());
+ String *name = NewString("self");
+ SwigType_add_pointer(type);
+ Parm *p = NewParm(type, name, n);
+ Delete(name);
+ Delete(type);
+ type = NewString("SV");
+ SwigType_add_pointer(type);
+ String *action = NewString("");
+ Printv(action, "{\n", " Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);\n",
+ " result = sv_newmortal();\n" " if (director) sv_setsv(result, director->swig_get_self());\n", "}\n", NIL);
+ Setfile(get_attr, Getfile(n));
+ Setline(get_attr, Getline(n));
+ Setattr(get_attr, "wrap:action", action);
+ Setattr(get_attr, "name", mrename);
+ Setattr(get_attr, "sym:name", mrename);
+ Setattr(get_attr, "type", type);
+ Setattr(get_attr, "parms", p);
+ Delete(action);
+ Delete(type);
+ Delete(p);
+
+ member_func = 1;
+ functionWrapper(get_attr);
+ member_func = 0;
+ Delete(get_attr);
+
+ Printv(pm, "sub FETCH {\n", tab4, "my ($self,$field) = @_;\n", tab4, "my $member_func = \"swig_${field}_get\";\n", tab4,
+ "if (not $self->can($member_func)) {\n", tab8, "my $h = ", cmodule, "::", mrename, "($self);\n", tab8, "return $h->{$field} if $h;\n",
+ tab4, "}\n", tab4, "return $self->$member_func;\n", "}\n", "\n", "sub STORE {\n", tab4, "my ($self,$field,$newval) = @_;\n", tab4,
+ "my $member_func = \"swig_${field}_set\";\n", tab4, "if (not $self->can($member_func)) {\n", tab8, "my $h = ", cmodule, "::", mrename,
+ "($self);\n", tab8, "return $h->{$field} = $newval if $h;\n", tab4, "}\n", tab4, "return $self->$member_func($newval);\n", "}\n", NIL);
+
+ Delete(mrename);
+ }
}
return SWIG_OK;
}
String *symname = Getattr(n, "sym:name");
member_func = 1;
+
+ Swig_save("perl5:constructorHandler", n, "parms", NIL);
+ if (Swig_directorclass(n)) {
+ Parm *parms = Getattr(n, "parms");
+ Parm *self;
+ String *name = NewString("self");
+ String *type = NewString("SV");
+ SwigType_add_pointer(type);
+ self = NewParm(type, name, n);
+ Delete(type);
+ Delete(name);
+ Setattr(self, "lname", "O");
+ if (parms)
+ set_nextSibling(self, parms);
+ Setattr(n, "parms", self);
+ Setattr(n, "wrap:self", "1");
+ Setattr(n, "hidden", "1");
+ Delete(self);
+ }
+
+ String *saved_nc = none_comparison;
+ none_comparison = NewStringf("strcmp(SvPV_nolen(ST(0)), \"%s::%s\") != 0", module, class_name);
+ String *saved_director_prot_ctor_code = director_prot_ctor_code;
+ director_prot_ctor_code = NewStringf("if ($comparison) { /* subclassed */\n" " $director_new\n" "} else {\n"
+ "SWIG_exception_fail(SWIG_RuntimeError, \"accessing abstract class or protected constructor\");\n" "}\n");
Language::constructorHandler(n);
+ Delete(none_comparison);
+ none_comparison = saved_nc;
+ Delete(director_prot_ctor_code);
+ director_prot_ctor_code = saved_director_prot_ctor_code;
+ Swig_restore(n);
if ((blessed) && (!Getattr(n, "sym:nextSibling"))) {
if (Getattr(n, "feature:shadow")) {
Printv(pcode, "sub ", Swig_name_construct(NSPACE_TODO, symname), " {\n", NIL);
}
+ const char *pkg = getCurrentClass() && Swig_directorclass(getCurrentClass())? "$_[0]" : "shift";
Printv(pcode,
- tab4, "my $pkg = shift;\n",
+ tab4, "my $pkg = ", pkg, ";\n",
tab4, "my $self = ", cmodule, "::", Swig_name_construct(NSPACE_TODO, symname), "(@_);\n", tab4, "bless $self, $pkg if defined($self);\n", "}\n\n", NIL);
have_constructor = 1;
String *defaultExternalRuntimeFilename() {
return NewString("swigperlrun.h");
}
+
+ virtual int classDirectorInit(Node *n) {
+ String *declaration = Swig_director_declaration(n);
+ Printf(f_directors_h, "\n");
+ Printf(f_directors_h, "%s\n", declaration);
+ Printf(f_directors_h, "public:\n");
+ Delete(declaration);
+ return Language::classDirectorInit(n);
+ }
+
+ virtual int classDirectorEnd(Node *n) {
+ if (dirprot_mode()) {
+ /*
+ This implementation uses a std::map<std::string,int>.
+
+ It should be possible to rewrite it using a more elegant way,
+ like copying the Java approach for the 'override' array.
+
+ But for now, this seems to be the least intrusive way.
+ */
+ Printf(f_directors_h, "\n");
+ Printf(f_directors_h, "/* Internal director utilities */\n");
+ Printf(f_directors_h, "public:\n");
+ Printf(f_directors_h, " bool swig_get_inner(const char *swig_protected_method_name) const {\n");
+ Printf(f_directors_h, " std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);\n");
+ Printf(f_directors_h, " return (iv != swig_inner.end() ? iv->second : false);\n");
+ Printf(f_directors_h, " }\n");
+
+ Printf(f_directors_h, " void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {\n");
+ Printf(f_directors_h, " swig_inner[swig_protected_method_name] = swig_val;\n");
+ Printf(f_directors_h, " }\n");
+ Printf(f_directors_h, "private:\n");
+ Printf(f_directors_h, " mutable std::map<std::string, bool> swig_inner;\n");
+ }
+ Printf(f_directors_h, "};\n");
+ return Language::classDirectorEnd(n);
+ }
+
+ virtual int classDirectorConstructor(Node *n) {
+ Node *parent = Getattr(n, "parentNode");
+ String *sub = NewString("");
+ String *decl = Getattr(n, "decl");
+ String *supername = Swig_class_name(parent);
+ String *classname = NewString("");
+ Printf(classname, "SwigDirector_%s", supername);
+
+ /* insert self parameter */
+ Parm *p;
+ ParmList *superparms = Getattr(n, "parms");
+ ParmList *parms = CopyParmList(superparms);
+ String *type = NewString("SV");
+ SwigType_add_pointer(type);
+ p = NewParm(type, NewString("self"), n);
+ set_nextSibling(p, parms);
+ parms = p;
+
+ if (!Getattr(n, "defaultargs")) {
+ /* constructor */
+ {
+ Wrapper *w = NewWrapper();
+ String *call;
+ String *basetype = Getattr(parent, "classtype");
+ String *target = Swig_method_decl(0, decl, classname, parms, 0, 0);
+ call = Swig_csuperclass_call(0, basetype, superparms);
+ Printf(w->def, "%s::%s: %s, Swig::Director(self) { \n", classname, target, call);
+ Printf(w->def, " SWIG_DIRECTOR_RGTR((%s *)this, this); \n", basetype);
+ Append(w->def, "}\n");
+ Delete(target);
+ Wrapper_print(w, f_directors);
+ Delete(call);
+ DelWrapper(w);
+ }
+
+ /* constructor header */
+ {
+ String *target = Swig_method_decl(0, decl, classname, parms, 0, 1);
+ Printf(f_directors_h, " %s;\n", target);
+ Delete(target);
+ }
+ }
+
+ Delete(sub);
+ Delete(classname);
+ Delete(supername);
+ Delete(parms);
+ return Language::classDirectorConstructor(n);
+ }
+
+ virtual int classDirectorMethod(Node *n, Node *parent, String *super) {
+ int is_void = 0;
+ int is_pointer = 0;
+ String *decl = Getattr(n, "decl");
+ String *name = Getattr(n, "name");
+ String *classname = Getattr(parent, "sym:name");
+ String *c_classname = Getattr(parent, "name");
+ String *symname = Getattr(n, "sym:name");
+ String *declaration = NewString("");
+ ParmList *l = Getattr(n, "parms");
+ Wrapper *w = NewWrapper();
+ String *tm;
+ String *wrap_args = NewString("");
+ String *returntype = Getattr(n, "type");
+ String *value = Getattr(n, "value");
+ String *storage = Getattr(n, "storage");
+ bool pure_virtual = false;
+ int status = SWIG_OK;
+ int idx;
+ bool ignored_method = GetFlag(n, "feature:ignore") ? true : false;
+
+ if (Cmp(storage, "virtual") == 0) {
+ if (Cmp(value, "0") == 0) {
+ pure_virtual = true;
+ }
+ }
+
+ /* determine if the method returns a pointer */
+ is_pointer = SwigType_ispointer_return(decl);
+ is_void = (!Cmp(returntype, "void") && !is_pointer);
+
+ /* virtual method definition */
+ String *target;
+ String *pclassname = NewStringf("SwigDirector_%s", classname);
+ String *qualified_name = NewStringf("%s::%s", pclassname, name);
+ SwigType *rtype = Getattr(n, "conversion_operator") ? 0 : Getattr(n, "classDirectorMethods:type");
+ target = Swig_method_decl(rtype, decl, qualified_name, l, 0, 0);
+ Printf(w->def, "%s", target);
+ Delete(qualified_name);
+ Delete(target);
+ /* header declaration */
+ target = Swig_method_decl(rtype, decl, name, l, 0, 1);
+ Printf(declaration, " virtual %s", target);
+ Delete(target);
+
+ // Get any exception classes in the throws typemap
+ ParmList *throw_parm_list = 0;
+
+ if ((throw_parm_list = Getattr(n, "throws")) || Getattr(n, "throw")) {
+ Parm *p;
+ int gencomma = 0;
+
+ Append(w->def, " throw(");
+ Append(declaration, " throw(");
+
+ if (throw_parm_list)
+ Swig_typemap_attach_parms("throws", throw_parm_list, 0);
+ for (p = throw_parm_list; p; p = nextSibling(p)) {
+ if (Getattr(p, "tmap:throws")) {
+ if (gencomma++) {
+ Append(w->def, ", ");
+ Append(declaration, ", ");
+ }
+ String *str = SwigType_str(Getattr(p, "type"), 0);
+ Append(w->def, str);
+ Append(declaration, str);
+ Delete(str);
+ }
+ }
+
+ Append(w->def, ")");
+ Append(declaration, ")");
+ }
+
+ Append(w->def, " {");
+ Append(declaration, ";\n");
+
+ /* declare method return value
+ * if the return value is a reference or const reference, a specialized typemap must
+ * handle it, including declaration of c_result ($result).
+ */
+ if (!is_void) {
+ if (!(ignored_method && !pure_virtual)) {
+ String *cres = SwigType_lstr(returntype, "c_result");
+ Printf(w->code, "%s;\n", cres);
+ Delete(cres);
+ }
+ if (!ignored_method) {
+ String *pres = NewStringf("SV *%s", Swig_cresult_name());
+ Wrapper_add_local(w, Swig_cresult_name(), pres);
+ Delete(pres);
+ }
+ }
+
+ if (ignored_method) {
+ if (!pure_virtual) {
+ if (!is_void)
+ Printf(w->code, "return ");
+ String *super_call = Swig_method_call(super, l);
+ Printf(w->code, "%s;\n", super_call);
+ Delete(super_call);
+ } else {
+ Printf(w->code, "Swig::DirectorPureVirtualException::raise(\"Attempted to invoke pure virtual method %s::%s\");\n", SwigType_namestr(c_classname),
+ SwigType_namestr(name));
+ }
+ } else {
+ /* attach typemaps to arguments (C/C++ -> Perl) */
+ String *parse_args = NewString("");
+ String *pstack = NewString("");
+
+ Swig_director_parms_fixup(l);
+
+ /* remove the wrapper 'w' since it was producing spurious temps */
+ Swig_typemap_attach_parms("in", l, 0);
+ Swig_typemap_attach_parms("directorin", l, 0);
+ Swig_typemap_attach_parms("directorargout", l, w);
+
+ Wrapper_add_local(w, "SP", "dSP");
+
+ {
+ String *ptype = Copy(getClassType());
+ SwigType_add_pointer(ptype);
+ String *mangle = SwigType_manglestr(ptype);
+
+ Wrapper_add_local(w, "swigself", "SV *swigself");
+ Printf(w->code, "swigself = SWIG_NewPointerObj(SWIG_as_voidptr(this), SWIGTYPE%s, SWIG_SHADOW);\n", mangle);
+ Printf(w->code, "sv_bless(swigself, gv_stashpv(swig_get_class(), 0));\n");
+ Delete(mangle);
+ Delete(ptype);
+ Append(pstack, "XPUSHs(swigself);\n");
+ }
+
+ Parm *p;
+ char source[256];
+
+ int outputs = 0;
+ if (!is_void)
+ outputs++;
+
+ /* build argument list and type conversion string */
+ idx = 0;
+ p = l;
+ while (p) {
+ if (checkAttribute(p, "tmap:in:numinputs", "0")) {
+ p = Getattr(p, "tmap:in:next");
+ continue;
+ }
+
+ /* old style? caused segfaults without the p!=0 check
+ in the for() condition, and seems dangerous in the
+ while loop as well.
+ while (Getattr(p, "tmap:ignore")) {
+ p = Getattr(p, "tmap:ignore:next");
+ }
+ */
+
+ if (Getattr(p, "tmap:directorargout") != 0)
+ outputs++;
+
+ String *pname = Getattr(p, "name");
+ String *ptype = Getattr(p, "type");
+
+ if ((tm = Getattr(p, "tmap:directorin")) != 0) {
+ sprintf(source, "obj%d", idx++);
+ String *input = NewString(source);
+ Setattr(p, "emit:directorinput", input);
+ Replaceall(tm, "$input", input);
+ Delete(input);
+ Replaceall(tm, "$owner", "0");
+ Replaceall(tm, "$shadow", "0");
+ /* Wrapper_add_localv(w, source, "SV *", source, "= 0", NIL); */
+ Printv(wrap_args, "SV *", source, ";\n", NIL);
+
+ Printv(wrap_args, tm, "\n", NIL);
+ Putc('O', parse_args);
+ Printv(pstack, "XPUSHs(", source, ");\n", NIL);
+ p = Getattr(p, "tmap:directorin:next");
+ continue;
+ } else if (Cmp(ptype, "void")) {
+ /* special handling for pointers to other C++ director classes.
+ * ideally this would be left to a typemap, but there is currently no
+ * way to selectively apply the dynamic_cast<> to classes that have
+ * directors. in other words, the type "SwigDirector_$1_lname" only exists
+ * for classes with directors. we avoid the problem here by checking
+ * module.wrap::directormap, but it's not clear how to get a typemap to
+ * do something similar. perhaps a new default typemap (in addition
+ * to SWIGTYPE) called DIRECTORTYPE?
+ */
+ if (SwigType_ispointer(ptype) || SwigType_isreference(ptype)) {
+ Node *module = Getattr(parent, "module");
+ Node *target = Swig_directormap(module, ptype);
+ sprintf(source, "obj%d", idx++);
+ String *nonconst = 0;
+ /* strip pointer/reference --- should move to Swig/stype.c */
+ String *nptype = NewString(Char(ptype) + 2);
+ /* name as pointer */
+ String *ppname = Copy(pname);
+ if (SwigType_isreference(ptype)) {
+ Insert(ppname, 0, "&");
+ }
+ /* if necessary, cast away const since Perl doesn't support it! */
+ if (SwigType_isconst(nptype)) {
+ nonconst = NewStringf("nc_tmp_%s", pname);
+ String *nonconst_i = NewStringf("= const_cast< %s >(%s)", SwigType_lstr(ptype, 0), ppname);
+ Wrapper_add_localv(w, nonconst, SwigType_lstr(ptype, 0), nonconst, nonconst_i, NIL);
+ Delete(nonconst_i);
+ Swig_warning(WARN_LANG_DISCARD_CONST, input_file, line_number,
+ "Target language argument '%s' discards const in director method %s::%s.\n",
+ SwigType_str(ptype, pname), SwigType_namestr(c_classname), SwigType_namestr(name));
+ } else {
+ nonconst = Copy(ppname);
+ }
+ Delete(nptype);
+ Delete(ppname);
+ String *mangle = SwigType_manglestr(ptype);
+ if (target) {
+ String *director = NewStringf("director_%s", mangle);
+ Wrapper_add_localv(w, director, "Swig::Director *", director, "= 0", NIL);
+ Wrapper_add_localv(w, source, "SV *", source, "= 0", NIL);
+ Printf(wrap_args, "%s = SWIG_DIRECTOR_CAST(%s);\n", director, nonconst);
+ Printf(wrap_args, "if (!%s) {\n", director);
+ Printf(wrap_args, "%s = SWIG_NewPointerObj(%s, SWIGTYPE%s, 0);\n", source, nonconst, mangle);
+ Append(wrap_args, "} else {\n");
+ Printf(wrap_args, "%s = %s->swig_get_self();\n", source, director);
+ Printf(wrap_args, "SvREFCNT_inc((SV *)%s);\n", source);
+ Append(wrap_args, "}\n");
+ Delete(director);
+ } else {
+ Wrapper_add_localv(w, source, "SV *", source, "= 0", NIL);
+ Printf(wrap_args, "%s = SWIG_NewPointerObj(%s, SWIGTYPE%s, 0);\n", source, nonconst, mangle);
+ Printf(pstack, "XPUSHs(sv_2mortal(%s));\n", source);
+ }
+ Putc('O', parse_args);
+ Delete(mangle);
+ Delete(nonconst);
+ } else {
+ Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file, line_number,
+ "Unable to use type %s as a function argument in director method %s::%s (skipping method).\n", SwigType_str(ptype, 0),
+ SwigType_namestr(c_classname), SwigType_namestr(name));
+ status = SWIG_NOWRAP;
+ break;
+ }
+ }
+ p = nextSibling(p);
+ }
+
+ /* add the method name as a PyString */
+ String *pyname = Getattr(n, "sym:name");
+
+ /* wrap complex arguments to PyObjects */
+ Printv(w->code, wrap_args, NIL);
+
+ /* pass the method call on to the Python object */
+ if (dirprot_mode() && !is_public(n)) {
+ Printf(w->code, "swig_set_inner(\"%s\", true);\n", name);
+ }
+
+ Append(w->code, "ENTER;\n");
+ Append(w->code, "SAVETMPS;\n");
+ Append(w->code, "PUSHMARK(SP);\n");
+ Append(w->code, pstack);
+ Delete(pstack);
+ Append(w->code, "PUTBACK;\n");
+ Printf(w->code, "call_method(\"%s\", G_EVAL | G_SCALAR);\n", pyname);
+
+ if (dirprot_mode() && !is_public(n))
+ Printf(w->code, "swig_set_inner(\"%s\", false);\n", name);
+
+ /* exception handling */
+ tm = Swig_typemap_lookup("director:except", n, Swig_cresult_name(), 0);
+ if (!tm) {
+ tm = Getattr(n, "feature:director:except");
+ if (tm)
+ tm = Copy(tm);
+ }
+ Append(w->code, "if (SvTRUE(ERRSV)) {\n");
+ Append(w->code, " PUTBACK;\n FREETMPS;\n LEAVE;\n");
+ if ((tm) && Len(tm) && (Strcmp(tm, "1") != 0)) {
+ Replaceall(tm, "$error", "ERRSV");
+ Printv(w->code, Str(tm), "\n", NIL);
+ } else {
+ Printf(w->code, " Swig::DirectorMethodException::raise(ERRSV);\n", classname, pyname);
+ }
+ Append(w->code, "}\n");
+ Delete(tm);
+
+ /*
+ * Python method may return a simple object, or a tuple.
+ * for in/out aruments, we have to extract the appropriate PyObjects from the tuple,
+ * then marshal everything back to C/C++ (return value and output arguments).
+ *
+ */
+
+ /* marshal return value and other outputs (if any) from PyObject to C/C++ type */
+
+ String *cleanup = NewString("");
+ String *outarg = NewString("");
+
+ if (outputs > 1) {
+ Wrapper_add_local(w, "output", "SV *output");
+ Printf(w->code, "if (count != %d) {\n", outputs);
+ Printf(w->code, " Swig::DirectorTypeMismatchException::raise(\"Perl method %s.%sfailed to return a list.\");\n", classname, pyname);
+ Append(w->code, "}\n");
+ }
+
+ idx = 0;
+
+ /* marshal return value */
+ if (!is_void) {
+ Append(w->code, "SPAGAIN;\n");
+ Printf(w->code, "%s = POPs;\n", Swig_cresult_name());
+ tm = Swig_typemap_lookup("directorout", n, Swig_cresult_name(), w);
+ if (tm != 0) {
+ if (outputs > 1) {
+ Printf(w->code, "output = POPs;\n");
+ Replaceall(tm, "$input", "output");
+ } else {
+ Replaceall(tm, "$input", Swig_cresult_name());
+ }
+ char temp[24];
+ sprintf(temp, "%d", idx);
+ Replaceall(tm, "$argnum", temp);
+
+ /* TODO check this */
+ if (Getattr(n, "wrap:disown")) {
+ Replaceall(tm, "$disown", "SWIG_POINTER_DISOWN");
+ } else {
+ Replaceall(tm, "$disown", "0");
+ }
+ Replaceall(tm, "$result", "c_result");
+ Printv(w->code, tm, "\n", NIL);
+ Delete(tm);
+ } else {
+ Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number,
+ "Unable to use return type %s in director method %s::%s (skipping method).\n", SwigType_str(returntype, 0),
+ SwigType_namestr(c_classname), SwigType_namestr(name));
+ status = SWIG_ERROR;
+ }
+ }
+
+ /* marshal outputs */
+ for (p = l; p;) {
+ if ((tm = Getattr(p, "tmap:directorargout")) != 0) {
+ if (outputs > 1) {
+ Printf(w->code, "output = POPs;\n");
+ Replaceall(tm, "$result", "output");
+ } else {
+ Replaceall(tm, "$result", Swig_cresult_name());
+ }
+ Replaceall(tm, "$input", Getattr(p, "emit:directorinput"));
+ Printv(w->code, tm, "\n", NIL);
+ p = Getattr(p, "tmap:directorargout:next");
+ } else {
+ p = nextSibling(p);
+ }
+ }
+
+ Delete(parse_args);
+ Delete(cleanup);
+ Delete(outarg);
+ }
+
+ if (!ignored_method) {
+ Append(w->code, "PUTBACK;\n");
+ Append(w->code, "FREETMPS;\n");
+ Append(w->code, "LEAVE;\n");
+ }
+
+ if (!is_void) {
+ if (!(ignored_method && !pure_virtual)) {
+ String *rettype = SwigType_str(returntype, 0);
+ if (!SwigType_isreference(returntype)) {
+ Printf(w->code, "return (%s) c_result;\n", rettype);
+ } else {
+ Printf(w->code, "return (%s) *c_result;\n", rettype);
+ }
+ Delete(rettype);
+ }
+ }
+
+ Append(w->code, "}\n");
+
+ // We expose protected methods via an extra public inline method which makes a straight call to the wrapped class' method
+ String *inline_extra_method = NewString("");
+ if (dirprot_mode() && !is_public(n) && !pure_virtual) {
+ Printv(inline_extra_method, declaration, NIL);
+ String *extra_method_name = NewStringf("%sSwigPublic", name);
+ Replaceall(inline_extra_method, name, extra_method_name);
+ Replaceall(inline_extra_method, ";\n", " {\n ");
+ if (!is_void)
+ Printf(inline_extra_method, "return ");
+ String *methodcall = Swig_method_call(super, l);
+ Printv(inline_extra_method, methodcall, ";\n }\n", NIL);
+ Delete(methodcall);
+ Delete(extra_method_name);
+ }
+
+ /* emit the director method */
+ if (status == SWIG_OK) {
+ if (!Getattr(n, "defaultargs")) {
+ Replaceall(w->code, "$symname", symname);
+ Wrapper_print(w, f_directors);
+ Printv(f_directors_h, declaration, NIL);
+ Printv(f_directors_h, inline_extra_method, NIL);
+ }
+ }
+
+ /* clean up */
+ Delete(wrap_args);
+ Delete(pclassname);
+ DelWrapper(w);
+ return status;
+ }
+ int classDirectorDisown(Node *n) {
+ int rv;
+ member_func = 1;
+ rv = Language::classDirectorDisown(n);
+ member_func = 0;
+ if (rv == SWIG_OK && Swig_directorclass(n)) {
+ String *symname = Getattr(n, "sym:name");
+ String *disown = Swig_name_disown(NSPACE_TODO, symname);
+ Setattr(n, "perl5:directordisown", NewStringf("%s::%s", cmodule, disown));
+ }
+ return rv;
+ }
+ int classDirectorDestructor(Node *n) {
+ /* TODO: it would be nice if this didn't have to copy the body of Language::classDirectorDestructor() */
+ String *DirectorClassName = directorClassName(getCurrentClass());
+ String *body = NewString("\n");
+
+ String *ptype = Copy(getClassType());
+ SwigType_add_pointer(ptype);
+ String *mangle = SwigType_manglestr(ptype);
+
+ Printv(body, tab4, "dSP;\n", tab4, "SV *self = SWIG_NewPointerObj(SWIG_as_voidptr(this), SWIGTYPE", mangle, ", SWIG_SHADOW);\n", tab4, "\n", tab4,
+ "sv_bless(self, gv_stashpv(swig_get_class(), 0));\n", tab4, "ENTER;\n", tab4, "SAVETMPS;\n", tab4, "PUSHMARK(SP);\n", tab4,
+ "XPUSHs(self);\n", tab4, "XPUSHs(&PL_sv_yes);\n", tab4, "PUTBACK;\n", tab4, "call_method(\"DESTROY\", G_EVAL | G_VOID);\n", tab4,
+ "FREETMPS;\n", tab4, "LEAVE;\n", NIL);
+
+ Delete(mangle);
+ Delete(ptype);
+
+ if (Getattr(n, "throw")) {
+ Printf(f_directors_h, " virtual ~%s() throw ();\n", DirectorClassName);
+ Printf(f_directors, "%s::~%s() throw () {%s}\n\n", DirectorClassName, DirectorClassName, body);
+ } else {
+ Printf(f_directors_h, " virtual ~%s();\n", DirectorClassName);
+ Printf(f_directors, "%s::~%s() {%s}\n\n", DirectorClassName, DirectorClassName, body);
+ }
+ return SWIG_OK;
+ }
};
/* -----------------------------------------------------------------------------
#include <ctype.h>
#include <errno.h>
-static const char *usage = (char *) "\
+static const char *usage = "\
PHP Options (available with -php)\n\
- -cppext <ext> - Change C++ file extension to <ext> (default is cpp)\n\
-noproxy - Don't generate proxy classes.\n\
-prefix <prefix> - Prepend <prefix> to all class names in PHP wrappers\n\
\n";
static String *s_vdecl;
static String *s_cinit; // consttab initialization code.
static String *s_oinit;
+static String *s_arginfo;
static String *s_entry;
static String *cs_entry;
static String *all_cs_entry;
p = strchr(p, '"');
if (p) {
++p;
- Insert(action, p - Char(action), " TSRMLS_CC");
+ Insert(action, (int)(p - Char(action)), " TSRMLS_CC");
}
}
}
} else {
Swig_arg_error();
}
- } else if (strcmp(argv[i], "-cppext") == 0) {
- if (argv[i + 1]) {
- SWIG_config_cppext(argv[i + 1]);
- Swig_mark_arg(i);
- Swig_mark_arg(i + 1);
- i++;
- } else {
- Swig_arg_error();
- }
} else if ((strcmp(argv[i], "-noshadow") == 0) || (strcmp(argv[i], "-noproxy") == 0)) {
shadow = 0;
Swig_mark_arg(i);
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGPHP\n");
- Printf(f_runtime, "\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGPHP\n#define SWIGPHP\n#endif\n\n");
if (directorsEnabled()) {
Printf(f_runtime, "#define SWIG_DIRECTORS\n");
* which has to be dynamically generated as it depends on the module name.
*/
Append(s_header, "#ifdef __GNUC__\n");
- Append(s_header, "static void SWIG_FAIL() __attribute__ ((__noreturn__));\n");
+ Append(s_header, "static void SWIG_FAIL(TSRMLS_D) __attribute__ ((__noreturn__));\n");
Append(s_header, "#endif\n\n");
- Append(s_header, "static void SWIG_FAIL() {\n");
- Append(s_header, " TSRMLS_FETCH();\n");
+ Append(s_header, "static void SWIG_FAIL(TSRMLS_D) {\n");
Append(s_header, " zend_error(SWIG_ErrorCode(), \"%s\", SWIG_ErrorMsg());\n");
// zend_error() should never return with the parameters we pass, but if it
// does, we really don't want to let SWIG_FAIL() return. This also avoids
Printf(s_header, "static void %s_destroy_globals(zend_%s_globals * globals) { (void)globals; }\n", module, module);
Printf(s_header, "\n");
- Printf(s_header, "static void SWIG_ResetError() {\n");
- Printf(s_header, " TSRMLS_FETCH();\n");
+ Printf(s_header, "static void SWIG_ResetError(TSRMLS_D) {\n");
Printf(s_header, " SWIG_ErrorMsg() = default_error_msg;\n");
Printf(s_header, " SWIG_ErrorCode() = default_error_code;\n");
Printf(s_header, "}\n");
Append(s_header, " zval **args[2];\n");
Append(s_header, " swig_object_wrapper *value;\n");
Append(s_header, " int type;\n");
- Append(s_header, " int thisown;\n");
Append(s_header, "\n");
- Append(s_header, " SWIG_ResetError();\n");
+ Append(s_header, " SWIG_ResetError(TSRMLS_C);\n");
Append(s_header, " if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {\n");
Append(s_header, " WRONG_PARAM_COUNT;\n");
Append(s_header, " }\n");
Append(s_header, " swig_object_wrapper *value;\n");
Append(s_header, " int type;\n");
Append(s_header, "\n");
- Append(s_header, " SWIG_ResetError();\n");
+ Append(s_header, " SWIG_ResetError(TSRMLS_C);\n");
Append(s_header, " if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {\n");
Append(s_header, " WRONG_PARAM_COUNT;\n");
Append(s_header, " }\n");
if (directorsEnabled()) {
// Insert director runtime
+ Swig_insert_file("director_common.swg", s_header);
Swig_insert_file("director.swg", s_header);
}
Printf(f_h, "PHP_RSHUTDOWN_FUNCTION(%s);\n", module);
Printf(f_h, "PHP_MINFO_FUNCTION(%s);\n\n", module);
+ /* start the arginfo section */
+ s_arginfo = NewString("/* arginfo subsection */\n");
+
/* start the function entry section */
s_entry = NewString("/* entry subsection */\n");
Dump(f_directors, f_begin);
}
Printv(f_begin, s_vdecl, s_wrappers, NIL);
- Printv(f_begin, all_cs_entry, "\n\n", s_entry,
+ Printv(f_begin, all_cs_entry, "\n\n", s_arginfo, "\n\n", s_entry,
" SWIG_ZEND_NAMED_FE(swig_", module, "_alter_newobject,_wrap_swig_", module, "_alter_newobject,NULL)\n"
" SWIG_ZEND_NAMED_FE(swig_", module, "_get_newobject,_wrap_swig_", module, "_get_newobject,NULL)\n"
- "{NULL, NULL, NULL}\n};\n\n", NIL);
+ " ZEND_FE_END\n};\n\n", NIL);
Printv(f_begin, s_init, NIL);
Delete(s_header);
Delete(s_wrappers);
Delete(s_vdecl);
Delete(all_cs_entry);
Delete(s_entry);
+ Delete(s_arginfo);
Delete(f_runtime);
Delete(f_begin);
}
/* Just need to append function names to function table to register with PHP. */
- void create_command(String *cname, String *iname) {
+ void create_command(String *cname, String *iname, Node *n) {
// This is for the single main zend_function_entry record
Printf(f_h, "ZEND_NAMED_FUNCTION(%s);\n", iname);
String * s = cs_entry;
if (!s) s = s_entry;
- Printf(s, " SWIG_ZEND_NAMED_FE(%(lower)s,%s,NULL)\n", cname, iname);
+ Printf(s, " SWIG_ZEND_NAMED_FE(%(lower)s,%s,swig_arginfo_%(lower)s)\n", cname, iname, cname);
+
+ // This is the above referenced arginfo structure.
+ ParmList *l = Getattr(n, "parms");
+ Printf(s_arginfo, "ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_%(lower)s, 0, 0, 0)\n", cname);
+ for (Parm *p = l; p; p = Getattr(p, "tmap:in:next")) {
+ /* Ignored parameters */
+ if (checkAttribute(p, "tmap:in:numinputs", "0")) {
+ continue;
+ }
+ int byref = GetFlag(p, "tmap:in:byref");
+ Printf(s_arginfo, " ZEND_ARG_PASS_INFO(%d)\n", byref);
+ }
+ Printf(s_arginfo, "ZEND_END_ARG_INFO()\n");
}
/* ------------------------------------------------------------
String *symname = Getattr(n, "sym:name");
String *wname = Swig_name_wrapper(symname);
- create_command(symname, wname);
+ create_command(symname, wname, n);
Printv(f->def, "ZEND_NAMED_FUNCTION(", wname, ") {\n", NIL);
Wrapper_add_local(f, "argc", "int argc");
Printf(f->code, "SWIG_ErrorCode() = E_ERROR;\n");
Printf(f->code, "SWIG_ErrorMsg() = \"No matching function for overloaded '%s'\";\n", symname);
- Printv(f->code, "SWIG_FAIL();\n", NIL);
+ Printv(f->code, "SWIG_FAIL(TSRMLS_C);\n", NIL);
Printv(f->code, "}\n", NIL);
Wrapper_print(f, s_wrappers);
String *outarg = NewStringEmpty();
String *cleanup = NewStringEmpty();
- // Not issued for overloaded functions.
- if (!overloaded) {
- create_command(iname, wname);
- }
Printv(f->def, "ZEND_NAMED_FUNCTION(", wname, ") {\n", NIL);
emit_parameter_variables(l, f);
/* Attach standard typemaps */
emit_attach_parmmaps(l, f);
+ // Not issued for overloaded functions.
+ if (!overloaded) {
+ create_command(iname, wname, n);
+ }
// wrap:parms is used by overload resolution.
Setattr(n, "wrap:parms", l);
Delete(args);
args = NULL;
}
- if (is_member_director(n)) {
- Wrapper_add_local(f, "director", "Swig::Director *director = 0");
- Printf(f->code, "director = dynamic_cast<Swig::Director*>(arg1);\n");
- Wrapper_add_local(f, "upcall", "bool upcall = false");
- Printf(f->code, "upcall = !director->swig_is_overridden_method((char *)\"%s%s\", (char *)\"%s\");\n",
- prefix, Swig_class_name(Swig_methodclass(n)), name);
- }
// This generated code may be called:
// 1) as an object method, or
// NOTE: possible we ignore this_ptr as a param for native constructor
- Printf(f->code, "SWIG_ResetError();\n");
+ Printf(f->code, "SWIG_ResetError(TSRMLS_C);\n");
if (numopt > 0) { // membervariable wrappers do not have optional args
Wrapper_add_local(f, "arg_count", "int arg_count");
Delete(source);
}
+ if (is_member_director(n)) {
+ Wrapper_add_local(f, "upcall", "bool upcall = false");
+ Printf(f->code, "upcall = !Swig::Director::swig_is_overridden_method((char *)\"%s%s\", (char *)\"%s\" TSRMLS_CC);\n",
+ prefix, Swig_class_name(Swig_methodclass(n)), name);
+ }
+
Swig_director_emit_dynamic_cast(n, f);
/* Insert constraint checking code */
/* Error handling code */
Printf(f->code, "fail:\n");
Printv(f->code, cleanup, NIL);
- Append(f->code, "SWIG_FAIL();\n");
+ Append(f->code, "SWIG_FAIL(TSRMLS_C);\n");
Printf(f->code, "}\n");
break;
char *p;
errno = 0;
- int n = strtol(Char(value), &p, 0);
+ long n = strtol(Char(value), &p, 0);
Clear(value);
if (errno || *p) {
Append(value, "?");
case T_SCHAR:
case T_SHORT:
case T_INT:
- case T_LONG: {
+ case T_LONG:
+ case T_LONGLONG: {
char *p;
errno = 0;
- unsigned int n = strtol(Char(value), &p, 0);
+ long n = strtol(Char(value), &p, 0);
(void) n;
if (errno || *p) {
Clear(value);
case T_UCHAR:
case T_USHORT:
case T_UINT:
- case T_ULONG: {
+ case T_ULONG:
+ case T_ULONGLONG: {
char *p;
errno = 0;
unsigned int n = strtoul(Char(value), &p, 0);
break;
}
case T_FLOAT:
- case T_DOUBLE:{
+ case T_DOUBLE:
+ case T_LONGDOUBLE: {
char *p;
errno = 0;
/* FIXME: strtod is locale dependent... */
}
break;
}
- case T_REFERENCE:
- case T_USER:
- case T_ARRAY:
- Clear(value);
- Append(value, "?");
- break;
case T_STRING:
if (Len(value) < 2) {
// How can a string (including "" be less than 2 characters?)
}
}
if (Strcmp(value, "NULL") == 0 ||
+ Strcmp(value, "nullptr") == 0 ||
Strcmp(value, "0") == 0 ||
Strcmp(value, "0L") == 0) {
Clear(value);
}
break;
}
+ default:
+ /* Safe default */
+ Clear(value);
+ Append(value, "?");
+ break;
}
if (!arg_values[argno]) {
Printf(output, "\t\t\treturn new %s%s($r);\n", prefix, Getattr(classLookup(d), "sym:name"));
} else {
Printf(output, "\t\t\t$c = new stdClass();\n");
- Printf(output, "\t\t\t$c->"SWIG_PTR" = $r;\n");
+ Printf(output, "\t\t\t$c->" SWIG_PTR " = $r;\n");
Printf(output, "\t\t\treturn $c;\n");
}
Printf(output, "\t\t}\n\t\treturn $r;\n");
}
} else {
Printf(output, "\t\tif (!is_resource($r)) return $r;\n");
- Printf(output, "\t\tswitch (get_resource_type($r)) {\n");
+ String *wrapobj = NULL;
+ String *common = NULL;
Iterator i = First(ret_types);
while (i.item) {
SwigType *ret_type = i.item;
continue;
}
}
- Printf(output, "\t\t");
- if (i.item) {
- Printf(output, "case '%s': ", mangled);
- } else {
- Printf(output, "default: ");
- }
const char *classname = GetChar(class_node, "sym:name");
if (!classname)
classname = GetChar(class_node, "name");
+ String * action = NewStringEmpty();
if (classname)
- Printf(output, "return new %s%s($r);\n", prefix, classname);
+ Printf(action, "return new %s%s($r);\n", prefix, classname);
else
- Printf(output, "return $r;\n");
+ Printf(action, "return $r;\n");
+ if (!wrapobj) {
+ wrapobj = NewString("\t\tswitch (get_resource_type($r)) {\n");
+ common = action;
+ } else {
+ if (common && Cmp(common, action) != 0) {
+ Delete(common);
+ common = NULL;
+ }
+ }
+ Printf(wrapobj, "\t\t");
+ if (i.item) {
+ Printf(wrapobj, "case '%s': ", mangled);
+ } else {
+ Printf(wrapobj, "default: ");
+ }
+ Printv(wrapobj, action, NIL);
+ if (action != common) Delete(action);
Delete(mangled);
}
- Printf(output, "\t\t}\n");
+ Printf(wrapobj, "\t\t}\n");
+ if (common) {
+ // All cases have the same action, so eliminate the switch
+ // wrapper.
+ Printf(output, "\t\t%s", common);
+ Delete(common);
+ } else {
+ Printv(output, wrapobj, NIL);
+ }
+ Delete(wrapobj);
}
} else {
if (non_void_return) {
enumvalue = GetChar(n, "enumvalueex");
}
- if (enumvalue) {
+ if (enumvalue && *Char(enumvalue)) {
// Check for a simple constant expression which is valid in PHP.
// If we find one, initialise the const member with it; otherwise
// we initialise it using the C/C++ wrapped constant.
break;
}
}
- if (!*p) set_to = enumvalue;
+ if (!*p)
+ set_to = enumvalue;
}
if (wrapping_member_constant) {
String *proxyclassname = SwigType_str(Getattr(n, "classtypeobj"), 0);
String *baseclassname = SwigType_str(Getattr(base.item, "name"), 0);
Swig_warning(WARN_PHP_MULTIPLE_INHERITANCE, input_file, line_number,
- "Warning for %s proxy: Base %s ignored. Multiple inheritance is not supported in PHP.\n", proxyclassname, baseclassname);
+ "Warning for %s, base %s ignored. Multiple inheritance is not supported in PHP.\n", proxyclassname, baseclassname);
base = Next(base);
}
}
} else if (GetFlag(n, "feature:exceptionclass")) {
Append(s_phpclasses, "extends Exception ");
}
+ {
+ Node *node = NewHash();
+ Setattr(node, "type", Getattr(n, "name"));
+ Setfile(node, Getfile(n));
+ Setline(node, Getline(n));
+ String * interfaces = Swig_typemap_lookup("phpinterfaces", node, "", 0);
+ if (interfaces) {
+ Printf(s_phpclasses, "implements %s ", interfaces);
+ }
+ Delete(node);
+ }
Printf(s_phpclasses, "{\n\tpublic $%s=null;\n", SWIG_PTR);
if (!baseclass) {
// Only store this in the base class (NB !baseclass means we *are*
// Write property SET handlers
ki = First(shadow_set_vars);
-
if (ki.key) {
// This class has setters.
Printf(s_phpclasses, "\n\tfunction __set($var,$value) {\n");
Printf(s_phpclasses, "\t\t$this->%s[$var] = $value;\n", SWIG_DATA);
}
Printf(s_phpclasses, "\t}\n");
-
- /* Create __isset for PHP 5.1 and later; PHP 5.0 will just ignore it. */
- Printf(s_phpclasses, "\n\tfunction __isset($var) {\n");
- Printf(s_phpclasses, "\t\tif (function_exists('%s_'.$var.'_set')) return true;\n", shadow_classname);
- Printf(s_phpclasses, "\t\tif ($var === 'thisown') return true;\n");
- if (baseclass) {
- Printf(s_phpclasses, "\t\treturn %s%s::__isset($var);\n", prefix, baseclass);
- } else {
- Printf(s_phpclasses, "\t\treturn array_key_exists($var, $this->%s);\n", SWIG_DATA);
- }
- Printf(s_phpclasses, "\t}\n");
} else {
Printf(s_phpclasses, "\n\tfunction __set($var,$value) {\n");
Printf(s_phpclasses, "\t\tif ($var === 'thisown') return swig_%s_alter_newobject($this->%s,$value);\n", module, SWIG_PTR);
Printf(s_phpclasses, "\t\t$this->%s[$var] = $value;\n", SWIG_DATA);
}
Printf(s_phpclasses, "\t}\n");
- Printf(s_phpclasses, "\n\tfunction __isset($var) {\n");
- Printf(s_phpclasses, "\t\tif ($var === 'thisown') return true;\n");
- if (baseclass) {
- Printf(s_phpclasses, "\t\treturn %s%s::__isset($var);\n", prefix, baseclass);
- } else {
- Printf(s_phpclasses, "\t\treturn array_key_exists($var, $this->%s);\n", SWIG_DATA);
- }
- Printf(s_phpclasses, "\t}\n");
}
+
// Write property GET handlers
ki = First(shadow_get_vars);
-
if (ki.key) {
// This class has getters.
Printf(s_phpclasses, "\n\tfunction __get($var) {\n");
Printf(s_phpclasses, "\t\treturn $this->%s[$var];\n", SWIG_DATA);
}
Printf(s_phpclasses, "\t}\n");
+
+ /* Create __isset for PHP 5.1 and later; PHP 5.0 will just ignore it. */
+ /* __isset() should return true for read-only properties, so check for
+ * *_get() not *_set(). */
+ Printf(s_phpclasses, "\n\tfunction __isset($var) {\n");
+ Printf(s_phpclasses, "\t\tif (function_exists('%s_'.$var.'_get')) return true;\n", shadow_classname);
+ Printf(s_phpclasses, "\t\tif ($var === 'thisown') return true;\n");
+ if (baseclass) {
+ Printf(s_phpclasses, "\t\treturn %s%s::__isset($var);\n", prefix, baseclass);
+ } else {
+ Printf(s_phpclasses, "\t\treturn array_key_exists($var, $this->%s);\n", SWIG_DATA);
+ }
+ Printf(s_phpclasses, "\t}\n");
} else {
Printf(s_phpclasses, "\n\tfunction __get($var) {\n");
Printf(s_phpclasses, "\t\tif ($var === 'thisown') return swig_%s_get_newobject($this->%s);\n", module, SWIG_PTR);
Printf(s_phpclasses, "\t\treturn $this->%s[$var];\n", SWIG_DATA);
}
Printf(s_phpclasses, "\t}\n");
+ Printf(s_phpclasses, "\n\tfunction __isset($var) {\n");
+ Printf(s_phpclasses, "\t\tif ($var === 'thisown') return true;\n");
+ if (baseclass) {
+ Printf(s_phpclasses, "\t\treturn %s%s::__isset($var);\n", prefix, baseclass);
+ } else {
+ Printf(s_phpclasses, "\t\treturn array_key_exists($var, $this->%s);\n", SWIG_DATA);
+ }
+ Printf(s_phpclasses, "\t}\n");
}
if (!class_has_ctor) {
if (i) {
Insert(args, 0, ", ");
}
- Printf(director_ctor_code, "} else {\n %s = (%s *)new SwigDirector_%s(arg0%s TSRMLS_CC);\n}\n", Swig_cresult_name(), ctype, sname, args);
- Printf(director_prot_ctor_code, "} else {\n %s = (%s *)new SwigDirector_%s(arg0%s TSRMLS_CC);\n}\n", Swig_cresult_name(), ctype, sname, args);
+ Printf(director_ctor_code, "} else {\n %s = (%s *)new SwigDirector_%s(arg0 TSRMLS_CC%s);\n}\n", Swig_cresult_name(), ctype, sname, args);
+ Printf(director_prot_ctor_code, "} else {\n %s = (%s *)new SwigDirector_%s(arg0 TSRMLS_CC%s);\n}\n", Swig_cresult_name(), ctype, sname, args);
Delete(args);
wrapperType = directorconstructor;
Append(f->code, "return;\n");
Append(f->code, "fail:\n");
- Append(f->code, "SWIG_FAIL();\n");
+ Append(f->code, "SWIG_FAIL(TSRMLS_C);\n");
Printf(f->code, "}\n");
Wrapper_print(f, s_wrappers);
parms = p;
if (!Getattr(n, "defaultargs")) {
+ // There should always be a "self" parameter first.
+ assert(ParmList_len(parms) > 0);
+
/* constructor */
{
Wrapper *w = NewWrapper();
String *call;
String *basetype = Getattr(parent, "classtype");
+
+ // We put TSRMLS_DC after the self parameter in order to cope with
+ // any default parameters.
String *target = Swig_method_decl(0, decl, classname, parms, 0, 0);
- if (((const char *)Char(target))[Len(target) - 2] == '(') {
- Insert(target, Len(target) - 1, "TSRMLS_D");
- } else {
- Insert(target, Len(target) - 1, " TSRMLS_DC");
- }
+ const char * p = Char(target);
+ const char * comma = strchr(p, ',');
+ int ins = comma ? (int)(comma - p) : Len(target) - 1;
+ Insert(target, ins, " TSRMLS_DC");
+
call = Swig_csuperclass_call(0, basetype, superparms);
Printf(w->def, "%s::%s: %s, Swig::Director(self TSRMLS_CC) {", classname, target, call);
Append(w->def, "}");
/* constructor header */
{
+ // We put TSRMLS_DC after the self parameter in order to cope with
+ // any default parameters.
String *target = Swig_method_decl(0, decl, classname, parms, 0, 1);
- if (((const char *)Char(target))[Len(target) - 2] == '(') {
- Insert(target, Len(target) - 1, "TSRMLS_D");
- } else {
- Insert(target, Len(target) - 1, " TSRMLS_DC");
- }
+ const char * p = Char(target);
+ const char * comma = strchr(p, ',');
+ int ins = comma ? (int)(comma - p) : Len(target) - 1;
+ Insert(target, ins, " TSRMLS_DC");
+
Printf(f_directors_h, " %s;\n", target);
Delete(target);
}
Printf(w->code, "zval *args[%d];\n", idx);
}
Printf(w->code, "zval *%s, funcname;\n", Swig_cresult_name());
- Printf(w->code, "MAKE_STD_ZVAL(%s);\n", Swig_cresult_name());
- const char * funcname = GetChar(n, "sym:name");
- Printf(w->code, "ZVAL_STRINGL(&funcname, (char *)\"%s\", %d, 0);\n", funcname, strlen(funcname));
Append(w->code, "if (!swig_self) {\n");
Append(w->code, " SWIG_PHP_Error(E_ERROR, \"this pointer is NULL\");");
Append(w->code, "}\n\n");
+ Printf(w->code, "MAKE_STD_ZVAL(%s);\n", Swig_cresult_name());
+ const char * funcname = GetChar(n, "sym:name");
+ Printf(w->code, "ZVAL_STRINGL(&funcname, (char *)\"%s\", %d, 0);\n", funcname, strlen(funcname));
/* wrap complex arguments to zvals */
Printv(w->code, wrap_args, NIL);
- Append(w->code, "call_user_function(EG(function_table), (zval**)&swig_self, &funcname,\n");
- Printf(w->code, " %s, %d, args TSRMLS_CC);\n", Swig_cresult_name(), idx);
+ Append(w->code, "call_user_function(EG(function_table), (zval**)&swig_self, &funcname,");
+ Printf(w->code, " %s, %d, args TSRMLS_CC);\n", Swig_cresult_name(), idx);
if (tm) {
Printv(w->code, Str(tm), "\n", NIL);
if (!is_void) {
tm = Swig_typemap_lookup("directorout", n, Swig_cresult_name(), w);
if (tm != 0) {
- static const String *amp_result = NewStringf("&%s", Swig_cresult_name());
- Replaceall(tm, "$input", amp_result);
+ Replaceall(tm, "$input", Swig_cresult_name());
char temp[24];
sprintf(temp, "%d", idx);
Replaceall(tm, "$argnum", temp);
}
Append(w->code, "fail:\n");
- Append(w->code, "SWIG_FAIL();\n");
+ Append(w->code, "SWIG_FAIL(TSRMLS_C);\n");
Append(w->code, "}\n");
// We expose protected methods via an extra public inline method which makes a straight call to the wrapped class' method
#include <ctype.h> // for isalnum()
-static const char *usage = (char *) "\
+static const char *usage = "\
Pike Options (available with -pike)\n\
[no additional options]\n\
\n";
/* Standard stuff for the SWIG runtime section */
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGPIKE\n");
- Printf(f_runtime, "\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGPIKE\n#define SWIGPIKE\n#endif\n\n");
Printf(f_header, "#define SWIG_init pike_module_init\n");
Printf(f_header, "#define SWIG_name \"%s\"\n\n", module);
* ----------------------------------------------------------------------------- */
#include "swigmod.h"
+#include <limits.h>
#include "cparse.h"
-
-static int treduce = SWIG_cparse_template_reduce(0);
-
#include <ctype.h>
+#include <errno.h>
+#include <stdlib.h>
#define PYSHADOW_MEMBER 0x2
#define WARN_PYTHON_MULTIPLE_INH 405
static int extranative = 0;
static int outputtuple = 0;
static int nortti = 0;
+static int relativeimport = 0;
/* flags for the make_autodoc function */
enum autodoc_t {
};
-static const char *usage1 = (char *) "\
+static const char *usage1 = "\
Python Options (available with -python)\n\
-aliasobj0 - Alias obj0 when using fastunpack, needed for some old typemaps \n\
-buildnone - Use Py_BuildValue(" ") to obtain Py_None (default in Windows)\n\
-keyword - Use keyword arguments\n\
-modern - Use modern python features only, without compatibility code\n\
-modernargs - Use \"modern\" args mechanism to pack/unpack the function arguments\n";
-static const char *usage2 = (char *) "\
+static const char *usage2 = "\
-newrepr - Use more informative version of __repr__ in proxy classes (default) \n\
-newvwm - New value wrapper mode, use only when everything else fails \n\
-noaliasobj0 - Don't generate an obj0 alias when using fastunpack (default) \n\
-noh - Don't generate the output header file\n\
-nomodern - Don't use modern python features which are not backwards compatible \n\
-nomodernargs - Use classic ParseTuple/CallFunction methods to pack/unpack the function arguments (default) \n";
-static const char *usage3 = (char *) "\
+static const char *usage3 = "\
-noolddefs - Don't emit the old method definitions even when using fastproxy (default) \n\
-nooutputtuple - Use a PyList for appending output values (default) \n\
-noproxy - Don't generate proxy classes \n\
-oldrepr - Use shorter and old version of __repr__ in proxy classes\n\
-outputtuple - Use a PyTuple for outputs instead of a PyList (use carefully with legacy interfaces) \n\
-proxydel - Generate a __del__ method even though it is now redundant (default) \n\
+ -relativeimport - Use relative python imports \n\
-safecstrings - Use safer (but slower) C string mapping, generating copies from Python -> C/C++\n\
-threads - Add thread support for all the interface\n\
-O - Enable the following optimization options: \n\
fputs(usage3, stdout);
} else if (strcmp(argv[i], "-py3") == 0) {
py3 = 1;
+ Preprocessor_define("SWIGPYTHON_PY3", 0);
Swig_mark_arg(i);
} else if (strcmp(argv[i], "-builtin") == 0) {
builtin = 1;
Preprocessor_define("SWIGPYTHON_BUILTIN", 0);
Swig_mark_arg(i);
+ } else if (strcmp(argv[i], "-relativeimport") == 0) {
+ relativeimport = 1;
+ Swig_mark_arg(i);
}
}
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGPYTHON\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGPYTHON\n#define SWIGPYTHON\n#endif\n\n");
if (directorsEnabled()) {
Printf(f_runtime, "#define SWIG_DIRECTORS\n");
Swig_register_filebyname("shadow", f_shadow);
Swig_register_filebyname("python", f_shadow);
- if (mod_docstring && Len(mod_docstring)) {
- Printv(f_shadow, "\"\"\"\n", mod_docstring, "\n\"\"\"\n\n", NIL);
+ if (mod_docstring) {
+ if (Len(mod_docstring)) {
+ const char *triple_double = "\"\"\"";
+ // follow PEP257 rules: https://www.python.org/dev/peps/pep-0257/
+ // reported by pep257: https://github.com/GreenSteam/pep257
+ bool multi_line_ds = Strchr(mod_docstring, '\n') != 0;
+ Printv(f_shadow, triple_double, multi_line_ds ? "\n":"", mod_docstring, multi_line_ds ? "\n":"", triple_double, "\n\n", NIL);
+ }
Delete(mod_docstring);
mod_docstring = NULL;
}
- Printv(f_shadow, "\nfrom sys import version_info\n", NULL);
+ Printv(f_shadow, "\nfrom sys import version_info as _swig_python_version_info\n", NULL);
if (!builtin && fastproxy) {
- Printv(f_shadow, "if version_info >= (3,0,0):\n", NULL);
+ Printv(f_shadow, "if _swig_python_version_info >= (3, 0, 0):\n", NULL);
Printf(f_shadow, tab4 "new_instancemethod = lambda func, inst, cls: %s.SWIG_PyInstanceMethod_New(func)\n", module);
Printv(f_shadow, "else:\n", NULL);
Printv(f_shadow, tab4, "from new import instancemethod as new_instancemethod\n", NULL);
* in 2.6, and fail in 2.7 onwards), but the relative import syntax
* isn't available in python 2.4 or earlier, so we have to write some
* code conditional on the python version.
+ *
+ * For python 2.7.0 and newer, first determine the shadow wrappers package
+ * based on the __name__ it was given by the importer that loaded it.
+ * Then construct a name for the module based on the package name and the
+ * module name (we know the module name). Use importlib to try and load
+ * it. If an attempt to load the module with importlib fails with an
+ * ImportError then fallback and try and load just the module name from
+ * the global namespace.
*/
- Printv(f_shadow, "if version_info >= (2,6,0):\n", NULL);
+ Printv(f_shadow, "if _swig_python_version_info >= (2, 7, 0):\n", NULL);
+ Printv(f_shadow, tab4, "def swig_import_helper():\n", NULL);
+ Printv(f_shadow, tab8, "import importlib\n", NULL);
+ Printv(f_shadow, tab8, "pkg = __name__.rpartition('.')[0]\n", NULL);
+ Printf(f_shadow, tab8 "mname = '.'.join((pkg, '%s')).lstrip('.')\n",
+ module);
+ Printv(f_shadow, tab8, "try:\n", NULL);
+ Printv(f_shadow, tab8, tab4, "return importlib.import_module(mname)\n",
+ NULL);
+ Printv(f_shadow, tab8, "except ImportError:\n", NULL);
+ Printf(f_shadow, tab8 tab4 "return importlib.import_module('%s')\n",
+ module);
+ Printf(f_shadow, tab4 "%s = swig_import_helper()\n", module);
+ Printv(f_shadow, tab4, "del swig_import_helper\n", NULL);
+ Printv(f_shadow, "elif _swig_python_version_info >= (2, 6, 0):\n", NULL);
Printv(f_shadow, tab4, "def swig_import_helper():\n", NULL);
Printv(f_shadow, tab8, "from os.path import dirname\n", NULL);
Printv(f_shadow, tab8, "import imp\n", NULL);
Printv(f_shadow, "else:\n", NULL);
Printf(f_shadow, tab4 "import %s\n", module);
- /* Delete the version_info symbol since we don't use it elsewhere in the
- * module. */
- Printv(f_shadow, "del version_info\n", NULL);
-
if (builtin) {
- Printf(f_shadow, "from %s import *\n", module);
+ /*
+ * Pull in all the attributes from the C module.
+ *
+ * An alternative approach to doing this if/else chain was
+ * proposed by Michael Thon. Someone braver than I may try it out.
+ * I fear some current swig user may depend on some side effect
+ * of from _foo import *
+ *
+ * for attr in _foo.__all__:
+ * globals()[attr] = getattr(_foo, attr)
+ *
+ */
+ Printf(f_shadow, "# pull in all the attributes from %s\n", module);
+ Printv(f_shadow, "if __name__.rpartition('.')[0] != '':\n", NULL);
+ Printv(f_shadow, tab4, "if _swig_python_version_info >= (2, 7, 0):\n", NULL);
+ Printv(f_shadow, tab8, "try:\n", NULL);
+ Printf(f_shadow, tab8 tab4 "from .%s import *\n", module);
+ Printv(f_shadow, tab8 "except ImportError:\n", NULL);
+ Printf(f_shadow, tab8 tab4 "from %s import *\n", module);
+ Printv(f_shadow, tab4, "else:\n", NULL);
+ Printf(f_shadow, tab8 "from %s import *\n", module);
+ Printv(f_shadow, "else:\n", NULL);
+ Printf(f_shadow, tab4 "from %s import *\n", module);
}
+
+ /* Delete the _swig_python_version_info symbol since we don't use it elsewhere in the
+ * module. */
+ Printv(f_shadow, "del _swig_python_version_info\n", NULL);
+
if (modern || !classic) {
- Printv(f_shadow, "try:\n", tab4, "_swig_property = property\n", "except NameError:\n", tab4, "pass # Python < 2.2 doesn't have 'property'.\n", NULL);
+ Printv(f_shadow, "try:\n", tab4, "_swig_property = property\n", "except NameError:\n", tab4, "pass # Python < 2.2 doesn't have 'property'.\n\n", NULL);
}
+
+ /* Need builtins to qualify names like Exception that might also be
+ defined in this module (try both Python 3 and Python 2 names) */
+ Printv(f_shadow, "try:\n", tab4, "import builtins as __builtin__\n", "except ImportError:\n", tab4, "import __builtin__\n", NULL);
+
/* if (!modern) */
/* always needed, a class can be forced to be no-modern, such as an exception */
{
// Python-2.2 object hack
Printv(f_shadow,
- "def _swig_setattr_nondynamic(self,class_type,name,value,static=1):\n",
- tab4, "if (name == \"thisown\"): return self.this.own(value)\n",
- tab4, "if (name == \"this\"):\n", tab4, tab4, "if type(value).__name__ == 'SwigPyObject':\n", tab4, tab8, "self.__dict__[name] = value\n",
+ "\n", "def _swig_setattr_nondynamic(self, class_type, name, value, static=1):\n",
+ tab4, "if (name == \"thisown\"):\n", tab8, "return self.this.own(value)\n",
+ tab4, "if (name == \"this\"):\n", tab8, "if type(value).__name__ == 'SwigPyObject':\n", tab4, tab8, "self.__dict__[name] = value\n",
#ifdef USE_THISOWN
- tab4, tab8, "if hasattr(value,\"thisown\"): self.__dict__[\"thisown\"] = value.thisown\n", tab4, tab8, "del value.thisown\n",
+ tab4, tab8, "if hasattr(value,\"thisown\"):\n", tab8, tab8, "self.__dict__[\"thisown\"] = value.thisown\n", tab4, tab8, "del value.thisown\n",
#endif
- tab4, tab8, "return\n", tab4, "method = class_type.__swig_setmethods__.get(name,None)\n", tab4, "if method: return method(self,value)\n",
+ tab4, tab8, "return\n", tab4, "method = class_type.__swig_setmethods__.get(name, None)\n", tab4, "if method:\n", tab4, tab4, "return method(self, value)\n",
#ifdef USE_THISOWN
tab4, "if (not static) or (name == \"thisown\"):\n",
#else
tab4, "if (not static):\n",
#endif
- tab4, tab4, "self.__dict__[name] = value\n",
+ NIL);
+ if (!classic) {
+ if (!modern)
+ Printv(f_shadow, tab4, tab4, "if _newclass:\n", tab4, NIL);
+ Printv(f_shadow, tab4, tab4, "object.__setattr__(self, name, value)\n", NIL);
+ if (!modern)
+ Printv(f_shadow, tab4, tab4, "else:\n", tab4, NIL);
+ }
+ if (classic || !modern)
+ Printv(f_shadow, tab4, tab4, "self.__dict__[name] = value\n", NIL);
+ Printv(f_shadow,
tab4, "else:\n",
tab4, tab4, "raise AttributeError(\"You cannot add attributes to %s\" % self)\n\n",
- "def _swig_setattr(self,class_type,name,value):\n", tab4, "return _swig_setattr_nondynamic(self,class_type,name,value,0)\n\n", NIL);
+ "\n", "def _swig_setattr(self, class_type, name, value):\n", tab4, "return _swig_setattr_nondynamic(self, class_type, name, value, 0)\n\n", NIL);
Printv(f_shadow,
- "def _swig_getattr(self,class_type,name):\n",
- tab4, "if (name == \"thisown\"): return self.this.own()\n",
- tab4, "method = class_type.__swig_getmethods__.get(name,None)\n",
- tab4, "if method: return method(self)\n", tab4, "raise AttributeError(name)\n\n", NIL);
+ "\n", "def _swig_getattr(self, class_type, name):\n",
+ tab4, "if (name == \"thisown\"):\n", tab8, "return self.this.own()\n",
+ tab4, "method = class_type.__swig_getmethods__.get(name, None)\n",
+ tab4, "if method:\n", tab8, "return method(self)\n",
+ tab4, "raise AttributeError(\"'%s' object has no attribute '%s'\" % (class_type.__name__, name))\n\n", NIL);
Printv(f_shadow,
- "def _swig_repr(self):\n",
- tab4, "try: strthis = \"proxy of \" + self.this.__repr__()\n",
- tab4, "except: strthis = \"\"\n", tab4, "return \"<%s.%s; %s >\" % (self.__class__.__module__, self.__class__.__name__, strthis,)\n\n", NIL);
+ "\n", "def _swig_repr(self):\n",
+ tab4, "try:\n", tab8, "strthis = \"proxy of \" + self.this.__repr__()\n",
+ tab4, "except __builtin__.Exception:\n", tab8, "strthis = \"\"\n", tab4, "return \"<%s.%s; %s >\" % (self.__class__.__module__, self.__class__.__name__, strthis,)\n\n", NIL);
- if (!classic) {
- /* Usage of types.ObjectType is deprecated.
- * But don't sure wether this would broken old Python?
- */
+ if (!classic && !modern) {
Printv(f_shadow,
-// "import types\n",
"try:\n",
-// " _object = types.ObjectType\n",
- " _object = object\n", " _newclass = 1\n", "except AttributeError:\n", " class _object : pass\n", " _newclass = 0\n",
-// "del types\n",
- "\n\n", NIL);
+ tab4, "_object = object\n", tab4, "_newclass = 1\n",
+ "except __builtin__.Exception:\n",
+ tab4, "class _object:\n", tab8, "pass\n", tab4, "_newclass = 0\n\n", NIL);
}
}
if (modern) {
- Printv(f_shadow, "def _swig_setattr_nondynamic_method(set):\n", tab4, "def set_attr(self,name,value):\n",
+ Printv(f_shadow, "\n", "def _swig_setattr_nondynamic_method(set):\n", tab4, "def set_attr(self, name, value):\n",
#ifdef USE_THISOWN
- tab4, tab4, "if hasattr(self,name) or (name in (\"this\", \"thisown\")):\n",
+ tab4, tab4, "if hasattr(self, name) or (name in (\"this\", \"thisown\")):\n",
#else
- tab4, tab4, "if (name == \"thisown\"): return self.this.own(value)\n", tab4, tab4, "if hasattr(self,name) or (name == \"this\"):\n",
+ tab4, tab4, "if (name == \"thisown\"):\n", tab8, tab4, "return self.this.own(value)\n", tab4, tab4, "if hasattr(self, name) or (name == \"this\"):\n",
#endif
- tab4, tab4, tab4, "set(self,name,value)\n",
+ tab4, tab4, tab4, "set(self, name, value)\n",
tab4, tab4, "else:\n",
tab4, tab4, tab4, "raise AttributeError(\"You cannot add attributes to %s\" % self)\n", tab4, "return set_attr\n\n\n", NIL);
}
if (directorsEnabled()) {
// Try loading weakref.proxy, which is only available in Python 2.1 and higher
Printv(f_shadow,
- "try:\n", tab4, "import weakref\n", tab4, "weakref_proxy = weakref.proxy\n", "except:\n", tab4, "weakref_proxy = lambda x: x\n", "\n\n", NIL);
+ "try:\n", tab4, "import weakref\n", tab4, "weakref_proxy = weakref.proxy\n", "except __builtin__.Exception:\n", tab4, "weakref_proxy = lambda x: x\n", "\n\n", NIL);
}
}
// Include some information in the code
if (directorsEnabled()) {
// Insert director runtime into the f_runtime file (make it occur before %header section)
+ Swig_insert_file("director_common.swg", f_runtime);
Swig_insert_file("director.swg", f_runtime);
}
if (shadow) {
Swig_banner_target_lang(f_shadow_py, "#");
- if (!modern) {
+ if (!modern && !classic) {
Printv(f_shadow, "# This file is compatible with both classic and new-style classes.\n", NIL);
}
Printv(f_shadow_py, "\n", f_shadow_begin, "\n", NIL);
}
/* ------------------------------------------------------------
+ * subpkg_tail()
+ *
+ * Return the name of 'other' package relative to 'base'.
+ *
+ * 1. If 'other' is a sub-package of 'base', returns the 'other' relative to
+ * 'base'.
+ * 2. If 'other' and 'base' are equal, returns empty string "".
+ * 3. In any other case, NULL pointer is returned.
+ *
+ * The 'base' and 'other' are expected to be fully qualified names.
+ *
+ * NOTE: none of 'base' nor 'other' can be null.
+ *
+ * Examples:
+ *
+ * # base other tail
+ * -- ---- ----- ----
+ * 1 "Foo" "Foo.Bar" -> "Bar"
+ * 2 "Foo" "Foo." -> ""
+ * 3 "Foo" "FooB.ar" -> NULL
+ * 4 "Foo.Bar" "Foo.Bar" -> ""
+ * 5 "Foo.Bar" "Foo" -> NULL
+ * 6 "Foo.Bar" "Foo.Gez" -> NULL
+ *
+ * NOTE: the example #2 is actually a syntax error (at input). I believe
+ * swig parser prevents us from this case happening here.
+ * ------------------------------------------------------------ */
+
+ static String *subpkg_tail(const String *base, const String *other) {
+ int baselen = Len(base);
+ int otherlen = Len(other);
+
+ if (Strncmp(other, base, baselen) == 0) {
+ if ((baselen < otherlen) && (Char(other))[baselen] == '.') {
+ return NewString((Char(other)) + baselen + 1);
+ } else if (baselen == otherlen) {
+ return NewString("");
+ } else {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ /* ------------------------------------------------------------
+ * abs_import_directive_string()
+ *
+ * Return a string containing python code to import module.
+ *
+ * pkg package name or the module being imported
+ * mod module name of the module being imported
+ * pfx optional prefix to module name
+ *
+ * NOTE: keep this function consistent with abs_import_name_string().
+ * ------------------------------------------------------------ */
+
+ static String *abs_import_directive_string(const String *pkg, const String *mod, const char *pfx = "") {
+ String *out = NewString("");
+
+ if (pkg && *Char(pkg)) {
+ Printf(out, "import %s.%s%s\n", pkg, pfx, mod);
+ } else {
+ Printf(out, "import %s%s\n", pfx, mod);
+ }
+ return out;
+ }
+
+ /* ------------------------------------------------------------
+ * rel_import_directive_string()
+ *
+ * Return a string containing python code to import module that
+ * is potentially within a package.
+ *
+ * mainpkg package name of the module which imports the other module
+ * pkg package name or the module being imported
+ * mod module name of the module being imported
+ * pfx optional prefix to module name
+ *
+ * NOTE: keep this function consistent with rel_import_name_string().
+ * ------------------------------------------------------------ */
+
+ static String *rel_import_directive_string(const String *mainpkg, const String *pkg, const String *mod, const char *pfx = "") {
+
+ /* NOTE: things are not so trivial. This is what we do here (by examples):
+ *
+ * 0. To import module 'foo', which is not in any package, we do absolute
+ * import:
+ *
+ * import foo
+ *
+ * 1. To import 'pkg1.pkg2.foo', when mainpkg != "pkg1" and
+ * mainpkg != "pkg1.pkg2" or when mainpkg is not given we do absolute
+ * import:
+ *
+ * import pkg1.pkg2.foo
+ *
+ * 2. To import module pkg1.foo, when mainpkg == "pkg1", we do:
+ *
+ * - for py3 = 0:
+ *
+ * import foo
+ *
+ * - for py3 = 1:
+ *
+ * from . import foo
+ *
+ * 3. To import "pkg1.pkg2.pkg3.foo", when mainpkg = "pkg1", we do:
+ *
+ * - for py3 == 0:
+ *
+ * import pkg2.pkg3.foo
+ *
+ * - for py3 == 1:
+ *
+ * from . import pkg2 # [1]
+ * import pkg1.pkg2.pkg3.foo
+ *
+ * NOTE: [1] is necessary for pkg2.foo to be present in the importing module
+ */
+
+ String *apkg = 0; // absolute (FQDN) package name of pkg
+ String *rpkg = 0; // relative package name
+ int py3_rlen1 = 0; // length of 1st level sub-package name, used by py3
+ String *out = NewString("");
+
+ if (pkg && *Char(pkg)) {
+ if (mainpkg) {
+ String *tail = subpkg_tail(mainpkg, pkg);
+ if (tail) {
+ if (*Char(tail)) {
+ rpkg = NewString(tail);
+ const char *py3_end1 = Strchr(rpkg, '.');
+ if (!py3_end1)
+ py3_end1 = (Char(rpkg)) + Len(rpkg);
+ py3_rlen1 = (int)(py3_end1 - Char(rpkg));
+ } else {
+ rpkg = NewString("");
+ }
+ Delete(tail);
+ } else {
+ apkg = NewString(pkg);
+ }
+ } else {
+ apkg = NewString(pkg);
+ }
+ } else {
+ apkg = NewString("");
+ }
+
+ if (apkg) {
+ Printf(out, "import %s%s%s%s\n", apkg, *Char(apkg) ? "." : "", pfx, mod);
+ Delete(apkg);
+ } else {
+ Printf(out, "from sys import version_info as _swig_python_version_info\n");
+ Printf(out, "if _swig_python_version_info >= (2, 7, 0):\n");
+ if (py3_rlen1)
+ Printf(out, tab4 "from . import %.*s\n", py3_rlen1, rpkg);
+ Printf(out, tab4 "from .%s import %s%s\n", rpkg, pfx, mod);
+ Printf(out, "else:\n");
+ Printf(out, tab4 "import %s%s%s%s\n", rpkg, *Char(rpkg) ? "." : "", pfx, mod);
+ Printf(out, "del _swig_python_version_info\n");
+ Delete(rpkg);
+ }
+ return out;
+ }
+
+ /* ------------------------------------------------------------
+ * import_directive_string()
+ * ------------------------------------------------------------ */
+
+ static String *import_directive_string(const String *mainpkg, const String *pkg, const String *mod, const char *pfx = "") {
+ if (!relativeimport) {
+ return abs_import_directive_string(pkg, mod, pfx);
+ } else {
+ return rel_import_directive_string(mainpkg, pkg, mod, pfx);
+ }
+ }
+
+ /* ------------------------------------------------------------
+ * abs_import_name_string()
+ *
+ * Return a string with the name of a symbol (perhaps imported
+ * from external module by absolute import directive).
+ *
+ * mainpkg package name of current module
+ * mainmod module name of current module
+ * pkg package name of (perhaps other) module
+ * mod module name of (perhaps other) module
+ * sym symbol name
+ *
+ * NOTE: mainmod, mod, and sym can't be NULL.
+ * NOTE: keep this function consistent with abs_import_directive_string()
+ * ------------------------------------------------------------ */
+
+ static String *abs_import_name_string(const String *mainpkg, const String *mainmod, const String *pkg, const String *mod, const String *sym) {
+ String *out = NewString("");
+ if (pkg && *Char(pkg)) {
+ if (mainpkg && *Char(mainpkg)) {
+ if (Strcmp(mainpkg,pkg) != 0 || Strcmp(mainmod, mod) != 0) {
+ Printf(out, "%s.%s.", pkg, mod);
+ }
+ } else {
+ Printf(out, "%s.%s.", pkg, mod);
+ }
+ } else if ((mainpkg && *Char(mainpkg)) || Strcmp(mainmod, mod) != 0) {
+ Printf(out, "%s.", mod);
+ }
+ Append(out, sym);
+ return out;
+ }
+
+ /* ------------------------------------------------------------
+ * rel_import_name_string()
+ *
+ * Return a string with the name of a symbol (perhaps imported
+ * from external module by relative import directive).
+ *
+ * mainpkg package name of current module
+ * mainmod module name of current module
+ * pkg package name of (perhaps other) module
+ * mod module name of (perhaps other) module
+ * sym symbol name
+ *
+ * NOTE: mainmod, mod, and sym can't be NULL.
+ * NOTE: keep this function consistent with rel_import_directive_string()
+ * ------------------------------------------------------------ */
+
+ static String *rel_import_name_string(const String *mainpkg, const String *mainmod, const String *pkg, const String *mod, const String *sym) {
+ String *out = NewString("");
+ if (pkg && *Char(pkg)) {
+ String *tail = 0;
+ if (mainpkg)
+ tail = subpkg_tail(mainpkg, pkg);
+ if (!tail)
+ tail = NewString(pkg);
+ if (*Char(tail)) {
+ Printf(out, "%s.%s.", tail, mod);
+ } else if (Strcmp(mainmod, mod) != 0) {
+ Printf(out, "%s.", mod);
+ }
+ Delete(tail);
+ } else if ((mainpkg && *Char(mainpkg)) || Strcmp(mainmod, mod) != 0) {
+ Printf(out, "%s.", mod);
+ }
+ Append(out, sym);
+ return out;
+ }
+
+ /* ------------------------------------------------------------
+ * import_name_string()
+ * ------------------------------------------------------------ */
+
+ static String *import_name_string(const String *mainpkg, const String *mainmod, const String *pkg, const String *mod, const String *sym) {
+ if (!relativeimport) {
+ return abs_import_name_string(mainpkg,mainmod,pkg,mod,sym);
+ } else {
+ return rel_import_name_string(mainpkg,mainmod,pkg,mod,sym);
+ }
+ }
+
+ /* ------------------------------------------------------------
* importDirective()
* ------------------------------------------------------------ */
String *modname = Getattr(n, "module");
if (modname) {
- String *import = NewString("import ");
-
// Find the module node for this imported module. It should be the
// first child but search just in case.
Node *mod = firstChild(n);
while (mod && Strcmp(nodeType(mod), "module") != 0)
mod = nextSibling(mod);
- // Is the imported module in another package? (IOW, does it use the
- // %module(package="name") option and it's different than the package
- // of this module.)
Node *options = Getattr(mod, "options");
String *pkg = options ? Getattr(options, "package") : 0;
- if (pkg) {
- Printf(import, "%s.", pkg);
- }
- // finally, output the name of the imported module
if (shadowimport) {
if (!options || (!Getattr(options, "noshadow") && !Getattr(options, "noproxy"))) {
- Printf(import, "_%s\n", modname);
- if (!GetFlagAttr(f_shadow_imports, import)) {
- if (pkg) {
- Printf(builtin ? f_shadow_builtin_imports : f_shadow, "import %s.%s\n", pkg, modname);
- } else {
- Printf(builtin ? f_shadow_builtin_imports : f_shadow, "import %s\n", modname);
- }
- SetFlag(f_shadow_imports, import);
+ String *_import = import_directive_string(package, pkg, modname, "_");
+ if (!GetFlagAttr(f_shadow_imports, _import)) {
+ String *import = import_directive_string(package, pkg, modname);
+ Printf(builtin ? f_shadow_builtin_imports : f_shadow, "%s", import);
+ Delete(import);
+ SetFlag(f_shadow_imports, _import);
}
+ Delete(_import);
}
}
-
- Delete(import);
}
}
return Language::importDirective(n);
/* ------------------------------------------------------------
* funcCall()
- * Emit shadow code to call a function in the extension
- * module. Using proper argument and calling style for
- * given node n.
+ *
+ * Emit shadow code to call a function in the extension
+ * module. Using proper argument and calling style for
+ * given node n.
* ------------------------------------------------------------ */
String *funcCall(String *name, String *parms) {
String *str = NewString("");
return str;
}
-
/* ------------------------------------------------------------
- * pythoncode() - Output python code into the shadow file
+ * indent_pythoncode()
+ *
+ * Format (indent) Python code.
+ * Remove leading whitespace from 'code' and re-indent using
+ * the indentation string in 'indent'.
* ------------------------------------------------------------ */
- String *pythoncode(String *code, const_String_or_char_ptr indent) {
+ String *indent_pythoncode(const String *code, const_String_or_char_ptr indent, String *file, int line, const char *directive_name) {
String *out = NewString("");
String *temp;
char *t;
/* Split the input text into lines */
List *clist = SplitLines(temp);
Delete(temp);
- int initial = 0;
- String *s = 0;
+
+ // Line number within the pythoncode.
+ int py_line = 0;
+
+ String *initial = 0;
Iterator si;
- /* Get the initial indentation */
- for (si = First(clist); si.item; si = Next(si)) {
- s = si.item;
- if (Len(s)) {
- char *c = Char(s);
- while (*c) {
- if (!isspace(*c))
- break;
- initial++;
- c++;
- }
- if (*c && !isspace(*c)) {
- break;
- } else {
- initial = 0;
- }
+ /* Get the initial indentation. Skip lines which only contain whitespace
+ * and/or a comment, as the indentation of those doesn't matter:
+ *
+ * A logical line that contains only spaces, tabs, formfeeds and
+ * possibly a comment, is ignored (i.e., no NEWLINE token is
+ * generated).
+ *
+ * see:
+ * https://docs.python.org/2/reference/lexical_analysis.html#blank-lines
+ * https://docs.python.org/3/reference/lexical_analysis.html#blank-lines
+ */
+ for (si = First(clist); si.item; si = Next(si), ++py_line) {
+ const char *c = Char(si.item);
+ int i;
+ for (i = 0; isspace((unsigned char)c[i]); i++) {
+ // Scan forward until we find a non-space (which may be a null byte).
+ }
+ char ch = c[i];
+ if (ch && ch != '#') {
+ // Found a line with actual content.
+ initial = NewStringWithSize(c, i);
+ break;
}
+ if (ch) {
+ Printv(out, indent, c, NIL);
+ }
+ Putc('\n', out);
}
- while (si.item) {
- s = si.item;
- if (Len(s) > initial) {
- char *c = Char(s);
- c += initial;
+
+ // Process remaining lines.
+ for ( ; si.item; si = Next(si), ++py_line) {
+ const char *c = Char(si.item);
+ // If no prefixed line was found, the above loop should have completed.
+ assert(initial);
+
+ int i;
+ for (i = 0; isspace((unsigned char)c[i]); i++) {
+ // Scan forward until we find a non-space (which may be a null byte).
+ }
+ char ch = c[i];
+ if (!ch) {
+ // Line is just whitespace - emit an empty line.
+ Putc('\n', out);
+ continue;
+ }
+
+ if (ch == '#') {
+ // Comment - the indentation doesn't matter to python, but try to
+ // adjust the whitespace for the benefit of human readers (though SWIG
+ // currently seems to always remove any whitespace before a '#' before
+ // we get here, in which case we'll just leave the comment at the start
+ // of the line).
+ if (i >= Len(initial)) {
+ Printv(out, indent, NIL);
+ }
+
+ Printv(out, c + i, "\n", NIL);
+ continue;
+ }
+
+ if (i < Len(initial)) {
+ // There's non-whitespace in the initial prefix of this line.
+ Swig_error(file, line, "Line indented less than expected (line %d of %s) as no line should be indented less than the indentation in line 1\n", py_line, directive_name);
Printv(out, indent, c, "\n", NIL);
} else {
- Printv(out, "\n", NIL);
+ if (memcmp(c, Char(initial), Len(initial)) == 0) {
+ // Prefix matches initial, so just remove it.
+ Printv(out, indent, c + Len(initial), "\n", NIL);
+ continue;
+ }
+ Swig_warning(WARN_PYTHON_INDENT_MISMATCH,
+ file, line, "Whitespace indentation is inconsistent compared to earlier lines (line %d of %s)\n", py_line, directive_name);
+ // To avoid gratuitously breaking interface files which worked with
+ // SWIG <= 3.0.5, we remove a prefix of the same number of bytes for
+ // lines which start with different whitespace to the line we got
+ // 'initial' from.
+ Printv(out, indent, c + Len(initial), "\n", NIL);
}
- si = Next(si);
}
Delete(clist);
return out;
}
+ /* ------------------------------------------------------------
+ * indent_docstring()
+ *
+ * Format (indent) a Python docstring.
+ * Remove leading whitespace from 'code' and re-indent using
+ * the indentation string in 'indent'.
+ * ------------------------------------------------------------ */
+
+ String *indent_docstring(const String *code, const_String_or_char_ptr indent) {
+ String *out = NewString("");
+ String *temp;
+ char *t;
+ if (!indent)
+ indent = "";
+
+ temp = NewString(code);
+
+ t = Char(temp);
+ if (*t == '{') {
+ Delitem(temp, 0);
+ Delitem(temp, DOH_END);
+ }
+
+ /* Split the input text into lines */
+ List *clist = SplitLines(temp);
+ Delete(temp);
+
+ Iterator si;
+
+ int truncate_characters_count = INT_MAX;
+ for (si = First(clist); si.item; si = Next(si)) {
+ const char *c = Char(si.item);
+ int i;
+ for (i = 0; isspace((unsigned char)c[i]); i++) {
+ // Scan forward until we find a non-space (which may be a null byte).
+ }
+ char ch = c[i];
+ if (ch) {
+ // Found a line which isn't just whitespace
+ if (i < truncate_characters_count)
+ truncate_characters_count = i;
+ }
+ }
+
+ if (truncate_characters_count == INT_MAX)
+ truncate_characters_count = 0;
+
+ for (si = First(clist); si.item; si = Next(si)) {
+ const char *c = Char(si.item);
+
+ int i;
+ for (i = 0; isspace((unsigned char)c[i]); i++) {
+ // Scan forward until we find a non-space (which may be a null byte).
+ }
+ char ch = c[i];
+ if (!ch) {
+ // Line is just whitespace - emit an empty line.
+ Putc('\n', out);
+ continue;
+ }
+
+ Printv(out, indent, c + truncate_characters_count, "\n", NIL);
+ }
+ Delete(clist);
+ return out;
+ }
/* ------------------------------------------------------------
* autodoc level declarations
/* ------------------------------------------------------------
* have_docstring()
- * Check if there is a docstring directive and it has text,
- * or there is an autodoc flag set
+ *
+ * Check if there is a docstring directive and it has text,
+ * or there is an autodoc flag set
* ------------------------------------------------------------ */
bool have_docstring(Node *n) {
/* ------------------------------------------------------------
* docstring()
- * Get the docstring text, stripping off {} if neccessary,
- * and enclose in triple double quotes. If autodoc is also
- * set then it will build a combined docstring.
+ *
+ * Get the docstring text, stripping off {} if necessary,
+ * and enclose in triple double quotes. If autodoc is also
+ * set then it will build a combined docstring.
* ------------------------------------------------------------ */
String *docstring(Node *n, autodoc_t ad_type, const String *indent, bool use_triple = true) {
//
if (have_auto && have_ds) { // Both autodoc and docstring are present
doc = NewString("");
- Printv(doc, triple_double, "\n", pythoncode(autodoc, indent), "\n", pythoncode(str, indent), indent, triple_double, NIL);
+ Printv(doc, triple_double, "\n",
+ indent_docstring(autodoc, indent), "\n",
+ indent_docstring(str, indent), indent, triple_double, NIL);
} else if (!have_auto && have_ds) { // only docstring
if (Strchr(str, '\n') == 0) {
doc = NewStringf("%s%s%s", triple_double, str, triple_double);
} else {
doc = NewString("");
- Printv(doc, triple_double, "\n", pythoncode(str, indent), indent, triple_double, NIL);
+ Printv(doc, triple_double, "\n", indent_docstring(str, indent), indent, triple_double, NIL);
}
} else if (have_auto && !have_ds) { // only autodoc
if (Strchr(autodoc, '\n') == 0) {
doc = NewStringf("%s%s%s", triple_double, autodoc, triple_double);
} else {
doc = NewString("");
- Printv(doc, triple_double, "\n", pythoncode(autodoc, indent), indent, triple_double, NIL);
+ Printv(doc, triple_double, "\n", indent_docstring(autodoc, indent), indent, triple_double, NIL);
}
} else
doc = NewString("");
/* ------------------------------------------------------------
* cdocstring()
- * Get the docstring text as it would appear in C-language
- * source code.
+ *
+ * Get the docstring text as it would appear in C-language
+ * source code.
* ------------------------------------------------------------ */
String *cdocstring(Node *n, autodoc_t ad_type)
return ds;
}
+ virtual String *makeParameterName(Node *n, Parm *p, int arg_num, bool = false) const {
+ // For the keyword arguments, we want to preserve the names as much as possible,
+ // so we only minimally rename them in Swig_name_make(), e.g. replacing "keyword"
+ // with "_keyword" if they have any name at all.
+ if (check_kwargs(n)) {
+ String *name = Getattr(p, "name");
+ if (name)
+ return Swig_name_make(p, 0, name, 0, 0);
+ }
+
+ // For the other cases use the general function which replaces arguments whose
+ // names clash with keywords with (less useful) "argN".
+ return Language::makeParameterName(n, p, arg_num);
+ }
+
/* -----------------------------------------------------------------------------
* addMissingParameterNames()
- * For functions that have not had nameless parameters set in the Language class.
+ *
+ * For functions that have not had nameless parameters set in the Language class.
*
* Inputs:
* plist - entire parameter list
* The "lname" attribute in each parameter in plist will be contain a parameter name
* ----------------------------------------------------------------------------- */
- void addMissingParameterNames(ParmList *plist, int arg_offset) {
+ void addMissingParameterNames(Node *n, ParmList *plist, int arg_offset) {
Parm *p = plist;
int i = arg_offset;
while (p) {
if (!Getattr(p, "lname")) {
- String *pname = Swig_cparm_name(p, i);
- Delete(pname);
+ String *name = makeParameterName(n, p, i);
+ Setattr(p, "lname", name);
+ Delete(name);
}
i++;
p = nextSibling(p);
/* ------------------------------------------------------------
* make_autodocParmList()
- * Generate the documentation for the function parameters
- * Parameters:
+ *
+ * Generate the documentation for the function parameters
+ * Parameters:
* func_annotation: Function annotation support
* ------------------------------------------------------------ */
Parm *pnext;
- int lines = 0;
- int start_arg_num = is_wrapping_class() ? 1 : 0;
- const int maxwidth = 80;
+ // Normally we start counting auto-generated argument names from 1, but we should do it from 2
+ // if the first argument is "self", i.e. if we're handling a non-static member function.
+ int arg_num = 1;
+ if (is_wrapping_class()) {
+ if (Cmp(Getattr(n, "storage"), "static") != 0)
+ arg_num++;
+ }
if (calling)
func_annotation = false;
- addMissingParameterNames(plist, start_arg_num); // for $1_name substitutions done in Swig_typemap_attach_parms
+ addMissingParameterNames(n, plist, arg_num); // for $1_name substitutions done in Swig_typemap_attach_parms
Swig_typemap_attach_parms("in", plist, 0);
Swig_typemap_attach_parms("doc", plist, 0);
return doc;
}
- for (p = plist; p; p = pnext) {
+ for (p = plist; p; p = pnext, arg_num++) {
String *tm = Getattr(p, "tmap:in");
if (tm) {
}
// Note: the generated name should be consistent with that in kwnames[]
- name = name ? name : Getattr(p, "name");
- name = name ? name : Getattr(p, "lname");
- name = Swig_name_make(p, 0, name, 0, 0); // rename parameter if a keyword
+ String *made_name = 0;
+ if (!name) {
+ name = made_name = makeParameterName(n, p, arg_num);
+ }
type = type ? type : Getattr(p, "type");
value = value ? value : Getattr(p, "value");
- if (SwigType_isvarargs(type))
+ if (SwigType_isvarargs(type)) {
+ Delete(made_name);
break;
+ }
if (Len(doc)) {
// add a comma to the previous one if any
Append(doc, ", ");
-
- // Do we need to wrap a long line?
- if ((Len(doc) - lines * maxwidth) > maxwidth) {
- Printf(doc, "\n%s", tab4);
- lines += 1;
- }
}
// Do the param type too?
Append(doc, name);
if (pdoc) {
if (!pdocs)
- pdocs = NewString("\nParameters:\n");
- Printf(pdocs, " %s\n", pdoc);
+ // numpydoc style: https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt
+ pdocs = NewString("\nParameters\n----------\n");
+ Printf(pdocs, "%s\n", pdoc);
}
// Write the function annotation
if (func_annotation)
- Printf(doc, " : '%s'", type_str);
+ Printf(doc, ": '%s'", type_str);
// Write default value
if (value && !calling) {
String *new_value = convertValue(value, Getattr(p, "type"));
- if (new_value) {
- value = new_value;
- } else {
- Node *lookup = Swig_symbol_clookup(value, 0);
- if (lookup)
- value = Getattr(lookup, "sym:name");
- }
- Printf(doc, "=%s", value);
+ if (new_value)
+ Printf(doc, "=%s", new_value);
}
Delete(type_str);
- Delete(name);
+ Delete(made_name);
}
if (pdocs)
Setattr(n, "feature:pdocs", pdocs);
/* ------------------------------------------------------------
* make_autodoc()
- * Build a docstring for the node, using parameter and other
- * info in the parse tree. If the value of the autodoc
- * attribute is "0" then do not include parameter types, if
- * it is "1" (the default) then do. If it has some other
- * value then assume it is supplied by the extension writer
- * and use it directly.
+ *
+ * Build a docstring for the node, using parameter and other
+ * info in the parse tree. If the value of the autodoc
+ * attribute is "0" then do not include parameter types, if
+ * it is "1" (the default) then do. If it has some other
+ * value then assume it is supplied by the extension writer
+ * and use it directly.
* ------------------------------------------------------------ */
String *make_autodoc(Node *n, autodoc_t ad_type) {
// Only do the autodoc if there isn't a docstring for the class
String *str = Getattr(n, "feature:docstring");
if (!str || Len(str) == 0) {
- if (CPlusPlus) {
- Printf(doc, "Proxy of C++ %s class", real_classname);
+ if (builtin) {
+ String *name = Getattr(n, "name");
+ String *rname = add_explicit_scope(SwigType_namestr(name));
+ Printf(doc, "%s", rname);
+ Delete(rname);
} else {
- Printf(doc, "Proxy of C %s struct", real_classname);
+ if (CPlusPlus) {
+ Printf(doc, "Proxy of C++ %s class.", real_classname);
+ } else {
+ Printf(doc, "Proxy of C %s struct.", real_classname);
+ }
}
}
}
}
/* ------------------------------------------------------------
+ * convertDoubleValue()
+ *
+ * Check if the given string looks like a decimal floating point constant
+ * and return it if it does, otherwise return NIL.
+ * ------------------------------------------------------------ */
+ String *convertDoubleValue(String *v) {
+ const char *const s = Char(v);
+ char *end;
+
+ double value = strtod(s, &end);
+ (void) value;
+ if (errno != ERANGE && end != s) {
+ // An added complication: at least some versions of strtod() recognize
+ // hexadecimal floating point numbers which don't exist in Python, so
+ // detect them ourselves and refuse to convert them (this can't be done
+ // without loss of precision in general).
+ //
+ // Also don't accept neither "NAN" nor "INFINITY" (both of which
+ // conveniently contain "n").
+ if (strpbrk(s, "xXnN"))
+ return NIL;
+
+ // Disregard optional "f" suffix, it can be just dropped in Python as it
+ // uses doubles for everything anyhow.
+ for (char* p = end; *p != '\0'; ++p) {
+ switch (*p) {
+ case 'f':
+ case 'F':
+ break;
+
+ default:
+ return NIL;
+ }
+ }
+
+ // Avoid unnecessary string allocation in the common case when we don't
+ // need to remove any suffix.
+ return *end == '\0' ? v : NewStringWithSize(s, (int)(end - s));
+ }
+
+ return NIL;
+ }
+
+ /* ------------------------------------------------------------
* convertValue()
- * Check if string v can be a Python value literal,
- * (eg. number or string), or translate it to a Python literal.
+ *
+ * Check if string v can be a Python value literal or a
+ * constant. Return NIL if it isn't.
* ------------------------------------------------------------ */
- String *convertValue(String *v, SwigType *t) {
- if (v && Len(v) > 0) {
- char fc = (Char(v))[0];
- if (('0' <= fc && fc <= '9') || '\'' == fc || '"' == fc) {
- /* number or string (or maybe NULL pointer) */
- if (SwigType_ispointer(t) && Strcmp(v, "0") == 0)
- return NewString("None");
- else
- return v;
+ String *convertValue(String *v, SwigType *type) {
+ const char *const s = Char(v);
+ char *end;
+ String *result = NIL;
+ bool fail = false;
+ SwigType *resolved_type = 0;
+
+ // Check if this is a number in any base.
+ long value = strtol(s, &end, 0);
+ (void) value;
+ if (end != s) {
+ if (errno == ERANGE) {
+ // There was an overflow, we could try representing the value as Python
+ // long integer literal, but for now don't bother with it.
+ fail = true;
+ } else {
+ if (*end != '\0') {
+ // If there is a suffix after the number, we can safely ignore any
+ // combination of "l" and "u", but not anything else (again, stuff like
+ // "LL" could be handled, but we don't bother to do it currently).
+ bool seen_long = false;
+ for (char* p = end; *p != '\0'; ++p) {
+ switch (*p) {
+ case 'l':
+ case 'L':
+ // Bail out on "LL".
+ if (seen_long) {
+ fail = true;
+ break;
+ }
+ seen_long = true;
+ break;
+
+ case 'u':
+ case 'U':
+ break;
+
+ default:
+ // Except that our suffix could actually be the fractional part of
+ // a floating point number, so we still have to check for this.
+ result = convertDoubleValue(v);
+ }
+ }
+ }
+
+ if (!fail) {
+ // Allow integers as the default value for a bool parameter.
+ resolved_type = SwigType_typedef_resolve_all(type);
+ if (Cmp(resolved_type, "bool") == 0) {
+ result = NewString(value ? "True" : "False");
+ } else {
+ // Deal with the values starting with 0 first as they can be octal or
+ // hexadecimal numbers or even pointers.
+ if (s[0] == '0') {
+ if (Len(v) == 1) {
+ // This is just a lone 0, but it needs to be represented differently
+ // in Python depending on whether it's a zero or a null pointer.
+ if (SwigType_ispointer(resolved_type))
+ result = NewString("None");
+ else
+ result = v;
+ } else if (s[1] == 'x' || s[1] == 'X') {
+ // This must have been a hex number, we can use it directly in Python,
+ // so nothing to do here.
+ } else {
+ // This must have been an octal number, we have to change its prefix
+ // to be "0o" in Python 3 only (and as long as we still support Python
+ // 2.5, this can't be done unconditionally).
+ if (py3) {
+ if (end - s > 1) {
+ result = NewString("0o");
+ Append(result, NewStringWithSize(s + 1, (int)(end - s - 1)));
+ }
+ }
+ }
+ }
+
+ // Avoid unnecessary string allocation in the common case when we don't
+ // need to remove any suffix.
+ if (!result)
+ result = *end == '\0' ? v : NewStringWithSize(s, (int)(end - s));
+ }
+ }
}
- if (Strcmp(v, "true") == 0 || Strcmp(v, "TRUE") == 0)
- return NewString("True");
- if (Strcmp(v, "false") == 0 || Strcmp(v, "FALSE") == 0)
- return NewString("False");
- if (Strcmp(v, "NULL") == 0)
- return SwigType_ispointer(t) ? NewString("None") : NewString("0");
}
- return 0;
+
+ // Check if this is a floating point number (notice that it wasn't
+ // necessarily parsed as a long above, consider e.g. ".123").
+ if (!fail && !result) {
+ result = convertDoubleValue(v);
+ if (!result) {
+ if (Strcmp(v, "true") == 0 || Strcmp(v, "TRUE") == 0)
+ result = NewString("True");
+ else if (Strcmp(v, "false") == 0 || Strcmp(v, "FALSE") == 0)
+ result = NewString("False");
+ else if (Strcmp(v, "NULL") == 0 || Strcmp(v, "nullptr") == 0) {
+ if (!resolved_type)
+ resolved_type = SwigType_typedef_resolve_all(type);
+ result = SwigType_ispointer(resolved_type) ? NewString("None") : NewString("0");
+ }
+
+ // This could also be an enum type, default value of which could be
+ // representable in Python if it doesn't include any scope (which could,
+ // but currently is not, translated).
+ else if (!Strchr(s, ':')) {
+ Node *lookup = Swig_symbol_clookup(v, 0);
+ if (lookup) {
+ if (Cmp(Getattr(lookup, "nodeType"), "enumitem") == 0)
+ result = Getattr(lookup, "sym:name");
+ }
+ }
+ }
+ }
+
+ Delete(resolved_type);
+ return result;
}
+
/* ------------------------------------------------------------
- * is_primitive_defaultargs()
- * Check if all the default args have primitive type.
- * (So we can generate proper parameter list with default
- * values..)
+ * is_representable_as_pyargs()
+ *
+ * Check if the function parameters default argument values
+ * can be represented in Python.
+ *
+ * If this method returns false, the parameters will be translated
+ * to a generic "*args" which allows us to deal with default values
+ * at C++ code level where they can always be handled.
* ------------------------------------------------------------ */
- bool is_primitive_defaultargs(Node *n) {
+ bool is_representable_as_pyargs(Node *n) {
ParmList *plist = CopyParmList(Getattr(n, "parms"));
+ Swig_typemap_attach_parms("default", plist, NULL);
+
Parm *p;
Parm *pnext;
- Swig_typemap_attach_parms("in", plist, 0);
for (p = plist; p; p = pnext) {
+ pnext = nextSibling(p);
String *tm = Getattr(p, "tmap:in");
if (tm) {
- pnext = Getattr(p, "tmap:in:next");
+ Parm *in_next = Getattr(p, "tmap:in:next");
+ if (in_next)
+ pnext = in_next;
if (checkAttribute(p, "tmap:in:numinputs", "0")) {
continue;
}
- } else {
- pnext = nextSibling(p);
}
- String *type = Getattr(p, "type");
- String *value = Getattr(p, "value");
- if (!convertValue(value, type))
+
+ // "default" typemap can contain arbitrary C++ code, so while it could, in
+ // principle, be possible to examine it and check if it's just something
+ // simple of the form "$1 = expression" and then use convertValue() to
+ // check if expression can be used in Python, but for now we just
+ // pessimistically give up and prefer to handle this at C++ level only.
+ if (Getattr(p, "tmap:default"))
return false;
+
+ if (String *value = Getattr(p, "value")) {
+ String *type = Getattr(p, "type");
+ if (!convertValue(value, type))
+ return false;
+ }
}
+
return true;
}
/* ------------------------------------------------------------
* is_real_overloaded()
- * Check if the function is overloaded, but not just have some
- * siblings generated due to the original function have
- * default arguments.
+ *
+ * Check if the function is overloaded, but not just have some
+ * siblings generated due to the original function have
+ * default arguments.
* ------------------------------------------------------------ */
bool is_real_overloaded(Node *n) {
Node *h = Getattr(n, "sym:overloaded");
/* ------------------------------------------------------------
* make_pyParmList()
- * Generate parameter list for Python functions or methods,
- * reuse make_autodocParmList() to do so.
+ *
+ * Generate parameter list for Python functions or methods,
+ * reuse make_autodocParmList() to do so.
* ------------------------------------------------------------ */
String *make_pyParmList(Node *n, bool in_class, bool is_calling, int kw) {
/* Get the original function for a defaultargs copy,
if (nn)
n = nn;
- /* For overloaded function, just use *args */
- if (is_real_overloaded(n) || GetFlag(n, "feature:compactdefaultargs") || !is_primitive_defaultargs(n)) {
+ /* We prefer to explicitly list all parameters of the C function in the
+ generated Python code as this makes the function more convenient to use,
+ however in some cases we must replace the real parameters list with just
+ the catch all "*args". This happens when:
+
+ 1. The function is overloaded as Python doesn't support this.
+ 2. We were explicitly asked to use the "compact" arguments form.
+ 3. We were explicitly asked to use default args from C via the "python:cdefaultargs" feature.
+ 4. One of the default argument values can't be represented in Python.
+ */
+ if (is_real_overloaded(n) || GetFlag(n, "feature:compactdefaultargs") || GetFlag(n, "feature:python:cdefaultargs") || !is_representable_as_pyargs(n)) {
String *parms = NewString("");
if (in_class)
Printf(parms, "self, ");
/* ------------------------------------------------------------
* have_pythonprepend()
- * Check if there is a %pythonprepend directive and it has text
+ *
+ * Check if there is a %pythonprepend directive and it has text
* ------------------------------------------------------------ */
bool have_pythonprepend(Node *n) {
/* ------------------------------------------------------------
* pythonprepend()
- * Get the %pythonprepend code, stripping off {} if neccessary
+ *
+ * Get the %pythonprepend code, stripping off {} if necessary
* ------------------------------------------------------------ */
String *pythonprepend(Node *n) {
/* ------------------------------------------------------------
* have_pythonappend()
- * Check if there is a %pythonappend directive and it has text
+ *
+ * Check if there is a %pythonappend directive and it has text
* ------------------------------------------------------------ */
bool have_pythonappend(Node *n) {
/* ------------------------------------------------------------
* pythonappend()
- * Get the %pythonappend code, stripping off {} if neccessary
+ *
+ * Get the %pythonappend code, stripping off {} if necessary
* ------------------------------------------------------------ */
String *pythonappend(Node *n) {
/* ------------------------------------------------------------
* have_addtofunc()
- * Check if there is a %addtofunc directive and it has text
+ *
+ * Check if there is a %addtofunc directive and it has text
* ------------------------------------------------------------ */
bool have_addtofunc(Node *n) {
/* ------------------------------------------------------------
* returnTypeAnnotation()
- * Helper function for constructing the function annotation
- * of the returning type, return a empty string for Python 2.x
+ *
+ * Helper function for constructing the function annotation
+ * of the returning type, return a empty string for Python 2.x
* ------------------------------------------------------------ */
String *returnTypeAnnotation(Node *n) {
String *ret = 0;
if (ret)
ret = SwigType_str(ret, 0);
}
- return (ret && py3) ? NewStringf(" -> \"%s\" ", ret)
+ return (ret && py3) ? NewStringf(" -> \"%s\"", ret)
: NewString("");
}
/* ------------------------------------------------------------
* emitFunctionShadowHelper()
- * Refactoring some common code out of functionWrapper and
- * dispatchFunction that writes the proxy code for non-member
- * functions.
+ *
+ * Refactoring some common code out of functionWrapper and
+ * dispatchFunction that writes the proxy code for non-member
+ * functions.
* ------------------------------------------------------------ */
void emitFunctionShadowHelper(Node *n, File *f_dest, String *name, int kw) {
/* Make a wrapper function to insert the code into */
Printv(f_dest, "\ndef ", name, "(", parms, ")", returnTypeAnnotation(n), ":\n", NIL);
if (have_docstring(n))
- Printv(f_dest, " ", docstring(n, AUTODOC_FUNC, tab4), "\n", NIL);
+ Printv(f_dest, tab4, docstring(n, AUTODOC_FUNC, tab4), "\n", NIL);
if (have_pythonprepend(n))
- Printv(f_dest, pythoncode(pythonprepend(n), " "), "\n", NIL);
+ Printv(f_dest, indent_pythoncode(pythonprepend(n), tab4, Getfile(n), Getline(n), "%pythonprepend or %feature(\"pythonprepend\")"), "\n", NIL);
if (have_pythonappend(n)) {
- Printv(f_dest, " val = ", funcCall(name, callParms), "\n", NIL);
- Printv(f_dest, pythoncode(pythonappend(n), " "), "\n", NIL);
- Printv(f_dest, " return val\n", NIL);
+ Printv(f_dest, tab4 "val = ", funcCall(name, callParms), "\n", NIL);
+ Printv(f_dest, indent_pythoncode(pythonappend(n), tab4, Getfile(n), Getline(n), "%pythonappend or %feature(\"pythonappend\")"), "\n", NIL);
+ Printv(f_dest, tab4 "return val\n", NIL);
} else {
- Printv(f_dest, " return ", funcCall(name, callParms), "\n", NIL);
+ Printv(f_dest, tab4 "return ", funcCall(name, callParms), "\n", NIL);
}
- if (Getattr(n, "feature:python:callback") || !have_addtofunc(n)) {
+ if (!have_addtofunc(n)) {
/* If there is no addtofunc directive then just assign from the extension module (for speed up) */
Printv(f_dest, name, " = ", module, ".", name, "\n", NIL);
}
/* ------------------------------------------------------------
* check_kwargs()
- * check if using kwargs is allowed for this Node
+ *
+ * check if using kwargs is allowed for this Node
* ------------------------------------------------------------ */
- int check_kwargs(Node *n) {
+ int check_kwargs(Node *n) const {
return (use_kw || GetFlag(n, "feature:kwargs"))
&& !GetFlag(n, "memberset") && !GetFlag(n, "memberget");
}
if (!n) {
Append(methods, "NULL");
- } else if (Getattr(n, "feature:callback")) {
- if (have_docstring(n)) {
- String *ds = cdocstring(n, AUTODOC_FUNC);
- Printf(methods, "(char *)\"%s\\nswig_ptr: %s\"", ds, Getattr(n, "feature:callback:name"));
- Delete(ds);
- } else {
- Printf(methods, "(char *)\"swig_ptr: %s\"", Getattr(n, "feature:callback:name"));
- }
} else if (have_docstring(n)) {
String *ds = cdocstring(n, AUTODOC_FUNC);
Printf(methods, "(char *)\"%s\"", ds);
Delete(ds);
+ } else if (Getattr(n, "feature:callback")) {
+ Printf(methods, "(char *)\"swig_ptr: %s\"", Getattr(n, "feature:callback:name"));
} else {
Append(methods, "NULL");
}
Printv(f->def, linkage, builtin_ctor ? "int " : "PyObject *", wname, "(PyObject *self, PyObject *args) {", NIL);
- Wrapper_add_local(f, "argc", "int argc");
- Printf(tmp, "PyObject *argv[%d]", maxargs + 1);
+ Wrapper_add_local(f, "argc", "Py_ssize_t argc");
+ Printf(tmp, "PyObject *argv[%d] = {0}", maxargs + 1);
Wrapper_add_local(f, "argv", tmp);
if (!fastunpack) {
- Wrapper_add_local(f, "ii", "int ii");
+ Wrapper_add_local(f, "ii", "Py_ssize_t ii");
if (maxargs - (add_self ? 1 : 0) > 0)
Append(f->code, "if (!PyTuple_Check(args)) SWIG_fail;\n");
- Append(f->code, "argc = args ? (int)PyObject_Length(args) : 0;\n");
+ Append(f->code, "argc = args ? PyObject_Length(args) : 0;\n");
if (add_self)
Append(f->code, "argv[0] = self;\n");
Printf(f->code, "for (ii = 0; (ii < %d) && (ii < argc); ii++) {\n", add_self ? maxargs - 1 : maxargs);
Append(f->code, "--argc;\n");
}
- Replaceall(dispatch, "$args", "self,args");
+ Replaceall(dispatch, "$args", "self, args");
Printv(f->code, dispatch, "\n", NIL);
int noargs = funpack && (tuple_required == 0 && tuple_arguments == 0);
int onearg = funpack && (tuple_required == 1 && tuple_arguments == 1);
- if (builtin && funpack && !overname && !builtin_ctor && !GetFlag(n, "feature:compactdefaultargs")) {
+ if (builtin && funpack && !overname && !builtin_ctor &&
+ !(GetFlag(n, "feature:compactdefaultargs") && (tuple_arguments > tuple_required || varargs))) {
String *argattr = NewStringf("%d", tuple_arguments);
Setattr(n, "python:argcount", argattr);
Delete(argattr);
}
SwigType *pt = Getattr(p, "type");
- String *pn = Getattr(p, "name");
String *ln = Getattr(p, "lname");
bool parse_from_tuple = (i > 0 || !add_self);
if (SwigType_type(pt) == T_VARARGS) {
/* Keyword argument handling */
if (allow_kwargs && parse_from_tuple) {
- if (Len(pn)) {
- String *tmp = 0;
- String *name = pn;
- if (!Getattr(p, "hidden")) {
- name = tmp = Swig_name_make(p, 0, pn, 0, 0); // rename parameter if a keyword
- }
- Printf(kwargs, "(char *) \"%s\",", name);
- if (tmp)
- Delete(tmp);
- } else {
- Printf(kwargs, "(char *)\"arg%d\",", i + 1);
- }
+ String *name = makeParameterName(n, p, i + 1);
+ Printf(kwargs, "(char *) \"%s\",", name);
+ Delete(name);
}
/* Look for an input typemap */
Printv(f->locals, " char * kwnames[] = ", kwargs, ";\n", NIL);
}
- if (use_parse || allow_kwargs || !modernargs) {
- if (builtin && in_class && tuple_arguments == 0) {
- Printf(parse_args, " if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;\n");
- } else {
- Printf(parse_args, ":%s\"", iname);
- Printv(parse_args, arglist, ")) SWIG_fail;\n", NIL);
- funpack = 0;
- }
+ if (builtin && !funpack && in_class && tuple_arguments == 0) {
+ Printf(parse_args, " if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, \"%s takes no arguments\");\n", iname);
+ } else if (use_parse || allow_kwargs || !modernargs) {
+ Printf(parse_args, ":%s\"", iname);
+ Printv(parse_args, arglist, ")) SWIG_fail;\n", NIL);
+ funpack = 0;
} else {
Clear(parse_args);
if (funpack) {
Printf(parse_args, "if (!SWIG_Python_UnpackTuple(args,\"%s\",%d,%d,0)) SWIG_fail;\n", iname, num_fixed_arguments, tuple_arguments);
}
}
- } else if (tuple_arguments > 0) {
+ } else {
Printf(parse_args, "if(!PyArg_UnpackTuple(args,(char *)\"%s\",%d,%d", iname, num_fixed_arguments, tuple_arguments);
Printv(parse_args, arglist, ")) SWIG_fail;\n", NIL);
}
/* Insert cleanup code */
for (p = l; p;) {
- // if (!checkAttribute(p,"tmap:in:numinputs","0") && !Getattr(p,"tmap:in:parse")) {
if (!Getattr(p, "tmap:in:parse") && (tm = Getattr(p, "tmap:freearg"))) {
if (Getattr(p, "tmap:freearg:implicitconv")) {
const char *convflag = "0";
}
/* If this is a builtin type, create a PyGetSetDef entry for this member variable. */
+ if (builtin) {
+ const char *memname = "__dict__";
+ Hash *h = Getattr(builtin_getset, memname);
+ if (!h) {
+ h = NewHash();
+ Setattr(builtin_getset, memname, h);
+ Delete(h);
+ }
+ Setattr(h, "getter", "SwigPyObject_get___dict__");
+ }
+
if (builtin_getter) {
String *memname = Getattr(n, "membervariableHandler:sym:name");
if (!memname)
* constantWrapper()
* ------------------------------------------------------------ */
+ /* Determine if the node requires the _swigconstant code to be generated */
+ bool needs_swigconstant(Node* n) {
+ SwigType *type = Getattr(n, "type");
+ SwigType *qtype = SwigType_typedef_resolve_all(type);
+ SwigType *uqtype = SwigType_strip_qualifiers(qtype);
+ bool result = false;
+
+ /* Note, that we need special handling for function pointers, as
+ * SwigType_base(fptr) does not return the underlying pointer-to-function
+ * type but the return-type of function. */
+ if(!SwigType_isfunction(uqtype) && !SwigType_isfunctionpointer(uqtype)) {
+ SwigType *basetype = SwigType_base(uqtype);
+ result = SwigType_isclass(basetype) != 0;
+ Delete(basetype);
+ }
+
+ Delete(qtype);
+ Delete(uqtype);
+
+ return result;
+ }
+
virtual int constantWrapper(Node *n) {
String *name = Getattr(n, "name");
String *iname = Getattr(n, "sym:name");
Replaceall(tm, "$source", value);
Replaceall(tm, "$target", name);
Replaceall(tm, "$value", value);
- Printf(f_init, "%s\n", tm);
+ if (needs_swigconstant(n) && !builtin && (shadow) && (!(shadow & PYSHADOW_MEMBER)) && (!in_class || !Getattr(n, "feature:python:callback"))) {
+ // Generate `*_swigconstant()` method which registers the new constant.
+ //
+ // *_swigconstant methods are required for constants of class type.
+ // Class types are registered in shadow file (see *_swigregister). The
+ // instances of class must be created (registered) after the type is
+ // registered, so we can't let SWIG_init() to register constants of
+ // class type (the SWIG_init() is called before shadow classes are
+ // defined and registered).
+ Printf(f_wrappers, "SWIGINTERN PyObject *%s_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {\n", iname);
+ Printf(f_wrappers, tab2 "PyObject *module;\n", tm);
+ Printf(f_wrappers, tab2 "PyObject *d;\n");
+ if (modernargs) {
+ if (fastunpack) {
+ Printf(f_wrappers, tab2 "if (!SWIG_Python_UnpackTuple(args,(char*)\"swigconstant\", 1, 1,&module)) return NULL;\n");
+ } else {
+ Printf(f_wrappers, tab2 "if (!PyArg_UnpackTuple(args,(char*)\"swigconstant\", 1, 1,&module)) return NULL;\n");
+ }
+ } else {
+ Printf(f_wrappers, tab2 "if (!PyArg_ParseTuple(args,(char*)\"O:swigconstant\", &module)) return NULL;\n");
+ }
+ Printf(f_wrappers, tab2 "d = PyModule_GetDict(module);\n");
+ Printf(f_wrappers, tab2 "if (!d) return NULL;\n");
+ Printf(f_wrappers, tab2 "%s\n", tm);
+ Printf(f_wrappers, tab2 "return SWIG_Py_Void();\n");
+ Printf(f_wrappers, "}\n\n\n");
+
+ // Register the method in SwigMethods array
+ String *cname = NewStringf("%s_swigconstant", iname);
+ add_method(cname, cname, 0);
+ Delete(cname);
+ } else {
+ Printf(f_init, "%s\n", tm);
+ }
Delete(tm);
have_tm = 1;
}
if (!builtin && (shadow) && (!(shadow & PYSHADOW_MEMBER))) {
if (!in_class) {
+ if(needs_swigconstant(n)) {
+ Printv(f_shadow, "\n",NIL);
+ Printv(f_shadow, module, ".", iname, "_swigconstant(",module,")\n", NIL);
+ }
Printv(f_shadow, iname, " = ", module, ".", iname, "\n", NIL);
} else {
if (!(Getattr(n, "feature:python:callback"))) {
+ if(needs_swigconstant(n)) {
+ Printv(f_shadow_stubs, "\n",NIL);
+ Printv(f_shadow_stubs, module, ".", iname, "_swigconstant(", module, ")\n", NIL);
+ }
Printv(f_shadow_stubs, iname, " = ", module, ".", iname, "\n", NIL);
}
}
* BEGIN C++ Director Class modifications
* ------------------------------------------------------------------------- */
- /* C++/Python polymorphism demo code, copyright (C) 2002 Mark Rose <mrose@stm.lbl.gov>
+ /* C++/Python polymorphism demo code
*
* TODO
*
But for now, this seems to be the least intrusive way.
*/
- Printf(f_directors_h, "\n\n");
- Printf(f_directors_h, "/* Internal Director utilities */\n");
+ Printf(f_directors_h, "\n");
+ Printf(f_directors_h, "/* Internal director utilities */\n");
Printf(f_directors_h, "public:\n");
- Printf(f_directors_h, " bool swig_get_inner(const char* swig_protected_method_name) const {\n");
+ Printf(f_directors_h, " bool swig_get_inner(const char *swig_protected_method_name) const {\n");
Printf(f_directors_h, " std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);\n");
Printf(f_directors_h, " return (iv != swig_inner.end() ? iv->second : false);\n");
- Printf(f_directors_h, " }\n\n");
+ Printf(f_directors_h, " }\n");
- Printf(f_directors_h, " void swig_set_inner(const char* swig_protected_method_name, bool val) const\n");
- Printf(f_directors_h, " { swig_inner[swig_protected_method_name] = val;}\n\n");
+ Printf(f_directors_h, " void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {\n");
+ Printf(f_directors_h, " swig_inner[swig_protected_method_name] = swig_val;\n");
+ Printf(f_directors_h, " }\n");
Printf(f_directors_h, "private:\n");
Printf(f_directors_h, " mutable std::map<std::string, bool> swig_inner;\n");
}
if (director_method_index) {
- Printf(f_directors_h, "\n\n");
+ Printf(f_directors_h, "\n");
Printf(f_directors_h, "#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)\n");
Printf(f_directors_h, "/* VTable implementation */\n");
Printf(f_directors_h, " PyObject *swig_get_method(size_t method_index, const char *method_name) const {\n");
if (shadow && !Getattr(n, "feature:onlychildren")) {
Node *mod = Getattr(n, "module");
if (mod) {
- String *importname = NewString("");
String *modname = Getattr(mod, "name");
- if (Strcmp(modname, mainmodule) != 0) {
- // check if the module has a package option
- Node *options = Getattr(mod, "options");
- String *pkg = options ? Getattr(options, "package") : 0;
- if (pkg) {
- Printf(importname, "%s.", pkg);
- }
- Printf(importname, "%s.", modname);
- }
- Append(importname, Getattr(n, "sym:name"));
+ Node *options = Getattr(mod, "options");
+ String *pkg = options ? Getattr(options, "package") : 0;
+ String *sym = Getattr(n, "sym:name");
+ String *importname = import_name_string(package, mainmodule, pkg, modname, sym);
Setattr(n, "python:proxy", importname);
+ Delete(importname);
}
}
int result = Language::classDeclaration(n);
if (GetFlag(n, "feature:python:nondynamic"))
Setattr(n, "feature:python:tp_setattro", "SWIG_Python_NonDynamicSetAttr");
- String *quoted_symname = NewStringf("\"%s\"", symname);
- String *quoted_rname = NewStringf("\"%s\"", rname);
+ Node *mod = Getattr(n, "module");
+ String *modname = mod ? Getattr(mod, "name") : 0;
+ String *quoted_symname;
+ if (package) {
+ if (modname)
+ quoted_symname = NewStringf("\"%s.%s.%s\"", package, modname, symname);
+ else
+ quoted_symname = NewStringf("\"%s.%s\"", package, symname);
+ } else {
+ if (modname)
+ quoted_symname = NewStringf("\"%s.%s\"", modname, symname);
+ else
+ quoted_symname = NewStringf("\"%s\"", symname);
+ }
+ String *quoted_tp_doc_str = NewStringf("\"%s\"", getSlot(n, "feature:python:tp_doc"));
char const *tp_init = builtin_tp_init ? Char(builtin_tp_init) : Swig_directorclass(n) ? "0" : "SwigPyBuiltin_BadInit";
String *tp_flags = NewString("Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES");
String *py3_tp_flags = NewString("Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE");
Printv(f, "#else\n", NIL);
printSlot(f, tp_flags, "tp_flags");
Printv(f, "#endif\n", NIL);
- printSlot(f, quoted_rname, "tp_doc");
+ printSlot(f, quoted_tp_doc_str, "tp_doc");
printSlot(f, getSlot(n, "feature:python:tp_traverse"), "tp_traverse", "traverseproc");
printSlot(f, getSlot(n, "feature:python:tp_clear"), "tp_clear", "inquiry");
printSlot(f, richcompare_func, "feature:python:tp_richcompare", "richcmpfunc");
Printv(f, "#if PY_VERSION_HEX >= 0x02060000\n", NIL);
printSlot(f, getSlot(n, "feature:python:tp_version_tag"), "tp_version_tag", "int");
Printv(f, "#endif\n", NIL);
+ Printv(f, "#if PY_VERSION_HEX >= 0x03040000\n", NIL);
+ printSlot(f, getSlot(n, "feature:python:tp_finalize"), "tp_finalize", "destructor");
+ Printv(f, "#endif\n", NIL);
+ Printv(f, "#ifdef COUNT_ALLOCS\n", NIL);
+ printSlot(f, getSlot(), "tp_allocs", "Py_ssize_t");
+ printSlot(f, getSlot(), "tp_frees", "Py_ssize_t");
+ printSlot(f, getSlot(), "tp_maxalloc", "Py_ssize_t");
+ Printv(f, "#if PY_VERSION_HEX >= 0x02050000\n", NIL);
+ printSlot(f, getSlot(), "tp_prev", "struct _typeobject*");
+ Printv(f, "#endif\n", NIL);
+ printSlot(f, getSlot(), "tp_next", "struct _typeobject*");
+ Printv(f, "#endif\n", NIL);
Printf(f, " },\n");
+ // PyAsyncMethods as_async
+ Printv(f, "#if PY_VERSION_HEX >= 0x03050000\n", NIL);
+ Printf(f, " {\n");
+ printSlot(f, getSlot(n, "feature:python:am_await"), "am_await", "unaryfunc");
+ printSlot(f, getSlot(n, "feature:python:am_aiter"), "am_aiter", "unaryfunc");
+ printSlot(f, getSlot(n, "feature:python:am_anext"), "am_anext", "unaryfunc");
+ Printf(f, " },\n");
+ Printv(f, "#endif\n", NIL);
+
// PyNumberMethods as_number
Printf(f, " {\n");
printSlot(f, getSlot(n, "feature:python:nb_add"), "nb_add", "binaryfunc");
printSlot(f, getSlot(n, "feature:python:nb_inplace_xor"), "nb_inplace_xor", "binaryfunc");
printSlot(f, getSlot(n, "feature:python:nb_inplace_or"), "nb_inplace_or", "binaryfunc");
printSlot(f, getSlot(n, "feature:python:nb_floor_divide"), "nb_floor_divide", "binaryfunc");
- printSlot(f, getSlot(n, "feature:python:nb_true_divide"), "nb_true_divide", "binaryfunc");
+ printSlot(f, getSlot(n, "feature:python:nb_divide"), "nb_true_divide", "binaryfunc");
printSlot(f, getSlot(n, "feature:python:nb_inplace_floor_divide"), "nb_inplace_floor_divide", "binaryfunc");
- printSlot(f, getSlot(n, "feature:python:nb_inplace_true_divide"), "nb_inplace_true_divide", "binaryfunc");
+ printSlot(f, getSlot(n, "feature:python:nb_inplace_divide"), "nb_inplace_true_divide", "binaryfunc");
Printv(f, "#if PY_VERSION_HEX >= 0x02050000\n", NIL);
printSlot(f, getSlot(n, "feature:python:nb_index"), "nb_index", "unaryfunc");
Printv(f, "#endif\n", NIL);
+ Printv(f, "#if PY_VERSION_HEX >= 0x03050000\n", NIL);
+ printSlot(f, getSlot(n, "feature:python:nb_matrix_multiply"), "nb_matrix_multiply", "binaryfunc");
+ printSlot(f, getSlot(n, "feature:python:nb_inplace_matrix_multiply"), "nb_inplace_matrix_multiply", "binaryfunc");
+ Printv(f, "#endif\n", NIL);
Printf(f, " },\n");
// PyMappingMethods as_mapping;
Printv(f, "#endif\n", NIL);
Printf(f, " },\n");
- // PyObject *ht_name, *ht_slots
+ // PyObject *ht_name, *ht_slots, *ht_qualname;
printSlot(f, getSlot(n, "feature:python:ht_name"), "ht_name", "PyObject*");
printSlot(f, getSlot(n, "feature:python:ht_slots"), "ht_slots", "PyObject*");
+ Printv(f, "#if PY_VERSION_HEX >= 0x03030000\n", NIL);
+ printSlot(f, getSlot(n, "feature:python:ht_qualname"), "ht_qualname", "PyObject*");
+
+ // struct _dictkeysobject *ht_cached_keys;
+ printSlot(f, getSlot(n, "feature:python:ht_cached_keys"), "ht_cached_keys", "struct _dictkeysobject*");
+ Printv(f, "#endif\n", NIL);
Printf(f, "};\n\n");
String *clientdata = NewString("");
Printf(clientdata, "&%s_clientdata", templ);
SwigType_remember_mangleddata(pmname, clientdata);
- String *smartptr = Getattr(n, "feature:smartptr");
- if (smartptr) {
- SwigType *spt = Swig_cparse_type(smartptr);
- SwigType *smart = SwigType_typedef_resolve_all(spt);
+ SwigType *smart = Swig_cparse_smartptr(n);
+ if (smart) {
SwigType_add_pointer(smart);
String *smart_pmname = SwigType_manglestr(smart);
SwigType_remember_mangleddata(smart_pmname, clientdata);
- Delete(spt);
- Delete(smart);
Delete(smart_pmname);
}
Printv(f_init, " d = md;\n", NIL);
Delete(clientdata);
+ Delete(smart);
Delete(rname);
Delete(pname);
Delete(mname);
Delete(tp_flags);
Delete(py3_tp_flags);
Delete(quoted_symname);
- Delete(quoted_rname);
+ Delete(quoted_tp_doc_str);
Delete(clientdata_klass);
Delete(richcompare_func);
Delete(getset_name);
Printv(base_class, bname, NIL);
b = Next(b);
if (b.item) {
- Putc(',', base_class);
+ Printv(base_class, ", ", NIL);
}
}
}
String *abcs = Getattr(n, "feature:python:abc");
if (py3 && abcs) {
if (Len(base_class)) {
- Putc(',', base_class);
+ Printv(base_class, ", ", NIL);
}
Printv(base_class, abcs, NIL);
}
String *str = cdocstring(n, AUTODOC_CLASS);
Setattr(n, "feature:python:tp_doc", str);
Delete(str);
+ } else {
+ String *name = Getattr(n, "name");
+ String *rname = add_explicit_scope(SwigType_namestr(name));
+ Setattr(n, "feature:python:tp_doc", rname);
+ Delete(rname);
}
} else {
Printv(f_shadow, "class ", class_name, NIL);
if (have_docstring(n)) {
String *str = docstring(n, AUTODOC_CLASS, tab4);
if (str && Len(str))
- Printv(f_shadow, tab4, str, "\n", NIL);
+ Printv(f_shadow, tab4, str, "\n\n", NIL);
}
if (!modern) {
Printv(f_shadow, tab4, "__swig_setmethods__ = {}\n", NIL);
if (Len(base_class)) {
- Printf(f_shadow, "%sfor _s in [%s]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))\n", tab4, base_class);
+ Printv(f_shadow, tab4, "for _s in [", base_class, "]:\n", tab8, "__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))\n", NIL);
}
if (!GetFlag(n, "feature:python:nondynamic")) {
Printv(f_shadow, tab4, "__swig_getmethods__ = {}\n", NIL);
if (Len(base_class)) {
- Printf(f_shadow, "%sfor _s in [%s]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))\n", tab4, base_class);
+ Printv(f_shadow, tab4, "for _s in [", base_class, "]:\n", tab8, "__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))\n", NIL);
}
Printv(f_shadow, tab4, "__getattr__ = lambda self, name: _swig_getattr(self, ", class_name, ", name)\n", NIL);
if (builtin)
builtin_pre_decl(n);
- /* Overide the shadow file so we can capture its methods */
+ /* Override the shadow file so we can capture its methods */
f_shadow = NewString("");
// Set up type check for director class constructor
/* Complete the class */
if (shadow) {
/* Generate a class registration function */
- String *smartptr = Getattr(n, "feature:smartptr"); // Replace storing a pointer to underlying class with a smart pointer (intended for use with non-intrusive smart pointers)
- SwigType *smart = 0;
- if (smartptr) {
- SwigType *cpt = Swig_cparse_type(smartptr);
- if (cpt) {
- smart = SwigType_typedef_resolve_all(cpt);
- Delete(cpt);
- } else {
- // TODO: report line number of where the feature comes from
- Swig_error(Getfile(n), Getline(n), "Invalid type (%s) in 'smartptr' feature for class %s.\n", smartptr, real_classname);
- }
- }
+ // Replace storing a pointer to underlying class with a smart pointer (intended for use with non-intrusive smart pointers)
+ SwigType *smart = Swig_cparse_smartptr(n);
SwigType *ct = Copy(smart ? smart : real_classname);
SwigType_add_pointer(ct);
SwigType *realct = Copy(real_classname);
Delete(realct);
if (!have_constructor) {
if (!builtin)
- Printv(f_shadow_file, tab4, "def __init__(self, *args, **kwargs): raise AttributeError(\"", "No constructor defined",
+ Printv(f_shadow_file, "\n", tab4, "def __init__(self, *args, **kwargs):\n", tab8, "raise AttributeError(\"", "No constructor defined",
(Getattr(n, "abstracts") ? " - class is abstract" : ""), "\")\n", NIL);
} else if (fastinit && !builtin) {
Printv(f_shadow_file, "\nclass ", class_name, "Ptr(", class_name, "):\n", tab4, "def __init__(self, this):\n", NIL);
if (!modern) {
Printv(f_shadow_file,
- tab8, "try: self.this.append(this)\n",
- tab8, "except: self.this = this\n", tab8, "self.this.own(0)\n", tab8, "self.__class__ = ", class_name, "\n\n", NIL);
+ tab8, "try:\n", tab8, tab4, "self.this.append(this)\n",
+ tab8, "except __builtin__.Exception:\n", tab8, tab4, "self.this = this\n", tab8, "self.this.own(0)\n", tab8, "self.__class__ = ", class_name, "\n\n", NIL);
} else {
Printv(f_shadow_file,
- tab8, "try: self.this.append(this)\n",
- tab8, "except: self.this = this\n", tab8, "self.this.own(0)\n", tab8, "self.__class__ = ", class_name, "\n\n", NIL);
+ tab8, "try:\n", tab8, tab4, "self.this.append(this)\n",
+ tab8, "except __builtin__.Exception:\n", tab8, tab4, "self.this = this\n", tab8, "self.this.own(0)\n", tab8, "self.__class__ = ", class_name, "\n\n", NIL);
}
}
List *shadow_list = Getattr(n, "shadow_methods");
for (int i = 0; i < Len(shadow_list); ++i) {
String *symname = Getitem(shadow_list, i);
- Printf(f_shadow_file, "%s.%s = new_instancemethod(%s.%s,None,%s)\n", class_name, symname, module, Swig_name_member(NSPACE_TODO, class_name, symname),
+ Printf(f_shadow_file, "%s.%s = new_instancemethod(%s.%s, None, %s)\n", class_name, symname, module, Swig_name_member(NSPACE_TODO, class_name, symname),
class_name);
}
}
have_repr = 1;
}
if (Getattr(n, "feature:shadow")) {
- String *pycode = pythoncode(Getattr(n, "feature:shadow"), tab4);
+ String *pycode = indent_pythoncode(Getattr(n, "feature:shadow"), tab4, Getfile(n), Getline(n), "%feature(\"shadow\")");
String *pyaction = NewStringf("%s.%s", module, fullname);
Replaceall(pycode, "$action", pyaction);
Delete(pyaction);
String *callParms = make_pyParmList(n, true, true, allow_kwargs);
if (!have_addtofunc(n)) {
if (!fastproxy || olddefs) {
- Printv(f_shadow, tab4, "def ", symname, "(", parms, ")", returnTypeAnnotation(n), ":", NIL);
- Printv(f_shadow, " return ", funcCall(fullname, callParms), "\n", NIL);
+ Printv(f_shadow, "\n", tab4, "def ", symname, "(", parms, ")", returnTypeAnnotation(n), ":\n", NIL);
+ Printv(f_shadow, tab8, "return ", funcCall(fullname, callParms), "\n", NIL);
}
} else {
- Printv(f_shadow, tab4, "def ", symname, "(", parms, ")", returnTypeAnnotation(n), ":", NIL);
- Printv(f_shadow, "\n", NIL);
+ Printv(f_shadow, "\n", tab4, "def ", symname, "(", parms, ")", returnTypeAnnotation(n), ":\n", NIL);
if (have_docstring(n))
Printv(f_shadow, tab8, docstring(n, AUTODOC_METHOD, tab8), "\n", NIL);
if (have_pythonprepend(n)) {
fproxy = 0;
- Printv(f_shadow, pythoncode(pythonprepend(n), tab8), "\n", NIL);
+ Printv(f_shadow, indent_pythoncode(pythonprepend(n), tab8, Getfile(n), Getline(n), "%pythonprepend or %feature(\"pythonprepend\")"), "\n", NIL);
}
if (have_pythonappend(n)) {
fproxy = 0;
Printv(f_shadow, tab8, "val = ", funcCall(fullname, callParms), "\n", NIL);
- Printv(f_shadow, pythoncode(pythonappend(n), tab8), "\n", NIL);
+ Printv(f_shadow, indent_pythoncode(pythonappend(n), tab8, Getfile(n), Getline(n), "%pythonappend or %feature(\"pythonappend\")"), "\n", NIL);
Printv(f_shadow, tab8, "return val\n\n", NIL);
} else {
Printv(f_shadow, tab8, "return ", funcCall(fullname, callParms), "\n\n", NIL);
}
if (shadow) {
- if (!classic && !Getattr(n, "feature:python:callback") && have_addtofunc(n)) {
+ if (!Getattr(n, "feature:python:callback") && have_addtofunc(n)) {
int kw = (check_kwargs(n) && !Getattr(n, "sym:overloaded")) ? 1 : 0;
String *parms = make_pyParmList(n, false, false, kw);
String *callParms = make_pyParmList(n, false, true, kw);
- Printv(f_shadow, tab4, "def ", symname, "(", parms, ")", returnTypeAnnotation(n), ":\n", NIL);
+ Printv(f_shadow, "\n", tab4, "def ", symname, "(", parms, ")", returnTypeAnnotation(n), ":\n", NIL);
if (have_docstring(n))
Printv(f_shadow, tab8, docstring(n, AUTODOC_STATICFUNC, tab8), "\n", NIL);
if (have_pythonprepend(n))
- Printv(f_shadow, pythoncode(pythonprepend(n), tab8), "\n", NIL);
+ Printv(f_shadow, indent_pythoncode(pythonprepend(n), tab8, Getfile(n), Getline(n), "%pythonprepend or %feature(\"pythonprepend\")"), "\n", NIL);
if (have_pythonappend(n)) {
Printv(f_shadow, tab8, "val = ", funcCall(Swig_name_member(NSPACE_TODO, class_name, symname), callParms), "\n", NIL);
- Printv(f_shadow, pythoncode(pythonappend(n), tab8), "\n", NIL);
+ Printv(f_shadow, indent_pythoncode(pythonappend(n), tab8, Getfile(n), Getline(n), "%pythonappend or %feature(\"pythonappend\")"), "\n", NIL);
Printv(f_shadow, tab8, "return val\n\n", NIL);
} else {
Printv(f_shadow, tab8, "return ", funcCall(Swig_name_member(NSPACE_TODO, class_name, symname), callParms), "\n\n", NIL);
}
- Printv(f_shadow, tab4, modern ? "" : "if _newclass:", symname, " = staticmethod(", symname, ")\n", NIL);
-
- if (!modern) {
- Printv(f_shadow, tab4, "__swig_getmethods__[\"", symname, "\"] = lambda x: ", symname, "\n", NIL);
- }
-
+ Printv(f_shadow, tab4, symname, " = staticmethod(", symname, ")\n", NIL);
} else {
- if (!modern) {
- Printv(f_shadow, tab4, "__swig_getmethods__[\"", symname, "\"] = lambda x: ", module, ".", Swig_name_member(NSPACE_TODO, class_name, symname), "\n",
- NIL);
- }
if (!classic) {
- Printv(f_shadow, tab4, modern ? "" : "if _newclass:", symname, " = staticmethod(", module, ".", Swig_name_member(NSPACE_TODO, class_name, symname),
+ if (!modern)
+ Printv(f_shadow, tab4, "if _newclass:\n", tab4, NIL);
+ Printv(f_shadow, tab4, symname, " = staticmethod(", module, ".", Swig_name_member(NSPACE_TODO, class_name, symname),
")\n", NIL);
}
+ if (classic || !modern) {
+ if (!classic)
+ Printv(f_shadow, tab4, "else:\n", tab4, NIL);
+ Printv(f_shadow, tab4, symname, " = ", module, ".", Swig_name_member(NSPACE_TODO, class_name, symname), "\n", NIL);
+ }
}
}
return SWIG_OK;
if (!have_constructor && handled_as_init) {
if (!builtin) {
if (Getattr(n, "feature:shadow")) {
- String *pycode = pythoncode(Getattr(n, "feature:shadow"), tab4);
+ String *pycode = indent_pythoncode(Getattr(n, "feature:shadow"), tab4, Getfile(n), Getline(n), "%feature(\"shadow\")");
String *pyaction = NewStringf("%s.%s", module, Swig_name_construct(NSPACE_TODO, symname));
Replaceall(pycode, "$action", pyaction);
Delete(pyaction);
Printv(pass_self, tab8, tab4, "_self = None\n", tab8, "else:\n", tab8, tab4, "_self = self\n", NIL);
}
- Printv(f_shadow, tab4, "def __init__(", parms, ")", returnTypeAnnotation(n), ": \n", NIL);
+ Printv(f_shadow, "\n", tab4, "def __init__(", parms, ")", returnTypeAnnotation(n), ":\n", NIL);
if (have_docstring(n))
Printv(f_shadow, tab8, docstring(n, AUTODOC_CTOR, tab8), "\n", NIL);
if (have_pythonprepend(n))
- Printv(f_shadow, pythoncode(pythonprepend(n), tab8), "\n", NIL);
+ Printv(f_shadow, indent_pythoncode(pythonprepend(n), tab8, Getfile(n), Getline(n), "%pythonprepend or %feature(\"pythonprepend\")"), "\n", NIL);
Printv(f_shadow, pass_self, NIL);
if (fastinit) {
- Printv(f_shadow, tab8, module, ".", class_name, "_swiginit(self,", funcCall(Swig_name_construct(NSPACE_TODO, symname), callParms), ")\n", NIL);
+ Printv(f_shadow, tab8, module, ".", class_name, "_swiginit(self, ", funcCall(Swig_name_construct(NSPACE_TODO, symname), callParms), ")\n", NIL);
} else {
Printv(f_shadow,
tab8, "this = ", funcCall(Swig_name_construct(NSPACE_TODO, symname), callParms), "\n",
- tab8, "try: self.this.append(this)\n", tab8, "except: self.this = this\n", NIL);
+ tab8, "try:\n", tab8, tab4, "self.this.append(this)\n", tab8, "except __builtin__.Exception:\n", tab8, tab4, "self.this = this\n", NIL);
}
if (have_pythonappend(n))
- Printv(f_shadow, pythoncode(pythonappend(n), tab8), "\n\n", NIL);
+ Printv(f_shadow, indent_pythoncode(pythonappend(n), tab8, Getfile(n), Getline(n), "%pythonappend or %feature(\"pythonappend\")"), "\n\n", NIL);
Delete(pass_self);
}
have_constructor = 1;
/* Hmmm. We seem to be creating a different constructor. We're just going to create a
function for it. */
if (Getattr(n, "feature:shadow")) {
- String *pycode = pythoncode(Getattr(n, "feature:shadow"), "");
+ String *pycode = indent_pythoncode(Getattr(n, "feature:shadow"), "", Getfile(n), Getline(n), "%feature(\"shadow\")");
String *pyaction = NewStringf("%s.%s", module, Swig_name_construct(NSPACE_TODO, symname));
Replaceall(pycode, "$action", pyaction);
Delete(pyaction);
if (have_docstring(n))
Printv(f_shadow_stubs, tab4, docstring(n, AUTODOC_CTOR, tab4), "\n", NIL);
if (have_pythonprepend(n))
- Printv(f_shadow_stubs, pythoncode(pythonprepend(n), tab4), "\n", NIL);
+ Printv(f_shadow_stubs, indent_pythoncode(pythonprepend(n), tab4, Getfile(n), Getline(n), "%pythonprepend or %feature(\"pythonprepend\")"), "\n", NIL);
String *subfunc = NULL;
/*
if (builtin)
Printv(f_shadow_stubs, tab4, "val.thisown = 1\n", NIL);
#endif
if (have_pythonappend(n))
- Printv(f_shadow_stubs, pythoncode(pythonappend(n), tab4), "\n", NIL);
+ Printv(f_shadow_stubs, indent_pythoncode(pythonappend(n), tab4, Getfile(n), Getline(n), "%pythonappend or %feature(\"pythonappend\")"), "\n", NIL);
Printv(f_shadow_stubs, tab4, "return val\n", NIL);
Delete(subfunc);
}
if (shadow) {
if (Getattr(n, "feature:shadow")) {
- String *pycode = pythoncode(Getattr(n, "feature:shadow"), tab4);
+ String *pycode = indent_pythoncode(Getattr(n, "feature:shadow"), tab4, Getfile(n), Getline(n), "%feature(\"shadow\")");
String *pyaction = NewStringf("%s.%s", module, Swig_name_destroy(NSPACE_TODO, symname));
Replaceall(pycode, "$action", pyaction);
Delete(pyaction);
Printv(f_shadow, tab4, "__swig_destroy__ = ", module, ".", Swig_name_destroy(NSPACE_TODO, symname), "\n", NIL);
if (!have_pythonprepend(n) && !have_pythonappend(n)) {
if (proxydel) {
- Printv(f_shadow, tab4, "__del__ = lambda self : None;\n", NIL);
+ Printv(f_shadow, tab4, "__del__ = lambda self: None\n", NIL);
}
return SWIG_OK;
}
if (have_docstring(n))
Printv(f_shadow, tab8, docstring(n, AUTODOC_DTOR, tab8), "\n", NIL);
if (have_pythonprepend(n))
- Printv(f_shadow, pythoncode(pythonprepend(n), tab8), "\n", NIL);
+ Printv(f_shadow, indent_pythoncode(pythonprepend(n), tab8, Getfile(n), Getline(n), "%pythonprepend or %feature(\"pythonprepend\")"), "\n", NIL);
#ifdef USE_THISOWN
Printv(f_shadow, tab8, "try:\n", NIL);
- Printv(f_shadow, tab8, tab4, "if self.thisown: ", module, ".", Swig_name_destroy(NSPACE_TODO, symname), "(self)\n", NIL);
- Printv(f_shadow, tab8, "except: pass\n", NIL);
+ Printv(f_shadow, tab8, tab4, "if self.thisown:", module, ".", Swig_name_destroy(NSPACE_TODO, symname), "(self)\n", NIL);
+ Printv(f_shadow, tab8, "except __builtin__.Exception: pass\n", NIL);
#else
#endif
if (have_pythonappend(n))
- Printv(f_shadow, pythoncode(pythonappend(n), tab8), "\n", NIL);
+ Printv(f_shadow, indent_pythoncode(pythonappend(n), tab8, Getfile(n), Getline(n), "%pythonappend or %feature(\"pythonappend\")"), "\n", NIL);
Printv(f_shadow, tab8, "pass\n", NIL);
Printv(f_shadow, "\n", NIL);
}
Printv(f_shadow, tab4, "__swig_getmethods__[\"", symname, "\"] = ", module, ".", getname, "\n", NIL);
}
if (!classic) {
- if (!assignable) {
- Printv(f_shadow, tab4, modern ? "" : "if _newclass:", symname, " = _swig_property(", module, ".", getname, ")\n", NIL);
- } else {
- Printv(f_shadow, tab4, modern ? "" : "if _newclass:", symname, " = _swig_property(", module, ".", getname, ", ", module, ".", setname, ")\n", NIL);
- }
+ if (!modern)
+ Printv(f_shadow, tab4, "if _newclass:\n", tab4, NIL);
+ Printv(f_shadow, tab4, symname, " = _swig_property(", module, ".", getname, NIL);
+ if (assignable)
+ Printv(f_shadow, ", ", module, ".", setname, NIL);
+ Printv(f_shadow, ")\n", NIL);
}
Delete(mname);
Delete(setname);
Printv(f_shadow, tab4, "__swig_getmethods__[\"", symname, "\"] = ", module, ".", getname, "\n", NIL);
}
if (!classic && !builtin) {
- if (!assignable) {
- Printv(f_shadow, tab4, modern ? "" : "if _newclass:", symname, " = _swig_property(", module, ".", getname, ")\n", NIL);
- } else {
- Printv(f_shadow, tab4, modern ? "" : "if _newclass:", symname, " = _swig_property(", module, ".", getname, ", ", module, ".", setname, ")\n", NIL);
- }
+ if (!modern)
+ Printv(f_shadow, tab4, "if _newclass:\n", tab4, NIL);
+ Printv(f_shadow, tab4, symname, " = _swig_property(", module, ".", getname, NIL);
+ if (assignable)
+ Printv(f_shadow, ", ", module, ".", setname, NIL);
+ Printv(f_shadow, ")\n", NIL);
}
String *getter = Getattr(n, "pybuiltin:getter");
String *setter = Getattr(n, "pybuiltin:setter");
if (!ImportMode && (Cmp(section, "python") == 0 || Cmp(section, "shadow") == 0)) {
if (shadow) {
- String *pycode = pythoncode(code, shadow_indent);
+ String *pycode = indent_pythoncode(code, shadow_indent, Getfile(n), Getline(n), "%pythoncode or %insert(\"python\") block");
Printv(f_shadow, pycode, NIL);
Delete(pycode);
}
} else if (!ImportMode && (Cmp(section, "pythonbegin") == 0)) {
- String *pycode = pythoncode(code, "");
+ String *pycode = indent_pythoncode(code, "", Getfile(n), Getline(n), "%pythonbegin or %insert(\"pythonbegin\") block");
Printv(f_shadow_begin, pycode, NIL);
Delete(pycode);
} else {
return NewString("swigpyrun.h");
}
+ /*----------------------------------------------------------------------
+ * kwargsSupport()
+ *--------------------------------------------------------------------*/
+
+ bool kwargsSupport() const {
+ return true;
+ }
};
/* ---------------------------------------------------------------
int idx;
bool ignored_method = GetFlag(n, "feature:ignore") ? true : false;
+ if (builtin) {
+ // Rename any wrapped parameters called 'self' as the generated code contains a variable with same name
+ Parm *p;
+ for (p = l; p; p = nextSibling(p)) {
+ String *arg = Getattr(p, "name");
+ if (arg && Cmp(arg, "self") == 0)
+ Delattr(p, "name");
+ }
+ }
+
if (Cmp(storage, "virtual") == 0) {
if (Cmp(value, "0") == 0) {
pure_virtual = true;
#include "swigmod.h"
static const double DEFAULT_NUMBER = .0000123456712312312323;
-static const int MAX_OVERLOAD_ARGS = 5;
static String* replaceInitialDash(const String *name)
{
}
-static const char *usage = (char *)"\
+static const char *usage = "\
R Options (available with -r)\n\
-copystruct - Emit R code to copy C structs (on by default)\n\
-cppcast - Enable C++ casting operators (default) \n\
void dispatchFunction(Node *n);
int functionWrapper(Node *n);
+ int constantWrapper(Node *n);
int variableWrapper(Node *n);
int classDeclaration(Node *n);
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGR\n");
- Printf(f_runtime, "\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGR\n#define SWIGR\n#endif\n\n");
Swig_banner_target_lang(s_init, "#");
tdname is the typedef of the enumeration, i.e. giving its name.
*************************************************************/
int R::enumDeclaration(Node *n) {
+ if (getCurrentClass() && (cplus_mode != PUBLIC))
+ return SWIG_NOWRAP;
+
String *name = Getattr(n, "name");
String *tdname = Getattr(n, "tdname");
}
if ((!t1) && (!nodes[i].error)) {
Swig_warning(WARN_TYPEMAP_TYPECHECK, Getfile(nodes[i].n), Getline(nodes[i].n),
- "Overloaded method %s not supported (no type checking rule for '%s').\n",
+ "Overloaded method %s not supported (incomplete type checking rule - no precedence level in typecheck typemap for '%s').\n",
Swig_name_decl(nodes[i].n), SwigType_str(Getattr(p1, "type"), 0));
nodes[i].error = 1;
} else if ((!t2) && (!nodes[j].error)) {
Swig_warning(WARN_TYPEMAP_TYPECHECK, Getfile(nodes[j].n), Getline(nodes[j].n),
- "xx Overloaded method %s not supported (no type checking rule for '%s').\n",
+ "Overloaded method %s not supported (incomplete type checking rule - no precedence level in typecheck typemap for '%s').\n",
Swig_name_decl(nodes[j].n), SwigType_str(Getattr(p2, "type"), 0));
nodes[j].error = 1;
}
Swig_warning(WARN_LANG_OVERLOAD_CONST, Getfile(nodes[i].n), Getline(nodes[i].n),
"using non-const method %s instead.\n", Swig_name_decl(nodes[i].n));
} else {
- if (!Getattr(nodes[j].n, "overload:ignore"))
+ if (!Getattr(nodes[j].n, "overload:ignore")) {
Swig_warning(WARN_LANG_OVERLOAD_IGNORED, Getfile(nodes[j].n), Getline(nodes[j].n),
"Overloaded method %s ignored,\n", Swig_name_decl(nodes[j].n));
Swig_warning(WARN_LANG_OVERLOAD_IGNORED, Getfile(nodes[i].n), Getline(nodes[i].n),
"using %s instead.\n", Swig_name_decl(nodes[i].n));
+ }
}
}
nodes[j].error = 1;
Swig_warning(WARN_LANG_OVERLOAD_CONST, Getfile(nodes[i].n), Getline(nodes[i].n),
"using non-const method %s instead.\n", Swig_name_decl(nodes[i].n));
} else {
- if (!Getattr(nodes[j].n, "overload:ignore"))
+ if (!Getattr(nodes[j].n, "overload:ignore")) {
Swig_warning(WARN_LANG_OVERLOAD_IGNORED, Getfile(nodes[j].n), Getline(nodes[j].n),
"Overloaded method %s ignored,\n", Swig_name_decl(nodes[j].n));
Swig_warning(WARN_LANG_OVERLOAD_IGNORED, Getfile(nodes[i].n), Getline(nodes[i].n),
"using %s instead.\n", Swig_name_decl(nodes[i].n));
+ }
}
}
nodes[j].error = 1;
Swig_warning(WARN_LANG_OVERLOAD_SHADOW, Getfile(nodes[i].n), Getline(nodes[i].n),
"as it is shadowed by %s.\n", Swig_name_decl(nodes[i].n));
} else {
- if (!Getattr(nodes[j].n, "overload:ignore"))
+ if (!Getattr(nodes[j].n, "overload:ignore")) {
Swig_warning(WARN_LANG_OVERLOAD_IGNORED, Getfile(nodes[j].n), Getline(nodes[j].n),
"Overloaded method %s ignored,\n", Swig_name_decl(nodes[j].n));
Swig_warning(WARN_LANG_OVERLOAD_IGNORED, Getfile(nodes[i].n), Getline(nodes[i].n),
"using %s instead.\n", Swig_name_decl(nodes[i].n));
+ }
}
nodes[j].error = 1;
}
/* If we are dealing with a method in an C++ class, then
add the name of the R function and its definition.
XXX need to figure out how to store the Wrapper if possible in the hash/list.
- Would like to be able to do this so that we can potentialy insert
+ Would like to be able to do this so that we can potentially insert
*/
if(processing_member_access_function || processing_class_member_function) {
addAccessor(member_name, sfun, iname);
return SWIG_OK;
}
+/* ----------------------------------------------------------------------
+ * R::constantWrapper()
+ * ---------------------------------------------------------------------- */
+
+int R::constantWrapper(Node *n) {
+ (void) n;
+ // TODO
+ return SWIG_OK;
+}
+
/*****************************************************
Add the specified routine name to the collection of
generated routines that are called from R functions.
/* If we have a typedef union { ... } U, then we never get to see the typedef
via a regular call to typedefHandler. Instead, */
- if(Getattr(n, "unnamed") && Strcmp(Getattr(n, "storage"), "typedef") == 0
+ if(Getattr(n, "unnamed") && Getattr(n, "storage") && Strcmp(Getattr(n, "storage"), "typedef") == 0
&& Getattr(n, "tdname") && Strcmp(Getattr(n, "tdname"), name) == 0) {
if (debugMode)
Printf(stdout, "Typedef in the class declaration for %s\n", name);
#include "swigmod.h"
#include "cparse.h"
-static int treduce = SWIG_cparse_template_reduce(0);
-
-#define SWIG_PROTECTED_TARGET_METHODS 1
-
#include <ctype.h>
#include <string.h>
#include <limits.h> /* for INT_MAX */
+#define SWIG_PROTECTED_TARGET_METHODS 1
+
class RClass {
private:
String *temp;
AUTODOC_NONE
};
-static const char *usage = (char *) "\
+static const char *usage = "\
Ruby Options (available with -ruby)\n\
-autorename - Enable renaming of classes and methods to follow Ruby coding standards\n\
-cppcast - Enable C++ casting operators (default)\n\
/* ------------------------------------------------------------
* docstring()
- * Get the docstring text, stripping off {} if neccessary,
+ * Get the docstring text, stripping off {} if necessary,
* and enclose in triple double quotes. If autodoc is also
* set then it will build a combined docstring.
* ------------------------------------------------------------ */
else
return v;
}
- if (Strcmp(v, "NULL") == 0)
+ if (Strcmp(v, "NULL") == 0 || Strcmp(v, "nullptr") == 0)
return SwigType_ispointer(t) ? NewString("nil") : NewString("0");
if (Strcmp(v, "true") == 0 || Strcmp(v, "TRUE") == 0)
return NewString("True");
virtual int top(Node *n) {
+ String *mod_docstring = NULL;
+
/**
* See if any Ruby module options have been specified as options
* to the %module directive.
multipleInheritance = true;
director_multiple_inheritance = 1;
}
+ mod_docstring = Getattr(options, "docstring");
}
}
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGRUBY\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGRUBY\n#define SWIGRUBY\n#endif\n\n");
if (directorsEnabled()) {
Printf(f_runtime, "#define SWIG_DIRECTORS\n");
/* typedef void *VALUE */
SwigType *value = NewSwigType(T_VOID);
SwigType_add_pointer(value);
- SwigType_typedef(value, (char *) "VALUE");
+ SwigType_typedef(value, "VALUE");
Delete(value);
/* Set module name */
Printf(f_header, "#define SWIG_init Init_%s\n", feature);
Printf(f_header, "#define SWIG_name \"%s\"\n\n", module);
+
+ if (mod_docstring) {
+ if (Len(mod_docstring)) {
+ Printf(f_header, "/*\n Document-module: %s\n\n%s\n*/\n", module, mod_docstring);
+ }
+ Delete(mod_docstring);
+ mod_docstring = NULL;
+ }
+
Printf(f_header, "static VALUE %s;\n", modvar);
/* Start generating the initialization function */
if (directorsEnabled()) {
// Insert director runtime into the f_runtime file (make it occur before %header section)
+ Swig_insert_file("director_common.swg", f_runtime);
Swig_insert_file("director.swg", f_runtime);
}
/* Finish argument marshalling */
Printf(kwargs, " NULL }");
if (allow_kwargs) {
- Printv(f->locals, tab4, "const char *kwnames[] = ", kwargs, ";\n", NIL);
+// kwarg support not implemented
+// Printv(f->locals, tab4, "const char *kwnames[] = ", kwargs, ";\n", NIL);
}
/* Trailing varargs */
/* Now write the wrapper function itself */
if (current == CONSTRUCTOR_ALLOCATE) {
+ Printv(f->def, "SWIGINTERN VALUE\n", NIL);
Printf(f->def, "#ifdef HAVE_RB_DEFINE_ALLOC_FUNC\n");
- Printv(f->def, "SWIGINTERN VALUE\n", wname, "(VALUE self) {", NIL);
+ Printv(f->def, wname, "(VALUE self)\n", NIL);
Printf(f->def, "#else\n");
- Printv(f->def, "SWIGINTERN VALUE\n", wname, "(int argc, VALUE *argv, VALUE self) {", NIL);
+ Printv(f->def, wname, "(int argc, VALUE *argv, VALUE self)\n", NIL);
Printf(f->def, "#endif\n");
+ Printv(f->def, "{\n", NIL);
} else if (current == CONSTRUCTOR_INITIALIZE) {
Printv(f->def, "SWIGINTERN VALUE\n", wname, "(int argc, VALUE *argv, VALUE self) {", NIL);
if (!varargs) {
/* if the object is a director, and the method call originated from its
* underlying Ruby object, resolve the call by going up the c++
- * inheritance chain. otherwise try to resolve the method in python.
- * without this check an infinite loop is set up between the director and
+ * inheritance chain. otherwise try to resolve the method in Ruby.
+ * without this check an infinite loop is set up between the director and
* shadow class method calls.
*/
Wrapper_add_local(f, "classname", classname);
}
if (action) {
- Printf(action, "\nDATA_PTR(self) = %s;", Swig_cresult_name());
+ SwigType *smart = Swig_cparse_smartptr(pn);
+ String *result_name = NewStringf("%s%s", smart ? "smart" : "", Swig_cresult_name());
+ if (smart) {
+ String *result_var = NewStringf("%s *%s = 0", SwigType_namestr(smart), result_name);
+ Wrapper_add_local(f, result_name, result_var);
+ Printf(action, "\n%s = new %s(%s);", result_name, SwigType_namestr(smart), Swig_cresult_name());
+ }
+ Printf(action, "\nDATA_PTR(self) = %s;", result_name);
if (GetFlag(pn, "feature:trackobjects")) {
- Printf(action, "\nSWIG_RubyAddTracking(%s, self);", Swig_cresult_name());
+ Printf(action, "\nSWIG_RubyAddTracking(%s, self);", result_name);
}
+ Delete(result_name);
+ Delete(smart);
}
}
/* Extra code needed for new and initialize methods */
if (current == CONSTRUCTOR_ALLOCATE) {
+ Node *pn = Swig_methodclass(n);
+ SwigType *smart = Swig_cparse_smartptr(pn);
+ if (smart)
+ SwigType_add_pointer(smart);
+ String *classtype = smart ? smart : t;
need_result = 1;
- Printf(f->code, "VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE%s);\n", Char(SwigType_manglestr(t)));
+ Printf(f->code, "VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE%s);\n", Char(SwigType_manglestr(classtype)));
Printf(f->code, "#ifndef HAVE_RB_DEFINE_ALLOC_FUNC\n");
Printf(f->code, "rb_obj_call_init(vresult, argc, argv);\n");
Printf(f->code, "#endif\n");
+ Delete(smart);
} else if (current == CONSTRUCTOR_INITIALIZE) {
need_result = 1;
}
// Generate prototype list, go to first node
Node *sibl = n;
- String* type = SwigType_str(Getattr(sibl,"type"),NULL);
-
while (Getattr(sibl, "sym:previousSibling"))
sibl = Getattr(sibl, "sym:previousSibling"); // go all the way up
// Constructors will be treated specially
- const bool isCtor = Cmp(Getattr(sibl,"feature:new"), "1") == 0;
+ const bool isCtor = (!Cmp(Getattr(sibl, "nodeType"), "constructor"));
const bool isMethod = ( Cmp(Getattr(sibl, "ismember"), "1") == 0 &&
(!isCtor) );
String *protoTypes = NewString("");
do {
Append( protoTypes, "\n\" ");
- if ( !isCtor ) Printv( protoTypes, type, " ", NIL );
+ if (!isCtor) {
+ SwigType *type = SwigType_str(Getattr(sibl, "type"), NULL);
+ Printv(protoTypes, type, " ", NIL);
+ Delete(type);
+ }
Printv(protoTypes, methodName, NIL );
Parm* p = Getattr(sibl, "wrap:parms");
if (p && (current == MEMBER_FUNC || current == MEMBER_VAR ||
Append(f->code, "\nreturn Qnil;\n");
Delete(methodName);
- Delete(type);
Delete(protoTypes);
Printv(f->code, "}\n", NIL);
SwigType *btype = NewString(basename);
SwigType_add_pointer(btype);
SwigType_remember(btype);
+ SwigType *smart = Swig_cparse_smartptr(base.item);
+ if (smart) {
+ SwigType_add_pointer(smart);
+ SwigType_remember(smart);
+ }
+ String *bmangle = SwigType_manglestr(smart ? smart : btype);
if (multipleInheritance) {
- String *bmangle = SwigType_manglestr(btype);
Insert(bmangle, 0, "((swig_class *) SWIGTYPE");
Append(bmangle, "->clientdata)->mImpl");
Printv(klass->init, "rb_include_module(", klass->mImpl, ", ", bmangle, ");\n", NIL);
- Delete(bmangle);
} else {
- String *bmangle = SwigType_manglestr(btype);
Insert(bmangle, 0, "((swig_class *) SWIGTYPE");
Append(bmangle, "->clientdata)->klass");
Replaceall(klass->init, "$super", bmangle);
- Delete(bmangle);
}
+ Delete(bmangle);
+ Delete(smart);
Delete(btype);
}
base = Next(base);
String *proxyclassname = SwigType_str(Getattr(n, "classtypeobj"), 0);
String *baseclassname = SwigType_str(Getattr(base.item, "name"), 0);
Swig_warning(WARN_RUBY_MULTIPLE_INHERITANCE, Getfile(n), Getline(n),
- "Warning for %s proxy: Base %s ignored. Multiple inheritance is not supported in Ruby.\n", proxyclassname, baseclassname);
+ "Warning for %s, base %s ignored. Multiple inheritance is not supported in Ruby.\n", proxyclassname, baseclassname);
base = Next(base);
}
}
SwigType *tt = NewString(name);
SwigType_add_pointer(tt);
SwigType_remember(tt);
- String *tm = SwigType_manglestr(tt);
+ SwigType *smart = Swig_cparse_smartptr(n);
+ if (smart) {
+ SwigType_add_pointer(smart);
+ SwigType_remember(smart);
+ }
+ String *tm = SwigType_manglestr(smart ? smart : tt);
Printf(klass->init, "SWIG_TypeClientData(SWIGTYPE%s, (void *) &SwigClass%s);\n", tm, valid_name);
Delete(tm);
+ Delete(smart);
Delete(tt);
Delete(valid_name);
String *pname0 = Swig_cparm_name(0, 0);
Printv(freefunc, "free_", klass->mname, NIL);
- Printv(freebody, "SWIGINTERN void\n", freefunc, "(", klass->type, " *", pname0, ") {\n", tab4, NIL);
+ Printv(freebody, "SWIGINTERN void\n", freefunc, "(void *self) {\n", NIL);
+ Printv(freebody, tab4, klass->type, " *", pname0, " = (", klass->type, " *)self;\n", NIL);
+ Printv(freebody, tab4, NIL);
/* Check to see if object tracking is activated for the class
that owns this destructor. */
Printf(rescue->code, "if (%s == 0) ", depthCountName);
Printv(rescue->code, Str(tm), "\n", NIL);
Printv(rescue->code, "rb_exc_raise(error);\n", NIL);
+ Printv(rescue->code, "return Qnil;\n", NIL);
Printv(rescue->code, "}", NIL);
}
String *defaultExternalRuntimeFilename() {
return NewString("swigrubyrun.h");
}
+
+ /*----------------------------------------------------------------------
+ * kwargsSupport()
+ *--------------------------------------------------------------------*/
+
+ bool kwargsSupport() const {
+ // kwargs support isn't actually implemented, but changing to return false may break something now as it turns on compactdefaultargs
+ return true;
+ }
}; /* class RUBY */
/* -----------------------------------------------------------------------------
--- /dev/null
+/* ----------------------------------------------------------------------------
+ * This file is part of SWIG, which is licensed as a whole under version 3
+ * (or any later version) of the GNU General Public License. Some additional
+ * terms also apply to certain portions of SWIG. The full details of the SWIG
+ * license and copyrights can be found in the LICENSE and COPYRIGHT files
+ * included with the SWIG source code as distributed by the SWIG developers
+ * and at http://www.swig.org/legal.html.
+ *
+ * scilab.cxx
+ *
+ * Scilab language module for SWIG.
+ * --------------------------------------------------------------------------*/
+
+#include "swigmod.h"
+
+static const int SCILAB_IDENTIFIER_NAME_CHAR_MAX = 24;
+static const int SCILAB_VARIABLE_NAME_CHAR_MAX = SCILAB_IDENTIFIER_NAME_CHAR_MAX - 4;
+
+static const char *usage = (char *) " \
+Scilab options (available with -scilab)\n \
+ -builder - Generate a Scilab builder script\n \
+ -buildercflags <cflags> - Add <cflags> to the builder compiler flags\n \
+ -builderflagscript <file> - Set the Scilab script <file> to use by builder to configure the build flags\n \
+ -builderldflags <ldflags> - Add <ldflags> to the builder linker flags\n \
+ -buildersources <files> - Add the (comma separated) files <files> to the builder sources\n \
+ -builderverbositylevel <level> - Set the builder verbosity level to <level> (default 0: off, 2: high)\n \
+ -gatewayxml <gateway_id> - Generate gateway xml with the given <gateway_id>\n \
+\n";
+
+
+class SCILAB:public Language {
+protected:
+ /* General objects used for holding the strings */
+ File *beginSection;
+ File *runtimeSection;
+ File *headerSection;
+ File *wrappersSection;
+ File *initSection;
+
+ String *variablesCode;
+
+ bool generateBuilder;
+ File *builderFile;
+ String *builderCode;
+ int builderFunctionCount;
+
+ List *sourceFileList;
+ List *cflags;
+ List *ldflags;
+
+ String *verboseBuildLevel;
+ String *buildFlagsScript;
+
+ String *gatewayHeader;
+ String *gatewayHeaderV5;
+ String *gatewayHeaderV6;
+
+ bool createGatewayXML;
+ File *gatewayXMLFile;
+ String *gatewayXML;
+ String *gatewayID;
+ int primitiveID;
+
+ bool createLoader;
+ File *loaderFile;
+ String *loaderScript;
+public:
+
+ /* ------------------------------------------------------------------------
+ * main()
+ * ----------------------------------------------------------------------*/
+
+ virtual void main(int argc, char *argv[]) {
+
+ generateBuilder = false;
+ sourceFileList = NewList();
+ cflags = NewList();
+ ldflags = NewList();
+ verboseBuildLevel = NULL;
+ buildFlagsScript = NULL;
+
+ gatewayHeader = NULL;
+ gatewayHeaderV5 = NULL;
+ gatewayHeaderV6 = NULL;
+
+ createGatewayXML = false;
+ gatewayXML = NULL;
+ gatewayXMLFile = NULL;
+ gatewayID = NULL;
+
+ createLoader = true;
+ loaderFile = NULL;
+ loaderScript = NULL;
+
+ /* Manage command line arguments */
+ for (int argIndex = 1; argIndex < argc; argIndex++) {
+ if (argv[argIndex] != NULL) {
+ if (strcmp(argv[argIndex], "-help") == 0) {
+ Printf(stdout, "%s\n", usage);
+ } else if (strcmp(argv[argIndex], "-builder") == 0) {
+ Swig_mark_arg(argIndex);
+ generateBuilder = true;
+ createLoader = false;
+ } else if (strcmp(argv[argIndex], "-buildersources") == 0) {
+ if (argv[argIndex + 1] != NULL) {
+ Swig_mark_arg(argIndex);
+ char *sourceFile = strtok(argv[argIndex + 1], ",");
+ while (sourceFile != NULL) {
+ Insert(sourceFileList, Len(sourceFileList), sourceFile);
+ sourceFile = strtok(NULL, ",");
+ }
+ Swig_mark_arg(argIndex + 1);
+ }
+ } else if (strcmp(argv[argIndex], "-buildercflags") == 0) {
+ Swig_mark_arg(argIndex);
+ if (argv[argIndex + 1] != NULL) {
+ Insert(cflags, Len(cflags), argv[argIndex + 1]);
+ Swig_mark_arg(argIndex + 1);
+ }
+ } else if (strcmp(argv[argIndex], "-builderldflags") == 0) {
+ Swig_mark_arg(argIndex);
+ if (argv[argIndex + 1] != NULL) {
+ Insert(ldflags, Len(ldflags), argv[argIndex + 1]);
+ Swig_mark_arg(argIndex + 1);
+ }
+ } else if (strcmp(argv[argIndex], "-builderverbositylevel") == 0) {
+ Swig_mark_arg(argIndex);
+ verboseBuildLevel = NewString(argv[argIndex + 1]);
+ Swig_mark_arg(argIndex + 1);
+ } else if (strcmp(argv[argIndex], "-builderflagscript") == 0) {
+ Swig_mark_arg(argIndex);
+ buildFlagsScript = NewString(argv[argIndex + 1]);
+ Swig_mark_arg(argIndex + 1);
+ } else if (strcmp(argv[argIndex], "-gatewayxml") == 0) {
+ Swig_mark_arg(argIndex);
+ createGatewayXML = true;
+ gatewayID = NewString(argv[argIndex + 1]);
+ Swig_mark_arg(argIndex + 1);
+ }
+ }
+ }
+
+ if (verboseBuildLevel == NULL) {
+ verboseBuildLevel = NewString("0");
+ }
+
+ /* Set language-specific subdirectory in SWIG library */
+ SWIG_library_directory("scilab");
+
+ /* Add a symbol to the parser for conditional compilation */
+ Preprocessor_define("SWIGSCILAB 1", 0);
+
+ /* Set scilab configuration file */
+ SWIG_config_file("scilab.swg");
+
+ /* Set typemap for scilab */
+ SWIG_typemap_lang("scilab");
+
+ allow_overloading();
+ }
+
+ /* ------------------------------------------------------------------------
+ * top()
+ * ----------------------------------------------------------------------*/
+
+ virtual int top(Node *node) {
+
+ /* Get the module name */
+ String *gatewayName = Getattr(node, "name");
+
+ // Set library name
+ String *gatewayLibraryName = NewStringf("lib%s", gatewayName);
+
+ /* Get the output file name */
+ String *outputFilename = Getattr(node, "outfile");
+
+ /* Initialize I/O */
+ beginSection = NewFile(outputFilename, "w", SWIG_output_files());
+ if (!beginSection) {
+ FileErrorDisplay(outputFilename);
+ SWIG_exit(EXIT_FAILURE);
+ }
+ runtimeSection = NewString("");
+ initSection = NewString("");
+ headerSection = NewString("");
+ wrappersSection = NewString("");
+
+ /* Register file targets with the SWIG file handler */
+ Swig_register_filebyname("begin", beginSection);
+ Swig_register_filebyname("header", headerSection);
+ Swig_register_filebyname("wrapper", wrappersSection);
+ Swig_register_filebyname("runtime", runtimeSection);
+ Swig_register_filebyname("init", initSection);
+
+ /* Output module initialization code */
+ Swig_banner(beginSection);
+
+ Printf(runtimeSection, "\n\n#ifndef SWIGSCILAB\n#define SWIGSCILAB\n#endif\n\n");
+
+ // Gateway header source merged with wrapper source in nobuilder mode
+ if (!generateBuilder)
+ startGatewayHeader(gatewayLibraryName);
+
+ // Create builder file if required
+ if (generateBuilder) {
+ createBuilderFile(outputFilename);
+ }
+
+ // Create gateway XML if required
+ if (createGatewayXML) {
+ createGatewayXMLFile(gatewayName);
+ }
+
+ // Create loader script if required
+ if (createLoader) {
+ createLoaderFile(gatewayLibraryName);
+ }
+
+ // Module initialization function
+ String *gatewayInitFunctionName = NewStringf("%s_Init", gatewayName);
+
+ /* Add initialization function to builder table */
+ addFunctionToScilab(gatewayInitFunctionName, gatewayInitFunctionName);
+
+ // Add helper functions to builder table
+ addHelperFunctions();
+
+ // Open Scilab wrapper variables creation function
+ variablesCode = NewString("");
+ Printf(variablesCode, "int SWIG_CreateScilabVariables(void *_pvApiCtx) {");
+
+ /* Emit code for children */
+ if (CPlusPlus) {
+ Printf(wrappersSection, "extern \"C\" {\n");
+ }
+
+ Language::top(node);
+
+ if (CPlusPlus) {
+ Printf(wrappersSection, "}\n");
+ }
+ // Close Scilab wrapper variables creation function
+ Printf(variablesCode, " return SWIG_OK;\n}\n");
+
+ // Add Builder footer code and save
+ if (generateBuilder) {
+ saveBuilderFile(gatewayName);
+ }
+
+ /* Close the init function and rename with module name */
+ Printf(initSection, "return 0;\n}\n");
+ Replaceall(initSection, "<module>", gatewayName);
+
+ /* Write all to the wrapper file */
+ SwigType_emit_type_table(runtimeSection, wrappersSection); // Declare pointer types, ... (Ex: SWIGTYPE_p_p_double)
+
+ // Gateway header source merged with wrapper source in nobuilder mode
+ if (!generateBuilder) {
+ terminateGatewayHeader(gatewayLibraryName);
+ Printv(initSection, gatewayHeader, NIL);
+ }
+
+ Dump(runtimeSection, beginSection);
+ Dump(headerSection, beginSection);
+ Dump(wrappersSection, beginSection);
+ Dump(variablesCode, beginSection);
+ Wrapper_pretty_print(initSection, beginSection);
+
+ if (createGatewayXML) {
+ saveGatewayXMLFile();
+ }
+
+ if (createLoader) {
+ saveLoaderFile(gatewayLibraryName);
+ }
+
+ /* Cleanup files */
+ Delete(runtimeSection);
+ Delete(headerSection);
+ Delete(wrappersSection);
+ Delete(initSection);
+ Delete(beginSection);
+
+ Delete(sourceFileList);
+ Delete(cflags);
+ Delete(ldflags);
+
+ return SWIG_OK;
+ }
+
+ /* ------------------------------------------------------------------------
+ * emitBanner()
+ * ----------------------------------------------------------------------*/
+
+ void emitBanner(File *f) {
+ Printf(f, "// ----------------------------------------------------------------------------\n");
+ Swig_banner_target_lang(f, "// ");
+ Printf(f, "// ----------------------------------------------------------------------------- */\n\n");
+ }
+
+ /* ------------------------------------------------------------------------
+ * functionWrapper()
+ * ----------------------------------------------------------------------*/
+
+ virtual int functionWrapper(Node *node) {
+
+ /* Get some useful attributes of this function */
+ String *functionName = Getattr(node, "sym:name");
+ SwigType *functionReturnType = Getattr(node, "type");
+ ParmList *functionParamsList = Getattr(node, "parms");
+
+ int paramIndex = 0; // Used for loops over ParmsList
+ Parm *param = NULL; // Used for loops over ParamsList
+
+ /* Create the wrapper object */
+ Wrapper *wrapper = NewWrapper();
+
+ /* Create the function wrapper name */
+ String *wrapperName = Swig_name_wrapper(functionName);
+
+ /* Deal with overloading */
+ String *overloadedName = Copy(wrapperName);
+ /* Determine whether the function is overloaded or not */
+ bool isOverloaded = ! !Getattr(node, "sym:overloaded");
+ /* Determine whether the function is the last overloaded */
+ bool isLastOverloaded = isOverloaded && !Getattr(node, "sym:nextSibling");
+
+ if (!isOverloaded && !addSymbol(functionName, node)) {
+ return SWIG_ERROR;
+ }
+
+ if (isOverloaded) {
+ Append(overloadedName, Getattr(node, "sym:overname"));
+ }
+
+ /* Write the wrapper function definition (standard Scilab gateway function prototype) */
+ Printv(wrapper->def, "int ", overloadedName, "(SWIG_GatewayParameters) {", NIL);
+
+ /* Emit all of the local variables for holding arguments */
+ // E.g.: double arg1;
+ emit_parameter_variables(functionParamsList, wrapper);
+
+ /* Attach typemaps to the parameter list */
+ // Add local variables used in typemaps (iRows, iCols, ...)
+ emit_attach_parmmaps(functionParamsList, wrapper);
+ Setattr(node, "wrap:parms", functionParamsList);
+
+ /* Check input/output arguments count */
+ int maxInputArguments = emit_num_arguments(functionParamsList);
+ int minInputArguments = emit_num_required(functionParamsList);
+ int minOutputArguments = 0;
+ int maxOutputArguments = 0;
+
+ if (!emit_isvarargs(functionParamsList)) {
+ Printf(wrapper->code, "SWIG_CheckInputArgument(pvApiCtx, $mininputarguments, $maxinputarguments);\n");
+ }
+ else {
+ Printf(wrapper->code, "SWIG_CheckInputArgumentAtLeast(pvApiCtx, $mininputarguments-1);\n");
+ }
+ Printf(wrapper->code, "SWIG_CheckOutputArgument(pvApiCtx, $minoutputarguments, $maxoutputarguments);\n");
+
+ /* Set context */
+ Printf(wrapper->code, "SWIG_Scilab_SetFuncName(fname);\n");
+ Printf(wrapper->code, "SWIG_Scilab_SetApiContext(pvApiCtx);\n");
+
+ /* Write typemaps(in) */
+
+ for (paramIndex = 0, param = functionParamsList; paramIndex < maxInputArguments; ++paramIndex) {
+ // Ignore parameter if the typemap specifies numinputs=0
+ while (checkAttribute(param, "tmap:in:numinputs", "0")) {
+ param = Getattr(param, "tmap:in:next");
+ }
+
+ SwigType *paramType = Getattr(param, "type");
+ String *paramTypemap = Getattr(param, "tmap:in");
+
+ if (paramTypemap) {
+ // Replace $input by the position on Scilab stack
+ String *source = NewString("");
+ Printf(source, "%d", paramIndex + 1);
+ Setattr(param, "emit:input", source);
+ Replaceall(paramTypemap, "$input", Getattr(param, "emit:input"));
+
+ if (Getattr(param, "wrap:disown") || (Getattr(param, "tmap:in:disown"))) {
+ Replaceall(paramTypemap, "$disown", "SWIG_POINTER_DISOWN");
+ } else {
+ Replaceall(paramTypemap, "$disown", "0");
+ }
+
+ if (paramIndex >= minInputArguments) { /* Optional input argument management */
+ Printf(wrapper->code, "if (SWIG_NbInputArgument(pvApiCtx) > %d) {\n%s\n}\n", paramIndex, paramTypemap);
+ } else {
+ Printf(wrapper->code, "%s\n", paramTypemap);
+ }
+ param = Getattr(param, "tmap:in:next");
+ } else {
+ Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument.\n", SwigType_str(paramType, 0));
+ break;
+ }
+ }
+
+ /* TODO write constraints */
+
+ Setattr(node, "wrap:name", overloadedName);
+
+ /* Emit the function call */
+ Swig_director_emit_dynamic_cast(node, wrapper);
+ String *functionActionCode = emit_action(node);
+
+ /* Insert the return variable */
+ emit_return_variable(node, functionReturnType, wrapper);
+
+ /* Return the function value if necessary */
+ String *functionReturnTypemap = Swig_typemap_lookup_out("out", node, "result", wrapper, functionActionCode);
+ if (functionReturnTypemap) {
+ // Result is actually the position of output value on stack
+ if (Len(functionReturnTypemap) > 0) {
+ Printf(wrapper->code, "SWIG_Scilab_SetOutputPosition(%d);\n", 1);
+ }
+ Replaceall(functionReturnTypemap, "$result", "1");
+
+ if (GetFlag(node, "feature:new")) {
+ Replaceall(functionReturnTypemap, "$owner", "1");
+ } else {
+ Replaceall(functionReturnTypemap, "$owner", "0");
+ }
+
+ Printf(wrapper->code, "%s\n", functionReturnTypemap);
+
+ /* If the typemap is not empty, the function return one more argument than the typemaps gives */
+ if (Len(functionReturnTypemap) > 0) {
+ minOutputArguments++;
+ maxOutputArguments++;
+ }
+ Delete(functionReturnTypemap);
+
+ } else {
+ Swig_warning(WARN_TYPEMAP_OUT_UNDEF, input_file, line_number, "Unable to use return type %s in function %s.\n", SwigType_str(functionReturnType, 0),
+ functionName);
+ }
+
+ /* Write typemaps(out) */
+ for (param = functionParamsList; param;) {
+ String *paramTypemap = Getattr(param, "tmap:argout");
+ if (paramTypemap) {
+ minOutputArguments++;
+ maxOutputArguments++;
+ Printf(wrapper->code, "SWIG_Scilab_SetOutputPosition(%d);\n", minOutputArguments);
+ String *result = NewString("");
+ Printf(result, "%d", minOutputArguments);
+ Replaceall(paramTypemap, "$result", result);
+ Printf(wrapper->code, "%s\n", paramTypemap);
+ Delete(paramTypemap);
+ param = Getattr(param, "tmap:argout:next");
+ } else {
+ param = nextSibling(param);
+ }
+ }
+ /* Add cleanup code */
+ for (param = functionParamsList; param;) {
+ String *tm;
+ if ((tm = Getattr(param, "tmap:freearg"))) {
+ if (tm && (Len(tm) != 0)) {
+ Replaceall(tm, "$source", Getattr(param, "lname"));
+ Printf(wrapper->code, "%s\n", tm);
+ }
+ param = Getattr(param, "tmap:freearg:next");
+ } else {
+ param = nextSibling(param);
+ }
+ }
+
+
+ /* Close the function(ok) */
+ Printv(wrapper->code, "return SWIG_OK;\n", NIL);
+ Printv(wrapper->code, "}\n", NIL);
+
+ /* Add the failure cleanup code */
+ /* TODO */
+
+ /* Final substititions if applicable */
+ Replaceall(wrapper->code, "$symname", functionName);
+
+ /* Set CheckInputArgument and CheckOutputArgument input arguments */
+ /* In Scilab there is always one output even if not defined */
+ if (minOutputArguments == 0) {
+ maxOutputArguments = 1;
+ }
+ String *argnumber = NewString("");
+ Printf(argnumber, "%d", minInputArguments);
+ Replaceall(wrapper->code, "$mininputarguments", argnumber);
+
+ argnumber = NewString("");
+ Printf(argnumber, "%d", maxInputArguments);
+ Replaceall(wrapper->code, "$maxinputarguments", argnumber);
+
+ argnumber = NewString("");
+ Printf(argnumber, "%d", minOutputArguments);
+ Replaceall(wrapper->code, "$minoutputarguments", argnumber);
+
+ argnumber = NewString("");
+ Printf(argnumber, "%d", maxOutputArguments);
+ Replaceall(wrapper->code, "$maxoutputarguments", argnumber);
+
+ /* Dump the function out */
+ Wrapper_print(wrapper, wrappersSection);
+
+ String *scilabFunctionName = checkIdentifierName(functionName, SCILAB_IDENTIFIER_NAME_CHAR_MAX);
+
+ /* Update builder.sce contents */
+ if (isLastOverloaded) {
+ addFunctionToScilab(scilabFunctionName, wrapperName);
+ dispatchFunction(node);
+ }
+
+ if (!isOverloaded) {
+ addFunctionToScilab(scilabFunctionName, wrapperName);
+ }
+
+ /* tidy up */
+ Delete(overloadedName);
+ Delete(wrapperName);
+ DelWrapper(wrapper);
+
+ return SWIG_OK;
+ }
+
+ /* -----------------------------------------------------------------------
+ * dispatchFunction()
+ * ----------------------------------------------------------------------- */
+
+ void dispatchFunction(Node *node) {
+ Wrapper *wrapper = NewWrapper();
+
+ String *functionName = Getattr(node, "sym:name");
+ String *wrapperName = Swig_name_wrapper(functionName);
+ int maxargs = 0;
+
+ /* Generate the dispatch function */
+ String *dispatch = Swig_overload_dispatch(node, "return %s(SWIG_GatewayArguments);", &maxargs);
+ String *tmp = NewString("");
+
+ Printv(wrapper->def, "int ", wrapperName, "(SWIG_GatewayParameters) {\n", NIL);
+
+ /* Get the number of the parameters */
+ Wrapper_add_local(wrapper, "argc", "int argc = SWIG_NbInputArgument(pvApiCtx)");
+ Printf(tmp, "int argv[%d] = {", maxargs);
+ for (int j = 0; j < maxargs; ++j) {
+ Printf(tmp, "%s%d", j ? "," : " ", j + 1);
+ }
+ Printf(tmp, "}");
+ Wrapper_add_local(wrapper, "argv", tmp);
+
+ Printf(wrapper->code, "SWIG_Scilab_SetApiContext(pvApiCtx);\n");
+
+ /* Dump the dispatch function */
+ Printv(wrapper->code, dispatch, "\n", NIL);
+ Printf(wrapper->code, "Scierror(999, _(\"No matching function for overload\"));\n");
+ Printf(wrapper->code, "return SWIG_ERROR;\n");
+ Printv(wrapper->code, "}\n", NIL);
+ Wrapper_print(wrapper, wrappersSection);
+
+ Delete(tmp);
+ DelWrapper(wrapper);
+ Delete(dispatch);
+ Delete(wrapperName);
+ }
+
+ /* -----------------------------------------------------------------------
+ * variableWrapper()
+ * ----------------------------------------------------------------------- */
+
+ virtual int variableWrapper(Node *node) {
+
+ /* Get information about variable */
+ String *origVariableName = Getattr(node, "name"); // Ex: Shape::nshapes
+ String *variableName = Getattr(node, "sym:name"); // Ex; Shape_nshapes (can be used for function names, ...)
+
+ // Variable names can have SCILAB_VARIABLE_NAME_CHAR_MAX because of suffixes "_get" or "_set" added to function
+ String *scilabVariableName = checkIdentifierName(variableName, SCILAB_VARIABLE_NAME_CHAR_MAX);
+
+ /* Manage GET function */
+ Wrapper *getFunctionWrapper = NewWrapper();
+ String *getFunctionName = Swig_name_get(NSPACE_TODO, variableName);
+ String *scilabGetFunctionName = Swig_name_get(NSPACE_TODO, scilabVariableName);
+
+ Setattr(node, "wrap:name", getFunctionName);
+ Printv(getFunctionWrapper->def, "int ", getFunctionName, "(SWIG_GatewayParameters) {\n", NIL);
+
+ /* Check the number of input and output */
+ Printf(getFunctionWrapper->def, "SWIG_CheckInputArgument(pvApiCtx, 0, 0);\n");
+ Printf(getFunctionWrapper->def, "SWIG_CheckOutputArgument(pvApiCtx, 1, 1);\n");
+ Printf(getFunctionWrapper->def, "SWIG_Scilab_SetApiContext(pvApiCtx);\n");
+
+ String *varoutTypemap = Swig_typemap_lookup("varout", node, origVariableName, 0);
+ if (varoutTypemap != NULL) {
+ Printf(getFunctionWrapper->code, "SWIG_Scilab_SetOutputPosition(%d);\n", 1);
+ Replaceall(varoutTypemap, "$value", origVariableName);
+ Replaceall(varoutTypemap, "$result", "1");
+ emit_action_code(node, getFunctionWrapper->code, varoutTypemap);
+ Delete(varoutTypemap);
+ }
+ Append(getFunctionWrapper->code, "return SWIG_OK;\n");
+ Append(getFunctionWrapper->code, "}\n");
+ Wrapper_print(getFunctionWrapper, wrappersSection);
+
+ /* Add function to builder table */
+ addFunctionToScilab(scilabGetFunctionName, getFunctionName);
+
+ /* Manage SET function */
+ if (is_assignable(node)) {
+ Wrapper *setFunctionWrapper = NewWrapper();
+ String *setFunctionName = Swig_name_set(NSPACE_TODO, variableName);
+ String *scilabSetFunctionName = Swig_name_set(NSPACE_TODO, scilabVariableName);
+
+ Setattr(node, "wrap:name", setFunctionName);
+ Printv(setFunctionWrapper->def, "int ", setFunctionName, "(SWIG_GatewayParameters) {\n", NIL);
+
+ /* Check the number of input and output */
+ Printf(setFunctionWrapper->def, "SWIG_CheckInputArgument(pvApiCtx, 1, 1);\n");
+ Printf(setFunctionWrapper->def, "SWIG_CheckOutputArgument(pvApiCtx, 1, 1);\n");
+ Printf(setFunctionWrapper->def, "SWIG_Scilab_SetApiContext(pvApiCtx);\n");
+
+ String *varinTypemap = Swig_typemap_lookup("varin", node, origVariableName, 0);
+ if (varinTypemap != NULL) {
+ Replaceall(varinTypemap, "$input", "1");
+ emit_action_code(node, setFunctionWrapper->code, varinTypemap);
+ Delete(varinTypemap);
+ }
+ Append(setFunctionWrapper->code, "return SWIG_OK;\n");
+ Append(setFunctionWrapper->code, "}\n");
+ Wrapper_print(setFunctionWrapper, wrappersSection);
+
+ /* Add function to builder table */
+ addFunctionToScilab(scilabSetFunctionName, setFunctionName);
+ }
+
+ return SWIG_OK;
+ }
+
+ /* -----------------------------------------------------------------------
+ * constantWrapper()
+ * ----------------------------------------------------------------------- */
+
+ virtual int constantWrapper(Node *node) {
+
+ /* Get the useful information from the node */
+ String *nodeName = Getattr(node, "name");
+ SwigType *type = Getattr(node, "type");
+ String *constantName = Getattr(node, "sym:name");
+ String *rawValue = Getattr(node, "rawval");
+ String *constantValue = rawValue ? rawValue : Getattr(node, "value");
+ String *constantTypemap = NULL;
+
+ // If feature scilab:const enabled, constants & enums are wrapped to Scilab variables
+ if (GetFlag(node, "feature:scilab:const")) {
+ bool isConstant = ((SwigType_issimple(type)) || (SwigType_type(type) == T_STRING));
+ bool isEnum = (Cmp(nodeType(node), "enumitem") == 0);
+
+ if (isConstant || isEnum) {
+ if (isEnum) {
+ Setattr(node, "type", "double");
+ constantValue = Getattr(node, "enumvalue");
+ }
+
+ constantTypemap = Swig_typemap_lookup("scilabconstcode", node, nodeName, 0);
+ if (constantTypemap != NULL) {
+ String *scilabConstantName = checkIdentifierName(constantName, SCILAB_IDENTIFIER_NAME_CHAR_MAX);
+
+ Setattr(node, "wrap:name", constantName);
+ Replaceall(constantTypemap, "$result", scilabConstantName);
+ Replaceall(constantTypemap, "$value", constantValue);
+
+ emit_action_code(node, variablesCode, constantTypemap);
+ Delete(constantTypemap);
+ return SWIG_OK;
+ }
+ }
+ }
+
+ /* Create variables for member pointer constants, not supported by typemaps (like Python wrapper does) */
+ if (SwigType_type(type) == T_MPOINTER) {
+ String *wname = Swig_name_wrapper(constantName);
+ String *str = SwigType_str(type, wname);
+ Printf(headerSection, "static %s = %s;\n", str, constantValue);
+ Delete(str);
+ constantValue = wname;
+ }
+ // Constant names can have SCILAB_VARIABLE_NAME_CHAR_MAX because of suffixes "_get" added to function
+ String *scilabConstantName = checkIdentifierName(constantName, SCILAB_VARIABLE_NAME_CHAR_MAX);
+
+ /* Create GET function to get the constant value */
+ Wrapper *getFunctionWrapper = NewWrapper();
+ String *getFunctionName = Swig_name_get(NSPACE_TODO, constantName);
+ String *scilabGetFunctionName = Swig_name_get(NSPACE_TODO, scilabConstantName);
+ Setattr(node, "wrap:name", getFunctionName);
+ Printv(getFunctionWrapper->def, "int ", getFunctionName, "(SWIG_GatewayParameters) {\n", NIL);
+
+ /* Check the number of input and output */
+ Printf(getFunctionWrapper->def, "SWIG_CheckInputArgument(pvApiCtx, 0, 0);\n");
+ Printf(getFunctionWrapper->def, "SWIG_CheckOutputArgument(pvApiCtx, 1, 1);\n");
+ Printf(getFunctionWrapper->def, "SWIG_Scilab_SetApiContext(pvApiCtx);\n");
+
+ constantTypemap = Swig_typemap_lookup("constcode", node, nodeName, 0);
+ if (constantTypemap != NULL) {
+ Printf(getFunctionWrapper->code, "SWIG_Scilab_SetOutputPosition(%d);\n", 1);
+ Replaceall(constantTypemap, "$value", constantValue);
+ Replaceall(constantTypemap, "$result", "1");
+ emit_action_code(node, getFunctionWrapper->code, constantTypemap);
+ Delete(constantTypemap);
+ }
+
+ /* Dump the wrapper function */
+ Append(getFunctionWrapper->code, "return SWIG_OK;\n");
+ Append(getFunctionWrapper->code, "}\n");
+ Wrapper_print(getFunctionWrapper, wrappersSection);
+
+ /* Add the function to Scilab */
+ addFunctionToScilab(scilabGetFunctionName, getFunctionName);
+
+ DelWrapper(getFunctionWrapper);
+
+ return SWIG_OK;
+ }
+
+ /* ---------------------------------------------------------------------
+ * enumvalueDeclaration()
+ * --------------------------------------------------------------------- */
+
+ virtual int enumvalueDeclaration(Node *node) {
+ static int iPreviousEnumValue = 0;
+
+ if (GetFlag(node, "feature:scilab:const")) {
+ // Compute the "absolute" value of enum if needed
+ // (most of time enum values are a linked list of relative values)
+ String *enumValue = Getattr(node, "enumvalue");
+ String *enumValueEx = Getattr(node, "enumvalueex");
+
+ // First enum value ?
+ String *firstenumitem = Getattr(node, "firstenumitem");
+ if (firstenumitem) {
+ if (enumValue) {
+ // Value is in 'enumvalue'
+ iPreviousEnumValue = atoi(Char(enumValue));
+ } else if (enumValueEx) {
+ // Or value is in 'enumValueEx'
+ iPreviousEnumValue = atoi(Char(enumValueEx));
+
+ enumValue = NewString("");
+ Printf(enumValue, "%d", iPreviousEnumValue);
+ Setattr(node, "enumvalue", enumValue);
+ }
+ } else if (!enumValue && enumValueEx) {
+ // Value is not specified, set it by incrementing last value
+ enumValue = NewString("");
+ Printf(enumValue, "%d", ++iPreviousEnumValue);
+ Setattr(node, "enumvalue", enumValue);
+ }
+ // Enums in Scilab are mapped to double
+ Setattr(node, "type", "double");
+ }
+
+ return Language::enumvalueDeclaration(node);
+ }
+
+ /* ---------------------------------------------------------------------
+ * membervariableHandler()
+ * --------------------------------------------------------------------- */
+ virtual int membervariableHandler(Node *node) {
+ checkMemberIdentifierName(node, SCILAB_VARIABLE_NAME_CHAR_MAX);
+ return Language::membervariableHandler(node);
+ }
+
+ /* -----------------------------------------------------------------------
+ * checkIdentifierName()
+ * Truncates (and displays a warning) for too long identifier names
+ * (applies on functions, variables, constants...)
+ * (Scilab identifiers names are limited to 24 chars max)
+ * ----------------------------------------------------------------------- */
+
+ String *checkIdentifierName(String *name, int char_size_max) {
+ String *scilabIdentifierName;
+ if (Len(name) > char_size_max) {
+ scilabIdentifierName = DohNewStringWithSize(name, char_size_max);
+ Swig_warning(WARN_SCILAB_TRUNCATED_NAME, input_file, line_number,
+ "Identifier name '%s' exceeds 24 characters and has been truncated to '%s'.\n", name, scilabIdentifierName);
+ } else
+ scilabIdentifierName = name;
+ return scilabIdentifierName;
+ }
+
+ /* -----------------------------------------------------------------------
+ * checkMemberIdentifierName()
+ * Truncates (and displays a warning) too long member identifier names
+ * (applies on members of structs, classes...)
+ * (Scilab identifiers names are limited to 24 chars max)
+ * ----------------------------------------------------------------------- */
+
+ void checkMemberIdentifierName(Node *node, int char_size_max) {
+
+ String *memberName = Getattr(node, "sym:name");
+
+ Node *containerNode = parentNode(node);
+ String *containerName = Getattr(containerNode, "sym:name");
+
+ int lenContainerName = Len(containerName);
+ int lenMemberName = Len(memberName);
+
+ if (lenContainerName + lenMemberName + 1 > char_size_max) {
+ int lenScilabMemberName = char_size_max - lenContainerName - 1;
+
+ if (lenScilabMemberName > 0) {
+ String *scilabMemberName = DohNewStringWithSize(memberName, lenScilabMemberName);
+ Setattr(node, "sym:name", scilabMemberName);
+ Swig_warning(WARN_SCILAB_TRUNCATED_NAME, input_file, line_number,
+ "Wrapping functions names for member '%s.%s' will exceed 24 characters, "
+ "so member name has been truncated to '%s'.\n", containerName, memberName, scilabMemberName);
+ } else
+ Swig_error(input_file, line_number,
+ "Wrapping functions names for member '%s.%s' will exceed 24 characters, "
+ "please rename the container of member '%s'.\n", containerName, memberName, containerName);
+ }
+ }
+
+
+
+ /* -----------------------------------------------------------------------
+ * addHelperFunctions()
+ * ----------------------------------------------------------------------- */
+
+ void addHelperFunctions() {
+ addFunctionToScilab("SWIG_this", "SWIG_this");
+ addFunctionToScilab("SWIG_ptr", "SWIG_ptr");
+ }
+
+ /* -----------------------------------------------------------------------
+ * addFunctionToScilab()
+ * Declare a wrapped function in Scilab (builder, gateway, XML, ...)
+ * ----------------------------------------------------------------------- */
+
+ void addFunctionToScilab(const_String_or_char_ptr scilabFunctionName, const_String_or_char_ptr wrapperFunctionName) {
+ if (!generateBuilder)
+ addFunctionInGatewayHeader(scilabFunctionName, wrapperFunctionName);
+
+ if (generateBuilder) {
+ addFunctionInScriptTable(scilabFunctionName, wrapperFunctionName, builderCode);
+ }
+
+ if (createLoader) {
+ addFunctionInLoader(scilabFunctionName);
+ }
+
+ if (gatewayXMLFile) {
+ Printf(gatewayXML, "<PRIMITIVE gatewayId=\"%s\" primitiveId=\"%d\" primitiveName=\"%s\"/>\n", gatewayID, primitiveID++, scilabFunctionName);
+ }
+ }
+
+
+ /* -----------------------------------------------------------------------
+ * createBuilderCode()
+ * ----------------------------------------------------------------------- */
+
+ void createBuilderFile(String *outputFilename) {
+ String *builderFilename = NewStringf("builder.sce");
+ builderFile = NewFile(builderFilename, "w", SWIG_output_files());
+ if (!builderFile) {
+ FileErrorDisplay(builderFilename);
+ SWIG_exit(EXIT_FAILURE);
+ }
+ emitBanner(builderFile);
+
+ builderFunctionCount = 0;
+ builderCode = NewString("");
+ Printf(builderCode, "mode(-1);\n");
+ Printf(builderCode, "lines(0);\n"); /* Useful for automatic tests */
+
+ // Scilab needs to be in the build directory
+ Printf(builderCode, "originaldir = pwd();\n");
+ Printf(builderCode, "builddir = get_absolute_file_path('builder.sce');\n");
+ Printf(builderCode, "cd(builddir);\n");
+
+ Printf(builderCode, "ilib_verbose(%s);\n", verboseBuildLevel);
+
+ Printf(builderCode, "libs = [];\n");
+
+ // Flags from command line arguments
+ Printf(builderCode, "cflags = \"\";\n");
+ for (int i = 0; i < Len(cflags); i++) {
+ String *cflag = Getitem(cflags, i);
+ Printf(builderCode, "cflags = cflags + \" %s\";\n", cflag);
+ }
+
+ if (Len(ldflags) > 0) {
+ for (int i = 0; i < Len(ldflags); i++) {
+ String *ldflag = Getitem(ldflags, i);
+ if (i == 0) {
+ Printf(builderCode, "ldflags = \"%s\";\n", ldflag);
+ } else {
+ Printf(builderCode, "ldflags = ldflags + \" %s\";\n", ldflag);
+ }
+ }
+ } else {
+ Printf(builderCode, "ldflags = \"\";\n");
+ }
+
+ // External script to set flags
+ if (buildFlagsScript) {
+ Printf(builderCode, "exec(\"%s\");\n", buildFlagsScript);
+ Printf(builderCode, "cflags = cflags + getCompilationFlags();\n");
+ Printf(builderCode, "ldflags = ldflags + getLinkFlags();\n");
+ }
+ // Additional sources
+ Insert(sourceFileList, 0, outputFilename);
+ for (int i = 0; i < Len(sourceFileList); i++) {
+ String *sourceFile = Getitem(sourceFileList, i);
+ if (i == 0) {
+ Printf(builderCode, "files = \"%s\";\n", sourceFile);
+ } else {
+ Printf(builderCode, "files($ + 1) = \"%s\";\n", sourceFile);
+ }
+ }
+
+ Printf(builderCode, "table = [");
+ }
+
+ /* -----------------------------------------------------------------------
+ * addFunctionInBuilderCode()
+ * Add a function wrapper in the function table of generated builder script
+ * ----------------------------------------------------------------------- */
+
+ void addFunctionInScriptTable(const_String_or_char_ptr scilabFunctionName, const_String_or_char_ptr wrapperFunctionName, String *scriptCode) {
+ if (++builderFunctionCount % 10 == 0) {
+ Printf(scriptCode, "];\ntable = [table;");
+ }
+ Printf(scriptCode, "\"%s\",\"%s\";", scilabFunctionName, wrapperFunctionName);
+ }
+
+ /* -----------------------------------------------------------------------
+ * saveBuilderFile()
+ * ----------------------------------------------------------------------- */
+
+ void saveBuilderFile(String *gatewayName) {
+ Printf(builderCode, "];\n");
+ Printf(builderCode, "ierr = 0;\n");
+ Printf(builderCode, "if ~isempty(table) then\n");
+ Printf(builderCode, " ierr = execstr(\"ilib_build(''%s'', table, files, libs, [], ldflags, cflags);\", 'errcatch');\n", gatewayName);
+ Printf(builderCode, " if ierr <> 0 then\n");
+ Printf(builderCode, " err_msg = lasterror();\n");
+ Printf(builderCode, " end\n");
+ Printf(builderCode, "end\n");
+ Printf(builderCode, "cd(originaldir);\n");
+ Printf(builderCode, "if ierr <> 0 then\n");
+ Printf(builderCode, " error(ierr, err_msg);\n");
+ Printf(builderCode, "end\n");
+ Printv(builderFile, builderCode, NIL);
+ Delete(builderFile);
+ }
+
+ /* -----------------------------------------------------------------------
+ * createGatewayXMLFile()
+ * This XML file is used by Scilab in the context of internal modules
+ * ----------------------------------------------------------------------- */
+
+ void createGatewayXMLFile(String *gatewayName) {
+ String *gatewayXMLFilename = NewStringf("%s_gateway.xml", gatewayName);
+ gatewayXMLFile = NewFile(gatewayXMLFilename, "w", SWIG_output_files());
+ if (!gatewayXMLFile) {
+ FileErrorDisplay(gatewayXMLFilename);
+ SWIG_exit(EXIT_FAILURE);
+ }
+ // Add a slightly modified SWIG banner to the gateway XML ("--modify" is illegal in XML)
+ gatewayXML = NewString("");
+ Printf(gatewayXML, "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n");
+ Printf(gatewayXML, "<!--\n");
+ Printf(gatewayXML, "This file was automatically generated by SWIG (http://www.swig.org).\n");
+ Printf(gatewayXML, "Version %s\n", Swig_package_version());
+ Printf(gatewayXML, "\n");
+ Printf(gatewayXML, "Do not make changes to this file unless you know what you are doing - modify\n");
+ Printf(gatewayXML, "the SWIG interface file instead.\n");
+ Printf(gatewayXML, "-->\n");
+ Printf(gatewayXML, "<GATEWAY name=\"%s\">\n", gatewayName);
+
+ primitiveID = 1;
+ }
+
+ /* -----------------------------------------------------------------------
+ * saveGatewayXMLFile()
+ * ----------------------------------------------------------------------- */
+
+ void saveGatewayXMLFile() {
+ Printf(gatewayXML, "</GATEWAY>\n");
+ Printv(gatewayXMLFile, gatewayXML, NIL);
+ Delete(gatewayXMLFile);
+ }
+
+ /* -----------------------------------------------------------------------
+ * startGatewayHeader()
+ * Start the gateway header
+ * ----------------------------------------------------------------------- */
+ void startGatewayHeader(String *gatewayLibraryName) {
+ gatewayHeader = NewString("");
+ Printf(gatewayHeader, "\n");
+
+ gatewayHeaderV6 = NewString("");
+ Printf(gatewayHeaderV6, "#include \"c_gateway_prototype.h\"\n");
+ Printf(gatewayHeaderV6, "#include \"addfunction.h\"\n");
+ Printf(gatewayHeaderV6, "\n");
+ Printf(gatewayHeaderV6, "#define MODULE_NAME L\"%s\"\n", gatewayLibraryName);
+ Printf(gatewayHeaderV6, "#ifdef __cplusplus\n");
+ Printf(gatewayHeaderV6, "extern \"C\"\n");
+ Printf(gatewayHeaderV6, "#endif\n");
+ Printf(gatewayHeaderV6, "int %s(wchar_t *pwstFuncName) {\n", gatewayLibraryName);
+ Printf(gatewayHeaderV6, "\n");
+ }
+
+ /* -----------------------------------------------------------------------
+ * addFunctionInGatewayHeader()
+ * Add a function in the gateway header
+ * ----------------------------------------------------------------------- */
+
+ void addFunctionInGatewayHeader(const_String_or_char_ptr scilabFunctionName, const_String_or_char_ptr wrapperFunctionName) {
+ if (gatewayHeaderV5 == NULL) {
+ gatewayHeaderV5 = NewString("");
+ Printf(gatewayHeaderV5, "static GenericTable Tab[] = {\n");
+ } else
+ Printf(gatewayHeaderV5, ",\n");
+ Printf(gatewayHeaderV5, " {(Myinterfun)sci_gateway, (GT)%s, (char *)\"%s\"}", wrapperFunctionName, scilabFunctionName);
+
+ Printf(gatewayHeaderV6, "if (wcscmp(pwstFuncName, L\"%s\") == 0) { addCFunction((wchar_t *)L\"%s\", &%s, (wchar_t *)MODULE_NAME); }\n", scilabFunctionName, scilabFunctionName, wrapperFunctionName);
+ }
+
+ /* -----------------------------------------------------------------------
+ * terminateGatewayHeader()
+ * Terminates the gateway header
+ * ----------------------------------------------------------------------- */
+
+ void terminateGatewayHeader(String *gatewayLibraryName) {
+ Printf(gatewayHeaderV5, "};\n");
+ Printf(gatewayHeaderV5, "\n");
+ Printf(gatewayHeaderV5, "#ifdef __cplusplus\n");
+ Printf(gatewayHeaderV5, "extern \"C\" {\n");
+ Printf(gatewayHeaderV5, "#endif\n");
+ Printf(gatewayHeaderV5, "int C2F(%s)() {\n", gatewayLibraryName);
+ Printf(gatewayHeaderV5, " Rhs = Max(0, Rhs);\n");
+ Printf(gatewayHeaderV5, " if (*(Tab[Fin-1].f) != NULL) {\n");
+ Printf(gatewayHeaderV5, " if(pvApiCtx == NULL) {\n");
+ Printf(gatewayHeaderV5, " pvApiCtx = (StrCtx *)MALLOC(sizeof(StrCtx));\n");
+ Printf(gatewayHeaderV5, " }\n");
+ Printf(gatewayHeaderV5, " pvApiCtx->pstName = (char *)Tab[Fin-1].name;\n");
+ Printf(gatewayHeaderV5, " (*(Tab[Fin-1].f))(Tab[Fin-1].name,(GatefuncH)Tab[Fin-1].F);\n");
+ Printf(gatewayHeaderV5, " }\n");
+ Printf(gatewayHeaderV5, " return 0;\n");
+ Printf(gatewayHeaderV5, "}\n");
+ Printf(gatewayHeaderV5, "\n");
+ Printf(gatewayHeaderV5, "#ifdef __cplusplus\n");
+ Printf(gatewayHeaderV5, "}\n");
+ Printf(gatewayHeaderV5, "#endif\n");
+
+ Printf(gatewayHeaderV6, "return 1;\n");
+ Printf(gatewayHeaderV6, "};\n");
+
+ Printf(gatewayHeader, "#if SWIG_SCILAB_VERSION >= 600\n");
+ Printv(gatewayHeader, gatewayHeaderV6, NIL);
+ Printf(gatewayHeader, "#else\n");
+ Printv(gatewayHeader, gatewayHeaderV5, NIL);
+ Printf(gatewayHeader, "#endif\n");
+ }
+
+
+ /* -----------------------------------------------------------------------
+ * createLoaderScriptFile()
+ * Creates the loader script file (loader.sce)
+ * ----------------------------------------------------------------------- */
+
+ void createLoaderFile(String *gatewayLibraryName) {
+ String *loaderFilename = NewString("loader.sce");
+ loaderFile = NewFile(loaderFilename, "w", SWIG_output_files());
+ if (!loaderFile) {
+ FileErrorDisplay(loaderFilename);
+ SWIG_exit(EXIT_FAILURE);
+ }
+
+ emitBanner(loaderFile);
+
+ loaderScript = NewString("");
+ Printf(loaderScript, "%s_path = get_absolute_file_path('loader.sce');\n", gatewayLibraryName);
+ Printf(loaderScript, "[bOK, ilib] = c_link('%s');\n", gatewayLibraryName);
+ Printf(loaderScript, "if bOK then\n");
+ Printf(loaderScript, " ulink(ilib);\n");
+ Printf(loaderScript, "end\n");
+ Printf(loaderScript, "list_functions = [..\n");
+ }
+
+ /* -----------------------------------------------------------------------
+ * addFunctionInLoaderScript()
+ * Add a function in the loader script table
+ * ----------------------------------------------------------------------- */
+
+ void addFunctionInLoader(const_String_or_char_ptr scilabFunctionName) {
+ Printf(loaderScript, " '%s'; ..\n", scilabFunctionName);
+ }
+
+ /* -----------------------------------------------------------------------
+ * saveLoaderScriptFile()
+ * Terminates and saves the loader script
+ * ----------------------------------------------------------------------- */
+
+ void saveLoaderFile(String *gatewayLibraryName) {
+ Printf(loaderScript, "];\n");
+ Printf(loaderScript, "addinter(fullfile(%s_path, '%s' + getdynlibext()), '%s', list_functions);\n",
+ gatewayLibraryName, gatewayLibraryName, gatewayLibraryName);
+ Printf(loaderScript, "clear %s_path;\n", gatewayLibraryName);
+ Printf(loaderScript, "clear bOK;\n");
+ Printf(loaderScript, "clear ilib;\n");
+ Printf(loaderScript, "clear list_functions;\n");
+ Printv(loaderFile, loaderScript, NIL);
+
+ Delete(loaderFile);
+ }
+
+};
+
+extern "C" Language *swig_scilab(void) {
+ return new SCILAB();
+}
Language *swig_cffi(void);
Language *swig_uffi(void);
Language *swig_r(void);
+ Language *swig_scilab(void);
Language *swig_go(void);
Language *swig_d(void);
+ Language *swig_javascript(void);
}
struct swig_module {
{"-go", swig_go, "Go"},
{"-guile", swig_guile, "Guile"},
{"-java", swig_java, "Java"},
+ {"-javascript", swig_javascript, "Javascript"},
{"-lua", swig_lua, "Lua"},
{"-modula3", swig_modula3, "Modula 3"},
{"-mzscheme", swig_mzscheme, "Mzscheme"},
{"-python", swig_python, "Python"},
{"-r", swig_r, "R (aka GNU S)"},
{"-ruby", swig_ruby, "Ruby"},
+ {"-scilab", swig_scilab, "Scilab"},
{"-sexp", swig_sexp, "Lisp S-Expressions"},
{"-tcl", swig_tcl, "Tcl"},
{"-tcl8", swig_tcl, 0},
} else if (strcmp(argv[i], "-nolang") == 0) {
dl = new Language;
Swig_mark_arg(i);
- } else if ((strcmp(argv[i], "-dnone") == 0) ||
- (strcmp(argv[i], "-dhtml") == 0) ||
- (strcmp(argv[i], "-dlatex") == 0) || (strcmp(argv[i], "-dascii") == 0) || (strcmp(argv[i], "-stat") == 0)) {
- Printf(stderr, "swig: Warning. %s option deprecated.\n", argv[i]);
- Swig_mark_arg(i);
} else if ((strcmp(argv[i], "-help") == 0) || (strcmp(argv[i], "--help") == 0)) {
if (strcmp(argv[i], "--help") == 0)
strcpy(argv[i], "-help");
#include "preprocessor.h"
#include "swigwarn.h"
-#if !defined(HAVE_BOOL)
-typedef int bool;
-#define true ((bool)1)
-#define false ((bool)0)
-#endif
-
#define NOT_VIRTUAL 0
#define PLAIN_VIRTUAL 1
#define PURE_VIRTUAL 2
virtual int usingDeclaration(Node *n);
virtual int namespaceDeclaration(Node *n);
virtual int templateDeclaration(Node *n);
+ virtual int lambdaDeclaration(Node *n);
enum AccessMode { PUBLIC, PRIVATE, PROTECTED };
/* Miscellaneous */
virtual int validIdentifier(String *s); /* valid identifier? */
virtual int addSymbol(const String *s, const Node *n, const_String_or_char_ptr scope = ""); /* Add symbol */
+ virtual int addInterfaceSymbol(const String *interface_name, Node *n, const_String_or_char_ptr scope = "");
virtual void dumpSymbols();
- virtual Node *symbolLookup(String *s, const_String_or_char_ptr scope = ""); /* Symbol lookup */
- virtual Node *classLookup(const SwigType *s); /* Class lookup */
+ virtual Node *symbolLookup(const String *s, const_String_or_char_ptr scope = ""); /* Symbol lookup */
+ virtual Hash* symbolAddScope(const_String_or_char_ptr scope);
+ virtual Hash* symbolScopeLookup(const_String_or_char_ptr scope);
+ virtual Hash* symbolScopePseudoSymbolLookup(const_String_or_char_ptr scope);
+ virtual Node *classLookup(const SwigType *s) const; /* Class lookup */
virtual Node *enumLookup(SwigType *s); /* Enum lookup */
virtual int abstractClassTest(Node *n); /* Is class really abstract? */
virtual int is_assignable(Node *n); /* Is variable assignable? */
/* Return the current class prefix */
String *getClassPrefix() const;
+ /* Return the current enum class prefix */
+ String *getEnumClassPrefix() const;
+
/* Fully qualified type name to use */
String *getClassType() const;
/* Return true if the current method is part of a smart-pointer */
int is_smart_pointer() const;
+ /* Return the name to use for the given parameter. */
+ virtual String *makeParameterName(Node *n, Parm *p, int arg_num, bool setter = false) const;
+
/* Some language modules require additional wrappers for virtual methods not declared in sub-classes */
virtual bool extraDirectorProtectedCPPMethodsRequired() const;
+public:
+ enum NestedClassSupport {
+ NCS_None, // Target language does not have an equivalent to nested classes
+ NCS_Full, // Target language does have an equivalent to nested classes and is fully implemented
+ NCS_Unknown // Target language may or may not have an equivalent to nested classes. If it does, it has not been implemented yet.
+ };
+ /* Does target language support nested classes? Default is NCS_Unknown.
+ If NCS_Unknown is returned, then the nested classes will be ignored unless
+ %feature "flatnested" is applied to them, in which case they will appear in global space.
+ If the target language does not support the notion of class
+ nesting, the language module should return NCS_None from this function, and
+ the nested classes will be moved to the global scope (like implicit global %feature "flatnested").
+ */
+ virtual NestedClassSupport nestedClassesSupport() const;
+
+ /* Returns true if the target language supports key word arguments (kwargs) */
+ virtual bool kwargsSupport() const;
+
+protected:
/* Identifies if a protected members that are generated when the allprotected option is used.
This does not include protected virtual methods as they are turned on with the dirprot option. */
bool isNonVirtualProtectedAccess(Node *n) const;
+ /* Identify if a wrapped global or member variable n should use the naturalvar feature */
+ int use_naturalvar_mode(Node *n) const;
+
/* Director subclass comparison test */
String *none_comparison;
int is_member_director(Node *parentnode, Node *member);
int is_member_director(Node *member);
int is_non_virtual_protected_access(Node *n); /* Check if the non-virtual protected members are required (for directors) */
-int use_naturalvar_mode(Node *n);
void Wrapper_virtual_elimination_mode_set(int);
void Wrapper_fast_dispatch_mode_set(int);
}
/* Contracts */
-
void Swig_contracts(Node *n);
void Swig_contract_mode_set(int flag);
int Swig_contract_mode_get();
/* Browser */
-
void Swig_browser(Node *n, int);
void Swig_default_allocators(Node *n);
void Swig_process_types(Node *n);
+/* Nested classes */
+void Swig_nested_process_classes(Node *n);
+void Swig_nested_name_unnamed_c_structs(Node *n);
+
+/* Interface feature */
+void Swig_interface_feature_enable();
+void Swig_interface_propagate_methods(Node *n);
+
+/* Miscellaneous */
+template <class T> class save_value {
+ T _value;
+ T& _value_ptr;
+ save_value(const save_value&);
+ save_value& operator=(const save_value&);
+
+public:
+ save_value(T& value) : _value(value), _value_ptr(value) {}
+ save_value(T& value, T new_val) : _value(value), _value_ptr(value) { value = new_val; }
+ ~save_value() { _value_ptr = _value; }
+};
+
#endif
#include "swigmod.h"
#include "cparse.h"
-static int treduce = SWIG_cparse_template_reduce(0);
-static const char *usage = (char *) "\
+static const char *usage = "\
Tcl 8 Options (available with -tcl)\n\
-itcl - Enable ITcl support\n\
-nosafe - Leave out SafeInit module function.\n\
Swig_banner(f_begin);
- Printf(f_runtime, "\n");
- Printf(f_runtime, "#define SWIGTCL\n");
- Printf(f_runtime, "\n");
+ Printf(f_runtime, "\n\n#ifndef SWIGTCL\n#define SWIGTCL\n#endif\n\n");
/* Set the module name, namespace, and prefix */
Printf(f_wrappers, ",0");
}
Printv(f_wrappers, ", swig_", mangled_classname, "_methods, swig_", mangled_classname, "_attributes, swig_", mangled_classname, "_bases,",
- "swig_", mangled_classname, "_base_names, &swig_module };\n", NIL);
+ "swig_", mangled_classname, "_base_names, &swig_module, SWIG_TCL_HASHTABLE_INIT };\n", NIL);
if (!itcl) {
Printv(cmd_tab, tab4, "{ SWIG_prefix \"", class_name, "\", (swig_wrapper_func) SWIG_ObjectConstructor, (ClientData)&_wrap_class_", mangled_classname,
}
continue;
}
+ // A case when both outer and nested classes inherit from the same parent. Constructor may be found instead of the class itself.
+ } else if (GetFlag(cls, "nested") && checkAttribute(bcls, "nodeType", "constructor")) {
+ bcls = Getattr(bcls, "parentNode");
+ if (Getattr(bcls, "typepass:visit")) {
+ if (!Getattr(bcls, "feature:onlychildren")) {
+ if (!ilist)
+ ilist = alist = NewList();
+ Append(ilist, bcls);
+ } else {
+ Swig_warning(WARN_TYPE_UNDEFINED_CLASS, Getfile(bname), Getline(bname), "Base class '%s' has no name as it is an empty template instantiated with '%%template()'. Ignored.\n", SwigType_namestr(bname));
+ Swig_warning(WARN_TYPE_UNDEFINED_CLASS, Getfile(bcls), Getline(bcls), "The %%template directive must be written before '%s' is used as a base class and be declared with a name.\n", SwigType_namestr(bname));
+ }
+ }
+ break;
}
if (Strcmp(nodeType(bcls), "classforward") != 0) {
Swig_error(Getfile(bname), Getline(bname), "'%s' is not a valid base class.\n", SwigType_namestr(bname));
if (tname)
Delete(tname);
if (!bcls) {
- if (!clsforward) {
+ if (!clsforward && !GetFlag(cls, "feature:ignore")) {
if (ispublic && !Getmeta(bname, "already_warned")) {
Swig_warning(WARN_TYPE_UNDEFINED_CLASS, Getfile(bname), Getline(bname), "Nothing known about base class '%s'. Ignored.\n", SwigType_namestr(bname));
if (Strchr(bname, '<')) {
Node *bclass = n; /* Getattr(n,"class"); */
Hash *scopes = Getattr(bclass, "typescope");
SwigType_inherit(clsname, bname, cast, 0);
- String *smartptr = Getattr(first, "feature:smartptr");
- if (smartptr) {
- SwigType *smart = 0;
- SwigType *spt = Swig_cparse_type(smartptr);
- if (spt) {
- smart = SwigType_typedef_resolve_all(spt);
- Delete(spt);
- /* Record a (fake) inheritance relationship between smart pointer
- and smart pointer to base class, so that smart pointer upcasts
- are automatically generated. */
- SwigType *bsmart = Copy(smart);
- SwigType *rclsname = SwigType_typedef_resolve_all(clsname);
- SwigType *rbname = SwigType_typedef_resolve_all(bname);
- Replaceall(bsmart, rclsname, rbname);
- Delete(rclsname);
- Delete(rbname);
- String *smartnamestr = SwigType_namestr(smart);
- String *bsmartnamestr = SwigType_namestr(bsmart);
- /* construct casting code */
- String *convcode = NewStringf("\n *newmemory = SWIG_CAST_NEW_MEMORY;\n return (void *) new %s(*(%s *)$from);\n", bsmartnamestr, smartnamestr);
- Delete(bsmartnamestr);
- Delete(smartnamestr);
- /* setup inheritance relationship between smart pointer templates */
- SwigType_inherit(smart, bsmart, 0, convcode);
- if (!GetFlag(bclass, "feature:smartptr"))
- Swig_warning(WARN_LANG_SMARTPTR_MISSING, Getfile(first), Getline(first), "Base class '%s' of '%s' is not similarly marked as a smart pointer.\n", SwigType_namestr(Getattr(bclass, "name")), SwigType_namestr(Getattr(first, "name")));
- Delete(convcode);
- Delete(bsmart);
+ if (ispublic && !GetFlag(bclass, "feature:ignore")) {
+ String *smartptr = Getattr(first, "feature:smartptr");
+ if (smartptr) {
+ SwigType *smart = Swig_cparse_smartptr(first);
+ if (smart) {
+ /* Record a (fake) inheritance relationship between smart pointer
+ and smart pointer to base class, so that smart pointer upcasts
+ are automatically generated. */
+ SwigType *bsmart = Copy(smart);
+ SwigType *rclsname = SwigType_typedef_resolve_all(clsname);
+ SwigType *rbname = SwigType_typedef_resolve_all(bname);
+ Replaceall(bsmart, rclsname, rbname);
+ Delete(rclsname);
+ Delete(rbname);
+ String *smartnamestr = SwigType_namestr(smart);
+ String *bsmartnamestr = SwigType_namestr(bsmart);
+ /* construct casting code */
+ String *convcode = NewStringf("\n *newmemory = SWIG_CAST_NEW_MEMORY;\n return (void *) new %s(*(%s *)$from);\n", bsmartnamestr, smartnamestr);
+ Delete(bsmartnamestr);
+ Delete(smartnamestr);
+ /* setup inheritance relationship between smart pointer templates */
+ SwigType_inherit(smart, bsmart, 0, convcode);
+ if (!GetFlag(bclass, "feature:smartptr"))
+ Swig_warning(WARN_LANG_SMARTPTR_MISSING, Getfile(first), Getline(first), "Base class '%s' of '%s' is not similarly marked as a smart pointer.\n", SwigType_namestr(Getattr(bclass, "name")), SwigType_namestr(Getattr(first, "name")));
+ Delete(convcode);
+ Delete(bsmart);
+ }
Delete(smart);
} else {
- Swig_error(Getfile(first), Getline(first), "Invalid type (%s) in 'smartptr' feature for class %s.\n", SwigType_namestr(smartptr), SwigType_namestr(clsname));
+ if (GetFlag(bclass, "feature:smartptr"))
+ Swig_warning(WARN_LANG_SMARTPTR_MISSING, Getfile(first), Getline(first), "Derived class '%s' of '%s' is not similarly marked as a smart pointer.\n", SwigType_namestr(Getattr(first, "name")), SwigType_namestr(Getattr(bclass, "name")));
}
- } else {
- if (GetFlag(bclass, "feature:smartptr"))
- Swig_warning(WARN_LANG_SMARTPTR_MISSING, Getfile(first), Getline(first), "Derived class '%s' of '%s' is not similarly marked as a smart pointer.\n", SwigType_namestr(Getattr(first, "name")), SwigType_namestr(Getattr(bclass, "name")));
}
if (!importmode) {
String *btype = Copy(bname);
String *unnamed = Getattr(n, "unnamed");
String *storage = Getattr(n, "storage");
String *kind = Getattr(n, "kind");
- Node *oldinclass = inclass;
+ save_value<Node*> oldinclass(inclass);
List *olist = normalize;
Symtab *symtab;
String *nname = 0;
if (unnamed && tdname && (Cmp(storage, "typedef") == 0)) {
SwigType_typedef(unnamed, tdname);
}
+ // name of the outer class should already be patched to contain its outer classes names, but not to contain namespaces
+ // namespace name (if present) is added after processing child nodes
+ if (Getattr(n, "nested:outer") && name) {
+ String *outerName = Getattr(Getattr(n, "nested:outer"), "name");
+ name = NewStringf("%s::%s", outerName, name);
+ Setattr(n, "name", name);
+ if (tdname) {
+ tdname = NewStringf("%s::%s", outerName, tdname);
+ Setattr(n, "tdname", tdname);
+ }
+ }
if (nsname && name) {
nname = NewStringf("%s::%s", nsname, name);
SwigType_attach_symtab(Getattr(n, "symtab"));
/* Inherit type definitions into the class */
- if (name) {
+ if (name && !(GetFlag(n, "nested") && !checkAttribute(n, "access", "public") &&
+ (GetFlag(n, "feature:flatnested") || Language::instance()->nestedClassesSupport() == Language::NCS_None))) {
cplus_inherit_types(n, 0, nname ? nname : (fname ? fname : name));
}
normalize = olist;
- inclass = oldinclass;
-
/* If in a namespace, patch the class name */
if (nname) {
Setattr(n, "name", nname);
}
/* ------------------------------------------------------------
- * namespaceDeclaration()
+ * templateDeclaration()
* ------------------------------------------------------------ */
virtual int templateDeclaration(Node *n) {
}
/* ------------------------------------------------------------
+ * lambdaDeclaration()
+ * ------------------------------------------------------------ */
+
+ virtual int lambdaDeclaration(Node *) {
+ return SWIG_OK;
+ }
+
+ /* ------------------------------------------------------------
* classforwardDeclaration()
* ------------------------------------------------------------ */
/* Normalize types. */
SwigType *ty = Getattr(n, "type");
+ if (!ty) {
+ return SWIG_OK;
+ }
normalize_type(ty);
SwigType *decl = Getattr(n, "decl");
if (decl) {
if (GetFlag(n, "conversion_operator")) {
/* The call to the operator in the generated wrapper must be fully qualified in order to compile */
SwigType *name = Getattr(n, "name");
- SwigType *qualifiedname = Swig_symbol_string_qualify(name,0);
+ SwigType *qualifiedname = Swig_symbol_string_qualify(name, 0);
Clear(name);
Append(name, qualifiedname);
Delete(qualifiedname);
virtual int enumvalueDeclaration(Node *n) {
String *name = Getattr(n, "name");
String *value = Getattr(n, "value");
+ String *scopedenum = Getattr(parentNode(n), "scopedenum");
if (!value)
value = name;
if (Strcmp(value, name) == 0) {
String *new_value;
- if ((nsname || inclass) && cparse_cplusplus) {
+ if ((nsname || inclass || scopedenum) && cparse_cplusplus) {
new_value = NewStringf("%s::%s", SwigType_namestr(Swig_symbol_qualified(n)), value);
} else {
new_value = NewString(value);
}
- if ((nsname || inclass) && !cparse_cplusplus) {
+ if ((nsname || inclass || scopedenum) && !cparse_cplusplus) {
String *cppvalue = NewStringf("%s::%s", SwigType_namestr(Swig_symbol_qualified(n)), value);
Setattr(n, "cppvalue", cppvalue); /* for target languages that always generate C++ code even when wrapping C code */
}
String *symname = Getattr(n, "sym:name");
while (c) {
if (Strcmp(nodeType(c), "cdecl") == 0) {
- if (!(checkAttribute(c, "storage", "static")
+ if (!(Swig_storage_isstatic(c)
|| checkAttribute(c, "storage", "typedef")
|| checkAttribute(c, "storage", "friend")
|| (Getattr(c, "feature:extend") && !Getattr(c, "code"))
* list of overloaded methods we have just added in as child nodes to the "using" node.
* The node will still exist, it is just the symbol table linked list of overloaded methods
* which is hacked. */
- if (Getattr(n, "sym:overloaded"))
- {
+ if (Getattr(n, "sym:overloaded")) {
int cnt = 0;
#ifdef DEBUG_OVERLOADED
Node *debugnode = n;
#ifdef DEBUG_OVERLOADED
show_overloaded(debugnode);
#endif
- clean_overloaded(n); // Needed?
+ clean_overloaded(n); // Needed?
}
}
}
return;
TypePass::pass(n);
}
+
#include "swigmod.h"
-static const char *usage = (char *) "\
+static const char *usage = "\
UFFI Options (available with -uffi)\n\
-identifier-converter <type or funcname> - \n\
Specifies the type of conversion to do on C identifiers\n\
else if (c == '\"') {
start_line = Getline(s);
if (skip_tochar(s, '\"', chunk) < 0) {
- Swig_error(Getfile(s), -1, "Unterminated string constant starting at line %d\n", start_line);
+ Swig_error(Getfile(s), start_line, "Unterminated string constant\n");
}
} else if (c == '\'') {
start_line = Getline(s);
if (skip_tochar(s, '\'', chunk) < 0) {
- Swig_error(Getfile(s), -1, "Unterminated character constant starting at line %d\n", start_line);
+ Swig_error(Getfile(s), start_line, "Unterminated character constant\n");
}
} else if (c == '/')
state = 30; /* Comment */
}
} else if (Equal(id, kpp_level)) {
Swig_error(Getfile(s), Getline(id), "cpp debug: level = %d, startlevel = %d\n", level, start_level);
+ } else if (Equal(id, "")) {
+ /* Null directive */
+ } else {
+ /* Ignore unknown preprocessor directives which are inside an inactive
+ * conditional (github issue #394). */
+ if (allow)
+ Swig_error(Getfile(s), Getline(id), "Unknown SWIG preprocessor directive: %s (if this is a block of target language code, delimit it with %%{ and %%})\n", id);
}
for (i = 0; i < cpp_lines; i++)
Putc('\n', ns);
}
}
while (level > 0) {
- Swig_error(Getfile(s), -1, "Missing #endif for conditional starting on line %d\n", cond_lines[level - 1]);
+ Swig_error(Getfile(s), cond_lines[level - 1], "Missing #endif for conditional starting here\n");
level--;
}
if (state == 120) {
- Swig_error(Getfile(s), -1, "Missing %%endoffile for file inclusion block starting on line %d\n", start_line);
+ Swig_error(Getfile(s), start_line, "Missing %%endoffile for file inclusion block starting here\n");
}
if (state == 150) {
Seek(value, 0, SEEK_SET);
- Swig_error(Getfile(s), -1, "Missing %%enddef for macro starting on line %d\n", Getline(value));
+ Swig_error(Getfile(s), Getline(value), "Missing %%enddef for macro starting here\n", Getline(value));
}
if ((state >= 105) && (state < 107)) {
- Swig_error(Getfile(s), -1, "Unterminated %%{ ... %%} block starting on line %d\n", start_line);
+ Swig_error(Getfile(s), start_line, "Unterminated %%{ ... %%} block\n");
}
if ((state >= 30) && (state < 40)) {
- Swig_error(Getfile(s), -1, "Unterminated comment starting on line %d\n", start_line);
+ Swig_error(Getfile(s), start_line, "Unterminated comment\n");
}
copy_location(s, chunk);
* ----------------------------------------------------------------------------- */
#include "swig.h"
+#include "cparse.h"
-extern int cparse_cplusplus;
static const char *cresult_variable_name = "result";
static Parm *nonvoid_parms(Parm *p) {
Delete(lstrname);
}
break;
+ case T_RVALUE_REFERENCE:
+ if (value) {
+ String *lstrname = SwigType_lstr(t, name);
+ String *lstr = SwigType_lstr(t, 0);
+ Printf(decl, "%s = (%s) &%s_defrvalue", lstrname, lstr, name);
+ Delete(lstrname);
+ Delete(lstr);
+ } else {
+ String *lstrname = SwigType_lstr(t, name);
+ Printf(decl, "%s = 0", lstrname);
+ Delete(lstrname);
+ }
+ break;
case T_VOID:
break;
case T_VARARGS:
Delete(defname);
Delete(defvalue);
}
- } else if (!pvalue && ((tycode == T_POINTER) || (tycode == T_STRING))) {
+ } else if (tycode == T_RVALUE_REFERENCE) {
+ if (pvalue) {
+ SwigType *tvalue;
+ String *defname, *defvalue, *rvalue, *qvalue;
+ rvalue = SwigType_typedef_resolve_all(pvalue);
+ qvalue = SwigType_typedef_qualified(rvalue);
+ defname = NewStringf("%s_defrvalue", lname);
+ tvalue = Copy(type);
+ SwigType_del_rvalue_reference(tvalue);
+ tycode = SwigType_type(tvalue);
+ if (tycode != T_USER) {
+ /* plain primitive type, we copy the the def value */
+ String *lstr = SwigType_lstr(tvalue, defname);
+ defvalue = NewStringf("%s = %s", lstr, qvalue);
+ Delete(lstr);
+ } else {
+ /* user type, we copy the reference value */
+ String *str = SwigType_str(type, defname);
+ defvalue = NewStringf("%s = %s", str, qvalue);
+ Delete(str);
+ }
+ Wrapper_add_localv(w, defname, defvalue, NIL);
+ Delete(tvalue);
+ Delete(rvalue);
+ Delete(qvalue);
+ Delete(defname);
+ Delete(defvalue);
+ }
+ } else if (!pvalue && ((tycode == T_POINTER) || (tycode == T_STRING) || (tycode == T_WSTRING))) {
pvalue = (String *) "0";
}
if (!altty) {
Delete(lstr);
}
break;
+ case T_RVALUE_REFERENCE:
+ {
+ String *const_lvalue_str;
+ String *lstr = SwigType_lstr(t, 0);
+ SwigType *tt = Copy(t);
+ SwigType_del_rvalue_reference(tt);
+ SwigType_add_qualifier(tt, "const");
+ SwigType_add_reference(tt);
+ const_lvalue_str = SwigType_rcaststr(tt, 0);
+
+ Printf(fcall, "%s = (%s) &%s", name, lstr, const_lvalue_str);
+
+ Delete(const_lvalue_str);
+ Delete(tt);
+ Delete(lstr);
+ }
+ break;
case T_USER:
Printf(fcall, "%s = ", name);
break;
return func;
if (!self)
- self = (char *) "(this)->";
+ self = "(this)->";
Append(func, self);
if (SwigType_istemplate(name) && (strncmp(Char(name), "operator ", 9) == 0)) {
if (SwigType_type(type) != T_ARRAY) {
if (!Strstr(type, "enum $unnamed")) {
String *dref = Swig_wrapped_var_deref(type, pname1, varcref);
- Printf(func, "if (%s) %s%s = %s", pname0, self, name, dref);
+ int extra_cast = 0;
+ if (cparse_cplusplusout) {
+ /* Required for C nested structs compiled as C++ as a duplicate of the nested struct is put into the global namespace.
+ * We could improve this by adding the extra casts just for nested structs rather than all structs. */
+ String *base = SwigType_base(type);
+ extra_cast = SwigType_isclass(base);
+ Delete(base);
+ }
+ if (extra_cast) {
+ String *lstr;
+ SwigType *ptype = Copy(type);
+ SwigType_add_pointer(ptype);
+ lstr = SwigType_lstr(ptype, 0);
+ Printf(func, "if (%s) *(%s)&%s%s = %s", pname0, lstr, self, name, dref);
+ Delete(lstr);
+ Delete(ptype);
+ } else {
+ Printf(func, "if (%s) %s%s = %s", pname0, self, name, dref);
+ }
Delete(dref);
} else {
Printf(func, "if (%s && sizeof(int) == sizeof(%s%s)) *(int*)(void*)&(%s%s) = %s", pname0, self, name, self, name, pname1);
String *parentclassname = 0;
if (parentclass)
parentclassname = Getattr(parentclass, "name");
- Replaceall(code, "$parentclassname", parentclassname ? parentclassname : "");
+ Replaceall(code, "$parentclassname", parentclassname ? SwigType_str(parentclassname, "") : "");
}
}
self = NewString("(*(this))->");
is_smart_pointer_overload = 1;
}
- else if (Cmp(Getattr(n, "storage"), "static") == 0) {
- String *cname = Getattr(n, "classname") ? Getattr(n, "classname") : classname;
+ else if (Swig_storage_isstatic(n)) {
+ String *cname = Getattr(n, "extendsmartclassname") ? Getattr(n, "extendsmartclassname") : classname;
String *ctname = SwigType_namestr(cname);
self = NewStringf("(*(%s const *)this)->", ctname);
is_smart_pointer_overload = 1;
String *defaultargs = Getattr(n, "defaultargs");
String *code = Getattr(n, "code");
- String *cname = Getattr(n, "classname") ? Getattr(n, "classname") : classname;
+ String *cname = Getattr(n, "extendsmartclassname") ? Getattr(n, "extendsmartclassname") : classname;
String *membername = Swig_name_member(nspace, cname, name);
String *mangled = Swig_name_mangle(membername);
int is_smart_pointer = flags & CWRAP_SMART_POINTER;
String *func = NewStringf("%s(", mangled);
String *cres;
- if (Cmp(Getattr(n, "storage"), "static") != 0) {
+ if (!Swig_storage_isstatic(n)) {
String *pname = Swig_cparm_name(pp, i);
String *ctname = SwigType_namestr(cname);
String *fadd = 0;
* This function creates a C wrapper for a C constructor function.
* ----------------------------------------------------------------------------- */
-int Swig_ConstructorToFunction(Node *n, const_String_or_char_ptr nspace, String *classname, String *none_comparison, String *director_ctor, int cplus, int flags) {
- ParmList *parms;
- Parm *prefix_args;
+int Swig_ConstructorToFunction(Node *n, const_String_or_char_ptr nspace, String *classname, String *none_comparison, String *director_ctor, int cplus, int flags, String *directorname) {
Parm *p;
ParmList *directorparms;
SwigType *type;
- int use_director;
- String *directorScope = NewString(nspace);
-
- Replace(directorScope, NSPACE_SEPARATOR, "_", DOH_REPLACE_ANY);
-
- use_director = Swig_directorclass(n);
-
- parms = CopyParmList(nonvoid_parms(Getattr(n, "parms")));
-
+ int use_director = Swig_directorclass(n);
+ ParmList *parms = CopyParmList(nonvoid_parms(Getattr(n, "parms")));
/* Prepend the list of prefix_args (if any) */
- prefix_args = Getattr(n, "director:prefix_args");
+ Parm *prefix_args = Getattr(n, "director:prefix_args");
if (prefix_args != NIL) {
Parm *p2, *p3;
if (use_director) {
Node *parent = Swig_methodclass(n);
int abstract = Getattr(parent, "abstracts") != 0;
- String *name = Getattr(parent, "sym:name");
- String *directorname;
String *action = NewStringEmpty();
String *tmp_none_comparison = Copy(none_comparison);
String *director_call;
String *nodirector_call;
- if (Len(directorScope) > 0)
- directorname = NewStringf("SwigDirector_%s_%s", directorScope, name);
- else
- directorname = NewStringf("SwigDirector_%s", name);
-
Replaceall(tmp_none_comparison, "$arg", "arg1");
director_call = Swig_cppconstructor_director_call(directorname, directorparms);
Setattr(n, "wrap:action", action);
Delete(tmp_none_comparison);
Delete(action);
- Delete(directorname);
} else {
String *call = Swig_cppconstructor_call(classname, parms);
String *cres = Swig_cresult(type, Swig_cresult_name(), call);
if (directorparms != parms)
Delete(directorparms);
Delete(parms);
- Delete(directorScope);
return SWIG_OK;
}
int varcref = flags & CWRAP_NATURAL_VAR;
if (flags & CWRAP_SMART_POINTER) {
- if (checkAttribute(n, "storage", "static")) {
+ if (Swig_storage_isstatic(n)) {
Node *sn = Getattr(n, "cplus:staticbase");
String *base = Getattr(sn, "name");
self = NewStringf("%s::", base);
Delete(mangled);
Delete(sname);
} else {
- String *nname = SwigType_namestr(name);
+ String *nname = 0;
+ if (Equal(nodeType(n), "constant")) {
+ String *rawval = Getattr(n, "rawval");
+ String *value = rawval ? rawval : Getattr(n, "value");
+ nname = NewStringf("(%s)", value);
+ } else {
+ nname = SwigType_namestr(name);
+ }
call = Swig_wrapped_var_assign(type, nname, varcref);
cres = Swig_cresult(ty, Swig_cresult_name(), call);
Setattr(n, "wrap:action", cres);
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * This file is part of SWIG, which is licensed as a whole under version 3
+ * (or any later version) of the GNU General Public License. Some additional
+ * terms also apply to certain portions of SWIG. The full details of the SWIG
+ * license and copyrights can be found in the LICENSE and COPYRIGHT files
+ * included with the SWIG source code as distributed by the SWIG developers
+ * and at http://www.swig.org/legal.html.
+ *
+ * extend.c
+ *
+ * Extensions support (%extend)
+ * ----------------------------------------------------------------------------- */
+
+#include "swig.h"
+#include "cparse.h"
+
+static Hash *extendhash = 0; /* Hash table of added methods */
+
+/* -----------------------------------------------------------------------------
+ * Swig_extend_hash()
+ *
+ * Access the extend hash
+ * ----------------------------------------------------------------------------- */
+Hash *Swig_extend_hash(void) {
+ if (!extendhash)
+ extendhash = NewHash();
+ return extendhash;
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_extend_merge()
+ *
+ * Extension merge. This function is used to handle the %extend directive
+ * when it appears before a class definition. To handle this, the %extend
+ * actually needs to take precedence. Therefore, we will selectively nuke symbols
+ * from the current symbol table, replacing them with the added methods.
+ * ----------------------------------------------------------------------------- */
+
+void Swig_extend_merge(Node *cls, Node *am) {
+ Node *n;
+ Node *csym;
+
+ n = firstChild(am);
+ while (n) {
+ String *symname;
+ if (Strcmp(nodeType(n),"constructor") == 0) {
+ symname = Getattr(n,"sym:name");
+ if (symname) {
+ if (Strcmp(symname,Getattr(n,"name")) == 0) {
+ /* If the name and the sym:name of a constructor are the same,
+ then it hasn't been renamed. However---the name of the class
+ itself might have been renamed so we need to do a consistency
+ check here */
+ if (Getattr(cls,"sym:name")) {
+ Setattr(n,"sym:name", Getattr(cls,"sym:name"));
+ }
+ }
+ }
+ }
+
+ symname = Getattr(n,"sym:name");
+ DohIncref(symname);
+ if ((symname) && (!Getattr(n,"error"))) {
+ /* Remove node from its symbol table */
+ Swig_symbol_remove(n);
+ csym = Swig_symbol_add(symname,n);
+ if (csym != n) {
+ /* Conflict with previous definition. Nuke previous definition */
+ String *e = NewStringEmpty();
+ String *en = NewStringEmpty();
+ String *ec = NewStringEmpty();
+ Printf(ec,"Identifier '%s' redefined by %%extend (ignored),",symname);
+ Printf(en,"%%extend definition of '%s'.",symname);
+ SWIG_WARN_NODE_BEGIN(n);
+ Swig_warning(WARN_PARSE_REDEFINED,Getfile(csym),Getline(csym),"%s\n",ec);
+ Swig_warning(WARN_PARSE_REDEFINED,Getfile(n),Getline(n),"%s\n",en);
+ SWIG_WARN_NODE_END(n);
+ Printf(e,"%s:%d:%s\n%s:%d:%s\n",Getfile(csym),Getline(csym),ec,
+ Getfile(n),Getline(n),en);
+ Setattr(csym,"error",e);
+ Delete(e);
+ Delete(en);
+ Delete(ec);
+ Swig_symbol_remove(csym); /* Remove class definition */
+ Swig_symbol_add(symname,n); /* Insert extend definition */
+ }
+ }
+ n = nextSibling(n);
+ }
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_extend_append_previous()
+ * ----------------------------------------------------------------------------- */
+
+void Swig_extend_append_previous(Node *cls, Node *am) {
+ Node *n, *ne;
+ Node *pe = 0;
+ Node *ae = 0;
+
+ if (!am) return;
+
+ n = firstChild(am);
+ while (n) {
+ ne = nextSibling(n);
+ set_nextSibling(n,0);
+ /* typemaps and fragments need to be prepended */
+ if (((Cmp(nodeType(n),"typemap") == 0) || (Cmp(nodeType(n),"fragment") == 0))) {
+ if (!pe) pe = new_node("extend");
+ appendChild(pe, n);
+ } else {
+ if (!ae) ae = new_node("extend");
+ appendChild(ae, n);
+ }
+ n = ne;
+ }
+ if (pe) prependChild(cls,pe);
+ if (ae) appendChild(cls,ae);
+}
+
+
+/* -----------------------------------------------------------------------------
+ * Swig_extend_unused_check()
+ *
+ * Check for unused %extend. Special case, don't report unused
+ * extensions for templates
+ * ----------------------------------------------------------------------------- */
+
+void Swig_extend_unused_check(void) {
+ Iterator ki;
+
+ if (!extendhash) return;
+ for (ki = First(extendhash); ki.key; ki = Next(ki)) {
+ if (!Strchr(ki.key,'<')) {
+ SWIG_WARN_NODE_BEGIN(ki.item);
+ Swig_warning(WARN_PARSE_EXTEND_UNDEF,Getfile(ki.item), Getline(ki.item), "%%extend defined for an undeclared class %s.\n", SwigType_namestr(ki.key));
+ SWIG_WARN_NODE_END(ki.item);
+ }
+ }
+}
+
String *name = 0;
String *type = 0;
+ name = Getattr(n, "value");
+ if (!name) {
+ name = n;
+ }
+
if (!fragments) {
Swig_warning(WARN_FRAGMENT_NOT_FOUND, Getfile(n), Getline(n), "Fragment '%s' not found.\n", name);
return;
}
-
- name = Getattr(n, "value");
- if (!name) {
- name = n;
- }
type = Getattr(n, "type");
if (type) {
mangle = Swig_string_mangle(type);
lastpath = filename;
/* Skip the UTF-8 BOM if it's present */
- nbytes = fread(bom, 1, 3, f);
+ nbytes = (int)fread(bom, 1, 3, f);
if (nbytes == 3 && bom[0] == (char)0xEF && bom[1] == (char)0xBB && bom[2] == (char)0xBF) {
/* skip */
} else {
String *Swig_file_dirname(const_String_or_char_ptr filename) {
const char *delim = SWIG_FILE_DELIMITER;
const char *c = strrchr(Char(filename), *delim);
- return c ? NewStringWithSize(filename, c - Char(filename) + 1) : NewString("");
+ return c ? NewStringWithSize(filename, (int)(c - Char(filename) + 1)) : NewString("");
}
/*
}
if (comment_begin && comment_end) {
- int size = comment_begin - Char(s);
+ int size = (int)(comment_begin - Char(s));
String *stripmore = 0;
stripped = NewStringWithSize(s, size);
Printv(stripped, comment_end + 1, NIL);
}
/* -----------------------------------------------------------------------------
+ * Swig_storage_isextern()
+ *
+ * Determine if the storage class specifier is extern (but not externc)
+ * ----------------------------------------------------------------------------- */
+
+int Swig_storage_isextern(Node *n) {
+ const String *storage = Getattr(n, "storage");
+ return storage ? Strcmp(storage, "extern") == 0 || Strncmp(storage, "extern ", 7) == 0 : 0;
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_storage_isexternc()
+ *
+ * Determine if the storage class specifier is externc (but not plain extern)
+ * ----------------------------------------------------------------------------- */
+
+int Swig_storage_isexternc(Node *n) {
+ const String *storage = Getattr(n, "storage");
+ return storage ? Strcmp(storage, "externc") == 0 || Strncmp(storage, "externc ", 8) == 0 : 0;
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_storage_isstatic_custom()
+ *
+ * Determine if the storage class specifier is static
+ * ----------------------------------------------------------------------------- */
+
+int Swig_storage_isstatic_custom(Node *n, const_String_or_char_ptr storage_name) {
+ const String *storage = Getattr(n, storage_name);
+ return storage ? Strncmp(storage, "static", 6) == 0 : 0;
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_storage_isstatic()
+ *
+ * Determine if the storage class specifier is static
+ * ----------------------------------------------------------------------------- */
+
+int Swig_storage_isstatic(Node *n) {
+ return Swig_storage_isstatic_custom(n, "storage");
+}
+
+/* -----------------------------------------------------------------------------
* Swig_string_escape()
*
* Takes a string object and produces a string with escape codes added to it.
+ * Octal escaping is used.
* ----------------------------------------------------------------------------- */
String *Swig_string_escape(String *s) {
return ns;
}
+/* -----------------------------------------------------------------------------
+ * Swig_string_hexescape()
+ *
+ * Takes a string object and produces a string with escape codes added to it.
+ * Hex escaping is used.
+ * ----------------------------------------------------------------------------- */
+
+String *Swig_string_hexescape(String *s) {
+ String *ns;
+ int c;
+ ns = NewStringEmpty();
+
+ while ((c = Getc(s)) != EOF) {
+ if (c == '\n') {
+ Printf(ns, "\\n");
+ } else if (c == '\r') {
+ Printf(ns, "\\r");
+ } else if (c == '\t') {
+ Printf(ns, "\\t");
+ } else if (c == '\\') {
+ Printf(ns, "\\\\");
+ } else if (c == '\'') {
+ Printf(ns, "\\'");
+ } else if (c == '\"') {
+ Printf(ns, "\\\"");
+ } else if (c == ' ') {
+ Putc(c, ns);
+ } else if (!isgraph(c)) {
+ if (c < 0)
+ c += UCHAR_MAX + 1;
+ Printf(ns, "\\x%X", c);
+ } else {
+ Putc(c, ns);
+ }
+ }
+ return ns;
+}
/* -----------------------------------------------------------------------------
* Swig_string_upper()
*rlast = Copy(s);
return;
} else {
- *rprefix = NewStringWithSize(cc, co - cc - 2);
+ *rprefix = NewStringWithSize(cc, (int)(co - cc - 2));
*rlast = NewString(co);
return;
}
}
if (cc != tmp) {
- *rprefix = NewStringWithSize(tmp, cc - tmp);
+ *rprefix = NewStringWithSize(tmp, (int)(cc - tmp));
*rlast = NewString(cc + 2);
return;
} else {
if (co == cc) {
return 0;
} else {
- String *prefix = NewStringWithSize(cc, co - cc - 2);
+ String *prefix = NewStringWithSize(cc, (int)(co - cc - 2));
return prefix;
}
}
}
if (cc != tmp) {
- return NewStringWithSize(tmp, cc - tmp);
+ return NewStringWithSize(tmp, (int)(cc - tmp));
} else {
return 0;
}
}
}
if (*c && (c != tmp)) {
- return NewStringWithSize(tmp, c - tmp);
+ return NewStringWithSize(tmp, (int)(c - tmp));
} else {
return 0;
}
return ns;
}
+/* -----------------------------------------------------------------------------
+ * Swig_string_rstrip()
+ *
+ * Strip given suffix from identifiers
+ *
+ * Printf(stderr,"%(rstrip:[Cls])s","HelloCls") -> Hello
+ * ----------------------------------------------------------------------------- */
+
+String *Swig_string_rstrip(String *s) {
+ String *ns;
+ int len = Len(s);
+ if (!len) {
+ ns = NewString(s);
+ } else {
+ const char *cs = Char(s);
+ const char *ce = Strchr(cs, ']');
+ if (*cs != '[' || !ce) {
+ ns = NewString(s);
+ } else {
+ String *fmt = NewStringf("%%.%ds", ce-cs-1);
+ String *suffix = NewStringf(fmt, cs+1);
+ int suffix_len = Len(suffix);
+ if (0 == Strncmp(cs+len-suffix_len, suffix, suffix_len)) {
+ int copy_len = len-suffix_len-(ce+1-cs);
+ ns = NewStringWithSize(ce+1, copy_len);
+ } else {
+ ns = NewString(ce+1);
+ }
+ }
+ }
+ return ns;
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_offset_string()
+ *
+ * Insert number tabs before each new line in s
+ * ----------------------------------------------------------------------------- */
+
+void Swig_offset_string(String *s, int number) {
+ char *res, *p, *end, *start;
+ /* count a number of lines in s */
+ int lines = 1;
+ int len = Len(s);
+ if (len == 0)
+ return;
+ start = strchr(Char(s), '\n');
+ while (start) {
+ ++lines;
+ start = strchr(start + 1, '\n');
+ }
+ /* do not count pending new line */
+ if ((Char(s))[len-1] == '\n')
+ --lines;
+ /* allocate a temporary storage for a padded string */
+ res = (char*)malloc(len + lines * number * 2 + 1);
+ res[len + lines * number * 2] = 0;
+
+ /* copy lines to res, prepending tabs to each line */
+ p = res; /* output pointer */
+ start = Char(s); /* start of a current line */
+ end = strchr(start, '\n'); /* end of a current line */
+ while (end) {
+ memset(p, ' ', number*2);
+ p += number*2;
+ memcpy(p, start, end - start + 1);
+ p += end - start + 1;
+ start = end + 1;
+ end = strchr(start, '\n');
+ }
+ /* process the last line */
+ if (*start) {
+ memset(p, ' ', number*2);
+ p += number*2;
+ strcpy(p, start);
+ }
+ /* replace 's' contents with 'res' */
+ Clear(s);
+ Append(s, res);
+ free(res);
+}
+
#ifdef HAVE_PCRE
#include <pcre.h>
if (!p) goto err_out;
sube = p;
- *pattern = NewStringWithSize(pats, pate - pats);
- *subst = NewStringWithSize(subs, sube - subs);
+ *pattern = NewStringWithSize(pats, (int)(pate - pats));
+ *subst = NewStringWithSize(subs, (int)(sube - subs));
*input = p + 1;
return 1;
exit(1);
}
+/* This function copies len characters from src to dst, possibly applying case conversions to them: if convertCase is 1, to upper case and if it is -1, to lower
+ * case. If convertNextOnly is 1, only a single character is converted (and convertCase is reset), otherwise all of them are. */
+static void copy_with_maybe_case_conversion(String *dst, const char *src, int len, int *convertCase, int convertNextOnly)
+{
+ /* Deal with the trivial cases first. */
+ if (!len)
+ return;
+
+ if (!*convertCase) {
+ Write(dst, src, len);
+ return;
+ }
+
+ /* If we must convert only the first character, do it and write the rest at once. */
+ if (convertNextOnly) {
+ int src_char = *src;
+ Putc(*convertCase == 1 ? toupper(src_char) : tolower(src_char), dst);
+ *convertCase = 0;
+ if (len > 1) {
+ Write(dst, src + 1, len - 1);
+ }
+ } else {
+ /* We need to convert all characters. */
+ int i;
+ for (i = 0; i < len; i++, src++) {
+ int src_char = *src;
+ Putc(*convertCase == 1 ? toupper(src_char) : tolower(src_char), dst);
+ }
+ }
+}
+
String *replace_captures(int num_captures, const char *input, String *subst, int captures[], String *pattern, String *s)
{
+ int convertCase = 0, convertNextOnly = 0;
String *result = NewStringEmpty();
const char *p = Char(subst);
/* Copy part without substitutions */
const char *q = strchr(p, '\\');
if (!q) {
- Write(result, p, strlen(p));
+ copy_with_maybe_case_conversion(result, p, (int)strlen(p), &convertCase, convertNextOnly);
break;
}
- Write(result, p, q - p);
+ copy_with_maybe_case_conversion(result, p, (int)(q - p), &convertCase, convertNextOnly);
p = q + 1;
/* Handle substitution */
if (group < num_captures) {
int l = captures[group*2], r = captures[group*2 + 1];
if (l != -1) {
- Write(result, input + l, r - l);
+ copy_with_maybe_case_conversion(result, input + l, r - l, &convertCase, convertNextOnly);
}
} else {
Swig_error("SWIG", Getline(s), "PCRE capture replacement failed while matching \"%s\" using \"%s\" - request for group %d is greater than the number of captures %d.\n",
Char(pattern), input, group, num_captures-1);
}
+ } else {
+ /* Handle Perl-like case conversion escapes. */
+ switch (*p) {
+ case 'u':
+ convertCase = 1;
+ convertNextOnly = 1;
+ break;
+ case 'U':
+ convertCase = 1;
+ convertNextOnly = 0;
+ break;
+ case 'l':
+ convertCase = -1;
+ convertNextOnly = 1;
+ break;
+ case 'L':
+ convertCase = -1;
+ convertNextOnly = 0;
+ break;
+ case 'E':
+ convertCase = 0;
+ break;
+ default:
+ Swig_error("SWIG", Getline(s), "Unrecognized escape character '%c' in the replacement string \"%s\".\n",
+ *p, Char(subst));
+ }
+ p++;
}
}
*
* Executes a regular expression substitution. For example:
*
- * Printf(stderr,"gsl%(regex:/GSL_.*_/\\1/)s","GSL_Hello_") -> gslHello
+ * Printf(stderr,"gsl%(regex:/GSL_(.*)_/\\1/)s", "GSL_Hello_") -> gslHello
* ----------------------------------------------------------------------------- */
String *Swig_string_regex(String *s) {
const int pcre_options = 0;
pcre_error, Char(pattern), pcre_errorpos);
exit(1);
}
- rc = pcre_exec(compiled_pat, NULL, input, strlen(input), 0, 0, captures, 30);
+ rc = pcre_exec(compiled_pat, NULL, input, (int)strlen(input), 0, 0, captures, 30);
if (rc >= 0) {
res = replace_captures(rc, input, subst, captures, pattern, s);
} else if (rc != PCRE_ERROR_NOMATCH) {
void Swig_init() {
/* Set some useful string encoding methods */
DohEncoding("escape", Swig_string_escape);
+ DohEncoding("hexescape", Swig_string_hexescape);
DohEncoding("upper", Swig_string_upper);
DohEncoding("lower", Swig_string_lower);
DohEncoding("title", Swig_string_title);
DohEncoding("command", Swig_string_command);
DohEncoding("schemify", Swig_string_schemify);
DohEncoding("strip", Swig_string_strip);
+ DohEncoding("rstrip", Swig_string_rstrip);
DohEncoding("regex", Swig_string_regex);
/* aliases for the case encoders */
}
}
+/* Return naming format for the specified method or the default format if none was explicitly registered */
+static String* get_naming_format_for(const char *method, const char *def_format) {
+ String* f = naming_hash ? Getattr(naming_hash, method) : NULL;
+
+ return f ? Copy(f) : NewString(def_format);
+}
+
static int name_mangle(String *r) {
char *c;
int special;
* ----------------------------------------------------------------------------- */
String *Swig_name_wrapper(const_String_or_char_ptr fname) {
- String *r;
- String *f;
+ String *r = get_naming_format_for("wrapper", "_wrap_%f");
- r = NewStringEmpty();
- if (!naming_hash)
- naming_hash = NewHash();
- f = Getattr(naming_hash, "wrapper");
- if (!f) {
- Append(r, "_wrap_%f");
- } else {
- Append(r, f);
- }
Replace(r, "%f", fname, DOH_REPLACE_ANY);
name_mangle(r);
return r;
String *Swig_name_member(const_String_or_char_ptr nspace, const_String_or_char_ptr classname, const_String_or_char_ptr membername) {
String *r;
- String *f;
String *rclassname;
char *cname;
rclassname = SwigType_namestr(classname);
- r = NewStringEmpty();
- if (!naming_hash)
- naming_hash = NewHash();
- f = Getattr(naming_hash, "member");
- if (!f) {
- Append(r, "%n%c_%m");
- } else {
- Append(r, f);
- }
+ r = get_naming_format_for("member", "%n%c_%m");
cname = Char(rclassname);
if ((strncmp(cname, "struct ", 7) == 0) || ((strncmp(cname, "class ", 6) == 0)) || ((strncmp(cname, "union ", 6) == 0))) {
cname = strchr(cname, ' ') + 1;
* ----------------------------------------------------------------------------- */
String *Swig_name_get(const_String_or_char_ptr nspace, const_String_or_char_ptr vname) {
- String *r;
- String *f;
+ String *r = get_naming_format_for("get", "%n%v_get");
#ifdef SWIG_DEBUG
Printf(stdout, "Swig_name_get: '%s'\n", vname);
#endif
- r = NewStringEmpty();
- if (!naming_hash)
- naming_hash = NewHash();
- f = Getattr(naming_hash, "get");
- if (!f) {
- Append(r, "%n%v_get");
- } else {
- Append(r, f);
- }
-
replace_nspace(r, nspace);
Replace(r, "%v", vname, DOH_REPLACE_ANY);
/* name_mangle(r); */
* ----------------------------------------------------------------------------- */
String *Swig_name_set(const_String_or_char_ptr nspace, const_String_or_char_ptr vname) {
- String *r;
- String *f;
-
- r = NewStringEmpty();
- if (!naming_hash)
- naming_hash = NewHash();
- f = Getattr(naming_hash, "set");
- if (!f) {
- Append(r, "%n%v_set");
- } else {
- Append(r, f);
- }
+ String *r = get_naming_format_for("set", "%n%v_set");
replace_nspace(r, nspace);
Replace(r, "%v", vname, DOH_REPLACE_ANY);
return r;
}
-/* -----------------------------------------------------------------------------
- * Swig_name_construct()
- *
- * Returns the name of the accessor function used to create an object.
- * ----------------------------------------------------------------------------- */
-
-String *Swig_name_construct(const_String_or_char_ptr nspace, const_String_or_char_ptr classname) {
+/* Common implementation of all Swig_name_<special-method>() functions below. */
+static String *make_full_name_for(const char *method, const char *def_format, const_String_or_char_ptr nspace, const_String_or_char_ptr classname) {
String *r;
- String *f;
String *rclassname;
char *cname;
rclassname = SwigType_namestr(classname);
- r = NewStringEmpty();
- if (!naming_hash)
- naming_hash = NewHash();
- f = Getattr(naming_hash, "construct");
- if (!f) {
- Append(r, "new_%n%c");
- } else {
- Append(r, f);
- }
+ r = get_naming_format_for(method, def_format);
cname = Char(rclassname);
if ((strncmp(cname, "struct ", 7) == 0) || ((strncmp(cname, "class ", 6) == 0)) || ((strncmp(cname, "union ", 6) == 0))) {
return r;
}
+/* -----------------------------------------------------------------------------
+ * Swig_name_construct()
+ *
+ * Returns the name of the accessor function used to create an object.
+ * ----------------------------------------------------------------------------- */
+
+String *Swig_name_construct(const_String_or_char_ptr nspace, const_String_or_char_ptr classname) {
+ return make_full_name_for("construct", "new_%n%c", nspace, classname);
+}
+
/* -----------------------------------------------------------------------------
* Swig_name_copyconstructor()
* ----------------------------------------------------------------------------- */
String *Swig_name_copyconstructor(const_String_or_char_ptr nspace, const_String_or_char_ptr classname) {
- String *r;
- String *f;
- String *rclassname;
- char *cname;
-
- rclassname = SwigType_namestr(classname);
- r = NewStringEmpty();
- if (!naming_hash)
- naming_hash = NewHash();
- f = Getattr(naming_hash, "copy");
- if (!f) {
- Append(r, "copy_%n%c");
- } else {
- Append(r, f);
- }
-
- cname = Char(rclassname);
- if ((strncmp(cname, "struct ", 7) == 0) || ((strncmp(cname, "class ", 6) == 0)) || ((strncmp(cname, "union ", 6) == 0))) {
- cname = strchr(cname, ' ') + 1;
- }
-
- replace_nspace(r, nspace);
- Replace(r, "%c", cname, DOH_REPLACE_ANY);
- Delete(rclassname);
- return r;
+ return make_full_name_for("copy", "copy_%n%c", nspace, classname);
}
/* -----------------------------------------------------------------------------
* ----------------------------------------------------------------------------- */
String *Swig_name_destroy(const_String_or_char_ptr nspace, const_String_or_char_ptr classname) {
- String *r;
- String *f;
- String *rclassname;
- char *cname;
- rclassname = SwigType_namestr(classname);
- r = NewStringEmpty();
- if (!naming_hash)
- naming_hash = NewHash();
- f = Getattr(naming_hash, "destroy");
- if (!f) {
- Append(r, "delete_%n%c");
- } else {
- Append(r, f);
- }
-
- cname = Char(rclassname);
- if ((strncmp(cname, "struct ", 7) == 0) || ((strncmp(cname, "class ", 6) == 0)) || ((strncmp(cname, "union ", 6) == 0))) {
- cname = strchr(cname, ' ') + 1;
- }
-
- replace_nspace(r, nspace);
- Replace(r, "%c", cname, DOH_REPLACE_ANY);
- Delete(rclassname);
- return r;
+ return make_full_name_for("destroy", "delete_%n%c", nspace, classname);
}
* ----------------------------------------------------------------------------- */
String *Swig_name_disown(const_String_or_char_ptr nspace, const_String_or_char_ptr classname) {
- String *r;
- String *f;
- String *rclassname;
- char *cname;
- rclassname = SwigType_namestr(classname);
- r = NewStringEmpty();
- if (!naming_hash)
- naming_hash = NewHash();
- f = Getattr(naming_hash, "disown");
- if (!f) {
- Append(r, "disown_%n%c");
- } else {
- Append(r, f);
- }
-
- cname = Char(rclassname);
- if ((strncmp(cname, "struct ", 7) == 0) || ((strncmp(cname, "class ", 6) == 0)) || ((strncmp(cname, "union ", 6) == 0))) {
- cname = strchr(cname, ' ') + 1;
- }
-
- replace_nspace(r, nspace);
- Replace(r, "%c", cname, DOH_REPLACE_ANY);
- Delete(rclassname);
- return r;
+ return make_full_name_for("disown", "disown_%n%c", nspace, classname);
}
return rn;
}
-static
-DOH *name_object_get(Hash *namehash, String *tname, SwigType *decl, SwigType *ncdecl) {
+static DOH *name_object_get(Hash *namehash, String *tname, SwigType *decl, SwigType *ncdecl) {
DOH *rn = 0;
Hash *n = Getattr(namehash, tname);
if (n) {
bprefix = NewStringf("%s::", base);
dprefix = NewStringf("%s::", derived);
cbprefix = Char(bprefix);
- plen = strlen(cbprefix);
+ plen = (int)strlen(cbprefix);
for (ki = First(namehash); ki.key; ki = Next(ki)) {
char *k = Char(ki.key);
if (strncmp(k, cbprefix, plen) == 0) {
* the declaration, decl.
* ----------------------------------------------------------------------------- */
-static
-void features_get(Hash *features, const String *tname, SwigType *decl, SwigType *ncdecl, Node *node) {
+static void features_get(Hash *features, const String *tname, SwigType *decl, SwigType *ncdecl, Node *node) {
Node *n = Getattr(features, tname);
#ifdef SWIG_DEBUG
Printf(stdout, " features_get: %s\n", tname);
* concatenating the feature name plus ':' plus the attribute name.
* ----------------------------------------------------------------------------- */
-void Swig_feature_set(Hash *features, const_String_or_char_ptr name, SwigType *decl, const_String_or_char_ptr featurename, String *value, Hash *featureattribs) {
+void Swig_feature_set(Hash *features, const_String_or_char_ptr name, SwigType *decl, const_String_or_char_ptr featurename, const_String_or_char_ptr value, Hash *featureattribs) {
Hash *n;
Hash *fhash;
* ----------------------------------------------------------------------------- */
static Hash *namewarn_hash = 0;
-Hash *Swig_name_namewarn_hash() {
+static Hash *name_namewarn_hash() {
if (!namewarn_hash)
namewarn_hash = NewHash();
return namewarn_hash;
}
static Hash *rename_hash = 0;
-Hash *Swig_name_rename_hash() {
+static Hash *name_rename_hash() {
if (!rename_hash)
rename_hash = NewHash();
return rename_hash;
}
static List *namewarn_list = 0;
-List *Swig_name_namewarn_list() {
+static List *name_namewarn_list() {
if (!namewarn_list)
namewarn_list = NewList();
return namewarn_list;
}
static List *rename_list = 0;
-List *Swig_name_rename_list() {
+static List *name_rename_list() {
if (!rename_list)
rename_list = NewList();
return rename_list;
}
/* -----------------------------------------------------------------------------
- * int Swig_need_name_warning(Node *n)
+ * int need_name_warning(Node *n)
*
* Detects if a node needs name warnings
*
* ----------------------------------------------------------------------------- */
-int Swig_need_name_warning(Node *n) {
+static int need_name_warning(Node *n) {
int need = 1;
/*
We don't use name warnings for:
}
/* static functions */
- if ((Cmp(a_storage, "static") == 0)
- || (Cmp(b_storage, "static") == 0)) {
+ if (Swig_storage_isstatic(a) || Swig_storage_isstatic(b)) {
if (Cmp(a_storage, b_storage) != 0)
return 0;
}
}
return 0;
}
+ if (Equal(ta, "template") && Equal(tb, "template")) {
+ if (Cmp(a_storage, "friend") == 0 || Cmp(b_storage, "friend") == 0)
+ return 1;
+ }
}
return 0;
}
}
/* -----------------------------------------------------------------------------
- * void Swig_name_nameobj_add()
+ * void name_nameobj_add()
*
* Add nameobj (rename/namewarn)
*
* ----------------------------------------------------------------------------- */
-static List *Swig_make_attrlist(const char *ckey) {
+static List *make_attrlist(const char *ckey) {
List *list = NewList();
const char *cattr = strchr(ckey, '$');
if (cattr) {
String *nattr;
const char *rattr = strchr(++cattr, '$');
while (rattr) {
- nattr = NewStringWithSize(cattr, rattr - cattr);
+ nattr = NewStringWithSize(cattr, (int)(rattr - cattr));
Append(list, nattr);
Delete(nattr);
cattr = rattr + 1;
return list;
}
-static void Swig_name_object_attach_keys(const char *keys[], Hash *nameobj) {
+static void name_object_attach_keys(const char *keys[], Hash *nameobj) {
Node *kw = nextSibling(nameobj);
List *matchlist = 0;
while (kw) {
|| (isregexmatch = (strncmp(ckey, "regexmatch", 10) == 0))
|| (isnotmatch = isregexmatch = (strncmp(ckey, "notregexmatch", 13) == 0))) {
Hash *mi = NewHash();
- List *attrlist = Swig_make_attrlist(ckey);
+ List *attrlist = make_attrlist(ckey);
if (!matchlist)
matchlist = NewList();
Setattr(mi, "value", Getattr(kw, "value"));
}
}
-void Swig_name_nameobj_add(Hash *name_hash, List *name_list, String *prefix, String *name, SwigType *decl, Hash *nameobj) {
+static void name_nameobj_add(Hash *name_hash, List *name_list, String *prefix, String *name, SwigType *decl, Hash *nameobj) {
String *nname = 0;
if (name && Len(name)) {
String *target_fmt = Getattr(nameobj, "targetfmt");
}
/* -----------------------------------------------------------------------------
- * int Swig_name_match_nameobj()
+ * int name_match_nameobj()
*
* Apply and check the nameobj's math list to the node
*
* ----------------------------------------------------------------------------- */
-static DOH *Swig_get_lattr(Node *n, List *lattr) {
+static DOH *get_lattr(Node *n, List *lattr) {
DOH *res = 0;
int ilen = Len(lattr);
int i;
#ifdef HAVE_PCRE
#include <pcre.h>
-int Swig_name_regexmatch_value(Node *n, String *pattern, String *s) {
+static int name_regexmatch_value(Node *n, String *pattern, String *s) {
pcre *compiled_pat;
const char *err;
int errpos;
#else /* !HAVE_PCRE */
-int Swig_name_regexmatch_value(Node *n, String *pattern, String *s) {
+static int name_regexmatch_value(Node *n, String *pattern, String *s) {
(void)pattern;
(void)s;
Swig_error("SWIG", Getline(n),
#endif /* HAVE_PCRE/!HAVE_PCRE */
-int Swig_name_match_value(String *mvalue, String *value) {
+static int name_match_value(String *mvalue, String *value) {
#if defined(SWIG_USE_SIMPLE_MATCHOR)
int match = 0;
char *cvalue = Char(value);
#endif
}
-
-int Swig_name_match_nameobj(Hash *rn, Node *n) {
+static int name_match_nameobj(Hash *rn, Node *n) {
int match = 1;
List *matchlist = Getattr(rn, "matchlist");
#ifdef SWIG_DEBUG
- Printf(stdout, "Swig_name_match_nameobj: %s\n", Getattr(n, "name"));
+ Printf(stdout, "name_match_nameobj: %s\n", Getattr(n, "name"));
#endif
if (matchlist) {
int ilen = Len(matchlist);
for (i = 0; match && (i < ilen); ++i) {
Node *mi = Getitem(matchlist, i);
List *lattr = Getattr(mi, "attrlist");
- String *nval = Swig_get_lattr(n, lattr);
+ String *nval = get_lattr(n, lattr);
int notmatch = GetFlag(mi, "notmatch");
int regexmatch = GetFlag(mi, "regexmatch");
match = 0;
if (nval) {
String *kwval = Getattr(mi, "value");
- match = regexmatch ? Swig_name_regexmatch_value(n, kwval, nval)
- : Swig_name_match_value(kwval, nval);
+ match = regexmatch ? name_regexmatch_value(n, kwval, nval)
+ : name_match_value(kwval, nval);
#ifdef SWIG_DEBUG
Printf(stdout, "val %s %s %d %d \n", nval, kwval, match, ilen);
#endif
}
}
#ifdef SWIG_DEBUG
- Printf(stdout, "Swig_name_match_nameobj: %d\n", match);
+ Printf(stdout, "name_match_nameobj: %d\n", match);
#endif
return match;
}
/* -----------------------------------------------------------------------------
- * Hash *Swig_name_nameobj_lget()
+ * Hash *name_nameobj_lget()
*
* Get a nameobj (rename/namewarn) from the list of filters
*
* ----------------------------------------------------------------------------- */
-Hash *Swig_name_nameobj_lget(List *namelist, Node *n, String *prefix, String *name, String *decl) {
+static Hash *name_nameobj_lget(List *namelist, Node *n, String *prefix, String *name, String *decl) {
Hash *res = 0;
if (namelist) {
int len = Len(namelist);
String *rdecl = Getattr(rn, "decl");
if (rdecl && (!decl || !Equal(rdecl, decl))) {
continue;
- } else if (Swig_name_match_nameobj(rn, n)) {
+ } else if (name_match_nameobj(rn, n)) {
String *tname = Getattr(rn, "targetname");
if (tname) {
String *sfmt = Getattr(rn, "sourcefmt");
DohIncref(name);
}
}
- match = regextarget ? Swig_name_regexmatch_value(n, tname, sname)
- : Swig_name_match_value(tname, sname);
+ match = regextarget ? name_regexmatch_value(n, tname, sname)
+ : name_match_value(tname, sname);
Delete(sname);
} else {
/* Applying the renaming rule may fail if it contains a %(regex)s expression that doesn't match the given name. */
void Swig_name_namewarn_add(String *prefix, String *name, SwigType *decl, Hash *namewrn) {
const char *namewrn_keys[] = { "rename", "error", "fullname", "sourcefmt", "targetfmt", 0 };
- Swig_name_object_attach_keys(namewrn_keys, namewrn);
- Swig_name_nameobj_add(Swig_name_namewarn_hash(), Swig_name_namewarn_list(), prefix, name, decl, namewrn);
+ name_object_attach_keys(namewrn_keys, namewrn);
+ name_nameobj_add(name_namewarn_hash(), name_namewarn_list(), prefix, name, decl, namewrn);
}
/* -----------------------------------------------------------------------------
- * Hash *Swig_name_namewarn_get()
+ * Hash *name_namewarn_get()
*
* Return the namewarn object, if there is one.
*
* ----------------------------------------------------------------------------- */
-Hash *Swig_name_namewarn_get(Node *n, String *prefix, String *name, SwigType *decl) {
+static Hash *name_namewarn_get(Node *n, String *prefix, String *name, SwigType *decl) {
if (!namewarn_hash && !namewarn_list)
return 0;
if (n) {
/* Return in the obvious cases */
- if (!name || !Swig_need_name_warning(n)) {
+ if (!name || !need_name_warning(n)) {
return 0;
} else {
String *access = Getattr(n, "access");
}
if (name) {
/* Check to see if the name is in the hash */
- Hash *wrn = Swig_name_object_get(Swig_name_namewarn_hash(), prefix, name, decl);
- if (wrn && !Swig_name_match_nameobj(wrn, n))
+ Hash *wrn = Swig_name_object_get(name_namewarn_hash(), prefix, name, decl);
+ if (wrn && !name_match_nameobj(wrn, n))
wrn = 0;
if (!wrn) {
- wrn = Swig_name_nameobj_lget(Swig_name_namewarn_list(), n, prefix, name, decl);
+ wrn = name_nameobj_lget(name_namewarn_list(), n, prefix, name, decl);
}
if (wrn && Getattr(wrn, "error")) {
if (n) {
* ----------------------------------------------------------------------------- */
String *Swig_name_warning(Node *n, String *prefix, String *name, SwigType *decl) {
- Hash *wrn = Swig_name_namewarn_get(n, prefix, name, decl);
+ Hash *wrn = name_namewarn_get(n, prefix, name, decl);
return (name && wrn) ? Getattr(wrn, "name") : 0;
}
* ----------------------------------------------------------------------------- */
static void single_rename_add(String *prefix, String *name, SwigType *decl, Hash *newname) {
- Swig_name_nameobj_add(Swig_name_rename_hash(), Swig_name_rename_list(), prefix, name, decl, newname);
+ name_nameobj_add(name_rename_hash(), name_rename_list(), prefix, name, decl, newname);
}
/* Add a new rename. Works much like new_feature including default argument handling. */
ParmList *declparms = declaratorparms;
const char *rename_keys[] = { "fullname", "sourcefmt", "targetfmt", "continue", "regextarget", 0 };
- Swig_name_object_attach_keys(rename_keys, newname);
+ name_object_attach_keys(rename_keys, newname);
/* Add the name */
single_rename_add(prefix, name, decl, newname);
}
}
-
if (rename_hash || rename_list || namewarn_hash || namewarn_list) {
- Hash *rn = Swig_name_object_get(Swig_name_rename_hash(), prefix, name, decl);
- if (!rn || !Swig_name_match_nameobj(rn, n)) {
- rn = Swig_name_nameobj_lget(Swig_name_rename_list(), n, prefix, name, decl);
+ Hash *rn = Swig_name_object_get(name_rename_hash(), prefix, name, decl);
+ if (!rn || !name_match_nameobj(rn, n)) {
+ rn = name_nameobj_lget(name_rename_list(), n, prefix, name, decl);
if (rn) {
String *sfmt = Getattr(rn, "sourcefmt");
int fullname = GetFlag(rn, "fullname");
}
}
nname = result ? result : name;
- wrn = Swig_name_namewarn_get(n, prefix, nname, decl);
+ wrn = name_namewarn_get(n, prefix, nname, decl);
if (wrn) {
String *rename = Getattr(wrn, "rename");
if (rename) {
/* -----------------------------------------------------------------------------
* void Swig_name_inherit()
*
- * Inherit namewarn,rename, and feature objects
+ * Inherit namewarn, rename, and feature objects
*
* ----------------------------------------------------------------------------- */
void Swig_name_inherit(String *base, String *derived) {
/* Printf(stdout,"base = '%s', derived = '%s'\n", base, derived); */
- Swig_name_object_inherit(Swig_name_rename_hash(), base, derived);
- Swig_name_object_inherit(Swig_name_namewarn_hash(), base, derived);
+ Swig_name_object_inherit(name_rename_hash(), base, derived);
+ Swig_name_object_inherit(name_namewarn_hash(), base, derived);
Swig_name_object_inherit(Swig_cparse_features(), base, derived);
}
/* -----------------------------------------------------------------------------
+ * Swig_inherit_base_symbols()
+ * ----------------------------------------------------------------------------- */
+
+void Swig_inherit_base_symbols(List *bases) {
+ if (bases) {
+ Iterator s;
+ for (s = First(bases); s.item; s = Next(s)) {
+ Symtab *st = Getattr(s.item, "symtab");
+ if (st) {
+ Setfile(st, Getfile(s.item));
+ Setline(st, Getline(s.item));
+ Swig_symbol_inherit(st);
+ }
+ }
+ Delete(bases);
+ }
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_make_inherit_list()
+ * ----------------------------------------------------------------------------- */
+
+List *Swig_make_inherit_list(String *clsname, List *names, String *Namespaceprefix) {
+ int i, ilen;
+ String *derived;
+ List *bases = NewList();
+
+ if (Namespaceprefix)
+ derived = NewStringf("%s::%s", Namespaceprefix, clsname);
+ else
+ derived = NewString(clsname);
+
+ ilen = Len(names);
+ for (i = 0; i < ilen; i++) {
+ String *base;
+ String *n = Getitem(names, i);
+ /* Try to figure out where this symbol is */
+ Node *s = Swig_symbol_clookup(n, 0);
+ if (s) {
+ while (s && (Strcmp(nodeType(s), "class") != 0)) {
+ /* Not a class. Could be a typedef though. */
+ String *storage = Getattr(s, "storage");
+ if (storage && (Strcmp(storage, "typedef") == 0)) {
+ String *nn = Getattr(s, "type");
+ s = Swig_symbol_clookup(nn, Getattr(s, "sym:symtab"));
+ } else {
+ break;
+ }
+ }
+ if (s && ((Strcmp(nodeType(s), "class") == 0) || (Strcmp(nodeType(s), "template") == 0))) {
+ String *q = Swig_symbol_qualified(s);
+ Append(bases, s);
+ if (q) {
+ base = NewStringf("%s::%s", q, Getattr(s, "name"));
+ Delete(q);
+ } else {
+ base = NewString(Getattr(s, "name"));
+ }
+ } else {
+ base = NewString(n);
+ }
+ } else {
+ base = NewString(n);
+ }
+ if (base) {
+ Swig_name_inherit(base, derived);
+ Delete(base);
+ }
+ }
+ return bases;
+}
+
+
+/* -----------------------------------------------------------------------------
* void Swig_name_str()
*
* Return a stringified version of a C/C++ symbol from a node.
String *error; /* Last error message (if any) */
int error_line; /* Error line number */
int freeze_line; /* Suspend line number updates */
+ List *brackets; /* Current level of < > brackets on each level */
};
typedef struct Locator {
} Locator;
static int follow_locators = 0;
+static void brackets_push(Scanner *);
+static void brackets_clear(Scanner *);
+
/* -----------------------------------------------------------------------------
* NewScanner()
*
s->error = 0;
s->error_line = 0;
s->freeze_line = 0;
+ s->brackets = NewList();
+ brackets_push(s);
return s;
}
* Delete a scanner object.
* ----------------------------------------------------------------------------- */
-void DelScanner(Scanner * s) {
+void DelScanner(Scanner *s) {
assert(s);
Delete(s->scanobjs);
+ Delete(s->brackets);
Delete(s->text);
Delete(s->file);
Delete(s->error);
Delete(s->str);
free(s->idstart);
- free(s);
+ free(s);
}
/* -----------------------------------------------------------------------------
* Clear the contents of a scanner object.
* ----------------------------------------------------------------------------- */
-void Scanner_clear(Scanner * s) {
+void Scanner_clear(Scanner *s) {
assert(s);
Delete(s->str);
Clear(s->text);
Clear(s->scanobjs);
+ brackets_clear(s);
Delete(s->error);
s->str = 0;
s->error = 0;
* immediately before returning to the old text.
* ----------------------------------------------------------------------------- */
-void Scanner_push(Scanner * s, String *txt) {
+void Scanner_push(Scanner *s, String *txt) {
assert(s && txt);
Push(s->scanobjs, txt);
if (s->str) {
* call to Scanner_token().
* ----------------------------------------------------------------------------- */
-void Scanner_pushtoken(Scanner * s, int nt, const_String_or_char_ptr val) {
+void Scanner_pushtoken(Scanner *s, int nt, const_String_or_char_ptr val) {
assert(s);
assert((nt >= 0) && (nt < SWIG_MAXTOKENS));
s->nexttoken = nt;
* Set the file and line number location of the scanner.
* ----------------------------------------------------------------------------- */
-void Scanner_set_location(Scanner * s, String *file, int line) {
+void Scanner_set_location(Scanner *s, String *file, int line) {
Setline(s->str, line);
Setfile(s->str, file);
s->line = line;
* Get the current file.
* ----------------------------------------------------------------------------- */
-String *Scanner_file(Scanner * s) {
+String *Scanner_file(Scanner *s) {
return Getfile(s->str);
}
*
* Get the current line number
* ----------------------------------------------------------------------------- */
-int Scanner_line(Scanner * s) {
+int Scanner_line(Scanner *s) {
return s->line;
}
*
* Get the line number on which the current token starts
* ----------------------------------------------------------------------------- */
-int Scanner_start_line(Scanner * s) {
+int Scanner_start_line(Scanner *s) {
return s->start_line;
}
* Change the set of additional characters that can be used to start an identifier.
* ----------------------------------------------------------------------------- */
-void Scanner_idstart(Scanner * s, const char *id) {
+void Scanner_idstart(Scanner *s, const char *id) {
free(s->idstart);
s->idstart = Swig_copy_string(id);
}
*
* Returns the next character from the scanner or 0 if end of the string.
* ----------------------------------------------------------------------------- */
-static char nextchar(Scanner * s) {
+static char nextchar(Scanner *s) {
int nc;
if (!s->str)
return 0;
return s->error;
}
-int
-Scanner_errline(Scanner *s) {
+int Scanner_errline(Scanner *s) {
return s->error_line;
}
}
/* -----------------------------------------------------------------------------
+ * brackets_count()
+ *
+ * Returns the number of brackets at the current depth.
+ * A syntax error with unbalanced ) brackets will result in a NULL pointer return.
+ * ----------------------------------------------------------------------------- */
+static int *brackets_count(Scanner *s) {
+ int *count;
+ if (Len(s->brackets) > 0)
+ count = (int *)Data(Getitem(s->brackets, 0));
+ else
+ count = 0;
+ return count;
+}
+
+/* -----------------------------------------------------------------------------
+ * brackets_clear()
+ *
+ * Resets the current depth and clears all brackets.
+ * Usually called at the end of statements;
+ * ----------------------------------------------------------------------------- */
+static void brackets_clear(Scanner *s) {
+ Clear(s->brackets);
+ brackets_push(s); /* base bracket count should always be created */
+}
+
+/* -----------------------------------------------------------------------------
+ * brackets_increment()
+ *
+ * Increases the number of brackets at the current depth.
+ * Usually called when a single '<' is found.
+ * ----------------------------------------------------------------------------- */
+static void brackets_increment(Scanner *s) {
+ int *count = brackets_count(s);
+ if (count)
+ (*count)++;
+}
+
+/* -----------------------------------------------------------------------------
+ * brackets_decrement()
+ *
+ * Decreases the number of brackets at the current depth.
+ * Usually called when a single '>' is found.
+ * ----------------------------------------------------------------------------- */
+static void brackets_decrement(Scanner *s) {
+ int *count = brackets_count(s);
+ if (count)
+ (*count)--;
+}
+
+/* -----------------------------------------------------------------------------
+ * brackets_reset()
+ *
+ * Sets the number of '<' brackets back to zero. Called at the point where
+ * it is no longer possible to have a matching closing >> pair for a template.
+ * ----------------------------------------------------------------------------- */
+static void brackets_reset(Scanner *s) {
+ int *count = brackets_count(s);
+ if (count)
+ *count = 0;
+}
+
+/* -----------------------------------------------------------------------------
+ * brackets_push()
+ *
+ * Increases the depth of brackets.
+ * Usually called when '(' is found.
+ * ----------------------------------------------------------------------------- */
+static void brackets_push(Scanner *s) {
+ int *newInt = (int *)malloc(sizeof(int));
+ *newInt = 0;
+ Push(s->brackets, NewVoid(newInt, free));
+}
+
+/* -----------------------------------------------------------------------------
+ * brackets_pop()
+ *
+ * Decreases the depth of brackets.
+ * Usually called when ')' is found.
+ * ----------------------------------------------------------------------------- */
+static void brackets_pop(Scanner *s) {
+ if (Len(s->brackets) > 0) /* protect against unbalanced ')' brackets */
+ Delitem(s->brackets, 0);
+}
+
+/* -----------------------------------------------------------------------------
+ * brackets_allow_shift()
+ *
+ * Return 1 to allow shift (>>), or 0 if (>>) should be split into (> >).
+ * This is for C++11 template syntax for closing templates.
+ * ----------------------------------------------------------------------------- */
+static int brackets_allow_shift(Scanner *s) {
+ int *count = brackets_count(s);
+ return !count || (*count <= 0);
+}
+
+/* -----------------------------------------------------------------------------
* retract()
*
* Retract n characters
* ----------------------------------------------------------------------------- */
-static void retract(Scanner * s, int n) {
+static void retract(Scanner *s, int n) {
int i, l;
char *str;
* Return the raw value of the next token.
* ----------------------------------------------------------------------------- */
-static int look(Scanner * s) {
- int state;
+static int look(Scanner *s) {
+ int state = 0;
int c = 0;
+ String *str_delimiter = 0;
- state = 0;
Clear(s->text);
s->start_line = s->line;
Setfile(s->text, Getfile(s->str));
+
+
while (1) {
switch (state) {
case 0:
case 1000:
if ((c = nextchar(s)) == 0)
- return (0);
+ return (0);
if (c == '%')
state = 4; /* Possibly a SWIG directive */
-
- /* Look for possible identifiers */
-
+
+ /* Look for possible identifiers or unicode/delimiter strings */
else if ((isalpha(c)) || (c == '_') ||
- (s->idstart && strchr(s->idstart, c)))
+ (s->idstart && strchr(s->idstart, c))) {
state = 7;
+ }
/* Look for single character symbols */
- else if (c == '(')
+ else if (c == '(') {
+ brackets_push(s);
return SWIG_TOKEN_LPAREN;
- else if (c == ')')
+ }
+ else if (c == ')') {
+ brackets_pop(s);
return SWIG_TOKEN_RPAREN;
- else if (c == ';')
+ }
+ else if (c == ';') {
+ brackets_clear(s);
return SWIG_TOKEN_SEMI;
+ }
else if (c == ',')
return SWIG_TOKEN_COMMA;
else if (c == '*')
state = 220;
else if (c == '}')
return SWIG_TOKEN_RBRACE;
- else if (c == '{')
+ else if (c == '{') {
+ brackets_reset(s);
return SWIG_TOKEN_LBRACE;
+ }
else if (c == '=')
state = 33;
else if (c == '+')
state = 1; /* Comment (maybe) */
s->start_line = s->line;
}
- else if (c == '\"') {
- state = 2; /* Possibly a string */
- s->start_line = s->line;
- Clear(s->text);
- }
else if (c == ':')
state = 5; /* maybe double colon */
else if (c == '0')
state = 83; /* An octal or hex value */
+ else if (c == '\"') {
+ state = 2; /* A string constant */
+ s->start_line = s->line;
+ Clear(s->text);
+ }
else if (c == '\'') {
s->start_line = s->line;
Clear(s->text);
break;
case 2: /* Processing a string */
+ if (!str_delimiter) {
+ state=20;
+ break;
+ }
+
if ((c = nextchar(s)) == 0) {
Swig_error(cparse_file, cparse_start_line, "Unterminated string\n");
return SWIG_TOKEN_ERROR;
}
- if (c == '\"') {
- Delitem(s->text, DOH_END);
- return SWIG_TOKEN_STRING;
- } else if (c == '\\') {
- Delitem(s->text, DOH_END);
- get_escape(s);
- } else
- state = 2;
+ else if (c == '(') {
+ state = 20;
+ }
+ else {
+ char temp[2] = { 0, 0 };
+ temp[0] = c;
+ Append( str_delimiter, temp );
+ }
+
+ break;
+
+ case 20: /* Inside the string */
+ if ((c = nextchar(s)) == 0) {
+ Swig_error(cparse_file, cparse_start_line, "Unterminated string\n");
+ return SWIG_TOKEN_ERROR;
+ }
+
+ if (!str_delimiter) { /* Ordinary string: "value" */
+ if (c == '\"') {
+ Delitem(s->text, DOH_END);
+ return SWIG_TOKEN_STRING;
+ } else if (c == '\\') {
+ Delitem(s->text, DOH_END);
+ get_escape(s);
+ }
+ } else { /* Custom delimiter string: R"XXXX(value)XXXX" */
+ if (c==')') {
+ int i=0;
+ String *end_delimiter = NewStringEmpty();
+ while ((c = nextchar(s)) != 0 && c!='\"') {
+ char temp[2] = { 0, 0 };
+ temp[0] = c;
+ Append( end_delimiter, temp );
+ i++;
+ }
+
+ if (Strcmp( str_delimiter, end_delimiter )==0) {
+ Delete( end_delimiter ); /* Correct end delimiter )XXXX" occured */
+ Delete( str_delimiter );
+ str_delimiter = 0;
+ return SWIG_TOKEN_STRING;
+ } else { /* Incorrect end delimiter occured */
+ retract( s, i );
+ Delete( end_delimiter );
+ }
+ }
+ }
+
break;
case 3: /* Maybe a not equals */
state = 7;
} else if (c == '=') {
return SWIG_TOKEN_MODEQUAL;
+ } else if (c == '}') {
+ Swig_error(cparse_file, cparse_line, "Syntax error. Extraneous '%%}'\n");
+ exit(1);
} else {
retract(s, 1);
return SWIG_TOKEN_PERCENT;
break;
case 60: /* shift operators */
- if ((c = nextchar(s)) == 0)
+ if ((c = nextchar(s)) == 0) {
+ brackets_increment(s);
return SWIG_TOKEN_LESSTHAN;
+ }
if (c == '<')
state = 240;
else if (c == '=')
return SWIG_TOKEN_LTEQUAL;
else {
retract(s, 1);
+ brackets_increment(s);
return SWIG_TOKEN_LESSTHAN;
}
break;
case 61:
- if ((c = nextchar(s)) == 0)
+ if ((c = nextchar(s)) == 0) {
+ brackets_decrement(s);
return SWIG_TOKEN_GREATERTHAN;
- if (c == '>')
+ }
+ if (c == '>' && brackets_allow_shift(s))
state = 250;
else if (c == '=')
return SWIG_TOKEN_GTEQUAL;
else {
retract(s, 1);
+ brackets_decrement(s);
return SWIG_TOKEN_GREATERTHAN;
}
break;
- case 7: /* Identifier */
- if ((c = nextchar(s)) == 0)
+
+ case 7: /* Identifier or true/false or unicode/custom delimiter string */
+ if (c == 'R') { /* Possibly CUSTOM DELIMITER string */
+ state = 72;
+ break;
+ }
+ else if (c == 'L') { /* Probably identifier but may be a wide string literal */
+ state = 77;
+ break;
+ }
+ else if (c != 'u' && c != 'U') { /* Definitely an identifier */
+ state = 70;
+ break;
+ }
+
+ if ((c = nextchar(s)) == 0) {
+ state = 76;
+ }
+ else if (c == '\"') { /* Definitely u, U or L string */
+ retract(s, 1);
+ state = 1000;
+ }
+ else if (c == 'R') { /* Possibly CUSTOM DELIMITER u, U, L string */
+ state = 73;
+ }
+ else if (c == '8') { /* Possibly u8 string */
state = 71;
+ }
+ else {
+ retract(s, 1); /* Definitely an identifier */
+ state = 70;
+ }
+ break;
+
+ case 70: /* Identifier */
+ if ((c = nextchar(s)) == 0)
+ state = 76;
else if (isalnum(c) || (c == '_') || (c == '$')) {
- state = 7;
+ state = 70;
} else {
retract(s, 1);
- state = 71;
+ state = 76;
+ }
+ break;
+
+ case 71: /* Possibly u8 string */
+ if ((c = nextchar(s)) == 0) {
+ state = 76;
+ }
+ else if (c=='\"') {
+ retract(s, 1); /* Definitely u8 string */
+ state = 1000;
+ }
+ else if (c=='R') {
+ state = 74; /* Possibly CUSTOM DELIMITER u8 string */
+ }
+ else {
+ retract(s, 2); /* Definitely an identifier. Retract 8" */
+ state = 70;
+ }
+
+ break;
+
+ case 72: /* Possibly CUSTOM DELIMITER string */
+ case 73:
+ case 74:
+ if ((c = nextchar(s)) == 0) {
+ state = 76;
+ }
+ else if (c=='\"') {
+ retract(s, 1); /* Definitely custom delimiter u, U or L string */
+ str_delimiter = NewStringEmpty();
+ state = 1000;
+ }
+ else {
+ if (state==72) {
+ retract(s, 1); /* Definitely an identifier. Retract ? */
+ }
+ else if (state==73) {
+ retract(s, 2); /* Definitely an identifier. Retract R? */
+ }
+ else if (state==74) {
+ retract(s, 3); /* Definitely an identifier. Retract 8R? */
+ }
+ state = 70;
+ }
+
+ break;
+
+ case 75: /* Special identifier $ */
+ if ((c = nextchar(s)) == 0)
+ return SWIG_TOKEN_DOLLAR;
+ if (isalnum(c) || (c == '_') || (c == '*') || (c == '&')) {
+ state = 70;
+ } else {
+ retract(s,1);
+ if (Len(s->text) == 1) return SWIG_TOKEN_DOLLAR;
+ state = 76;
}
break;
- case 71: /* Identifier or true/false */
+ case 76: /* Identifier or true/false */
if (cparse_cplusplus) {
if (Strcmp(s->text, "true") == 0)
return SWIG_TOKEN_BOOL;
return SWIG_TOKEN_ID;
break;
- case 75: /* Special identifier $ */
+ case 77: /*identifier or wide string literal*/
if ((c = nextchar(s)) == 0)
- return SWIG_TOKEN_DOLLAR;
- if (isalnum(c) || (c == '_') || (c == '*') || (c == '&')) {
+ return SWIG_TOKEN_ID;
+ else if (c == '\"') {
+ s->start_line = s->line;
+ Clear(s->text);
+ state = 78;
+ }
+ else if (c == '\'') {
+ s->start_line = s->line;
+ Clear(s->text);
+ state = 79;
+ }
+ else if (isalnum(c) || (c == '_') || (c == '$'))
state = 7;
- } else {
- retract(s,1);
- if (Len(s->text) == 1) return SWIG_TOKEN_DOLLAR;
- state = 71;
+ else {
+ retract(s, 1);
+ return SWIG_TOKEN_ID;
+ }
+ break;
+
+ case 78: /* Processing a wide string literal*/
+ if ((c = nextchar(s)) == 0) {
+ Swig_error(cparse_file, cparse_start_line, "Unterminated wide string\n");
+ return SWIG_TOKEN_ERROR;
+ }
+ if (c == '\"') {
+ Delitem(s->text, DOH_END);
+ return SWIG_TOKEN_WSTRING;
+ } else if (c == '\\') {
+ if ((c = nextchar(s)) == 0) {
+ Swig_error(cparse_file, cparse_start_line, "Unterminated wide string\n");
+ return SWIG_TOKEN_ERROR;
+ }
+ }
+ break;
+
+ case 79: /* Processing a wide char literal */
+ if ((c = nextchar(s)) == 0) {
+ Swig_error(cparse_file, cparse_start_line, "Unterminated wide character constant\n");
+ return SWIG_TOKEN_ERROR;
+ }
+ if (c == '\'') {
+ Delitem(s->text, DOH_END);
+ return (SWIG_TOKEN_WCHAR);
+ } else if (c == '\\') {
+ if ((c = nextchar(s)) == 0) {
+ Swig_error(cparse_file, cparse_start_line, "Unterminated wide character literal\n");
+ return SWIG_TOKEN_ERROR;
+ }
}
break;
* Real entry point to return the next token. Returns 0 if at end of input.
* ----------------------------------------------------------------------------- */
-int Scanner_token(Scanner * s) {
+int Scanner_token(Scanner *s) {
int t;
Delete(s->error);
if (s->nexttoken >= 0) {
* Return the lexene associated with the last returned token.
* ----------------------------------------------------------------------------- */
-String *Scanner_text(Scanner * s) {
+String *Scanner_text(Scanner *s) {
return s->text;
}
* Skips to the end of a line
* ----------------------------------------------------------------------------- */
-void Scanner_skip_line(Scanner * s) {
+void Scanner_skip_line(Scanner *s) {
char c;
int done = 0;
Clear(s->text);
* (...). Ignores symbols inside comments or strings.
* ----------------------------------------------------------------------------- */
-int Scanner_skip_balanced(Scanner * s, int startchar, int endchar) {
+int Scanner_skip_balanced(Scanner *s, int startchar, int endchar) {
char c;
int num_levels = 1;
int state = 0;
}
/* -----------------------------------------------------------------------------
+ * Scanner_get_raw_text_balanced()
+ *
+ * Returns raw text between 2 braces, does not change scanner state in any way
+ * ----------------------------------------------------------------------------- */
+
+String *Scanner_get_raw_text_balanced(Scanner *s, int startchar, int endchar) {
+ String *result = 0;
+ char c;
+ int old_line = s->line;
+ String *old_text = Copy(s->text);
+ long position = Tell(s->str);
+
+ int num_levels = 1;
+ int state = 0;
+ char temp[2] = { 0, 0 };
+ temp[0] = (char) startchar;
+ Clear(s->text);
+ Setfile(s->text, Getfile(s->str));
+ Setline(s->text, s->line);
+ Append(s->text, temp);
+ while (num_levels > 0) {
+ if ((c = nextchar(s)) == 0) {
+ Clear(s->text);
+ Append(s->text, old_text);
+ Delete(old_text);
+ s->line = old_line;
+ return 0;
+ }
+ switch (state) {
+ case 0:
+ if (c == startchar)
+ num_levels++;
+ else if (c == endchar)
+ num_levels--;
+ else if (c == '/')
+ state = 10;
+ else if (c == '\"')
+ state = 20;
+ else if (c == '\'')
+ state = 30;
+ break;
+ case 10:
+ if (c == '/')
+ state = 11;
+ else if (c == '*')
+ state = 12;
+ else if (c == startchar) {
+ state = 0;
+ num_levels++;
+ }
+ else
+ state = 0;
+ break;
+ case 11:
+ if (c == '\n')
+ state = 0;
+ else
+ state = 11;
+ break;
+ case 12: /* first character inside C comment */
+ if (c == '*')
+ state = 14;
+ else
+ state = 13;
+ break;
+ case 13:
+ if (c == '*')
+ state = 14;
+ break;
+ case 14: /* possible end of C comment */
+ if (c == '*')
+ state = 14;
+ else if (c == '/')
+ state = 0;
+ else
+ state = 13;
+ break;
+ case 20:
+ if (c == '\"')
+ state = 0;
+ else if (c == '\\')
+ state = 21;
+ break;
+ case 21:
+ state = 20;
+ break;
+ case 30:
+ if (c == '\'')
+ state = 0;
+ else if (c == '\\')
+ state = 31;
+ break;
+ case 31:
+ state = 30;
+ break;
+ default:
+ break;
+ }
+ }
+ Seek(s->str, position, SEEK_SET);
+ result = Copy(s->text);
+ Clear(s->text);
+ Append(s->text, old_text);
+ Delete(old_text);
+ s->line = old_line;
+ return result;
+}
+/* -----------------------------------------------------------------------------
* Scanner_isoperator()
*
* Returns 0 or 1 depending on whether or not a token corresponds to a C/C++
*
* 'p.' = Pointer (*)
* 'r.' = Reference (&)
+ * 'z.' = Rvalue reference (&&)
* 'a(n).' = Array of size n [n]
* 'f(..,..).' = Function with arguments (args)
* 'q(str).' = Qualifier (such as const or volatile) (const, volatile)
case T_UCHAR:
return NewString("unsigned char");
break;
- case T_STRING:{
+ case T_STRING: {
SwigType *t = NewString("char");
+ SwigType_add_qualifier(t, "const");
SwigType_add_pointer(t);
return t;
break;
}
+ case T_WCHAR:
+ return NewString("wchar_t");
+ break;
+ case T_WSTRING: {
+ SwigType *t = NewString("wchar_t");
+ SwigType_add_pointer(t);
+ return t;
+ break;
+ }
case T_LONGLONG:
return NewString("long long");
break;
case T_VOID:
return NewString("void");
break;
+ case T_AUTO:
+ return NewString("auto");
+ break;
default:
break;
}
if (!t)
return 0;
c = Char(t);
- idx = strlen(c) - 4;
+ idx = (int)strlen(c) - 4;
if (idx >= 0) {
return (strcmp(c + idx, ").p.") == 0);
}
if (!t)
return 0;
c = Char(t);
- idx = strlen(c) - 4;
+ idx = (int)strlen(c) - 4;
if (idx >= 0) {
return (strcmp(c + idx, ").r.") == 0);
}
int SwigType_ismutable(const SwigType *t) {
int r;
SwigType *qt = SwigType_typedef_resolve_all(t);
- if (SwigType_isreference(qt) || SwigType_isarray(qt)) {
+ if (SwigType_isreference(qt) || SwigType_isrvalue_reference(qt) || SwigType_isarray(qt)) {
Delete(SwigType_pop(qt));
}
r = SwigType_isconst(qt);
if (!c || !strstr(c + 2, ")>"))
return NewString(t);
- r = NewStringWithSize(d, c - d);
+ r = NewStringWithSize(d, (int)(c - d));
if (*(c - 1) == '<')
Putc(' ', r);
Putc('<', r);
Insert(result, 0, "(");
Append(result, ")");
}
+ } else if (SwigType_isrvalue_reference(element)) {
+ Insert(result, 0, "&&");
+ if ((nextelement) && ((SwigType_isfunction(nextelement) || (SwigType_isarray(nextelement))))) {
+ Insert(result, 0, "(");
+ Append(result, ")");
+ }
} else if (SwigType_isarray(element)) {
DOH *size;
Append(result, "[");
SwigType *tt = Copy(tc);
td = 0;
while ((td = SwigType_typedef_resolve(tt))) {
- if (td && (SwigType_isconst(td) || SwigType_isarray(td) || SwigType_isreference(td))) {
+ if (td && (SwigType_isconst(td) || SwigType_isarray(td) || SwigType_isreference(td) || SwigType_isrvalue_reference(td))) {
/* We need to use the typedef type */
Delete(tt);
break;
Append(result, "p.");
}
firstarray = 0;
+ } else if (SwigType_isrvalue_reference(element)) {
+ if (notypeconv) {
+ Append(result, element);
+ } else {
+ Append(result, "p.");
+ }
+ firstarray = 0;
} else if (SwigType_isarray(element) && firstarray) {
if (notypeconv) {
Append(result, element);
rs = s;
}
- if ((SwigType_isconst(rs) || SwigType_isarray(rs) || SwigType_isreference(rs))) {
+ if ((SwigType_isconst(rs) || SwigType_isarray(rs) || SwigType_isreference(rs) || SwigType_isrvalue_reference(rs))) {
td = 0;
} else {
td = SwigType_typedef_resolve(rs);
}
if (td) {
- if ((SwigType_isconst(td) || SwigType_isarray(td) || SwigType_isreference(td))) {
+ if ((SwigType_isconst(td) || SwigType_isarray(td) || SwigType_isreference(td) || SwigType_isrvalue_reference(td))) {
elements = SwigType_split(td);
} else {
elements = SwigType_split(rs);
}
if (!isfunction)
isreference = 1;
+ } else if (SwigType_isrvalue_reference(element)) {
+ Insert(result, 0, "&&");
+ if ((forwardelement) && ((SwigType_isfunction(forwardelement) || (SwigType_isarray(forwardelement))))) {
+ Insert(result, 0, "(");
+ Append(result, ")");
+ }
+ if (!isfunction)
+ isreference = 1;
+ clear = 0;
} else if (SwigType_isarray(element)) {
DOH *size;
if (firstarray && !isreference) {
Delete(str);
if (name)
Append(result, name);
+ } else if (SwigType_isrvalue_reference(s)) {
+ String *str = SwigType_str(s, 0);
+ Printf(result, "(%s)", str);
+ Delete(str);
+ if (name)
+ Append(result, name);
} else if (SwigType_isqualifier(s)) {
String *lstr = SwigType_lstr(s, 0);
Printf(result, "(%s)%s", lstr, name);
#define T_FLTCPLX 23
#define T_DBLCPLX 24
#define T_NUMERIC 25
+#define T_AUTO 26
#define T_COMPLEX T_DBLCPLX
#define T_FUNCTION 37
#define T_MPOINTER 38
#define T_VARARGS 39
+#define T_RVALUE_REFERENCE 40
+#define T_WSTRING 41
+
#define T_SYMBOL 98
#define T_ERROR 99
+
/* --- File interface --- */
#include "swigfile.h"
extern SwigType *SwigType_pop_arrays(SwigType *t);
extern SwigType *SwigType_add_reference(SwigType *t);
extern SwigType *SwigType_del_reference(SwigType *t);
+ extern SwigType *SwigType_add_rvalue_reference(SwigType *t);
+ extern SwigType *SwigType_del_rvalue_reference(SwigType *t);
extern SwigType *SwigType_add_qualifier(SwigType *t, const_String_or_char_ptr qual);
extern SwigType *SwigType_del_qualifier(SwigType *t);
extern SwigType *SwigType_add_function(SwigType *t, ParmList *parms);
extern int SwigType_ismemberpointer(const SwigType *t);
extern int SwigType_isreference(const SwigType *t);
extern int SwigType_isreference_return(const SwigType *t);
+ extern int SwigType_isrvalue_reference(const SwigType *t);
extern int SwigType_isarray(const SwigType *t);
extern int SwigType_prefix_is_simple_1D_array(const SwigType *t);
extern int SwigType_isfunction(const SwigType *t);
extern void Swig_naming_init(void);
extern void Swig_name_namewarn_add(String *prefix, String *name, SwigType *decl, Hash *namewrn);
- extern Hash *Swig_name_namewarn_get(Node *n, String *prefix, String *name, SwigType *decl);
extern void Swig_name_rename_add(String *prefix, String *name, SwigType *decl, Hash *namewrn, ParmList *declaratorparms);
extern void Swig_name_inherit(String *base, String *derived);
+ extern List *Swig_make_inherit_list(String *clsname, List *names, String *Namespaceprefix);
+ extern void Swig_inherit_base_symbols(List *bases);
extern int Swig_need_protected(Node *n);
- extern int Swig_need_name_warning(Node *n);
extern int Swig_need_redefined_warn(Node *a, Node *b, int InClass);
extern String *Swig_name_make(Node *n, String *prefix, const_String_or_char_ptr cname, SwigType *decl, String *oldname);
extern DOH *Swig_name_object_get(Hash *namehash, String *prefix, String *name, SwigType *decl);
extern void Swig_name_object_inherit(Hash *namehash, String *base, String *derived);
extern void Swig_features_get(Hash *features, String *prefix, String *name, SwigType *decl, Node *n);
- extern void Swig_feature_set(Hash *features, const_String_or_char_ptr name, SwigType *decl, const_String_or_char_ptr featurename, String *value, Hash *featureattribs);
+ extern void Swig_feature_set(Hash *features, const_String_or_char_ptr name, SwigType *decl, const_String_or_char_ptr featurename, const_String_or_char_ptr value, Hash *featureattribs);
/* --- Misc --- */
extern char *Swig_copy_string(const char *c);
extern void Swig_filename_correct(String *filename);
extern String *Swig_filename_escape(String *filename);
extern void Swig_filename_unescape(String *filename);
+ extern int Swig_storage_isextern(Node *n);
+ extern int Swig_storage_isexternc(Node *n);
+ extern int Swig_storage_isstatic_custom(Node *n, const_String_or_char_ptr storage);
+ extern int Swig_storage_isstatic(Node *n);
extern String *Swig_string_escape(String *s);
extern String *Swig_string_mangle(const String *s);
extern void Swig_scopename_split(const String *s, String **prefix, String **last);
extern String *Swig_string_lower(String *s);
extern String *Swig_string_upper(String *s);
extern String *Swig_string_title(String *s);
+ extern void Swig_offset_string(String *s, int number);
extern String *Swig_pcre_version(void);
extern void Swig_init(void);
extern int Swig_value_wrapper_mode(int mode);
/* --- Transformations --- */
extern int Swig_MethodToFunction(Node *n, const_String_or_char_ptr nspace, String *classname, int flags, SwigType *director_type, int is_director);
- extern int Swig_ConstructorToFunction(Node *n, const_String_or_char_ptr nspace, String *classname, String *none_comparison, String *director_ctor, int cplus, int flags);
+ extern int Swig_ConstructorToFunction(Node *n, const_String_or_char_ptr nspace, String *classname, String *none_comparison, String *director_ctor, int cplus, int flags, String *directorname);
extern int Swig_DestructorToFunction(Node *n, const_String_or_char_ptr nspace, String *classname, int cplus, int flags);
extern int Swig_MembersetToFunction(Node *n, String *classname, int flags);
extern int Swig_MembergetToFunction(Node *n, String *classname, int flags);
extern String *Swig_typemap_lookup(const_String_or_char_ptr tmap_method, Node *n, const_String_or_char_ptr lname, Wrapper *f);
extern String *Swig_typemap_lookup_out(const_String_or_char_ptr tmap_method, Node *n, const_String_or_char_ptr lname, Wrapper *f, String *actioncode);
- extern void Swig_typemap_new_scope(void);
- extern Hash *Swig_typemap_pop_scope(void);
extern void Swig_typemap_attach_parms(const_String_or_char_ptr tmap_method, ParmList *parms, Wrapper *f);
extern void Swig_fragment_emit(String *name);
extern void Swig_fragment_clear(String *section);
+/* --- Extension support --- */
+
+ extern Hash *Swig_extend_hash(void);
+ extern void Swig_extend_merge(Node *cls, Node *am);
+ extern void Swig_extend_append_previous(Node *cls, Node *am);
+ extern void Swig_extend_unused_check(void);
+
/* hacks defined in C++ ! */
extern int Swig_director_mode(void);
extern int Swig_director_protected_mode(void);
extern String *Scanner_text(Scanner *);
extern void Scanner_skip_line(Scanner *);
extern int Scanner_skip_balanced(Scanner *, int startchar, int endchar);
+extern String *Scanner_get_raw_text_balanced(Scanner *, int startchar, int endchar);
extern void Scanner_set_location(Scanner *, String *file, int line);
extern String *Scanner_file(Scanner *);
extern int Scanner_line(Scanner *);
#define SWIG_TOKEN_QUESTION 30 /* ? */
#define SWIG_TOKEN_COMMENT 31 /* C or C++ comment */
#define SWIG_TOKEN_BOOL 32 /* true or false */
+#define SWIG_TOKEN_WSTRING 33 /* L"str" */
+#define SWIG_TOKEN_WCHAR 34 /* L'c' */
+
#define SWIG_TOKEN_ILLEGAL 99
#define SWIG_TOKEN_ERROR -1
extern void prependChild(Node *node, Node *child);
extern void removeNode(Node *node);
extern Node *copyNode(Node *node);
+extern void appendSibling(Node *node, Node *child);
/* Node restoration/restore functions */
Symtab *un = Getattr(s, "sym:symtab");
Node *ss = (!Equal(name, uname) || (un != n)) ? Swig_symbol_clookup(uname, un) : 0; /* avoid infinity loop */
if (!ss) {
- Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", Getattr(s, "uname"));
+ Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", SwigType_namestr(Getattr(s, "uname")));
}
s = ss;
}
Node *ss;
ss = Swig_symbol_clookup(Getattr(s, "uname"), Getattr(s, "sym:symtab"));
if (!ss && !checkfunc) {
- Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", Getattr(s, "uname"));
+ Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", SwigType_namestr(Getattr(s, "uname")));
}
s = ss;
}
while (s && Checkattr(s, "nodeType", "using")) {
Node *ss = Swig_symbol_clookup_local(Getattr(s, "uname"), Getattr(s, "sym:symtab"));
if (!ss) {
- Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", Getattr(s, "uname"));
+ Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", SwigType_namestr(Getattr(s, "uname")));
}
s = ss;
}
while (s && Checkattr(s, "nodeType", "using")) {
Node *ss = Swig_symbol_clookup_local_check(Getattr(s, "uname"), Getattr(s, "sym:symtab"), checkfunc);
if (!ss && !checkfunc) {
- Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", Getattr(s, "uname"));
+ Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", SwigType_namestr(Getattr(s, "uname")));
}
s = ss;
}
Delete(ntq);
ntq = ty;
}
- /* Printf(stderr,"value %s %s %s\n",value,ntr,ntq); */
cp = NewParmWithoutFileLineInfo(ntq, 0);
- if (lp)
- set_nextSibling(lp, cp);
- else
- expandedparms = CopyParm(cp);
+ if (lp) {
+ set_nextSibling(lp, cp);
+ Delete(cp);
+ } else {
+ expandedparms = cp;
+ }
lp = cp;
tp = nextSibling(tp);
- Delete(cp);
Delete(nt);
Delete(ntq);
} else {
Node *cobj;
print_indent(0);
- Printf(stdout, "+++ %s ----------------------------------------\n", nodeType(obj));
+ Printf(stdout, "+++ %s - %p ----------------------------------------\n", nodeType(obj), obj);
ki = First(obj);
while (ki.key) {
String *k = ki.key;
}
}
+void appendSibling(Node *node, Node *chd) {
+ Node *parent;
+ Node *lc = node;
+ while (nextSibling(lc))
+ lc = nextSibling(lc);
+ set_nextSibling(lc, chd);
+ set_previousSibling(chd, lc);
+ parent = parentNode(node);
+ if (parent) {
+ while (chd) {
+ lc = chd;
+ set_parentNode(chd, parent);
+ chd = nextSibling(chd);
+ }
+ set_lastChild(parent, lc);
+ }
+}
+
/* -----------------------------------------------------------------------------
* removeNode()
*
*
* ----------------------------------------------------------------------------- */
-#define MAX_SCOPE 32
+static Hash *typemaps;
-
-static Hash *typemaps[MAX_SCOPE];
-static int tm_scope = 0;
-
-static Hash *get_typemap(int tm_scope, const SwigType *type) {
+static Hash *get_typemap(const SwigType *type) {
Hash *tm = 0;
SwigType *dtype = 0;
SwigType *hashtype;
/* remove unary scope operator (::) prefix indicating global scope for looking up in the hashmap */
hashtype = SwigType_remove_global_scope_prefix(type);
- tm = Getattr(typemaps[tm_scope], hashtype);
+ tm = Getattr(typemaps, hashtype);
Delete(dtype);
Delete(hashtype);
return tm;
}
-static void set_typemap(int tm_scope, const SwigType *type, Hash **tmhash) {
+static void set_typemap(const SwigType *type, Hash **tmhash) {
SwigType *hashtype = 0;
Hash *new_tm = 0;
assert(*tmhash == 0);
String *ty = Swig_symbol_template_deftype(rty, 0);
String *tyq = Swig_symbol_type_qualify(ty, 0);
hashtype = SwigType_remove_global_scope_prefix(tyq);
- *tmhash = Getattr(typemaps[tm_scope], hashtype);
+ *tmhash = Getattr(typemaps, hashtype);
Delete(rty);
Delete(tyq);
Delete(ty);
}
/* note that the unary scope operator (::) prefix indicating global scope has been removed from the type */
- Setattr(typemaps[tm_scope], hashtype, *tmhash);
+ Setattr(typemaps, hashtype, *tmhash);
Delete(hashtype);
Delete(new_tm);
* ----------------------------------------------------------------------------- */
void Swig_typemap_init() {
- int i;
- for (i = 0; i < MAX_SCOPE; i++) {
- typemaps[i] = 0;
- }
- typemaps[0] = NewHash();
- tm_scope = 0;
+ typemaps = NewHash();
}
static String *typemap_method_name(const_String_or_char_ptr tmap_method) {
return s;
}
-#if 0
-/* -----------------------------------------------------------------------------
- * Swig_typemap_new_scope()
- *
- * Create a new typemap scope
- * ----------------------------------------------------------------------------- */
-
-void Swig_typemap_new_scope() {
- tm_scope++;
- typemaps[tm_scope] = NewHash();
-}
-
-/* -----------------------------------------------------------------------------
- * Swig_typemap_pop_scope()
- *
- * Pop the last typemap scope off
- * ----------------------------------------------------------------------------- */
-
-Hash *Swig_typemap_pop_scope() {
- if (tm_scope > 0) {
- return typemaps[tm_scope--];
- }
- return 0;
-}
-#endif
-
/* -----------------------------------------------------------------------------
* typemap_register()
*
pname = Getattr(parms, "name");
/* See if this type has been seen before */
- tm = get_typemap(tm_scope, type);
+ tm = get_typemap(type);
if (!tm) {
- set_typemap(tm_scope, type, &tm);
+ set_typemap(type, &tm);
}
if (pname) {
/* See if parameter has been seen before */
/* -----------------------------------------------------------------------------
* typemap_get()
*
- * Retrieve typemap information from current scope.
+ * Retrieve typemap information.
* ----------------------------------------------------------------------------- */
-static Hash *typemap_get(SwigType *type, const_String_or_char_ptr name, int scope) {
+static Hash *typemap_get(SwigType *type, const_String_or_char_ptr name) {
Hash *tm, *tm1;
- /* See if this type has been seen before */
- if ((scope < 0) || (scope > tm_scope))
- return 0;
- tm = get_typemap(scope, type);
+ tm = get_typemap(type);
if (!tm) {
return 0;
}
Parm *p;
String *pname;
SwigType *ptype;
- int ts = tm_scope;
String *tm_methods, *multi_tmap_method;
if (ParmList_len(parms) != ParmList_len(srcparms))
return -1;
tm_method = typemap_method_name(tmap_method);
- while (ts >= 0) {
- p = srcparms;
- tm_methods = NewString(tm_method);
- while (p) {
- ptype = Getattr(p, "type");
- pname = Getattr(p, "name");
+ p = srcparms;
+ tm_methods = NewString(tm_method);
+ while (p) {
+ ptype = Getattr(p, "type");
+ pname = Getattr(p, "name");
- /* Lookup the type */
- tm = typemap_get(ptype, pname, ts);
- if (!tm)
- break;
+ /* Lookup the type */
+ tm = typemap_get(ptype, pname);
+ if (!tm)
+ break;
- tm = Getattr(tm, tm_methods);
- if (!tm)
- break;
+ tm = Getattr(tm, tm_methods);
+ if (!tm)
+ break;
- /* Got a match. Look for next typemap */
- multi_tmap_method = NewStringf("%s-%s+%s:", tm_methods, ptype, pname);
- Delete(tm_methods);
- tm_methods = multi_tmap_method;
- p = nextSibling(p);
- }
+ /* Got a match. Look for next typemap */
+ multi_tmap_method = NewStringf("%s-%s+%s:", tm_methods, ptype, pname);
Delete(tm_methods);
+ tm_methods = multi_tmap_method;
+ p = nextSibling(p);
+ }
+ Delete(tm_methods);
- if (!p && tm) {
- /* Got some kind of match */
- String *parms_str = ParmList_str_multibrackets(parms);
- String *srcparms_str = ParmList_str_multibrackets(srcparms);
- String *source_directive = NewStringf("typemap(%s) %s = %s", tmap_method, parms_str, srcparms_str);
+ if (!p && tm) {
+ /* Got some kind of match */
+ String *parms_str = ParmList_str_multibrackets(parms);
+ String *srcparms_str = ParmList_str_multibrackets(srcparms);
+ String *source_directive = NewStringf("typemap(%s) %s = %s", tmap_method, parms_str, srcparms_str);
- typemap_register(tmap_method, parms, Getattr(tm, "code"), Getattr(tm, "locals"), Getattr(tm, "kwargs"), source_directive);
+ typemap_register(tmap_method, parms, Getattr(tm, "code"), Getattr(tm, "locals"), Getattr(tm, "kwargs"), source_directive);
- Delete(source_directive);
- Delete(srcparms_str);
- Delete(parms_str);
- return 0;
- }
- ts--;
+ Delete(source_directive);
+ Delete(srcparms_str);
+ Delete(parms_str);
+ return 0;
}
+
/* Not found */
return -1;
while (p) {
type = Getattr(p, "type");
name = Getattr(p, "name");
- tm = typemap_get(type, name, tm_scope);
+ tm = typemap_get(type, name);
if (!tm)
return;
p = nextSibling(p);
String *ssig, *dsig;
Parm *p, *np, *lastp, *dp, *lastdp = 0;
int narg = 0;
- int ts = tm_scope;
SwigType *type = 0, *name;
Hash *tm, *sm;
int match = 0;
/* make sure a typemap node exists for the last destination node */
type = Getattr(lastdp, "type");
- tm = get_typemap(tm_scope, type);
+ tm = get_typemap(type);
if (!tm) {
- set_typemap(tm_scope, type, &tm);
+ set_typemap(type, &tm);
}
name = Getattr(lastdp, "name");
if (name) {
type = Getattr(lastp, "type");
name = Getattr(lastp, "name");
- while (ts >= 0) {
+ /* See if there is a matching typemap in this scope */
+ sm = typemap_get(type, name);
- /* See if there is a matching typemap in this scope */
- sm = typemap_get(type, name, ts);
+ /* if there is not matching, look for a typemap in the
+ original typedef, if any, like in:
- /* if there is not matching, look for a typemap in the
- original typedef, if any, like in:
-
- typedef unsigned long size_t;
- ...
- %apply(size_t) {my_size}; ==> %apply(unsigned long) {my_size};
- */
- if (!sm) {
- SwigType *ntype = SwigType_typedef_resolve(type);
- if (ntype && (Cmp(ntype, type) != 0)) {
- sm = typemap_get(ntype, name, ts);
- }
- Delete(ntype);
+ typedef unsigned long size_t;
+ ...
+ %apply(size_t) {my_size}; ==> %apply(unsigned long) {my_size};
+ */
+ if (!sm) {
+ SwigType *ntype = SwigType_typedef_resolve(type);
+ if (ntype && (Cmp(ntype, type) != 0)) {
+ sm = typemap_get(ntype, name);
}
-
- if (sm) {
- /* Got a typemap. Need to only merge attributes for methods that match our signature */
- Iterator ki;
- match = 1;
- for (ki = First(sm); ki.key; ki = Next(ki)) {
- /* Check for a signature match with the source signature */
- if ((count_args(ki.key) == narg) && (Strstr(ki.key, ssig))) {
- String *oldm;
- /* A typemap we have to copy */
- String *nkey = Copy(ki.key);
- Replace(nkey, ssig, dsig, DOH_REPLACE_ANY);
-
- /* Make sure the typemap doesn't already exist in the target map */
-
- oldm = Getattr(tm, nkey);
- if (!oldm || (!Getattr(tm, "code"))) {
- String *code;
- ParmList *locals;
- ParmList *kwargs;
- Hash *sm1 = ki.item;
-
- code = Getattr(sm1, "code");
- locals = Getattr(sm1, "locals");
- kwargs = Getattr(sm1, "kwargs");
- if (code) {
- String *src_str = ParmList_str_multibrackets(src);
- String *dest_str = ParmList_str_multibrackets(dest);
- String *source_directive = NewStringf("apply %s { %s }", src_str, dest_str);
-
- Replace(nkey, dsig, "", DOH_REPLACE_ANY);
- Replace(nkey, "tmap:", "", DOH_REPLACE_ANY);
- typemap_register(nkey, dest, code, locals, kwargs, source_directive);
-
- Delete(source_directive);
- Delete(dest_str);
- Delete(src_str);
- }
+ Delete(ntype);
+ }
+
+ if (sm) {
+ /* Got a typemap. Need to only merge attributes for methods that match our signature */
+ Iterator ki;
+ match = 1;
+ for (ki = First(sm); ki.key; ki = Next(ki)) {
+ /* Check for a signature match with the source signature */
+ if ((count_args(ki.key) == narg) && (Strstr(ki.key, ssig))) {
+ String *oldm;
+ /* A typemap we have to copy */
+ String *nkey = Copy(ki.key);
+ Replace(nkey, ssig, dsig, DOH_REPLACE_ANY);
+
+ /* Make sure the typemap doesn't already exist in the target map */
+
+ oldm = Getattr(tm, nkey);
+ if (!oldm || (!Getattr(tm, "code"))) {
+ String *code;
+ ParmList *locals;
+ ParmList *kwargs;
+ Hash *sm1 = ki.item;
+
+ code = Getattr(sm1, "code");
+ locals = Getattr(sm1, "locals");
+ kwargs = Getattr(sm1, "kwargs");
+ if (code) {
+ String *src_str = ParmList_str_multibrackets(src);
+ String *dest_str = ParmList_str_multibrackets(dest);
+ String *source_directive = NewStringf("apply %s { %s }", src_str, dest_str);
+
+ Replace(nkey, dsig, "", DOH_REPLACE_ANY);
+ Replace(nkey, "tmap:", "", DOH_REPLACE_ANY);
+ typemap_register(nkey, dest, code, locals, kwargs, source_directive);
+
+ Delete(source_directive);
+ Delete(dest_str);
+ Delete(src_str);
}
- Delete(nkey);
}
+ Delete(nkey);
}
}
- ts--;
}
Delete(ssig);
Delete(dsig);
}
p = np;
}
- tm = get_typemap(tm_scope, Getattr(lastp, "type"));
+ tm = get_typemap(Getattr(lastp, "type"));
if (!tm) {
Delete(tsig);
return;
SwigType *primitive = 0;
SwigType *ctype = 0;
SwigType *ctype_unstripped = 0;
- int ts;
int isarray;
const String *cname = 0;
const String *cqualifiedname = 0;
cname = name;
if ((qualifiedname) && Len(qualifiedname))
cqualifiedname = qualifiedname;
- ts = tm_scope;
if (debug_display) {
String *typestr = SwigType_str(type, cqualifiedname ? cqualifiedname : cname);
Swig_diagnostic(Getfile(node), Getline(node), "Searching for a suitable '%s' typemap for: %s\n", tmap_method, typestr);
Delete(typestr);
}
- while (ts >= 0) {
- ctype = Copy(type);
- ctype_unstripped = Copy(ctype);
- while (ctype) {
- /* Try to get an exact type-match */
- tm = get_typemap(ts, ctype);
- result = typemap_search_helper(debug_display, tm, tm_method, ctype, cqualifiedname, cname, &backup);
- if (result && Getattr(result, "code"))
- goto ret_result;
-
- {
- /* Look for the type reduced to just the template prefix - for templated types without the template parameter list being specified */
- SwigType *template_prefix = SwigType_istemplate_only_templateprefix(ctype);
- if (template_prefix) {
- tm = get_typemap(ts, template_prefix);
- result = typemap_search_helper(debug_display, tm, tm_method, template_prefix, cqualifiedname, cname, &backup);
- Delete(template_prefix);
- if (result && Getattr(result, "code"))
- goto ret_result;
- }
- }
+ ctype = Copy(type);
+ ctype_unstripped = Copy(ctype);
+ while (ctype) {
+ /* Try to get an exact type-match */
+ tm = get_typemap(ctype);
+ result = typemap_search_helper(debug_display, tm, tm_method, ctype, cqualifiedname, cname, &backup);
+ if (result && Getattr(result, "code"))
+ goto ret_result;
- /* look for [ANY] arrays */
- isarray = SwigType_isarray(ctype);
- if (isarray) {
- /* If working with arrays, strip away all of the dimensions and replace with "ANY".
- See if that generates a match */
- SwigType *noarrays = strip_arrays(ctype);
- tm = get_typemap(ts, noarrays);
- result = typemap_search_helper(debug_display, tm, tm_method, noarrays, cqualifiedname, cname, &backup);
- Delete(noarrays);
+ {
+ /* Look for the type reduced to just the template prefix - for templated types without the template parameter list being specified */
+ SwigType *template_prefix = SwigType_istemplate_only_templateprefix(ctype);
+ if (template_prefix) {
+ tm = get_typemap(template_prefix);
+ result = typemap_search_helper(debug_display, tm, tm_method, template_prefix, cqualifiedname, cname, &backup);
+ Delete(template_prefix);
if (result && Getattr(result, "code"))
goto ret_result;
}
+ }
- /* No match so far - try with a qualifier stripped (strip one qualifier at a time until none remain)
- * The order of stripping in SwigType_strip_single_qualifier is used to provide some sort of consistency
- * with the default (SWIGTYPE) typemap matching rules for the first qualifier to be stripped. */
- {
- SwigType *oldctype = ctype;
- ctype = SwigType_strip_single_qualifier(oldctype);
- if (!Equal(ctype, oldctype)) {
- Delete(oldctype);
- continue;
- }
- Delete(oldctype);
- }
+ /* look for [ANY] arrays */
+ isarray = SwigType_isarray(ctype);
+ if (isarray) {
+ /* If working with arrays, strip away all of the dimensions and replace with "ANY".
+ See if that generates a match */
+ SwigType *noarrays = strip_arrays(ctype);
+ tm = get_typemap(noarrays);
+ result = typemap_search_helper(debug_display, tm, tm_method, noarrays, cqualifiedname, cname, &backup);
+ Delete(noarrays);
+ if (result && Getattr(result, "code"))
+ goto ret_result;
+ }
- /* Once all qualifiers are stripped try resolve a typedef */
- {
- SwigType *oldctype = ctype;
- ctype = SwigType_typedef_resolve(ctype_unstripped);
+ /* No match so far - try with a qualifier stripped (strip one qualifier at a time until none remain)
+ * The order of stripping in SwigType_strip_single_qualifier is used to provide some sort of consistency
+ * with the default (SWIGTYPE) typemap matching rules for the first qualifier to be stripped. */
+ {
+ SwigType *oldctype = ctype;
+ ctype = SwigType_strip_single_qualifier(oldctype);
+ if (!Equal(ctype, oldctype)) {
Delete(oldctype);
- ctype_unstripped = Copy(ctype);
+ continue;
}
+ Delete(oldctype);
}
- /* Hmmm. Well, no match seems to be found at all. See if there is some kind of default (SWIGTYPE) mapping */
+ /* Once all qualifiers are stripped try resolve a typedef */
+ {
+ SwigType *oldctype = ctype;
+ ctype = SwigType_typedef_resolve(ctype_unstripped);
+ Delete(oldctype);
+ ctype_unstripped = Copy(ctype);
+ }
+ }
- primitive = SwigType_default_create(type);
- while (primitive) {
- tm = get_typemap(ts, primitive);
- result = typemap_search_helper(debug_display, tm, tm_method, primitive, cqualifiedname, cname, &backup);
- if (result && Getattr(result, "code"))
- goto ret_result;
+ /* Hmmm. Well, no match seems to be found at all. See if there is some kind of default (SWIGTYPE) mapping */
- {
- SwigType *nprim = SwigType_default_deduce(primitive);
- Delete(primitive);
- primitive = nprim;
- }
- }
- if (ctype != type) {
- Delete(ctype);
- ctype = 0;
+ primitive = SwigType_default_create(type);
+ while (primitive) {
+ tm = get_typemap(primitive);
+ result = typemap_search_helper(debug_display, tm, tm_method, primitive, cqualifiedname, cname, &backup);
+ if (result && Getattr(result, "code"))
+ goto ret_result;
+
+ {
+ SwigType *nprim = SwigType_default_deduce(primitive);
+ Delete(primitive);
+ primitive = nprim;
}
- ts--; /* Hmmm. Nothing found in this scope. Guess we'll go try another scope */
+ }
+ if (ctype != type) {
+ Delete(ctype);
+ ctype = 0;
}
result = backup;
$*n_ltype
*/
- if (SwigType_ispointer(ftype) || (SwigType_isarray(ftype)) || (SwigType_isreference(ftype))) {
- if (!(SwigType_isarray(type) || SwigType_ispointer(type) || SwigType_isreference(type))) {
+ if (SwigType_ispointer(ftype) || (SwigType_isarray(ftype)) || (SwigType_isreference(ftype)) || (SwigType_isrvalue_reference(ftype))) {
+ if (!(SwigType_isarray(type) || SwigType_ispointer(type) || SwigType_isreference(type) || SwigType_isrvalue_reference(type))) {
star_type = Copy(ftype);
} else {
star_type = Copy(type);
}
- if (!SwigType_isreference(star_type)) {
+ if (!(SwigType_isreference(star_type) || SwigType_isrvalue_reference(star_type))) {
if (SwigType_isarray(star_type)) {
SwigType_del_element(star_type);
} else {
* creates the local variables.
* ------------------------------------------------------------------------ */
-static void typemap_locals(DOHString * s, ParmList *l, Wrapper *f, int argnum) {
+static void typemap_locals(String *s, ParmList *l, Wrapper *f, int argnum) {
Parm *p;
char *new_name;
char *cmethod = Char(tmap_method);
int optimal_attribute = 0;
int optimal_substitution = 0;
+ int delete_optimal_attribute = 0;
int num_substitutions = 0;
SwigType *matchtype = 0;
Delete(typestr);
}
-
Delete(qpname);
qpname = 0;
Delete(noscope_pname);
s = Copy(s); /* Make a local copy of the typemap code */
- /* Attach kwargs - ie the typemap attributes */
- kw = Getattr(tm, "kwargs");
- while (kw) {
- String *value = Copy(Getattr(kw, "value"));
- String *kwtype = Getattr(kw, "type");
- char *ckwname = Char(Getattr(kw, "name"));
- if (kwtype) {
- String *mangle = Swig_string_mangle(kwtype);
- Append(value, mangle);
- Delete(mangle);
+ /* Look in the "out" typemap for the "optimal" attribute */
+ if (Cmp(cmethod, "out") == 0) {
+ kw = Getattr(tm, "kwargs");
+ while (kw) {
+ if (Cmp(Getattr(kw, "name"), "optimal") == 0) {
+ optimal_attribute = GetFlag(kw, "value");
+ break;
+ }
+ kw = nextSibling(kw);
}
- sprintf(temp, "%s:%s", cmethod, ckwname);
- Setattr(node, typemap_method_name(temp), value);
- if (Cmp(temp, "out:optimal") == 0)
- optimal_attribute = (Cmp(value, "0") != 0) ? 1 : 0;
- Delete(value);
- kw = nextSibling(kw);
}
if (optimal_attribute) {
}
}
if (!optimal_substitution) {
- Swig_warning(WARN_TYPEMAP_OUT_OPTIMAL_IGNORED, Getfile(node), Getline(node), "Method %s usage of the optimal attribute ignored\n", Swig_name_decl(node));
- Swig_warning(WARN_TYPEMAP_OUT_OPTIMAL_IGNORED, Getfile(s), Getline(s), "in the out typemap as the following cannot be used to generate optimal code: %s\n", clname);
- Delattr(node, "tmap:out:optimal");
+ Swig_warning(WARN_TYPEMAP_OUT_OPTIMAL_IGNORED, Getfile(node), Getline(node), "Method %s usage of the optimal attribute ignored\n", Swig_name_decl(node));
+ Swig_warning(WARN_TYPEMAP_OUT_OPTIMAL_IGNORED, Getfile(s), Getline(s), "in the out typemap as the following cannot be used to generate optimal code: %s\n", clname);
+ delete_optimal_attribute = 1;
}
} else {
assert(!f);
}
}
+
if (actioncode) {
assert(f);
Append(f->code, actioncode);
Delete(parm_sublist);
}
+ /* Attach kwargs - ie the typemap attributes */
+ kw = Getattr(tm, "kwargs");
+ while (kw) {
+ String *value = Copy(Getattr(kw, "value"));
+ String *kwtype = Getattr(kw, "type");
+ char *ckwname = Char(Getattr(kw, "name"));
+ {
+ /* Expand special variables in typemap attributes. */
+ SwigType *ptype = Getattr(node, "type");
+ String *pname = Getattr(node, "name");
+ SwigType *mtype = Getattr(node, "tmap:match");
+ SwigType *matchtype = mtype ? mtype : ptype;
+ ParmList *parm_sublist;
+ typemap_replace_vars(value, NULL, matchtype, ptype, pname, (char *)lname, 1);
+
+ /* Expand special variable macros (embedded typemaps) in typemap attributes. */
+ parm_sublist = NewParmWithoutFileLineInfo(ptype, pname);
+ Setattr(parm_sublist, "lname", lname);
+ replace_embedded_typemap(value, parm_sublist, NULL, tm);
+ Delete(parm_sublist);
+ }
+ if (kwtype) {
+ String *mangle = Swig_string_mangle(kwtype);
+ Append(value, mangle);
+ Delete(mangle);
+ }
+ sprintf(temp, "%s:%s", cmethod, ckwname);
+ Setattr(node, typemap_method_name(temp), value);
+ Delete(value);
+ kw = nextSibling(kw);
+ }
+
+ if (delete_optimal_attribute)
+ Delattr(node, "tmap:out:optimal");
+
Replace(s, "$name", pname, DOH_REPLACE_ANY);
symname = Getattr(node, "sym:name");
* If this hash (tm) contains a linked list of parameters under its "kwargs"
* attribute, add keys for each of those named keyword arguments to this
* parameter for later use.
- * For example, attach the typemap attributes to p:
+ * For example, attach the typemap attributes to firstp (first parameter in parameter list):
* %typemap(in, foo="xyz") ...
- * A new attribute called "tmap:in:foo" with value "xyz" is attached to p.
+ * A new attribute called "tmap:in:foo" with value "xyz" is attached to firstp.
+ * Also expands special variables and special variable macros in the typemap attributes.
* ----------------------------------------------------------------------------- */
-static void typemap_attach_kwargs(Hash *tm, const_String_or_char_ptr tmap_method, Parm *p) {
+static void typemap_attach_kwargs(Hash *tm, const_String_or_char_ptr tmap_method, Parm *firstp, int nmatch) {
String *temp = NewStringEmpty();
Parm *kw = Getattr(tm, "kwargs");
while (kw) {
String *value = Copy(Getattr(kw, "value"));
String *type = Getattr(kw, "type");
+ int i;
+ Parm *p = firstp;
+ /* Expand special variables */
+ for (i = 0; i < nmatch; i++) {
+ SwigType *type = Getattr(p, "type");
+ String *pname = Getattr(p, "name");
+ String *lname = Getattr(p, "lname");
+ SwigType *mtype = Getattr(p, "tmap:match");
+ SwigType *matchtype = mtype ? mtype : type;
+ typemap_replace_vars(value, NULL, matchtype, type, pname, lname, i + 1);
+ p = nextSibling(p);
+ }
+
+ /* Expand special variable macros (embedded typemaps).
+ * Special variable are expanded first above as they might be used in the special variable macros.
+ * For example: $typemap(imtype, $2_type). */
+ p = firstp;
+ for (i = 0; i < nmatch; i++) {
+ SwigType *type = Getattr(p, "type");
+ String *pname = Getattr(p, "name");
+ String *lname = Getattr(p, "lname");
+ ParmList *parm_sublist = NewParmWithoutFileLineInfo(type, pname);
+ Setattr(parm_sublist, "lname", lname);
+ replace_embedded_typemap(value, parm_sublist, NULL, tm);
+ p = nextSibling(p);
+ }
if (type) {
Hash *v = NewHash();
Setattr(v, "type", type);
}
Clear(temp);
Printf(temp, "%s:%s", tmap_method, Getattr(kw, "name"));
- Setattr(p, typemap_method_name(temp), value);
+ Setattr(firstp, typemap_method_name(temp), value);
Delete(value);
kw = nextSibling(kw);
}
Clear(temp);
Printf(temp, "%s:match_type", tmap_method);
- Setattr(p, typemap_method_name(temp), Getattr(tm, "type"));
+ Setattr(firstp, typemap_method_name(temp), Getattr(tm, "type"));
Delete(temp);
}
Setattr(firstp, typemap_method_name(temp), p);
/* Attach kwargs */
- typemap_attach_kwargs(tm, tmap_method, firstp);
+ typemap_attach_kwargs(tm, tmap_method, firstp, nmatch);
/* Replace the argument number */
sprintf(temp, "%d", argnum);
}
}
if ((level == 0) && angle_level == 0 && ((*c == ',') || (*c == ')'))) {
- String *tmp = NewStringWithSize(start, c - start);
+ String *tmp = NewStringWithSize(start, (int)(c - start));
Append(args, tmp);
Delete(tmp);
start = c + 1;
c++;
}
if (end) {
- dollar_typemap = NewStringWithSize(start, (end - start));
+ dollar_typemap = NewStringWithSize(start, (int)((end - start)));
syntax_error = 0;
} else {
- dollar_typemap = NewStringWithSize(start, (c - start));
+ dollar_typemap = NewStringWithSize(start, (int)((c - start)));
}
if (!syntax_error) {
char *eq = strchr(Char(parm), '=');
char *c = Char(parm);
if (eq && (eq - c > 0)) {
- String *name = NewStringWithSize(c, eq - c);
+ String *name = NewStringWithSize(c, (int)(eq - c));
String *value = NewString(eq + 1);
Insert(name, 0, "$");
Setattr(vars, name, value);
* ----------------------------------------------------------------------------- */
void Swig_typemap_debug() {
- int ts;
int nesting_level = 2;
Printf(stdout, "---[ typemaps ]--------------------------------------------------------------\n");
-
- ts = tm_scope;
- while (ts >= 0) {
- Printf(stdout, "::: scope %d\n\n", ts);
- Swig_print(typemaps[ts], nesting_level);
- ts--;
- }
+ Swig_print(typemaps, nesting_level);
Printf(stdout, "-----------------------------------------------------------------------------\n");
}
*
* 'p.' = Pointer (*)
* 'r.' = Reference (&)
+ * 'z.' = Rvalue reference (&&)
* 'a(n).' = Array of size n [n]
* 'f(..,..).' = Function with arguments (args)
* 'q(str).' = Qualifier (such as const or volatile) (const, volatile)
*
* SwigType_add_pointer()
* SwigType_add_reference()
+ * SwigType_add_rvalue_reference()
* SwigType_add_array()
*
* These are used to build new types. There are also functions to undo these
*
* SwigType_del_pointer()
* SwigType_del_reference()
+ * SwigType_del_rvalue_reference()
* SwigType_del_array()
*
* In addition, there are query functions
*
* SwigType_ispointer()
* SwigType_isreference()
+ * SwigType_isrvalue_reference()
* SwigType_isarray()
*
* Finally, there are some data extraction functions that can be used to
/* -----------------------------------------------------------------------------
* SwigType_split()
*
- * Splits a type into it's component parts and returns a list of string.
+ * Splits a type into its component parts and returns a list of string.
* ----------------------------------------------------------------------------- */
List *SwigType_split(const SwigType *t) {
printf("Fatal error. SwigType_del_pointer applied to non-pointer.\n");
abort();
}
- Delslice(t, 0, (c - s) + 2);
+ Delslice(t, 0, (int)((c - s) + 2));
return t;
}
}
/* -----------------------------------------------------------------------------
+ * Rvalue References
+ *
+ * SwigType_add_rvalue_reference()
+ * SwigType_del_rvalue_reference()
+ * SwigType_isrvalue_reference()
+ *
+ * Add, remove, and test if a type is a rvalue reference. The deletion and query
+ * functions take into account qualifiers (if any).
+ * ----------------------------------------------------------------------------- */
+
+SwigType *SwigType_add_rvalue_reference(SwigType *t) {
+ Insert(t, 0, "z.");
+ return t;
+}
+
+SwigType *SwigType_del_rvalue_reference(SwigType *t) {
+ char *c = Char(t);
+ int check = strncmp(c, "z.", 2);
+ assert(check == 0);
+ Delslice(t, 0, 2);
+ return t;
+}
+
+int SwigType_isrvalue_reference(const SwigType *t) {
+ char *c;
+ if (!t)
+ return 0;
+ c = Char(t);
+ if (strncmp(c, "z.", 2) == 0) {
+ return 1;
+ }
+ return 0;
+}
+
+/* -----------------------------------------------------------------------------
* Qualifiers
*
* SwigType_add_qualifier()
String *SwigType_templateprefix(const SwigType *t) {
const char *s = Char(t);
const char *c = strstr(s, "<(");
- return c ? NewStringWithSize(s, c - s) : NewString(s);
+ return c ? NewStringWithSize(s, (int)(c - s)) : NewString(s);
}
/* -----------------------------------------------------------------------------
String *SwigType_istemplate_templateprefix(const SwigType *t) {
const char *s = Char(t);
const char *c = strstr(s, "<(");
- return c ? NewStringWithSize(s, c - s) : 0;
+ return c ? NewStringWithSize(s, (int)(c - s)) : 0;
}
/* -----------------------------------------------------------------------------
const char *s = Char(t);
if (len >= 4 && strcmp(s + len - 2, ")>") == 0) {
const char *c = strstr(s, "<(");
- return c ? NewStringWithSize(s, c - s) : 0;
+ return c ? NewStringWithSize(s, (int)(c - s)) : 0;
} else {
return 0;
}
nest--;
c++;
}
- return NewStringWithSize(start, c - start);
+ return NewStringWithSize(start, (int)(c - start));
}
c++;
}
Typetab *s;
Hash *ttab;
String *namebase = 0;
- String *nameprefix = 0;
+ String *nameprefix = 0, *rnameprefix = 0;
int newtype = 0;
resolved_scope = 0;
Printf(stdout, "nameprefix = '%s'\n", nameprefix);
#endif
if (nameprefix) {
- /* Name had a prefix on it. See if we can locate the proper scope for it */
- String *rnameprefix = template_parameters_resolve(nameprefix);
- nameprefix = rnameprefix ? Copy(rnameprefix) : nameprefix;
- Delete(rnameprefix);
- s = SwigType_find_scope(s, nameprefix);
-
- /* Couldn't locate a scope for the type. */
- if (!s) {
- Delete(base);
- Delete(namebase);
- Delete(nameprefix);
- r = 0;
- goto return_result;
- }
- /* Try to locate the name starting in the scope */
+ rnameprefix = SwigType_typedef_resolve(nameprefix);
+ if(rnameprefix != NULL) {
#ifdef SWIG_DEBUG
- Printf(stdout, "namebase = '%s'\n", namebase);
+ Printf(stdout, "nameprefix '%s' is a typedef to '%s'\n", nameprefix, rnameprefix);
#endif
- type = typedef_resolve(s, namebase);
- if (type && resolved_scope) {
- /* we need to look for the resolved type, this will also
- fix the resolved_scope if 'type' and 'namebase' are
- declared in different scopes */
- String *rtype = 0;
- rtype = typedef_resolve(resolved_scope, type);
- if (rtype)
- type = rtype;
- }
+ type = Copy(namebase);
+ Insert(type, 0, "::");
+ Insert(type, 0, rnameprefix);
+ if (strncmp(Char(type), "::", 2) == 0) {
+ Delitem(type, 0);
+ Delitem(type, 0);
+ }
+ newtype = 1;
+ } else {
+ /* Name had a prefix on it. See if we can locate the proper scope for it */
+ String *rnameprefix = template_parameters_resolve(nameprefix);
+ nameprefix = rnameprefix ? Copy(rnameprefix) : nameprefix;
+ Delete(rnameprefix);
+ s = SwigType_find_scope(s, nameprefix);
+
+ /* Couldn't locate a scope for the type. */
+ if (!s) {
+ Delete(base);
+ Delete(namebase);
+ Delete(nameprefix);
+ r = 0;
+ goto return_result;
+ }
+ /* Try to locate the name starting in the scope */
+#ifdef SWIG_DEBUG
+ Printf(stdout, "namebase = '%s'\n", namebase);
+#endif
+ type = typedef_resolve(s, namebase);
+ if (type && resolved_scope) {
+ /* we need to look for the resolved type, this will also
+ fix the resolved_scope if 'type' and 'namebase' are
+ declared in different scopes */
+ String *rtype = 0;
+ rtype = typedef_resolve(resolved_scope, type);
+ if (rtype)
+ type = rtype;
+ }
#ifdef SWIG_DEBUG
- Printf(stdout, "%s type = '%s'\n", Getattr(s, "name"), type);
+ Printf(stdout, "%s type = '%s'\n", Getattr(s, "name"), type);
#endif
- if (type && (!Swig_scopename_check(type)) && resolved_scope) {
- Typetab *rtab = resolved_scope;
- String *qname = Getattr(resolved_scope, "qname");
- /* If qualified *and* the typename is defined from the resolved scope, we qualify */
- if ((qname) && typedef_resolve(resolved_scope, type)) {
- type = Copy(type);
- Insert(type, 0, "::");
- Insert(type, 0, qname);
+ if ((type) && (!Swig_scopename_check(type)) && resolved_scope) {
+ Typetab *rtab = resolved_scope;
+ String *qname = Getattr(resolved_scope, "qname");
+ /* If qualified *and* the typename is defined from the resolved scope, we qualify */
+ if ((qname) && typedef_resolve(resolved_scope, type)) {
+ type = Copy(type);
+ Insert(type, 0, "::");
+ Insert(type, 0, qname);
#ifdef SWIG_DEBUG
- Printf(stdout, "qual %s \n", type);
+ Printf(stdout, "qual %s \n", type);
#endif
- newtype = 1;
+ newtype = 1;
+ }
+ resolved_scope = rtab;
}
- resolved_scope = rtab;
}
} else {
/* Name is unqualified. */
if (strncmp(c, "p.", 2) == 0) {
if (SwigType_type(c + 2) == T_CHAR)
return T_STRING;
+ else if (SwigType_type(c + 2) == T_WCHAR)
+ return T_WSTRING;
else
return T_POINTER;
}
return T_ARRAY;
if (strncmp(c, "r.", 2) == 0)
return T_REFERENCE;
+ if (strncmp(c, "z.", 2) == 0)
+ return T_RVALUE_REFERENCE;
if (strncmp(c, "m(", 2) == 0)
return T_MPOINTER;
if (strncmp(c, "q(", 2) == 0) {
return T_SCHAR;
if (strcmp(c, "unsigned char") == 0)
return T_UCHAR;
+ if (strcmp(c, "wchar_t") == 0)
+ return T_WCHAR;
if (strcmp(c, "float") == 0)
return T_FLOAT;
if (strcmp(c, "double") == 0)
return T_ULONGLONG;
if (strncmp(c, "enum ", 5) == 0)
return T_INT;
+ if (strcmp(c, "auto") == 0)
+ return T_AUTO;
if (strcmp(c, "v(...)") == 0)
return T_VARARGS;
*
* 2.- swig doesn't mark 'type' as non-assignable.
*
- * 3.- the user specify that the value wrapper is not needed by using
- * the %feature("novaluewrapper"), in that case the user need to type
+ * 3.- the user specifies that the value wrapper is not needed by using
+ * %feature("novaluewrapper") like so:
*
* %feature("novaluewrapper") MyOpaqueClass;
* class MyOpaqueClass;
*
- * Users can also force the use of the value wrapper by using the
+ * The user can also force the use of the value wrapper with
* %feature("valuewrapper").
* ----------------------------------------------------------------------------- */
SwigType_del_reference(tt);
SwigType_add_pointer(tt);
SwigType_remember_clientdata(tt, clientdata);
+ } else if (SwigType_isrvalue_reference(t)) {
+ SwigType *tt = Copy(t);
+ SwigType_del_rvalue_reference(tt);
+ SwigType_add_pointer(tt);
+ SwigType_remember_clientdata(tt, clientdata);
}
}
--- /dev/null
+#!/bin/bash
+
+# Wrapper around 'brew install' emitting a message every minute if the command is still running.
+# This is used on Travis to ensure the install isn't killed when there is no output over a long period (10 minutes).
+# Usage: brew-install package, where package is the name of the package for brew to install.
+
+seconds=0
+minutes=0
+brew install $1 &
+while true; do
+ ps -p$! 2>& 1>/dev/null
+ if [ $? = 0 ]; then
+ if [ $seconds = 60 ]; then
+ let seconds=0
+ let minutes=minutes+1
+ echo "brew install $1 still running ($minutes min)"
+ fi
+ sleep 1
+ let seconds=seconds+1
+ else
+ break
+ fi
+done
+wait $!
+exit $?
+++ /dev/null
-dnl @synopsis AC_COMPARE_VERSION\
-dnl (version-a, version-b, action-if-greater, action-if-equal, action-if-less)
-dnl
-dnl This macro compares two version numbers and executes the indicated action
-dnl based on whether they're equal or one is greater than the other.
-dnl It's needed to determine whether ocaml is new enough that the incompatible
-dnl change 'loc' -> '_loc' is present in this version of camlp4.
-dnl
-dnl It's implemented from scratch just for SWIG by arty.
-dnl
-dnl @category Misc
-dnl @author arty
-dnl @version 2006-11-02
-dnl @license GPLWithACException
-
-AC_DEFUN([AC_COMPARE_VERSION], [
- # Split the version into units.
- ver_a="[$1]"
- ver_b="[$2]"
- nodots_a=`echo $ver_a | sed -e 's/\./ /g'`
- condition="equal"
- isolate_b_regex='\([[0-9]]\+\).*'
- for ver_part in $nodots_a ; do
- b_ver_part=`echo "$ver_b" | sed -e 's/'"$isolate_b_regex"'/\1/'`
- if test \( "$ver_part" -lt "$b_ver_part" \) -a \( "x$condition" = "xequal" \) ; then
- condition=less
- elif test \( "$ver_part" -gt "$b_ver_part" \) -a \( "x$condition" = "xequal" \) ; then
- condition=greater
- fi
- isolate_b_regex='[[0-9]]\+\.'"$isolate_b_regex"
- done
-
- if test "x$condition" = "xequal" ; then
- [$4]
- elif test "x$condition" = "xless" ; then
- [$3]
- elif test "x$condition" = "xgreater" ; then
- [$5]
- fi
-])
dnl Currently supports g++ and gcc.
dnl
dnl The compiler options are always added CFLAGS and CXXFLAGS even if
-dnl these are overidden at configure time. Removing the maximum warning
+dnl these are overridden at configure time. Removing the maximum warning
dnl flags can be removed with --without-maximum-compile-warnings. For example:
dnl
dnl ./configure --without-maximum-compile-warnings CFLAGS= CXXFLAGS=
# and this notice are preserved. This file is offered as-is, without any
# warranty.
-#serial 20
+#serial 26
AC_DEFUN([AX_BOOST_BASE],
[
dnl are found, e.g. when only header-only libraries are installed!
libsubdirs="lib"
ax_arch=`uname -m`
- if test $ax_arch = x86_64 -o $ax_arch = ppc64 -o $ax_arch = s390x -o $ax_arch = sparc64; then
- libsubdirs="lib64 lib lib64"
- fi
+ case $ax_arch in
+ x86_64)
+ libsubdirs="lib64 libx32 lib lib64"
+ ;;
+ ppc64|s390x|sparc64|aarch64|ppc64le)
+ libsubdirs="lib64 lib lib64 ppc64le"
+ ;;
+ esac
+
+ dnl allow for real multi-arch paths e.g. /usr/lib/x86_64-linux-gnu. Give
+ dnl them priority over the other paths since, if libs are found there, they
+ dnl are almost assuredly the ones desired.
+ AC_REQUIRE([AC_CANONICAL_HOST])
+ libsubdirs="lib/${host_cpu}-${host_os} $libsubdirs"
+
+ case ${host_cpu} in
+ i?86)
+ libsubdirs="lib/i386-${host_os} $libsubdirs"
+ ;;
+ esac
dnl first we check the system location for boost libraries
dnl this location ist chosen if boost libraries are installed with the --layout=system option
dnl if we found no boost with system layout we search for boost libraries
dnl built and installed without the --layout=system option or for a staged(not installed) version
if test "x$succeeded" != "xyes"; then
+ CPPFLAGS="$CPPFLAGS_SAVED"
+ LDFLAGS="$LDFLAGS_SAVED"
+ BOOST_CPPFLAGS=
+ BOOST_LDFLAGS=
_version=0
if test "$ac_boost_path" != ""; then
if test -d "$ac_boost_path" && test -r "$ac_boost_path"; then
VERSION_UNDERSCORE=`echo $_version | sed 's/\./_/'`
BOOST_CPPFLAGS="-I$ac_boost_path/include/boost-$VERSION_UNDERSCORE"
done
+ dnl if nothing found search for layout used in Windows distributions
+ if test -z "$BOOST_CPPFLAGS"; then
+ if test -d "$ac_boost_path/boost" && test -r "$ac_boost_path/boost"; then
+ BOOST_CPPFLAGS="-I$ac_boost_path"
+ fi
+ fi
fi
else
if test "$cross_compiling" != yes; then
--- /dev/null
+# ============================================================================
+# http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
+# ============================================================================
+#
+# SYNOPSIS
+#
+# AX_CXX_COMPILE_STDCXX_11([ext|noext], [nostop])
+#
+# DESCRIPTION
+#
+# Check for baseline language coverage in the compiler for the C++11
+# standard; if necessary, add switches to CXXFLAGS to enable support.
+# CXX11FLAGS will also contain any necessary switches to enable support.
+# HAVE_CXX11_COMPILER will additionally be set to yes if there is support.
+# If the second argument is not specified, errors out if no mode that
+# supports C++11 baseline syntax can be found. The first argument, if
+# specified, indicates whether you insist on an extended mode
+# (e.g. -std=gnu++11) or a strict conformance mode (e.g. -std=c++11).
+# If neither is specified, you get whatever works, with preference for an
+# extended mode.
+#
+# LICENSE
+#
+# Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+# Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+# Copyright (c) 2012 William Fulton <wsf@fultondesigns.co.uk>
+#
+# Copying and distribution of this file, with or without modification, are
+# permitted in any medium without royalty provided the copyright notice
+# and this notice are preserved. This file is offered as-is, without any
+# warranty.
+
+#serial 1
+
+m4_define([_AX_CXX_COMPILE_STDCXX_11_testbody], [
+ template <typename T>
+ struct check
+ {
+ static_assert(sizeof(int) <= sizeof(T), "not big enough");
+ };
+
+ typedef check<check<bool>> right_angle_brackets;
+
+ int a;
+ decltype(a) b;
+
+ typedef check<int> check_type;
+ check_type c;
+ check_type&& cr = static_cast<check_type&&>(c);
+])
+
+AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [dnl
+ m4_if([$1], [], [],
+ [$1], [ext], [],
+ [$1], [noext], [],
+ [m4_fatal([invalid argument `$1' to AX_CXX_COMPILE_STDCXX_11])])dnl
+ m4_if([$2], [], [],
+ [$2], [nostop], [],
+ [m4_fatal([invalid argument `$2' to AX_CXX_COMPILE_STDCXX_11])])dnl
+ AC_LANG_ASSERT([C++])dnl
+ ac_success=no
+ CXX11FLAGS=
+ AC_CACHE_CHECK(whether $CXX supports C++11 features by default,
+ ax_cv_cxx_compile_cxx11,
+ [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
+ [ax_cv_cxx_compile_cxx11=yes],
+ [ax_cv_cxx_compile_cxx11=no])])
+ if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+ ac_success=yes
+ fi
+
+ m4_if([$1], [noext], [], [dnl
+ if test x$ac_success = xno; then
+ for switch in -std=gnu++11 -std=gnu++0x; do
+ cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
+ AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
+ $cachevar,
+ [ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS $switch"
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
+ [eval $cachevar=yes],
+ [eval $cachevar=no])
+ CXXFLAGS="$ac_save_CXXFLAGS"])
+ if eval test x\$$cachevar = xyes; then
+ CXXFLAGS="$CXXFLAGS $switch"
+ CXX11FLAGS=$switch
+ ac_success=yes
+ break
+ fi
+ done
+ fi])
+
+ m4_if([$1], [ext], [], [dnl
+ if test x$ac_success = xno; then
+ for switch in -std=c++11 -std=c++0x; do
+ cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
+ AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
+ $cachevar,
+ [ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS $switch"
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
+ [eval $cachevar=yes],
+ [eval $cachevar=no])
+ CXXFLAGS="$ac_save_CXXFLAGS"])
+ if eval test x\$$cachevar = xyes; then
+ CXXFLAGS="$CXXFLAGS $switch"
+ CXX11FLAGS=$switch
+ ac_success=yes
+ break
+ fi
+ done
+ fi])
+
+ if test x$ac_success = xno; then
+ if test x$2 != xnostop; then
+ AC_MSG_ERROR([*** A compiler with support for C++11 language features is required.])
+ fi
+ else
+ HAVE_CXX11_COMPILER=yes
+ fi
+])
# and this notice are preserved. This file is offered as-is, without any
# warranty.
-#serial 11
+#serial 13
AU_ALIAS([AC_PATH_GENERIC], [AX_PATH_GENERIC])
AC_DEFUN([AX_PATH_GENERIC],[
AC_ARG_VAR(UP[]_CFLAGS, [CFLAGS used for $1])
AC_ARG_VAR(UP[]_LIBS, [LIBS used for $1])
- AS_IF([test x$UP[]_CFLAGS != x -o x$UP[]_LIBS != x],[
+ AS_IF([test x"$UP[]_CFLAGS" != x -o x"$UP[]_LIBS" != x],[
dnl Don't run config script at all, use user-provided values instead.
AC_SUBST(UP[]_CFLAGS)
AC_SUBST(UP[]_LIBS)
#! /bin/sh
# Wrapper for compilers which do not understand '-c -o'.
-scriptversion=2012-01-04.17; # UTC
+scriptversion=2012-10-14.11; # UTC
-# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2009, 2010, 2012 Free
-# Software Foundation, Inc.
+# Copyright (C) 1999-2014 Free Software Foundation, Inc.
# Written by Tom Tromey <tromey@cygnus.com>.
#
# This program is free software; you can redistribute it and/or modify
esac
}
+# func_cl_dashL linkdir
+# Make cl look for libraries in LINKDIR
+func_cl_dashL ()
+{
+ func_file_conv "$1"
+ if test -z "$lib_path"; then
+ lib_path=$file
+ else
+ lib_path="$lib_path;$file"
+ fi
+ linker_opts="$linker_opts -LIBPATH:$file"
+}
+
+# func_cl_dashl library
+# Do a library search-path lookup for cl
+func_cl_dashl ()
+{
+ lib=$1
+ found=no
+ save_IFS=$IFS
+ IFS=';'
+ for dir in $lib_path $LIB
+ do
+ IFS=$save_IFS
+ if $shared && test -f "$dir/$lib.dll.lib"; then
+ found=yes
+ lib=$dir/$lib.dll.lib
+ break
+ fi
+ if test -f "$dir/$lib.lib"; then
+ found=yes
+ lib=$dir/$lib.lib
+ break
+ fi
+ if test -f "$dir/lib$lib.a"; then
+ found=yes
+ lib=$dir/lib$lib.a
+ break
+ fi
+ done
+ IFS=$save_IFS
+
+ if test "$found" != yes; then
+ lib=$lib.lib
+ fi
+}
+
# func_cl_wrapper cl arg...
# Adjust compile command to suit cl
func_cl_wrapper ()
;;
esac
;;
+ -I)
+ eat=1
+ func_file_conv "$2" mingw
+ set x "$@" -I"$file"
+ shift
+ ;;
-I*)
func_file_conv "${1#-I}" mingw
set x "$@" -I"$file"
shift
;;
+ -l)
+ eat=1
+ func_cl_dashl "$2"
+ set x "$@" "$lib"
+ shift
+ ;;
-l*)
- lib=${1#-l}
- found=no
- save_IFS=$IFS
- IFS=';'
- for dir in $lib_path $LIB
- do
- IFS=$save_IFS
- if $shared && test -f "$dir/$lib.dll.lib"; then
- found=yes
- set x "$@" "$dir/$lib.dll.lib"
- break
- fi
- if test -f "$dir/$lib.lib"; then
- found=yes
- set x "$@" "$dir/$lib.lib"
- break
- fi
- done
- IFS=$save_IFS
-
- test "$found" != yes && set x "$@" "$lib.lib"
+ func_cl_dashl "${1#-l}"
+ set x "$@" "$lib"
shift
;;
+ -L)
+ eat=1
+ func_cl_dashL "$2"
+ ;;
-L*)
- func_file_conv "${1#-L}"
- if test -z "$lib_path"; then
- lib_path=$file
- else
- lib_path="$lib_path;$file"
- fi
- linker_opts="$linker_opts -LIBPATH:$file"
+ func_cl_dashL "${1#-L}"
;;
-static)
shared=false
#! /bin/sh
# Attempt to guess a canonical system name.
-# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-# 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
-# 2011, 2012 Free Software Foundation, Inc.
+# Copyright 1992-2015 Free Software Foundation, Inc.
-timestamp='2012-02-10'
+timestamp='2015-08-20'
# This file is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
+# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that program.
-
-
-# Originally written by Per Bothner. Please send patches (context
-# diff format) to <config-patches@gnu.org> and include a ChangeLog
-# entry.
+# the same distribution terms that you use for the rest of that
+# program. This Exception is an additional permission under section 7
+# of the GNU General Public License, version 3 ("GPLv3").
#
-# This script attempts to guess a canonical system name similar to
-# config.sub. If it succeeds, it prints the system name on stdout, and
-# exits with 0. Otherwise, it exits with 1.
+# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
#
# You can get the latest version of this script from:
# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
+#
+# Please send patches to <config-patches@gnu.org>.
+
me=`echo "$0" | sed -e 's,.*/,,'`
GNU config.guess ($timestamp)
Originally written by Per Bothner.
-Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
-Free Software Foundation, Inc.
+Copyright 1992-2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+case "${UNAME_SYSTEM}" in
+Linux|GNU|GNU/*)
+ # If the system lacks a compiler, then just pick glibc.
+ # We could probably try harder.
+ LIBC=gnu
+
+ eval $set_cc_for_build
+ cat <<-EOF > $dummy.c
+ #include <features.h>
+ #if defined(__UCLIBC__)
+ LIBC=uclibc
+ #elif defined(__dietlibc__)
+ LIBC=dietlibc
+ #else
+ LIBC=gnu
+ #endif
+ EOF
+ eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`
+ ;;
+esac
+
# Note: order is significant - the case branches are not exclusive.
case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
# Note: NetBSD doesn't particularly care about the vendor
# portion of the name. We always set it to "unknown".
sysctl="sysctl -n hw.machine_arch"
- UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
- /usr/sbin/$sysctl 2>/dev/null || echo unknown)`
+ UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
+ /sbin/$sysctl 2>/dev/null || \
+ /usr/sbin/$sysctl 2>/dev/null || \
+ echo unknown)`
case "${UNAME_MACHINE_ARCH}" in
armeb) machine=armeb-unknown ;;
arm*) machine=arm-unknown ;;
sh3el) machine=shl-unknown ;;
sh3eb) machine=sh-unknown ;;
sh5el) machine=sh5le-unknown ;;
+ earmv*)
+ arch=`echo ${UNAME_MACHINE_ARCH} | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
+ endian=`echo ${UNAME_MACHINE_ARCH} | sed -ne 's,^.*\(eb\)$,\1,p'`
+ machine=${arch}${endian}-unknown
+ ;;
*) machine=${UNAME_MACHINE_ARCH}-unknown ;;
esac
# The Operating System including object format, if it has switched
# to ELF recently, or will in the future.
case "${UNAME_MACHINE_ARCH}" in
- arm*|i386|m68k|ns32k|sh3*|sparc|vax)
+ arm*|earm*|i386|m68k|ns32k|sh3*|sparc|vax)
eval $set_cc_for_build
if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
| grep -q __ELF__
os=netbsd
;;
esac
+ # Determine ABI tags.
+ case "${UNAME_MACHINE_ARCH}" in
+ earm*)
+ expr='s/^earmv[0-9]/-eabi/;s/eb$//'
+ abi=`echo ${UNAME_MACHINE_ARCH} | sed -e "$expr"`
+ ;;
+ esac
# The OS release
# Debian GNU/NetBSD machines have a different userland, and
# thus, need a distinct triplet. However, they do not need
release='-gnu'
;;
*)
- release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
+ release=`echo ${UNAME_RELEASE} | sed -e 's/[-_].*//' | cut -d. -f1,2`
;;
esac
# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
# contains redundant information, the shorter form:
# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
- echo "${machine}-${os}${release}"
+ echo "${machine}-${os}${release}${abi}"
+ exit ;;
+ *:Bitrig:*:*)
+ UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
+ echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE}
exit ;;
*:OpenBSD:*:*)
UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
*:MirBSD:*:*)
echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
exit ;;
+ *:Sortix:*:*)
+ echo ${UNAME_MACHINE}-unknown-sortix
+ exit ;;
alpha:OSF1:*:*)
case $UNAME_RELEASE in
*4.0)
arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
echo arm-acorn-riscix${UNAME_RELEASE}
exit ;;
- arm:riscos:*:*|arm:RISCOS:*:*)
+ arm*:riscos:*:*|arm*:RISCOS:*:*)
echo arm-unknown-riscos
exit ;;
SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
else
IBM_ARCH=powerpc
fi
- if [ -x /usr/bin/oslevel ] ; then
- IBM_REV=`/usr/bin/oslevel`
+ if [ -x /usr/bin/lslpp ] ; then
+ IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc |
+ awk -F: '{ print $3 }' | sed s/[0-9]*$/0/`
else
IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
fi
i*:CYGWIN*:*)
echo ${UNAME_MACHINE}-pc-cygwin
exit ;;
+ *:MINGW64*:*)
+ echo ${UNAME_MACHINE}-pc-mingw64
+ exit ;;
*:MINGW*:*)
echo ${UNAME_MACHINE}-pc-mingw32
exit ;;
- i*:MSYS*:*)
+ *:MSYS*:*)
echo ${UNAME_MACHINE}-pc-msys
exit ;;
i*:windows32*:*)
exit ;;
*:GNU:*:*)
# the GNU system
- echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+ echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
exit ;;
*:GNU/*:*:*)
# other systems with GNU libc and userland
- echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu
+ echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC}
exit ;;
i*86:Minix:*:*)
echo ${UNAME_MACHINE}-pc-minix
exit ;;
aarch64:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
aarch64_be:Linux:*:*)
UNAME_MACHINE=aarch64_be
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
alpha:Linux:*:*)
case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
EV68*) UNAME_MACHINE=alphaev68 ;;
esac
objdump --private-headers /bin/sh | grep -q ld.so.1
- if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi
- echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
+ if test "$?" = 0 ; then LIBC="gnulibc1" ; fi
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ arc:Linux:*:* | arceb:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
arm*:Linux:*:*)
eval $set_cc_for_build
if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
| grep -q __ARM_EABI__
then
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
else
if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
| grep -q __ARM_PCS_VFP
then
- echo ${UNAME_MACHINE}-unknown-linux-gnueabi
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi
else
- echo ${UNAME_MACHINE}-unknown-linux-gnueabihf
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf
fi
fi
exit ;;
avr32*:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
cris:Linux:*:*)
- echo ${UNAME_MACHINE}-axis-linux-gnu
+ echo ${UNAME_MACHINE}-axis-linux-${LIBC}
exit ;;
crisv32:Linux:*:*)
- echo ${UNAME_MACHINE}-axis-linux-gnu
+ echo ${UNAME_MACHINE}-axis-linux-${LIBC}
+ exit ;;
+ e2k:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
frv:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
hexagon:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
i*86:Linux:*:*)
- LIBC=gnu
- eval $set_cc_for_build
- sed 's/^ //' << EOF >$dummy.c
- #ifdef __dietlibc__
- LIBC=dietlibc
- #endif
-EOF
- eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'`
- echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
+ echo ${UNAME_MACHINE}-pc-linux-${LIBC}
exit ;;
ia64:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
m32r*:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
m68*:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
mips:Linux:*:* | mips64:Linux:*:*)
eval $set_cc_for_build
#endif
EOF
eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
- test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
+ test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
;;
- or32:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ openrisc*:Linux:*:*)
+ echo or1k-unknown-linux-${LIBC}
+ exit ;;
+ or32:Linux:*:* | or1k*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
padre:Linux:*:*)
- echo sparc-unknown-linux-gnu
+ echo sparc-unknown-linux-${LIBC}
exit ;;
parisc64:Linux:*:* | hppa64:Linux:*:*)
- echo hppa64-unknown-linux-gnu
+ echo hppa64-unknown-linux-${LIBC}
exit ;;
parisc:Linux:*:* | hppa:Linux:*:*)
# Look for CPU level
case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
- PA7*) echo hppa1.1-unknown-linux-gnu ;;
- PA8*) echo hppa2.0-unknown-linux-gnu ;;
- *) echo hppa-unknown-linux-gnu ;;
+ PA7*) echo hppa1.1-unknown-linux-${LIBC} ;;
+ PA8*) echo hppa2.0-unknown-linux-${LIBC} ;;
+ *) echo hppa-unknown-linux-${LIBC} ;;
esac
exit ;;
ppc64:Linux:*:*)
- echo powerpc64-unknown-linux-gnu
+ echo powerpc64-unknown-linux-${LIBC}
exit ;;
ppc:Linux:*:*)
- echo powerpc-unknown-linux-gnu
+ echo powerpc-unknown-linux-${LIBC}
+ exit ;;
+ ppc64le:Linux:*:*)
+ echo powerpc64le-unknown-linux-${LIBC}
+ exit ;;
+ ppcle:Linux:*:*)
+ echo powerpcle-unknown-linux-${LIBC}
exit ;;
s390:Linux:*:* | s390x:Linux:*:*)
- echo ${UNAME_MACHINE}-ibm-linux
+ echo ${UNAME_MACHINE}-ibm-linux-${LIBC}
exit ;;
sh64*:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
sh*:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
sparc:Linux:*:* | sparc64:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
tile*:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
vax:Linux:*:*)
- echo ${UNAME_MACHINE}-dec-linux-gnu
+ echo ${UNAME_MACHINE}-dec-linux-${LIBC}
exit ;;
x86_64:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-pc-linux-${LIBC}
exit ;;
xtensa*:Linux:*:*)
- echo ${UNAME_MACHINE}-unknown-linux-gnu
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
i*86:DYNIX/ptx:4*:*)
# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
BePC:Haiku:*:*) # Haiku running on Intel PC compatible.
echo i586-pc-haiku
exit ;;
+ x86_64:Haiku:*:*)
+ echo x86_64-unknown-haiku
+ exit ;;
SX-4:SUPER-UX:*:*)
echo sx4-nec-superux${UNAME_RELEASE}
exit ;;
exit ;;
*:Darwin:*:*)
UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
- case $UNAME_PROCESSOR in
- i386)
- eval $set_cc_for_build
- if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
- if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
- (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
- grep IS_64BIT_ARCH >/dev/null
- then
- UNAME_PROCESSOR="x86_64"
- fi
- fi ;;
- unknown) UNAME_PROCESSOR=powerpc ;;
- esac
+ eval $set_cc_for_build
+ if test "$UNAME_PROCESSOR" = unknown ; then
+ UNAME_PROCESSOR=powerpc
+ fi
+ if test `echo "$UNAME_RELEASE" | sed -e 's/\..*//'` -le 10 ; then
+ if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
+ if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
+ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
+ grep IS_64BIT_ARCH >/dev/null
+ then
+ case $UNAME_PROCESSOR in
+ i386) UNAME_PROCESSOR=x86_64 ;;
+ powerpc) UNAME_PROCESSOR=powerpc64 ;;
+ esac
+ fi
+ fi
+ elif test "$UNAME_PROCESSOR" = i386 ; then
+ # Avoid executing cc on OS X 10.9, as it ships with a stub
+ # that puts up a graphical alert prompting to install
+ # developer tools. Any system running Mac OS X 10.7 or
+ # later (Darwin 11 and later) is required to have a 64-bit
+ # processor. This is not true of the ARM version of Darwin
+ # that Apple uses in portable devices.
+ UNAME_PROCESSOR=x86_64
+ fi
echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
exit ;;
*:procnto*:*:* | *:QNX:[0123456789]*:*)
NEO-?:NONSTOP_KERNEL:*:*)
echo neo-tandem-nsk${UNAME_RELEASE}
exit ;;
- NSE-?:NONSTOP_KERNEL:*:*)
+ NSE-*:NONSTOP_KERNEL:*:*)
echo nse-tandem-nsk${UNAME_RELEASE}
exit ;;
NSR-?:NONSTOP_KERNEL:*:*)
exit ;;
esac
-#echo '(No uname command or uname output not recognized.)' 1>&2
-#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2
-
-eval $set_cc_for_build
-cat >$dummy.c <<EOF
-#ifdef _SEQUENT_
-# include <sys/types.h>
-# include <sys/utsname.h>
-#endif
-main ()
-{
-#if defined (sony)
-#if defined (MIPSEB)
- /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed,
- I don't know.... */
- printf ("mips-sony-bsd\n"); exit (0);
-#else
-#include <sys/param.h>
- printf ("m68k-sony-newsos%s\n",
-#ifdef NEWSOS4
- "4"
-#else
- ""
-#endif
- ); exit (0);
-#endif
-#endif
-
-#if defined (__arm) && defined (__acorn) && defined (__unix)
- printf ("arm-acorn-riscix\n"); exit (0);
-#endif
-
-#if defined (hp300) && !defined (hpux)
- printf ("m68k-hp-bsd\n"); exit (0);
-#endif
-
-#if defined (NeXT)
-#if !defined (__ARCHITECTURE__)
-#define __ARCHITECTURE__ "m68k"
-#endif
- int version;
- version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
- if (version < 4)
- printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
- else
- printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
- exit (0);
-#endif
-
-#if defined (MULTIMAX) || defined (n16)
-#if defined (UMAXV)
- printf ("ns32k-encore-sysv\n"); exit (0);
-#else
-#if defined (CMU)
- printf ("ns32k-encore-mach\n"); exit (0);
-#else
- printf ("ns32k-encore-bsd\n"); exit (0);
-#endif
-#endif
-#endif
-
-#if defined (__386BSD__)
- printf ("i386-pc-bsd\n"); exit (0);
-#endif
-
-#if defined (sequent)
-#if defined (i386)
- printf ("i386-sequent-dynix\n"); exit (0);
-#endif
-#if defined (ns32000)
- printf ("ns32k-sequent-dynix\n"); exit (0);
-#endif
-#endif
-
-#if defined (_SEQUENT_)
- struct utsname un;
-
- uname(&un);
-
- if (strncmp(un.version, "V2", 2) == 0) {
- printf ("i386-sequent-ptx2\n"); exit (0);
- }
- if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
- printf ("i386-sequent-ptx1\n"); exit (0);
- }
- printf ("i386-sequent-ptx\n"); exit (0);
-
-#endif
-
-#if defined (vax)
-# if !defined (ultrix)
-# include <sys/param.h>
-# if defined (BSD)
-# if BSD == 43
- printf ("vax-dec-bsd4.3\n"); exit (0);
-# else
-# if BSD == 199006
- printf ("vax-dec-bsd4.3reno\n"); exit (0);
-# else
- printf ("vax-dec-bsd\n"); exit (0);
-# endif
-# endif
-# else
- printf ("vax-dec-bsd\n"); exit (0);
-# endif
-# else
- printf ("vax-dec-ultrix\n"); exit (0);
-# endif
-#endif
-
-#if defined (alliant) && defined (i860)
- printf ("i860-alliant-bsd\n"); exit (0);
-#endif
-
- exit (1);
-}
-EOF
-
-$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` &&
- { echo "$SYSTEM_NAME"; exit; }
-
-# Apollos put the system type in the environment.
-
-test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; }
-
-# Convex versions that predate uname can use getsysinfo(1)
-
-if [ -x /usr/convex/getsysinfo ]
-then
- case `getsysinfo -f cpu_type` in
- c1*)
- echo c1-convex-bsd
- exit ;;
- c2*)
- if getsysinfo -f scalar_acc
- then echo c32-convex-bsd
- else echo c2-convex-bsd
- fi
- exit ;;
- c34*)
- echo c34-convex-bsd
- exit ;;
- c38*)
- echo c38-convex-bsd
- exit ;;
- c4*)
- echo c4-convex-bsd
- exit ;;
- esac
-fi
-
cat >&2 <<EOF
$0: unable to guess system type
#! /bin/sh
# Configuration validation subroutine script.
-# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-# 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
-# 2011, 2012 Free Software Foundation, Inc.
+# Copyright 1992-2015 Free Software Foundation, Inc.
-timestamp='2012-02-10'
+timestamp='2015-08-20'
-# This file is (in principle) common to ALL GNU software.
-# The presence of a machine in this file suggests that SOME GNU software
-# can handle that machine. It does not imply ALL GNU software can.
-#
-# This file is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that program.
+# the same distribution terms that you use for the rest of that
+# program. This Exception is an additional permission under section 7
+# of the GNU General Public License, version 3 ("GPLv3").
-# Please send patches to <config-patches@gnu.org>. Submit a context
-# diff and a properly formatted GNU ChangeLog entry.
+# Please send patches to <config-patches@gnu.org>.
#
# Configuration subroutine to validate and canonicalize a configuration type.
# Supply the specified configuration type as an argument.
version="\
GNU config.sub ($timestamp)
-Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
-Free Software Foundation, Inc.
+Copyright 1992-2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
case $maybe_os in
nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
- linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
- knetbsd*-gnu* | netbsd*-gnu* | \
+ linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
+ knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \
kopensolaris*-gnu* | \
storm-chaos* | os2-emx* | rtmk-nova*)
os=-$maybe_os
-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
- -apple | -axis | -knuth | -cray | -microblaze)
+ -apple | -axis | -knuth | -cray | -microblaze*)
os=
basic_machine=$1
;;
-isc*)
basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
;;
+ -lynx*178)
+ os=-lynxos178
+ ;;
+ -lynx*5)
+ os=-lynxos5
+ ;;
-lynx*)
os=-lynxos
;;
| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
| am33_2.0 \
- | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \
- | be32 | be64 \
+ | arc | arceb \
+ | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
+ | avr | avr32 \
+ | ba \
+ | be32 | be64 \
| bfin \
- | c4x | clipper \
+ | c4x | c8051 | clipper \
| d10v | d30v | dlx | dsp16xx \
- | epiphany \
- | fido | fr30 | frv \
+ | e2k | epiphany \
+ | fido | fr30 | frv | ft32 \
| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
| hexagon \
| i370 | i860 | i960 | ia64 \
| ip2k | iq2000 \
+ | k1om \
| le32 | le64 \
| lm32 \
| m32c | m32r | m32rle | m68000 | m68k | m88k \
- | maxq | mb | microblaze | mcore | mep | metag \
+ | maxq | mb | microblaze | microblazeel | mcore | mep | metag \
| mips | mipsbe | mipseb | mipsel | mipsle \
| mips16 \
| mips64 | mips64el \
| mips64vr5900 | mips64vr5900el \
| mipsisa32 | mipsisa32el \
| mipsisa32r2 | mipsisa32r2el \
+ | mipsisa32r6 | mipsisa32r6el \
| mipsisa64 | mipsisa64el \
| mipsisa64r2 | mipsisa64r2el \
+ | mipsisa64r6 | mipsisa64r6el \
| mipsisa64sb1 | mipsisa64sb1el \
| mipsisa64sr71k | mipsisa64sr71kel \
+ | mipsr5900 | mipsr5900el \
| mipstx39 | mipstx39el \
| mn10200 | mn10300 \
| moxie \
| mt \
| msp430 \
| nds32 | nds32le | nds32be \
- | nios | nios2 \
+ | nios | nios2 | nios2eb | nios2el \
| ns16k | ns32k \
- | open8 \
- | or32 \
+ | open8 | or1k | or1knd | or32 \
| pdp10 | pdp11 | pj | pjl \
| powerpc | powerpc64 | powerpc64le | powerpcle \
| pyramid \
+ | riscv32 | riscv64 \
| rl78 | rx \
| score \
- | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
+ | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
| sh64 | sh64le \
| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
| ubicom32 \
| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
+ | visium \
| we32k \
| x86 | xc16x | xstormy16 | xtensa \
| z8k | z80)
c6x)
basic_machine=tic6x-unknown
;;
- m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | picochip)
+ leon|leon[3-9])
+ basic_machine=sparc-$basic_machine
+ ;;
+ m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip)
basic_machine=$basic_machine-unknown
os=-none
;;
| aarch64-* | aarch64_be-* \
| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
- | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
+ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
| arm-* | armbe-* | armle-* | armeb-* | armv*-* \
| avr-* | avr32-* \
+ | ba-* \
| be32-* | be64-* \
| bfin-* | bs2000-* \
| c[123]* | c30-* | [cjt]90-* | c4x-* \
- | clipper-* | craynv-* | cydra-* \
+ | c8051-* | clipper-* | craynv-* | cydra-* \
| d10v-* | d30v-* | dlx-* \
- | elxsi-* \
+ | e2k-* | elxsi-* \
| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
| h8300-* | h8500-* \
| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
| hexagon-* \
| i*86-* | i860-* | i960-* | ia64-* \
| ip2k-* | iq2000-* \
+ | k1om-* \
| le32-* | le64-* \
| lm32-* \
| m32c-* | m32r-* | m32rle-* \
| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
- | m88110-* | m88k-* | maxq-* | mcore-* | metag-* | microblaze-* \
+ | m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
+ | microblaze-* | microblazeel-* \
| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
| mips16-* \
| mips64-* | mips64el-* \
| mips64vr5900-* | mips64vr5900el-* \
| mipsisa32-* | mipsisa32el-* \
| mipsisa32r2-* | mipsisa32r2el-* \
+ | mipsisa32r6-* | mipsisa32r6el-* \
| mipsisa64-* | mipsisa64el-* \
| mipsisa64r2-* | mipsisa64r2el-* \
+ | mipsisa64r6-* | mipsisa64r6el-* \
| mipsisa64sb1-* | mipsisa64sb1el-* \
| mipsisa64sr71k-* | mipsisa64sr71kel-* \
+ | mipsr5900-* | mipsr5900el-* \
| mipstx39-* | mipstx39el-* \
| mmix-* \
| mt-* \
| msp430-* \
| nds32-* | nds32le-* | nds32be-* \
- | nios-* | nios2-* \
+ | nios-* | nios2-* | nios2eb-* | nios2el-* \
| none-* | np1-* | ns16k-* | ns32k-* \
| open8-* \
+ | or1k*-* \
| orion-* \
| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
| pyramid-* \
+ | riscv32-* | riscv64-* \
| rl78-* | romp-* | rs6000-* | rx-* \
| sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
| sparclite-* \
- | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \
+ | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \
| tahoe-* \
| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
| tile*-* \
| ubicom32-* \
| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
| vax-* \
+ | visium-* \
| we32k-* \
| x86-* | x86_64-* | xc16x-* | xps100-* \
| xstormy16-* | xtensa*-* \
basic_machine=i386-pc
os=-aros
;;
+ asmjs)
+ basic_machine=asmjs-unknown
+ ;;
aux)
basic_machine=m68k-apple
os=-aux
basic_machine=m68k-isi
os=-sysv
;;
+ leon-*|leon[3-9]-*)
+ basic_machine=sparc-`echo $basic_machine | sed 's/-.*//'`
+ ;;
m68knommu)
basic_machine=m68k-unknown
os=-linux
basic_machine=ns32k-utek
os=-sysv
;;
- microblaze)
+ microblaze*)
basic_machine=microblaze-xilinx
;;
+ mingw64)
+ basic_machine=x86_64-pc
+ os=-mingw64
+ ;;
mingw32)
- basic_machine=i386-pc
+ basic_machine=i686-pc
os=-mingw32
;;
mingw32ce)
basic_machine=powerpc-unknown
os=-morphos
;;
+ moxiebox)
+ basic_machine=moxie-unknown
+ os=-moxiebox
+ ;;
msdos)
basic_machine=i386-pc
os=-msdos
basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
;;
msys)
- basic_machine=i386-pc
+ basic_machine=i686-pc
os=-msys
;;
mvs)
basic_machine=i586-unknown
os=-pw32
;;
- rdos)
+ rdos | rdos64)
+ basic_machine=x86_64-pc
+ os=-rdos
+ ;;
+ rdos32)
basic_machine=i386-pc
os=-rdos
;;
-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
| -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
| -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
- | -sym* | -kopensolaris* \
+ | -sym* | -kopensolaris* | -plan9* \
| -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
- | -aos* | -aros* \
+ | -aos* | -aros* | -cloudabi* | -sortix* \
| -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
| -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
| -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
- | -openbsd* | -solidbsd* \
+ | -bitrig* | -openbsd* | -solidbsd* \
| -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
| -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
| -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
| -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
| -chorusos* | -chorusrdb* | -cegcc* \
| -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
- | -mingw32* | -linux-gnu* | -linux-android* \
- | -linux-newlib* | -linux-uclibc* \
- | -uxpv* | -beos* | -mpeix* | -udk* \
+ | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
+ | -linux-newlib* | -linux-musl* | -linux-uclibc* \
+ | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
| -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
| -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
| -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
| -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
| -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
| -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
- | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*)
+ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* | -tirtos*)
# Remember, each alternative MUST END IN *, to match a version number.
;;
-qnx*)
-aros*)
os=-aros
;;
- -kaos*)
- os=-kaos
- ;;
-zvmoe)
os=-zvmoe
;;
c4x-* | tic4x-*)
os=-coff
;;
+ c8051-*)
+ os=-elf
+ ;;
+ hexagon-*)
+ os=-elf
+ ;;
tic54x-*)
os=-coff
;;
#! /bin/sh
# depcomp - compile a program generating dependencies as side-effects
-scriptversion=2011-12-04.11; # UTC
+scriptversion=2013-05-30.07; # UTC
-# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2009, 2010,
-# 2011 Free Software Foundation, Inc.
+# Copyright (C) 1999-2014 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
case $1 in
'')
- echo "$0: No command. Try \`$0 --help' for more information." 1>&2
- exit 1;
- ;;
+ echo "$0: No command. Try '$0 --help' for more information." 1>&2
+ exit 1;
+ ;;
-h | --h*)
cat <<\EOF
Usage: depcomp [--help] [--version] PROGRAM [ARGS]
Environment variables:
depmode Dependency tracking mode.
- source Source file read by `PROGRAMS ARGS'.
- object Object file output by `PROGRAMS ARGS'.
+ source Source file read by 'PROGRAMS ARGS'.
+ object Object file output by 'PROGRAMS ARGS'.
DEPDIR directory where to store dependencies.
depfile Dependency file to output.
tmpdepfile Temporary file to use when outputting dependencies.
;;
esac
+# Get the directory component of the given path, and save it in the
+# global variables '$dir'. Note that this directory component will
+# be either empty or ending with a '/' character. This is deliberate.
+set_dir_from ()
+{
+ case $1 in
+ */*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;;
+ *) dir=;;
+ esac
+}
+
+# Get the suffix-stripped basename of the given path, and save it the
+# global variable '$base'.
+set_base_from ()
+{
+ base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'`
+}
+
+# If no dependency file was actually created by the compiler invocation,
+# we still have to create a dummy depfile, to avoid errors with the
+# Makefile "include basename.Plo" scheme.
+make_dummy_depfile ()
+{
+ echo "#dummy" > "$depfile"
+}
+
+# Factor out some common post-processing of the generated depfile.
+# Requires the auxiliary global variable '$tmpdepfile' to be set.
+aix_post_process_depfile ()
+{
+ # If the compiler actually managed to produce a dependency file,
+ # post-process it.
+ if test -f "$tmpdepfile"; then
+ # Each line is of the form 'foo.o: dependency.h'.
+ # Do two passes, one to just change these to
+ # $object: dependency.h
+ # and one to simply output
+ # dependency.h:
+ # which is needed to avoid the deleted-header problem.
+ { sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile"
+ sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile"
+ } > "$depfile"
+ rm -f "$tmpdepfile"
+ else
+ make_dummy_depfile
+ fi
+}
+
+# A tabulation character.
+tab=' '
+# A newline character.
+nl='
+'
+# Character ranges might be problematic outside the C locale.
+# These definitions help.
+upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
+lower=abcdefghijklmnopqrstuvwxyz
+digits=0123456789
+alpha=${upper}${lower}
+
if test -z "$depmode" || test -z "$source" || test -z "$object"; then
echo "depcomp: Variables source, object and depmode must be set" 1>&2
exit 1
rm -f "$tmpdepfile"
+# Avoid interferences from the environment.
+gccflag= dashmflag=
+
# Some modes work just like other modes, but use different flags. We
# parameterize here, but still list the modes in the big case below,
# to make depend.m4 easier to write. Note that we *cannot* use a case
fi
if test "$depmode" = dashXmstdout; then
- # This is just like dashmstdout with a different argument.
- dashmflag=-xM
- depmode=dashmstdout
+ # This is just like dashmstdout with a different argument.
+ dashmflag=-xM
+ depmode=dashmstdout
fi
cygpath_u="cygpath -u -f -"
if test "$depmode" = msvcmsys; then
- # This is just like msvisualcpp but w/o cygpath translation.
- # Just convert the backslash-escaped backslashes to single forward
- # slashes to satisfy depend.m4
- cygpath_u='sed s,\\\\,/,g'
- depmode=msvisualcpp
+ # This is just like msvisualcpp but w/o cygpath translation.
+ # Just convert the backslash-escaped backslashes to single forward
+ # slashes to satisfy depend.m4
+ cygpath_u='sed s,\\\\,/,g'
+ depmode=msvisualcpp
fi
if test "$depmode" = msvc7msys; then
- # This is just like msvc7 but w/o cygpath translation.
- # Just convert the backslash-escaped backslashes to single forward
- # slashes to satisfy depend.m4
- cygpath_u='sed s,\\\\,/,g'
- depmode=msvc7
+ # This is just like msvc7 but w/o cygpath translation.
+ # Just convert the backslash-escaped backslashes to single forward
+ # slashes to satisfy depend.m4
+ cygpath_u='sed s,\\\\,/,g'
+ depmode=msvc7
+fi
+
+if test "$depmode" = xlc; then
+ # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
+ gccflag=-qmakedep=gcc,-MF
+ depmode=gcc
fi
case "$depmode" in
done
"$@"
stat=$?
- if test $stat -eq 0; then :
- else
+ if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
;;
gcc)
+## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
+## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
+## (see the conditional assignment to $gccflag above).
## There are various ways to get dependency output from gcc. Here's
## why we pick this rather obscure method:
## - Don't want to use -MD because we'd like the dependencies to end
## up in a subdir. Having to rename by hand is ugly.
## (We might end up doing this anyway to support other compilers.)
## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
-## -MM, not -M (despite what the docs say).
+## -MM, not -M (despite what the docs say). Also, it might not be
+## supported by the other compilers which use the 'gcc' depmode.
## - Using -M directly means running the compiler twice (even worse
## than renaming).
if test -z "$gccflag"; then
fi
"$@" -Wp,"$gccflag$tmpdepfile"
stat=$?
- if test $stat -eq 0; then :
- else
+ if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
echo "$object : \\" > "$depfile"
- alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
-## The second -e expression handles DOS-style file names with drive letters.
+ # The second -e expression handles DOS-style file names with drive
+ # letters.
sed -e 's/^[^:]*: / /' \
-e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
-## This next piece of magic avoids the `deleted header file' problem.
+## This next piece of magic avoids the "deleted header file" problem.
## The problem is that when a header file which appears in a .P file
## is deleted, the dependency causes make to die (because there is
## typically no way to rebuild the header). We avoid this by adding
## dummy dependencies for each header file. Too bad gcc doesn't do
## this for us directly.
- tr ' ' '
-' < "$tmpdepfile" |
-## Some versions of gcc put a space before the `:'. On the theory
+## Some versions of gcc put a space before the ':'. On the theory
## that the space means something, we add a space to the output as
## well. hp depmode also adds that space, but also prefixes the VPATH
## to the object. Take care to not repeat it in the output.
## Some versions of the HPUX 10.20 sed can't process this invocation
## correctly. Breaking it into two sed invocations is a workaround.
- sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
- | sed -e 's/$/ :/' >> "$depfile"
+ tr ' ' "$nl" < "$tmpdepfile" \
+ | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
+ | sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
"$@" -MDupdate "$tmpdepfile"
fi
stat=$?
- if test $stat -eq 0; then :
- else
+ if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files
echo "$object : \\" > "$depfile"
-
# Clip off the initial element (the dependent). Don't try to be
# clever and replace this with sed code, as IRIX sed won't handle
# lines with more than a fixed number of characters (4096 in
# IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines;
- # the IRIX cc adds comments like `#:fec' to the end of the
+ # the IRIX cc adds comments like '#:fec' to the end of the
# dependency line.
- tr ' ' '
-' < "$tmpdepfile" \
- | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
- tr '
-' ' ' >> "$depfile"
+ tr ' ' "$nl" < "$tmpdepfile" \
+ | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \
+ | tr "$nl" ' ' >> "$depfile"
echo >> "$depfile"
-
# The second pass generates a dummy entry for each header file.
- tr ' ' '
-' < "$tmpdepfile" \
- | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
- >> "$depfile"
+ tr ' ' "$nl" < "$tmpdepfile" \
+ | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
+ >> "$depfile"
else
- # The sourcefile does not contain any dependencies, so just
- # store a dummy comment line, to avoid errors with the Makefile
- # "include basename.Plo" scheme.
- echo "#dummy" > "$depfile"
+ make_dummy_depfile
fi
rm -f "$tmpdepfile"
;;
+xlc)
+ # This case exists only to let depend.m4 do its work. It works by
+ # looking at the text of this script. This case will never be run,
+ # since it is checked for above.
+ exit 1
+ ;;
+
aix)
# The C for AIX Compiler uses -M and outputs the dependencies
# in a .u file. In older versions, this file always lives in the
- # current directory. Also, the AIX compiler puts `$object:' at the
+ # current directory. Also, the AIX compiler puts '$object:' at the
# start of each line; $object doesn't have directory information.
# Version 6 uses the directory in both cases.
- dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
- test "x$dir" = "x$object" && dir=
- base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+ set_dir_from "$object"
+ set_base_from "$object"
if test "$libtool" = yes; then
tmpdepfile1=$dir$base.u
tmpdepfile2=$base.u
"$@" -M
fi
stat=$?
-
- if test $stat -eq 0; then :
- else
+ if test $stat -ne 0; then
rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
exit $stat
fi
do
test -f "$tmpdepfile" && break
done
- if test -f "$tmpdepfile"; then
- # Each line is of the form `foo.o: dependent.h'.
- # Do two passes, one to just change these to
- # `$object: dependent.h' and one to simply `dependent.h:'.
- sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
- # That's a tab and a space in the [].
- sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
- else
- # The sourcefile does not contain any dependencies, so just
- # store a dummy comment line, to avoid errors with the Makefile
- # "include basename.Plo" scheme.
- echo "#dummy" > "$depfile"
+ aix_post_process_depfile
+ ;;
+
+tcc)
+ # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26
+ # FIXME: That version still under development at the moment of writing.
+ # Make that this statement remains true also for stable, released
+ # versions.
+ # It will wrap lines (doesn't matter whether long or short) with a
+ # trailing '\', as in:
+ #
+ # foo.o : \
+ # foo.c \
+ # foo.h \
+ #
+ # It will put a trailing '\' even on the last line, and will use leading
+ # spaces rather than leading tabs (at least since its commit 0394caf7
+ # "Emit spaces for -MD").
+ "$@" -MD -MF "$tmpdepfile"
+ stat=$?
+ if test $stat -ne 0; then
+ rm -f "$tmpdepfile"
+ exit $stat
fi
+ rm -f "$depfile"
+ # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'.
+ # We have to change lines of the first kind to '$object: \'.
+ sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile"
+ # And for each line of the second kind, we have to emit a 'dep.h:'
+ # dummy dependency, to avoid the deleted-header problem.
+ sed -n -e 's|^ *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile"
rm -f "$tmpdepfile"
;;
-icc)
- # Intel's C compiler understands `-MD -MF file'. However on
- # icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c
- # ICC 7.0 will fill foo.d with something like
- # foo.o: sub/foo.c
- # foo.o: sub/foo.h
- # which is wrong. We want:
- # sub/foo.o: sub/foo.c
- # sub/foo.o: sub/foo.h
- # sub/foo.c:
- # sub/foo.h:
- # ICC 7.1 will output
+## The order of this option in the case statement is important, since the
+## shell code in configure will try each of these formats in the order
+## listed in this file. A plain '-MD' option would be understood by many
+## compilers, so we must ensure this comes after the gcc and icc options.
+pgcc)
+ # Portland's C compiler understands '-MD'.
+ # Will always output deps to 'file.d' where file is the root name of the
+ # source file under compilation, even if file resides in a subdirectory.
+ # The object file name does not affect the name of the '.d' file.
+ # pgcc 10.2 will output
# foo.o: sub/foo.c sub/foo.h
- # and will wrap long lines using \ :
+ # and will wrap long lines using '\' :
# foo.o: sub/foo.c ... \
# sub/foo.h ... \
# ...
+ set_dir_from "$object"
+ # Use the source, not the object, to determine the base name, since
+ # that's sadly what pgcc will do too.
+ set_base_from "$source"
+ tmpdepfile=$base.d
+
+ # For projects that build the same source file twice into different object
+ # files, the pgcc approach of using the *source* file root name can cause
+ # problems in parallel builds. Use a locking strategy to avoid stomping on
+ # the same $tmpdepfile.
+ lockdir=$base.d-lock
+ trap "
+ echo '$0: caught signal, cleaning up...' >&2
+ rmdir '$lockdir'
+ exit 1
+ " 1 2 13 15
+ numtries=100
+ i=$numtries
+ while test $i -gt 0; do
+ # mkdir is a portable test-and-set.
+ if mkdir "$lockdir" 2>/dev/null; then
+ # This process acquired the lock.
+ "$@" -MD
+ stat=$?
+ # Release the lock.
+ rmdir "$lockdir"
+ break
+ else
+ # If the lock is being held by a different process, wait
+ # until the winning process is done or we timeout.
+ while test -d "$lockdir" && test $i -gt 0; do
+ sleep 1
+ i=`expr $i - 1`
+ done
+ fi
+ i=`expr $i - 1`
+ done
+ trap - 1 2 13 15
+ if test $i -le 0; then
+ echo "$0: failed to acquire lock after $numtries attempts" >&2
+ echo "$0: check lockdir '$lockdir'" >&2
+ exit 1
+ fi
- "$@" -MD -MF "$tmpdepfile"
- stat=$?
- if test $stat -eq 0; then :
- else
+ if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
# Some versions of the HPUX 10.20 sed can't process this invocation
# correctly. Breaking it into two sed invocations is a workaround.
- sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" |
- sed -e 's/$/ :/' >> "$depfile"
+ sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \
+ | sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
# 'foo.d', which lands next to the object file, wherever that
# happens to be.
# Much of this is similar to the tru64 case; see comments there.
- dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
- test "x$dir" = "x$object" && dir=
- base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+ set_dir_from "$object"
+ set_base_from "$object"
if test "$libtool" = yes; then
tmpdepfile1=$dir$base.d
tmpdepfile2=$dir.libs/$base.d
"$@" +Maked
fi
stat=$?
- if test $stat -eq 0; then :
- else
+ if test $stat -ne 0; then
rm -f "$tmpdepfile1" "$tmpdepfile2"
exit $stat
fi
test -f "$tmpdepfile" && break
done
if test -f "$tmpdepfile"; then
- sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile"
- # Add `dependent.h:' lines.
+ sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile"
+ # Add 'dependent.h:' lines.
sed -ne '2,${
- s/^ *//
- s/ \\*$//
- s/$/:/
- p
- }' "$tmpdepfile" >> "$depfile"
+ s/^ *//
+ s/ \\*$//
+ s/$/:/
+ p
+ }' "$tmpdepfile" >> "$depfile"
else
- echo "#dummy" > "$depfile"
+ make_dummy_depfile
fi
rm -f "$tmpdepfile" "$tmpdepfile2"
;;
tru64)
- # The Tru64 compiler uses -MD to generate dependencies as a side
- # effect. `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'.
- # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
- # dependencies in `foo.d' instead, so we check for that too.
- # Subdirectories are respected.
- dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
- test "x$dir" = "x$object" && dir=
- base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
-
- if test "$libtool" = yes; then
- # With Tru64 cc, shared objects can also be used to make a
- # static library. This mechanism is used in libtool 1.4 series to
- # handle both shared and static libraries in a single compilation.
- # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
- #
- # With libtool 1.5 this exception was removed, and libtool now
- # generates 2 separate objects for the 2 libraries. These two
- # compilations output dependencies in $dir.libs/$base.o.d and
- # in $dir$base.o.d. We have to check for both files, because
- # one of the two compilations can be disabled. We should prefer
- # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
- # automatically cleaned when .libs/ is deleted, while ignoring
- # the former would cause a distcleancheck panic.
- tmpdepfile1=$dir.libs/$base.lo.d # libtool 1.4
- tmpdepfile2=$dir$base.o.d # libtool 1.5
- tmpdepfile3=$dir.libs/$base.o.d # libtool 1.5
- tmpdepfile4=$dir.libs/$base.d # Compaq CCC V6.2-504
- "$@" -Wc,-MD
- else
- tmpdepfile1=$dir$base.o.d
- tmpdepfile2=$dir$base.d
- tmpdepfile3=$dir$base.d
- tmpdepfile4=$dir$base.d
- "$@" -MD
- fi
-
- stat=$?
- if test $stat -eq 0; then :
- else
- rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
- exit $stat
- fi
-
- for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
- do
- test -f "$tmpdepfile" && break
- done
- if test -f "$tmpdepfile"; then
- sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
- # That's a tab and a space in the [].
- sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
- else
- echo "#dummy" > "$depfile"
- fi
- rm -f "$tmpdepfile"
- ;;
+ # The Tru64 compiler uses -MD to generate dependencies as a side
+ # effect. 'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
+ # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
+ # dependencies in 'foo.d' instead, so we check for that too.
+ # Subdirectories are respected.
+ set_dir_from "$object"
+ set_base_from "$object"
+
+ if test "$libtool" = yes; then
+ # Libtool generates 2 separate objects for the 2 libraries. These
+ # two compilations output dependencies in $dir.libs/$base.o.d and
+ # in $dir$base.o.d. We have to check for both files, because
+ # one of the two compilations can be disabled. We should prefer
+ # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
+ # automatically cleaned when .libs/ is deleted, while ignoring
+ # the former would cause a distcleancheck panic.
+ tmpdepfile1=$dir$base.o.d # libtool 1.5
+ tmpdepfile2=$dir.libs/$base.o.d # Likewise.
+ tmpdepfile3=$dir.libs/$base.d # Compaq CCC V6.2-504
+ "$@" -Wc,-MD
+ else
+ tmpdepfile1=$dir$base.d
+ tmpdepfile2=$dir$base.d
+ tmpdepfile3=$dir$base.d
+ "$@" -MD
+ fi
+
+ stat=$?
+ if test $stat -ne 0; then
+ rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+ exit $stat
+ fi
+
+ for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+ do
+ test -f "$tmpdepfile" && break
+ done
+ # Same post-processing that is required for AIX mode.
+ aix_post_process_depfile
+ ;;
msvc7)
if test "$libtool" = yes; then
"$@" $showIncludes > "$tmpdepfile"
stat=$?
grep -v '^Note: including file: ' "$tmpdepfile"
- if test "$stat" = 0; then :
- else
+ if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
p
}' | $cygpath_u | sort -u | sed -n '
s/ /\\ /g
-s/\(.*\)/ \1 \\/p
+s/\(.*\)/'"$tab"'\1 \\/p
s/.\(.*\) \\/\1:/
H
$ {
- s/.*/ /
+ s/.*/'"$tab"'/
G
p
}' >> "$depfile"
+ echo >> "$depfile" # make sure the fragment doesn't end with a backslash
rm -f "$tmpdepfile"
;;
shift
fi
- # Remove `-o $object'.
+ # Remove '-o $object'.
IFS=" "
for arg
do
done
test -z "$dashmflag" && dashmflag=-M
- # Require at least two characters before searching for `:'
+ # Require at least two characters before searching for ':'
# in the target name. This is to cope with DOS-style filenames:
- # a dependency such as `c:/foo/bar' could be seen as target `c' otherwise.
+ # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
"$@" $dashmflag |
- sed 's:^[ ]*[^: ][^:][^:]*\:[ ]*:'"$object"'\: :' > "$tmpdepfile"
+ sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile"
rm -f "$depfile"
cat < "$tmpdepfile" > "$depfile"
- tr ' ' '
-' < "$tmpdepfile" | \
-## Some versions of the HPUX 10.20 sed can't process this invocation
-## correctly. Breaking it into two sed invocations is a workaround.
- sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+ # Some versions of the HPUX 10.20 sed can't process this sed invocation
+ # correctly. Breaking it into two sed invocations is a workaround.
+ tr ' ' "$nl" < "$tmpdepfile" \
+ | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
+ | sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
# makedepend may prepend the VPATH from the source file name to the object.
# No need to regex-escape $object, excess matching of '.' is harmless.
sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
- sed '1,2d' "$tmpdepfile" | tr ' ' '
-' | \
-## Some versions of the HPUX 10.20 sed can't process this invocation
-## correctly. Breaking it into two sed invocations is a workaround.
- sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+ # Some versions of the HPUX 10.20 sed can't process the last invocation
+ # correctly. Breaking it into two sed invocations is a workaround.
+ sed '1,2d' "$tmpdepfile" \
+ | tr ' ' "$nl" \
+ | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
+ | sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile" "$tmpdepfile".bak
;;
shift
fi
- # Remove `-o $object'.
+ # Remove '-o $object'.
IFS=" "
for arg
do
esac
done
- "$@" -E |
- sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
- -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
- sed '$ s: \\$::' > "$tmpdepfile"
+ "$@" -E \
+ | sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
+ -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
+ | sed '$ s: \\$::' > "$tmpdepfile"
rm -f "$depfile"
echo "$object : \\" > "$depfile"
cat < "$tmpdepfile" >> "$depfile"
shift
;;
"-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
- set fnord "$@"
- shift
- shift
- ;;
+ set fnord "$@"
+ shift
+ shift
+ ;;
*)
- set fnord "$@" "$arg"
- shift
- shift
- ;;
+ set fnord "$@" "$arg"
+ shift
+ shift
+ ;;
esac
done
"$@" -E 2>/dev/null |
sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
rm -f "$depfile"
echo "$object : \\" > "$depfile"
- sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s:: \1 \\:p' >> "$depfile"
- echo " " >> "$depfile"
+ sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
+ echo "$tab" >> "$depfile"
sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
rm -f "$tmpdepfile"
;;
#!/bin/sh
# install - install a program, script, or datafile
-scriptversion=2011-01-19.21; # UTC
+scriptversion=2014-09-12.12; # UTC
# This originates from X11R5 (mit/util/scripts/install.sh), which was
# later released in X11R6 (xc/config/util/install.sh) with the
# FSF changes to this file are in the public domain.
#
# Calling this script install-sh is preferred over install.sh, to prevent
-# `make' implicit rules from creating a file called install from it
+# 'make' implicit rules from creating a file called install from it
# when there is no Makefile.
#
# This script is compatible with the BSD install script, but was written
# from scratch.
+tab=' '
nl='
'
-IFS=" "" $nl"
+IFS=" $tab$nl"
-# set DOITPROG to echo to test this script
+# Set DOITPROG to "echo" to test this script.
-# Don't use :- since 4.3BSD and earlier shells don't like it.
doit=${DOITPROG-}
-if test -z "$doit"; then
- doit_exec=exec
-else
- doit_exec=$doit
-fi
+doit_exec=${doit:-exec}
# Put in absolute file names if you don't have them in your path;
# or use environment vars.
rmprog=${RMPROG-rm}
stripprog=${STRIPPROG-strip}
-posix_glob='?'
-initialize_posix_glob='
- test "$posix_glob" != "?" || {
- if (set -f) 2>/dev/null; then
- posix_glob=
- else
- posix_glob=:
- fi
- }
-'
-
posix_mkdir=
# Desired mode of installed file.
dst_arg=
copy_on_change=false
-no_target_directory=
+is_target_a_directory=possibly
usage="\
Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
-d) dir_arg=true;;
-g) chgrpcmd="$chgrpprog $2"
- shift;;
+ shift;;
--help) echo "$usage"; exit $?;;
-m) mode=$2
- case $mode in
- *' '* | *' '* | *'
-'* | *'*'* | *'?'* | *'['*)
- echo "$0: invalid mode: $mode" >&2
- exit 1;;
- esac
- shift;;
+ case $mode in
+ *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
+ echo "$0: invalid mode: $mode" >&2
+ exit 1;;
+ esac
+ shift;;
-o) chowncmd="$chownprog $2"
- shift;;
+ shift;;
-s) stripcmd=$stripprog;;
- -t) dst_arg=$2
- # Protect names problematic for `test' and other utilities.
- case $dst_arg in
- -* | [=\(\)!]) dst_arg=./$dst_arg;;
- esac
- shift;;
+ -t)
+ is_target_a_directory=always
+ dst_arg=$2
+ # Protect names problematic for 'test' and other utilities.
+ case $dst_arg in
+ -* | [=\(\)!]) dst_arg=./$dst_arg;;
+ esac
+ shift;;
- -T) no_target_directory=true;;
+ -T) is_target_a_directory=never;;
--version) echo "$0 $scriptversion"; exit $?;;
- --) shift
- break;;
+ --) shift
+ break;;
- -*) echo "$0: invalid option: $1" >&2
- exit 1;;
+ -*) echo "$0: invalid option: $1" >&2
+ exit 1;;
*) break;;
esac
shift
done
+# We allow the use of options -d and -T together, by making -d
+# take the precedence; this is for compatibility with GNU install.
+
+if test -n "$dir_arg"; then
+ if test -n "$dst_arg"; then
+ echo "$0: target directory not allowed when installing a directory." >&2
+ exit 1
+ fi
+fi
+
if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
# When -d is used, all remaining arguments are directories to create.
# When -t is used, the destination is already specified.
fi
shift # arg
dst_arg=$arg
- # Protect names problematic for `test' and other utilities.
+ # Protect names problematic for 'test' and other utilities.
case $dst_arg in
-* | [=\(\)!]) dst_arg=./$dst_arg;;
esac
echo "$0: no input file specified." >&2
exit 1
fi
- # It's OK to call `install-sh -d' without argument.
+ # It's OK to call 'install-sh -d' without argument.
# This can happen when creating conditional directories.
exit 0
fi
if test -z "$dir_arg"; then
+ if test $# -gt 1 || test "$is_target_a_directory" = always; then
+ if test ! -d "$dst_arg"; then
+ echo "$0: $dst_arg: Is not a directory." >&2
+ exit 1
+ fi
+ fi
+fi
+
+if test -z "$dir_arg"; then
do_exit='(exit $ret); exit $ret'
trap "ret=129; $do_exit" 1
trap "ret=130; $do_exit" 2
*[0-7])
if test -z "$stripcmd"; then
- u_plus_rw=
+ u_plus_rw=
else
- u_plus_rw='% 200'
+ u_plus_rw='% 200'
fi
cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
*)
if test -z "$stripcmd"; then
- u_plus_rw=
+ u_plus_rw=
else
- u_plus_rw=,u+rw
+ u_plus_rw=,u+rw
fi
cp_umask=$mode$u_plus_rw;;
esac
for src
do
- # Protect names problematic for `test' and other utilities.
+ # Protect names problematic for 'test' and other utilities.
case $src in
-* | [=\(\)!]) src=./$src;;
esac
# If destination is a directory, append the input filename; won't work
# if double slashes aren't ignored.
if test -d "$dst"; then
- if test -n "$no_target_directory"; then
- echo "$0: $dst_arg: Is a directory" >&2
- exit 1
+ if test "$is_target_a_directory" = never; then
+ echo "$0: $dst_arg: Is a directory" >&2
+ exit 1
fi
dstdir=$dst
dst=$dstdir/`basename "$src"`
dstdir_status=0
else
- # Prefer dirname, but fall back on a substitute if dirname fails.
- dstdir=`
- (dirname "$dst") 2>/dev/null ||
- expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
- X"$dst" : 'X\(//\)[^/]' \| \
- X"$dst" : 'X\(//\)$' \| \
- X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
- echo X"$dst" |
- sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
- s//\1/
- q
- }
- /^X\(\/\/\)[^/].*/{
- s//\1/
- q
- }
- /^X\(\/\/\)$/{
- s//\1/
- q
- }
- /^X\(\/\).*/{
- s//\1/
- q
- }
- s/.*/./; q'
- `
-
+ dstdir=`dirname "$dst"`
test -d "$dstdir"
dstdir_status=$?
fi
if test $dstdir_status != 0; then
case $posix_mkdir in
'')
- # Create intermediate dirs using mode 755 as modified by the umask.
- # This is like FreeBSD 'install' as of 1997-10-28.
- umask=`umask`
- case $stripcmd.$umask in
- # Optimize common cases.
- *[2367][2367]) mkdir_umask=$umask;;
- .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
-
- *[0-7])
- mkdir_umask=`expr $umask + 22 \
- - $umask % 100 % 40 + $umask % 20 \
- - $umask % 10 % 4 + $umask % 2
- `;;
- *) mkdir_umask=$umask,go-w;;
- esac
-
- # With -d, create the new directory with the user-specified mode.
- # Otherwise, rely on $mkdir_umask.
- if test -n "$dir_arg"; then
- mkdir_mode=-m$mode
- else
- mkdir_mode=
- fi
-
- posix_mkdir=false
- case $umask in
- *[123567][0-7][0-7])
- # POSIX mkdir -p sets u+wx bits regardless of umask, which
- # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
- ;;
- *)
- tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
- trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
-
- if (umask $mkdir_umask &&
- exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
- then
- if test -z "$dir_arg" || {
- # Check for POSIX incompatibilities with -m.
- # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
- # other-writeable bit of parent directory when it shouldn't.
- # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
- ls_ld_tmpdir=`ls -ld "$tmpdir"`
- case $ls_ld_tmpdir in
- d????-?r-*) different_mode=700;;
- d????-?--*) different_mode=755;;
- *) false;;
- esac &&
- $mkdirprog -m$different_mode -p -- "$tmpdir" && {
- ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
- test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
- }
- }
- then posix_mkdir=:
- fi
- rmdir "$tmpdir/d" "$tmpdir"
- else
- # Remove any dirs left behind by ancient mkdir implementations.
- rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
- fi
- trap '' 0;;
- esac;;
+ # Create intermediate dirs using mode 755 as modified by the umask.
+ # This is like FreeBSD 'install' as of 1997-10-28.
+ umask=`umask`
+ case $stripcmd.$umask in
+ # Optimize common cases.
+ *[2367][2367]) mkdir_umask=$umask;;
+ .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
+
+ *[0-7])
+ mkdir_umask=`expr $umask + 22 \
+ - $umask % 100 % 40 + $umask % 20 \
+ - $umask % 10 % 4 + $umask % 2
+ `;;
+ *) mkdir_umask=$umask,go-w;;
+ esac
+
+ # With -d, create the new directory with the user-specified mode.
+ # Otherwise, rely on $mkdir_umask.
+ if test -n "$dir_arg"; then
+ mkdir_mode=-m$mode
+ else
+ mkdir_mode=
+ fi
+
+ posix_mkdir=false
+ case $umask in
+ *[123567][0-7][0-7])
+ # POSIX mkdir -p sets u+wx bits regardless of umask, which
+ # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+ ;;
+ *)
+ # $RANDOM is not portable (e.g. dash); use it when possible to
+ # lower collision chance
+ tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+ trap 'ret=$?; rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null; exit $ret' 0
+
+ # As "mkdir -p" follows symlinks and we work in /tmp possibly; so
+ # create the $tmpdir first (and fail if unsuccessful) to make sure
+ # that nobody tries to guess the $tmpdir name.
+ if (umask $mkdir_umask &&
+ $mkdirprog $mkdir_mode "$tmpdir" &&
+ exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
+ then
+ if test -z "$dir_arg" || {
+ # Check for POSIX incompatibilities with -m.
+ # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+ # other-writable bit of parent directory when it shouldn't.
+ # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+ test_tmpdir="$tmpdir/a"
+ ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
+ case $ls_ld_tmpdir in
+ d????-?r-*) different_mode=700;;
+ d????-?--*) different_mode=755;;
+ *) false;;
+ esac &&
+ $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
+ ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
+ test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+ }
+ }
+ then posix_mkdir=:
+ fi
+ rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
+ else
+ # Remove any dirs left behind by ancient mkdir implementations.
+ rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
+ fi
+ trap '' 0;;
+ esac;;
esac
if
$posix_mkdir && (
- umask $mkdir_umask &&
- $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+ umask $mkdir_umask &&
+ $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
)
then :
else
# directory the slow way, step by step, checking for races as we go.
case $dstdir in
- /*) prefix='/';;
- [-=\(\)!]*) prefix='./';;
- *) prefix='';;
+ /*) prefix='/';;
+ [-=\(\)!]*) prefix='./';;
+ *) prefix='';;
esac
- eval "$initialize_posix_glob"
-
oIFS=$IFS
IFS=/
- $posix_glob set -f
+ set -f
set fnord $dstdir
shift
- $posix_glob set +f
+ set +f
IFS=$oIFS
prefixes=
for d
do
- test X"$d" = X && continue
-
- prefix=$prefix$d
- if test -d "$prefix"; then
- prefixes=
- else
- if $posix_mkdir; then
- (umask=$mkdir_umask &&
- $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
- # Don't fail if two instances are running concurrently.
- test -d "$prefix" || exit 1
- else
- case $prefix in
- *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
- *) qprefix=$prefix;;
- esac
- prefixes="$prefixes '$qprefix'"
- fi
- fi
- prefix=$prefix/
+ test X"$d" = X && continue
+
+ prefix=$prefix$d
+ if test -d "$prefix"; then
+ prefixes=
+ else
+ if $posix_mkdir; then
+ (umask=$mkdir_umask &&
+ $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+ # Don't fail if two instances are running concurrently.
+ test -d "$prefix" || exit 1
+ else
+ case $prefix in
+ *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+ *) qprefix=$prefix;;
+ esac
+ prefixes="$prefixes '$qprefix'"
+ fi
+ fi
+ prefix=$prefix/
done
if test -n "$prefixes"; then
- # Don't fail if two instances are running concurrently.
- (umask $mkdir_umask &&
- eval "\$doit_exec \$mkdirprog $prefixes") ||
- test -d "$dstdir" || exit 1
- obsolete_mkdir_used=true
+ # Don't fail if two instances are running concurrently.
+ (umask $mkdir_umask &&
+ eval "\$doit_exec \$mkdirprog $prefixes") ||
+ test -d "$dstdir" || exit 1
+ obsolete_mkdir_used=true
fi
fi
fi
# If -C, don't bother to copy if it wouldn't change the file.
if $copy_on_change &&
- old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` &&
- new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` &&
-
- eval "$initialize_posix_glob" &&
- $posix_glob set -f &&
+ old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` &&
+ new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` &&
+ set -f &&
set X $old && old=:$2:$4:$5:$6 &&
set X $new && new=:$2:$4:$5:$6 &&
- $posix_glob set +f &&
-
+ set +f &&
test "$old" = "$new" &&
$cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
then
# to itself, or perhaps because mv is so ancient that it does not
# support -f.
{
- # Now remove or move aside any old file at destination location.
- # We try this two ways since rm can't unlink itself on some
- # systems and the destination file might be busy for other
- # reasons. In this case, the final cleanup might fail but the new
- # file should still install successfully.
- {
- test ! -f "$dst" ||
- $doit $rmcmd -f "$dst" 2>/dev/null ||
- { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
- { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
- } ||
- { echo "$0: cannot unlink or rename $dst" >&2
- (exit 1); exit 1
- }
- } &&
-
- # Now rename the file to the real destination.
- $doit $mvcmd "$dsttmp" "$dst"
+ # Now remove or move aside any old file at destination location.
+ # We try this two ways since rm can't unlink itself on some
+ # systems and the destination file might be busy for other
+ # reasons. In this case, the final cleanup might fail but the new
+ # file should still install successfully.
+ {
+ test ! -f "$dst" ||
+ $doit $rmcmd -f "$dst" 2>/dev/null ||
+ { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+ { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
+ } ||
+ { echo "$0: cannot unlink or rename $dst" >&2
+ (exit 1); exit 1
+ }
+ } &&
+
+ # Now rename the file to the real destination.
+ $doit $mvcmd "$dsttmp" "$dst"
}
fi || exit 1
#! /bin/sh
-# Common stub for a few missing GNU programs while installing.
+# Common wrapper for a few potentially missing GNU programs.
-scriptversion=2012-01-06.13; # UTC
+scriptversion=2013-10-28.13; # UTC
-# Copyright (C) 1996, 1997, 1999, 2000, 2002, 2003, 2004, 2005, 2006,
-# 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
-# Originally by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
+# Copyright (C) 1996-2014 Free Software Foundation, Inc.
+# Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the same distribution terms that you use for the rest of that program.
if test $# -eq 0; then
- echo 1>&2 "Try \`$0 --help' for more information"
+ echo 1>&2 "Try '$0 --help' for more information"
exit 1
fi
-run=:
-sed_output='s/.* --output[ =]\([^ ]*\).*/\1/p'
-sed_minuso='s/.* -o \([^ ]*\).*/\1/p'
-
-# In the cases where this matters, `missing' is being run in the
-# srcdir already.
-if test -f configure.ac; then
- configure_ac=configure.ac
-else
- configure_ac=configure.in
-fi
+case $1 in
-msg="missing on your system"
+ --is-lightweight)
+ # Used by our autoconf macros to check whether the available missing
+ # script is modern enough.
+ exit 0
+ ;;
-case $1 in
---run)
- # Try to run requested program, and just exit if it succeeds.
- run=
- shift
- "$@" && exit 0
- # Exit code 63 means version mismatch. This often happens
- # when the user try to use an ancient version of a tool on
- # a file that requires a minimum version. In this case we
- # we should proceed has if the program had been absent, or
- # if --run hadn't been passed.
- if test $? = 63; then
- run=:
- msg="probably too old"
- fi
- ;;
+ --run)
+ # Back-compat with the calling convention used by older automake.
+ shift
+ ;;
-h|--h|--he|--hel|--help)
echo "\
$0 [OPTION]... PROGRAM [ARGUMENT]...
-Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
-error status if there is no known handling for PROGRAM.
+Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due
+to PROGRAM being missing or too old.
Options:
-h, --help display this help and exit
-v, --version output version information and exit
- --run try to run the given command, and emulate it if it fails
Supported PROGRAM values:
- aclocal touch file \`aclocal.m4'
- autoconf touch file \`configure'
- autoheader touch file \`config.h.in'
- autom4te touch the output file, or create a stub one
- automake touch all \`Makefile.in' files
- bison create \`y.tab.[ch]', if possible, from existing .[ch]
- flex create \`lex.yy.c', if possible, from existing .c
- help2man touch the output file
- lex create \`lex.yy.c', if possible, from existing .c
- makeinfo touch the output file
- yacc create \`y.tab.[ch]', if possible, from existing .[ch]
+ aclocal autoconf autoheader autom4te automake makeinfo
+ bison yacc flex lex help2man
-Version suffixes to PROGRAM as well as the prefixes \`gnu-', \`gnu', and
-\`g' are ignored when checking the name.
+Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
+'g' are ignored when checking the name.
Send bug reports to <bug-automake@gnu.org>."
exit $?
;;
-*)
- echo 1>&2 "$0: Unknown \`$1' option"
- echo 1>&2 "Try \`$0 --help' for more information"
+ echo 1>&2 "$0: unknown '$1' option"
+ echo 1>&2 "Try '$0 --help' for more information"
exit 1
;;
esac
-# normalize program name to check for.
-program=`echo "$1" | sed '
- s/^gnu-//; t
- s/^gnu//; t
- s/^g//; t'`
-
-# Now exit if we have it, but it failed. Also exit now if we
-# don't have it and --version was passed (most likely to detect
-# the program). This is about non-GNU programs, so use $1 not
-# $program.
-case $1 in
- lex*|yacc*)
- # Not GNU programs, they don't have --version.
- ;;
-
- *)
- if test -z "$run" && ($1 --version) > /dev/null 2>&1; then
- # We have it, but it failed.
- exit 1
- elif test "x$2" = "x--version" || test "x$2" = "x--help"; then
- # Could not run --version or --help. This is probably someone
- # running `$TOOL --version' or `$TOOL --help' to check whether
- # $TOOL exists and not knowing $TOOL uses missing.
- exit 1
- fi
- ;;
-esac
-
-# If it does not exist, or fails to run (possibly an outdated version),
-# try to emulate it.
-case $program in
- aclocal*)
- echo 1>&2 "\
-WARNING: \`$1' is $msg. You should only need it if
- you modified \`acinclude.m4' or \`${configure_ac}'. You might want
- to install the \`Automake' and \`Perl' packages. Grab them from
- any GNU archive site."
- touch aclocal.m4
- ;;
-
- autoconf*)
- echo 1>&2 "\
-WARNING: \`$1' is $msg. You should only need it if
- you modified \`${configure_ac}'. You might want to install the
- \`Autoconf' and \`GNU m4' packages. Grab them from any GNU
- archive site."
- touch configure
- ;;
-
- autoheader*)
- echo 1>&2 "\
-WARNING: \`$1' is $msg. You should only need it if
- you modified \`acconfig.h' or \`${configure_ac}'. You might want
- to install the \`Autoconf' and \`GNU m4' packages. Grab them
- from any GNU archive site."
- files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}`
- test -z "$files" && files="config.h"
- touch_files=
- for f in $files; do
- case $f in
- *:*) touch_files="$touch_files "`echo "$f" |
- sed -e 's/^[^:]*://' -e 's/:.*//'`;;
- *) touch_files="$touch_files $f.in";;
- esac
- done
- touch $touch_files
- ;;
-
- automake*)
- echo 1>&2 "\
-WARNING: \`$1' is $msg. You should only need it if
- you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'.
- You might want to install the \`Automake' and \`Perl' packages.
- Grab them from any GNU archive site."
- find . -type f -name Makefile.am -print |
- sed 's/\.am$/.in/' |
- while read f; do touch "$f"; done
- ;;
-
- autom4te*)
- echo 1>&2 "\
-WARNING: \`$1' is needed, but is $msg.
- You might have modified some files without having the
- proper tools for further handling them.
- You can get \`$1' as part of \`Autoconf' from any GNU
- archive site."
-
- file=`echo "$*" | sed -n "$sed_output"`
- test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
- if test -f "$file"; then
- touch $file
- else
- test -z "$file" || exec >$file
- echo "#! /bin/sh"
- echo "# Created by GNU Automake missing as a replacement of"
- echo "# $ $@"
- echo "exit 0"
- chmod +x $file
- exit 1
- fi
- ;;
-
- bison*|yacc*)
- echo 1>&2 "\
-WARNING: \`$1' $msg. You should only need it if
- you modified a \`.y' file. You may need the \`Bison' package
- in order for those modifications to take effect. You can get
- \`Bison' from any GNU archive site."
- rm -f y.tab.c y.tab.h
- if test $# -ne 1; then
- eval LASTARG=\${$#}
- case $LASTARG in
- *.y)
- SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
- if test -f "$SRCFILE"; then
- cp "$SRCFILE" y.tab.c
- fi
- SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
- if test -f "$SRCFILE"; then
- cp "$SRCFILE" y.tab.h
- fi
- ;;
- esac
- fi
- if test ! -f y.tab.h; then
- echo >y.tab.h
- fi
- if test ! -f y.tab.c; then
- echo 'main() { return 0; }' >y.tab.c
- fi
- ;;
-
- lex*|flex*)
- echo 1>&2 "\
-WARNING: \`$1' is $msg. You should only need it if
- you modified a \`.l' file. You may need the \`Flex' package
- in order for those modifications to take effect. You can get
- \`Flex' from any GNU archive site."
- rm -f lex.yy.c
- if test $# -ne 1; then
- eval LASTARG=\${$#}
- case $LASTARG in
- *.l)
- SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
- if test -f "$SRCFILE"; then
- cp "$SRCFILE" lex.yy.c
- fi
- ;;
- esac
- fi
- if test ! -f lex.yy.c; then
- echo 'main() { return 0; }' >lex.yy.c
- fi
- ;;
-
- help2man*)
- echo 1>&2 "\
-WARNING: \`$1' is $msg. You should only need it if
- you modified a dependency of a manual page. You may need the
- \`Help2man' package in order for those modifications to take
- effect. You can get \`Help2man' from any GNU archive site."
-
- file=`echo "$*" | sed -n "$sed_output"`
- test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
- if test -f "$file"; then
- touch $file
- else
- test -z "$file" || exec >$file
- echo ".ab help2man is required to generate this page"
- exit $?
- fi
- ;;
-
- makeinfo*)
- echo 1>&2 "\
-WARNING: \`$1' is $msg. You should only need it if
- you modified a \`.texi' or \`.texinfo' file, or any other file
- indirectly affecting the aspect of the manual. The spurious
- call might also be the consequence of using a buggy \`make' (AIX,
- DU, IRIX). You might want to install the \`Texinfo' package or
- the \`GNU make' package. Grab either from any GNU archive site."
- # The file to touch is that specified with -o ...
- file=`echo "$*" | sed -n "$sed_output"`
- test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
- if test -z "$file"; then
- # ... or it is the one specified with @setfilename ...
- infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
- file=`sed -n '
- /^@setfilename/{
- s/.* \([^ ]*\) *$/\1/
- p
- q
- }' $infile`
- # ... or it is derived from the source name (dir/f.texi becomes f.info)
- test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info
- fi
- # If the file does not exist, the user really needs makeinfo;
- # let's fail without touching anything.
- test -f $file || exit 1
- touch $file
- ;;
+# Run the given program, remember its exit status.
+"$@"; st=$?
+
+# If it succeeded, we are done.
+test $st -eq 0 && exit 0
+
+# Also exit now if we it failed (or wasn't found), and '--version' was
+# passed; such an option is passed most likely to detect whether the
+# program is present and works.
+case $2 in --version|--help) exit $st;; esac
+
+# Exit code 63 means version mismatch. This often happens when the user
+# tries to use an ancient version of a tool on a file that requires a
+# minimum version.
+if test $st -eq 63; then
+ msg="probably too old"
+elif test $st -eq 127; then
+ # Program was missing.
+ msg="missing on your system"
+else
+ # Program was found and executed, but failed. Give up.
+ exit $st
+fi
- *)
- echo 1>&2 "\
-WARNING: \`$1' is needed, and is $msg.
- You might have modified some files without having the
- proper tools for further handling them. Check the \`README' file,
- it often tells you about the needed prerequisites for installing
- this package. You may also peek at any GNU archive site, in case
- some other package would contain this missing \`$1' program."
- exit 1
+perl_URL=http://www.perl.org/
+flex_URL=http://flex.sourceforge.net/
+gnu_software_URL=http://www.gnu.org/software
+
+program_details ()
+{
+ case $1 in
+ aclocal|automake)
+ echo "The '$1' program is part of the GNU Automake package:"
+ echo "<$gnu_software_URL/automake>"
+ echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
+ echo "<$gnu_software_URL/autoconf>"
+ echo "<$gnu_software_URL/m4/>"
+ echo "<$perl_URL>"
+ ;;
+ autoconf|autom4te|autoheader)
+ echo "The '$1' program is part of the GNU Autoconf package:"
+ echo "<$gnu_software_URL/autoconf/>"
+ echo "It also requires GNU m4 and Perl in order to run:"
+ echo "<$gnu_software_URL/m4/>"
+ echo "<$perl_URL>"
+ ;;
+ esac
+}
+
+give_advice ()
+{
+ # Normalize program name to check for.
+ normalized_program=`echo "$1" | sed '
+ s/^gnu-//; t
+ s/^gnu//; t
+ s/^g//; t'`
+
+ printf '%s\n' "'$1' is $msg."
+
+ configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
+ case $normalized_program in
+ autoconf*)
+ echo "You should only need it if you modified 'configure.ac',"
+ echo "or m4 files included by it."
+ program_details 'autoconf'
+ ;;
+ autoheader*)
+ echo "You should only need it if you modified 'acconfig.h' or"
+ echo "$configure_deps."
+ program_details 'autoheader'
+ ;;
+ automake*)
+ echo "You should only need it if you modified 'Makefile.am' or"
+ echo "$configure_deps."
+ program_details 'automake'
+ ;;
+ aclocal*)
+ echo "You should only need it if you modified 'acinclude.m4' or"
+ echo "$configure_deps."
+ program_details 'aclocal'
+ ;;
+ autom4te*)
+ echo "You might have modified some maintainer files that require"
+ echo "the 'autom4te' program to be rebuilt."
+ program_details 'autom4te'
+ ;;
+ bison*|yacc*)
+ echo "You should only need it if you modified a '.y' file."
+ echo "You may want to install the GNU Bison package:"
+ echo "<$gnu_software_URL/bison/>"
+ ;;
+ lex*|flex*)
+ echo "You should only need it if you modified a '.l' file."
+ echo "You may want to install the Fast Lexical Analyzer package:"
+ echo "<$flex_URL>"
+ ;;
+ help2man*)
+ echo "You should only need it if you modified a dependency" \
+ "of a man page."
+ echo "You may want to install the GNU Help2man package:"
+ echo "<$gnu_software_URL/help2man/>"
;;
-esac
-
-exit 0
+ makeinfo*)
+ echo "You should only need it if you modified a '.texi' file, or"
+ echo "any other file indirectly affecting the aspect of the manual."
+ echo "You might want to install the Texinfo package:"
+ echo "<$gnu_software_URL/texinfo/>"
+ echo "The spurious makeinfo call might also be the consequence of"
+ echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
+ echo "want to install GNU make:"
+ echo "<$gnu_software_URL/make/>"
+ ;;
+ *)
+ echo "You might have modified some files without having the proper"
+ echo "tools for further handling them. Check the 'README' file, it"
+ echo "often tells you about the needed prerequisites for installing"
+ echo "this package. You may also peek at any GNU archive site, in"
+ echo "case some other package contains this missing '$1' program."
+ ;;
+ esac
+}
+
+give_advice "$1" | sed -e '1s/^/WARNING: /' \
+ -e '2,$s/^/ /' >&2
+
+# Propagate the correct exit status (expected to be 127 for a program
+# not found, 63 for a program that failed due to version mismatch).
+exit $st
# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
#! /bin/sh
# ylwrap - wrapper for lex/yacc invocations.
-scriptversion=2011-08-25.18; # UTC
+scriptversion=2013-01-12.17; # UTC
-# Copyright (C) 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004, 2005,
-# 2007, 2009, 2010, 2011 Free Software Foundation, Inc.
+# Copyright (C) 1996-2014 Free Software Foundation, Inc.
#
# Written by Tom Tromey <tromey@cygnus.com>.
#
# bugs to <bug-automake@gnu.org> or send patches to
# <automake-patches@gnu.org>.
+get_dirname ()
+{
+ case $1 in
+ */*|*\\*) printf '%s\n' "$1" | sed -e 's|\([\\/]\)[^\\/]*$|\1|';;
+ # Otherwise, we want the empty string (not ".").
+ esac
+}
+
+# guard FILE
+# ----------
+# The CPP macro used to guard inclusion of FILE.
+guard ()
+{
+ printf '%s\n' "$1" \
+ | sed \
+ -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' \
+ -e 's/[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]/_/g' \
+ -e 's/__*/_/g'
+}
+
+# quote_for_sed [STRING]
+# ----------------------
+# Return STRING (or stdin) quoted to be used as a sed pattern.
+quote_for_sed ()
+{
+ case $# in
+ 0) cat;;
+ 1) printf '%s\n' "$1";;
+ esac \
+ | sed -e 's|[][\\.*]|\\&|g'
+}
+
case "$1" in
'')
- echo "$0: No files given. Try \`$0 --help' for more information." 1>&2
+ echo "$0: No files given. Try '$0 --help' for more information." 1>&2
exit 1
;;
--basedir)
# The input.
-input="$1"
+input=$1
shift
-case "$input" in
+# We'll later need for a correct munging of "#line" directives.
+input_sub_rx=`get_dirname "$input" | quote_for_sed`
+case $input in
[\\/]* | ?:[\\/]*)
# Absolute path; do nothing.
;;
*)
# Relative path. Make it absolute.
- input="`pwd`/$input"
+ input=`pwd`/$input
;;
esac
+input_rx=`get_dirname "$input" | quote_for_sed`
+
+# Since DOS filename conventions don't allow two dots,
+# the DOS version of Bison writes out y_tab.c instead of y.tab.c
+# and y_tab.h instead of y.tab.h. Test to see if this is the case.
+y_tab_nodot=false
+if test -f y_tab.c || test -f y_tab.h; then
+ y_tab_nodot=true
+fi
+
+# The parser itself, the first file, is the destination of the .y.c
+# rule in the Makefile.
+parser=$1
+
+# A sed program to s/FROM/TO/g for all the FROM/TO so that, for
+# instance, we rename #include "y.tab.h" into #include "parse.h"
+# during the conversion from y.tab.c to parse.c.
+sed_fix_filenames=
-pairlist=
-while test "$#" -ne 0; do
- if test "$1" = "--"; then
+# Also rename header guards, as Bison 2.7 for instance uses its header
+# guard in its implementation file.
+sed_fix_header_guards=
+
+while test $# -ne 0; do
+ if test x"$1" = x"--"; then
shift
break
fi
- pairlist="$pairlist $1"
+ from=$1
+ # Handle y_tab.c and y_tab.h output by DOS
+ if $y_tab_nodot; then
+ case $from in
+ "y.tab.c") from=y_tab.c;;
+ "y.tab.h") from=y_tab.h;;
+ esac
+ fi
shift
+ to=$1
+ shift
+ sed_fix_filenames="${sed_fix_filenames}s|"`quote_for_sed "$from"`"|$to|g;"
+ sed_fix_header_guards="${sed_fix_header_guards}s|"`guard "$from"`"|"`guard "$to"`"|g;"
done
# The program to run.
-prog="$1"
+prog=$1
shift
# Make any relative path in $prog absolute.
-case "$prog" in
+case $prog in
[\\/]* | ?:[\\/]*) ;;
- *[\\/]*) prog="`pwd`/$prog" ;;
+ *[\\/]*) prog=`pwd`/$prog ;;
esac
-# FIXME: add hostname here for parallel makes that run commands on
-# other machines. But that might take us over the 14-char limit.
dirname=ylwrap$$
do_exit="cd '`pwd`' && rm -rf $dirname > /dev/null 2>&1;"' (exit $ret); exit $ret'
trap "ret=129; $do_exit" 1
ret=$?
if test $ret -eq 0; then
- set X $pairlist
- shift
- first=yes
- # Since DOS filename conventions don't allow two dots,
- # the DOS version of Bison writes out y_tab.c instead of y.tab.c
- # and y_tab.h instead of y.tab.h. Test to see if this is the case.
- y_tab_nodot="no"
- if test -f y_tab.c || test -f y_tab.h; then
- y_tab_nodot="yes"
- fi
-
- # The directory holding the input.
- input_dir=`echo "$input" | sed -e 's,\([\\/]\)[^\\/]*$,\1,'`
- # Quote $INPUT_DIR so we can use it in a regexp.
- # FIXME: really we should care about more than `.' and `\'.
- input_rx=`echo "$input_dir" | sed 's,\\\\,\\\\\\\\,g;s,\\.,\\\\.,g'`
-
- while test "$#" -ne 0; do
- from="$1"
- # Handle y_tab.c and y_tab.h output by DOS
- if test $y_tab_nodot = "yes"; then
- if test $from = "y.tab.c"; then
- from="y_tab.c"
- else
- if test $from = "y.tab.h"; then
- from="y_tab.h"
- fi
- fi
- fi
+ for from in *
+ do
+ to=`printf '%s\n' "$from" | sed "$sed_fix_filenames"`
if test -f "$from"; then
# If $2 is an absolute path name, then just use that,
- # otherwise prepend `../'.
- case "$2" in
- [\\/]* | ?:[\\/]*) target="$2";;
- *) target="../$2";;
+ # otherwise prepend '../'.
+ case $to in
+ [\\/]* | ?:[\\/]*) target=$to;;
+ *) target=../$to;;
esac
- # We do not want to overwrite a header file if it hasn't
- # changed. This avoid useless recompilations. However the
- # parser itself (the first file) should always be updated,
- # because it is the destination of the .y.c rule in the
- # Makefile. Divert the output of all other files to a temporary
- # file so we can compare them to existing versions.
- if test $first = no; then
- realtarget="$target"
- target="tmp-`echo $target | sed s/.*[\\/]//g`"
+ # Do not overwrite unchanged header files to avoid useless
+ # recompilations. Always update the parser itself: it is the
+ # destination of the .y.c rule in the Makefile. Divert the
+ # output of all other files to a temporary file so we can
+ # compare them to existing versions.
+ if test $from != $parser; then
+ realtarget=$target
+ target=tmp-`printf '%s\n' "$target" | sed 's|.*[\\/]||g'`
fi
- # Edit out `#line' or `#' directives.
- #
- # We don't want the resulting debug information to point at
- # an absolute srcdir; it is better for it to just mention the
- # .y file with no path.
- #
- # We want to use the real output file name, not yy.lex.c for
- # instance.
- #
- # We want the include guards to be adjusted too.
- FROM=`echo "$from" | sed \
- -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'\
- -e 's/[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]/_/g'`
- TARGET=`echo "$2" | sed \
- -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'\
- -e 's/[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]/_/g'`
-
- sed -e "/^#/!b" -e "s,$input_rx,," -e "s,$from,$2," \
- -e "s,$FROM,$TARGET," "$from" >"$target" || ret=$?
-
- # Check whether header files must be updated.
- if test $first = no; then
+
+ # Munge "#line" or "#" directives. Don't let the resulting
+ # debug information point at an absolute srcdir. Use the real
+ # output file name, not yy.lex.c for instance. Adjust the
+ # include guards too.
+ sed -e "/^#/!b" \
+ -e "s|$input_rx|$input_sub_rx|" \
+ -e "$sed_fix_filenames" \
+ -e "$sed_fix_header_guards" \
+ "$from" >"$target" || ret=$?
+
+ # Check whether files must be updated.
+ if test "$from" != "$parser"; then
if test -f "$realtarget" && cmp -s "$realtarget" "$target"; then
- echo "$2" is unchanged
+ echo "$to is unchanged"
rm -f "$target"
else
- echo updating "$2"
+ echo "updating $to"
mv -f "$target" "$realtarget"
fi
fi
else
- # A missing file is only an error for the first file. This
- # is a blatant hack to let us support using "yacc -d". If -d
- # is not specified, we don't want an error when the header
- # file is "missing".
- if test $first = yes; then
+ # A missing file is only an error for the parser. This is a
+ # blatant hack to let us support using "yacc -d". If -d is not
+ # specified, don't fail when the header file is "missing".
+ if test "$from" = "$parser"; then
ret=1
fi
fi
- shift
- shift
- first=no
done
-else
- ret=$?
fi
# Remove the directory.
--- /dev/null
+#!/bin/sh
+
+# Unix to Windows path conversion in a script.
+# Useful for avoiding backslash quoting difficulties in Makefiles.
+# Acts as a much dumbed down cygpath tool mainly for use on MinGW.
+
+usage()
+{
+ cat <<EOF
+Usage: $0 [-m|-u|-w|-h] [path]...
+
+Convert Windows and Unix paths
+
+ -m Convert Unix path to mixed path (full paths, MinGW MSYS only)
+ -u Convert forward slashes to backslashes in the paths (relative paths only)
+ -w Convert backslashes to forward slashes in the paths (relative paths only)
+EOF
+}
+
+option="$1"
+case "$option" in
+ -m) shift
+ case $MACHTYPE in
+ # This echo converts unix to mixed paths. Then zap unexpected trailing space on old versions of MinGW.
+ *-msys) echo `cmd //c echo "$@" | sed -e "s/[ ]*$//"`;;
+ *) echo "The -m option is only supported on MinGW MSYS" 1>&2; exit 1 ;;
+ esac ;;
+ -u) shift; echo $@ | sed -e 's,\\,/,g' ;;
+ -w) shift; echo $@ | sed -e 's,/,\\,g' ;;
+ -h) shift; usage; ;;
+ *) usage; exit 1 ;;
+esac
+
+exit 0
--- /dev/null
+# ----------------------------------------------------------------
+# Compile a custom javascript interpreter
+# ----------------------------------------------------------------
+#
+# Note:
+# There is no common CLI Javascript interpreter.
+# V8 comes with one 'd8' which however does not provide a means
+# to load extensions. Therefore, by default we use nodejs as
+# environment.
+# For testing native v8 and jsc extensions we provide our own
+# interpreter (see 'Tools/javascript').
+#
+# ----------------------------------------------------------------
+all: javascript
+
+CC = @CC@
+# HACK: under Mac OS X a g++ compiled interpreter is seg-faulting when loading module libraries
+# with 'c++' it works... probably some missing flags?
+JSCXX = @JSINTERPRETERCXX@
+CPPFLAGS = @BOOST_CPPFLAGS@
+CFLAGS = @PLATCFLAGS@
+CXXFLAGS = @PLATCXXFLAGS@
+LDFLAGS =
+LINKFLAGS = @JSINTERPRETERLINKFLAGS@
+
+ROOT_DIR = @ROOT_DIR@
+JSINCLUDES = @JSCOREINC@ @JSV8INC@
+JSDYNAMICLINKING = @JSCOREDYNAMICLINKING@ @JSV8DYNAMICLINKING@
+JSV8ENABLED = @JSV8ENABLED@
+JSCENABLED = @JSCENABLED@
+
+srcdir = @srcdir@
+
+
+ifneq (, $(V8_VERSION))
+ JSV8_VERSION=$(V8_VERSION)
+else
+ JSV8_VERSION=0x031110
+endif
+
+# Regenerate Makefile if Makefile.in or config.status have changed.
+Makefile: $(srcdir)/Makefile.in ../../config.status
+ cd ../.. && $(SHELL) ./config.status Tools/javascript/Makefile
+
+# These settings are provided by 'configure' (see '/configure.in')
+ifeq (1, $(JSV8ENABLED))
+JS_INTERPRETER_SRC_V8 = v8_shell.cxx
+JS_INTERPRETER_ENABLE_V8 = -DENABLE_V8 -DSWIG_V8_VERSION=$(JSV8_VERSION) -DV8_DEPRECATION_WARNINGS
+endif
+
+ifeq (1, $(JSCENABLED))
+JS_INTERPRETER_SRC_JSC = jsc_shell.cxx
+JS_INTERPRETER_ENABLE_JSC = -DENABLE_JSC
+endif
+
+JS_INTERPRETER_DEFINES = $(JS_INTERPRETER_ENABLE_JSC) $(JS_INTERPRETER_ENABLE_V8)
+JS_INTERPRETER_SRC = javascript.cxx js_shell.cxx $(JS_INTERPRETER_SRC_JSC) $(JS_INTERPRETER_SRC_V8)
+
+JS_INTERPRETER_OBJS = $(JS_INTERPRETER_SRC:.cxx=.o)
+
+%.o: $(srcdir)/%.cxx
+ $(JSCXX) $(JS_INTERPRETER_DEFINES) $(CPPFLAGS) $(CXXFLAGS) $(JSINCLUDES) -o $@ -c $<
+
+javascript: $(JS_INTERPRETER_OBJS)
+ $(JSCXX) $^ $(CXXFLAGS) $(LDFLAGS) -o javascript $(JSDYNAMICLINKING) $(LINKFLAGS)
+
+clean:
+ rm -f *.o
+ rm -f javascript
+
+distclean: clean
+ rm -f Makefile
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "js_shell.h"
+
+void print_usage() {
+ std::cout << "javascript [-i] [-jsc|-v8] [-l module] <js-file>" << std::endl;
+}
+
+int main(int argc, char* argv[]) {
+
+#if defined(JAVASCRIPT_INTERPRETER_STOP)
+ std::cout << "Attach your Debugger and press any key to continue" << std::endl;
+ std::cin.get();
+#endif
+
+ std::string scriptPath = "";
+
+ bool interactive = false;
+ JSShell* shell = 0;
+
+ std::vector<std::string> modulePath;
+ modulePath.push_back(".");
+
+ for (int idx = 1; idx < argc; ++idx) {
+ if(strcmp(argv[idx], "-v8") == 0) {
+ shell = JSShell::Create(JSShell::V8);
+ } else if(strcmp(argv[idx], "-jsc") == 0) {
+ shell = JSShell::Create(JSShell::JSC);
+ } else if(strcmp(argv[idx], "-i") == 0) {
+ interactive = true;
+ } else if(strcmp(argv[idx], "-L") == 0) {
+ modulePath.push_back(argv[++idx]);
+ } else {
+ scriptPath = argv[idx];
+ }
+ }
+
+ if (shell == 0) {
+ shell = JSShell::Create();
+ }
+
+ shell->setModulePath(modulePath);
+
+ bool failed = false;
+
+ if(interactive) {
+ failed = !(shell->RunShell());
+ } else {
+ failed = !(shell->RunScript(scriptPath));
+ }
+
+ if (failed) {
+ delete shell;
+ printf("FAIL: Error during execution of script.\n");
+ return 1;
+ }
+
+ delete shell;
+
+ return 0;
+}
--- /dev/null
+#include "js_shell.h"
+
+#include <iostream>
+#include <fstream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#ifdef __GNUC__
+#ifdef __APPLE__
+#define LIBRARY_EXT ".bundle"
+#else
+#define LIBRARY_EXT ".so"
+#endif
+#include <dlfcn.h>
+#define LOAD_LIBRARY(name) dlopen(name, RTLD_LAZY)
+#define CLOSE_LIBRARY(handle) dlclose(handle)
+#define LIBRARY_ERROR dlerror
+#define LIBRARYFILE(name) std::string("lib").append(name).append(LIBRARY_EXT)
+#else
+#error "implement dll loading"
+#endif
+
+
+JSShell::~JSShell() {
+
+ for(std::vector<HANDLE>::iterator it = loaded_modules.begin();
+ it != loaded_modules.end(); ++it) {
+ HANDLE handle = *it;
+ CLOSE_LIBRARY(handle);
+ }
+
+}
+
+// TODO: this could be done more intelligent...
+// - can we achieve source file relative loading?
+// - better path resolution
+std::string JSShell::LoadModule(const std::string& name, HANDLE* library) {
+
+ // works only for posix like OSs
+ size_t pathIdx = name.find_last_of("/");
+
+ std::string lib_name;
+ std::string module_name;
+
+ if (pathIdx == std::string::npos) {
+ module_name = name;
+ lib_name = std::string(name).append(LIBRARY_EXT);
+ } else {
+ std::string path = name.substr(0, pathIdx+1);
+ module_name = name.substr(pathIdx+1);
+ lib_name = path.append(module_name).append(LIBRARY_EXT);
+ }
+
+ std::string lib_path;
+ HANDLE handle = 0;
+
+ for (int i = 0; i < module_path.size(); ++i) {
+ lib_path = module_path[i] + "/" + lib_name;
+ if (access( lib_path.c_str(), F_OK ) != -1) {
+ handle = LOAD_LIBRARY(lib_path.c_str());
+ }
+ }
+
+ if(handle == 0) {
+ std::cerr << "Could not find module " << lib_path << ":"
+ << std::endl << LIBRARY_ERROR() << std::endl;
+ return 0;
+ }
+
+ loaded_modules.push_back(handle);
+
+ *library = handle;
+
+ return module_name;
+}
+
+bool JSShell::RunScript(const std::string& scriptPath) {
+ std::string source = ReadFile(scriptPath);
+ if(!InitializeEngine()) return false;
+
+ // Node.js compatibility: make `print` available as `console.log()`
+ ExecuteScript("var console = {}; console.log = print;", "<console>");
+
+ if(!ExecuteScript(source, scriptPath)) {
+ return false;
+ }
+
+ return DisposeEngine();
+}
+
+bool JSShell::RunShell() {
+
+ if(!InitializeEngine()) return false;
+
+ static const int kBufferSize = 1024;
+ while (true) {
+ char buffer[kBufferSize];
+ printf("> ");
+ char* str = fgets(buffer, kBufferSize, stdin);
+ if (str == NULL) break;
+ std::string source(str);
+ ExecuteScript(source, "(shell)");
+ }
+ printf("\n");
+ return true;
+}
+
+std::string JSShell::ReadFile(const std::string& fileName)
+{
+ std::string script;
+
+ std::ifstream file(fileName.c_str());
+ if (file.is_open()) {
+ while ( file.good() ) {
+ std::string line;
+ getline(file, line);
+ script.append(line);
+ script.append("\n");
+ }
+ file.close();
+ } else {
+ std::cout << "Unable to open file " << fileName << "." << std::endl;
+ }
+
+ return script;
+}
+
+#ifdef ENABLE_JSC
+extern JSShell* JSCShell_Create();
+#endif
+#ifdef ENABLE_V8
+extern JSShell* V8Shell_Create();
+#endif
+
+typedef JSShell*(*ShellFactory)();
+
+static ShellFactory js_shell_factories[2] = {
+#ifdef ENABLE_JSC
+JSCShell_Create,
+#else
+0,
+#endif
+#ifdef ENABLE_V8
+V8Shell_Create,
+#else
+0,
+#endif
+};
+
+JSShell *JSShell::Create(Engine engine) {
+ if(js_shell_factories[engine] == 0) {
+ throw "Engine not available.";
+ }
+ return js_shell_factories[engine]();
+}
--- /dev/null
+#ifndef JS_SHELL_H
+#define JS_SHELL_H
+
+#include <vector>
+#include <string>
+
+typedef void* HANDLE;
+typedef void* MODULE;
+
+class JSShell {
+
+public:
+ enum Engine {
+ JSC = 0,
+ V8
+ };
+
+public:
+
+ JSShell() {}
+
+ virtual ~JSShell() = 0;
+
+ static JSShell* Create(Engine engine = JSC);
+
+ std::string LoadModule(const std::string& name, HANDLE* library);
+
+ virtual bool RunScript(const std::string& scriptPath);
+
+ virtual bool RunShell();
+
+ void setModulePath(const std::vector<std::string>& modulePath) {
+ module_path = modulePath;
+ }
+
+protected:
+
+ virtual bool InitializeEngine() = 0;
+
+ virtual bool ExecuteScript(const std::string& source, const std::string& scriptPath) = 0;
+
+ virtual bool DisposeEngine() = 0;
+
+ static std::string ReadFile(const std::string& fileName);
+
+protected:
+
+ std::vector<HANDLE> loaded_modules;
+ std::vector<std::string> module_path;
+
+};
+
+#endif // JS_SHELL_H
--- /dev/null
+#include <JavaScriptCore/JavaScript.h>
+
+#include "js_shell.h"
+
+#include <iostream>
+#include <stdio.h>
+
+#ifdef __GNUC__
+#include <dlfcn.h>
+#define LOAD_SYMBOL(handle, name) dlsym(handle, name)
+#else
+#error "implement dll loading"
+#endif
+
+class JSCShell: public JSShell {
+
+typedef int (*JSCIntializer)(JSGlobalContextRef context, JSObjectRef *module);
+
+public:
+
+ JSCShell() {};
+
+ virtual ~JSCShell();
+
+protected:
+
+ virtual bool InitializeEngine();
+
+ virtual bool ExecuteScript(const std::string& source, const std::string& scriptPath);
+
+ virtual bool DisposeEngine();
+
+private:
+
+ JSObjectRef Import(const std::string &moduleName);
+
+ static JSValueRef Print(JSContextRef context, JSObjectRef object, JSObjectRef globalobj, size_t argc, const JSValueRef args[], JSValueRef* ex);
+
+ static JSValueRef Require(JSContextRef context, JSObjectRef object, JSObjectRef globalobj, size_t argc, const JSValueRef args[], JSValueRef* ex);
+
+ static bool RegisterFunction(JSGlobalContextRef context, JSObjectRef object, const char* functionName, JSObjectCallAsFunctionCallback cbFunction);
+
+ static void PrintError(JSContextRef, JSValueRef);
+
+private:
+
+ JSGlobalContextRef context;
+};
+
+JSCShell::~JSCShell() {
+ if(context != 0) {
+ JSGlobalContextRelease(context);
+ context = 0;
+ }
+}
+
+bool JSCShell::InitializeEngine() {
+ if(context != 0) {
+ JSGlobalContextRelease(context);
+ context = 0;
+ }
+ // TODO: check for initialization errors
+ context = JSGlobalContextCreate(NULL);
+ if(context == 0) return false;
+ JSObjectRef globalObject = JSContextGetGlobalObject(context);
+
+ // store this for later use
+ JSClassDefinition __shell_classdef__ = JSClassDefinition();
+
+ JSClassRef __shell_class__ = JSClassCreate(&__shell_classdef__);
+ JSObjectRef __shell__ = JSObjectMake(context, __shell_class__, 0);
+ bool success = JSObjectSetPrivate(__shell__, (void*) (long) this);
+ if (!success) {
+ std::cerr << "Could not register the shell in the Javascript context" << std::endl;
+ return false;
+ }
+ JSStringRef shellKey = JSStringCreateWithUTF8CString("__shell__");
+ JSObjectSetProperty(context, globalObject, shellKey, __shell__, kJSPropertyAttributeReadOnly, NULL);
+ JSStringRelease(shellKey);
+
+ JSCShell::RegisterFunction(context, globalObject, "print", JSCShell::Print);
+ JSCShell::RegisterFunction(context, globalObject, "require", JSCShell::Require);
+
+ return true;
+}
+
+bool JSCShell::ExecuteScript(const std::string& source, const std::string& scriptPath) {
+ JSStringRef jsScript;
+ JSStringRef sourceURL;
+ JSValueRef ex;
+ jsScript = JSStringCreateWithUTF8CString(source.c_str());
+ sourceURL = JSStringCreateWithUTF8CString(scriptPath.c_str());
+ JSValueRef jsResult = JSEvaluateScript(context, jsScript, 0, sourceURL, 0, &ex);
+ JSStringRelease(jsScript);
+ if (jsResult == NULL && ex != NULL) {
+ JSCShell::PrintError(context, ex);
+ return false;
+ }
+ return true;
+}
+
+bool JSCShell::DisposeEngine() {
+ JSGlobalContextRelease(context);
+ context = 0;
+ return true;
+}
+
+JSValueRef JSCShell::Print(JSContextRef context, JSObjectRef object,
+ JSObjectRef globalobj, size_t argc,
+ const JSValueRef args[], JSValueRef* ex) {
+ if (argc > 0)
+ {
+ JSStringRef string = JSValueToStringCopy(context, args[0], NULL);
+ size_t numChars = JSStringGetMaximumUTF8CStringSize(string);
+ char *stringUTF8 = new char[numChars];
+ JSStringGetUTF8CString(string, stringUTF8, numChars);
+ printf("%s\n", stringUTF8);
+
+ delete[] stringUTF8;
+ }
+
+ return JSValueMakeUndefined(context);
+}
+
+// Attention: this feature should not create too high expectations.
+// It is only capable of loading things relative to the execution directory
+// and not relative to the parent script.
+JSValueRef JSCShell::Require(JSContextRef context, JSObjectRef object,
+ JSObjectRef globalObj, size_t argc,
+ const JSValueRef args[], JSValueRef* ex) {
+ JSObjectRef module;
+
+ JSStringRef shellKey = JSStringCreateWithUTF8CString("__shell__");
+ JSValueRef shellAsVal = JSObjectGetProperty(context, globalObj, shellKey, NULL);
+ JSStringRelease(shellKey);
+ JSObjectRef shell = JSValueToObject(context, shellAsVal, 0);
+ JSCShell *_this = (JSCShell*) (long) JSObjectGetPrivate(shell);
+
+ if (argc > 0)
+ {
+ JSStringRef string = JSValueToStringCopy(context, args[0], NULL);
+ size_t numChars = JSStringGetMaximumUTF8CStringSize(string);
+ char *stringUTF8 = new char[numChars];
+ JSStringGetUTF8CString(string, stringUTF8, numChars);
+
+ std::string modulePath(stringUTF8);
+ module = _this->Import(modulePath);
+
+ delete[] stringUTF8;
+ }
+
+ if (module) {
+ return module;
+ } else {
+ printf("Ooops.\n");
+ return JSValueMakeUndefined(context);
+ }
+}
+
+JSObjectRef JSCShell::Import(const std::string& module_path) {
+
+ HANDLE library;
+ std::string module_name = LoadModule(module_path, &library);
+
+ if (library == 0) {
+ printf("Could not load module.");
+ return 0;
+ }
+
+ std::string symname = std::string(module_name).append("_initialize");
+
+ JSCIntializer init_function = reinterpret_cast<JSCIntializer>((long) LOAD_SYMBOL(library, symname.c_str()));
+ if(init_function == 0) {
+ printf("Could not find module's initializer function.");
+ return 0;
+ }
+
+ JSObjectRef module;
+ init_function(context, &module);
+
+ return module;
+}
+
+bool JSCShell::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;
+}
+
+void JSCShell::PrintError(JSContextRef ctx, JSValueRef err) {
+ char *buffer;
+ size_t length;
+
+ JSStringRef string = JSValueToStringCopy(ctx, err, 0);
+ length = JSStringGetLength(string);
+ buffer = new char[length+1];
+ JSStringGetUTF8CString(string, buffer, length+1);
+ std::string errMsg(buffer);
+ JSStringRelease(string);
+ delete[] buffer;
+
+ JSObjectRef errObj = JSValueToObject(ctx, err, 0);
+
+ if(errObj == 0) {
+ std::cerr << errMsg << std::endl;
+ return;
+ }
+
+ JSStringRef sourceURLKey = JSStringCreateWithUTF8CString("sourceURL");
+ JSStringRef sourceURLStr = JSValueToStringCopy(ctx, JSObjectGetProperty(ctx, errObj, sourceURLKey, 0), 0);
+ length = JSStringGetLength(sourceURLStr);
+ buffer = new char[length+1];
+ JSStringGetUTF8CString(sourceURLStr, buffer, length+1);
+ std::string sourceURL(buffer);
+ delete[] buffer;
+ JSStringRelease(sourceURLStr);
+ JSStringRelease(sourceURLKey);
+
+ JSStringRef lineKey = JSStringCreateWithUTF8CString("line");
+ JSValueRef jsLine = JSObjectGetProperty(ctx, errObj, lineKey, 0);
+ int line = (int) JSValueToNumber(ctx, jsLine, 0);
+ JSStringRelease(lineKey);
+
+ std::cerr << sourceURL << ":" << line << ":" << errMsg << std::endl;
+}
+
+JSShell* JSCShell_Create() {
+ return new JSCShell();
+}
--- /dev/null
+#include <assert.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <v8.h>
+#include <vector>
+
+#include "js_shell.h"
+
+typedef int (*V8ExtensionInitializer) (v8::Handle<v8::Object> module);
+
+// Note: these typedefs and defines are used to deal with v8 API changes since version 3.19.00
+
+#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 < 0x032318)
+#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 < 0x032318)
+#define SWIGV8_CURRENT_CONTEXT() v8::Context::GetCurrent()
+#define SWIGV8_STRING_NEW(str) v8::String::New(str)
+#define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(func)
+#define SWIGV8_OBJECT_NEW() v8::Object::New()
+#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(val)
+#define SWIGV8_UNDEFINED() v8::Undefined()
+#else
+#define SWIGV8_CURRENT_CONTEXT() v8::Isolate::GetCurrent()->GetCurrentContext()
+#define SWIGV8_STRING_NEW(str) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str)
+#define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), func)
+#define SWIGV8_OBJECT_NEW() v8::Object::New(v8::Isolate::GetCurrent())
+#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(v8::Isolate::GetCurrent(), val)
+#define SWIGV8_UNDEFINED() v8::Undefined(v8::Isolate::GetCurrent())
+#endif
+
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+typedef v8::Persistent<v8::Context> SwigV8Context;
+#else
+typedef v8::Local<v8::Context> SwigV8Context;
+#endif
+
+class V8Shell: public JSShell {
+
+public:
+ V8Shell();
+
+ virtual ~V8Shell();
+
+ virtual bool RunScript(const std::string &scriptPath);
+
+ virtual bool RunShell();
+
+
+protected:
+
+ virtual bool InitializeEngine();
+
+ virtual bool ExecuteScript(const std::string &source, const std::string &scriptPath);
+
+ virtual bool DisposeEngine();
+
+private:
+
+ v8::Handle<v8::Value> Import(const std::string &moduleName);
+
+ SwigV8Context CreateShellContext();
+
+ void ReportException(v8::TryCatch *handler);
+
+ static SwigV8ReturnValue Print(const SwigV8Arguments &args);
+
+ static SwigV8ReturnValue Require(const SwigV8Arguments &args);
+
+ static SwigV8ReturnValue Quit(const SwigV8Arguments &args);
+
+ static SwigV8ReturnValue Version(const SwigV8Arguments &args);
+
+ static const char* ToCString(const v8::String::Utf8Value &value);
+
+};
+
+#ifdef __GNUC__
+#include <dlfcn.h>
+#define LOAD_SYMBOL(handle, name) dlsym(handle, name)
+#else
+#error "implement dll loading"
+#endif
+
+V8Shell::V8Shell() {}
+
+V8Shell::~V8Shell() {}
+
+bool V8Shell::RunScript(const std::string &scriptPath) {
+ std::string source = ReadFile(scriptPath);
+
+ v8::Isolate *isolate = v8::Isolate::New();
+ v8::Isolate::Scope isolate_scope(isolate);
+
+ SWIGV8_HANDLESCOPE();
+
+ SwigV8Context context = CreateShellContext();
+
+ if (context.IsEmpty()) {
+ printf("Could not create context.\n");
+ return false;
+ }
+
+ context->Enter();
+
+ // Store a pointer to this shell for later use
+
+ v8::Handle<v8::Object> global = context->Global();
+ v8::Local<v8::External> __shell__ = SWIGV8_EXTERNAL_NEW((void*) (long) this);
+
+ global->SetHiddenValue(SWIGV8_STRING_NEW("__shell__"), __shell__);
+
+ // Node.js compatibility: make `print` available as `console.log()`
+ ExecuteScript("var console = {}; console.log = print;", "<console>");
+
+ bool success = ExecuteScript(source, scriptPath);
+
+ // Cleanup
+
+ context->Exit();
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+ context.Dispose();
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+ context.Dispose(v8::Isolate::GetCurrent());
+#else
+// context.Dispose();
+#endif
+
+// v8::V8::Dispose();
+
+ return success;
+}
+
+bool V8Shell::RunShell() {
+ SWIGV8_HANDLESCOPE();
+
+ SwigV8Context context = CreateShellContext();
+
+ if (context.IsEmpty()) {
+ printf("Could not create context.\n");
+ return false;
+ }
+
+ context->Enter();
+
+ v8::Context::Scope context_scope(context);
+
+ ExecuteScript("var console = {}; console.log = print;", "<console>");
+
+ static const int kBufferSize = 1024;
+ while (true) {
+ char buffer[kBufferSize];
+ printf("> ");
+ char *str = fgets(buffer, kBufferSize, stdin);
+ if (str == NULL) break;
+ std::string source(str);
+ ExecuteScript(source, "(shell)");
+ }
+ printf("\n");
+
+ // Cleanup
+
+ context->Exit();
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
+ context.Dispose();
+#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+ context.Dispose(v8::Isolate::GetCurrent());
+#else
+// context.Dispose();
+#endif
+
+// v8::V8::Dispose();
+
+ return true;
+}
+
+
+bool V8Shell::InitializeEngine() {
+ return true;
+}
+
+bool V8Shell::ExecuteScript(const std::string &source, const std::string &name) {
+ SWIGV8_HANDLESCOPE();
+
+ v8::TryCatch try_catch;
+ v8::Handle<v8::Script> script = v8::Script::Compile(SWIGV8_STRING_NEW(source.c_str()), SWIGV8_STRING_NEW(name.c_str()));
+
+ // Stop if script is empty
+ if (script.IsEmpty()) {
+ // Print errors that happened during compilation.
+ ReportException(&try_catch);
+ return false;
+ }
+
+ v8::Handle<v8::Value> result = script->Run();
+
+ // Print errors that happened during execution.
+ if (try_catch.HasCaught()) {
+ ReportException(&try_catch);
+ return false;
+ } else {
+ return true;
+ }
+}
+
+bool V8Shell::DisposeEngine() {
+ return true;
+}
+
+SwigV8Context V8Shell::CreateShellContext() {
+ // Create a template for the global object.
+ v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
+
+ // Bind global functions
+ global->Set(SWIGV8_STRING_NEW("print"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Print));
+ global->Set(SWIGV8_STRING_NEW("quit"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Quit));
+ global->Set(SWIGV8_STRING_NEW("require"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Require));
+ global->Set(SWIGV8_STRING_NEW("version"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Version));
+
+#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
+ SwigV8Context context = v8::Context::New(NULL, global);
+ return context;
+#else
+ SwigV8Context context = v8::Context::New(v8::Isolate::GetCurrent(), NULL, global);
+ return context;
+#endif
+}
+
+v8::Handle<v8::Value> V8Shell::Import(const std::string &module_path)
+{
+ SWIGV8_HANDLESCOPE_ESC();
+
+ HANDLE library;
+ std::string module_name = LoadModule(module_path, &library);
+
+ std::string symname = std::string(module_name).append("_initialize");
+
+ V8ExtensionInitializer init_function = reinterpret_cast<V8ExtensionInitializer>((long) LOAD_SYMBOL(library, symname.c_str()));
+
+ if(init_function == 0) {
+ printf("Could not find initializer function.");
+
+ return SWIGV8_UNDEFINED();
+ }
+
+ v8::Local<v8::Object> module = SWIGV8_OBJECT_NEW();
+ init_function(module);
+
+ SWIGV8_ESCAPE(module);
+}
+
+SwigV8ReturnValue V8Shell::Print(const SwigV8Arguments &args) {
+ SWIGV8_HANDLESCOPE();
+
+ bool first = true;
+ for (int i = 0; i < args.Length(); i++) {
+
+ if (first) {
+ first = false;
+ } else {
+ printf(" ");
+ }
+ v8::String::Utf8Value str(args[i]);
+ const char *cstr = V8Shell::ToCString(str);
+ printf("%s", cstr);
+ }
+ printf("\n");
+ fflush(stdout);
+
+ SWIGV8_RETURN(SWIGV8_UNDEFINED());
+}
+
+SwigV8ReturnValue V8Shell::Require(const SwigV8Arguments &args) {
+ SWIGV8_HANDLESCOPE();
+
+ if (args.Length() != 1) {
+ printf("Illegal arguments for `require`");
+ };
+
+ v8::String::Utf8Value str(args[0]);
+ const char *cstr = V8Shell::ToCString(str);
+ std::string moduleName(cstr);
+
+ v8::Local<v8::Object> global = SWIGV8_CURRENT_CONTEXT()->Global();
+
+ v8::Local<v8::Value> hidden = global->GetHiddenValue(SWIGV8_STRING_NEW("__shell__"));
+ v8::Local<v8::External> __shell__ = v8::Local<v8::External>::Cast(hidden);
+ V8Shell *_this = (V8Shell *) (long) __shell__->Value();
+
+ v8::Handle<v8::Value> module = _this->Import(moduleName);
+
+ SWIGV8_RETURN(module);
+}
+
+SwigV8ReturnValue V8Shell::Quit(const SwigV8Arguments &args) {
+ SWIGV8_HANDLESCOPE();
+
+ int exit_code = args[0]->Int32Value();
+ fflush(stdout);
+ fflush(stderr);
+ exit(exit_code);
+
+ SWIGV8_RETURN(SWIGV8_UNDEFINED());
+}
+
+SwigV8ReturnValue V8Shell::Version(const SwigV8Arguments &args) {
+ SWIGV8_HANDLESCOPE();
+ SWIGV8_RETURN(SWIGV8_STRING_NEW(v8::V8::GetVersion()));
+}
+
+void V8Shell::ReportException(v8::TryCatch *try_catch) {
+ SWIGV8_HANDLESCOPE();
+
+ v8::String::Utf8Value exception(try_catch->Exception());
+ const char *exception_string = V8Shell::ToCString(exception);
+ v8::Handle<v8::Message> message = try_catch->Message();
+ if (message.IsEmpty()) {
+ // V8 didn't provide any extra information about this error; just
+ // print the exception.
+ printf("%s\n", exception_string);
+ } else {
+ // Print (filename):(line number): (message).
+ v8::String::Utf8Value filename(message->GetScriptResourceName());
+ const char *filename_string = V8Shell::ToCString(filename);
+ int linenum = message->GetLineNumber();
+ printf("%s:%i: %s\n", filename_string, linenum, exception_string);
+ // Print line of source code.
+ v8::String::Utf8Value sourceline(message->GetSourceLine());
+ const char *sourceline_string = V8Shell::ToCString(sourceline);
+ printf("%s\n", sourceline_string);
+ // Print wavy underline (GetUnderline is deprecated).
+ int start = message->GetStartColumn();
+ for (int i = 0; i < start; i++) {
+ printf(" ");
+ }
+ int end = message->GetEndColumn();
+ for (int i = start; i < end; i++) {
+ printf("^");
+ }
+ printf("\n");
+ v8::String::Utf8Value stack_trace(try_catch->StackTrace());
+ if (stack_trace.length() > 0) {
+ const char *stack_trace_string = V8Shell::ToCString(stack_trace);
+ printf("%s\n", stack_trace_string);
+ }
+ }
+}
+
+// Extracts a C string from a V8 Utf8Value.
+const char *V8Shell::ToCString(const v8::String::Utf8Value &value) {
+ return *value ? *value : "<string conversion failed>";
+}
+
+JSShell *V8Shell_Create() {
+ return new V8Shell();
+}
# Build documentation
print "Building html documentation"
os.system("cd "+dirname+"/Doc/Manual && make all clean-baks") == 0 or failed()
-print "Building man pages"
-os.system("cd "+dirname+"/CCache && yodl2man -o ccache-swig.1 ccache.yo") == 0 or failed()
# Build the tar-ball
os.system("tar -cf "+dirname+".tar "+dirname) == 0 or failed()
print "Finished"
-print "Now log in to SourceForge and set the operating systems applicable to the newly uploaded tarball and zip file. Also remember to do a 'git push'."
+print "Now log in to SourceForge and set the operating systems applicable to the newly uploaded tarball and zip file. Also remember to do a 'git push --tags'."
# options for configure
extraconfigureoptions=
-compileflags="-O2"
-extracompileflags=
+compileflags="-O2 -Wall -Wextra"
if test x$1 != x; then
version=$1
if test x$zip = x; then
zip=zip
fi
- extraconfigureoptions="--host=i586-mingw32msvc --build=i686-linux"
+ echo "Checking that mingw 32-bit gcc is installed/available"
+ if test -n "`which i686-w64-mingw32-gcc`" ; then
+ i686-w64-mingw32-gcc --version || exit 1
+ i686-w64-mingw32-g++ --version || exit 1
+ extraconfigureoptions="--host=i686-w64-mingw32 --build=i686-linux"
+ # Statically link so that libstdc++-6.dll and libgcc_s_sjlj-1.dll don't have to be shipped
+ compileflags="$compileflags -static-libgcc -static-libstdc++"
+ elif test -n "`which i586-mingw32msvc-gcc`" ; then
+ i586-mingw32msvc-gcc --version || exit 1
+ i586-mingw32msvc-g++ --version || exit 1
+ extraconfigureoptions="--host=i586-mingw32msvc --build=i686-linux"
+ else
+ echo "Could not detect mingw gcc - please install mingw-w64 package."
+ exit 1;
+ fi
else
if test "$cygwin"; then
echo "Building native Windows executable on Cygwin"
if test x$zip = x; then
zip=zip
fi
- compileflags="-O2 -mno-cygwin"
+ compileflags="$compileflags -mno-cygwin"
else
echo "Unknown platform. Requires either Linux or MinGW."
exit 1;
fi
fi
+export CFLAGS="$compileflags"
+export CXXFLAGS="$compileflags"
+
swigbasename=swig-$version
swigwinbasename=swigwin-$version
tarball=$swigbasename.tar.gz
tar -zxf ../$tarball
cd $swigbasename
(cd ../.. && cp $pcre_tarball $builddir/$swigbasename)
- echo Running: Tools/pcre-build.sh $extraconfigureoptions CFLAGS="$compileflags" CXXFLAGS="$compileflags"
- ./Tools/pcre-build.sh $extraconfigureoptions CFLAGS="$compileflags" CXXFLAGS="$compileflags" || exit 1
- echo Running: ./configure $extraconfigureoptions CFLAGS="$compileflags" CXXFLAGS="$compileflags"
- ./configure $extraconfigureoptions CFLAGS="$compileflags" CXXFLAGS="$compileflags" || exit 1
+ echo Running: Tools/pcre-build.sh $extraconfigureoptions
+ ./Tools/pcre-build.sh $extraconfigureoptions
+ echo Running: ./configure $extraconfigureoptions --without-alllang
+ ./configure $extraconfigureoptions --without-alllang
echo "Compiling (quietly)..."
make > build.log
echo "Simple check to see if swig.exe runs..."
--- /dev/null
+rem Workaround 'nuget install' not being reliable by retrying a few times
+
+@echo off
+rem initiate the retry number
+set errorCode=1
+set retryNumber=0
+set maxRetries=5
+
+:RESTORE
+nuget install %*
+
+rem problem?
+IF ERRORLEVEL %errorCode% GOTO :RETRY
+
+rem everything is fine!
+GOTO :EXIT
+
+:RETRY
+@echo Oops, nuget restore exited with code %errorCode% - let us try again!
+set /a retryNumber=%retryNumber%+1
+IF %reTryNumber% LSS %maxRetries% (GOTO :RESTORE)
+IF %retryNumber% EQU %maxRetries% (GOTO :ERR)
+
+:ERR
+@echo Sorry, we tried restoring nuget packages for %maxRetries% times and all attempts were unsuccessful!
+EXIT /B 1
+
+:EXIT
--- /dev/null
+#!/usr/bin/env python
+
+import os
+import subprocess
+import argparse
+import glob
+
+def remove_old_files():
+ files = glob.glob("*.log")
+ for file in files:
+ os.remove(file)
+
+def download():
+ repos = subprocess.Popen(['osc', 'repositories'], stdout=subprocess.PIPE)
+ for line in repos.stdout:
+ command = ['osc', 'buildlog', '--last'] + line.split()
+ filename = "-".join(line.split()) + ".log"
+ print "Downloading logs using: {}".format(" ".join(command))
+ buildlog = subprocess.Popen(command, stdout=subprocess.PIPE)
+
+ print("Writing log to {}".format(filename))
+ file = open(filename, "w")
+ if buildlog.stderr != None:
+ print("Errors: {}".format(buildlog.stderr))
+ for log_line in buildlog.stdout:
+ file.write(log_line)
+
+ print("Finished")
+
+parser = argparse.ArgumentParser(description="Download OpenBuild logs using osc. All the logs for each architecture from the last completed builds are downloaded and stored as .log files. Must be run from a working copy that is already checked out, eg after running obs-update.")
+args = parser.parse_args()
+
+remove_old_files()
+download()
--- /dev/null
+#!/bin/bash
+
+# Update SWIG tarball on openSUSE Build Service to contain the latest from master
+# Requires the openSUSE Build Service command-line tool (osc)
+# See http://openbuildservice.org/download/
+# And these packages: obs-service-tar_scm obs-service-recompress obs-service-set_version
+
+# Results appear at https://build.opensuse.org/package/show/home:kwk:swig/swig-raw
+
+set -e
+set -x
+
+rm -rf home-kwk-swig/swig-raw
+mkdir -p home-kwk-swig
+cd home-kwk-swig
+# check out 'swig-raw'
+osc co -o swig-raw home:kwk:swig swig-raw
+cd swig-raw
+# remove existing tarball
+osc rm swig*tar.bz2
+# fetch latest master branch from git and create tarball
+osc service disabledrun
+# add new tarball
+osc addremove
+# check changes into build service, triggers build
+osc ci
--- /dev/null
+#!/usr/bin/env python
+
+def get_cflags(language, std, compiler):
+ if std == None or len(std) == 0:
+ std = "gnu89"
+ c_common = "-fdiagnostics-show-option -std=" + std + " -Wno-long-long -Wreturn-type -Wdeclaration-after-statement -Wmissing-field-initializers"
+ cflags = {
+ "csharp":"-Werror " + c_common,
+ "d":"-Werror " + c_common,
+ "go":"-Werror " + c_common + " -Wno-declaration-after-statement",
+ "guile":"-Werror " + c_common,
+ "java":"-Werror " + c_common,
+ "javascript":"-Werror " + c_common,
+ "lua":"-Werror " + c_common,
+ "octave":"-Werror " + c_common,
+ "perl5":"-Werror " + c_common,
+ "php":"-Werror " + c_common,
+ "python":"-Werror " + c_common,
+ "r":"-Werror " + c_common,
+ "ruby":"-Werror " + c_common,
+ "scilab":"-Werror " + c_common,
+ "tcl":"-Werror " + c_common,
+ }
+ if compiler == 'clang':
+ cflags["guile"] += " -Wno-attributes" # -Wno-attributes is for clang LLVM 3.5 and bdw-gc < 7.5 used by guile
+
+ if language not in cflags:
+ raise RuntimeError("{} is not a supported language".format(language))
+
+ return cflags[language]
+
+def get_cxxflags(language, std, compiler):
+ if std == None or len(std) == 0:
+ std = "c++98"
+ cxx_common = "-fdiagnostics-show-option -std=" + std + " -Wno-long-long -Wreturn-type -Wmissing-field-initializers"
+ cxxflags = {
+ "csharp":"-Werror " + cxx_common,
+ "d":"-Werror " + cxx_common,
+ "go":"-Werror " + cxx_common,
+ "guile":"-Werror " + cxx_common,
+ "java":"-Werror " + cxx_common,
+ "javascript":"-Werror " + cxx_common + " -Wno-error=unused-function", # Until overload_rename is fixed for node
+ "lua":"-Werror " + cxx_common,
+ "octave":"-Werror " + cxx_common,
+ "perl5":"-Werror " + cxx_common,
+ "php":"-Werror " + cxx_common,
+ "python":"-Werror " + cxx_common,
+ "r":"-Werror " + cxx_common,
+ "ruby":"-Werror " + cxx_common,
+ "scilab":"-Werror " + cxx_common,
+ "tcl":"-Werror " + cxx_common,
+ }
+ if compiler == 'clang':
+ cxxflags["guile"] += " -Wno-attributes" # -Wno-attributes is for clang LLVM 3.5 and bdw-gc < 7.5 used by guile
+
+ if language not in cxxflags:
+ raise RuntimeError("{} is not a supported language".format(language))
+
+ return cxxflags[language]
+
+import argparse
+parser = argparse.ArgumentParser(description="Display CFLAGS or CXXFLAGS to use for testing the SWIG examples and test-suite.")
+parser.add_argument('-l', '--language', required=True, help='set language to show flags for')
+flags = parser.add_mutually_exclusive_group(required=True)
+flags.add_argument('-c', '--cflags', action='store_true', default=False, help='show CFLAGS')
+flags.add_argument('-x', '--cxxflags', action='store_true', default=False, help='show CXXFLAGS')
+parser.add_argument('-s', '--std', required=False, help='language standard flags for the -std= option')
+parser.add_argument('-C', '--compiler', required=False, help='compiler used (clang or gcc)')
+args = parser.parse_args()
+
+if args.cflags:
+ get_flags = get_cflags
+elif args.cxxflags:
+ get_flags = get_cxxflags
+else:
+ parser.print_help()
+ exit(1)
+
+print(get_flags(args.language, args.std, args.compiler))
--- /dev/null
+#!/bin/bash
+
+set -e # exit on failure
+
+lsb_release -a
+sudo apt-get -qq update
+
+if [[ "$CC" == gcc-5 ]]; then
+ sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+ sudo apt-get -qq update
+ sudo apt-get install -qq g++-5
+elif [[ "$CC" == gcc-6 ]]; then
+ sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+ sudo apt-get -qq update
+ sudo apt-get install -qq g++-6
+fi
+
+sudo apt-get -qq install libboost-dev
+
+WITHLANG=$SWIGLANG
+
+case "$SWIGLANG" in
+ "") ;;
+ "csharp")
+ sudo apt-get -qq install mono-devel
+ ;;
+ "d")
+ wget http://downloads.dlang.org/releases/2014/dmd_2.066.0-0_amd64.deb
+ sudo dpkg -i dmd_2.066.0-0_amd64.deb
+ ;;
+ "go")
+ ;;
+ "javascript")
+ case "$ENGINE" in
+ "node")
+ sudo add-apt-repository -y ppa:chris-lea/node.js
+ sudo apt-get -qq update
+ sudo apt-get install -qq nodejs rlwrap
+ sudo npm install -g node-gyp
+ ;;
+ "jsc")
+ sudo apt-get install -qq libwebkitgtk-dev
+ ;;
+ "v8")
+ sudo apt-get install -qq libv8-dev
+ ;;
+ esac
+ ;;
+ "guile")
+ sudo apt-get -qq install guile-2.0-dev
+ ;;
+ "lua")
+ if [[ -z "$VER" ]]; then
+ sudo apt-get -qq install lua5.1 liblua5.1-dev
+ else
+ sudo add-apt-repository -y ppa:ubuntu-cloud-archive/mitaka-staging
+ sudo apt-get -qq update
+ sudo apt-get -qq install lua${VER} liblua${VER}-dev
+ fi
+ ;;
+ "ocaml")
+ # configure also looks for ocamldlgen, but this isn't packaged. But it isn't used by default so this doesn't matter.
+ sudo apt-get -qq install ocaml ocaml-findlib
+ ;;
+ "octave")
+ if [[ -z "$VER" ]]; then
+ sudo apt-get -qq install octave3.2 octave3.2-headers
+ else
+ sudo add-apt-repository -y ppa:kwwette/octaves
+ sudo apt-get -qq update
+ sudo apt-get -qq install liboctave${VER}-dev
+ fi
+ ;;
+ "php")
+ sudo apt-get install php5-cli php5-dev
+ ;;
+ "python")
+ git clone https://github.com/jcrocholl/pep8.git
+ (
+ cd pep8
+ git checkout tags/1.5.7
+ python ./setup.py build
+ sudo python ./setup.py install
+ )
+ if [[ "$PY3" ]]; then
+ sudo apt-get install -qq python3-dev
+ fi
+ WITHLANG=$SWIGLANG$PY3
+ if [[ "$VER" ]]; then
+ sudo add-apt-repository -y ppa:fkrull/deadsnakes
+ sudo apt-get -qq update
+ sudo apt-get -qq install python${VER}-dev
+ WITHLANG=$SWIGLANG$PY3=$SWIGLANG$VER
+ fi
+ ;;
+ "r")
+ sudo apt-get -qq install r-base
+ ;;
+ "ruby")
+ if [[ "$VER" ]]; then
+ rvm install $VER
+ fi
+ ;;
+ "scilab")
+ sudo apt-get -qq install scilab
+ ;;
+ "tcl")
+ sudo apt-get -qq install tcl8.4-dev
+ ;;
+esac
--- /dev/null
+#!/bin/bash
+
+set -e # exit on failure
+
+sw_vers
+brew update
+brew list
+brew install pcre
+# brew install boost
+
+WITHLANG=$SWIGLANG
+
+case "$SWIGLANG" in
+ "csharp")
+ brew install https://s3.amazonaws.com/travisbuilds.swig.org/mono.rb
+ ;;
+ "guile")
+ Tools/brew-install guile
+ ;;
+ "lua")
+ brew install lua
+ ;;
+ "python")
+ WITHLANG=$SWIGLANG$PY3
+ if [[ "$PY3" ]]; then
+ brew install python3
+ brew list -v python3
+ fi
+ ;;
+esac
# This is a simple utility for Cygwin/Mingw which is useful when running the SWIG
# test-suite through Visual Studio. If the output from the test-suite is piped
-# through this utility, it will filter the junk that the compiler generates.
+# through this utility, it will filter the junk that the compiler outputs to stdout.
# Typical usage: make check | vcfilter
# dos2unix needed for ^ and $ to work.
-2>&1 dos2unix | grep -v "\.cxx$" | grep -v "\.c$" | grep -v "^ Creating library" | grep -v "^Generating Code"
+2>&1 dos2unix | grep -v -e "\.cxx$" -e "\.c$" -e "^ Creating library" -e "^Generating Code"
-# generated automatically by aclocal 1.11.3 -*- Autoconf -*-
+# generated automatically by aclocal 1.15 -*- Autoconf -*-
+
+# Copyright (C) 1996-2014 Free Software Foundation, Inc.
-# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
-# 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation,
-# Inc.
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
+m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
m4_ifndef([AC_AUTOCONF_VERSION],
[m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
-m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.68],,
-[m4_warning([this file was generated for autoconf 2.68.
+m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],,
+[m4_warning([this file was generated for autoconf 2.69.
You have another version of autoconf. It may work, but is not guaranteed to.
If you have problems, you may need to regenerate the build system entirely.
-To do so, use the procedure documented by the package, typically `autoreconf'.])])
+To do so, use the procedure documented by the package, typically 'autoreconf'.])])
-# Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008, 2011 Free Software
-# Foundation, Inc.
+# Copyright (C) 2002-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 1
-
# AM_AUTOMAKE_VERSION(VERSION)
# ----------------------------
# Automake X.Y traces this macro to ensure aclocal.m4 has been
# generated from the m4 files accompanying Automake X.Y.
# (This private macro should not be called outside this file.)
AC_DEFUN([AM_AUTOMAKE_VERSION],
-[am__api_version='1.11'
+[am__api_version='1.15'
dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
dnl require some minimum version. Point them to the right macro.
-m4_if([$1], [1.11.3], [],
+m4_if([$1], [1.15], [],
[AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
])
# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
-[AM_AUTOMAKE_VERSION([1.11.3])dnl
+[AM_AUTOMAKE_VERSION([1.15])dnl
m4_ifndef([AC_AUTOCONF_VERSION],
[m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
# AM_AUX_DIR_EXPAND -*- Autoconf -*-
-# Copyright (C) 2001, 2003, 2005, 2011 Free Software Foundation, Inc.
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 1
-
# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
-# $ac_aux_dir to `$srcdir/foo'. In other projects, it is set to
-# `$srcdir', `$srcdir/..', or `$srcdir/../..'.
+# $ac_aux_dir to '$srcdir/foo'. In other projects, it is set to
+# '$srcdir', '$srcdir/..', or '$srcdir/../..'.
#
# Of course, Automake must honor this variable whenever it calls a
# tool from the auxiliary directory. The problem is that $srcdir (and
#
# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
# are both prefixed by $srcdir. In an in-source build this is usually
-# harmless because $srcdir is `.', but things will broke when you
+# harmless because $srcdir is '.', but things will broke when you
# start a VPATH build or use an absolute $srcdir.
#
# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
# configured tree to be moved without reconfiguration.
AC_DEFUN([AM_AUX_DIR_EXPAND],
-[dnl Rely on autoconf to set up CDPATH properly.
-AC_PREREQ([2.50])dnl
-# expand $ac_aux_dir to an absolute path
-am_aux_dir=`cd $ac_aux_dir && pwd`
+[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
+# Expand $ac_aux_dir to an absolute path.
+am_aux_dir=`cd "$ac_aux_dir" && pwd`
])
# AM_CONDITIONAL -*- Autoconf -*-
-# Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005, 2006, 2008
-# Free Software Foundation, Inc.
+# Copyright (C) 1997-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 9
-
# AM_CONDITIONAL(NAME, SHELL-CONDITION)
# -------------------------------------
# Define a conditional.
AC_DEFUN([AM_CONDITIONAL],
-[AC_PREREQ(2.52)dnl
- ifelse([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])],
- [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
+[AC_PREREQ([2.52])dnl
+ m4_if([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])],
+ [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
AC_SUBST([$1_TRUE])dnl
AC_SUBST([$1_FALSE])dnl
_AM_SUBST_NOTMAKE([$1_TRUE])dnl
Usually this means the macro was only invoked conditionally.]])
fi])])
-# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2009,
-# 2010, 2011 Free Software Foundation, Inc.
+# Copyright (C) 1999-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 12
-# There are a few dirty hacks below to avoid letting `AC_PROG_CC' be
+# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be
# written in clear, in which case automake, when reading aclocal.m4,
# will think it sees a *use*, and therefore will trigger all it's
# C support machinery. Also note that it means that autoscan, seeing
# _AM_DEPENDENCIES(NAME)
# ----------------------
# See how the compiler implements dependency checking.
-# NAME is "CC", "CXX", "GCJ", or "OBJC".
+# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC".
# We try a few techniques and use that to set a single cache variable.
#
# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
AC_REQUIRE([AM_MAKE_INCLUDE])dnl
AC_REQUIRE([AM_DEP_TRACK])dnl
-ifelse([$1], CC, [depcc="$CC" am_compiler_list=],
- [$1], CXX, [depcc="$CXX" am_compiler_list=],
- [$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
- [$1], UPC, [depcc="$UPC" am_compiler_list=],
- [$1], GCJ, [depcc="$GCJ" am_compiler_list='gcc3 gcc'],
- [depcc="$$1" am_compiler_list=])
+m4_if([$1], [CC], [depcc="$CC" am_compiler_list=],
+ [$1], [CXX], [depcc="$CXX" am_compiler_list=],
+ [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
+ [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'],
+ [$1], [UPC], [depcc="$UPC" am_compiler_list=],
+ [$1], [GCJ], [depcc="$GCJ" am_compiler_list='gcc3 gcc'],
+ [depcc="$$1" am_compiler_list=])
AC_CACHE_CHECK([dependency style of $depcc],
[am_cv_$1_dependencies_compiler_type],
# We make a subdir and do the tests there. Otherwise we can end up
# making bogus files that we don't know about and never remove. For
# instance it was reported that on HP-UX the gcc test will end up
- # making a dummy file named `D' -- because `-MD' means `put the output
- # in D'.
+ # making a dummy file named 'D' -- because '-MD' means "put the output
+ # in D".
rm -rf conftest.dir
mkdir conftest.dir
# Copy depcomp to subdir because otherwise we won't find it if we're
: > sub/conftest.c
for i in 1 2 3 4 5 6; do
echo '#include "conftst'$i'.h"' >> sub/conftest.c
- # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
- # Solaris 8's {/usr,}/bin/sh.
- touch sub/conftst$i.h
+ # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+ # Solaris 10 /bin/sh.
+ echo '/* dummy */' > sub/conftst$i.h
done
echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
- # We check with `-c' and `-o' for the sake of the "dashmstdout"
+ # We check with '-c' and '-o' for the sake of the "dashmstdout"
# mode. It turns out that the SunPro C++ compiler does not properly
- # handle `-M -o', and we need to detect this. Also, some Intel
- # versions had trouble with output in subdirs
+ # handle '-M -o', and we need to detect this. Also, some Intel
+ # versions had trouble with output in subdirs.
am__obj=sub/conftest.${OBJEXT-o}
am__minus_obj="-o $am__obj"
case $depmode in
test "$am__universal" = false || continue
;;
nosideeffect)
- # after this tag, mechanisms are not by side-effect, so they'll
- # only be used when explicitly requested
+ # After this tag, mechanisms are not by side-effect, so they'll
+ # only be used when explicitly requested.
if test "x$enable_dependency_tracking" = xyes; then
continue
else
fi
;;
msvc7 | msvc7msys | msvisualcpp | msvcmsys)
- # This compiler won't grok `-c -o', but also, the minuso test has
+ # This compiler won't grok '-c -o', but also, the minuso test has
# not run yet. These depmodes are late enough in the game, and
# so weak that their functioning should not be impacted.
am__obj=conftest.${OBJEXT-o}
# AM_SET_DEPDIR
# -------------
# Choose a directory name for dependency files.
-# This macro is AC_REQUIREd in _AM_DEPENDENCIES
+# This macro is AC_REQUIREd in _AM_DEPENDENCIES.
AC_DEFUN([AM_SET_DEPDIR],
[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
# AM_DEP_TRACK
# ------------
AC_DEFUN([AM_DEP_TRACK],
-[AC_ARG_ENABLE(dependency-tracking,
-[ --disable-dependency-tracking speeds up one-time build
- --enable-dependency-tracking do not reject slow dependency extractors])
+[AC_ARG_ENABLE([dependency-tracking], [dnl
+AS_HELP_STRING(
+ [--enable-dependency-tracking],
+ [do not reject slow dependency extractors])
+AS_HELP_STRING(
+ [--disable-dependency-tracking],
+ [speeds up one-time build])])
if test "x$enable_dependency_tracking" != xno; then
am_depcomp="$ac_aux_dir/depcomp"
AMDEPBACKSLASH='\'
# Generate code to set up dependency tracking. -*- Autoconf -*-
-# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2008
-# Free Software Foundation, Inc.
+# Copyright (C) 1999-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-#serial 5
# _AM_OUTPUT_DEPENDENCY_COMMANDS
# ------------------------------
AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
[{
- # Autoconf 2.62 quotes --file arguments for eval, but not when files
+ # Older Autoconf quotes --file arguments for eval, but not when files
# are listed without --file. Let's play safe and only enable the eval
# if we detect the quoting.
case $CONFIG_FILES in
# Strip MF so we end up with the name of the file.
mf=`echo "$mf" | sed -e 's/:.*$//'`
# Check whether this is an Automake generated Makefile or not.
- # We used to match only the files named `Makefile.in', but
+ # We used to match only the files named 'Makefile.in', but
# some people rename them; so instead we look at the file content.
# Grep'ing the first line is not enough: some people post-process
# each Makefile.in and add a new line on top of each file to say so.
continue
fi
# Extract the definition of DEPDIR, am__include, and am__quote
- # from the Makefile without running `make'.
+ # from the Makefile without running 'make'.
DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
test -z "$DEPDIR" && continue
am__include=`sed -n 's/^am__include = //p' < "$mf"`
- test -z "am__include" && continue
+ test -z "$am__include" && continue
am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
- # When using ansi2knr, U may be empty or an underscore; expand it
- U=`sed -n 's/^U = //p' < "$mf"`
# Find all dependency output files, they are included files with
# $(DEPDIR) in their names. We invoke sed twice because it is the
# simplest approach to changing $(DEPDIR) to its actual value in the
# expansion.
for file in `sed -n "
s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
- sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
+ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
# Make sure the directory exists.
test -f "$dirpart/$file" && continue
fdir=`AS_DIRNAME(["$file"])`
# This macro should only be invoked once -- use via AC_REQUIRE.
#
# This code is only required when automatic dependency tracking
-# is enabled. FIXME. This creates each `.P' file that we will
+# is enabled. FIXME. This creates each '.P' file that we will
# need in order to bootstrap the dependency handling code.
AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
[AC_CONFIG_COMMANDS([depfiles],
# Do all the work for Automake. -*- Autoconf -*-
-# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
-# 2005, 2006, 2008, 2009 Free Software Foundation, Inc.
+# Copyright (C) 1996-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 16
-
# This macro actually does too much. Some checks are only needed if
# your package does certain things. But this isn't really a big deal.
+dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O.
+m4_define([AC_PROG_CC],
+m4_defn([AC_PROG_CC])
+[_AM_PROG_CC_C_O
+])
+
# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
# AM_INIT_AUTOMAKE([OPTIONS])
# -----------------------------------------------
# arguments mandatory, and then we can depend on a new Autoconf
# release and drop the old call support.
AC_DEFUN([AM_INIT_AUTOMAKE],
-[AC_PREREQ([2.62])dnl
+[AC_PREREQ([2.65])dnl
dnl Autoconf wants to disallow AM_ names. We explicitly allow
dnl the ones we care about.
m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
# Define the identity of the package.
dnl Distinguish between old-style and new-style calls.
m4_ifval([$2],
-[m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
+[AC_DIAGNOSE([obsolete],
+ [$0: two- and three-arguments forms are deprecated.])
+m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
AC_SUBST([PACKAGE], [$1])dnl
AC_SUBST([VERSION], [$2])],
[_AM_SET_OPTIONS([$1])dnl
dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
-m4_if(m4_ifdef([AC_PACKAGE_NAME], 1)m4_ifdef([AC_PACKAGE_VERSION], 1), 11,,
+m4_if(
+ m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]),
+ [ok:ok],,
[m4_fatal([AC_INIT should be called with package and version arguments])])dnl
AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
_AM_IF_OPTION([no-define],,
-[AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
- AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl
+[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package])
+ AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl
# Some tools Automake needs.
AC_REQUIRE([AM_SANITY_CHECK])dnl
AC_REQUIRE([AC_ARG_PROGRAM])dnl
-AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version})
-AM_MISSING_PROG(AUTOCONF, autoconf)
-AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version})
-AM_MISSING_PROG(AUTOHEADER, autoheader)
-AM_MISSING_PROG(MAKEINFO, makeinfo)
+AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}])
+AM_MISSING_PROG([AUTOCONF], [autoconf])
+AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}])
+AM_MISSING_PROG([AUTOHEADER], [autoheader])
+AM_MISSING_PROG([MAKEINFO], [makeinfo])
AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
-AC_REQUIRE([AM_PROG_MKDIR_P])dnl
-# We need awk for the "check" target. The system "awk" is bad on
-# some platforms.
+AC_REQUIRE([AC_PROG_MKDIR_P])dnl
+# For better backward compatibility. To be removed once Automake 1.9.x
+# dies out for good. For more background, see:
+# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
+# We need awk for the "check" target (and possibly the TAP driver). The
+# system "awk" is bad on some platforms.
AC_REQUIRE([AC_PROG_AWK])dnl
AC_REQUIRE([AC_PROG_MAKE_SET])dnl
AC_REQUIRE([AM_SET_LEADING_DOT])dnl
[_AM_PROG_TAR([v7])])])
_AM_IF_OPTION([no-dependencies],,
[AC_PROVIDE_IFELSE([AC_PROG_CC],
- [_AM_DEPENDENCIES(CC)],
- [define([AC_PROG_CC],
- defn([AC_PROG_CC])[_AM_DEPENDENCIES(CC)])])dnl
+ [_AM_DEPENDENCIES([CC])],
+ [m4_define([AC_PROG_CC],
+ m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl
AC_PROVIDE_IFELSE([AC_PROG_CXX],
- [_AM_DEPENDENCIES(CXX)],
- [define([AC_PROG_CXX],
- defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl
+ [_AM_DEPENDENCIES([CXX])],
+ [m4_define([AC_PROG_CXX],
+ m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl
AC_PROVIDE_IFELSE([AC_PROG_OBJC],
- [_AM_DEPENDENCIES(OBJC)],
- [define([AC_PROG_OBJC],
- defn([AC_PROG_OBJC])[_AM_DEPENDENCIES(OBJC)])])dnl
+ [_AM_DEPENDENCIES([OBJC])],
+ [m4_define([AC_PROG_OBJC],
+ m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
+ [_AM_DEPENDENCIES([OBJCXX])],
+ [m4_define([AC_PROG_OBJCXX],
+ m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl
])
-_AM_IF_OPTION([silent-rules], [AC_REQUIRE([AM_SILENT_RULES])])dnl
-dnl The `parallel-tests' driver may need to know about EXEEXT, so add the
-dnl `am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This macro
-dnl is hooked onto _AC_COMPILER_EXEEXT early, see below.
+AC_REQUIRE([AM_SILENT_RULES])dnl
+dnl The testsuite driver may need to know about EXEEXT, so add the
+dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This
+dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below.
AC_CONFIG_COMMANDS_PRE(dnl
[m4_provide_if([_AM_COMPILER_EXEEXT],
[AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
+
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes. So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+ cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present. This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+Please tell bug-automake@gnu.org about your system, including the value
+of your $PATH and any error possibly output before this message. This
+can help us improve future automake versions.
+
+END
+ if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
+ echo 'Configuration will proceed anyway, since you have set the' >&2
+ echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
+ echo >&2
+ else
+ cat >&2 <<'END'
+Aborting the configuration process, to ensure you take notice of the issue.
+
+You can download and install GNU coreutils to get an 'rm' implementation
+that behaves properly: <http://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+ AC_MSG_ERROR([Your 'rm' program is bad, sorry.])
+ fi
+fi
+dnl The trailing newline in this macro's definition is deliberate, for
+dnl backward compatibility and to allow trailing 'dnl'-style comments
+dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841.
])
-dnl Hook into `_AC_COMPILER_EXEEXT' early to learn its expansion. Do not
+dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion. Do not
dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
dnl mangled by Autoconf and run in a shell conditional statement.
m4_define([_AC_COMPILER_EXEEXT],
m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
-
# When config.status generates a header, we must update the stamp-h file.
# This file resides in the same directory as the config header
# that is generated. The stamp files are numbered to have different names.
done
echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
-# Copyright (C) 2001, 2003, 2005, 2008, 2011 Free Software Foundation,
-# Inc.
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 1
-
# AM_PROG_INSTALL_SH
# ------------------
# Define $install_sh.
AC_DEFUN([AM_PROG_INSTALL_SH],
[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
-if test x"${install_sh}" != xset; then
+if test x"${install_sh+set}" != xset; then
case $am_aux_dir in
*\ * | *\ *)
install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
install_sh="\${SHELL} $am_aux_dir/install-sh"
esac
fi
-AC_SUBST(install_sh)])
+AC_SUBST([install_sh])])
-# Copyright (C) 2003, 2005 Free Software Foundation, Inc.
+# Copyright (C) 2003-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 2
-
# Check whether the underlying file-system supports filenames
# with a leading dot. For instance MS-DOS doesn't.
AC_DEFUN([AM_SET_LEADING_DOT],
# Check to see how 'make' treats includes. -*- Autoconf -*-
-# Copyright (C) 2001, 2002, 2003, 2005, 2009 Free Software Foundation, Inc.
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 4
-
# AM_MAKE_INCLUDE()
# -----------------
# Check to see how make treats includes.
_am_result=none
# First try GNU make style include.
echo "include confinc" > confmf
-# Ignore all kinds of additional output from `make'.
+# Ignore all kinds of additional output from 'make'.
case `$am_make -s -f confmf 2> /dev/null` in #(
*the\ am__doit\ target*)
am__include=include
rm -f confinc confmf
])
-# Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2008
-# Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 6
-
-# AM_PROG_CC_C_O
-# --------------
-# Like AC_PROG_CC_C_O, but changed for automake.
-AC_DEFUN([AM_PROG_CC_C_O],
-[AC_REQUIRE([AC_PROG_CC_C_O])dnl
-AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
-AC_REQUIRE_AUX_FILE([compile])dnl
-# FIXME: we rely on the cache variable name because
-# there is no other way.
-set dummy $CC
-am_cc=`echo $[2] | sed ['s/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/']`
-eval am_t=\$ac_cv_prog_cc_${am_cc}_c_o
-if test "$am_t" != yes; then
- # Losing compiler, so override with the script.
- # FIXME: It is wrong to rewrite CC.
- # But if we don't then we get into trouble of one sort or another.
- # A longer-term fix would be to have automake use am__CC in this case,
- # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
- CC="$am_aux_dir/compile $CC"
-fi
-dnl Make sure AC_PROG_CC is never called again, or it will override our
-dnl setting of CC.
-m4_define([AC_PROG_CC],
- [m4_fatal([AC_PROG_CC cannot be called after AM_PROG_CC_C_O])])
-])
-
# Fake the existence of programs that GNU maintainers use. -*- Autoconf -*-
-# Copyright (C) 1997, 1999, 2000, 2001, 2003, 2004, 2005, 2008
-# Free Software Foundation, Inc.
+# Copyright (C) 1997-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 6
-
# AM_MISSING_PROG(NAME, PROGRAM)
# ------------------------------
AC_DEFUN([AM_MISSING_PROG],
$1=${$1-"${am_missing_run}$2"}
AC_SUBST($1)])
-
# AM_MISSING_HAS_RUN
# ------------------
-# Define MISSING if not defined so far and test if it supports --run.
-# If it does, set am_missing_run to use it, otherwise, to nothing.
+# Define MISSING if not defined so far and test if it is modern enough.
+# If it is, set am_missing_run to use it, otherwise, to nothing.
AC_DEFUN([AM_MISSING_HAS_RUN],
[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
AC_REQUIRE_AUX_FILE([missing])dnl
esac
fi
# Use eval to expand $SHELL
-if eval "$MISSING --run true"; then
- am_missing_run="$MISSING --run "
+if eval "$MISSING --is-lightweight"; then
+ am_missing_run="$MISSING "
else
am_missing_run=
- AC_MSG_WARN([`missing' script is too old or missing])
+ AC_MSG_WARN(['missing' script is too old or missing])
fi
])
-# Copyright (C) 2003, 2004, 2005, 2006, 2011 Free Software Foundation,
-# Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# serial 1
-
-# AM_PROG_MKDIR_P
-# ---------------
-# Check for `mkdir -p'.
-AC_DEFUN([AM_PROG_MKDIR_P],
-[AC_PREREQ([2.60])dnl
-AC_REQUIRE([AC_PROG_MKDIR_P])dnl
-dnl Automake 1.8 to 1.9.6 used to define mkdir_p. We now use MKDIR_P,
-dnl while keeping a definition of mkdir_p for backward compatibility.
-dnl @MKDIR_P@ is magic: AC_OUTPUT adjusts its value for each Makefile.
-dnl However we cannot define mkdir_p as $(MKDIR_P) for the sake of
-dnl Makefile.ins that do not define MKDIR_P, so we do our own
-dnl adjustment using top_builddir (which is defined more often than
-dnl MKDIR_P).
-AC_SUBST([mkdir_p], ["$MKDIR_P"])dnl
-case $mkdir_p in
- [[\\/$]]* | ?:[[\\/]]*) ;;
- */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
-esac
-])
-
# Helper functions for option handling. -*- Autoconf -*-
-# Copyright (C) 2001, 2002, 2003, 2005, 2008, 2010 Free Software
-# Foundation, Inc.
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 5
-
# _AM_MANGLE_OPTION(NAME)
# -----------------------
AC_DEFUN([_AM_MANGLE_OPTION],
# --------------------
# Set option NAME. Presently that only means defining a flag for this option.
AC_DEFUN([_AM_SET_OPTION],
-[m4_define(_AM_MANGLE_OPTION([$1]), 1)])
+[m4_define(_AM_MANGLE_OPTION([$1]), [1])])
# _AM_SET_OPTIONS(OPTIONS)
# ------------------------
AC_DEFUN([_AM_IF_OPTION],
[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
-# Check to make sure that the build environment is sane. -*- Autoconf -*-
+# Copyright (C) 1999-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
-# Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005, 2008
-# Free Software Foundation, Inc.
+# _AM_PROG_CC_C_O
+# ---------------
+# Like AC_PROG_CC_C_O, but changed for automake. We rewrite AC_PROG_CC
+# to automatically call this.
+AC_DEFUN([_AM_PROG_CC_C_O],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([compile])dnl
+AC_LANG_PUSH([C])dnl
+AC_CACHE_CHECK(
+ [whether $CC understands -c and -o together],
+ [am_cv_prog_cc_c_o],
+ [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
+ # Make sure it works both with $CC and with simple cc.
+ # Following AC_PROG_CC_C_O, we do the test twice because some
+ # compilers refuse to overwrite an existing .o file with -o,
+ # though they will create one.
+ am_cv_prog_cc_c_o=yes
+ for am_i in 1 2; do
+ if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \
+ && test -f conftest2.$ac_objext; then
+ : OK
+ else
+ am_cv_prog_cc_c_o=no
+ break
+ fi
+ done
+ rm -f core conftest*
+ unset am_i])
+if test "$am_cv_prog_cc_c_o" != yes; then
+ # Losing compiler, so override with the script.
+ # FIXME: It is wrong to rewrite CC.
+ # But if we don't then we get into trouble of one sort or another.
+ # A longer-term fix would be to have automake use am__CC in this case,
+ # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+ CC="$am_aux_dir/compile $CC"
+fi
+AC_LANG_POP([C])])
+
+# For backward compatibility.
+AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
+
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 5
+# AM_RUN_LOG(COMMAND)
+# -------------------
+# Run COMMAND, save the exit status in ac_status, and log it.
+# (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
+AC_DEFUN([AM_RUN_LOG],
+[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
+ ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+ (exit $ac_status); }])
+
+# Check to make sure that the build environment is sane. -*- Autoconf -*-
+
+# Copyright (C) 1996-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
# AM_SANITY_CHECK
# ---------------
AC_DEFUN([AM_SANITY_CHECK],
[AC_MSG_CHECKING([whether build environment is sane])
-# Just in case
-sleep 1
-echo timestamp > conftest.file
# Reject unsafe characters in $srcdir or the absolute working directory
# name. Accept space and tab only in the latter.
am_lf='
esac
case $srcdir in
*[[\\\"\#\$\&\'\`$am_lf\ \ ]]*)
- AC_MSG_ERROR([unsafe srcdir value: `$srcdir']);;
+ AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);;
esac
-# Do `set' in a subshell so we don't clobber the current shell's
+# Do 'set' in a subshell so we don't clobber the current shell's
# arguments. Must try -L first in case configure is actually a
# symlink; some systems play weird games with the mod time of symlinks
# (eg FreeBSD returns the mod time of the symlink's containing
# directory).
if (
- set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
- if test "$[*]" = "X"; then
- # -L didn't work.
- set X `ls -t "$srcdir/configure" conftest.file`
- fi
- rm -f conftest.file
- if test "$[*]" != "X $srcdir/configure conftest.file" \
- && test "$[*]" != "X conftest.file $srcdir/configure"; then
-
- # If neither matched, then we have a broken ls. This can happen
- # if, for instance, CONFIG_SHELL is bash and it inherits a
- # broken ls alias from the environment. This has actually
- # happened. Such a system could not be considered "sane".
- AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken
-alias in your environment])
- fi
-
+ am_has_slept=no
+ for am_try in 1 2; do
+ echo "timestamp, slept: $am_has_slept" > conftest.file
+ set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+ if test "$[*]" = "X"; then
+ # -L didn't work.
+ set X `ls -t "$srcdir/configure" conftest.file`
+ fi
+ if test "$[*]" != "X $srcdir/configure conftest.file" \
+ && test "$[*]" != "X conftest.file $srcdir/configure"; then
+
+ # If neither matched, then we have a broken ls. This can happen
+ # if, for instance, CONFIG_SHELL is bash and it inherits a
+ # broken ls alias from the environment. This has actually
+ # happened. Such a system could not be considered "sane".
+ AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken
+ alias in your environment])
+ fi
+ if test "$[2]" = conftest.file || test $am_try -eq 2; then
+ break
+ fi
+ # Just in case.
+ sleep 1
+ am_has_slept=yes
+ done
test "$[2]" = conftest.file
)
then
AC_MSG_ERROR([newly created file is older than distributed files!
Check your system clock])
fi
-AC_MSG_RESULT(yes)])
+AC_MSG_RESULT([yes])
+# If we didn't sleep, we still need to ensure time stamps of config.status and
+# generated files are strictly newer.
+am_sleep_pid=
+if grep 'slept: no' conftest.file >/dev/null 2>&1; then
+ ( sleep 1 ) &
+ am_sleep_pid=$!
+fi
+AC_CONFIG_COMMANDS_PRE(
+ [AC_MSG_CHECKING([that generated files are newer than configure])
+ if test -n "$am_sleep_pid"; then
+ # Hide warnings about reused PIDs.
+ wait $am_sleep_pid 2>/dev/null
+ fi
+ AC_MSG_RESULT([done])])
+rm -f conftest.file
+])
-# Copyright (C) 2001, 2003, 2005, 2011 Free Software Foundation, Inc.
+# Copyright (C) 2009-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 1
+# AM_SILENT_RULES([DEFAULT])
+# --------------------------
+# Enable less verbose build rules; with the default set to DEFAULT
+# ("yes" being less verbose, "no" or empty being verbose).
+AC_DEFUN([AM_SILENT_RULES],
+[AC_ARG_ENABLE([silent-rules], [dnl
+AS_HELP_STRING(
+ [--enable-silent-rules],
+ [less verbose build output (undo: "make V=1")])
+AS_HELP_STRING(
+ [--disable-silent-rules],
+ [verbose build output (undo: "make V=0")])dnl
+])
+case $enable_silent_rules in @%:@ (((
+ yes) AM_DEFAULT_VERBOSITY=0;;
+ no) AM_DEFAULT_VERBOSITY=1;;
+ *) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
+esac
+dnl
+dnl A few 'make' implementations (e.g., NonStop OS and NextStep)
+dnl do not support nested variable expansions.
+dnl See automake bug#9928 and bug#10237.
+am_make=${MAKE-make}
+AC_CACHE_CHECK([whether $am_make supports nested variables],
+ [am_cv_make_support_nested_variables],
+ [if AS_ECHO([['TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+ @$(TRUE)
+.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then
+ am_cv_make_support_nested_variables=yes
+else
+ am_cv_make_support_nested_variables=no
+fi])
+if test $am_cv_make_support_nested_variables = yes; then
+ dnl Using '$V' instead of '$(V)' breaks IRIX make.
+ AM_V='$(V)'
+ AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+ AM_V=$AM_DEFAULT_VERBOSITY
+ AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AC_SUBST([AM_V])dnl
+AM_SUBST_NOTMAKE([AM_V])dnl
+AC_SUBST([AM_DEFAULT_V])dnl
+AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl
+AC_SUBST([AM_DEFAULT_VERBOSITY])dnl
+AM_BACKSLASH='\'
+AC_SUBST([AM_BACKSLASH])dnl
+_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
+])
+
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
# AM_PROG_INSTALL_STRIP
# ---------------------
-# One issue with vendor `install' (even GNU) is that you can't
+# One issue with vendor 'install' (even GNU) is that you can't
# specify the program used to strip binaries. This is especially
# annoying in cross-compiling environments, where the build's strip
# is unlikely to handle the host's binaries.
# Fortunately install-sh will honor a STRIPPROG variable, so we
-# always use install-sh in `make install-strip', and initialize
+# always use install-sh in "make install-strip", and initialize
# STRIPPROG with the value of the STRIP variable (set by the user).
AC_DEFUN([AM_PROG_INSTALL_STRIP],
[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
-# Installed binaries are usually stripped using `strip' when the user
-# run `make install-strip'. However `strip' might not be the right
+# Installed binaries are usually stripped using 'strip' when the user
+# run "make install-strip". However 'strip' might not be the right
# tool to use in cross-compilation environments, therefore Automake
-# will honor the `STRIP' environment variable to overrule this program.
-dnl Don't test for $cross_compiling = yes, because it might be `maybe'.
+# will honor the 'STRIP' environment variable to overrule this program.
+dnl Don't test for $cross_compiling = yes, because it might be 'maybe'.
if test "$cross_compiling" != no; then
AC_CHECK_TOOL([STRIP], [strip], :)
fi
INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
AC_SUBST([INSTALL_STRIP_PROGRAM])])
-# Copyright (C) 2006, 2008, 2010 Free Software Foundation, Inc.
+# Copyright (C) 2006-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 3
-
# _AM_SUBST_NOTMAKE(VARIABLE)
# ---------------------------
# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
# Check how to create a tarball. -*- Autoconf -*-
-# Copyright (C) 2004, 2005, 2012 Free Software Foundation, Inc.
+# Copyright (C) 2004-2014 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
-# serial 2
-
# _AM_PROG_TAR(FORMAT)
# --------------------
# Check how to create a tarball in format FORMAT.
-# FORMAT should be one of `v7', `ustar', or `pax'.
+# FORMAT should be one of 'v7', 'ustar', or 'pax'.
#
# Substitute a variable $(am__tar) that is a command
# writing to stdout a FORMAT-tarball containing the directory
# Substitute a variable $(am__untar) that extract such
# a tarball read from stdin.
# $(am__untar) < result.tar
+#
AC_DEFUN([_AM_PROG_TAR],
[# Always define AMTAR for backward compatibility. Yes, it's still used
# in the wild :-( We should find a proper way to deprecate it ...
AC_SUBST([AMTAR], ['$${TAR-tar}'])
-m4_if([$1], [v7],
- [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
- [m4_case([$1], [ustar],, [pax],,
- [m4_fatal([Unknown tar format])])
-AC_MSG_CHECKING([how to create a $1 tar archive])
-# Loop over all known methods to create a tar archive until one works.
+
+# We'll loop over all known methods to create a tar archive until one works.
_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
-_am_tools=${am_cv_prog_tar_$1-$_am_tools}
-# Do not fold the above two line into one, because Tru64 sh and
-# Solaris sh will not grok spaces in the rhs of `-'.
-for _am_tool in $_am_tools
-do
- case $_am_tool in
- gnutar)
- for _am_tar in tar gnutar gtar;
- do
- AM_RUN_LOG([$_am_tar --version]) && break
- done
- am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
- am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
- am__untar="$_am_tar -xf -"
- ;;
- plaintar)
- # Must skip GNU tar: if it does not support --format= it doesn't create
- # ustar tarball either.
- (tar --version) >/dev/null 2>&1 && continue
- am__tar='tar chf - "$$tardir"'
- am__tar_='tar chf - "$tardir"'
- am__untar='tar xf -'
- ;;
- pax)
- am__tar='pax -L -x $1 -w "$$tardir"'
- am__tar_='pax -L -x $1 -w "$tardir"'
- am__untar='pax -r'
- ;;
- cpio)
- am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
- am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
- am__untar='cpio -i -H $1 -d'
- ;;
- none)
- am__tar=false
- am__tar_=false
- am__untar=false
- ;;
- esac
- # If the value was cached, stop now. We just wanted to have am__tar
- # and am__untar set.
- test -n "${am_cv_prog_tar_$1}" && break
+m4_if([$1], [v7],
+ [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
+
+ [m4_case([$1],
+ [ustar],
+ [# The POSIX 1988 'ustar' format is defined with fixed-size fields.
+ # There is notably a 21 bits limit for the UID and the GID. In fact,
+ # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343
+ # and bug#13588).
+ am_max_uid=2097151 # 2^21 - 1
+ am_max_gid=$am_max_uid
+ # The $UID and $GID variables are not portable, so we need to resort
+ # to the POSIX-mandated id(1) utility. Errors in the 'id' calls
+ # below are definitely unexpected, so allow the users to see them
+ # (that is, avoid stderr redirection).
+ am_uid=`id -u || echo unknown`
+ am_gid=`id -g || echo unknown`
+ AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format])
+ if test $am_uid -le $am_max_uid; then
+ AC_MSG_RESULT([yes])
+ else
+ AC_MSG_RESULT([no])
+ _am_tools=none
+ fi
+ AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format])
+ if test $am_gid -le $am_max_gid; then
+ AC_MSG_RESULT([yes])
+ else
+ AC_MSG_RESULT([no])
+ _am_tools=none
+ fi],
+
+ [pax],
+ [],
+
+ [m4_fatal([Unknown tar format])])
+
+ AC_MSG_CHECKING([how to create a $1 tar archive])
+
+ # Go ahead even if we have the value already cached. We do so because we
+ # need to set the values for the 'am__tar' and 'am__untar' variables.
+ _am_tools=${am_cv_prog_tar_$1-$_am_tools}
+
+ for _am_tool in $_am_tools; do
+ case $_am_tool in
+ gnutar)
+ for _am_tar in tar gnutar gtar; do
+ AM_RUN_LOG([$_am_tar --version]) && break
+ done
+ am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
+ am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
+ am__untar="$_am_tar -xf -"
+ ;;
+ plaintar)
+ # Must skip GNU tar: if it does not support --format= it doesn't create
+ # ustar tarball either.
+ (tar --version) >/dev/null 2>&1 && continue
+ am__tar='tar chf - "$$tardir"'
+ am__tar_='tar chf - "$tardir"'
+ am__untar='tar xf -'
+ ;;
+ pax)
+ am__tar='pax -L -x $1 -w "$$tardir"'
+ am__tar_='pax -L -x $1 -w "$tardir"'
+ am__untar='pax -r'
+ ;;
+ cpio)
+ am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
+ am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
+ am__untar='cpio -i -H $1 -d'
+ ;;
+ none)
+ am__tar=false
+ am__tar_=false
+ am__untar=false
+ ;;
+ esac
- # tar/untar a dummy directory, and stop if the command works
- rm -rf conftest.dir
- mkdir conftest.dir
- echo GrepMe > conftest.dir/file
- AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
+ # If the value was cached, stop now. We just wanted to have am__tar
+ # and am__untar set.
+ test -n "${am_cv_prog_tar_$1}" && break
+
+ # tar/untar a dummy directory, and stop if the command works.
+ rm -rf conftest.dir
+ mkdir conftest.dir
+ echo GrepMe > conftest.dir/file
+ AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
+ rm -rf conftest.dir
+ if test -s conftest.tar; then
+ AM_RUN_LOG([$am__untar <conftest.tar])
+ AM_RUN_LOG([cat conftest.dir/file])
+ grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
+ fi
+ done
rm -rf conftest.dir
- if test -s conftest.tar; then
- AM_RUN_LOG([$am__untar <conftest.tar])
- grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
- fi
-done
-rm -rf conftest.dir
-AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
-AC_MSG_RESULT([$am_cv_prog_tar_$1])])
+ AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
+ AC_MSG_RESULT([$am_cv_prog_tar_$1])])
+
AC_SUBST([am__tar])
AC_SUBST([am__untar])
]) # _AM_PROG_TAR
-m4_include([Tools/config/ac_compare_version.m4])
m4_include([Tools/config/ac_compile_warnings.m4])
m4_include([Tools/config/ac_define_dir.m4])
m4_include([Tools/config/ax_boost_base.m4])
m4_include([Tools/config/ax_compare_version.m4])
+m4_include([Tools/config/ax_cxx_compile_stdcxx_11.m4])
m4_include([Tools/config/ax_path_generic.m4])
--- /dev/null
+platform:
+- x86
+- x64
+
+environment:
+ matrix:
+ - SWIGLANG: csharp
+ VSVER: 14
+ - SWIGLANG: csharp
+ VSVER: 12
+ - SWIGLANG: java
+ VSVER: 12
+ - SWIGLANG: python
+ VSVER: 12
+ VER: 27
+ - SWIGLANG: python
+ VSVER: 12
+ VER: 35
+ PY3: 1
+
+install:
+- date /T & time /T
+- set PATH=C:\cygwin\bin;%PATH%
+- set CYGWIN=nodosfilewarning
+- git clone -q --depth=1 --single-branch --branch cccl-1.0 git://github.com/swig/cccl.git C:\cccl-1.0
+- bash -c "cp C:/cccl-1.0/cccl /usr/bin"
+- ps: >-
+ If ($env:Platform -Match "x86") {
+ $env:PCRE_PLATFORM="Win32"
+ $env:JAVA_HOME="C:/Program Files (x86)/Java/jdk1.8.0"
+ $env:VCVARS_PLATFORM="x86"
+ $env:LANG_PLATFORM=""
+ } Else {
+ $env:PCRE_PLATFORM="x64"
+ $env:JAVA_HOME="C:/Program Files/Java/jdk1.8.0"
+ $env:VCVARS_PLATFORM="amd64"
+ $env:LANG_PLATFORM="-x64"
+ }
+- ps: $env:VSCOMNTOOLS=(Get-Content ("env:VS" + "$env:VSVER" + "0COMNTOOLS"))
+- echo "Using Visual Studio %VSVER%.0 at %VSCOMNTOOLS%"
+- call "%VSCOMNTOOLS%\..\..\VC\vcvarsall.bat" %VCVARS_PLATFORM%
+- Tools\nuget-install.cmd pcre -Verbosity detailed -Version 8.33.0.1 -OutputDirectory C:\pcre
+- set PCRE_ROOT=C:/pcre/pcre.8.33.0.1/build/native
+- set PATH=C:\Python%VER%%LANG_PLATFORM%;%PATH%
+- python -V
+- bash -c "which python"
+- bash -c "python -V"
+- bash -c "which cl.exe"
+- bash -c "cl.exe /? 2>&1 | head -n 2"
+- bash -c "which csc.exe"
+- bash -c "csc.exe /? | head -n 2"
+- bash -c "which cccl"
+- bash -c "cccl --version"
+- make --version
+- uname -a
+
+build_script:
+- set CCCL_OPTIONS=--cccl-muffle /W3
+- set CHECK_OPTIONS=CSHARPOPTIONS=-platform:%Platform%
+ # Open dummy file descriptor to fix error on cygwin: ./configure: line 560: 0: Bad file descriptor
+- bash -c "exec 0</dev/null && ./autogen.sh && time ./configure --disable-dependency-tracking --disable-ccache CC=cccl CXX=cccl CFLAGS='-O2' CXXFLAGS='-O2' LDFLAGS='--cccl-link /LTCG' PCRE_CFLAGS='-I%PCRE_ROOT%/include -DPCRE_STATIC' PCRE_LIBS='-L%PCRE_ROOT%/lib/v110/%PCRE_PLATFORM%/Release/static/utf8 -lpcre8' --without-perl5 --without-go --with-boost=C:/Libraries/boost || cat config.log"
+- bash -c "time make -s"
+
+test_script:
+- set CCCL_OPTIONS=--cccl-muffle /W3 /EHsc
+# (Warning below is fixed in newer versions of Python (2.7.9)) '_hypot' : recursive on all control paths, function will cause runtime stack overflow
+- ps: >-
+ If ("$env:SWIGLANG$env:VER" -Match "python27") {
+ $env:CCCL_OPTIONS="$env:CCCL_OPTIONS /wd4717"
+ }
+- .\swig.exe -version
+- bash -c "file ./swig.exe"
+- bash -c "time make -k check-%SWIGLANG%-version"
+- bash -c "time make -k check-%SWIGLANG%-examples %CHECK_OPTIONS%"
+- bash -c "time make -k check-%SWIGLANG%-test-suite %CHECK_OPTIONS%"
+
+# Do not build on tags (GitHub only)
+skip_tags: true
#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.68 for swig 2.0.12.
+# Generated by GNU Autoconf 2.69 for swig 3.0.10.
#
# Report bugs to <http://www.swig.org>.
#
#
-# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
-# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
-# Foundation, Inc.
+# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
#
#
# This configure script is free software; the Free Software Foundation
# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+# Use a proper internal environment variable to ensure we don't fall
+ # into an infinite loop, continuously re-executing ourselves.
+ if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
+ _as_can_reexec=no; export _as_can_reexec;
+ # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+ *v*x* | *x*v* ) as_opts=-vx ;;
+ *v* ) as_opts=-v ;;
+ *x* ) as_opts=-x ;;
+ * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+as_fn_exit 255
+ fi
+ # We don't want this to propagate to other subprocesses.
+ { _as_can_reexec=; unset _as_can_reexec;}
if test "x$CONFIG_SHELL" = x; then
as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
emulate sh
else
exitcode=1; echo positional parameters were not saved.
fi
-test x\$exitcode = x0 || exit 1"
+test x\$exitcode = x0 || exit 1
+test -x / || exit 1"
as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
if test "x$CONFIG_SHELL" != x; then :
- # We cannot yet assume a decent shell, so we have to provide a
- # neutralization value for shells without unset; and this also
- # works around shells that cannot unset nonexistent variables.
- # Preserve -v and -x to the replacement shell.
- BASH_ENV=/dev/null
- ENV=/dev/null
- (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
- export CONFIG_SHELL
- case $- in # ((((
- *v*x* | *x*v* ) as_opts=-vx ;;
- *v* ) as_opts=-v ;;
- *x* ) as_opts=-x ;;
- * ) as_opts= ;;
- esac
- exec "$CONFIG_SHELL" $as_opts "$as_myself" ${1+"$@"}
+ export CONFIG_SHELL
+ # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+ *v*x* | *x*v* ) as_opts=-vx ;;
+ *v* ) as_opts=-v ;;
+ *x* ) as_opts=-x ;;
+ * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
fi
if test x$as_have_required = xno; then :
} # as_fn_mkdir_p
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+ test -f "$1" && test -x "$1"
+} # as_fn_executable_p
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
chmod +x "$as_me.lineno" ||
{ $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+ # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+ # already done that, so ensure we don't try to do so again and fall
+ # in an infinite loop. This has already happened in practice.
+ _as_can_reexec=no; export _as_can_reexec
# Don't try to exec as it changes $[0], causing all sort of problems
# (the dirname of $[0] is not the place where we might find the
# original and so on. Autoconf is especially sensitive to this).
# ... but there are two gotchas:
# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
- # In both cases, we have to default to `cp -p'.
+ # In both cases, we have to default to `cp -pR'.
ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
- as_ln_s='cp -p'
+ as_ln_s='cp -pR'
elif ln conf$$.file conf$$ 2>/dev/null; then
as_ln_s=ln
else
- as_ln_s='cp -p'
+ as_ln_s='cp -pR'
fi
else
- as_ln_s='cp -p'
+ as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null
as_mkdir_p=false
fi
-if test -x / >/dev/null 2>&1; then
- as_test_x='test -x'
-else
- if ls -dL / >/dev/null 2>&1; then
- as_ls_L_option=L
- else
- as_ls_L_option=
- fi
- as_test_x='
- eval sh -c '\''
- if test -d "$1"; then
- test -d "$1/.";
- else
- case $1 in #(
- -*)set "./$1";;
- esac;
- case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
- ???[sx]*):;;*)false;;esac;fi
- '\'' sh
- '
-fi
-as_executable_p=$as_test_x
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
# Identity of this package.
PACKAGE_NAME='swig'
PACKAGE_TARNAME='swig'
-PACKAGE_VERSION='2.0.12'
-PACKAGE_STRING='swig 2.0.12'
+PACKAGE_VERSION='3.0.10'
+PACKAGE_STRING='swig 3.0.10'
PACKAGE_BUGREPORT='http://www.swig.org'
PACKAGE_URL=''
ac_unique_file="Source/Swig/swig.h"
+enable_option_checking=no
# Factoring default headers for most tests.
ac_includes_default="\
#include <stdio.h>
# include <unistd.h>
#endif"
-enable_option_checking=no
ac_subst_vars='am__EXEEXT_FALSE
am__EXEEXT_TRUE
LTLIBOBJS
LIBOBJS
+SWIG_LIB_SET
+SWIG_LIB_PREINST
SWIG_LIB
-swig_lib
+SWIG_LIB_INSTALL
ac_aux_dir
EXTRA_CLEAN
ROOT_DIR
SKIP_GCJ
SKIP_D
SKIP_GO
+SKIP_SCILAB
SKIP_UFFI
SKIP_CFFI
SKIP_R
SKIP_RUBY
SKIP_MZSCHEME
SKIP_GUILE
+SKIP_JAVASCRIPT
SKIP_JAVA
SKIP_PYTHON3
SKIP_PYTHON
D2COMPILER
D1COMPILER
GOVERSIONOPTION
+GCCGOOPT
GOOPT
+GO15
+GO13
+GO12
GO1
GOC
GOGCC
+GCCGO
GO
RBIN
CLISPBIN
CSHARPCFLAGS
CSHARPLIBRARYPREFIX
CSHARPDYNAMICLINKING
-CSHARPCYGPATH_W
-CSHARPPATHSEPARATOR
+CSHARPCONVERTPATH
CSHARPCILINTERPRETER_FLAGS
CSHARPCILINTERPRETER
CSHARPCOMPILER
PIKEINCLUDE
PIKECONFIG
PIKE
-OCAMLINC
-OCAMLVER
-OCAMLLOC
+CAMLP4
OCAMLMKTOP
-OCAMLBIN
OCAMLC
OCAMLFIND
OCAMLDLGEN
ANDROID
GCJH
GCJ
+JSV8ENABLED
+JSCENABLED
+JSV8DYNAMICLINKING
+JSV8INC
+JSCOREVERSION
+JSCOREDYNAMICLINKING
+JSCOREINC
+JSINTERPRETERLINKFLAGS
+JSINTERPRETERCXX
+NODEGYP
+NODEJS
JAVACFLAGS
+JAVAFLAGS
JAVACXXSHARED
JAVALDSHARED
JAVASO
JAVAINC
JAVAC
JAVA
+SCILABOPT
+SCILABINCLUDE
+SCILAB
OCTAVE_LDFLAGS
OCTAVE_CXXFLAGS
OCTAVE_CPPFLAGS
PERL5DYNAMICLINKING
PERL5EXT
PERL
+PEP8
PYTHON3DYNAMICLINKING
PY3LINK
PY3LIB
TCLDYNAMICLINKING
TCLLIB
TCLINCLUDE
-XLIBSW
-XINCLUDES
-XMKMF
+PKGCONFIG
LIBC
LIBCRYPT
LIBM
TCL_SO
PYTHON_SO
LINKFORSHARED
-PLATFLAGS
+HAVE_CXX11_COMPILER
+PLATCXXFLAGS
+PLATCFLAGS
RPATH
TRYLINKINGWITHCXX
CXXSHARED
SO
BOOST_LDFLAGS
BOOST_CPPFLAGS
-YODL2HTML
-YODL2MAN
-AR
-RANLIB
YFLAGS
YACC
ENABLE_CCACHE
LDFLAGS
CFLAGS
CC
+AM_BACKSLASH
+AM_DEFAULT_VERBOSITY
+AM_DEFAULT_V
+AM_V
am__untar
am__tar
AMTAR
docdir
oldincludedir
includedir
+runstatedir
localstatedir
sharedstatedir
sysconfdir
ac_subst_files=''
ac_user_opts='
enable_option_checking
+enable_silent_rules
enable_dependency_tracking
with_maximum_compile_warnings
with_popen
enable_ccache
with_boost
with_boost_libdir
+enable_cpp11_testing
with_libm
with_libc
-with_x
with_alllang
with_tclconfig
with_tcl
with_python3
with_perl5
with_octave
+with_scilab
+with_scilab_inc
with_java
with_javac
with_javaincl
+with_javascript
+with_jscoreinc
+with_jscorelib
+with_jsv8inc
+with_jsv8lib
with_gcj
with_gcjh
with_android
with_ocamldlgen
with_ocamlfind
with_ocamlmktop
+with_camlp4
with_pike
with_pike_config
with_pikeincl
PCRE_CFLAGS
PCRE_LIBS
YACC
-YFLAGS
-XMKMF'
+YFLAGS'
ac_subdirs_all='CCache'
# Initialize some variables set by options.
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
+runstatedir='${localstatedir}/run'
includedir='${prefix}/include'
oldincludedir='/usr/include'
docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
| -silent | --silent | --silen | --sile | --sil)
silent=yes ;;
+ -runstatedir | --runstatedir | --runstatedi | --runstated \
+ | --runstate | --runstat | --runsta | --runst | --runs \
+ | --run | --ru | --r)
+ ac_prev=runstatedir ;;
+ -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
+ | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
+ | --run=* | --ru=* | --r=*)
+ runstatedir=$ac_optarg ;;
+
-sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
ac_prev=sbindir ;;
-sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
datadir sysconfdir sharedstatedir localstatedir includedir \
oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
- libdir localedir mandir
+ libdir localedir mandir runstatedir
do
eval ac_val=\$$ac_var
# Remove trailing slashes.
if test "x$host_alias" != x; then
if test "x$build_alias" = x; then
cross_compiling=maybe
- $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host.
- If a cross compiler is detected then cross compile mode will be used" >&2
elif test "x$build_alias" != "x$host_alias"; then
cross_compiling=yes
fi
# Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF
-\`configure' configures swig 2.0.12 to adapt to many kinds of systems.
+\`configure' configures swig 3.0.10 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]...
--sysconfdir=DIR read-only single-machine data [PREFIX/etc]
--sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
--localstatedir=DIR modifiable single-machine data [PREFIX/var]
+ --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run]
--libdir=DIR object code libraries [EPREFIX/lib]
--includedir=DIR C header files [PREFIX/include]
--oldincludedir=DIR C header files for non-gcc [/usr/include]
--program-suffix=SUFFIX append SUFFIX to installed program names
--program-transform-name=PROGRAM run sed PROGRAM on installed program names
-X features:
- --x-includes=DIR X include files are in DIR
- --x-libraries=DIR X library files are in DIR
-
System types:
--build=BUILD configure for building on BUILD [guessed]
--host=HOST cross-compile to build programs to run on HOST [BUILD]
if test -n "$ac_init_help"; then
case $ac_init_help in
- short | recursive ) echo "Configuration of swig 2.0.12:";;
+ short | recursive ) echo "Configuration of swig 3.0.10:";;
esac
cat <<\_ACEOF
--disable-option-checking ignore unrecognized --enable/--with options
--disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
--enable-FEATURE[=ARG] include FEATURE [ARG=yes]
- --disable-dependency-tracking speeds up one-time build
- --enable-dependency-tracking do not reject slow dependency extractors
+ --enable-silent-rules less verbose build output (undo: "make V=1")
+ --disable-silent-rules verbose build output (undo: "make V=0")
+ --enable-dependency-tracking
+ do not reject slow dependency extractors
+ --disable-dependency-tracking
+ speeds up one-time build
--disable-ccache disable building and installation of ccache-swig
executable (default enabled)
+ --enable-cpp11-testing enable C++11 testing if supported by compiler
+ (default disabled)
Optional Packages:
--with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
libraries are located.
--with-libm=STRING math library
--with-libc=STRING C library
- --with-x use the X Window System
--without-alllang Disable all languages
--without-tcl Disable Tcl
--with-tclconfig=path Set location of tclConfig.sh
--with-perl5=path Set location of Perl5 executable
--without-octave Disable Octave
--with-octave=path Set location of Octave executable
+ --without-scilab Disable Scilab
+ --with-scilab=path Set location of Scilab executable
+ --with-scilab-inc=path Set location of Scilab include directory
--without-java Disable Java
--with-java=path Set location of java executable
--with-javac=path Set location of javac executable
--with-javaincl=path Set location of Java include directory
+ --without-javascript Disable Javascript
+ --with-jscinc=path Set location of Javascript include directory
+ --with-jsclib=path Set location of the JavaScriptCore/Webkit library directory
+ --with-jsv8inc=path Set location of Javascript v8 include directory
+ --with-jsv8lib=path Set location of V8 Javascript library directory
--without-gcj Disable GCJ
--with-gcj=path Set location of gcj executable
--with-gcjh=path Set location of gcjh executable
--without-android Disable Android
--with-android=path Set location of android executable
- --with-adb=path Set location of adb executable - Android Debug Bridge
- --with-ant=path Set location of ant executable for Android
- --with-ndk-build=path Set location of Android ndk-build executable
+ --with-adb=path Set location of adb executable - Android Debug Bridge
+ --with-ant=path Set location of ant executable for Android
+ --with-ndk-build=path Set location of Android ndk-build executable
--without-guile Disable Guile
- --with-guile-config=path
+ --with-guile-config=path
Set location of guile-config
--with-guile=path Set location of Guile executable
--with-guile-cflags=cflags Set cflags required to compile against Guile
--without-php Disable PHP
--with-php=path Set location of PHP executable
--without-ocaml Disable OCaml
- --with-ocaml=path Set location of ocaml executable
--with-ocamlc=path Set location of ocamlc executable
--with-ocamldlgen=path Set location of ocamldlgen
--with-ocamlfind=path Set location of ocamlfind
--with-ocamlmktop=path Set location of ocamlmktop executable
+ --with-camlp4=path Set location of camlp4 executable
--without-pike Disable Pike
--with-pike=path Set location of Pike executable
--with-pike-config=path Set location of pike-config script
YFLAGS The list of arguments that will be passed by default to $YACC.
This script will default YFLAGS to the empty string to avoid a
default value of `-d' given by some make applications.
- XMKMF Path to xmkmf, Makefile generator for X Window System
Use these variables to override the choices made by `configure' or to help
it to find libraries and programs with nonstandard names/locations.
test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
cat <<\_ACEOF
-swig configure 2.0.12
-generated by GNU Autoconf 2.68
+swig configure 3.0.10
+generated by GNU Autoconf 2.69
-Copyright (C) 2010 Free Software Foundation, Inc.
+Copyright (C) 2012 Free Software Foundation, Inc.
This configure script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it.
_ACEOF
} # ac_fn_c_try_run
-# ac_fn_cxx_check_type LINENO TYPE VAR INCLUDES
-# ---------------------------------------------
-# Tests whether TYPE exists after having included INCLUDES, setting cache
-# variable VAR accordingly.
-ac_fn_cxx_check_type ()
-{
- as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
-$as_echo_n "checking for $2... " >&6; }
-if eval \${$3+:} false; then :
- $as_echo_n "(cached) " >&6
-else
- eval "$3=no"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h. */
-$4
-int
-main ()
-{
-if (sizeof ($2))
- return 0;
- ;
- return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"; then :
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h. */
-$4
-int
-main ()
-{
-if (sizeof (($2)))
- return 0;
- ;
- return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"; then :
-
-else
- eval "$3=yes"
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-eval ac_res=\$$3
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-$as_echo "$ac_res" >&6; }
- eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-
-} # ac_fn_cxx_check_type
-
-# ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
-# ---------------------------------------------------------
-# Tests whether HEADER exists and can be compiled using the include files in
-# INCLUDES, setting the cache variable VAR accordingly.
-ac_fn_cxx_check_header_compile ()
-{
- as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
-$as_echo_n "checking for $2... " >&6; }
-if eval \${$3+:} false; then :
- $as_echo_n "(cached) " >&6
-else
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h. */
-$4
-#include <$2>
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"; then :
- eval "$3=yes"
-else
- eval "$3=no"
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-eval ac_res=\$$3
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-$as_echo "$ac_res" >&6; }
- eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-
-} # ac_fn_cxx_check_header_compile
-
# ac_fn_c_try_link LINENO
# -----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded.
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
- $as_test_x conftest$ac_exeext
+ test -x conftest$ac_exeext
}; then :
ac_retval=0
else
} # ac_fn_c_check_func
+# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists and can be compiled using the include files in
+# INCLUDES, setting the cache variable VAR accordingly.
+ac_fn_c_check_header_compile ()
+{
+ as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+ eval "$3=yes"
+else
+ eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+ eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_compile
+
# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists, giving a warning if it cannot be compiled using
main ()
{
static int test_array [1 - 2 * !(($2) >= 0)];
-test_array [0] = 0
+test_array [0] = 0;
+return test_array [0];
;
return 0;
main ()
{
static int test_array [1 - 2 * !(($2) <= $ac_mid)];
-test_array [0] = 0
+test_array [0] = 0;
+return test_array [0];
;
return 0;
main ()
{
static int test_array [1 - 2 * !(($2) < 0)];
-test_array [0] = 0
+test_array [0] = 0;
+return test_array [0];
;
return 0;
main ()
{
static int test_array [1 - 2 * !(($2) >= $ac_mid)];
-test_array [0] = 0
+test_array [0] = 0;
+return test_array [0];
;
return 0;
main ()
{
static int test_array [1 - 2 * !(($2) <= $ac_mid)];
-test_array [0] = 0
+test_array [0] = 0;
+return test_array [0];
;
return 0;
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
-It was created by swig $as_me 2.0.12, which was
-generated by GNU Autoconf 2.68. Invocation command line was
+It was created by swig $as_me 3.0.10, which was
+generated by GNU Autoconf 2.69. Invocation command line was
$ $0 $@
case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
-am__api_version='1.11'
+am__api_version='1.15'
# Find a good install program. We prefer a C program (faster),
# so one script is as good as another. But avoid the broken or
# by default.
for ac_prog in ginstall scoinst install; do
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
if test $ac_prog = install &&
grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
# AIX install. It has an incompatible calling convention.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
$as_echo_n "checking whether build environment is sane... " >&6; }
-# Just in case
-sleep 1
-echo timestamp > conftest.file
# Reject unsafe characters in $srcdir or the absolute working directory
# name. Accept space and tab only in the latter.
am_lf='
esac
case $srcdir in
*[\\\"\#\$\&\'\`$am_lf\ \ ]*)
- as_fn_error $? "unsafe srcdir value: \`$srcdir'" "$LINENO" 5;;
+ as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
esac
-# Do `set' in a subshell so we don't clobber the current shell's
+# Do 'set' in a subshell so we don't clobber the current shell's
# arguments. Must try -L first in case configure is actually a
# symlink; some systems play weird games with the mod time of symlinks
# (eg FreeBSD returns the mod time of the symlink's containing
# directory).
if (
- set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
- if test "$*" = "X"; then
- # -L didn't work.
- set X `ls -t "$srcdir/configure" conftest.file`
- fi
- rm -f conftest.file
- if test "$*" != "X $srcdir/configure conftest.file" \
- && test "$*" != "X conftest.file $srcdir/configure"; then
-
- # If neither matched, then we have a broken ls. This can happen
- # if, for instance, CONFIG_SHELL is bash and it inherits a
- # broken ls alias from the environment. This has actually
- # happened. Such a system could not be considered "sane".
- as_fn_error $? "ls -t appears to fail. Make sure there is not a broken
-alias in your environment" "$LINENO" 5
- fi
-
+ am_has_slept=no
+ for am_try in 1 2; do
+ echo "timestamp, slept: $am_has_slept" > conftest.file
+ set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+ if test "$*" = "X"; then
+ # -L didn't work.
+ set X `ls -t "$srcdir/configure" conftest.file`
+ fi
+ if test "$*" != "X $srcdir/configure conftest.file" \
+ && test "$*" != "X conftest.file $srcdir/configure"; then
+
+ # If neither matched, then we have a broken ls. This can happen
+ # if, for instance, CONFIG_SHELL is bash and it inherits a
+ # broken ls alias from the environment. This has actually
+ # happened. Such a system could not be considered "sane".
+ as_fn_error $? "ls -t appears to fail. Make sure there is not a broken
+ alias in your environment" "$LINENO" 5
+ fi
+ if test "$2" = conftest.file || test $am_try -eq 2; then
+ break
+ fi
+ # Just in case.
+ sleep 1
+ am_has_slept=yes
+ done
test "$2" = conftest.file
)
then
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
+# If we didn't sleep, we still need to ensure time stamps of config.status and
+# generated files are strictly newer.
+am_sleep_pid=
+if grep 'slept: no' conftest.file >/dev/null 2>&1; then
+ ( sleep 1 ) &
+ am_sleep_pid=$!
+fi
+
+rm -f conftest.file
+
test "$program_prefix" != NONE &&
program_transform_name="s&^&$program_prefix&;$program_transform_name"
# Use a double $ so make ignores it.
ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
-# expand $ac_aux_dir to an absolute path
-am_aux_dir=`cd $ac_aux_dir && pwd`
+# Expand $ac_aux_dir to an absolute path.
+am_aux_dir=`cd "$ac_aux_dir" && pwd`
if test x"${MISSING+set}" != xset; then
case $am_aux_dir in
esac
fi
# Use eval to expand $SHELL
-if eval "$MISSING --run true"; then
- am_missing_run="$MISSING --run "
+if eval "$MISSING --is-lightweight"; then
+ am_missing_run="$MISSING "
else
am_missing_run=
- { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`missing' script is too old or missing" >&5
-$as_echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
+$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
fi
-if test x"${install_sh}" != xset; then
+if test x"${install_sh+set}" != xset; then
case $am_aux_dir in
*\ * | *\ *)
install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
esac
fi
-# Installed binaries are usually stripped using `strip' when the user
-# run `make install-strip'. However `strip' might not be the right
+# Installed binaries are usually stripped using 'strip' when the user
+# run "make install-strip". However 'strip' might not be the right
# tool to use in cross-compilation environments, therefore Automake
-# will honor the `STRIP' environment variable to overrule this program.
+# will honor the 'STRIP' environment variable to overrule this program.
if test "$cross_compiling" != no; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_STRIP="${ac_tool_prefix}strip"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_STRIP="strip"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
test -z "$as_dir" && as_dir=.
for ac_prog in mkdir gmkdir; do
for ac_exec_ext in '' $ac_executable_extensions; do
- { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; } || continue
+ as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
'mkdir (GNU coreutils) '* | \
'mkdir (coreutils) '* | \
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
$as_echo "$MKDIR_P" >&6; }
-mkdir_p="$MKDIR_P"
-case $mkdir_p in
- [\\/$]* | ?:[\\/]*) ;;
- */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
-esac
-
for ac_prog in gawk mawk nawk awk
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_AWK="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
rmdir .tst 2>/dev/null
+# Check whether --enable-silent-rules was given.
+if test "${enable_silent_rules+set}" = set; then :
+ enableval=$enable_silent_rules;
+fi
+
+case $enable_silent_rules in # (((
+ yes) AM_DEFAULT_VERBOSITY=0;;
+ no) AM_DEFAULT_VERBOSITY=1;;
+ *) AM_DEFAULT_VERBOSITY=1;;
+esac
+am_make=${MAKE-make}
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
+$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
+if ${am_cv_make_support_nested_variables+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if $as_echo 'TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+ @$(TRUE)
+.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
+ am_cv_make_support_nested_variables=yes
+else
+ am_cv_make_support_nested_variables=no
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
+$as_echo "$am_cv_make_support_nested_variables" >&6; }
+if test $am_cv_make_support_nested_variables = yes; then
+ AM_V='$(V)'
+ AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+ AM_V=$AM_DEFAULT_VERBOSITY
+ AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AM_BACKSLASH='\'
+
if test "`cd $srcdir && pwd`" != "`pwd`"; then
# Use -I$(srcdir) only when $(srcdir) != ., so that make's output
# is not polluted with repeated "-I."
# Define the identity of the package.
PACKAGE='swig'
- VERSION='2.0.12'
+ VERSION='3.0.10'
cat >>confdefs.h <<_ACEOF
MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
-# We need awk for the "check" target. The system "awk" is bad on
-# some platforms.
+# For better backward compatibility. To be removed once Automake 1.9.x
+# dies out for good. For more background, see:
+# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+mkdir_p='$(MKDIR_P)'
+
+# We need awk for the "check" target (and possibly the TAP driver). The
+# system "awk" is bad on some platforms.
# Always define AMTAR for backward compatibility. Yes, it's still used
# in the wild :-( We should find a proper way to deprecate it ...
AMTAR='$${TAR-tar}'
+
+# We'll loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar pax cpio none'
+
am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes. So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+ cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present. This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+Please tell bug-automake@gnu.org about your system, including the value
+of your $PATH and any error possibly output before this message. This
+can help us improve future automake versions.
+
+END
+ if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
+ echo 'Configuration will proceed anyway, since you have set the' >&2
+ echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
+ echo >&2
+ else
+ cat >&2 <<'END'
+Aborting the configuration process, to ensure you take notice of the issue.
+
+You can download and install GNU coreutils to get an 'rm' implementation
+that behaves properly: <http://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+ as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
+ fi
+fi
+
+
ac_ext=c
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}gcc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="gcc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}cc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
ac_prog_rejected=yes
continue
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
/* end confdefs.h. */
#include <stdarg.h>
#include <stdio.h>
-#include <sys/types.h>
-#include <sys/stat.h>
+struct stat;
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
struct buf { int x; };
FILE * (*rcsopen) (struct buf *, struct stat *, int);
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
+$as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
+if ${am_cv_prog_cc_c_o+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+ # Make sure it works both with $CC and with simple cc.
+ # Following AC_PROG_CC_C_O, we do the test twice because some
+ # compilers refuse to overwrite an existing .o file with -o,
+ # though they will create one.
+ am_cv_prog_cc_c_o=yes
+ for am_i in 1 2; do
+ if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
+ ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } \
+ && test -f conftest2.$ac_objext; then
+ : OK
+ else
+ am_cv_prog_cc_c_o=no
+ break
+ fi
+ done
+ rm -f core conftest*
+ unset am_i
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
+$as_echo "$am_cv_prog_cc_c_o" >&6; }
+if test "$am_cv_prog_cc_c_o" != yes; then
+ # Losing compiler, so override with the script.
+ # FIXME: It is wrong to rewrite CC.
+ # But if we don't then we get into trouble of one sort or another.
+ # A longer-term fix would be to have automake use am__CC in this case,
+ # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+ CC="$am_aux_dir/compile $CC"
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
DEPDIR="${am__leading_dot}deps"
ac_config_commands="$ac_config_commands depfiles"
_am_result=none
# First try GNU make style include.
echo "include confinc" > confmf
-# Ignore all kinds of additional output from `make'.
+# Ignore all kinds of additional output from 'make'.
case `$am_make -s -f confmf 2> /dev/null` in #(
*the\ am__doit\ target*)
am__include=include
# We make a subdir and do the tests there. Otherwise we can end up
# making bogus files that we don't know about and never remove. For
# instance it was reported that on HP-UX the gcc test will end up
- # making a dummy file named `D' -- because `-MD' means `put the output
- # in D'.
+ # making a dummy file named 'D' -- because '-MD' means "put the output
+ # in D".
rm -rf conftest.dir
mkdir conftest.dir
# Copy depcomp to subdir because otherwise we won't find it if we're
: > sub/conftest.c
for i in 1 2 3 4 5 6; do
echo '#include "conftst'$i'.h"' >> sub/conftest.c
- # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
- # Solaris 8's {/usr,}/bin/sh.
- touch sub/conftst$i.h
+ # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+ # Solaris 10 /bin/sh.
+ echo '/* dummy */' > sub/conftst$i.h
done
echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
- # We check with `-c' and `-o' for the sake of the "dashmstdout"
+ # We check with '-c' and '-o' for the sake of the "dashmstdout"
# mode. It turns out that the SunPro C++ compiler does not properly
- # handle `-M -o', and we need to detect this. Also, some Intel
- # versions had trouble with output in subdirs
+ # handle '-M -o', and we need to detect this. Also, some Intel
+ # versions had trouble with output in subdirs.
am__obj=sub/conftest.${OBJEXT-o}
am__minus_obj="-o $am__obj"
case $depmode in
test "$am__universal" = false || continue
;;
nosideeffect)
- # after this tag, mechanisms are not by side-effect, so they'll
- # only be used when explicitly requested
+ # After this tag, mechanisms are not by side-effect, so they'll
+ # only be used when explicitly requested.
if test "x$enable_dependency_tracking" = xyes; then
continue
else
fi
;;
msvc7 | msvc7msys | msvisualcpp | msvcmsys)
- # This compiler won't grok `-c -o', but also, the minuso test has
+ # This compiler won't grok '-c -o', but also, the minuso test has
# not run yet. These depmodes are late enough in the game, and
# so weak that their functioning should not be impacted.
am__obj=conftest.${OBJEXT-o}
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CXX="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
# We make a subdir and do the tests there. Otherwise we can end up
# making bogus files that we don't know about and never remove. For
# instance it was reported that on HP-UX the gcc test will end up
- # making a dummy file named `D' -- because `-MD' means `put the output
- # in D'.
+ # making a dummy file named 'D' -- because '-MD' means "put the output
+ # in D".
rm -rf conftest.dir
mkdir conftest.dir
# Copy depcomp to subdir because otherwise we won't find it if we're
: > sub/conftest.c
for i in 1 2 3 4 5 6; do
echo '#include "conftst'$i'.h"' >> sub/conftest.c
- # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
- # Solaris 8's {/usr,}/bin/sh.
- touch sub/conftst$i.h
+ # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+ # Solaris 10 /bin/sh.
+ echo '/* dummy */' > sub/conftst$i.h
done
echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
- # We check with `-c' and `-o' for the sake of the "dashmstdout"
+ # We check with '-c' and '-o' for the sake of the "dashmstdout"
# mode. It turns out that the SunPro C++ compiler does not properly
- # handle `-M -o', and we need to detect this. Also, some Intel
- # versions had trouble with output in subdirs
+ # handle '-M -o', and we need to detect this. Also, some Intel
+ # versions had trouble with output in subdirs.
am__obj=sub/conftest.${OBJEXT-o}
am__minus_obj="-o $am__obj"
case $depmode in
test "$am__universal" = false || continue
;;
nosideeffect)
- # after this tag, mechanisms are not by side-effect, so they'll
- # only be used when explicitly requested
+ # After this tag, mechanisms are not by side-effect, so they'll
+ # only be used when explicitly requested.
if test "x$enable_dependency_tracking" = xyes; then
continue
else
fi
;;
msvc7 | msvc7msys | msvisualcpp | msvcmsys)
- # This compiler won't grok `-c -o', but also, the minuso test has
+ # This compiler won't grok '-c -o', but also, the minuso test has
# not run yet. These depmodes are late enough in the game, and
# so weak that their functioning should not be impacted.
am__obj=conftest.${OBJEXT-o}
-if test "x$CC" != xcc; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC and cc understand -c and -o together" >&5
-$as_echo_n "checking whether $CC and cc understand -c and -o together... " >&6; }
+ # Needed for subdir-objects in AUTOMAKE_OPTIONS
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking maximum warning verbosity option" >&5
+$as_echo_n "checking maximum warning verbosity option... " >&6; }
+
+
+
+
+# Check whether --with-maximum-compile-warnings was given.
+if test "${with_maximum_compile_warnings+set}" = set; then :
+ withval=$with_maximum_compile_warnings; ac_compile_warnings_on="$withval"
else
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether cc understands -c and -o together" >&5
-$as_echo_n "checking whether cc understands -c and -o together... " >&6; }
+ ac_compile_warnings_on=""
fi
-set dummy $CC; ac_cc=`$as_echo "$2" |
- sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
-if eval \${ac_cv_prog_cc_${ac_cc}_c_o+:} false; then :
- $as_echo_n "(cached) " >&6
-else
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h. */
-int
-main ()
-{
- ;
- return 0;
-}
-_ACEOF
-# Make sure it works both with $CC and with simple cc.
-# We do the test twice because some compilers refuse to overwrite an
-# existing .o file with -o, though they will create one.
-ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
-rm -f conftest2.*
-if { { case "(($ac_try" in
- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
- *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
- (eval "$ac_try") 2>&5
- ac_status=$?
- $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
- test $ac_status = 0; } &&
- test -f conftest2.$ac_objext && { { case "(($ac_try" in
- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
- *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
- (eval "$ac_try") 2>&5
- ac_status=$?
- $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
- test $ac_status = 0; };
-then
- eval ac_cv_prog_cc_${ac_cc}_c_o=yes
- if test "x$CC" != xcc; then
- # Test first that cc exists at all.
- if { ac_try='cc -c conftest.$ac_ext >&5'
- { { case "(($ac_try" in
- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
- *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
- (eval "$ac_try") 2>&5
- ac_status=$?
- $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
- test $ac_status = 0; }; }; then
- ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
- rm -f conftest2.*
- if { { case "(($ac_try" in
- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
- *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
- (eval "$ac_try") 2>&5
- ac_status=$?
- $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
- test $ac_status = 0; } &&
- test -f conftest2.$ac_objext && { { case "(($ac_try" in
- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
- *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
- (eval "$ac_try") 2>&5
- ac_status=$?
- $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
- test $ac_status = 0; };
- then
- # cc works too.
- :
- else
- # cc exists but doesn't like -o.
- eval ac_cv_prog_cc_${ac_cc}_c_o=no
- fi
- fi
- fi
-else
- eval ac_cv_prog_cc_${ac_cc}_c_o=no
-fi
-rm -f core conftest*
-
-fi
-if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-else
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-
-$as_echo "#define NO_MINUS_C_MINUS_O 1" >>confdefs.h
-
-fi
-
-# FIXME: we rely on the cache variable name because
-# there is no other way.
-set dummy $CC
-am_cc=`echo $2 | sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
-eval am_t=\$ac_cv_prog_cc_${am_cc}_c_o
-if test "$am_t" != yes; then
- # Losing compiler, so override with the script.
- # FIXME: It is wrong to rewrite CC.
- # But if we don't then we get into trouble of one sort or another.
- # A longer-term fix would be to have automake use am__CC in this case,
- # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
- CC="$am_aux_dir/compile $CC"
-fi
-
- # Needed for subdir-objects in AUTOMAKE_OPTIONS
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking maximum warning verbosity option" >&5
-$as_echo_n "checking maximum warning verbosity option... " >&6; }
-
-
-
-
-# Check whether --with-maximum-compile-warnings was given.
-if test "${with_maximum_compile_warnings+set}" = set; then :
- withval=$with_maximum_compile_warnings; ac_compile_warnings_on="$withval"
-else
- ac_compile_warnings_on=""
-fi
-
-
- if test x"$ac_compile_warnings_on" = xno
- then
- ac_compile_warnings_msg=no
- else
- if test -n "$CXX"
- then
- if test "$GXX" = "yes"
- then
- ac_compile_warnings_opt='-Wall -W -ansi -pedantic'
- fi
- CXXFLAGS="$CXXFLAGS $ac_compile_warnings_opt"
- ac_compile_warnings_msg="$ac_compile_warnings_opt for C++"
- fi
-
- if test -n "$CC"
- then
- if test "$GCC" = "yes"
- then
- ac_compile_warnings_opt='-Wall -W -ansi -pedantic'
- fi
- CFLAGS="$CFLAGS $ac_compile_warnings_opt"
- ac_compile_warnings_msg="$ac_compile_warnings_msg $ac_compile_warnings_opt for C"
- fi
- fi
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_compile_warnings_msg" >&5
-$as_echo "$ac_compile_warnings_msg" >&6; }
- unset ac_compile_warnings_msg
- unset ac_compile_warnings_opt
- # Increase warning levels
-
-
-cat >>confdefs.h <<_ACEOF
-#define SWIG_CXX "$CXX"
+ if test x"$ac_compile_warnings_on" = xno
+ then
+ ac_compile_warnings_msg=no
+ else
+ if test -n "$CXX"
+ then
+ if test "$GXX" = "yes"
+ then
+ ac_compile_warnings_opt='-Wall -W -ansi -pedantic'
+ fi
+ CXXFLAGS="$CXXFLAGS $ac_compile_warnings_opt"
+ ac_compile_warnings_msg="$ac_compile_warnings_opt for C++"
+ fi
+
+ if test -n "$CC"
+ then
+ if test "$GCC" = "yes"
+ then
+ ac_compile_warnings_opt='-Wall -W -ansi -pedantic'
+ fi
+ CFLAGS="$CFLAGS $ac_compile_warnings_opt"
+ ac_compile_warnings_msg="$ac_compile_warnings_msg $ac_compile_warnings_opt for C"
+ fi
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_compile_warnings_msg" >&5
+$as_echo "$ac_compile_warnings_msg" >&6; }
+ unset ac_compile_warnings_msg
+ unset ac_compile_warnings_opt
+ # Increase warning levels
+
+
+cat >>confdefs.h <<_ACEOF
+#define SWIG_CXX "$CXX"
_ACEOF
for ac_prog in grep ggrep; do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
- { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
+ as_fn_executable_p "$ac_path_GREP" || continue
# Check for GNU ac_path_GREP and select it if it is found.
# Check for GNU $ac_path_GREP
case `"$ac_path_GREP" --version 2>&1` in
for ac_prog in egrep; do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
- { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
+ as_fn_executable_p "$ac_path_EGREP" || continue
# Check for GNU ac_path_EGREP and select it if it is found.
# Check for GNU $ac_path_EGREP
case `"$ac_path_EGREP" --version 2>&1` in
fi
-ac_ext=cpp
-ac_cpp='$CXXCPP $CPPFLAGS'
-ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-
-
-# On IRIX 5.3, sys/types and inttypes.h are conflicting.
-for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
- inttypes.h stdint.h unistd.h
-do :
- as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
-ac_fn_cxx_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
-"
-if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
- cat >>confdefs.h <<_ACEOF
-#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
-_ACEOF
-
-fi
-
-done
-
-
-ac_fn_cxx_check_type "$LINENO" "bool" "ac_cv_type_bool" "$ac_includes_default"
-if test "x$ac_cv_type_bool" = xyes; then :
-
-cat >>confdefs.h <<_ACEOF
-#define HAVE_BOOL 1
-_ACEOF
-
-
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
# Check whether --with-popen was given.
if test "${with_popen+set}" = set; then :
for ac_prog in sed gsed; do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
- { test -f "$ac_path_SED" && $as_test_x "$ac_path_SED"; } || continue
+ as_fn_executable_p "$ac_path_SED" || continue
# Check for GNU ac_path_SED and select it if it is found.
# Check for GNU $ac_path_SED
case `"$ac_path_SED" --version 2>&1` in
- if test x$PCRE_CFLAGS != x -o x$PCRE_LIBS != x; then :
+ if test x"$PCRE_CFLAGS" != x -o x"$PCRE_LIBS" != x; then :
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_path_PCRE_CONFIG="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_YACC="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
done
test -n "$YACC" || YACC="yacc"
-if test -n "$ac_tool_prefix"; then
- # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
-set dummy ${ac_tool_prefix}ranlib; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_RANLIB+:} false; then :
- $as_echo_n "(cached) " >&6
-else
- if test -n "$RANLIB"; then
- ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
- IFS=$as_save_IFS
- test -z "$as_dir" && as_dir=.
- for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
- ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
- $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
- break 2
- fi
-done
- done
-IFS=$as_save_IFS
-
-fi
-fi
-RANLIB=$ac_cv_prog_RANLIB
-if test -n "$RANLIB"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
-$as_echo "$RANLIB" >&6; }
-else
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
+echo ""
+echo "Checking for installed target languages and other information in order to compile and run"
+echo "the examples and test-suite invoked by 'make check'."
+echo "Note : None of the following packages are required for users to compile and install SWIG from the distributed tarball"
+echo ""
-fi
-if test -z "$ac_cv_prog_RANLIB"; then
- ac_ct_RANLIB=$RANLIB
- # Extract the first word of "ranlib", so it can be a program name with args.
-set dummy ranlib; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
- $as_echo_n "(cached) " >&6
-else
- if test -n "$ac_ct_RANLIB"; then
- ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
- IFS=$as_save_IFS
- test -z "$as_dir" && as_dir=.
- for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
- ac_cv_prog_ac_ct_RANLIB="ranlib"
- $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
- break 2
- fi
-done
- done
-IFS=$as_save_IFS
-fi
-fi
-ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
-if test -n "$ac_ct_RANLIB"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
-$as_echo "$ac_ct_RANLIB" >&6; }
-else
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
- if test "x$ac_ct_RANLIB" = x; then
- RANLIB=":"
- else
- case $cross_compiling:$ac_tool_warned in
-yes:)
-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
- RANLIB=$ac_ct_RANLIB
- fi
-else
- RANLIB="$ac_cv_prog_RANLIB"
-fi
-for ac_prog in ar aal
-do
- # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_AR+:} false; then :
- $as_echo_n "(cached) " >&6
-else
- if test -n "$AR"; then
- ac_cv_prog_AR="$AR" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
- IFS=$as_save_IFS
- test -z "$as_dir" && as_dir=.
- for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
- ac_cv_prog_AR="$ac_prog"
- $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
- break 2
- fi
-done
- done
-IFS=$as_save_IFS
+# Check whether --with-boost was given.
+if test "${with_boost+set}" = set; then :
+ withval=$with_boost;
+ if test "$withval" = "no"; then
+ want_boost="no"
+ elif test "$withval" = "yes"; then
+ want_boost="yes"
+ ac_boost_path=""
+ else
+ want_boost="yes"
+ ac_boost_path="$withval"
+ fi
-fi
-fi
-AR=$ac_cv_prog_AR
-if test -n "$AR"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
-$as_echo "$AR" >&6; }
else
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
- test -n "$AR" && break
-done
-test -n "$AR" || AR="ar"
-
-
-for ac_prog in yodl2man
-do
- # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_YODL2MAN+:} false; then :
- $as_echo_n "(cached) " >&6
-else
- if test -n "$YODL2MAN"; then
- ac_cv_prog_YODL2MAN="$YODL2MAN" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
- IFS=$as_save_IFS
- test -z "$as_dir" && as_dir=.
- for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
- ac_cv_prog_YODL2MAN="$ac_prog"
- $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
- break 2
- fi
-done
- done
-IFS=$as_save_IFS
-
-fi
-fi
-YODL2MAN=$ac_cv_prog_YODL2MAN
-if test -n "$YODL2MAN"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $YODL2MAN" >&5
-$as_echo "$YODL2MAN" >&6; }
-else
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
- test -n "$YODL2MAN" && break
-done
-
-for ac_prog in yodl2html
-do
- # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_YODL2HTML+:} false; then :
- $as_echo_n "(cached) " >&6
-else
- if test -n "$YODL2HTML"; then
- ac_cv_prog_YODL2HTML="$YODL2HTML" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
- IFS=$as_save_IFS
- test -z "$as_dir" && as_dir=.
- for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
- ac_cv_prog_YODL2HTML="$ac_prog"
- $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
- break 2
- fi
-done
- done
-IFS=$as_save_IFS
-
-fi
-fi
-YODL2HTML=$ac_cv_prog_YODL2HTML
-if test -n "$YODL2HTML"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $YODL2HTML" >&5
-$as_echo "$YODL2HTML" >&6; }
-else
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
- test -n "$YODL2HTML" && break
-done
-
-
-if test -n "$YODL2MAN"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking yodl2man version >= 2.02" >&5
-$as_echo_n "checking yodl2man version >= 2.02... " >&6; }
- yodl_version=`$YODL2MAN --version 2>&1 | grep 'yodl version' | sed 's/.*\(0-90-9*\.0-90-9*\.*0-9*\).*/\1/g'`
-
-
-
- # Used to indicate true or false condition
- ax_compare_version=false
-
- # Convert the two version strings to be compared into a format that
- # allows a simple string comparison. The end result is that a version
- # string of the form 1.12.5-r617 will be converted to the form
- # 0001001200050617. In other words, each number is zero padded to four
- # digits, and non digits are removed.
-
- ax_compare_version_A=`echo "$yodl_version" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
- -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
- -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
- -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
- -e 's/[^0-9]//g'`
-
-
- ax_compare_version_B=`echo "2.02" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
- -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
- -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
- -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
- -e 's/[^0-9]//g'`
-
-
- ax_compare_version=`echo "x$ax_compare_version_A
-x$ax_compare_version_B" | sed 's/^ *//' | sort -r | sed "s/x${ax_compare_version_A}/true/;s/x${ax_compare_version_B}/false/;1q"`
-
-
-
- if test "$ax_compare_version" = "true" ; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
- else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no - $yodl_version found" >&5
-$as_echo "no - $yodl_version found" >&6; }
- fi
-
-fi
-
-if test -n "$YODL2HTML"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking yodl2html version >= 2.02" >&5
-$as_echo_n "checking yodl2html version >= 2.02... " >&6; }
- yodl_version=`$YODL2HTML --version 2>&1 | grep 'yodl version' | sed 's/.*\(0-90-9*\.0-90-9*\.0-90-9*\).*/\1/g'`
-
-
-
- # Used to indicate true or false condition
- ax_compare_version=false
-
- # Convert the two version strings to be compared into a format that
- # allows a simple string comparison. The end result is that a version
- # string of the form 1.12.5-r617 will be converted to the form
- # 0001001200050617. In other words, each number is zero padded to four
- # digits, and non digits are removed.
-
- ax_compare_version_A=`echo "$yodl_version" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
- -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
- -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
- -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
- -e 's/[^0-9]//g'`
-
-
- ax_compare_version_B=`echo "2.02" | sed -e 's/\([0-9]*\)/Z\1Z/g' \
- -e 's/Z\([0-9]\)Z/Z0\1Z/g' \
- -e 's/Z\([0-9][0-9]\)Z/Z0\1Z/g' \
- -e 's/Z\([0-9][0-9][0-9]\)Z/Z0\1Z/g' \
- -e 's/[^0-9]//g'`
-
-
- ax_compare_version=`echo "x$ax_compare_version_A
-x$ax_compare_version_B" | sed 's/^ *//' | sort -r | sed "s/x${ax_compare_version_A}/true/;s/x${ax_compare_version_B}/false/;1q"`
-
-
-
- if test "$ax_compare_version" = "true" ; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
- else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no - $yodl_version found" >&5
-$as_echo "no - $yodl_version found" >&6; }
- fi
-
-fi
-
-echo ""
-echo "Checking for installed target languages and other information in order to compile and run"
-echo "the examples and test-suite invoked by 'make check'."
-echo "Note : None of the following packages are required for users to compile and install SWIG from the distributed tarball"
-echo ""
-
-
-
-# Check whether --with-boost was given.
-if test "${with_boost+set}" = set; then :
- withval=$with_boost;
- if test "$withval" = "no"; then
- want_boost="no"
- elif test "$withval" = "yes"; then
- want_boost="yes"
- ac_boost_path=""
- else
- want_boost="yes"
- ac_boost_path="$withval"
- fi
-
-else
- want_boost="yes"
+ want_boost="yes"
fi
libsubdirs="lib"
ax_arch=`uname -m`
- if test $ax_arch = x86_64 -o $ax_arch = ppc64 -o $ax_arch = s390x -o $ax_arch = sparc64; then
- libsubdirs="lib64 lib lib64"
- fi
+ case $ax_arch in
+ x86_64)
+ libsubdirs="lib64 libx32 lib lib64"
+ ;;
+ ppc64|s390x|sparc64|aarch64|ppc64le)
+ libsubdirs="lib64 lib lib64 ppc64le"
+ ;;
+ esac
+
+
+ libsubdirs="lib/${host_cpu}-${host_os} $libsubdirs"
+
+ case ${host_cpu} in
+ i?86)
+ libsubdirs="lib/i386-${host_os} $libsubdirs"
+ ;;
+ esac
if test "$ac_boost_path" != ""; then
BOOST_CPPFLAGS="-I$ac_boost_path/include"
if test "x$succeeded" != "xyes"; then
+ CPPFLAGS="$CPPFLAGS_SAVED"
+ LDFLAGS="$LDFLAGS_SAVED"
+ BOOST_CPPFLAGS=
+ BOOST_LDFLAGS=
_version=0
if test "$ac_boost_path" != ""; then
if test -d "$ac_boost_path" && test -r "$ac_boost_path"; then
VERSION_UNDERSCORE=`echo $_version | sed 's/\./_/'`
BOOST_CPPFLAGS="-I$ac_boost_path/include/boost-$VERSION_UNDERSCORE"
done
+ if test -z "$BOOST_CPPFLAGS"; then
+ if test -d "$ac_boost_path/boost" && test -r "$ac_boost_path/boost"; then
+ BOOST_CPPFLAGS="-I$ac_boost_path"
+ fi
+ fi
fi
else
if test "$cross_compiling" != yes; then
then CCSHARED="-fpic"
else CCSHARED="+z"
fi;;
+ s390x*-*-*) CCSHARED="-fpic" ;;
+ s390*-*-*) CCSHARED="-fPIC" ;;
*-*-linux*) CCSHARED="-fpic";;
*-*-freebsd* | *-*-openbsd*) CCSHARED="-fpic";;
*-*-netbsd*) CCSHARED="-fPIC";;
$as_echo "$LINKFORSHARED" >&6; }
# Optional CFLAGS used to silence/enhance compiler warnings on some platforms.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking PLATFLAGS" >&5
-$as_echo_n "checking PLATFLAGS... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking PLATCFLAGS" >&5
+$as_echo_n "checking PLATCFLAGS... " >&6; }
case $host in
*-*-solaris*) if test "$GCC" = yes
- then PLATFLAGS=
- else PLATFLAGS=
- # else PLATFLAGS="-errtags=yes" # Need more work as C examples use ld for linking
+ then PLATCFLAGS=
+ else PLATCFLAGS=
+ # else PLATCFLAGS="-errtags=yes" # Need more work as C examples use ld for linking
+ fi;;
+ *) PLATCFLAGS=
+esac
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PLATCFLAGS" >&5
+$as_echo "$PLATCFLAGS" >&6; }
+
+# Add switch if necessary to enable C++11 support - just for tests
+# Check whether --enable-cpp11-testing was given.
+if test "${enable_cpp11_testing+set}" = set; then :
+ enableval=$enable_cpp11_testing; enable_cpp11_testing=$enableval
+else
+ enable_cpp11_testing=no
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable C++11 testing" >&5
+$as_echo_n "checking whether to enable C++11 testing... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_cpp11_testing" >&5
+$as_echo "$enable_cpp11_testing" >&6; }
+
+PLATCXXFLAGS="$PLATCFLAGS"
+if test x"$enable_cpp11_testing" = xyes; then
+ ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+ CXXFLAGS_SAVED=$CXXFLAGS
+ CXXFLAGS=
+ ac_success=no
+ CXX11FLAGS=
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features by default" >&5
+$as_echo_n "checking whether $CXX supports C++11 features by default... " >&6; }
+if ${ax_cv_cxx_compile_cxx11+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+ template <typename T>
+ struct check
+ {
+ static_assert(sizeof(int) <= sizeof(T), "not big enough");
+ };
+
+ typedef check<check<bool>> right_angle_brackets;
+
+ int a;
+ decltype(a) b;
+
+ typedef check<int> check_type;
+ check_type c;
+ check_type&& cr = static_cast<check_type&&>(c);
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+ ax_cv_cxx_compile_cxx11=yes
+else
+ ax_cv_cxx_compile_cxx11=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_cxx_compile_cxx11" >&5
+$as_echo "$ax_cv_cxx_compile_cxx11" >&6; }
+ if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+ ac_success=yes
+ fi
+
+
+
+ if test x$ac_success = xno; then
+ for switch in -std=c++11 -std=c++0x; do
+ cachevar=`$as_echo "ax_cv_cxx_compile_cxx11_$switch" | $as_tr_sh`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features with $switch" >&5
+$as_echo_n "checking whether $CXX supports C++11 features with $switch... " >&6; }
+if eval \${$cachevar+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS $switch"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+ template <typename T>
+ struct check
+ {
+ static_assert(sizeof(int) <= sizeof(T), "not big enough");
+ };
+
+ typedef check<check<bool>> right_angle_brackets;
+
+ int a;
+ decltype(a) b;
+
+ typedef check<int> check_type;
+ check_type c;
+ check_type&& cr = static_cast<check_type&&>(c);
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+ eval $cachevar=yes
+else
+ eval $cachevar=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ CXXFLAGS="$ac_save_CXXFLAGS"
+fi
+eval ac_res=\$$cachevar
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+ if eval test x\$$cachevar = xyes; then
+ CXXFLAGS="$CXXFLAGS $switch"
+ CXX11FLAGS=$switch
+ ac_success=yes
+ break
+ fi
+ done
+ fi
+
+ if test x$ac_success = xno; then
+ if test xnostop != xnostop; then
+ as_fn_error $? "*** A compiler with support for C++11 language features is required." "$LINENO" 5
+ fi
+ else
+ HAVE_CXX11_COMPILER=yes
+ fi
+
+ CXXFLAGS=$CXXFLAGS_SAVED
+ ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ if test x"$CXX11FLAGS" != x; then
+ PLATCXXFLAGS="$CXX11FLAGS $PLATCXXFLAGS"
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++11 enabled compiler" >&5
+$as_echo_n "checking for C++11 enabled compiler... " >&6; }
+ if test x"$HAVE_CXX11_COMPILER" = x; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HAVE_CXX11_COMPILER" >&5
+$as_echo "$HAVE_CXX11_COMPILER" >&6; }
+ fi
+fi
+
+# On darwin 10.7,10.8,10.9 using clang++, need to ensure using
+# libc++ for tests and examples to run under mono. May affect
+# other language targets as well - problem is a Mac OS X incompatibility
+# between libraries depending on libstdc++ and libc++.
+CLANGXX=
+$CXX -v 2>&1 | grep -i clang >/dev/null && CLANGXX=yes
+case $host in
+ *-*-darwin11* | *-*-darwin12* |*-*-darwin13* ) if test "$CLANGXX" = "yes";
+ then PLATCXXFLAGS="$PLATCXXFLAGS -stdlib=libc++"
fi;;
- *) PLATFLAGS=
+ *) ;;
esac
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PLATFLAGS" >&5
-$as_echo "$PLATFLAGS" >&6; }
# Set info about shared libraries.
+
+
# This variation is needed on OS-X because there is no (apparent) consistency in shared library naming.
# Sometimes .bundle works, but sometimes .so is needed. It depends on the target language
#--------------------------------------------------------------------
-# Locate the X11 header files and the X11 library archive. Try
-# the ac_path_x macro first, but if it doesn't find the X stuff
-# (e.g. because there's no xmkmf program) then check through
-# a list of possible directories. Under some conditions the
-# autoconf macro will return an include directory that contains
-# no include files, so double-check its result just to be safe.
+# Target languages
#--------------------------------------------------------------------
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5
-$as_echo_n "checking for X... " >&6; }
-
-# Check whether --with-x was given.
-if test "${with_x+set}" = set; then :
- withval=$with_x;
+# Check whether --with-alllang was given.
+if test "${with_alllang+set}" = set; then :
+ withval=$with_alllang; with_alllang="$withval"
fi
-# $have_x is `yes', `no', `disabled', or empty when we do not yet know.
-if test "x$with_x" = xno; then
- # The user explicitly disabled X.
- have_x=disabled
+
+if test "$with_alllang" = "no"; then
+ alllang_default=no
else
- case $x_includes,$x_libraries in #(
- *\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5;; #(
- *,NONE | NONE,*) if ${ac_cv_have_x+:} false; then :
+ alllang_default=yes
+fi
+
+for ac_prog in pkg-config
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_PKGCONFIG+:} false; then :
$as_echo_n "(cached) " >&6
else
- # One or both of the vars are not set, and there is no cached value.
-ac_x_includes=no ac_x_libraries=no
-rm -f -r conftest.dir
-if mkdir conftest.dir; then
- cd conftest.dir
- cat >Imakefile <<'_ACEOF'
-incroot:
- @echo incroot='${INCROOT}'
-usrlibdir:
- @echo usrlibdir='${USRLIBDIR}'
-libdir:
- @echo libdir='${LIBDIR}'
-_ACEOF
- if (export CC; ${XMKMF-xmkmf}) >/dev/null 2>/dev/null && test -f Makefile; then
- # GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
- for ac_var in incroot usrlibdir libdir; do
- eval "ac_im_$ac_var=\`\${MAKE-make} $ac_var 2>/dev/null | sed -n 's/^$ac_var=//p'\`"
- done
- # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR.
- for ac_extension in a so sl dylib la dll; do
- if test ! -f "$ac_im_usrlibdir/libX11.$ac_extension" &&
- test -f "$ac_im_libdir/libX11.$ac_extension"; then
- ac_im_usrlibdir=$ac_im_libdir; break
- fi
- done
- # Screen out bogus values from the imake configuration. They are
- # bogus both because they are the default anyway, and because
- # using them would break gcc on systems where it needs fixed includes.
- case $ac_im_incroot in
- /usr/include) ac_x_includes= ;;
- *) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes=$ac_im_incroot;;
- esac
- case $ac_im_usrlibdir in
- /usr/lib | /usr/lib64 | /lib | /lib64) ;;
- *) test -d "$ac_im_usrlibdir" && ac_x_libraries=$ac_im_usrlibdir ;;
- esac
- fi
- cd ..
- rm -f -r conftest.dir
-fi
-
-# Standard set of common directories for X headers.
-# Check X11 before X11Rn because it is often a symlink to the current release.
-ac_x_header_dirs='
-/usr/X11/include
-/usr/X11R7/include
-/usr/X11R6/include
-/usr/X11R5/include
-/usr/X11R4/include
-
-/usr/include/X11
-/usr/include/X11R7
-/usr/include/X11R6
-/usr/include/X11R5
-/usr/include/X11R4
-
-/usr/local/X11/include
-/usr/local/X11R7/include
-/usr/local/X11R6/include
-/usr/local/X11R5/include
-/usr/local/X11R4/include
-
-/usr/local/include/X11
-/usr/local/include/X11R7
-/usr/local/include/X11R6
-/usr/local/include/X11R5
-/usr/local/include/X11R4
-
-/usr/X386/include
-/usr/x386/include
-/usr/XFree86/include/X11
-
-/usr/include
-/usr/local/include
-/usr/unsupported/include
-/usr/athena/include
-/usr/local/x11r5/include
-/usr/lpp/Xamples/include
-
-/usr/openwin/include
-/usr/openwin/share/include'
-
-if test "$ac_x_includes" = no; then
- # Guess where to find include files, by looking for Xlib.h.
- # First, try using that file with no special directory specified.
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h. */
-#include <X11/Xlib.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
- # We can compile using X headers with no special include directory.
-ac_x_includes=
+ if test -n "$PKGCONFIG"; then
+ ac_cv_prog_PKGCONFIG="$PKGCONFIG" # Let the user override the test.
else
- for ac_dir in $ac_x_header_dirs; do
- if test -r "$ac_dir/X11/Xlib.h"; then
- ac_x_includes=$ac_dir
- break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_PKGCONFIG="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
fi
done
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-fi # $ac_x_includes = no
-
-if test "$ac_x_libraries" = no; then
- # Check for the libraries.
- # See if we find them without any special options.
- # Don't add to $LIBS permanently.
- ac_save_LIBS=$LIBS
- LIBS="-lX11 $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h. */
-#include <X11/Xlib.h>
-int
-main ()
-{
-XrmInitialize ()
- ;
- return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"; then :
- LIBS=$ac_save_LIBS
-# We can link X programs with no special library path.
-ac_x_libraries=
-else
- LIBS=$ac_save_LIBS
-for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g`
-do
- # Don't even attempt the hair of trying to link an X program!
- for ac_extension in a so sl dylib la dll; do
- if test -r "$ac_dir/libX11.$ac_extension"; then
- ac_x_libraries=$ac_dir
- break 2
- fi
done
-done
-fi
-rm -f core conftest.err conftest.$ac_objext \
- conftest$ac_exeext conftest.$ac_ext
-fi # $ac_x_libraries = no
-
-case $ac_x_includes,$ac_x_libraries in #(
- no,* | *,no | *\'*)
- # Didn't find X, or a directory has "'" in its name.
- ac_cv_have_x="have_x=no";; #(
- *)
- # Record where we found X for the cache.
- ac_cv_have_x="have_x=yes\
- ac_x_includes='$ac_x_includes'\
- ac_x_libraries='$ac_x_libraries'"
-esac
-fi
-;; #(
- *) have_x=yes;;
- esac
- eval "$ac_cv_have_x"
-fi # $with_x != no
-
-if test "$have_x" != yes; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5
-$as_echo "$have_x" >&6; }
- no_x=yes
-else
- # If each of the values was on the command line, it overrides each guess.
- test "x$x_includes" = xNONE && x_includes=$ac_x_includes
- test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries
- # Update the cache value to reflect the command line values.
- ac_cv_have_x="have_x=yes\
- ac_x_includes='$x_includes'\
- ac_x_libraries='$x_libraries'"
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5
-$as_echo "libraries $x_libraries, headers $x_includes" >&6; }
-fi
-
-not_really_there=""
-if test "$no_x" = ""; then
- if test "$x_includes" = ""; then
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h. */
-#include <X11/XIntrinsic.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-
-else
- not_really_there="yes"
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
- else
- if test ! -r $x_includes/X11/Intrinsic.h; then
- not_really_there="yes"
- fi
- fi
-fi
-if test "$no_x" = "yes" -o "$not_really_there" = "yes"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for X11 header files" >&5
-$as_echo_n "checking for X11 header files... " >&6; }
- XINCLUDES="# no special path needed"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h. */
-#include <X11/Intrinsic.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
+IFS=$as_save_IFS
-else
- XINCLUDES=""
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
- if test -z "$XINCLUDES"; then
- dirs="/usr/unsupported/include /usr/local/include /usr/X386/include /usr/include/X11R4 /usr/X11R5/include /usr/include/X11R5 /usr/openwin/include /usr/X11/include /usr/sww/include /usr/X11R6/include /usr/include/X11R6"
- for i in $dirs ; do
- if test -r $i/X11/Intrinsic.h; then
- XINCLUDES=" -I$i"
- break
- fi
- done
- fi
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XINCLUDES" >&5
-$as_echo "$XINCLUDES" >&6; }
-else
- if test "$x_includes" != ""; then
- XINCLUDES=-I$x_includes
- else
- XINCLUDES="# no special path needed"
- fi
fi
-if test -z "$XINCLUDES"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: couldn't find any!" >&5
-$as_echo "couldn't find any!" >&6; }
- XINCLUDES="# no include files found"
-fi
-
-if test "$no_x" = yes; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for X11 libraries" >&5
-$as_echo_n "checking for X11 libraries... " >&6; }
- XLIBSW=
- dirs="/usr/unsupported/lib /usr/local/lib /usr/X386/lib /usr/lib/X11R4 /usr/X11R5/lib /usr/lib/X11R5 /usr/X11R6/lib /usr/lib/X11R6 /usr/openwin/lib /usr/X11/lib /usr/sww/X11/lib"
- for i in $dirs ; do
- if test -r $i/libX11.a -o -r $i/libX11.so -o -r $i/libX11.sl; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $i" >&5
-$as_echo "$i" >&6; }
- XLIBSW="-L$i -lX11"
- break
- fi
- done
-else
- if test "$x_libraries" = ""; then
- XLIBSW=-lX11
- else
- XLIBSW="-L$x_libraries -lX11"
- fi
fi
-if test -z "$XLIBSW" ; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XCreateWindow in -lXwindow" >&5
-$as_echo_n "checking for XCreateWindow in -lXwindow... " >&6; }
-if ${ac_cv_lib_Xwindow_XCreateWindow+:} false; then :
- $as_echo_n "(cached) " >&6
-else
- ac_check_lib_save_LIBS=$LIBS
-LIBS="-lXwindow $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h. */
-
-/* Override any GCC internal prototype to avoid an error.
- Use char because int might match the return type of a GCC
- builtin and then its argument prototype would still apply. */
-#ifdef __cplusplus
-extern "C"
-#endif
-char XCreateWindow ();
-int
-main ()
-{
-return XCreateWindow ();
- ;
- return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"; then :
- ac_cv_lib_Xwindow_XCreateWindow=yes
+PKGCONFIG=$ac_cv_prog_PKGCONFIG
+if test -n "$PKGCONFIG"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGCONFIG" >&5
+$as_echo "$PKGCONFIG" >&6; }
else
- ac_cv_lib_Xwindow_XCreateWindow=no
-fi
-rm -f core conftest.err conftest.$ac_objext \
- conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xwindow_XCreateWindow" >&5
-$as_echo "$ac_cv_lib_Xwindow_XCreateWindow" >&6; }
-if test "x$ac_cv_lib_Xwindow_XCreateWindow" = xyes; then :
- XLIBSW=-lXwindow
-fi
-
-fi
-if test -z "$XLIBSW" ; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: couldn't find any! Using -lX11." >&5
-$as_echo "couldn't find any! Using -lX11." >&6; }
- XLIBSW=-lX11
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
fi
-
-
-
-# Check whether --with-alllang was given.
-if test "${with_alllang+set}" = set; then :
- withval=$with_alllang; with_alllang="$withval"
-fi
+ test -n "$PKGCONFIG" && break
+done
#--------------------------------------------------------------------
withval=$with_tcl;
TCLPACKAGE="$withval"
else
- TCLPACKAGE=yes
+ TCLPACKAGE="$alllang_default"
fi
# First, check for "--without-tcl" or "--with-tcl=no".
-if test x"${TCLPACKAGE}" = xno -o x"${with_alllang}" = xno; then
+if test x"${TCLPACKAGE}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Tcl" >&5
$as_echo "$as_me: Disabling Tcl" >&6;}
else
if test -f "${with_tclconfig}/tclConfig.sh" ; then
TCLCONFIG=`(cd ${with_tclconfig}; pwd)`
else
- as_fn_error $? "${with_tcl} directory doesn't contain tclConfig.sh" "$LINENO" 5
+ as_fn_error $? "${with_tcl} directory does not contain tclConfig.sh" "$LINENO" 5
fi
fi
# check in a few common install locations
if test x"${TCLCONFIG}" = x ; then
- for i in `ls -d /usr/lib/ 2>/dev/null` \
- `ls -d -r /usr/lib/tcl*/ 2>/dev/null` \
- `ls -d /usr/local/lib/ 2>/dev/null` \
- `ls -d -r /usr/local/lib/tcl*/ 2>/dev/null` ; do
+ for i in `ls -d -r /usr/lib*/ 2>/dev/null` \
+ `ls -d -r /usr/lib*/tcl*/ 2>/dev/null` \
+ `ls -d -r /usr/local/lib*/ 2>/dev/null` \
+ `ls -d -r /usr/local/lib*/tcl*/ 2>/dev/null` ; do
if test -f $i"tclConfig.sh" ; then
TCLCONFIG=`(cd $i; pwd)`
break
PYINCLUDE=
PYLIB=
+PYLINK=
PYPACKAGE=
if test "${with_python+set}" = set; then :
withval=$with_python; PYBIN="$withval"
else
- PYBIN=yes
+ PYBIN="$alllang_default"
fi
# First, check for "--without-python" or "--with-python=no".
-if test x"${PYBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${PYBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Python" >&5
$as_echo "$as_me: Disabling Python" >&6;}
else
# First figure out the name of the Python executable
if test "x$PYBIN" = xyes; then
- for ac_prog in python python2.8 python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 python1.6 python1.5 python1.4
+ for ac_prog in python python2.8 python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_PYTHON="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
PYTHON="$PYBIN"
fi
+ PYVER=0
if test -n "$PYTHON"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $PYTHON major version number" >&5
+$as_echo_n "checking for $PYTHON major version number... " >&6; }
+ PYVER=`($PYTHON -c "import sys; sys.stdout.write(sys.version[0])") 2>/dev/null`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYVER" >&5
+$as_echo "$PYVER" >&6; }
+ if test -z "$PYVER"; then
+ PYVER=0
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python os.name" >&5
+$as_echo_n "checking for Python os.name... " >&6; }
+ PYOSNAME=`($PYTHON -c "import sys, os; sys.stdout.write(os.name)")`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYOSNAME" >&5
+$as_echo "$PYOSNAME" >&6; }
+ fi
+ fi
+
+ if test $PYVER -eq 1 -o $PYVER -eq 2; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python prefix" >&5
$as_echo_n "checking for Python prefix... " >&6; }
- PYPREFIX=`($PYTHON -c "import sys; print sys.prefix") 2>/dev/null`
+ PYPREFIX=`($PYTHON -c "import sys; sys.stdout.write(sys.prefix)") 2>/dev/null`
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYPREFIX" >&5
$as_echo "$PYPREFIX" >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python exec-prefix" >&5
$as_echo_n "checking for Python exec-prefix... " >&6; }
- PYEPREFIX=`($PYTHON -c "import sys; print sys.exec_prefix") 2>/dev/null`
+ PYEPREFIX=`($PYTHON -c "import sys; sys.stdout.write(sys.exec_prefix)") 2>/dev/null`
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYEPREFIX" >&5
$as_echo "$PYEPREFIX" >&6; }
+ if test x"$PYOSNAME" = x"nt"; then
+ # Windows installations are quite different to posix installations
+ PYPREFIX=`echo "$PYPREFIX" | sed -e 's,\\\\,/,g'` # Forward slashes are easier to use and even work on Windows most of the time
+ PYTHON_SO=.pyd
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python header files" >&5
+$as_echo_n "checking for Python header files... " >&6; }
+ if test -r $PYPREFIX/include/Python.h; then
+ PYINCLUDE="-I$PYPREFIX/include"
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYINCLUDE" >&5
+$as_echo "$PYINCLUDE" >&6; }
- # Note: I could not think of a standard way to get the version string from different versions.
- # This trick pulls it out of the file location for a standard library file.
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python library directory" >&5
+$as_echo_n "checking for Python library directory... " >&6; }
+ if test -d $PYPREFIX/libs; then
+ PYLIB=$PYPREFIX/libs
+ PYLINKFILE=`ls $PYLIB/python*.lib | grep "python[0-9][0-9]\.lib"`
+ if test -r "$PYLINKFILE"; then
+ PYLINK=-l`basename $PYLINKFILE | sed -e 's/\.lib$//'`
+ else
+ PYLIB=
+ fi
+ fi
+ else
+ # Note: I could not think of a standard way to get the version string from different versions.
+ # This trick pulls it out of the file location for a standard library file.
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python version" >&5
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python version" >&5
$as_echo_n "checking for Python version... " >&6; }
- # Need to do this hack since autoconf replaces __file__ with the name of the configure file
- filehack="file__"
- PYVERSION=`($PYTHON -c "import string,operator,os.path; print operator.getitem(os.path.split(operator.getitem(os.path.split(string.__$filehack),0)),1)")`
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYVERSION" >&5
+ # Need to do this hack since autoconf replaces __file__ with the name of the configure file
+ filehack="file__"
+ PYVERSION=`($PYTHON -c "import sys,string,operator,os.path; sys.stdout.write(operator.getitem(os.path.split(operator.getitem(os.path.split(string.__$filehack),0)),1))")`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYVERSION" >&5
$as_echo "$PYVERSION" >&6; }
- # Find the directory for libraries this is necessary to deal with
- # platforms that can have apps built for multiple archs: e.g. x86_64
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python lib dir" >&5
+ # Find the directory for libraries this is necessary to deal with
+ # platforms that can have apps built for multiple archs: e.g. x86_64
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python lib dir" >&5
$as_echo_n "checking for Python lib dir... " >&6; }
- PYLIBDIR=`($PYTHON -c "import sys; print sys.lib") 2>/dev/null`
- if test -z "$PYLIBDIR"; then
- # Fedora patch Python to add sys.lib, for other distros we assume "lib".
- PYLIBDIR="lib"
- fi
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYLIBDIR" >&5
+ PYLIBDIR=`($PYTHON -c "import sys; sys.stdout.write(sys.lib)") 2>/dev/null`
+ if test -z "$PYLIBDIR"; then
+ # Fedora patch Python to add sys.lib, for other distros we assume "lib".
+ PYLIBDIR="lib"
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYLIBDIR" >&5
$as_echo "$PYLIBDIR" >&6; }
- # Set the include directory
+ # Set the include directory
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python header files" >&5
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python header files" >&5
$as_echo_n "checking for Python header files... " >&6; }
- if test -r $PYPREFIX/include/$PYVERSION/Python.h; then
- PYINCLUDE="-I$PYPREFIX/include/$PYVERSION -I$PYEPREFIX/$PYLIBDIR/$PYVERSION/config"
- fi
- if test -z "$PYINCLUDE"; then
- if test -r $PYPREFIX/include/Py/Python.h; then
- PYINCLUDE="-I$PYPREFIX/include/Py -I$PYEPREFIX/$PYLIBDIR/python/lib"
+ if test -r $PYPREFIX/include/$PYVERSION/Python.h; then
+ PYINCLUDE="-I$PYPREFIX/include/$PYVERSION -I$PYEPREFIX/$PYLIBDIR/$PYVERSION/config"
fi
- fi
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYINCLUDE" >&5
+ if test -z "$PYINCLUDE"; then
+ if test -r $PYPREFIX/include/Py/Python.h; then
+ PYINCLUDE="-I$PYPREFIX/include/Py -I$PYEPREFIX/$PYLIBDIR/python/lib"
+ fi
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYINCLUDE" >&5
$as_echo "$PYINCLUDE" >&6; }
- # Set the library directory blindly. This probably won't work with older versions
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python library" >&5
-$as_echo_n "checking for Python library... " >&6; }
- dirs="$PYVERSION/config $PYVERSION/$PYLIBDIR python/$PYLIBDIR"
- for i in $dirs; do
- if test -d $PYEPREFIX/$PYLIBDIR/$i; then
- PYLIB="$PYEPREFIX/$PYLIBDIR/$i"
- break
- fi
- done
+ # Set the library directory blindly. This probably won't work with older versions
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python library directory" >&5
+$as_echo_n "checking for Python library directory... " >&6; }
+ dirs="$PYVERSION/config $PYVERSION/$PYLIBDIR python/$PYLIBDIR"
+ for i in $dirs; do
+ if test -d $PYEPREFIX/$PYLIBDIR/$i; then
+ PYLIB="$PYEPREFIX/$PYLIBDIR/$i"
+ break
+ fi
+ done
+
+ PYLINK="-l$PYVERSION"
+ fi
+
if test -z "$PYLIB"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: Not found" >&5
$as_echo "Not found" >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYLIB" >&5
$as_echo "$PYLIB" >&6; }
fi
-
- PYLINK="-l$PYVERSION"
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python library" >&5
+$as_echo_n "checking for Python library... " >&6; }
+ if test -z "$PYLINK"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: Not found" >&5
+$as_echo "Not found" >&6; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYLINK" >&5
+$as_echo "$PYLINK" >&6; }
+ fi
fi
# Cygwin (Windows) needs the library for dynamic linking
# Look for Python 3.x
#----------------------------------------------------------------
-# mostly copy & pasted from "Look for Python" section,
-# did some trim, fix and rename
-
PY3INCLUDE=
PY3LIB=
+PY3LINK=
PY3PACKAGE=
if test "${with_python3+set}" = set; then :
withval=$with_python3; PY3BIN="$withval"
else
- PY3BIN=yes
+ PY3BIN="$alllang_default"
fi
# First, check for "--without-python3" or "--with-python3=no".
-if test x"${PY3BIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${PY3BIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Python 3.x support" >&5
$as_echo "$as_me: Disabling Python 3.x support" >&6;}
else
- for py_ver in 3 3.6 3.5 3.4 3.3 3.2 3.1 3.0; do
- for ac_prog in python$py_ver
+ if test -z "$PYVER"; then
+ PYVER=0
+ fi
+ if test "x$PY3BIN" = xyes; then
+ if test x"$PYOSNAME" = x"nt" -a $PYVER -ge 3; then
+ PYTHON3="$PYTHON"
+ else
+ for py_ver in 3 3.9 3.8 3.7 3.6 3.5 3.4 3.3 3.2 3.1 3.0 ""; do
+ for ac_prog in python$py_ver
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_PYTHON3="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
test -n "$PYTHON3" && break
done
- if test -n "$PYTHON3"; then
- for ac_prog in $PYTHON3-config
+ if test -n "$PYTHON3"; then
+ for ac_prog in $PYTHON3-config
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_PY3CONFIG="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
test -n "$PY3CONFIG" && break
done
- if test -n "$PY3CONFIG"; then
- break
- fi
+ if test -n "$PY3CONFIG"; then
+ break
+ fi
+ fi
+ done
fi
+ else
+ PYTHON3="$PY3BIN"
+ for ac_prog in $PYTHON3-config
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_PY3CONFIG+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$PY3CONFIG"; then
+ ac_cv_prog_PY3CONFIG="$PY3CONFIG" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_PY3CONFIG="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
done
+IFS=$as_save_IFS
+
+fi
+fi
+PY3CONFIG=$ac_cv_prog_PY3CONFIG
+if test -n "$PY3CONFIG"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3CONFIG" >&5
+$as_echo "$PY3CONFIG" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$PY3CONFIG" && break
+done
+
+ fi
+
+ if test -n "$PYTHON3"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $PYTHON3 major version number" >&5
+$as_echo_n "checking for $PYTHON3 major version number... " >&6; }
+ PYVER=`($PYTHON3 -c "import sys; sys.stdout.write(sys.version[0])") 2>/dev/null`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYVER" >&5
+$as_echo "$PYVER" >&6; }
+ if test -z "$PYVER"; then
+ PYVER=0
+ fi
+ fi
+
+ if test $PYVER -ge 3; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x os.name" >&5
+$as_echo_n "checking for Python 3.x os.name... " >&6; }
+ PY3OSNAME=`($PYTHON3 -c "import sys, os; sys.stdout.write(os.name)")`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3OSNAME" >&5
+$as_echo "$PY3OSNAME" >&6; }
+
+ if test x"$PY3OSNAME" = x"nt"; then
+ # Windows installations are quite different to posix installations
+ # There is no python-config to use
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x prefix" >&5
+$as_echo_n "checking for Python 3.x prefix... " >&6; }
+ PY3PREFIX=`($PYTHON3 -c "import sys; sys.stdout.write(sys.prefix)") 2>/dev/null`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3PREFIX" >&5
+$as_echo "$PY3PREFIX" >&6; }
+ PY3PREFIX=`echo "$PY3PREFIX" | sed -e 's,\\\\,/,g'` # Forward slashes are easier to use and even work on Windows most of the time
+ PYTHON_SO=.pyd
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x header files" >&5
+$as_echo_n "checking for Python 3.x header files... " >&6; }
+ if test -r $PY3PREFIX/include/Python.h; then
+ PY3INCLUDE="-I$PY3PREFIX/include"
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3INCLUDE" >&5
+$as_echo "$PY3INCLUDE" >&6; }
- if test -n "$PYTHON3" -a -n "$PY3CONFIG"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x prefix" >&5
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x library directory" >&5
+$as_echo_n "checking for Python 3.x library directory... " >&6; }
+ if test -d $PY3PREFIX/libs; then
+ PY3LIB=$PY3PREFIX/libs
+ PY3LINKFILE=`ls $PY3LIB/python*.lib | grep "python[0-9][0-9]\.lib"`
+ if test -r "$PY3LINKFILE"; then
+ PY3LINK=-l`basename $PY3LINKFILE | sed -e 's/\.lib$//'`
+ else
+ PY3LIB=
+ fi
+ fi
+ if test -z "$PY3LIB"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: Not found" >&5
+$as_echo "Not found" >&6; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3LIB" >&5
+$as_echo "$PY3LIB" >&6; }
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x library" >&5
+$as_echo_n "checking for Python 3.x library... " >&6; }
+ if test -z "$PY3LINK"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: Not found" >&5
+$as_echo "Not found" >&6; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3LINK" >&5
+$as_echo "$PY3LINK" >&6; }
+ fi
+ elif test -n "$PY3CONFIG"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x prefix" >&5
$as_echo_n "checking for Python 3.x prefix... " >&6; }
- PY3PREFIX=`($PY3CONFIG --prefix) 2>/dev/null`
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3PREFIX" >&5
+ PY3PREFIX=`($PY3CONFIG --prefix) 2>/dev/null`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3PREFIX" >&5
$as_echo "$PY3PREFIX" >&6; }
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x exec-prefix" >&5
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x exec-prefix" >&5
$as_echo_n "checking for Python 3.x exec-prefix... " >&6; }
- PY3EPREFIX=`($PY3CONFIG --exec-prefix) 2>/dev/null`
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3EPREFIX" >&5
+ PY3EPREFIX=`($PY3CONFIG --exec-prefix) 2>/dev/null`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3EPREFIX" >&5
$as_echo "$PY3EPREFIX" >&6; }
- # Note: I could not think of a standard way to get the version string from different versions.
- # This trick pulls it out of the file location for a standard library file.
+ # Note: I could not think of a standard way to get the version string from different versions.
+ # This trick pulls it out of the file location for a standard library file.
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x version" >&5
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x version" >&5
$as_echo_n "checking for Python 3.x version... " >&6; }
- # Need to do this hack since autoconf replaces __file__ with the name of the configure file
- filehack="file__"
- PY3VERSION=`($PYTHON3 -c "import string,operator,os.path; print(operator.getitem(os.path.split(operator.getitem(os.path.split(string.__$filehack),0)),1))")`
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3VERSION" >&5
+ # Need to do this hack since autoconf replaces __file__ with the name of the configure file
+ filehack="file__"
+ PY3VERSION=`($PYTHON3 -c "import string,operator,os.path; print(operator.getitem(os.path.split(operator.getitem(os.path.split(string.__$filehack),0)),1))")`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3VERSION" >&5
$as_echo "$PY3VERSION" >&6; }
- # Find the directory for libraries this is necessary to deal with
- # platforms that can have apps built for multiple archs: e.g. x86_64
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x lib dir" >&5
+ # Find the directory for libraries this is necessary to deal with
+ # platforms that can have apps built for multiple archs: e.g. x86_64
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x lib dir" >&5
$as_echo_n "checking for Python 3.x lib dir... " >&6; }
- PY3LIBDIR=`($PYTHON3 -c "import sys; print(sys.lib)") 2>/dev/null`
- if test -z "$PY3LIBDIR"; then
- # some dists don't have sys.lib so the best we can do is assume lib
- PY3LIBDIR="lib"
- fi
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3LIBDIR" >&5
+ PY3LIBDIR=`($PYTHON3 -c "import sys; print(sys.lib)") 2>/dev/null`
+ if test -z "$PY3LIBDIR"; then
+ # some dists don't have sys.lib so the best we can do is assume lib
+ PY3LIBDIR="lib"
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3LIBDIR" >&5
$as_echo "$PY3LIBDIR" >&6; }
- # Set the include directory
+ # Set the include directory
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x header files" >&5
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x header files" >&5
$as_echo_n "checking for Python 3.x header files... " >&6; }
- PY3INCLUDE=`($PY3CONFIG --includes) 2>/dev/null`
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3INCLUDE" >&5
+ PY3INCLUDE=`($PY3CONFIG --includes) 2>/dev/null`
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3INCLUDE" >&5
$as_echo "$PY3INCLUDE" >&6; }
- # Set the library directory blindly. This probably won't work with older versions
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x library" >&5
-$as_echo_n "checking for Python 3.x library... " >&6; }
- dirs="$PY3VERSION/config $PY3VERSION/$PY3LIBDIR python/$PY3LIBDIR"
- for i in $dirs; do
- if test -d $PY3EPREFIX/$PY3LIBDIR/$i; then
- PY3LIB="$PY3EPREFIX/$PY3LIBDIR/$i"
- break
- fi
- done
- if test -z "$PY3LIB"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: Not found" >&5
+ # Set the library directory blindly. This probably won't work with older versions
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x library directory" >&5
+$as_echo_n "checking for Python 3.x library directory... " >&6; }
+ dirs="$PY3VERSION/config $PY3VERSION/$PY3LIBDIR python/$PY3LIBDIR"
+ for i in $dirs; do
+ if test -d $PY3EPREFIX/$PY3LIBDIR/$i; then
+ PY3LIB="$PY3EPREFIX/$PY3LIBDIR/$i"
+ break
+ fi
+ done
+ if test -z "$PY3LIB"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: Not found" >&5
$as_echo "Not found" >&6; }
- else
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3LIB" >&5
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3LIB" >&5
$as_echo "$PY3LIB" >&6; }
- fi
+ fi
+
+ PY3LINK="-l$PY3VERSION"
- PY3LINK="-l$PY3VERSION"
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python 3.x library" >&5
+$as_echo_n "checking for Python 3.x library... " >&6; }
+ if test -z "$PY3LINK"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: Not found" >&5
+$as_echo "Not found" >&6; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PY3LINK" >&5
+$as_echo "$PY3LINK" >&6; }
+ fi
+ fi
fi
# Cygwin (Windows) needs the library for dynamic linking
case $host in
*-*-cygwin* | *-*-mingw*)
- PYTHON3DYNAMICLINKING="-L$PYLIB $PY3LINK"
+ PYTHON3DYNAMICLINKING="-L$PY3LIB $PY3LINK"
DEFS="-DUSE_DL_IMPORT $DEFS"
;;
*)PYTHON3DYNAMICLINKING="";;
esac
-fi
-
-
-
-
-#----------------------------------------------------------------
-# Look for Perl5
-#----------------------------------------------------------------
-
-PERLBIN=
-# Check whether --with-perl5 was given.
-if test "${with_perl5+set}" = set; then :
- withval=$with_perl5; PERLBIN="$withval"
+ for ac_prog in pep8
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_PEP8+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$PEP8"; then
+ ac_cv_prog_PEP8="$PEP8" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_PEP8="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+PEP8=$ac_cv_prog_PEP8
+if test -n "$PEP8"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PEP8" >&5
+$as_echo "$PEP8" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$PEP8" && break
+done
+
+fi
+
+#----------------------------------------------------------------
+# Look for Perl5
+#----------------------------------------------------------------
+
+PERLBIN=
+
+
+# Check whether --with-perl5 was given.
+if test "${with_perl5+set}" = set; then :
+ withval=$with_perl5; PERLBIN="$withval"
else
- PERLBIN=yes
+ PERLBIN="$alllang_default"
fi
# First, check for "--without-perl5" or "--with-perl5=no".
-if test x"${PERLBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${PERLBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Perl5" >&5
$as_echo "$as_me: Disabling Perl5" >&6;}
PERL=
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_PERL="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Perl5 header files" >&5
$as_echo_n "checking for Perl5 header files... " >&6; }
if test -n "$PERL"; then
- PERL5DIR=`($PERL -e 'use Config; print $Config{archlib}, "\n";') 2>/dev/null`
+ PERL5DIR=`($PERL -MConfig -le 'print $Config{archlibexp}') 2>/dev/null`
if test -n "$PERL5DIR" ; then
dirs="$PERL5DIR $PERL5DIR/CORE"
PERL5EXT=none
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PERL5LDFLAGS" >&5
$as_echo "$PERL5LDFLAGS" >&6; }
fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Perl5 Test::More module" >&5
+$as_echo_n "checking for Perl5 Test::More module... " >&6; } # For test-suite
+ PERL5TESTMORE=`($PERL -e 'use Test::More; print "good";') 2>/dev/null`
+ if test -z "$PERL5TESTMORE" ; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+$as_echo "not found" >&6; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
+$as_echo "found" >&6; }
+ fi
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unable to determine perl5 configuration" >&5
$as_echo "unable to determine perl5 configuration" >&6; }
if test "${with_octave+set}" = set; then :
withval=$with_octave; OCTAVEBIN="$withval"
else
- OCTAVEBIN=yes
+ OCTAVEBIN="$alllang_default"
fi
# First, check for "--without-octave" or "--with-octave=no".
-if test x"${OCTAVEBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${OCTAVEBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Octave" >&5
$as_echo "$as_me: Disabling Octave" >&6;}
OCTAVE=
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_path_OCTAVE="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
if test -n "$OCTAVE"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for mkoctfile" >&5
$as_echo_n "checking for mkoctfile... " >&6; }
- mkoctfile="`dirname ${OCTAVE}`/mkoctfile"
+ mkoctfile="$(dirname $OCTAVE)/$(basename $OCTAVE | sed -e 's/octave/mkoctfile/')"
if test -x "${mkoctfile}"; then :
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${mkoctfile}" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Octave preprocessor flags" >&5
$as_echo_n "checking for Octave preprocessor flags... " >&6; }
OCTAVE_CPPFLAGS=
- for n in CPPFLAGS INCFLAGS; do
- OCTAVE_CPPFLAGS="${OCTAVE_CPPFLAGS} "`${mkoctfile} -p $n`
+ for var in CPPFLAGS INCFLAGS ALL_CXXFLAGS; do
+ for flag in `env - ${mkoctfile} -p ${var}`; do
+ case ${flag} in
+ -D*|-I*) OCTAVE_CPPFLAGS="${OCTAVE_CPPFLAGS} ${flag}";;
+ *) ;;
+ esac
+ done
done
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCTAVE_CPPFLAGS" >&5
$as_echo "$OCTAVE_CPPFLAGS" >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Octave compiler flags" >&5
$as_echo_n "checking for Octave compiler flags... " >&6; }
OCTAVE_CXXFLAGS=
- for n in ALL_CXXFLAGS; do
- OCTAVE_CXXFLAGS="${OCTAVE_CXXFLAGS} "`${mkoctfile} -p $n`
+ for var in ALL_CXXFLAGS; do
+ for flag in `env - ${mkoctfile} -p ${var}`; do
+ case ${flag} in
+ -g*|-W*) OCTAVE_CXXFLAGS="${OCTAVE_CXXFLAGS} ${flag}";;
+ *) ;;
+ esac
+ done
done
+ save_CXXFLAGS="${CXXFLAGS}"
+ CXXFLAGS="-Werror -O0"
+ # On IRIX 5.3, sys/types and inttypes.h are conflicting.
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+ inttypes.h stdint.h unistd.h
+do :
+ as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
+"
+if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
+ cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+ $ac_includes_default
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+ OCTAVE_CXXFLAGS="${OCTAVE_CXXFLAGS} -O0"
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ CXXFLAGS="${save_CXXFLAGS}"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCTAVE_CXXFLAGS" >&5
$as_echo "$OCTAVE_CXXFLAGS" >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Octave linker flags" >&5
$as_echo_n "checking for Octave linker flags... " >&6; }
OCTAVE_LDFLAGS=
- for n in RDYNAMIC_FLAG LFLAGS RLD_FLAG OCTAVE_LIBS LIBS; do
- OCTAVE_LDFLAGS="${OCTAVE_LDFLAGS} "`${mkoctfile} -p $n`
+ for var in RDYNAMIC_FLAG LFLAGS RLD_FLAG OCTAVE_LIBS LIBS; do
+ OCTAVE_LDFLAGS="${OCTAVE_LDFLAGS} "`env - ${mkoctfile} -p ${var}`
done
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCTAVE_LDFLAGS" >&5
$as_echo "$OCTAVE_LDFLAGS" >&6; }
for octave_opt in --silent --norc --no-history --no-window-system; do
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if Octave option '${octave_opt}' is supported" >&5
$as_echo_n "checking if Octave option '${octave_opt}' is supported... " >&6; }
- octave_out=`${OCTAVE} ${octave_opt} /dev/null 2>&1 | sed -n '1{/unrecognized/p}'`
+ octave_out=`${OCTAVE} ${octave_opt} /dev/null 2>&1 | sed -n '1p' | sed -n '/unrecognized/p'`
if test "x${octave_out}" = x; then :
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
#----------------------------------------------------------------
+# Look for Scilab
+#----------------------------------------------------------------
+
+
+# Check whether --with-scilab was given.
+if test "${with_scilab+set}" = set; then :
+ withval=$with_scilab; SCILABBIN="$withval"
+else
+ SCILABBIN="$alllang_default"
+fi
+
+
+# Check whether --with-scilab-inc was given.
+if test "${with_scilab_inc+set}" = set; then :
+ withval=$with_scilab_inc; SCILABINCDIR="$withval"
+else
+ SCILABINCDIR=""
+fi
+
+
+# First, check for "--without-scilab" or "--with-scilab=no".
+if test x"${SCILABBIN}" = xno; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Scilab" >&5
+$as_echo "$as_me: Disabling Scilab" >&6;}
+ SCILAB=
+else
+ # Check for Scilab executable
+ if test "x$SCILABBIN" = xyes; then
+ for ac_prog in scilab
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_SCILAB+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$SCILAB"; then
+ ac_cv_prog_SCILAB="$SCILAB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_SCILAB="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+SCILAB=$ac_cv_prog_SCILAB
+if test -n "$SCILAB"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SCILAB" >&5
+$as_echo "$SCILAB" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$SCILAB" && break
+done
+
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for scilab" >&5
+$as_echo_n "checking for scilab... " >&6; }
+ if test -f "$SCILABBIN"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SCILABBIN" >&5
+$as_echo "$SCILABBIN" >&6; }
+ SCILAB="$SCILABBIN"
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+$as_echo "not found" >&6; }
+ fi
+ fi
+
+ if test -n "$SCILAB"; then
+ # Check for Scilab version (needs api_scilab so needs version 5.3.3 or higher)
+ SCILAB_FULL_VERSION=`$SCILAB -version | head -1 | sed -e 's|Scilab version \"\(.*\)\"|\1|g'`
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking Scilab version is 5.3.3 or higher" >&5
+$as_echo_n "checking Scilab version is 5.3.3 or higher... " >&6; }
+ SCILAB_MAJOR_VERSION=`echo $SCILAB_FULL_VERSION | cut -d. -f1`
+ SCILAB_MINOR_VERSION=`echo $SCILAB_FULL_VERSION | cut -d. -f2`
+ SCILAB_MAINTENANCE_VERSION=`echo $SCILAB_FULL_VERSION | cut -d. -f3`
+ SCILAB_VERSION="$SCILAB_MAJOR_VERSION$SCILAB_MINOR_VERSION$SCILAB_MAINTENANCE_VERSION"
+
+ if test $SCILAB_VERSION -ge 533; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+ SCILAB=
+ fi
+
+ if test -n "$SCILAB"; then
+ # Set Scilab startup options depending on version
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Scilab startup options" >&5
+$as_echo_n "checking for Scilab startup options... " >&6; }
+ SCILABOPT="-nwni -nb"
+ if test $SCILAB_VERSION -ge 540; then
+ SCILABOPT+=" -noatomsautoload"
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SCILABOPT" >&5
+$as_echo "$SCILABOPT" >&6; }
+
+ # Check for Scilab header files
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Scilab header files" >&5
+$as_echo_n "checking for Scilab header files... " >&6; }
+ if test "$SCILABINCDIR" != ""; then
+ dirs="$SCILABINCDIR"
+ elif test -n "$PKGCONFIG"; then
+ dirs=`$PKGCONFIG scilab --cflags-only-I | sed -e 's/-I//g'`
+ else
+ dirs=""
+ fi
+ for i in $dirs; do
+ if test -r $i/api_scilab.h; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $i" >&5
+$as_echo "$i" >&6; }
+ SCILABINCLUDE="-I$i"
+ break
+ fi
+ if test -r $i/scilab/api_scilab.h; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $i/scilab" >&5
+$as_echo "$i/scilab" >&6; }
+ SCILABINCLUDE="-I$i/scilab"
+ break
+ fi
+ done
+ if test "$SCILABINCLUDE" = "" ; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+$as_echo "not found" >&6; }
+ SCILAB=
+ fi
+ fi
+ fi
+fi
+
+
+
+
+
+
+#----------------------------------------------------------------
# Look for java
#----------------------------------------------------------------
if test "${with_java+set}" = set; then :
withval=$with_java; JAVABIN="$withval"
else
- JAVABIN=yes
+ JAVABIN="$alllang_default"
fi
# First, check for "--without-java" or "--with-java=no".
-if test x"${JAVABIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${JAVABIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Java" >&5
$as_echo "$as_me: Disabling Java" >&6;}
JAVA=
else
+case $host in
+ *-*-cygwin*)
+ if test -n "$JAVA_HOME"; then
+ JAVA_HOME=`cygpath --mixed "$JAVA_HOME"`
+ fi
+ ;;
+ *-*-mingw*)
+ if test -n "$JAVA_HOME"; then
+ JAVA_HOME=`${srcdir}/Tools/convertpath -u "$JAVA_HOME"`
+ fi
+ ;;
+ *-*-darwin*)
+ if test -z "$JAVA_HOME" -a -x /usr/libexec/java_home; then
+ JAVA_HOME=`/usr/libexec/java_home`
+ fi
+ JAVA_OSX_STD_INCDIR="/System/Library/Frameworks/JavaVM.framework/Headers"
+ if test -r "$JAVA_OSX_STD_INCDIR/jni.h"; then
+ JAVA_HOME_INCDIR=$JAVA_OSX_STD_INCDIR
+ fi
+ ;;
+esac
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for java JDK" >&5
+$as_echo_n "checking for java JDK... " >&6; }
+if test -n "$JAVA_HOME"; then
+ java_home_ok=1
+ if test -z "$JAVABIN" -a ! -x "$JAVA_HOME/bin/java"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No java executable under JAVA_HOME." >&5
+$as_echo "$as_me: WARNING: No java executable under JAVA_HOME." >&2;}
+ java_home_ok=0
+ fi
+ if test -z "$JAVACBIN" -a ! -x "$JAVA_HOME/bin/javac"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No javac executable under JAVA_HOME." >&5
+$as_echo "$as_me: WARNING: No javac executable under JAVA_HOME." >&2;}
+ java_home_ok=0
+ fi
+
+ if test -z "$JAVA_HOME_INCDIR"; then
+ JAVA_HOME_INCDIR="$JAVA_HOME/include"
+ fi
+ if test -z "$JAVAINCDIR" -a ! -r "$JAVA_HOME_INCDIR/jni.h"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No java headers under JAVA_HOME (does it point to a JDK and not just JRE?)." >&5
+$as_echo "$as_me: WARNING: No java headers under JAVA_HOME (does it point to a JDK and not just JRE?)." >&2;}
+ java_home_ok=0
+ fi
+ if test "$java_home_ok" = 1; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: found (in $JAVA_HOME)" >&5
+$as_echo "found (in $JAVA_HOME)" >&6; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: JAVA_HOME ($JAVA_HOME) is defined but does not point to a complete JDK installation, ignoring it." >&5
+$as_echo "$as_me: WARNING: JAVA_HOME ($JAVA_HOME) is defined but does not point to a complete JDK installation, ignoring it." >&2;}
+ JAVA_HOME=
+ fi
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no (JAVA_HOME is not defined)" >&5
+$as_echo "no (JAVA_HOME is not defined)" >&6; }
+fi
+
if test "x$JAVABIN" = xyes; then
- for ac_prog in java kaffe guavac
+ if test -n "$JAVA_HOME"; then
+ JAVA="$JAVA_HOME/bin/java"
+ else
+ for ac_prog in java kaffe guavac
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_JAVA="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
test -n "$JAVA" && break
done
+ fi
else
JAVA="$JAVABIN"
fi
if test -z "$JAVACBIN"; then
- for ac_prog in javac
+ if test -n "$JAVA_HOME"; then
+ JAVAC="$JAVA_HOME/bin/javac"
+ else
+ for ac_prog in javac
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_JAVAC="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
test -n "$JAVAC" && break
done
+ fi
else
JAVAC="$JAVACBIN"
fi
fi
+JAVAINC=""
if test -z "$JAVAINCDIR" ; then
- JAVAINCDIR="/usr/j2sdk*/include /usr/local/j2sdk*/include /usr/jdk*/include /usr/local/jdk*/include /opt/j2sdk*/include /opt/jdk*/include /usr/java/include /usr/java/j2sdk*/include /usr/java/jdk*/include /usr/local/java/include /opt/java/include /usr/include/java /usr/local/include/java /usr/lib/java/include /usr/lib/jvm/java*/include /usr/include/kaffe /usr/local/include/kaffe /usr/include"
+ if test -n "$JAVA_HOME"; then
+ JAVAINCDIR="$JAVA_HOME_INCDIR"
+ JAVAINC=-I\"$JAVAINCDIR\"
+ else
+ JAVAINCDIR="/usr/j2sdk*/include /usr/local/j2sdk*/include /usr/jdk*/include /usr/local/jdk*/include /opt/j2sdk*/include /opt/jdk*/include /usr/java/include /usr/java/j2sdk*/include /usr/java/jdk*/include /usr/local/java/include /opt/java/include /usr/include/java /usr/local/include/java /usr/lib/java/include /usr/lib/jvm/java*/include /usr/lib64/jvm/java*/include /usr/include/kaffe /usr/local/include/kaffe /usr/include"
- # Add in default installation directory on Windows for Cygwin
- case $host in
- *-*-cygwin* | *-*-mingw*) JAVAINCDIR="c:/Program*Files/Java/jdk*/include d:/Program*Files/Java/jdk*/include c:/j2sdk*/include d:/j2sdk*/include c:/jdk*/include d:/jdk*/include $JAVAINCDIR";;
- *-*-darwin*) JAVAINCDIR="/System/Library/Frameworks/JavaVM.framework/Headers $JAVAINCDIR";;
- *);;
- esac
-fi
+ # Add in default installation directory on Windows for Cygwin
+ case $host in
+ *-*-cygwin* | *-*-mingw*) JAVAINCDIR="c:/Program*Files*/Java/jdk*/include d:/Program*Files*/Java/jdk*/include c:/j2sdk*/include d:/j2sdk*/include c:/jdk*/include d:/jdk*/include $JAVAINCDIR";;
+ *-*-darwin*) JAVAINCDIR="$JAVA_OSX_STD_INCDIR $JAVAINCDIR";;
+ *);;
+ esac
-JAVAINC=""
-for d in $JAVAINCDIR ; do
- if test -r "$d/jni.h" ; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $d" >&5
-$as_echo "$d" >&6; }
- JAVAINCDIR=$d
- JAVAINC=-I\"$d\"
- break
+ for d in $JAVAINCDIR ; do
+ if test -r "$d/jni.h" ; then
+ JAVAINCDIR=$d
+ JAVAINC=-I\"$d\"
+ break
+ fi
+ done
fi
-done
+else
+ if test -r "$JAVAINCDIR/jni.h" ; then
+ JAVAINC=-I\"$JAVAINCDIR\"
+ fi
+fi
if test "$JAVAINC" = "" ; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
$as_echo "not found" >&6; }
else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAINC" >&5
+$as_echo "$JAVAINC" >&6; }
# now look for <arch>/jni_md.h
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for java include file jni_md.h" >&5
$as_echo_n "checking for java include file jni_md.h... " >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
$as_echo "not found" >&6; }
else
- JAVAMDDIR=`dirname "$JAVAMDDIR" | tail -1`
- JAVAINC="${JAVAINC} -I\"$JAVAMDDIR\""
+ JAVAMDDIR=-I\"`dirname "$JAVAMDDIR" | tail -1`\"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAMDDIR" >&5
$as_echo "$JAVAMDDIR" >&6; }
+ JAVAINC="${JAVAINC} ${JAVAMDDIR}"
fi
fi
+case $host in
+*-*-cygwin*)
+ # TODO: Only use this flag if the compiler supports it, later versions of gcc no longer have it
+ GCC_MNO_CYGWIN=" -mno-cygwin"
+ ;;
+*)
+ GCC_MNO_CYGWIN=""
+ ;;
+esac
+
# java.exe on Cygwin requires the Windows standard (Pascal) calling convention as it is a normal Windows executable and not a Cygwin built executable
case $host in
*-*-cygwin* | *-*-mingw*)
if test "$GCC" = yes; then
- JAVADYNAMICLINKING=" -mno-cygwin -mthreads -Wl,--add-stdcall-alias"
- JAVACFLAGS="-mno-cygwin -mthreads"
+ JAVADYNAMICLINKING="$GCC_MNO_CYGWIN -mthreads -Wl,--add-stdcall-alias"
+ JAVACFLAGS="$GCC_MNO_CYGWIN -mthreads"
else
JAVADYNAMICLINKING=""
JAVACFLAGS=""
;;
esac
-# Java on Windows platforms including Cygwin doesn't use libname.dll, rather name.dll when loading dlls
-case $host in
-*-*-cygwin* | *-*-mingw*) JAVALIBRARYPREFIX="";;
-*)JAVALIBRARYPREFIX="lib";;
-esac
+# Java on Windows platforms including Cygwin doesn't use libname.dll, rather name.dll when loading dlls
+case $host in
+*-*-cygwin* | *-*-mingw*) JAVALIBRARYPREFIX="";;
+*)JAVALIBRARYPREFIX="lib";;
+esac
+
+# Java on Mac OS X tweaks
+case $host in
+*-*-darwin*)
+ JAVASO=".jnilib"
+ JAVALDSHARED='$(CC)'
+ JAVACXXSHARED='$(CXX)'
+ ;;
+*)
+ JAVASO=$SO
+ JAVALDSHARED='$(LDSHARED)'
+ JAVACXXSHARED='$(CXXSHARED)'
+ ;;
+esac
+fi
+
+# Quote for spaces in path to executables
+if test -n "$JAVA"; then
+ JAVA=\"$JAVA\"
+fi
+if test -n "$JAVAC"; then
+ JAVAC=\"$JAVAC\"
+fi
+
+# Turned off due to spurious warnings in later versions of openjdk-1.8
+# JAVAFLAGS=-Xcheck:jni
+
+
+
+
+
+
+
+
+
+
+
+
+#----------------------------------------------------------------
+# Look for Javascript
+#----------------------------------------------------------------
+
+# Check whether --with-javascript was given.
+if test "${with_javascript+set}" = set; then :
+ withval=$with_javascript; with_javascript="$withval"
+else
+ with_javascript="$alllang_default"
+fi
+
+
+# First, check for "--without-javascript" or "--with-javascript=no".
+if test x"${with_javascript}" = xno; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Javascript" >&5
+$as_echo "$as_me: Disabling Javascript" >&6;}
+ JAVASCRIPT=
+else
+ JAVASCRIPT=1
+
+ #----------------------------------------------------------------
+ # General Javascript settings shared by JSC and V8
+ #----------------------------------------------------------------
+
+ case $host in
+ *-*-darwin*)
+ JSSO=".dylib"
+ # HACK: didn't manage to get dynamic module loading working with a g++ compiled interpreter
+ JSINTERPRETERCXX='c++'
+ JSINTERPRETERLINKFLAGS='-g -Wl,-search_paths_first -Wl,-headerpad_max_install_names'
+ ;;
+ *)
+ JSSO=$SO
+ JSINTERPRETERCXX='$(CXX)'
+ JSINTERPRETERLINKFLAGS='-ldl'
+ ;;
+ esac
+
+ #----------------------------------------------------------------
+ # Look for Node.js which is the default Javascript engine
+ #----------------------------------------------------------------
+
+ for ac_prog in nodejs node
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_NODEJS+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$NODEJS"; then
+ ac_cv_prog_NODEJS="$NODEJS" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_NODEJS="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+NODEJS=$ac_cv_prog_NODEJS
+if test -n "$NODEJS"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NODEJS" >&5
+$as_echo "$NODEJS" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$NODEJS" && break
+done
+
+
+ if test -n "$NODEJS"; then
+ # node-gyp is needed to run the test-suite/examples
+ for ac_prog in node-gyp
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_NODEGYP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$NODEGYP"; then
+ ac_cv_prog_NODEGYP="$NODEGYP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_NODEGYP="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+NODEGYP=$ac_cv_prog_NODEGYP
+if test -n "$NODEGYP"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NODEGYP" >&5
+$as_echo "$NODEGYP" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$NODEGYP" && break
+done
+
+ if test -z "$NODEGYP"; then
+ NODEJS=
+ fi
+ fi
+
+ #----------------------------------------------------------------
+ # Look for JavascriptCore (Webkit) settings (JSCOREINCDIR, JSCOREDYNAMICLINKING)
+ #----------------------------------------------------------------
+
+ # check for include files
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JavaScriptCore/JavaScript.h" >&5
+$as_echo_n "checking for JavaScriptCore/JavaScript.h... " >&6; }
+
+# Check whether --with-jscoreinc was given.
+if test "${with_jscoreinc+set}" = set; then :
+ withval=$with_jscoreinc; JSCOREINCDIR="$withval"
+else
+ JSCOREINCDIR=
+fi
+
+
+ JSCOREVERSION=
+
+ if test -z "$JSCOREINCDIR"; then
+ JSCOREINCDIR="/usr/include/ /usr/local/include/"
+
+ # Add in default directory for JavaScriptCore headers for Linux and Mac OS X
+ case $host in
+ *-*-linux*)
+ JSCOREINCDIR="/usr/include/webkit-1.0/ /usr/include/webkitgtk-1.0/ /usr/local/include/webkit-1.0/JavaScriptCore/ $JSCOREINCDIR"
+ ;;
+ *-*-darwin*)
+ JSCOREINCDIR="/System/Library/Frameworks/JavaScriptCore.framework/Headers/ $JSCOREINCDIR"
+ ;;
+ *)
+ ;;
+ esac
+ fi
+
+ for d in $JSCOREINCDIR ; do
+ if test -r "$d/JavaScriptCore/JavaScript.h" || test -r "$d/JavaScript.h" ; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $d" >&5
+$as_echo "$d" >&6; }
+ JSCOREINCDIR=$d
+ JSCOREINC=-I\"$d\"
+ break
+ fi
+ done
+
+ if test "$JSCOREINC" = "" ; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+$as_echo "not found" >&6; }
+ fi
+
+ # check for JavaScriptCore/Webkit libraries
+
+# Check whether --with-jscorelib was given.
+if test "${with_jscorelib+set}" = set; then :
+ withval=$with_jscorelib; JSCORELIB="-L$withval"
+else
+ JSCORELIB=
+fi
+
+
+ if test -z "$JSCORELIB" -a -n "$PKGCONFIG"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JavaScriptCore/Webkit library" >&5
+$as_echo_n "checking for JavaScriptCore/Webkit library... " >&6; }
+ if pkg-config javascriptcoregtk-1.0; then
+ JSCORELIB=`$PKGCONFIG --libs javascriptcoregtk-1.0`
+ JSCOREVERSION=`$PKGCONFIG --modversion javascriptcoregtk-1.0`
+ fi
+ if test -z "$JSCORELIB"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+$as_echo "not found" >&6; }
+ JSCENABLED=
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JSCORELIB" >&5
+$as_echo "$JSCORELIB" >&6; }
+ JSCOREDYNAMICLINKING="$JSCORELIB"
+ JSCENABLED=1
+ fi
+ fi
+
+ #----------------------------------------------------------------
+ # Look for V8 settings (JSV8INCDIR, JSV8DYNAMICLINKING)
+ #----------------------------------------------------------------
+
+ # check for include files
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for V8 Javascript v8.h" >&5
+$as_echo_n "checking for V8 Javascript v8.h... " >&6; }
+
+# Check whether --with-jsv8inc was given.
+if test "${with_jsv8inc+set}" = set; then :
+ withval=$with_jsv8inc; JSV8INCDIR="$withval"
+fi
+
+
+ # if not include dir is specified we try to find
+ if test -z "$JSV8INCDIR"; then
+ # Add in default directory for JavaScriptCore headers for Linux and Mac OS X
+ case $host in
+ *-*-linux*)
+ JSV8INCDIR="/usr/include /usr/local/include/ $JSV8INCDIR"
+ ;;
+ *-*-darwin*)
+ JSV8INCDIR="$JSV8INCDIR"
+ ;;
+ *)
+ ;;
+ esac
+ fi
+
+ for d in $JSV8INCDIR ; do
+ if test -r "$d/v8.h" ; then
+ JSV8INCDIR=$d
+ JSV8INC=-I\"$d\"
+ break
+ fi
+ done
+
+ if test "$JSV8INC" = "" ; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+$as_echo "not found" >&6; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JSV8INCDIR" >&5
+$as_echo "$JSV8INCDIR" >&6; }
+ fi
+
+ # check for V8 library
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for V8 Javascript library" >&5
+$as_echo_n "checking for V8 Javascript library... " >&6; }
-# Java on Mac OS X tweaks
-case $host in
-*-*-darwin*)
- JAVASO=".jnilib"
- JAVALDSHARED='$(CC)'
- JAVACXXSHARED='$(CXX)'
+# Check whether --with-jsv8lib was given.
+if test "${with_jsv8lib+set}" = set; then :
+ withval=$with_jsv8lib; JSV8LIBDIR="$withval"
+else
+ JSV8LIB=
+fi
+
+
+ v8libdirs="$JSV8LIBDIR /usr/lib64/ /usr/local/lib64/ /usr/lib/ /usr/local/lib/"
+ for d in $v8libdirs ; do
+ if test -r $d/libv8$JSSO; then
+ JSV8LIBDIR=$d
+ JSV8LIB="-L$d -lv8"
+ break
+ fi
+ done
+
+ if test "$JSV8LIB" = "" ; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+$as_echo "not found" >&6; }
+ JSV8ENABLED=
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JSV8LIBDIR" >&5
+$as_echo "$JSV8LIBDIR" >&6; }
+ JSV8ENABLED=1
+ fi
+
+
+ # linking options
+ case $host in
+ *-*-darwin*)
+ JSV8DYNAMICLINKING="$JSV8LIB"
;;
-*)
- JAVASO=$SO
- JAVALDSHARED='$(LDSHARED)'
- JAVACXXSHARED='$(CXXSHARED)'
+ *-*-linux*)
+ JSV8DYNAMICLINKING="$JSV8LIB"
;;
-esac
+ *)
+ JSV8DYNAMICLINKING=""
+ ;;
+ esac
+
fi
+
+
+
+
+
#----------------------------------------------------------------
# Look for gcj
#----------------------------------------------------------------
if test "${with_gcj+set}" = set; then :
withval=$with_gcj; GCJBIN="$withval"
else
- GCJBIN=yes
+ GCJBIN="$alllang_default"
fi
# First, check for "--without-gcj" or "--with-gcj=no".
-if test x"${GCJBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${GCJBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling GCJ" >&5
$as_echo "$as_me: Disabling GCJ" >&6;}
else
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_GCJ="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_GCJH="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
if test "${with_android+set}" = set; then :
withval=$with_android; ANDROIDBIN="$withval"
else
- ANDROIDBIN=yes
+ ANDROIDBIN="$alllang_default"
fi
# First, check for "--without-android" or "--with-android=no".
-if test x"${ANDROIDBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${ANDROIDBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Android" >&5
$as_echo "$as_me: Disabling Android" >&6;}
ANDROID=
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ANDROID="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ADB="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ANT="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_NDKBUILD="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
withval=$with_guile;
GUILE="$withval"
else
- GUILE=yes
+ GUILE="$alllang_default"
fi
# First, check for "--without-guile" or "--with-guile=no".
-if test x"${GUILE}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${GUILE}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Guile" >&5
$as_echo "$as_me: Disabling Guile" >&6;}
else
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_path_GUILE_CONFIG="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_path_GUILE="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
if test "${with_mzscheme+set}" = set; then :
withval=$with_mzscheme; MZSCHEMEBIN="$withval"
else
- MZSCHEMEBIN=yes
+ MZSCHEMEBIN="$alllang_default"
fi
# First, check for "--without-mzscheme" or "--with-mzscheme=no".
-if test x"${MZSCHEMEBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${MZSCHEMEBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling MzScheme" >&5
$as_echo "$as_me: Disabling MzScheme" >&6;}
MZC=
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_path_MZSCHEME="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_path_MZC="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
if test "${with_ruby+set}" = set; then :
withval=$with_ruby; RUBYBIN="$withval"
else
- RUBYBIN=yes
+ RUBYBIN="$alllang_default"
fi
# First, check for "--without-ruby" or "--with-ruby=no".
-if test x"${RUBYBIN}" = xno -o x"${with_alllang}" = xno ; then
+RUBYSO=$SO
+if test x"${RUBYBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Ruby" >&5
$as_echo "$as_me: Disabling Ruby" >&6;}
RUBY=
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_RUBY="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Ruby header files" >&5
$as_echo_n "checking for Ruby header files... " >&6; }
if test -n "$RUBY"; then
- # Try Ruby1.9 first
+ # Try Ruby1.9+ first
RUBYDIR=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG["rubyhdrdir"] || $rubyhdrdir') 2>/dev/null`
+ RUBYARCHHDRDIR=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG["rubyarchhdrdir"] || $rubyarchhdrdir') 2>/dev/null`
if test x"$RUBYDIR" = x"" || test x"$RUBYDIR" = x"nil"; then
- RUBYDIR=`($RUBY -rmkmf -e 'print Config::CONFIG["archdir"] || $archdir') 2>/dev/null`
+ RUBYDIR=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG["archdir"] || $archdir') 2>/dev/null`
else
RUBYARCH=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG["arch"] || $arch') 2>/dev/null`
fi
if test x"$RUBYDIR" != x""; then
dirs="$RUBYDIR"
- RUBYINCLUDE=none
+ RUBYINCLUDE=
for i in $dirs; do
if test -r $i/ruby.h; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $i" >&5
-$as_echo "$i" >&6; }
- RUBYINCLUDE="-I$i"
+ if test x"$RUBYARCH" = x""; then
+ RUBYINCLUDE="-I$i"
+ elif test -n "$RUBYARCHHDRDIR"; then
+ RUBYINCLUDE="-I$i -I$RUBYARCHHDRDIR"
+ else
+ RUBYINCLUDE="-I$i -I$i/$RUBYARCH"
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUBYINCLUDE" >&5
+$as_echo "$RUBYINCLUDE" >&6; }
break
fi
done
- if test x"$RUBYARCH" != x""; then
- RUBYINCLUDE="-I$RUBYDIR -I$RUBYDIR/$RUBYARCH"
- fi
- if test "$RUBYINCLUDE" = none; then
- RUBYINCLUDE="-I$RUBYDIR"
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not locate ruby.h...using $RUBYINCLUDE" >&5
-$as_echo "could not locate ruby.h...using $RUBYINCLUDE" >&6; }
+ if test x"$RUBYINCLUDE" = x""; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not locate ruby.h" >&5
+$as_echo "could not locate ruby.h" >&6; }
fi
# Find library and path for linking.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Ruby library" >&5
$as_echo_n "checking for Ruby library... " >&6; }
RUBYLIB=""
- rb_libdir=`($RUBY -rrbconfig -e 'print Config::CONFIG["libdir"]') 2>/dev/null`
- rb_bindir=`($RUBY -rrbconfig -e 'print Config::CONFIG["bindir"]') 2>/dev/null`
- dirs="$dirs $rb_libdir $rb_bindir"
+ rb_archlibdir=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG["archlibdir"]') 2>/dev/null`
+ rb_libdir=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG["libdir"]') 2>/dev/null`
+ rb_bindir=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG["bindir"]') 2>/dev/null`
+ dirs="$dirs $rb_archlibdir $rb_libdir $rb_bindir"
- rb_libruby=`($RUBY -rrbconfig -e 'print Config::CONFIG["LIBRUBY_A"]') 2>/dev/null`
+ rb_libruby=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG["LIBRUBY_A"]') 2>/dev/null`
RUBYLINK=`($RUBY -rrbconfig -e '
- c = Config::CONFIG
+ c = RbConfig::CONFIG
if c.has_key? "LIBRUBYARG_STATIC" # 1.8.x
if c["LIBRUBY"] == c["LIBRUBY_A"]
link = c["LIBRUBYARG_STATIC"]
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unable to determine ruby configuration" >&5
$as_echo "unable to determine ruby configuration" >&6; }
- RUBYINCLUDE="-I$RUBYDIR"
- RUBYLIB="$RUBYDIR"
fi
case $host in
*-*-mingw*) ;; # do nothing, the default windows libraries are already included
- *) RUBYLINK="$RUBYLINK `($RUBY -rrbconfig -e 'print Config::CONFIG["LIBS"]') 2>/dev/null`";;
+ *) RUBYLINK="$RUBYLINK `($RUBY -rrbconfig -e 'print RbConfig::CONFIG["LIBS"]') 2>/dev/null`";;
esac
- RUBYCCDLFLAGS=`($RUBY -rrbconfig -e 'print Config::CONFIG["CCDLFLAGS"]') 2>/dev/null`
- RUBYSO=.`($RUBY -rrbconfig -e 'print Config::CONFIG["DLEXT"]') 2>/dev/null`
+ RUBYCCDLFLAGS=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG["CCDLFLAGS"]') 2>/dev/null`
+ RUBYSO=.`($RUBY -rrbconfig -e 'print RbConfig::CONFIG["DLEXT"]') 2>/dev/null`
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: could not figure out how to run ruby" >&5
$as_echo "could not figure out how to run ruby" >&6; }
- RUBYINCLUDE="-I/usr/local/lib/ruby/1.4/arch"
- RUBYLIB="/usr/local/lib/ruby/1.4/arch"
- RUBYLINK="-lruby -lm"
fi
case $host in
if test "${with_php+set}" = set; then :
withval=$with_php; PHPBIN="$withval"
else
- PHPBIN=yes
+ PHPBIN="$alllang_default"
fi
# First, check for "--without-php" or "--with-php=no".
-if test x"${PHPBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${PHPBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling PHP" >&5
$as_echo "$as_me: Disabling PHP" >&6;}
PHP=
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_PHP="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
$as_echo "not found" >&6; }
fi
;;
+ "")
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not find $PHPCONFIG or obtain PHP version from it" >&5
+$as_echo "could not find $PHPCONFIG or obtain PHP version from it" >&6; } ;;
*)
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: found PHP $version, but only PHP 5 is supported" >&5
-$as_echo "found PHP $version, but only PHP 5 is supported" >&6; } ;;
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: found PHP $php_version, but only PHP 5 is supported" >&5
+$as_echo "found PHP $php_version, but only PHP 5 is supported" >&6; } ;;
esac
fi
# Check whether --with-ocaml was given.
if test "${with_ocaml+set}" = set; then :
- withval=$with_ocaml; OCAMLBIN="$withval"
+ withval=$with_ocaml; with_ocaml="$withval"
else
- OCAMLBIN=yes
+ with_ocaml="$alllang_default"
fi
fi
+# Check whether --with-camlp4 was given.
+if test "${with_camlp4+set}" = set; then :
+ withval=$with_camlp4; CAMLP4="$withval"
+else
+ CAMLP4=
+fi
+
+
# First, check for "--without-ocaml" or "--with-ocaml=no".
-if test x"${OCAMLBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${with_ocaml}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling OCaml" >&5
$as_echo "$as_me: Disabling OCaml" >&6;}
- OCAMLBIN=
+ OCAMLC=
else
-
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for Ocaml DL load generator" >&5
$as_echo_n "checking for Ocaml DL load generator... " >&6; }
if test -z "$OCAMLDLGEN"; then
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_OCAMLDLGEN="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
test -n "$OCAMLDLGEN" && break
done
-test -n "$OCAMLDLGEN" || OCAMLDLGEN=":"
fi
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_OCAMLFIND="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
test -n "$OCAMLFIND" && break
done
-test -n "$OCAMLFIND" || OCAMLFIND=":"
fi
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_OCAMLC="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
test -n "$OCAMLC" && break
done
-test -n "$OCAMLC" || OCAMLC=":"
fi
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Ocaml interpreter" >&5
-$as_echo_n "checking for Ocaml interpreter... " >&6; }
- if test "x$OCAMLBIN" = xyes; then
- for ac_prog in ocaml
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Ocaml toplevel creator" >&5
+$as_echo_n "checking for Ocaml toplevel creator... " >&6; }
+ if test -z "$OCAMLMKTOP"; then
+ for ac_prog in ocamlmktop
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_OCAMLBIN+:} false; then :
+if ${ac_cv_prog_OCAMLMKTOP+:} false; then :
$as_echo_n "(cached) " >&6
else
- if test -n "$OCAMLBIN"; then
- ac_cv_prog_OCAMLBIN="$OCAMLBIN" # Let the user override the test.
+ if test -n "$OCAMLMKTOP"; then
+ ac_cv_prog_OCAMLMKTOP="$OCAMLMKTOP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
- ac_cv_prog_OCAMLBIN="$ac_prog"
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_OCAMLMKTOP="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
fi
fi
-OCAMLBIN=$ac_cv_prog_OCAMLBIN
-if test -n "$OCAMLBIN"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLBIN" >&5
-$as_echo "$OCAMLBIN" >&6; }
+OCAMLMKTOP=$ac_cv_prog_OCAMLMKTOP
+if test -n "$OCAMLMKTOP"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLMKTOP" >&5
+$as_echo "$OCAMLMKTOP" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
- test -n "$OCAMLBIN" && break
+ test -n "$OCAMLMKTOP" && break
done
-test -n "$OCAMLBIN" || OCAMLBIN=":"
fi
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Ocaml toplevel creator" >&5
-$as_echo_n "checking for Ocaml toplevel creator... " >&6; }
- if test -z "$OCAMLMKTOP"; then
- for ac_prog in ocamlmktop
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Ocaml Pre-Processor-Pretty-Printer" >&5
+$as_echo_n "checking for Ocaml Pre-Processor-Pretty-Printer... " >&6; }
+ if test -z "$CAMLP4"; then
+ for ac_prog in camlp4
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_OCAMLMKTOP+:} false; then :
+if ${ac_cv_prog_CAMLP4+:} false; then :
$as_echo_n "(cached) " >&6
else
- if test -n "$OCAMLMKTOP"; then
- ac_cv_prog_OCAMLMKTOP="$OCAMLMKTOP" # Let the user override the test.
+ if test -n "$CAMLP4"; then
+ ac_cv_prog_CAMLP4="$CAMLP4" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
- ac_cv_prog_OCAMLMKTOP="$ac_prog"
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_CAMLP4="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
fi
fi
-OCAMLMKTOP=$ac_cv_prog_OCAMLMKTOP
-if test -n "$OCAMLMKTOP"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLMKTOP" >&5
-$as_echo "$OCAMLMKTOP" >&6; }
+CAMLP4=$ac_cv_prog_CAMLP4
+if test -n "$CAMLP4"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAMLP4" >&5
+$as_echo "$CAMLP4" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
- test -n "$OCAMLMKTOP" && break
+ test -n "$CAMLP4" && break
done
-test -n "$OCAMLMKTOP" || OCAMLMKTOP=":"
-
- fi
-
- OCAMLLOC=loc
- if test "$OCAMLC" != ":" ; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Ocaml header files" >&5
-$as_echo_n "checking for Ocaml header files... " >&6; }
- dirs="/usr/lib/ocaml/caml /usr/local/lib/ocaml/caml"
- dir="`$OCAMLC -where 2>/dev/null`"
- if test "$dir"; then
- dirs="$dir/caml $dirs"
- fi
- for i in $dirs; do
- if test -r $i/mlvalues.h; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $i" >&5
-$as_echo "$i" >&6; }
- OCAMLEXT="$i"
- OCAMLINC="-I$OCAMLEXT"
- break
- fi
- done
- if test -z "$OCAMLINC"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-$as_echo "not found" >&6; }
- fi
-
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Ocaml version 3.08.2 or higher" >&5
-$as_echo_n "checking for Ocaml version 3.08.2 or higher... " >&6; }
- OCAMLVER=`$OCAMLC -version | sed -e 's/.*version //g'`
-
- # Split the version into units.
- ver_a="$OCAMLVER"
- ver_b="3.08.2"
- nodots_a=`echo $ver_a | sed -e 's/\./ /g'`
- condition="equal"
- isolate_b_regex='\([0-9]\+\).*'
- for ver_part in $nodots_a ; do
- b_ver_part=`echo "$ver_b" | sed -e 's/'"$isolate_b_regex"'/\1/'`
- if test \( "$ver_part" -lt "$b_ver_part" \) -a \( "x$condition" = "xequal" \) ; then
- condition=less
- elif test \( "$ver_part" -gt "$b_ver_part" \) -a \( "x$condition" = "xequal" \) ; then
- condition=greater
- fi
- isolate_b_regex='[0-9]\+\.'"$isolate_b_regex"
- done
-
- if test "x$condition" = "xequal" ; then
- :
- elif test "x$condition" = "xless" ; then
- :
- elif test "x$condition" = "xgreater" ; then
- OCAMLLOC=_loc
- fi
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OCAMLVER" >&5
-$as_echo "$OCAMLVER" >&6; }
fi
fi # Disabling ocaml
-export OCAMLLOC
-export OCAMLVER
-export OCAMLINC
-export OCAMLBIN
-export OCAMLC
-export OCAMLDLGEN
-export OCAMLFIND
-export OCAMLMKTOP
-
-
-
-
if test "${with_pike+set}" = set; then :
withval=$with_pike; PIKEBIN="$withval"
else
- PIKEBIN=yes
+ PIKEBIN="$alllang_default"
fi
# First, check for "--without-pike" or "--with-pike=no".
-if test x"${PIKEBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${PIKEBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Pike" >&5
$as_echo "$as_me: Disabling Pike" >&6;}
PIKEBIN=
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_PIKE="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_PIKECONFIG="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
if test "${with_chicken+set}" = set; then :
withval=$with_chicken; CHICKENBIN="$withval"
else
- CHICKENBIN=yes
+ CHICKENBIN="$alllang_default"
fi
# First, check for "--without-chicken" or "--with-chicken=no".
-if test x"${CHICKENBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${CHICKENBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling CHICKEN" >&5
$as_echo "$as_me: Disabling CHICKEN" >&6;}
else
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CHICKEN="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CHICKEN_CSC="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CHICKEN_CSI="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
if test "${with_csharp+set}" = set; then :
withval=$with_csharp; with_csharp="$withval"
else
- with_csharp=yes
+ with_csharp="$alllang_default"
fi
# First, check for "--without-csharp" or "--with-csharp=no".
-if test x"${with_csharp}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${with_csharp}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling CSharp" >&5
$as_echo "$as_me: Disabling CSharp" >&6;}
CSHARPCOMPILER=
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CSHARPCOMPILER="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CSHARPCOMPILER="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CSHARPCOMPILER="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
CSHARPCOMPILER="$CSHARPCOMPILERBIN"
fi
-CSHARPPATHSEPARATOR="/"
-CSHARPCYGPATH_W=echo
+CSHARPCONVERTPATH="Tools/convertpath -u"
if test -z "$CSHARPBIN" ; then
CSHARPCILINTERPRETER=""
CSHARPCILINTERPRETER_FLAGS=""
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CSHARPCILINTERPRETER="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
echo "mcs is not a working Mono C# compiler"
fi
fi
- if test "mcs" = "$CSHARPCOMPILER" || test "gmcs" = "$CSHARPCOMPILER"; then
+ if test "mcs" = "$CSHARPCOMPILER" || test "gmcs" = "$CSHARPCOMPILER" || test "mono-csc" = "$CSHARPCOMPILER"; then
for ac_prog in mono
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CSHARPCILINTERPRETER="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
CSHARPCILINTERPRETER_FLAGS="--debug"
else
if test "csc" = "$CSHARPCOMPILER"; then
- CSHARPPATHSEPARATOR="\\\\"
- CSHARPCYGPATH_W='cygpath -w'
+ CSHARPCONVERTPATH="Tools/convertpath -w"
fi
fi
fi
case $host in
*-*-cygwin* | *-*-mingw*)
if test "$GCC" = yes; then
- CSHARPDYNAMICLINKING=" -mno-cygwin -mthreads -Wl,--add-stdcall-alias"
- CSHARPCFLAGS="-mno-cygwin -mthreads"
+ CSHARPDYNAMICLINKING="$GCC_MNO_CYGWIN -mthreads -Wl,--add-stdcall-alias"
+ CSHARPCFLAGS="$GCC_MNO_CYGWIN -mthreads"
else
CSHARPDYNAMICLINKING=""
CSHARPCFLAGS=""
- # Is this going to be used?
if test "${with_lua+set}" = set; then :
withval=$with_lua; LUABIN="$withval"
else
- LUABIN=yes
+ LUABIN="$alllang_default"
fi
# First, check for "--without-lua" or "--with-lua=no".
-if test x"${LUABIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${LUABIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Lua" >&5
$as_echo "$as_me: Disabling Lua" >&6;}
else
# The search order should match the include-file and library search
# orders below (a Lua shared library built for one version may not
# work with a Lua binary of a different version).
- for ac_prog in lua5.2 lua5.1 lua
+ for ac_prog in lua5.4 lua5.3 lua5.2 lua5.1 lua
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_path_LUABIN="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
# check version: we need Lua 5.x
if test "$LUABIN"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking Lua version" >&5
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking Lua version" >&5
$as_echo_n "checking Lua version... " >&6; }
- # if version 5.x
- LUAV5=`$LUABIN -e 'if string.sub(_VERSION,5,5)=="5" then print "1" end'`
- # if not version 5.0
- LUAV51=`$LUABIN -e 'if string.sub(_VERSION,5,7)~="5.0" then print "1" end'`
+ # if version 5.x
+ LUAV5=`$LUABIN -e 'if string.sub(_VERSION,5,5)=="5" then print "1" end'`
+ # if not version 5.0
+ LUAV51=`$LUABIN -e 'if string.sub(_VERSION,5,7)~="5.0" then print "1" end'`
- if test -z "$LUAV5"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Not Lua 5.x" >&5
+ if test -z "$LUAV5"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Not Lua 5.x" >&5
$as_echo "$as_me: WARNING: Not Lua 5.x" >&2;}
- LUABIN=""
- elif test -z "$LUAV51"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: Lua 5.0.x" >&5
+ LUABIN=""
+ elif test -z "$LUAV51"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: Lua 5.0.x" >&5
$as_echo "Lua 5.0.x" >&6; }
- else
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: Lua 5.1 or later" >&5
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: Lua 5.1 or later" >&5
$as_echo "Lua 5.1 or later" >&6; }
- fi
+ fi
fi
if test "$LUABIN"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether Lua dynamic loading is enabled" >&5
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether Lua dynamic loading is enabled" >&5
$as_echo_n "checking whether Lua dynamic loading is enabled... " >&6; }
- # using Lua to check Lua
- # lua 5.0 & 5.1 have different fn names
- if test -z "$LUAV51"; then
- LUADYNAMICLOADLIB=`$LUABIN -e '_,_,c=loadlib("no_such_lib","") if c~="absent" then print "1" end'`
- else
- LUADYNAMICLOADLIB=`$LUABIN -e '_,_,c=package.loadlib("no_such_lib","") if c~="absent" then print "1" end'`
- fi
+ # using Lua to check Lua
+ # lua 5.0 & 5.1 have different fn names
+ if test -z "$LUAV51"; then
+ LUADYNAMICLOADLIB=`$LUABIN -e '_,_,c=loadlib("no_such_lib","") if c~="absent" then print "1" end'`
+ else
+ LUADYNAMICLOADLIB=`$LUABIN -e '_,_,c=package.loadlib("no_such_lib","") if c~="absent" then print "1" end'`
+ fi
- if test -z "$LUADYNAMICLOADLIB"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+ if test -z "$LUADYNAMICLOADLIB"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
- else
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
- fi
-fi
+ fi
-# look for the header files & set LUAFLAGS accordingly
-# will clear LUABIN if not present
-if test -n "$LUAINCLUDE"; then
- as_ac_File=`$as_echo "ac_cv_file_$LUAINCLUDE/lua.h" | $as_tr_sh`
+ # look for the header files & set LUAFLAGS accordingly
+ # will clear LUABIN if not present
+ if test -n "$LUAINCLUDE"; then
+ as_ac_File=`$as_echo "ac_cv_file_$LUAINCLUDE/lua.h" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LUAINCLUDE/lua.h" >&5
$as_echo_n "checking for $LUAINCLUDE/lua.h... " >&6; }
if eval \${$as_ac_File+:} false; then :
LUABIN=
fi
-else
- LUA_OK="1"
- ac_fn_c_check_header_mongrel "$LINENO" "lua.h" "ac_cv_header_lua_h" "$ac_includes_default"
+ else
+ LUA_OK="1"
+ CFLAGS_SAVED=$CFLAGS
+ CFLAGS= # Use empty CFLAGS to avoid failure: "present but cannot be compiled"
+ ac_fn_c_check_header_mongrel "$LINENO" "lua.h" "ac_cv_header_lua_h" "$ac_includes_default"
if test "x$ac_cv_header_lua_h" = xyes; then :
LUAFLAGS=""
else
fi
- # if we didn't get it, going to have to look elsewhere (the hard way)
- if test -z "$LUA_OK"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for lua.h in other locations" >&5
+ CFLAGS=$CFLAGS_SAVED
+ # if we didn't get it, going to have to look elsewhere (the hard way)
+ if test -z "$LUA_OK"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for lua.h in other locations" >&5
$as_echo_n "checking for lua.h in other locations... " >&6; }
- # note: Debian/Ubuntu seem to like /usr/include/lua5.1/lua.h
- # The ordering of the include directories to search should match
- # the ordering of libraries to search in the library test below.
- inc=/usr/include
- dirs="$inc/lua5.2 $inc/lua5.1 $inc/lua51 $inc/lua5.0 $inc/lua50 /usr/local/include"
- for i in $dirs; do
- #echo "$i"
- if test -r $i/lua.h; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $i/lua.h" >&5
+ # note: Debian/Ubuntu seem to like /usr/include/lua5.1/lua.h
+ # The ordering of the include directories to search should match
+ # the ordering of libraries to search in the library test below.
+ inc=/usr/include
+ dirs="$inc/lua5.4 $inc/lua5.3 $inc/lua5.2 $inc/lua5.1 $inc/lua51 $inc/lua5.0 $inc/lua50 /usr/local/include"
+ for i in $dirs; do
+ #echo "$i"
+ if test -r $i/lua.h; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $i/lua.h" >&5
$as_echo "$i/lua.h" >&6; }
- LUAFLAGS="$ISYSTEM$i"
- break
- fi
- done
- if test -z "$LUAFLAGS"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+ LUAFLAGS="$ISYSTEM$i"
+ break
+ fi
+ done
+ if test -z "$LUAFLAGS"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
$as_echo "not found" >&6; }
- LUABIN="" # clear the bin
+ LUABIN="" # clear the bin
+ fi
fi
fi
-fi
-# look for the library files & set LUALINK accordingly
-# will clear LUABIN if not present
-lua_save_LIBS=$LIBS # the code seems to disrupt LIBS, so saving
+ # look for the library files & set LUALINK accordingly
+ # will clear LUABIN if not present
+ lua_save_LIBS=$LIBS # the code seems to disrupt LIBS, so saving
-if test -n "$LUALIB"; then
- as_ac_File=`$as_echo "ac_cv_file_$LUALIB/liblua.a" | $as_tr_sh`
+ if test -n "$LUALIB"; then
+ as_ac_File=`$as_echo "ac_cv_file_$LUALIB/liblua.a" | $as_tr_sh`
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LUALIB/liblua.a" >&5
$as_echo_n "checking for $LUALIB/liblua.a... " >&6; }
if eval \${$as_ac_File+:} false; then :
LUABIN=
fi
-else
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing lua_close" >&5
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing lua_close" >&5
$as_echo_n "checking for library containing lua_close... " >&6; }
if ${ac_cv_search_lua_close+:} false; then :
$as_echo_n "(cached) " >&6
return 0;
}
_ACEOF
-for ac_lib in '' lua lua5.2 lua5.1 lua51 lua5.0 lua50; do
+for ac_lib in '' lua lua5.4 lua5.3 lua5.2 lua5.1 lua51 lua5.0 lua50; do
if test -z "$ac_lib"; then
ac_res="none required"
else
LUABIN=
fi
-fi
+ fi
-# adding lualib for lua 5.0
-if test -z "$LUAV51"; then # extra for lua 5.0
- LUALINK="$LUALINK -llualib"
-fi
+ # adding lualib for lua 5.0
+ if test -z "$LUAV51"; then # extra for lua 5.0
+ LUALINK="$LUALINK -llualib"
+ fi
-LIBS=$lua_save_LIBS # restore LIBS
+ LIBS=$lua_save_LIBS # restore LIBS
+fi
fi # if not disabled
if test "${with_allegrocl+set}" = set; then :
withval=$with_allegrocl; ALLEGROCLBIN="$withval"
else
- ALLEGROCLBIN=yes
+ ALLEGROCLBIN="$alllang_default"
fi
# First, check for "--without-allegrocl" or "--with-allegrocl=no".
-if test x"${ALLEGROCLBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${ALLEGROCLBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Allegro CL" >&5
$as_echo "$as_me: Disabling Allegro CL" >&6;}
ALLEGROCLBIN=
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_path_ALLEGROCLBIN="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
if test "${with_clisp+set}" = set; then :
withval=$with_clisp; CLISPBIN="$withval"
else
- CLISPBIN=yes
+ CLISPBIN="$alllang_default"
fi
# First, check for "--without-clisp" or "--with-clisp=no".
-if test x"${CLISPBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${CLISPBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling CLISP" >&5
$as_echo "$as_me: Disabling CLISP" >&6;}
CLISPBIN=
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_path_CLISPBIN="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
if test "${with_r+set}" = set; then :
withval=$with_r; RBIN="$withval"
else
- RBIN=yes
+ RBIN="$alllang_default"
fi
# First, check for "--without-r" or "--with-r=no".
-if test x"${RBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${RBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling R" >&5
$as_echo "$as_me: Disabling R" >&6;}
RBIN=
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_path_RBIN="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
if test "${with_go+set}" = set; then :
withval=$with_go; GOBIN="$withval"
else
- GOBIN=yes
+ GOBIN="$alllang_default"
fi
-if test x"${GOBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${GOBIN}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling Go" >&5
$as_echo "$as_me: Disabling Go" >&6;}
GO=
GOC=
GO1=false
+ GO12=false
+ GO13=false
+ GO15=false
GOGCC=false
+ GCCGO=
GOOPT=
+ GCCGOOPT=
GOVERSIONOPTION=
else
if test "x$GOBIN" = xyes; then
- for ac_prog in go 6g 8g gccgo
+ for ac_prog in go
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_GO="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
GOGCC=false
+ GCCGO=
GO1=false
+ GO12=false
+ GO13=false
+ GO15=false
GOOPT=
+ GCCGOOPT=
GOVERSIONOPTION=
+
if test -n "$GO" ; then
- if $GO --help 2>/dev/null | grep gccgo >/dev/null 2>&1 ; then
- GOGCC=true
- GOVERSIONOPTION=--version
+ GO1=true
+ GOVERSIONOPTION=version
+ go_version=$($GO $GOVERSIONOPTION | sed -e 's/go version //')
+ case "$go_version" in
+ go1 | go1.[01234]*)
+ GOC=$(sh -c "$(go env) && echo \$GOCHAR")c
+ ;;
+ *)
+ GOC=compile
+ ;;
+ esac
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether go version is too old" >&5
+$as_echo_n "checking whether go version is too old... " >&6; }
+ case $go_version in
+ go1.1* | go1.0* | go1 )
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes - minimum version is 1.2" >&5
+$as_echo "yes - minimum version is 1.2" >&6; }
+ GO=
+ GOOPT="-intgosize 32"
+ ;;
+ *)
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+ case "$(go env GOARCH)" in
+ amd64 | arm64 | ppc64*)
+ GOOPT="-intgosize 64"
+ ;;
+ *)
+ GOOPT="-intgosize 32"
+ ;;
+ esac
+ ;;
+ esac
+ case $go_version in
+ go1.0* | go1 | go1.1*)
+ GOOPT="$GOOPT -use-shlib"
+ ;;
+ go1.2*)
+ GO12=true
+ ;;
+ go1.3* | go1.4*)
+ GO13=true
+ ;;
+ *)
+ GO15=true
+ ;;
+ esac
+ fi
+
+ for ac_prog in gccgo
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_GCCGO+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$GCCGO"; then
+ ac_cv_prog_GCCGO="$GCCGO" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_GCCGO="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+GCCGO=$ac_cv_prog_GCCGO
+if test -n "$GCCGO"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GCCGO" >&5
+$as_echo "$GCCGO" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$GCCGO" && break
+done
+
+
+ if test -n "$GCCGO" ; then
+ if $GCCGO --help 2>/dev/null | grep gccgo >/dev/null 2>&1 ; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether gccgo version is too old" >&5
$as_echo_n "checking whether gccgo version is too old... " >&6; }
- go_version=`$GO $GOVERSIONOPTION | sed -e 's/^0-9* \(0-9.*\) .*$/\1/' -e 's/.//g'`
- if test "$go_version" -lt 470; then
+ go_version=`$GO $GOVERSIONOPTION | sed -n '1p' | sed -e 's/^.* \([0-9.]*\) *$/\1/' -e 's/[.]//g'`
+ if test "x$go_version" = x; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not determine gccgo version" >&5
+$as_echo "could not determine gccgo version" >&6; }
+ GCCGO=
+ elif test "$go_version" -lt 470; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes - minimum version is 4.7.0" >&5
$as_echo "yes - minimum version is 4.7.0" >&6; }
+ GCCGO=
else
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
if test "$go_version" -lt 480; then
- GOOPT="-intgosize 32"
- else
- # The cast to long int works around a bug in the HP C Compiler
+ GCCGOOPT="-intgosize 32"
+ else
+ # The cast to long int works around a bug in the HP C Compiler
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
# This bug is HP SR number 8606223364.
_ACEOF
- if test "$ac_cv_sizeof_void_p" = "8"; then
- GOOPT="-intgosize 64"
- else
- GOOPT="-intgosize 32"
- fi
+ if test "$ac_cv_sizeof_void_p" = "8"; then
+ GCCGOOPT="-intgosize 64"
+ else
+ GCCGOOPT="-intgosize 32"
+ fi
fi
fi
- elif test "`echo $GO | sed -e 's|.*/||'`" = "go"; then
- GO1=true
- GOVERSIONOPTION=version
- GOC=$(sh -c "$(go env) && echo \$GOCHAR")c
- go_version=$($GO $GOVERSIONOPTION | sed -e 's/go version //')
- case $go_version in
- go1.0*) GOOPT="-intgosize 32" ;;
- *) if test "$GOC" = "6c"; then
- GOOPT="-intgosize 64"
- else
- GOOPT="-intgosize 32"
- fi
- ;;
- esac
- else
- GOC=`echo $GO | sed -e 's/g/c/'`
- GOVERSIONOPTION=-V
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether Go ($GO) version is too old" >&5
-$as_echo_n "checking whether Go ($GO) version is too old... " >&6; }
- go_version=`$GO $GOVERSIONOPTION 2>/dev/null | sed -e 's/.*version.* \([0-9]*\).*/\1/'`
- go_min_version=7077
- if test "$go_version" != "" -a "$go_version" -lt $go_min_version; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes - minimum version is $go_min_version" >&5
-$as_echo "yes - minimum version is $go_min_version" >&6; }
- GO=
- else
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
- fi
- GOOPT="-intgosize 32"
fi
fi
fi
+
+
+
+
+
#----------------------------------------------------------------
# Look for D
#----------------------------------------------------------------
if test "${with_d+set}" = set; then :
withval=$with_d; with_d="$withval"
else
- with_d=yes
+ with_d="$alllang_default"
fi
# First, check for "--without-d" or "--with-d=no".
-if test x"${with_d}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${with_d}" = xno; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: Disabling D" >&5
$as_echo "$as_me: Disabling D" >&6;}
D1COMPILER=
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_D1COMPILER="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_D2COMPILER="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
SKIP_PERL5=
-if test -z "$PERL" || test -z "$PERL5EXT" ; then
+if test -z "$PERL" || test -z "$PERL5EXT" || test -z "$PERL5TESTMORE"; then
SKIP_PERL5="1"
fi
SKIP_PYTHON=
-if (test -z "$PYINCLUDE") &&
- (test -z "$PY3INCLUDE") ; then
+if (test -z "$PYINCLUDE" || test -z "$PYLINK") &&
+ (test -z "$PY3INCLUDE" || test -z "$PY3LINK") ; then
SKIP_PYTHON="1"
fi
SKIP_PYTHON3=
-if test -z "$PY3INCLUDE" ; then
+if test -z "$PY3INCLUDE" || test -z "$PY3LINK" ; then
SKIP_PYTHON3="1"
fi
fi
+SKIP_JAVASCRIPT=
+if test -z "$JAVASCRIPT" || ( test -z "$NODEJS" && test -z "$JSCENABLED" && test -z "$JSV8ENABLED" ) ; then
+ SKIP_JAVASCRIPT="1"
+fi
+
SKIP_GUILE=
if test -z "$GUILE" || test -z "$GUILE_LIBS" ; then
SKIP_OCAML=
-if test -z "$OCAMLBIN" || test -z "$OCAMLINC" ; then
+if test -z "$OCAMLC" ; then
SKIP_OCAML="1"
fi
#fi
+SKIP_SCILAB=
+if test -z "$SCILAB"; then
+ SKIP_SCILAB="1"
+fi
+
+
SKIP_GO=
if test -z "$GO" ; then
SKIP_GO="1"
# Miscellaneous
#----------------------------------------------------------------
+ABS_SRCDIR=`(cd ${srcdir} && pwd)`
+
+case $host in
+ *-*-mingw* ) ABS_SRCDIR=`${srcdir}/Tools/convertpath -m $ABS_SRCDIR` ;;
+ *-*-cygwin* ) ABS_SRCDIR=`cygpath --mixed $ABS_SRCDIR` ;;
+esac
# Root directory
-# Translate path for native Windows compilers for use with 'make check'
ROOT_DIR=`pwd`
case $host in
-*-*-cygwin* | *-*-mingw*)
+*-*-cygwin*)
+ # Translate path for native Windows compilers for use with 'make check'
if (cygpath --mixed $ROOT_DIR) >/dev/null 2>/dev/null; then
ROOT_DIR=`cygpath --mixed $ROOT_DIR`
fi
+ ;;
+esac
+
+case $host in
+*-*-cygwin* | *-*-mingw*)
# Extra files generated by some Windows compilers
EXTRA_CLEAN="*.stackdump *.exp *.lib *.pdb *.ilk"
;;
swig_lib="${datadir}/swig/${PACKAGE_VERSION}"
fi
+SWIG_LIB_INSTALL=${swig_lib}
prefix_NONE=
case $build in
- # Windows does not understand unix directories. Convert into a windows directory with drive letter.
- *-*-mingw*) SWIG_LIB_WIN_UNIX=`cmd //c echo $SWIG_LIB | sed -e "s/ *$//"`;; # This echo converts unix to mixed paths. Then zap unexpected trailing space.
- *-*-cygwin*) SWIG_LIB_WIN_UNIX=`cygpath --mixed "$SWIG_LIB"`;;
- *) SWIG_LIB_WIN_UNIX="";;
+ # Windows does not understand unix directories. Convert into a windows directory with drive letter.
+ *-*-mingw*) SWIG_LIB_WIN_UNIX=`${srcdir}/Tools/convertpath -m $SWIG_LIB`;;
+ *-*-cygwin*) SWIG_LIB_WIN_UNIX=`cygpath --mixed "$SWIG_LIB"`;;
+ *) SWIG_LIB_WIN_UNIX="";;
esac
cat >>confdefs.h <<_ACEOF
_ACEOF
-ac_config_files="$ac_config_files Makefile swig.spec Source/Makefile Examples/Makefile Examples/xml/Makefile Examples/test-suite/chicken/Makefile Examples/test-suite/csharp/Makefile Examples/test-suite/d/Makefile Examples/test-suite/guile/Makefile Examples/test-suite/java/Makefile Examples/test-suite/mzscheme/Makefile Examples/test-suite/ocaml/Makefile Examples/test-suite/octave/Makefile Examples/test-suite/perl5/Makefile Examples/test-suite/php/Makefile Examples/test-suite/pike/Makefile Examples/test-suite/python/Makefile Examples/test-suite/ruby/Makefile Examples/test-suite/tcl/Makefile Examples/test-suite/lua/Makefile Examples/test-suite/allegrocl/Makefile Examples/test-suite/clisp/Makefile Examples/test-suite/cffi/Makefile Examples/test-suite/uffi/Makefile Examples/test-suite/r/Makefile Examples/test-suite/go/Makefile Lib/ocaml/swigp4.ml"
+SWIG_LIB_PREINST=$ABS_SRCDIR/Lib
+
+
+SWIG_LIB_SET="env SWIG_LIB=\$(SWIG_LIB_DIR)"
+if test "${srcdir}" = "."; then
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+#ifdef _WIN32
+ yes
+ #endif
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+ $EGREP "yes" >/dev/null 2>&1; then :
+ SWIG_LIB_SET="env SWIG_LIB="
+fi
+rm -f conftest*
+
+fi
+
+
+ac_config_files="$ac_config_files Makefile swig.spec Examples/Makefile Examples/d/example.mk Examples/xml/Makefile Examples/test-suite/errors/Makefile Examples/test-suite/chicken/Makefile Examples/test-suite/csharp/Makefile Examples/test-suite/d/Makefile Examples/test-suite/guile/Makefile Examples/test-suite/java/Makefile Examples/test-suite/javascript/Makefile Examples/test-suite/mzscheme/Makefile Examples/test-suite/ocaml/Makefile Examples/test-suite/octave/Makefile Examples/test-suite/perl5/Makefile Examples/test-suite/php/Makefile Examples/test-suite/pike/Makefile Examples/test-suite/python/Makefile Examples/test-suite/ruby/Makefile Examples/test-suite/scilab/Makefile Examples/test-suite/tcl/Makefile Examples/test-suite/lua/Makefile Examples/test-suite/allegrocl/Makefile Examples/test-suite/clisp/Makefile Examples/test-suite/cffi/Makefile Examples/test-suite/uffi/Makefile Examples/test-suite/r/Makefile Examples/test-suite/go/Makefile Source/Makefile Tools/javascript/Makefile"
ac_config_files="$ac_config_files preinst-swig"
ac_config_files="$ac_config_files CCache/ccache_swig_config.h"
+#--------------------------------------------------------------------
+# Building Examples/ out of source directory
+#--------------------------------------------------------------------
+
+# If building out of source tree, replicate Examples/ source tree in
+# build directory, and copy over Makefiles from source directory.
+# Prefix each Makefile with a header which sets SRCDIR to the relative
+# source directory, and provides a rule for updating the Makefile from
+# its original source.
+ac_config_commands="$ac_config_commands Examples"
+
+
+#--------------------------------------------------------------------
+
cat >confcache <<\_ACEOF
# This file is a shell script that caches the results of configure
# tests run on this system so they can be shared between configure
LTLIBOBJS=$ac_ltlibobjs
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
+$as_echo_n "checking that generated files are newer than configure... " >&6; }
+ if test -n "$am_sleep_pid"; then
+ # Hide warnings about reused PIDs.
+ wait $am_sleep_pid 2>/dev/null
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5
+$as_echo "done" >&6; }
if test -n "$EXEEXT"; then
am__EXEEXT_TRUE=
am__EXEEXT_FALSE='#'
# ... but there are two gotchas:
# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
- # In both cases, we have to default to `cp -p'.
+ # In both cases, we have to default to `cp -pR'.
ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
- as_ln_s='cp -p'
+ as_ln_s='cp -pR'
elif ln conf$$.file conf$$ 2>/dev/null; then
as_ln_s=ln
else
- as_ln_s='cp -p'
+ as_ln_s='cp -pR'
fi
else
- as_ln_s='cp -p'
+ as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null
as_mkdir_p=false
fi
-if test -x / >/dev/null 2>&1; then
- as_test_x='test -x'
-else
- if ls -dL / >/dev/null 2>&1; then
- as_ls_L_option=L
- else
- as_ls_L_option=
- fi
- as_test_x='
- eval sh -c '\''
- if test -d "$1"; then
- test -d "$1/.";
- else
- case $1 in #(
- -*)set "./$1";;
- esac;
- case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
- ???[sx]*):;;*)false;;esac;fi
- '\'' sh
- '
-fi
-as_executable_p=$as_test_x
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+ test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
-This file was extended by swig $as_me 2.0.12, which was
-generated by GNU Autoconf 2.68. Invocation command line was
+This file was extended by swig $as_me 3.0.10, which was
+generated by GNU Autoconf 2.69. Invocation command line was
CONFIG_FILES = $CONFIG_FILES
CONFIG_HEADERS = $CONFIG_HEADERS
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
-swig config.status 2.0.12
-configured by $0, generated by GNU Autoconf 2.68,
+swig config.status 3.0.10
+configured by $0, generated by GNU Autoconf 2.69,
with options \\"\$ac_cs_config\\"
-Copyright (C) 2010 Free Software Foundation, Inc.
+Copyright (C) 2012 Free Software Foundation, Inc.
This config.status script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
if \$ac_cs_recheck; then
- set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+ set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
shift
\$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
CONFIG_SHELL='$SHELL'
"depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
"Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
"swig.spec") CONFIG_FILES="$CONFIG_FILES swig.spec" ;;
- "Source/Makefile") CONFIG_FILES="$CONFIG_FILES Source/Makefile" ;;
"Examples/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/Makefile" ;;
+ "Examples/d/example.mk") CONFIG_FILES="$CONFIG_FILES Examples/d/example.mk" ;;
"Examples/xml/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/xml/Makefile" ;;
+ "Examples/test-suite/errors/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/errors/Makefile" ;;
"Examples/test-suite/chicken/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/chicken/Makefile" ;;
"Examples/test-suite/csharp/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/csharp/Makefile" ;;
"Examples/test-suite/d/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/d/Makefile" ;;
"Examples/test-suite/guile/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/guile/Makefile" ;;
"Examples/test-suite/java/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/java/Makefile" ;;
+ "Examples/test-suite/javascript/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/javascript/Makefile" ;;
"Examples/test-suite/mzscheme/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/mzscheme/Makefile" ;;
"Examples/test-suite/ocaml/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/ocaml/Makefile" ;;
"Examples/test-suite/octave/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/octave/Makefile" ;;
"Examples/test-suite/pike/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/pike/Makefile" ;;
"Examples/test-suite/python/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/python/Makefile" ;;
"Examples/test-suite/ruby/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/ruby/Makefile" ;;
+ "Examples/test-suite/scilab/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/scilab/Makefile" ;;
"Examples/test-suite/tcl/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/tcl/Makefile" ;;
"Examples/test-suite/lua/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/lua/Makefile" ;;
"Examples/test-suite/allegrocl/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/allegrocl/Makefile" ;;
"Examples/test-suite/uffi/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/uffi/Makefile" ;;
"Examples/test-suite/r/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/r/Makefile" ;;
"Examples/test-suite/go/Makefile") CONFIG_FILES="$CONFIG_FILES Examples/test-suite/go/Makefile" ;;
- "Lib/ocaml/swigp4.ml") CONFIG_FILES="$CONFIG_FILES Lib/ocaml/swigp4.ml" ;;
+ "Source/Makefile") CONFIG_FILES="$CONFIG_FILES Source/Makefile" ;;
+ "Tools/javascript/Makefile") CONFIG_FILES="$CONFIG_FILES Tools/javascript/Makefile" ;;
"preinst-swig") CONFIG_FILES="$CONFIG_FILES preinst-swig" ;;
"CCache/ccache_swig_config.h") CONFIG_FILES="$CONFIG_FILES CCache/ccache_swig_config.h" ;;
+ "Examples") CONFIG_COMMANDS="$CONFIG_COMMANDS Examples" ;;
*) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
esac
case $ac_file$ac_mode in
"depfiles":C) test x"$AMDEP_TRUE" != x"" || {
- # Autoconf 2.62 quotes --file arguments for eval, but not when files
+ # Older Autoconf quotes --file arguments for eval, but not when files
# are listed without --file. Let's play safe and only enable the eval
# if we detect the quoting.
case $CONFIG_FILES in
# Strip MF so we end up with the name of the file.
mf=`echo "$mf" | sed -e 's/:.*$//'`
# Check whether this is an Automake generated Makefile or not.
- # We used to match only the files named `Makefile.in', but
+ # We used to match only the files named 'Makefile.in', but
# some people rename them; so instead we look at the file content.
# Grep'ing the first line is not enough: some people post-process
# each Makefile.in and add a new line on top of each file to say so.
continue
fi
# Extract the definition of DEPDIR, am__include, and am__quote
- # from the Makefile without running `make'.
+ # from the Makefile without running 'make'.
DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
test -z "$DEPDIR" && continue
am__include=`sed -n 's/^am__include = //p' < "$mf"`
- test -z "am__include" && continue
+ test -z "$am__include" && continue
am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
- # When using ansi2knr, U may be empty or an underscore; expand it
- U=`sed -n 's/^U = //p' < "$mf"`
# Find all dependency output files, they are included files with
# $(DEPDIR) in their names. We invoke sed twice because it is the
# simplest approach to changing $(DEPDIR) to its actual value in the
# expansion.
for file in `sed -n "
s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
- sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
+ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
# Make sure the directory exists.
test -f "$dirpart/$file" && continue
fdir=`$as_dirname -- "$file" ||
}
;;
"preinst-swig":F) chmod +x preinst-swig ;;
+ "Examples":C)
+ if test "x${srcdir}" != "x." ; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: generating Examples build tree" >&5
+$as_echo "$as_me: generating Examples build tree" >&6;}
+ for mkfile in `cd ${srcdir} && find Examples/ -type f -name Makefile`; do
+ dir=`dirname ${mkfile}`
+ d=${dir}
+ reldir=""
+ while test "x$d" != "x." ; do
+ d=`dirname $d`
+ reldir="${reldir}../"
+ done
+ relsrcdir=${reldir}${srcdir}/
+ as_dir=${dir}; as_fn_mkdir_p
+ cat <<EOF >${mkfile}
+# DO NOT EDIT: instead edit ${relsrcdir}${mkfile}
+# and run (cd ${reldir} && ./config.status) to regenerate
+TOP_BUILDDIR_TO_TOP_SRCDIR = ${srcdir}/
+SRCDIR = ${relsrcdir}${dir}/
+
+EOF
+ cat ${srcdir}/${mkfile} >>${mkfile}
+ done
+ fi
+ ;;
esac
done # for ac_tag
$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
fi
+
+langs=""
+test -n "$SKIP_ALLEGROCL" || langs="${langs}allegrocl "
+test -n "$SKIP_CFFI" || langs="${langs}cffi "
+test -n "$SKIP_CHICKEN" || langs="${langs}chicken "
+test -n "$SKIP_CLISP" || langs="${langs}clisp "
+test -n "$SKIP_CSHARP" || langs="${langs}csharp "
+test -n "$SKIP_D" || langs="${langs}d "
+test -n "$SKIP_GO" || langs="${langs}go "
+test -n "$SKIP_GUILE" || langs="${langs}guile "
+test -n "$SKIP_JAVA" || langs="${langs}java "
+test -n "$SKIP_JAVASCRIPT" || langs="${langs}javascript "
+test -n "$SKIP_LUA" || langs="${langs}lua "
+test -n "$SKIP_MODULA3" || langs="${langs}modula3 "
+test -n "$SKIP_MZSCHEME" || langs="${langs}mzscheme "
+test -n "$SKIP_OCAML" || langs="${langs}ocaml "
+test -n "$SKIP_OCTAVE" || langs="${langs}octave "
+test -n "$SKIP_PERL5" || langs="${langs}perl5 "
+test -n "$SKIP_PHP" || langs="${langs}php "
+test -n "$SKIP_PIKE" || langs="${langs}pike "
+test -n "$SKIP_PYTHON" || langs="${langs}python "
+test -n "$SKIP_R" || langs="${langs}r "
+test -n "$SKIP_RUBY" || langs="${langs}ruby "
+test -n "$SKIP_SCILAB" || langs="${langs}scilab "
+test -n "$SKIP_TCL" || langs="${langs}tcl "
+test -n "$SKIP_UFFI" || langs="${langs}uffi "
+
+echo "
+The SWIG test-suite and examples are configured for the following languages:
+$langs
+"
+
dnl The macros which aren't shipped with the autotools are stored in the
dnl Tools/config directory in .m4 files.
-AC_INIT([swig],[2.0.12],[http://www.swig.org])
+AC_INIT([swig],[3.0.10],[http://www.swig.org])
dnl NB: When this requirement is increased to 2.60 or later, AC_PROG_SED
dnl definition below can be removed
/* Default language */
#define SWIG_LANG "-tcl"
-/* Deal with Microsofts attempt at deprecating C standard runtime functions */
+/* Deal with attempt by Microsoft to deprecate C standard runtime functions */
#if defined(_MSC_VER)
# define _CRT_SECURE_NO_DEPRECATE
#endif
dnl Checks for header files.
AC_HEADER_STDC
-dnl Checks for types.
-AC_LANG_PUSH([C++])
-AC_CHECK_TYPES([bool])
-AC_LANG_POP([C++])
-
dnl Look for popen
AC_ARG_WITH(popen, AS_HELP_STRING([--without-popen], [Disable popen]), with_popen="$withval")
if test x"${with_popen}" = xno ; then
echo ""
AC_PROG_YACC
-AC_PROG_RANLIB
-AC_CHECK_PROGS(AR, ar aal, ar)
-AC_SUBST(AR)
-AC_CHECK_PROGS(YODL2MAN, yodl2man)
-AC_CHECK_PROGS(YODL2HTML, yodl2html)
-
-if test -n "$YODL2MAN"; then
- AC_MSG_CHECKING([yodl2man version >= 2.02])
- yodl_version=`$YODL2MAN --version 2>&1 | grep 'yodl version' | sed 's/.*\([0-9][0-9]*\.[0-9][0-9]*\.*[0-9]*\).*/\1/g'`
- AX_COMPARE_VERSION([$yodl_version],[ge],[2.02], [AC_MSG_RESULT([yes])], [AC_MSG_RESULT([no - $yodl_version found])])
-fi
-
-if test -n "$YODL2HTML"; then
- AC_MSG_CHECKING([yodl2html version >= 2.02])
- yodl_version=`$YODL2HTML --version 2>&1 | grep 'yodl version' | sed 's/.*\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*/\1/g'`
- AX_COMPARE_VERSION([$yodl_version],[ge],[2.02], [AC_MSG_RESULT([yes])], [AC_MSG_RESULT([no - $yodl_version found])])
-fi
echo ""
echo "Checking for installed target languages and other information in order to compile and run"
then CCSHARED="-fpic"
else CCSHARED="+z"
fi;;
+ s390x*-*-*) CCSHARED="-fpic" ;;
+ s390*-*-*) CCSHARED="-fPIC" ;;
*-*-linux*) CCSHARED="-fpic";;
*-*-freebsd* | *-*-openbsd*) CCSHARED="-fpic";;
*-*-netbsd*) CCSHARED="-fPIC";;
AC_MSG_RESULT($LINKFORSHARED)
# Optional CFLAGS used to silence/enhance compiler warnings on some platforms.
-AC_MSG_CHECKING(PLATFLAGS)
+AC_MSG_CHECKING(PLATCFLAGS)
case $host in
*-*-solaris*) if test "$GCC" = yes
- then PLATFLAGS=
- else PLATFLAGS=
- # else PLATFLAGS="-errtags=yes" # Need more work as C examples use ld for linking
+ then PLATCFLAGS=
+ else PLATCFLAGS=
+ # else PLATCFLAGS="-errtags=yes" # Need more work as C examples use ld for linking
+ fi;;
+ *) PLATCFLAGS=
+esac
+AC_MSG_RESULT($PLATCFLAGS)
+
+# Add switch if necessary to enable C++11 support - just for tests
+AC_ARG_ENABLE([cpp11-testing], AS_HELP_STRING([--enable-cpp11-testing], [enable C++11 testing if supported by compiler (default disabled)]), [enable_cpp11_testing=$enableval], [enable_cpp11_testing=no])
+AC_MSG_CHECKING([whether to enable C++11 testing])
+AC_MSG_RESULT([$enable_cpp11_testing])
+
+PLATCXXFLAGS="$PLATCFLAGS"
+if test x"$enable_cpp11_testing" = xyes; then
+ AC_LANG_PUSH([C++])
+ CXXFLAGS_SAVED=$CXXFLAGS
+ CXXFLAGS=
+ AX_CXX_COMPILE_STDCXX_11([noext], [nostop])
+ CXXFLAGS=$CXXFLAGS_SAVED
+ AC_LANG_POP([C++])
+ if test x"$CXX11FLAGS" != x; then
+ PLATCXXFLAGS="$CXX11FLAGS $PLATCXXFLAGS"
+ fi
+ AC_MSG_CHECKING([for C++11 enabled compiler])
+ if test x"$HAVE_CXX11_COMPILER" = x; then
+ AC_MSG_RESULT([no])
+ else
+ AC_MSG_RESULT([$HAVE_CXX11_COMPILER])
+ fi
+fi
+
+# On darwin 10.7,10.8,10.9 using clang++, need to ensure using
+# libc++ for tests and examples to run under mono. May affect
+# other language targets as well - problem is a Mac OS X incompatibility
+# between libraries depending on libstdc++ and libc++.
+CLANGXX=
+$CXX -v 2>&1 | grep -i clang >/dev/null && CLANGXX=yes
+case $host in
+ *-*-darwin11* | *-*-darwin12* |*-*-darwin13* ) if test "$CLANGXX" = "yes";
+ then PLATCXXFLAGS="$PLATCXXFLAGS -stdlib=libc++"
fi;;
- *) PLATFLAGS=
+ *) ;;
esac
-AC_MSG_RESULT($PLATFLAGS)
# Set info about shared libraries.
AC_SUBST(SO)
AC_SUBST(CXXSHARED)
AC_SUBST(TRYLINKINGWITHCXX)
AC_SUBST(RPATH)
-AC_SUBST(PLATFLAGS)
+AC_SUBST(PLATCFLAGS)
+AC_SUBST(PLATCXXFLAGS)
+AC_SUBST(HAVE_CXX11_COMPILER)
AC_SUBST(LINKFORSHARED)
# This variation is needed on OS-X because there is no (apparent) consistency in shared library naming.
fi])
#--------------------------------------------------------------------
-# Locate the X11 header files and the X11 library archive. Try
-# the ac_path_x macro first, but if it doesn't find the X stuff
-# (e.g. because there's no xmkmf program) then check through
-# a list of possible directories. Under some conditions the
-# autoconf macro will return an include directory that contains
-# no include files, so double-check its result just to be safe.
+# Target languages
#--------------------------------------------------------------------
-AC_PATH_X
-not_really_there=""
-if test "$no_x" = ""; then
- if test "$x_includes" = ""; then
- AC_TRY_CPP([#include <X11/XIntrinsic.h>], , not_really_there="yes")
- else
- if test ! -r $x_includes/X11/Intrinsic.h; then
- not_really_there="yes"
- fi
- fi
-fi
-if test "$no_x" = "yes" -o "$not_really_there" = "yes"; then
- AC_MSG_CHECKING(for X11 header files)
- XINCLUDES="# no special path needed"
- AC_TRY_CPP([#include <X11/Intrinsic.h>], , XINCLUDES="")
- if test -z "$XINCLUDES"; then
- dirs="/usr/unsupported/include /usr/local/include /usr/X386/include /usr/include/X11R4 /usr/X11R5/include /usr/include/X11R5 /usr/openwin/include /usr/X11/include /usr/sww/include /usr/X11R6/include /usr/include/X11R6"
- for i in $dirs ; do
- if test -r $i/X11/Intrinsic.h; then
- XINCLUDES=" -I$i"
- break
- fi
- done
- fi
- AC_MSG_RESULT($XINCLUDES)
-else
- if test "$x_includes" != ""; then
- XINCLUDES=-I$x_includes
- else
- XINCLUDES="# no special path needed"
- fi
-fi
-if test -z "$XINCLUDES"; then
- AC_MSG_RESULT(couldn't find any!)
- XINCLUDES="# no include files found"
-fi
+AC_ARG_WITH(alllang, AS_HELP_STRING([--without-alllang], [Disable all languages]), with_alllang="$withval")
-if test "$no_x" = yes; then
- AC_MSG_CHECKING(for X11 libraries)
- XLIBSW=
- dirs="/usr/unsupported/lib /usr/local/lib /usr/X386/lib /usr/lib/X11R4 /usr/X11R5/lib /usr/lib/X11R5 /usr/X11R6/lib /usr/lib/X11R6 /usr/openwin/lib /usr/X11/lib /usr/sww/X11/lib"
- for i in $dirs ; do
- if test -r $i/libX11.a -o -r $i/libX11.so -o -r $i/libX11.sl; then
- AC_MSG_RESULT($i)
- XLIBSW="-L$i -lX11"
- break
- fi
- done
+if test "$with_alllang" = "no"; then
+ alllang_default=no
else
- if test "$x_libraries" = ""; then
- XLIBSW=-lX11
- else
- XLIBSW="-L$x_libraries -lX11"
- fi
-fi
-if test -z "$XLIBSW" ; then
- AC_CHECK_LIB(Xwindow, XCreateWindow, XLIBSW=-lXwindow)
-fi
-if test -z "$XLIBSW" ; then
- AC_MSG_RESULT(couldn't find any! Using -lX11.)
- XLIBSW=-lX11
+ alllang_default=yes
fi
-AC_SUBST(XINCLUDES)
-AC_SUBST(XLIBSW)
-
-AC_ARG_WITH(alllang, AS_HELP_STRING([--without-alllang], [Disable all languages]), with_alllang="$withval")
+AC_CHECK_PROGS(PKGCONFIG, [pkg-config])
#--------------------------------------------------------------------
# Look for Tcl
AS_HELP_STRING([--with-tclconfig=path], [Set location of tclConfig.sh]), [with_tclconfig="$withval"], [with_tclconfig=])
AC_ARG_WITH(tcl,
[ --with-tcl=path Set location of Tcl package],[
- TCLPACKAGE="$withval"], [TCLPACKAGE=yes])
+ TCLPACKAGE="$withval"], [TCLPACKAGE="$alllang_default"])
AC_ARG_WITH(tclincl,[ --with-tclincl=path Set location of Tcl include directory],[
TCLINCLUDE="$ISYSTEM$withval"], [TCLINCLUDE=])
AC_ARG_WITH(tcllib,[ --with-tcllib=path Set location of Tcl library directory],[
TCLLIB="-L$withval"], [TCLLIB=])
# First, check for "--without-tcl" or "--with-tcl=no".
-if test x"${TCLPACKAGE}" = xno -o x"${with_alllang}" = xno; then
+if test x"${TCLPACKAGE}" = xno; then
AC_MSG_NOTICE([Disabling Tcl])
else
AC_MSG_CHECKING([for Tcl configuration])
if test -f "${with_tclconfig}/tclConfig.sh" ; then
TCLCONFIG=`(cd ${with_tclconfig}; pwd)`
else
- AC_MSG_ERROR([${with_tcl} directory doesn't contain tclConfig.sh])
+ AC_MSG_ERROR([${with_tcl} directory does not contain tclConfig.sh])
fi
fi
# check in a few common install locations
if test x"${TCLCONFIG}" = x ; then
- for i in `ls -d /usr/lib/ 2>/dev/null` \
- `ls -d -r /usr/lib/tcl*/ 2>/dev/null` \
- `ls -d /usr/local/lib/ 2>/dev/null` \
- `ls -d -r /usr/local/lib/tcl*/ 2>/dev/null` ; do
+ for i in `ls -d -r /usr/lib*/ 2>/dev/null` \
+ `ls -d -r /usr/lib*/tcl*/ 2>/dev/null` \
+ `ls -d -r /usr/local/lib*/ 2>/dev/null` \
+ `ls -d -r /usr/local/lib*/tcl*/ 2>/dev/null` ; do
if test -f $i"tclConfig.sh" ; then
TCLCONFIG=`(cd $i; pwd)`
break
PYINCLUDE=
PYLIB=
+PYLINK=
PYPACKAGE=
AC_ARG_WITH(python, AS_HELP_STRING([--without-python], [Disable Python])
-AS_HELP_STRING([--with-python=path], [Set location of Python executable]),[ PYBIN="$withval"], [PYBIN=yes])
+AS_HELP_STRING([--with-python=path], [Set location of Python executable]),[ PYBIN="$withval"], [PYBIN="$alllang_default"])
# First, check for "--without-python" or "--with-python=no".
-if test x"${PYBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${PYBIN}" = xno; then
AC_MSG_NOTICE([Disabling Python])
else
# First figure out the name of the Python executable
if test "x$PYBIN" = xyes; then
- AC_CHECK_PROGS(PYTHON, [python python2.8 python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 python1.6 python1.5 python1.4])
+ AC_CHECK_PROGS(PYTHON, [python python2.8 python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0])
else
PYTHON="$PYBIN"
fi
+ PYVER=0
if test -n "$PYTHON"; then
+ AC_MSG_CHECKING([for $PYTHON major version number])
+ PYVER=`($PYTHON -c "import sys; sys.stdout.write(sys.version[[0]])") 2>/dev/null`
+ AC_MSG_RESULT($PYVER)
+ if test -z "$PYVER"; then
+ PYVER=0
+ else
+ AC_MSG_CHECKING(for Python os.name)
+ PYOSNAME=`($PYTHON -c "import sys, os; sys.stdout.write(os.name)")`
+ AC_MSG_RESULT($PYOSNAME)
+ fi
+ fi
+
+ if test $PYVER -eq 1 -o $PYVER -eq 2; then
AC_MSG_CHECKING(for Python prefix)
- PYPREFIX=`($PYTHON -c "import sys; print sys.prefix") 2>/dev/null`
+ PYPREFIX=`($PYTHON -c "import sys; sys.stdout.write(sys.prefix)") 2>/dev/null`
AC_MSG_RESULT($PYPREFIX)
AC_MSG_CHECKING(for Python exec-prefix)
- PYEPREFIX=`($PYTHON -c "import sys; print sys.exec_prefix") 2>/dev/null`
+ PYEPREFIX=`($PYTHON -c "import sys; sys.stdout.write(sys.exec_prefix)") 2>/dev/null`
AC_MSG_RESULT($PYEPREFIX)
+ if test x"$PYOSNAME" = x"nt"; then
+ # Windows installations are quite different to posix installations
+ PYPREFIX=`echo "$PYPREFIX" | sed -e 's,\\\\,/,g'` # Forward slashes are easier to use and even work on Windows most of the time
+ PYTHON_SO=.pyd
- # Note: I could not think of a standard way to get the version string from different versions.
- # This trick pulls it out of the file location for a standard library file.
-
- AC_MSG_CHECKING(for Python version)
-
- # Need to do this hack since autoconf replaces __file__ with the name of the configure file
- filehack="file__"
- PYVERSION=`($PYTHON -c "import string,operator,os.path; print operator.getitem(os.path.split(operator.getitem(os.path.split(string.__$filehack),0)),1)")`
- AC_MSG_RESULT($PYVERSION)
-
- # Find the directory for libraries this is necessary to deal with
- # platforms that can have apps built for multiple archs: e.g. x86_64
- AC_MSG_CHECKING(for Python lib dir)
- PYLIBDIR=`($PYTHON -c "import sys; print sys.lib") 2>/dev/null`
- if test -z "$PYLIBDIR"; then
- # Fedora patch Python to add sys.lib, for other distros we assume "lib".
- PYLIBDIR="lib"
- fi
- AC_MSG_RESULT($PYLIBDIR)
+ AC_MSG_CHECKING(for Python header files)
+ if test -r $PYPREFIX/include/Python.h; then
+ PYINCLUDE="-I$PYPREFIX/include"
+ fi
+ AC_MSG_RESULT($PYINCLUDE)
+
+ AC_MSG_CHECKING(for Python library directory)
+ if test -d $PYPREFIX/libs; then
+ PYLIB=$PYPREFIX/libs
+ PYLINKFILE=`ls $PYLIB/python*.lib | grep "python[[0-9]][[0-9]]\.lib"`
+ if test -r "$PYLINKFILE"; then
+ PYLINK=-l`basename $PYLINKFILE | sed -e 's/\.lib$//'`
+ else
+ PYLIB=
+ fi
+ fi
+ else
+ # Note: I could not think of a standard way to get the version string from different versions.
+ # This trick pulls it out of the file location for a standard library file.
+
+ AC_MSG_CHECKING(for Python version)
+
+ # Need to do this hack since autoconf replaces __file__ with the name of the configure file
+ filehack="file__"
+ PYVERSION=`($PYTHON -c "import sys,string,operator,os.path; sys.stdout.write(operator.getitem(os.path.split(operator.getitem(os.path.split(string.__$filehack),0)),1))")`
+ AC_MSG_RESULT($PYVERSION)
+
+ # Find the directory for libraries this is necessary to deal with
+ # platforms that can have apps built for multiple archs: e.g. x86_64
+ AC_MSG_CHECKING(for Python lib dir)
+ PYLIBDIR=`($PYTHON -c "import sys; sys.stdout.write(sys.lib)") 2>/dev/null`
+ if test -z "$PYLIBDIR"; then
+ # Fedora patch Python to add sys.lib, for other distros we assume "lib".
+ PYLIBDIR="lib"
+ fi
+ AC_MSG_RESULT($PYLIBDIR)
- # Set the include directory
+ # Set the include directory
- AC_MSG_CHECKING(for Python header files)
- if test -r $PYPREFIX/include/$PYVERSION/Python.h; then
- PYINCLUDE="-I$PYPREFIX/include/$PYVERSION -I$PYEPREFIX/$PYLIBDIR/$PYVERSION/config"
- fi
- if test -z "$PYINCLUDE"; then
- if test -r $PYPREFIX/include/Py/Python.h; then
- PYINCLUDE="-I$PYPREFIX/include/Py -I$PYEPREFIX/$PYLIBDIR/python/lib"
+ AC_MSG_CHECKING(for Python header files)
+ if test -r $PYPREFIX/include/$PYVERSION/Python.h; then
+ PYINCLUDE="-I$PYPREFIX/include/$PYVERSION -I$PYEPREFIX/$PYLIBDIR/$PYVERSION/config"
fi
+ if test -z "$PYINCLUDE"; then
+ if test -r $PYPREFIX/include/Py/Python.h; then
+ PYINCLUDE="-I$PYPREFIX/include/Py -I$PYEPREFIX/$PYLIBDIR/python/lib"
+ fi
+ fi
+ AC_MSG_RESULT($PYINCLUDE)
+
+ # Set the library directory blindly. This probably won't work with older versions
+ AC_MSG_CHECKING(for Python library directory)
+ dirs="$PYVERSION/config $PYVERSION/$PYLIBDIR python/$PYLIBDIR"
+ for i in $dirs; do
+ if test -d $PYEPREFIX/$PYLIBDIR/$i; then
+ PYLIB="$PYEPREFIX/$PYLIBDIR/$i"
+ break
+ fi
+ done
+
+ PYLINK="-l$PYVERSION"
fi
- AC_MSG_RESULT($PYINCLUDE)
- # Set the library directory blindly. This probably won't work with older versions
- AC_MSG_CHECKING(for Python library)
- dirs="$PYVERSION/config $PYVERSION/$PYLIBDIR python/$PYLIBDIR"
- for i in $dirs; do
- if test -d $PYEPREFIX/$PYLIBDIR/$i; then
- PYLIB="$PYEPREFIX/$PYLIBDIR/$i"
- break
- fi
- done
if test -z "$PYLIB"; then
AC_MSG_RESULT(Not found)
else
AC_MSG_RESULT($PYLIB)
fi
-
- PYLINK="-l$PYVERSION"
+ AC_MSG_CHECKING(for Python library)
+ if test -z "$PYLINK"; then
+ AC_MSG_RESULT(Not found)
+ else
+ AC_MSG_RESULT($PYLINK)
+ fi
fi
# Cygwin (Windows) needs the library for dynamic linking
# Look for Python 3.x
#----------------------------------------------------------------
-# mostly copy & pasted from "Look for Python" section,
-# did some trim, fix and rename
-
PY3INCLUDE=
PY3LIB=
+PY3LINK=
PY3PACKAGE=
AC_ARG_WITH(python3, AS_HELP_STRING([--without-python3], [Disable Python 3.x support])
-AS_HELP_STRING([--with-python3=path], [Set location of Python 3.x executable]),[ PY3BIN="$withval"], [PY3BIN=yes])
+AS_HELP_STRING([--with-python3=path], [Set location of Python 3.x executable]),[ PY3BIN="$withval"], [PY3BIN="$alllang_default"])
# First, check for "--without-python3" or "--with-python3=no".
-if test x"${PY3BIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${PY3BIN}" = xno; then
AC_MSG_NOTICE([Disabling Python 3.x support])
else
- for py_ver in 3 3.6 3.5 3.4 3.3 3.2 3.1 3.0; do
- AC_CHECK_PROGS(PYTHON3, [python$py_ver])
- if test -n "$PYTHON3"; then
- AC_CHECK_PROGS(PY3CONFIG, [$PYTHON3-config])
- if test -n "$PY3CONFIG"; then
- break
- fi
+ if test -z "$PYVER"; then
+ PYVER=0
+ fi
+ if test "x$PY3BIN" = xyes; then
+ if test x"$PYOSNAME" = x"nt" -a $PYVER -ge 3; then
+ PYTHON3="$PYTHON"
+ else
+ for py_ver in 3 3.9 3.8 3.7 3.6 3.5 3.4 3.3 3.2 3.1 3.0 ""; do
+ AC_CHECK_PROGS(PYTHON3, [python$py_ver])
+ if test -n "$PYTHON3"; then
+ AC_CHECK_PROGS(PY3CONFIG, [$PYTHON3-config])
+ if test -n "$PY3CONFIG"; then
+ break
+ fi
+ fi
+ done
fi
- done
+ else
+ PYTHON3="$PY3BIN"
+ AC_CHECK_PROGS(PY3CONFIG, [$PYTHON3-config])
+ fi
- if test -n "$PYTHON3" -a -n "$PY3CONFIG"; then
- AC_MSG_CHECKING([for Python 3.x prefix])
- PY3PREFIX=`($PY3CONFIG --prefix) 2>/dev/null`
- AC_MSG_RESULT($PY3PREFIX)
- AC_MSG_CHECKING(for Python 3.x exec-prefix)
- PY3EPREFIX=`($PY3CONFIG --exec-prefix) 2>/dev/null`
- AC_MSG_RESULT($PY3EPREFIX)
-
- # Note: I could not think of a standard way to get the version string from different versions.
- # This trick pulls it out of the file location for a standard library file.
-
- AC_MSG_CHECKING([for Python 3.x version])
-
- # Need to do this hack since autoconf replaces __file__ with the name of the configure file
- filehack="file__"
- PY3VERSION=`($PYTHON3 -c "import string,operator,os.path; print(operator.getitem(os.path.split(operator.getitem(os.path.split(string.__$filehack),0)),1))")`
- AC_MSG_RESULT($PY3VERSION)
-
- # Find the directory for libraries this is necessary to deal with
- # platforms that can have apps built for multiple archs: e.g. x86_64
- AC_MSG_CHECKING([for Python 3.x lib dir])
- PY3LIBDIR=`($PYTHON3 -c "import sys; print(sys.lib)") 2>/dev/null`
- if test -z "$PY3LIBDIR"; then
- # some dists don't have sys.lib so the best we can do is assume lib
- PY3LIBDIR="lib"
+ if test -n "$PYTHON3"; then
+ AC_MSG_CHECKING([for $PYTHON3 major version number])
+ PYVER=`($PYTHON3 -c "import sys; sys.stdout.write(sys.version[[0]])") 2>/dev/null`
+ AC_MSG_RESULT($PYVER)
+ if test -z "$PYVER"; then
+ PYVER=0
fi
- AC_MSG_RESULT($PY3LIBDIR)
+ fi
- # Set the include directory
+ if test $PYVER -ge 3; then
+ AC_MSG_CHECKING(for Python 3.x os.name)
+ PY3OSNAME=`($PYTHON3 -c "import sys, os; sys.stdout.write(os.name)")`
+ AC_MSG_RESULT($PY3OSNAME)
+
+ if test x"$PY3OSNAME" = x"nt"; then
+ # Windows installations are quite different to posix installations
+ # There is no python-config to use
+ AC_MSG_CHECKING(for Python 3.x prefix)
+ PY3PREFIX=`($PYTHON3 -c "import sys; sys.stdout.write(sys.prefix)") 2>/dev/null`
+ AC_MSG_RESULT($PY3PREFIX)
+ PY3PREFIX=`echo "$PY3PREFIX" | sed -e 's,\\\\,/,g'` # Forward slashes are easier to use and even work on Windows most of the time
+ PYTHON_SO=.pyd
+
+ AC_MSG_CHECKING(for Python 3.x header files)
+ if test -r $PY3PREFIX/include/Python.h; then
+ PY3INCLUDE="-I$PY3PREFIX/include"
+ fi
+ AC_MSG_RESULT($PY3INCLUDE)
+
+ AC_MSG_CHECKING(for Python 3.x library directory)
+ if test -d $PY3PREFIX/libs; then
+ PY3LIB=$PY3PREFIX/libs
+ PY3LINKFILE=`ls $PY3LIB/python*.lib | grep "python[[0-9]][[0-9]]\.lib"`
+ if test -r "$PY3LINKFILE"; then
+ PY3LINK=-l`basename $PY3LINKFILE | sed -e 's/\.lib$//'`
+ else
+ PY3LIB=
+ fi
+ fi
+ if test -z "$PY3LIB"; then
+ AC_MSG_RESULT([Not found])
+ else
+ AC_MSG_RESULT($PY3LIB)
+ fi
+ AC_MSG_CHECKING([for Python 3.x library])
+ if test -z "$PY3LINK"; then
+ AC_MSG_RESULT(Not found)
+ else
+ AC_MSG_RESULT($PY3LINK)
+ fi
+ elif test -n "$PY3CONFIG"; then
+ AC_MSG_CHECKING([for Python 3.x prefix])
+ PY3PREFIX=`($PY3CONFIG --prefix) 2>/dev/null`
+ AC_MSG_RESULT($PY3PREFIX)
+ AC_MSG_CHECKING(for Python 3.x exec-prefix)
+ PY3EPREFIX=`($PY3CONFIG --exec-prefix) 2>/dev/null`
+ AC_MSG_RESULT($PY3EPREFIX)
+
+ # Note: I could not think of a standard way to get the version string from different versions.
+ # This trick pulls it out of the file location for a standard library file.
+
+ AC_MSG_CHECKING([for Python 3.x version])
+
+ # Need to do this hack since autoconf replaces __file__ with the name of the configure file
+ filehack="file__"
+ PY3VERSION=`($PYTHON3 -c "import string,operator,os.path; print(operator.getitem(os.path.split(operator.getitem(os.path.split(string.__$filehack),0)),1))")`
+ AC_MSG_RESULT($PY3VERSION)
+
+ # Find the directory for libraries this is necessary to deal with
+ # platforms that can have apps built for multiple archs: e.g. x86_64
+ AC_MSG_CHECKING([for Python 3.x lib dir])
+ PY3LIBDIR=`($PYTHON3 -c "import sys; print(sys.lib)") 2>/dev/null`
+ if test -z "$PY3LIBDIR"; then
+ # some dists don't have sys.lib so the best we can do is assume lib
+ PY3LIBDIR="lib"
+ fi
+ AC_MSG_RESULT($PY3LIBDIR)
+
+ # Set the include directory
- AC_MSG_CHECKING([for Python 3.x header files])
- PY3INCLUDE=`($PY3CONFIG --includes) 2>/dev/null`
- AC_MSG_RESULT($PY3INCLUDE)
+ AC_MSG_CHECKING([for Python 3.x header files])
+ PY3INCLUDE=`($PY3CONFIG --includes) 2>/dev/null`
+ AC_MSG_RESULT($PY3INCLUDE)
- # Set the library directory blindly. This probably won't work with older versions
- AC_MSG_CHECKING([for Python 3.x library])
- dirs="$PY3VERSION/config $PY3VERSION/$PY3LIBDIR python/$PY3LIBDIR"
- for i in $dirs; do
- if test -d $PY3EPREFIX/$PY3LIBDIR/$i; then
- PY3LIB="$PY3EPREFIX/$PY3LIBDIR/$i"
- break
+ # Set the library directory blindly. This probably won't work with older versions
+ AC_MSG_CHECKING([for Python 3.x library directory])
+ dirs="$PY3VERSION/config $PY3VERSION/$PY3LIBDIR python/$PY3LIBDIR"
+ for i in $dirs; do
+ if test -d $PY3EPREFIX/$PY3LIBDIR/$i; then
+ PY3LIB="$PY3EPREFIX/$PY3LIBDIR/$i"
+ break
+ fi
+ done
+ if test -z "$PY3LIB"; then
+ AC_MSG_RESULT([Not found])
+ else
+ AC_MSG_RESULT($PY3LIB)
fi
- done
- if test -z "$PY3LIB"; then
- AC_MSG_RESULT([Not found])
- else
- AC_MSG_RESULT($PY3LIB)
- fi
- PY3LINK="-l$PY3VERSION"
+ PY3LINK="-l$PY3VERSION"
+
+ AC_MSG_CHECKING([for Python 3.x library])
+ if test -z "$PY3LINK"; then
+ AC_MSG_RESULT(Not found)
+ else
+ AC_MSG_RESULT($PY3LINK)
+ fi
+ fi
fi
# Cygwin (Windows) needs the library for dynamic linking
case $host in
*-*-cygwin* | *-*-mingw*)
- PYTHON3DYNAMICLINKING="-L$PYLIB $PY3LINK"
+ PYTHON3DYNAMICLINKING="-L$PY3LIB $PY3LINK"
DEFS="-DUSE_DL_IMPORT $DEFS"
;;
*)PYTHON3DYNAMICLINKING="";;
esac
-fi
-
-AC_SUBST(PY3INCLUDE)
-AC_SUBST(PY3LIB)
-AC_SUBST(PY3LINK)
-AC_SUBST(PYTHON3DYNAMICLINKING)
+ AC_SUBST(PY3INCLUDE)
+ AC_SUBST(PY3LIB)
+ AC_SUBST(PY3LINK)
+ AC_SUBST(PYTHON3DYNAMICLINKING)
+ AC_CHECK_PROGS(PEP8, pep8)
+fi
#----------------------------------------------------------------
# Look for Perl5
PERLBIN=
AC_ARG_WITH(perl5, AS_HELP_STRING([--without-perl5], [Disable Perl5])
-AS_HELP_STRING([--with-perl5=path], [Set location of Perl5 executable]),[ PERLBIN="$withval"], [PERLBIN=yes])
+AS_HELP_STRING([--with-perl5=path], [Set location of Perl5 executable]),[ PERLBIN="$withval"], [PERLBIN="$alllang_default"])
# First, check for "--without-perl5" or "--with-perl5=no".
-if test x"${PERLBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${PERLBIN}" = xno; then
AC_MSG_NOTICE([Disabling Perl5])
PERL=
else
# perl -MExtUtils::Embed -e ccopts
AC_MSG_CHECKING(for Perl5 header files)
if test -n "$PERL"; then
- PERL5DIR=`($PERL -e 'use Config; print $Config{archlib}, "\n";') 2>/dev/null`
+ PERL5DIR=`($PERL -MConfig -le 'print $Config{archlibexp}') 2>/dev/null`
if test -n "$PERL5DIR" ; then
dirs="$PERL5DIR $PERL5DIR/CORE"
PERL5EXT=none
else
AC_MSG_RESULT($PERL5LDFLAGS)
fi
+ AC_MSG_CHECKING(for Perl5 Test::More module) # For test-suite
+ PERL5TESTMORE=`($PERL -e 'use Test::More; print "good";') 2>/dev/null`
+ if test -z "$PERL5TESTMORE" ; then
+ AC_MSG_RESULT(not found)
+ else
+ AC_MSG_RESULT(found)
+ fi
else
AC_MSG_RESULT(unable to determine perl5 configuration)
PERL5EXT=$PERL5DIR
OCTAVE_SO=.oct
AC_ARG_WITH(octave, AS_HELP_STRING([--without-octave], [Disable Octave])
-AS_HELP_STRING([--with-octave=path], [Set location of Octave executable]),[OCTAVEBIN="$withval"], [OCTAVEBIN=yes])
+AS_HELP_STRING([--with-octave=path], [Set location of Octave executable]),[OCTAVEBIN="$withval"], [OCTAVEBIN="$alllang_default"])
# First, check for "--without-octave" or "--with-octave=no".
-if test x"${OCTAVEBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${OCTAVEBIN}" = xno; then
AC_MSG_NOTICE([Disabling Octave])
OCTAVE=
if test -n "$OCTAVE"; then
AC_MSG_CHECKING([for mkoctfile])
- mkoctfile="`dirname ${OCTAVE}`/mkoctfile"
+ mkoctfile="$(dirname $OCTAVE)/$(basename $OCTAVE | sed -e 's/octave/mkoctfile/')"
AS_IF([test -x "${mkoctfile}"],[
AC_MSG_RESULT([${mkoctfile}])
],[
if test -n "$OCTAVE"; then
AC_MSG_CHECKING([for Octave preprocessor flags])
OCTAVE_CPPFLAGS=
- for n in CPPFLAGS INCFLAGS; do
- OCTAVE_CPPFLAGS="${OCTAVE_CPPFLAGS} "`${mkoctfile} -p $n`
+ for var in CPPFLAGS INCFLAGS ALL_CXXFLAGS; do
+ for flag in `env - ${mkoctfile} -p ${var}`; do
+ case ${flag} in
+ -D*|-I*) OCTAVE_CPPFLAGS="${OCTAVE_CPPFLAGS} ${flag}";;
+ *) ;;
+ esac
+ done
done
AC_MSG_RESULT([$OCTAVE_CPPFLAGS])
AC_MSG_CHECKING([for Octave compiler flags])
OCTAVE_CXXFLAGS=
- for n in ALL_CXXFLAGS; do
- OCTAVE_CXXFLAGS="${OCTAVE_CXXFLAGS} "`${mkoctfile} -p $n`
+ for var in ALL_CXXFLAGS; do
+ for flag in `env - ${mkoctfile} -p ${var}`; do
+ case ${flag} in
+ -g*|-W*) OCTAVE_CXXFLAGS="${OCTAVE_CXXFLAGS} ${flag}";;
+ *) ;;
+ esac
+ done
done
+ save_CXXFLAGS="${CXXFLAGS}"
+ CXXFLAGS="-Werror -O0"
+ AC_COMPILE_IFELSE([
+ AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT],[])
+ ],[
+ OCTAVE_CXXFLAGS="${OCTAVE_CXXFLAGS} -O0"
+ ])
+ CXXFLAGS="${save_CXXFLAGS}"
AC_MSG_RESULT([$OCTAVE_CXXFLAGS])
AC_MSG_CHECKING([for Octave linker flags])
OCTAVE_LDFLAGS=
- for n in RDYNAMIC_FLAG LFLAGS RLD_FLAG OCTAVE_LIBS LIBS; do
- OCTAVE_LDFLAGS="${OCTAVE_LDFLAGS} "`${mkoctfile} -p $n`
+ for var in RDYNAMIC_FLAG LFLAGS RLD_FLAG OCTAVE_LIBS LIBS; do
+ OCTAVE_LDFLAGS="${OCTAVE_LDFLAGS} "`env - ${mkoctfile} -p ${var}`
done
AC_MSG_RESULT([$OCTAVE_LDFLAGS])
for octave_opt in --silent --norc --no-history --no-window-system; do
AC_MSG_CHECKING([if Octave option '${octave_opt}' is supported])
- octave_out=`${OCTAVE} ${octave_opt} /dev/null 2>&1 | sed -n '1{/unrecognized/p}'`
+ octave_out=`${OCTAVE} ${octave_opt} /dev/null 2>&1 | sed -n '1p' | sed -n '/unrecognized/p'`
AS_IF([test "x${octave_out}" = x],[
AC_MSG_RESULT([yes])
OCTAVE="${OCTAVE} ${octave_opt}"
AC_SUBST(OCTAVE_LDFLAGS)
#----------------------------------------------------------------
+# Look for Scilab
+#----------------------------------------------------------------
+
+AC_ARG_WITH(scilab, AS_HELP_STRING([--without-scilab], [Disable Scilab])
+AS_HELP_STRING([--with-scilab=path], [Set location of Scilab executable]),[SCILABBIN="$withval"], [SCILABBIN="$alllang_default"])
+AC_ARG_WITH(scilab-inc, [ --with-scilab-inc=path Set location of Scilab include directory], [SCILABINCDIR="$withval"], [SCILABINCDIR=""])
+
+# First, check for "--without-scilab" or "--with-scilab=no".
+if test x"${SCILABBIN}" = xno; then
+ AC_MSG_NOTICE([Disabling Scilab])
+ SCILAB=
+else
+ # Check for Scilab executable
+ if test "x$SCILABBIN" = xyes; then
+ AC_CHECK_PROGS(SCILAB, scilab)
+ else
+ AC_MSG_CHECKING(for scilab)
+ if test -f "$SCILABBIN"; then
+ AC_MSG_RESULT($SCILABBIN)
+ SCILAB="$SCILABBIN"
+ else
+ AC_MSG_RESULT(not found)
+ fi
+ fi
+
+ if test -n "$SCILAB"; then
+ # Check for Scilab version (needs api_scilab so needs version 5.3.3 or higher)
+ SCILAB_FULL_VERSION=`$SCILAB -version | head -1 | sed -e 's|Scilab version \"\(.*\)\"|\1|g'`
+
+ AC_MSG_CHECKING(Scilab version is 5.3.3 or higher)
+ SCILAB_MAJOR_VERSION=`echo $SCILAB_FULL_VERSION | cut -d. -f1`
+ SCILAB_MINOR_VERSION=`echo $SCILAB_FULL_VERSION | cut -d. -f2`
+ SCILAB_MAINTENANCE_VERSION=`echo $SCILAB_FULL_VERSION | cut -d. -f3`
+ SCILAB_VERSION="$SCILAB_MAJOR_VERSION$SCILAB_MINOR_VERSION$SCILAB_MAINTENANCE_VERSION"
+
+ if test $SCILAB_VERSION -ge 533; then
+ AC_MSG_RESULT(yes)
+ else
+ AC_MSG_RESULT(no)
+ SCILAB=
+ fi
+
+ if test -n "$SCILAB"; then
+ # Set Scilab startup options depending on version
+ AC_MSG_CHECKING(for Scilab startup options)
+ SCILABOPT="-nwni -nb"
+ if test $SCILAB_VERSION -ge 540; then
+ SCILABOPT+=" -noatomsautoload"
+ fi
+ AC_MSG_RESULT($SCILABOPT)
+
+ # Check for Scilab header files
+ AC_MSG_CHECKING(for Scilab header files)
+ if test "$SCILABINCDIR" != ""; then
+ dirs="$SCILABINCDIR"
+ elif test -n "$PKGCONFIG"; then
+ dirs=`$PKGCONFIG scilab --cflags-only-I | sed -e 's/-I//g'`
+ else
+ dirs=""
+ fi
+ for i in $dirs; do
+ if test -r $i/api_scilab.h; then
+ AC_MSG_RESULT($i)
+ SCILABINCLUDE="-I$i"
+ break
+ fi
+ if test -r $i/scilab/api_scilab.h; then
+ AC_MSG_RESULT($i/scilab)
+ SCILABINCLUDE="-I$i/scilab"
+ break
+ fi
+ done
+ if test "$SCILABINCLUDE" = "" ; then
+ AC_MSG_RESULT(not found)
+ SCILAB=
+ fi
+ fi
+ fi
+fi
+
+AC_SUBST(SCILAB)
+AC_SUBST(SCILABINCLUDE)
+AC_SUBST(SCILABOPT)
+
+
+#----------------------------------------------------------------
# Look for java
#----------------------------------------------------------------
AC_ARG_WITH(java, AS_HELP_STRING([--without-java], [Disable Java])
-AS_HELP_STRING([--with-java=path], [Set location of java executable]),[JAVABIN="$withval"], [JAVABIN=yes])
+AS_HELP_STRING([--with-java=path], [Set location of java executable]),[JAVABIN="$withval"], [JAVABIN="$alllang_default"])
AC_ARG_WITH(javac, [ --with-javac=path Set location of javac executable],[JAVACBIN="$withval"], [JAVACBIN=])
# First, check for "--without-java" or "--with-java=no".
-if test x"${JAVABIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${JAVABIN}" = xno; then
AC_MSG_NOTICE([Disabling Java])
JAVA=
else
+dnl Detect everything we need for Java: java for running Java tests, javac for
+dnl compiling them and C headers for compiling C code.
+dnl
+dnl If JAVA_HOME is defined and contains everything needed, as it's supposed to,
+dnl just use it. Otherwise try to locate the necessary files in the path.
+case $host in
+ *-*-cygwin*)
+ dnl Ensure that JAVA_HOME is in the form we can use, it's typically set to Windows path by the installer.
+ if test -n "$JAVA_HOME"; then
+ JAVA_HOME=`cygpath --mixed "$JAVA_HOME"`
+ fi
+ ;;
+ *-*-mingw*)
+ if test -n "$JAVA_HOME"; then
+ JAVA_HOME=`${srcdir}/Tools/convertpath -u "$JAVA_HOME"`
+ fi
+ ;;
+ *-*-darwin*)
+ dnl Under OS X JAVA_HOME is not set by default, try to use the system default JRE.
+ if test -z "$JAVA_HOME" -a -x /usr/libexec/java_home; then
+ JAVA_HOME=`/usr/libexec/java_home`
+ fi
+ dnl The JAVA_HOME doesn't contain the JDK headers though, but they seem to
+ dnl always be in the same location, according to Apple JNI documentation.
+ JAVA_OSX_STD_INCDIR="/System/Library/Frameworks/JavaVM.framework/Headers"
+ if test -r "$JAVA_OSX_STD_INCDIR/jni.h"; then
+ JAVA_HOME_INCDIR=$JAVA_OSX_STD_INCDIR
+ fi
+ ;;
+esac
+
+AC_MSG_CHECKING(for java JDK)
+if test -n "$JAVA_HOME"; then
+ dnl Don't complain about missing executables/headers if they had been
+ dnl explicitly overridden from the command line, but otherwise verify that we
+ dnl have everything we need.
+ java_home_ok=1
+ if test -z "$JAVABIN" -a ! -x "$JAVA_HOME/bin/java"; then
+ AC_MSG_WARN([No java executable under JAVA_HOME.])
+ java_home_ok=0
+ fi
+ if test -z "$JAVACBIN" -a ! -x "$JAVA_HOME/bin/javac"; then
+ AC_MSG_WARN([No javac executable under JAVA_HOME.])
+ java_home_ok=0
+ fi
+
+ dnl By default the headers are under JAVA_HOME/include, but OS X is special
+ dnl and defines JAVA_HOME_INCDIR differently above.
+ if test -z "$JAVA_HOME_INCDIR"; then
+ JAVA_HOME_INCDIR="$JAVA_HOME/include"
+ fi
+ if test -z "$JAVAINCDIR" -a ! -r "$JAVA_HOME_INCDIR/jni.h"; then
+ AC_MSG_WARN([No java headers under JAVA_HOME (does it point to a JDK and not just JRE?).])
+ java_home_ok=0
+ fi
+ if test "$java_home_ok" = 1; then
+ AC_MSG_RESULT([found (in $JAVA_HOME)])
+ else
+ AC_MSG_RESULT(no)
+ AC_MSG_WARN([JAVA_HOME ($JAVA_HOME) is defined but does not point to a complete JDK installation, ignoring it.])
+ JAVA_HOME=
+ fi
+else
+ AC_MSG_RESULT([no (JAVA_HOME is not defined)])
+fi
+
if test "x$JAVABIN" = xyes; then
- AC_CHECK_PROGS(JAVA, java kaffe guavac)
+ if test -n "$JAVA_HOME"; then
+ JAVA="$JAVA_HOME/bin/java"
+ else
+ AC_CHECK_PROGS(JAVA, java kaffe guavac)
+ fi
else
JAVA="$JAVABIN"
fi
if test -z "$JAVACBIN"; then
- AC_CHECK_PROGS(JAVAC, javac)
+ if test -n "$JAVA_HOME"; then
+ JAVAC="$JAVA_HOME/bin/javac"
+ else
+ AC_CHECK_PROGS(JAVAC, javac)
+ fi
else
JAVAC="$JAVACBIN"
fi
AC_MSG_CHECKING(for java include file jni.h)
AC_ARG_WITH(javaincl, [ --with-javaincl=path Set location of Java include directory], [JAVAINCDIR="$withval"], [JAVAINCDIR=])
+JAVAINC=""
if test -z "$JAVAINCDIR" ; then
- JAVAINCDIR="/usr/j2sdk*/include /usr/local/j2sdk*/include /usr/jdk*/include /usr/local/jdk*/include /opt/j2sdk*/include /opt/jdk*/include /usr/java/include /usr/java/j2sdk*/include /usr/java/jdk*/include /usr/local/java/include /opt/java/include /usr/include/java /usr/local/include/java /usr/lib/java/include /usr/lib/jvm/java*/include /usr/include/kaffe /usr/local/include/kaffe /usr/include"
+ if test -n "$JAVA_HOME"; then
+ JAVAINCDIR="$JAVA_HOME_INCDIR"
+ JAVAINC=-I\"$JAVAINCDIR\"
+ else
+ JAVAINCDIR="/usr/j2sdk*/include /usr/local/j2sdk*/include /usr/jdk*/include /usr/local/jdk*/include /opt/j2sdk*/include /opt/jdk*/include /usr/java/include /usr/java/j2sdk*/include /usr/java/jdk*/include /usr/local/java/include /opt/java/include /usr/include/java /usr/local/include/java /usr/lib/java/include /usr/lib/jvm/java*/include /usr/lib64/jvm/java*/include /usr/include/kaffe /usr/local/include/kaffe /usr/include"
- # Add in default installation directory on Windows for Cygwin
- case $host in
- *-*-cygwin* | *-*-mingw*) JAVAINCDIR="c:/Program*Files/Java/jdk*/include d:/Program*Files/Java/jdk*/include c:/j2sdk*/include d:/j2sdk*/include c:/jdk*/include d:/jdk*/include $JAVAINCDIR";;
- *-*-darwin*) JAVAINCDIR="/System/Library/Frameworks/JavaVM.framework/Headers $JAVAINCDIR";;
- *);;
- esac
-fi
+ # Add in default installation directory on Windows for Cygwin
+ case $host in
+ *-*-cygwin* | *-*-mingw*) JAVAINCDIR="c:/Program*Files*/Java/jdk*/include d:/Program*Files*/Java/jdk*/include c:/j2sdk*/include d:/j2sdk*/include c:/jdk*/include d:/jdk*/include $JAVAINCDIR";;
+ *-*-darwin*) JAVAINCDIR="$JAVA_OSX_STD_INCDIR $JAVAINCDIR";;
+ *);;
+ esac
-JAVAINC=""
-for d in $JAVAINCDIR ; do
- if test -r "$d/jni.h" ; then
- AC_MSG_RESULT($d)
- JAVAINCDIR=$d
- JAVAINC=-I\"$d\"
- break
+ for d in $JAVAINCDIR ; do
+ if test -r "$d/jni.h" ; then
+ JAVAINCDIR=$d
+ JAVAINC=-I\"$d\"
+ break
+ fi
+ done
fi
-done
+else
+ if test -r "$JAVAINCDIR/jni.h" ; then
+ JAVAINC=-I\"$JAVAINCDIR\"
+ fi
+fi
if test "$JAVAINC" = "" ; then
AC_MSG_RESULT(not found)
else
+ AC_MSG_RESULT($JAVAINC)
# now look for <arch>/jni_md.h
AC_MSG_CHECKING(for java include file jni_md.h)
JAVAMDDIR=`find "$JAVAINCDIR" -follow -name jni_md.h -print`
if test "$JAVAMDDIR" = "" ; then
AC_MSG_RESULT(not found)
else
- JAVAMDDIR=`dirname "$JAVAMDDIR" | tail -1`
- JAVAINC="${JAVAINC} -I\"$JAVAMDDIR\""
+ JAVAMDDIR=-I\"`dirname "$JAVAMDDIR" | tail -1`\"
AC_MSG_RESULT($JAVAMDDIR)
+ JAVAINC="${JAVAINC} ${JAVAMDDIR}"
fi
fi
+case $host in
+*-*-cygwin*)
+ # TODO: Only use this flag if the compiler supports it, later versions of gcc no longer have it
+ GCC_MNO_CYGWIN=" -mno-cygwin"
+ ;;
+*)
+ GCC_MNO_CYGWIN=""
+ ;;
+esac
+
# java.exe on Cygwin requires the Windows standard (Pascal) calling convention as it is a normal Windows executable and not a Cygwin built executable
case $host in
*-*-cygwin* | *-*-mingw*)
if test "$GCC" = yes; then
- JAVADYNAMICLINKING=" -mno-cygwin -mthreads -Wl,--add-stdcall-alias"
- JAVACFLAGS="-mno-cygwin -mthreads"
+ JAVADYNAMICLINKING="$GCC_MNO_CYGWIN -mthreads -Wl,--add-stdcall-alias"
+ JAVACFLAGS="$GCC_MNO_CYGWIN -mthreads"
else
JAVADYNAMICLINKING=""
JAVACFLAGS=""
esac
fi
+# Quote for spaces in path to executables
+if test -n "$JAVA"; then
+ JAVA=\"$JAVA\"
+fi
+if test -n "$JAVAC"; then
+ JAVAC=\"$JAVAC\"
+fi
+
+# Turned off due to spurious warnings in later versions of openjdk-1.8
+# JAVAFLAGS=-Xcheck:jni
+
AC_SUBST(JAVA)
AC_SUBST(JAVAC)
AC_SUBST(JAVAINC)
AC_SUBST(JAVASO)
AC_SUBST(JAVALDSHARED)
AC_SUBST(JAVACXXSHARED)
+AC_SUBST(JAVAFLAGS)
AC_SUBST(JAVACFLAGS)
#----------------------------------------------------------------
+# Look for Javascript
+#----------------------------------------------------------------
+AC_ARG_WITH(javascript, AS_HELP_STRING([--without-javascript], [Disable Javascript]), [with_javascript="$withval"], [with_javascript="$alllang_default"])
+
+# First, check for "--without-javascript" or "--with-javascript=no".
+if test x"${with_javascript}" = xno; then
+ AC_MSG_NOTICE([Disabling Javascript])
+ JAVASCRIPT=
+else
+ JAVASCRIPT=1
+
+ #----------------------------------------------------------------
+ # General Javascript settings shared by JSC and V8
+ #----------------------------------------------------------------
+
+ case $host in
+ *-*-darwin*)
+ JSSO=".dylib"
+ # HACK: didn't manage to get dynamic module loading working with a g++ compiled interpreter
+ JSINTERPRETERCXX='c++'
+ JSINTERPRETERLINKFLAGS='-g -Wl,-search_paths_first -Wl,-headerpad_max_install_names'
+ ;;
+ *)
+ JSSO=$SO
+ JSINTERPRETERCXX='$(CXX)'
+ JSINTERPRETERLINKFLAGS='-ldl'
+ ;;
+ esac
+
+ #----------------------------------------------------------------
+ # Look for Node.js which is the default Javascript engine
+ #----------------------------------------------------------------
+
+ AC_CHECK_PROGS(NODEJS, [nodejs node])
+
+ if test -n "$NODEJS"; then
+ # node-gyp is needed to run the test-suite/examples
+ AC_CHECK_PROGS(NODEGYP, node-gyp)
+ if test -z "$NODEGYP"; then
+ NODEJS=
+ fi
+ fi
+
+ #----------------------------------------------------------------
+ # Look for JavascriptCore (Webkit) settings (JSCOREINCDIR, JSCOREDYNAMICLINKING)
+ #----------------------------------------------------------------
+
+ # check for include files
+ AC_MSG_CHECKING(for JavaScriptCore/JavaScript.h)
+ AC_ARG_WITH(jscoreinc, [ --with-jscinc=path Set location of Javascript include directory], [JSCOREINCDIR="$withval"], [JSCOREINCDIR=])
+
+ JSCOREVERSION=
+
+ if test -z "$JSCOREINCDIR"; then
+ JSCOREINCDIR="/usr/include/ /usr/local/include/"
+
+ # Add in default directory for JavaScriptCore headers for Linux and Mac OS X
+ case $host in
+ *-*-linux*)
+ JSCOREINCDIR="/usr/include/webkit-1.0/ /usr/include/webkitgtk-1.0/ /usr/local/include/webkit-1.0/JavaScriptCore/ $JSCOREINCDIR"
+ ;;
+ *-*-darwin*)
+ JSCOREINCDIR="/System/Library/Frameworks/JavaScriptCore.framework/Headers/ $JSCOREINCDIR"
+ ;;
+ *)
+ ;;
+ esac
+ fi
+
+ for d in $JSCOREINCDIR ; do
+ if test -r "$d/JavaScriptCore/JavaScript.h" || test -r "$d/JavaScript.h" ; then
+ AC_MSG_RESULT($d)
+ JSCOREINCDIR=$d
+ JSCOREINC=-I\"$d\"
+ break
+ fi
+ done
+
+ if test "$JSCOREINC" = "" ; then
+ AC_MSG_RESULT(not found)
+ fi
+
+ # check for JavaScriptCore/Webkit libraries
+ AC_ARG_WITH(jscorelib,[ --with-jsclib=path Set location of the JavaScriptCore/Webkit library directory],[JSCORELIB="-L$withval"], [JSCORELIB=])
+
+ if test -z "$JSCORELIB" -a -n "$PKGCONFIG"; then
+ AC_MSG_CHECKING(for JavaScriptCore/Webkit library)
+ if pkg-config javascriptcoregtk-1.0; then
+ JSCORELIB=`$PKGCONFIG --libs javascriptcoregtk-1.0`
+ JSCOREVERSION=`$PKGCONFIG --modversion javascriptcoregtk-1.0`
+ fi
+ if test -z "$JSCORELIB"; then
+ AC_MSG_RESULT(not found)
+ JSCENABLED=
+ else
+ AC_MSG_RESULT([$JSCORELIB])
+ JSCOREDYNAMICLINKING="$JSCORELIB"
+ JSCENABLED=1
+ fi
+ fi
+
+ #----------------------------------------------------------------
+ # Look for V8 settings (JSV8INCDIR, JSV8DYNAMICLINKING)
+ #----------------------------------------------------------------
+
+ # check for include files
+ AC_MSG_CHECKING(for V8 Javascript v8.h)
+ AC_ARG_WITH(jsv8inc, [ --with-jsv8inc=path Set location of Javascript v8 include directory], [JSV8INCDIR="$withval"])
+
+ # if not include dir is specified we try to find
+ if test -z "$JSV8INCDIR"; then
+ # Add in default directory for JavaScriptCore headers for Linux and Mac OS X
+ case $host in
+ *-*-linux*)
+ JSV8INCDIR="/usr/include /usr/local/include/ $JSV8INCDIR"
+ ;;
+ *-*-darwin*)
+ JSV8INCDIR="$JSV8INCDIR"
+ ;;
+ *)
+ ;;
+ esac
+ fi
+
+ for d in $JSV8INCDIR ; do
+ if test -r "$d/v8.h" ; then
+ JSV8INCDIR=$d
+ JSV8INC=-I\"$d\"
+ break
+ fi
+ done
+
+ if test "$JSV8INC" = "" ; then
+ AC_MSG_RESULT(not found)
+ else
+ AC_MSG_RESULT($JSV8INCDIR)
+ fi
+
+ # check for V8 library
+ AC_MSG_CHECKING(for V8 Javascript library)
+ AC_ARG_WITH(jsv8lib,[ --with-jsv8lib=path Set location of V8 Javascript library directory],[JSV8LIBDIR="$withval"], [JSV8LIB=])
+
+ v8libdirs="$JSV8LIBDIR /usr/lib64/ /usr/local/lib64/ /usr/lib/ /usr/local/lib/"
+ for d in $v8libdirs ; do
+ if test -r $d/libv8$JSSO; then
+ JSV8LIBDIR=$d
+ JSV8LIB="-L$d -lv8"
+ break
+ fi
+ done
+
+ if test "$JSV8LIB" = "" ; then
+ AC_MSG_RESULT(not found)
+ JSV8ENABLED=
+ else
+ AC_MSG_RESULT($JSV8LIBDIR)
+ JSV8ENABLED=1
+ fi
+
+
+ # linking options
+ case $host in
+ *-*-darwin*)
+ JSV8DYNAMICLINKING="$JSV8LIB"
+ ;;
+ *-*-linux*)
+ JSV8DYNAMICLINKING="$JSV8LIB"
+ ;;
+ *)
+ JSV8DYNAMICLINKING=""
+ ;;
+ esac
+
+fi
+
+AC_SUBST(JSINTERPRETERCXX)
+AC_SUBST(JSINTERPRETERLINKFLAGS)
+
+AC_SUBST(JSCOREINC)
+AC_SUBST(JSCOREDYNAMICLINKING)
+AC_SUBST(JSCOREVERSION)
+AC_SUBST(JSV8INC)
+AC_SUBST(JSV8DYNAMICLINKING)
+
+AC_SUBST(JSCENABLED)
+AC_SUBST(JSV8ENABLED)
+
+AC_SUBST(NODEJS)
+AC_SUBST(NODEGYP)
+
+#----------------------------------------------------------------
# Look for gcj
#----------------------------------------------------------------
AC_ARG_WITH(gcj, AS_HELP_STRING([--without-gcj], [Disable GCJ])
-AS_HELP_STRING([--with-gcj=path], [Set location of gcj executable]),[GCJBIN="$withval"], [GCJBIN=yes])
+AS_HELP_STRING([--with-gcj=path], [Set location of gcj executable]),[GCJBIN="$withval"], [GCJBIN="$alllang_default"])
AC_ARG_WITH(gcjh, [ --with-gcjh=path Set location of gcjh executable],[GCJHBIN="$withval"], [GCJHBIN=])
# First, check for "--without-gcj" or "--with-gcj=no".
-if test x"${GCJBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${GCJBIN}" = xno; then
AC_MSG_NOTICE([Disabling GCJ])
else
if test "x$GCJBIN" = xyes; then
#----------------------------------------------------------------
AC_ARG_WITH(android, AS_HELP_STRING([--without-android], [Disable Android])
-AS_HELP_STRING([--with-android=path], [Set location of android executable]),[ANDROIDBIN="$withval"], [ANDROIDBIN=yes])
-AC_ARG_WITH(adb, [ --with-adb=path Set location of adb executable - Android Debug Bridge],[ADBBIN="$withval"], [ADBBIN=])
-AC_ARG_WITH(ant, [ --with-ant=path Set location of ant executable for Android],[ANTBIN="$withval"], [ANTBIN=])
-AC_ARG_WITH(ndk-build, [ --with-ndk-build=path Set location of Android ndk-build executable],[NDKBUILDBIN="$withval"], [NDKBUILDBIN=])
+AS_HELP_STRING([--with-android=path], [Set location of android executable]),[ANDROIDBIN="$withval"], [ANDROIDBIN="$alllang_default"])
+AC_ARG_WITH(adb, [ --with-adb=path Set location of adb executable - Android Debug Bridge],[ADBBIN="$withval"], [ADBBIN=])
+AC_ARG_WITH(ant, [ --with-ant=path Set location of ant executable for Android],[ANTBIN="$withval"], [ANTBIN=])
+AC_ARG_WITH(ndk-build, [ --with-ndk-build=path Set location of Android ndk-build executable],[NDKBUILDBIN="$withval"], [NDKBUILDBIN=])
# First, check for "--without-android" or "--with-android=no".
-if test x"${ANDROIDBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${ANDROIDBIN}" = xno; then
AC_MSG_NOTICE([Disabling Android])
ANDROID=
else
GUILE_LIBS=
AC_ARG_WITH(guile-config, AS_HELP_STRING([--without-guile], [Disable Guile])
- AS_HELP_STRING([--with-guile-config=path], [Set location of guile-config]),[ GUILE_CONFIG="$withval"], [GUILE_CONFIG=])
+AS_HELP_STRING([--with-guile-config=path], [Set location of guile-config]),[ GUILE_CONFIG="$withval"], [GUILE_CONFIG=])
AC_ARG_WITH(guile,[ --with-guile=path Set location of Guile executable],[
- GUILE="$withval"], [GUILE=yes])
+ GUILE="$withval"], [GUILE="$alllang_default"])
AC_ARG_WITH(guile-cflags,[ --with-guile-cflags=cflags Set cflags required to compile against Guile],[
GUILE_CFLAGS="$withval"])
AC_ARG_WITH(guile-libs,[ --with-guile-libs=ldflags Set ldflags needed to link with Guile],[
GUILE_LIBS="$withval"])
# First, check for "--without-guile" or "--with-guile=no".
-if test x"${GUILE}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${GUILE}" = xno; then
AC_MSG_NOTICE([Disabling Guile])
else
if test -z "$GUILE_CONFIG" ; then
#----------------------------------------------------------------
AC_ARG_WITH(mzscheme, AS_HELP_STRING([--without-mzscheme], [Disable MzScheme])
-AS_HELP_STRING([--with-mzscheme=path], [Set location of MzScheme executable]),[ MZSCHEMEBIN="$withval"], [MZSCHEMEBIN=yes])
+AS_HELP_STRING([--with-mzscheme=path], [Set location of MzScheme executable]),[ MZSCHEMEBIN="$withval"], [MZSCHEMEBIN="$alllang_default"])
AC_ARG_WITH(mzc, AS_HELP_STRING([--with-mzc=path], [Set location of MzScheme's mzc]), [ MZCBIN="$withval"], [MZCBIN=])
# First, check for "--without-mzscheme" or "--with-mzscheme=no".
-if test x"${MZSCHEMEBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${MZSCHEMEBIN}" = xno; then
AC_MSG_NOTICE([Disabling MzScheme])
MZC=
else
RUBYBIN=
AC_ARG_WITH(ruby, AS_HELP_STRING([--without-ruby], [Disable Ruby])
-AS_HELP_STRING([--with-ruby=path], [Set location of Ruby executable]),[ RUBYBIN="$withval"], [RUBYBIN=yes])
+AS_HELP_STRING([--with-ruby=path], [Set location of Ruby executable]),[ RUBYBIN="$withval"], [RUBYBIN="$alllang_default"])
# First, check for "--without-ruby" or "--with-ruby=no".
-if test x"${RUBYBIN}" = xno -o x"${with_alllang}" = xno ; then
+RUBYSO=$SO
+if test x"${RUBYBIN}" = xno; then
AC_MSG_NOTICE([Disabling Ruby])
RUBY=
else
AC_MSG_CHECKING(for Ruby header files)
if test -n "$RUBY"; then
- # Try Ruby1.9 first
+ # Try Ruby1.9+ first
RUBYDIR=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG[["rubyhdrdir"]] || $rubyhdrdir') 2>/dev/null`
+ RUBYARCHHDRDIR=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG[["rubyarchhdrdir"]] || $rubyarchhdrdir') 2>/dev/null`
if test x"$RUBYDIR" = x"" || test x"$RUBYDIR" = x"nil"; then
- RUBYDIR=`($RUBY -rmkmf -e 'print Config::CONFIG[["archdir"]] || $archdir') 2>/dev/null`
+ RUBYDIR=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG[["archdir"]] || $archdir') 2>/dev/null`
else
RUBYARCH=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG[["arch"]] || $arch') 2>/dev/null`
fi
if test x"$RUBYDIR" != x""; then
dirs="$RUBYDIR"
- RUBYINCLUDE=none
+ RUBYINCLUDE=
for i in $dirs; do
if test -r $i/ruby.h; then
- AC_MSG_RESULT($i)
- RUBYINCLUDE="-I$i"
+ if test x"$RUBYARCH" = x""; then
+ RUBYINCLUDE="-I$i"
+ elif test -n "$RUBYARCHHDRDIR"; then
+ RUBYINCLUDE="-I$i -I$RUBYARCHHDRDIR"
+ else
+ RUBYINCLUDE="-I$i -I$i/$RUBYARCH"
+ fi
+ AC_MSG_RESULT($RUBYINCLUDE)
break
fi
done
- if test x"$RUBYARCH" != x""; then
- RUBYINCLUDE="-I$RUBYDIR -I$RUBYDIR/$RUBYARCH"
- fi
- if test "$RUBYINCLUDE" = none; then
- RUBYINCLUDE="-I$RUBYDIR"
- AC_MSG_RESULT(could not locate ruby.h...using $RUBYINCLUDE)
+ if test x"$RUBYINCLUDE" = x""; then
+ AC_MSG_RESULT(could not locate ruby.h)
fi
# Find library and path for linking.
AC_MSG_CHECKING(for Ruby library)
RUBYLIB=""
- rb_libdir=`($RUBY -rrbconfig -e 'print Config::CONFIG[["libdir"]]') 2>/dev/null`
- rb_bindir=`($RUBY -rrbconfig -e 'print Config::CONFIG[["bindir"]]') 2>/dev/null`
- dirs="$dirs $rb_libdir $rb_bindir"
+ rb_archlibdir=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG[["archlibdir"]]') 2>/dev/null`
+ rb_libdir=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG[["libdir"]]') 2>/dev/null`
+ rb_bindir=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG[["bindir"]]') 2>/dev/null`
+ dirs="$dirs $rb_archlibdir $rb_libdir $rb_bindir"
- rb_libruby=`($RUBY -rrbconfig -e 'print Config::CONFIG[["LIBRUBY_A"]]') 2>/dev/null`
+ rb_libruby=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG[["LIBRUBY_A"]]') 2>/dev/null`
RUBYLINK=`($RUBY -rrbconfig -e '
- c = Config::CONFIG
+ c = RbConfig::CONFIG
if c.has_key? "LIBRUBYARG_STATIC" # 1.8.x
if c[["LIBRUBY"]] == c[["LIBRUBY_A"]]
link = c[["LIBRUBYARG_STATIC"]]
fi
else
AC_MSG_RESULT(unable to determine ruby configuration)
- RUBYINCLUDE="-I$RUBYDIR"
- RUBYLIB="$RUBYDIR"
fi
case $host in
*-*-mingw*) ;; # do nothing, the default windows libraries are already included
- *) RUBYLINK="$RUBYLINK `($RUBY -rrbconfig -e 'print Config::CONFIG[["LIBS"]]') 2>/dev/null`";;
+ *) RUBYLINK="$RUBYLINK `($RUBY -rrbconfig -e 'print RbConfig::CONFIG[["LIBS"]]') 2>/dev/null`";;
esac
- RUBYCCDLFLAGS=`($RUBY -rrbconfig -e 'print Config::CONFIG[["CCDLFLAGS"]]') 2>/dev/null`
- RUBYSO=.`($RUBY -rrbconfig -e 'print Config::CONFIG[["DLEXT"]]') 2>/dev/null`
+ RUBYCCDLFLAGS=`($RUBY -rrbconfig -e 'print RbConfig::CONFIG[["CCDLFLAGS"]]') 2>/dev/null`
+ RUBYSO=.`($RUBY -rrbconfig -e 'print RbConfig::CONFIG[["DLEXT"]]') 2>/dev/null`
else
AC_MSG_RESULT(could not figure out how to run ruby)
- RUBYINCLUDE="-I/usr/local/lib/ruby/1.4/arch"
- RUBYLIB="/usr/local/lib/ruby/1.4/arch"
- RUBYLINK="-lruby -lm"
fi
case $host in
PHPBIN=
AC_ARG_WITH(php, AS_HELP_STRING([--without-php], [Disable PHP])
-AS_HELP_STRING([--with-php=path], [Set location of PHP executable]),[ PHPBIN="$withval"], [PHPBIN=yes])
+AS_HELP_STRING([--with-php=path], [Set location of PHP executable]),[ PHPBIN="$withval"], [PHPBIN="$alllang_default"])
# First, check for "--without-php" or "--with-php=no".
-if test x"${PHPBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${PHPBIN}" = xno; then
AC_MSG_NOTICE([Disabling PHP])
PHP=
else
AC_MSG_RESULT(not found)
fi
;;
+ "")
+ AC_MSG_RESULT([could not find $PHPCONFIG or obtain PHP version from it]) ;;
*)
- AC_MSG_RESULT([found PHP $version, but only PHP 5 is supported]) ;;
+ AC_MSG_RESULT([found PHP $php_version, but only PHP 5 is supported]) ;;
esac
fi
AC_SUBST(PHP)
# Look for ocaml
#----------------------------------------------------------------
-AC_ARG_WITH(ocaml, AS_HELP_STRING([--without-ocaml], [Disable OCaml])
-AS_HELP_STRING([--with-ocaml=path], [Set location of ocaml executable]),[ OCAMLBIN="$withval"], [OCAMLBIN=yes])
+AC_ARG_WITH(ocaml, AS_HELP_STRING([--without-ocaml], [Disable OCaml]), [with_ocaml="$withval"], [with_ocaml="$alllang_default"])
AC_ARG_WITH(ocamlc,[ --with-ocamlc=path Set location of ocamlc executable],[ OCAMLC="$withval"], [OCAMLC=])
AC_ARG_WITH(ocamldlgen,[ --with-ocamldlgen=path Set location of ocamldlgen],[ OCAMLDLGEN="$withval" ], [OCAMLDLGEN=])
AC_ARG_WITH(ocamlfind,[ --with-ocamlfind=path Set location of ocamlfind],[OCAMLFIND="$withval"],[OCAMLFIND=])
AC_ARG_WITH(ocamlmktop,[ --with-ocamlmktop=path Set location of ocamlmktop executable],[ OCAMLMKTOP="$withval"], [OCAMLMKTOP=])
+AC_ARG_WITH(camlp4,[ --with-camlp4=path Set location of camlp4 executable],[ CAMLP4="$withval"], [CAMLP4=])
# First, check for "--without-ocaml" or "--with-ocaml=no".
-if test x"${OCAMLBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${with_ocaml}" = xno; then
AC_MSG_NOTICE([Disabling OCaml])
- OCAMLBIN=
+ OCAMLC=
else
-
AC_MSG_CHECKING(for Ocaml DL load generator)
if test -z "$OCAMLDLGEN"; then
- AC_CHECK_PROGS(OCAMLDLGEN, ocamldlgen, :)
+ AC_CHECK_PROGS(OCAMLDLGEN, ocamldlgen)
fi
AC_MSG_CHECKING(for Ocaml package tool)
if test -z "$OCAMLFIND"; then
- AC_CHECK_PROGS(OCAMLFIND, ocamlfind, :)
+ AC_CHECK_PROGS(OCAMLFIND, ocamlfind)
fi
AC_MSG_CHECKING(for Ocaml compiler)
if test -z "$OCAMLC"; then
- AC_CHECK_PROGS(OCAMLC, ocamlc, :)
- fi
-
- AC_MSG_CHECKING(for Ocaml interpreter)
- if test "x$OCAMLBIN" = xyes; then
- AC_CHECK_PROGS(OCAMLBIN, ocaml, :)
+ AC_CHECK_PROGS(OCAMLC, ocamlc)
fi
AC_MSG_CHECKING(for Ocaml toplevel creator)
if test -z "$OCAMLMKTOP"; then
- AC_CHECK_PROGS(OCAMLMKTOP, ocamlmktop, :)
+ AC_CHECK_PROGS(OCAMLMKTOP, ocamlmktop)
fi
- OCAMLLOC=loc
- if test "$OCAMLC" != ":" ; then
- AC_MSG_CHECKING(for Ocaml header files)
- dirs="/usr/lib/ocaml/caml /usr/local/lib/ocaml/caml"
- dir="`$OCAMLC -where 2>/dev/null`"
- if test "$dir"; then
- dirs="$dir/caml $dirs"
- fi
- for i in $dirs; do
- if test -r $i/mlvalues.h; then
- AC_MSG_RESULT($i)
- OCAMLEXT="$i"
- OCAMLINC="-I$OCAMLEXT"
- break
- fi
- done
- if test -z "$OCAMLINC"; then
- AC_MSG_RESULT(not found)
- fi
-
- AC_MSG_CHECKING(for Ocaml version 3.08.2 or higher)
- OCAMLVER=`$OCAMLC -version | sed -e 's/.*version //g'`
- AC_COMPARE_VERSION([$OCAMLVER],[3.08.2],[:],[:],[OCAMLLOC=_loc])
- AC_MSG_RESULT($OCAMLVER)
+ AC_MSG_CHECKING(for Ocaml Pre-Processor-Pretty-Printer)
+ if test -z "$CAMLP4"; then
+ AC_CHECK_PROGS(CAMLP4, camlp4)
fi
fi # Disabling ocaml
-export OCAMLLOC
-export OCAMLVER
-export OCAMLINC
-export OCAMLBIN
-export OCAMLC
-export OCAMLDLGEN
-export OCAMLFIND
-export OCAMLMKTOP
-
-AC_SUBST(OCAMLLOC)
-AC_SUBST(OCAMLVER)
-AC_SUBST(OCAMLINC)
-AC_SUBST(OCAMLBIN)
AC_SUBST(OCAMLC)
AC_SUBST(OCAMLDLGEN)
AC_SUBST(OCAMLFIND)
AC_SUBST(OCAMLMKTOP)
+AC_SUBST(CAMLP4)
#----------------------------------------------------------------
# Look for Pike
# Priority: configure option, automatic search
PIKEBIN=
AC_ARG_WITH(pike, AS_HELP_STRING([--without-pike], [Disable Pike])
-AS_HELP_STRING([--with-pike=path], [Set location of Pike executable]),[PIKEBIN="$withval"], [PIKEBIN=yes])
+AS_HELP_STRING([--with-pike=path], [Set location of Pike executable]),[PIKEBIN="$withval"], [PIKEBIN="$alllang_default"])
# First, check for "--without-pike" or "--with-pike=no".
-if test x"${PIKEBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${PIKEBIN}" = xno; then
AC_MSG_NOTICE([Disabling Pike])
PIKEBIN=
else
AC_ARG_WITH(chicken, AS_HELP_STRING([--without-chicken], [Disable CHICKEN])
-AS_HELP_STRING([--with-chicken=path], [Set location of CHICKEN executable]),[ CHICKENBIN="$withval"], [CHICKENBIN=yes])
+AS_HELP_STRING([--with-chicken=path], [Set location of CHICKEN executable]),[ CHICKENBIN="$withval"], [CHICKENBIN="$alllang_default"])
# First, check for "--without-chicken" or "--with-chicken=no".
-if test x"${CHICKENBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${CHICKENBIN}" = xno; then
AC_MSG_NOTICE([Disabling CHICKEN])
else
# Look for C#
#----------------------------------------------------------------
-AC_ARG_WITH(csharp, AS_HELP_STRING([--without-csharp], [Disable CSharp]), [with_csharp="$withval"], [with_csharp=yes])
+AC_ARG_WITH(csharp, AS_HELP_STRING([--without-csharp], [Disable CSharp]), [with_csharp="$withval"], [with_csharp="$alllang_default"])
AC_ARG_WITH(cil-interpreter, [ --with-cil-interpreter=path Set location of CIL interpreter for CSharp],[CSHARPBIN="$withval"], [CSHARPBIN=])
AC_ARG_WITH(csharp-compiler, [ --with-csharp-compiler=path Set location of CSharp compiler],[CSHARPCOMPILERBIN="$withval"], [CSHARPCOMPILERBIN=])
# First, check for "--without-csharp" or "--with-csharp=no".
-if test x"${with_csharp}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${with_csharp}" = xno; then
AC_MSG_NOTICE([Disabling CSharp])
CSHARPCOMPILER=
else
CSHARPCOMPILER="$CSHARPCOMPILERBIN"
fi
-CSHARPPATHSEPARATOR="/"
-CSHARPCYGPATH_W=echo
+CSHARPCONVERTPATH="Tools/convertpath -u"
if test -z "$CSHARPBIN" ; then
CSHARPCILINTERPRETER=""
CSHARPCILINTERPRETER_FLAGS=""
echo "mcs is not a working Mono C# compiler"
fi
fi
- if test "mcs" = "$CSHARPCOMPILER" || test "gmcs" = "$CSHARPCOMPILER"; then
+ if test "mcs" = "$CSHARPCOMPILER" || test "gmcs" = "$CSHARPCOMPILER" || test "mono-csc" = "$CSHARPCOMPILER"; then
AC_CHECK_PROGS(CSHARPCILINTERPRETER, mono) # Mono JIT
CSHARPCILINTERPRETER_FLAGS="--debug"
else
if test "csc" = "$CSHARPCOMPILER"; then
- CSHARPPATHSEPARATOR="\\\\"
- CSHARPCYGPATH_W='cygpath -w'
+ CSHARPCONVERTPATH="Tools/convertpath -w"
fi
fi
fi
case $host in
*-*-cygwin* | *-*-mingw*)
if test "$GCC" = yes; then
- CSHARPDYNAMICLINKING=" -mno-cygwin -mthreads -Wl,--add-stdcall-alias"
- CSHARPCFLAGS="-mno-cygwin -mthreads"
+ CSHARPDYNAMICLINKING="$GCC_MNO_CYGWIN -mthreads -Wl,--add-stdcall-alias"
+ CSHARPCFLAGS="$GCC_MNO_CYGWIN -mthreads"
else
CSHARPDYNAMICLINKING=""
CSHARPCFLAGS=""
AC_SUBST(CSHARPCILINTERPRETER_FLAGS)
AC_SUBST(CSHARPCILINTERPRETER)
-AC_SUBST(CSHARPPATHSEPARATOR)
-AC_SUBST(CSHARPCYGPATH_W)
+AC_SUBST(CSHARPCONVERTPATH)
AC_SUBST(CSHARPCOMPILER)
AC_SUBST(CSHARPDYNAMICLINKING)
-AC_SUBST(CSHARPLIBRARYPREFIX) # Is this going to be used?
+AC_SUBST(CSHARPLIBRARYPREFIX)
AC_SUBST(CSHARPCFLAGS)
AC_SUBST(CSHARPSO)
# LUABIN will be cleared if certain dependencies cannot be found
AC_ARG_WITH(lua, AS_HELP_STRING([--without-lua], [Disable Lua])
-AS_HELP_STRING([--with-lua=path], [Set location of Lua executable]),[ LUABIN="$withval"], [LUABIN=yes])
+AS_HELP_STRING([--with-lua=path], [Set location of Lua executable]),[ LUABIN="$withval"], [LUABIN="$alllang_default"])
AC_ARG_WITH(luaincl,[ --with-luaincl=path Set location of Lua include directory],[
LUAINCLUDE="$withval"], [LUAINCLUDE=])
AC_ARG_WITH(lualib,[ --with-lualib=path Set location of Lua library directory],[
LUALIB="$withval"], [LUALIB=])
# First, check for "--without-lua" or "--with-lua=no".
-if test x"${LUABIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${LUABIN}" = xno; then
AC_MSG_NOTICE([Disabling Lua])
else
# The search order should match the include-file and library search
# orders below (a Lua shared library built for one version may not
# work with a Lua binary of a different version).
- AC_PATH_PROGS(LUABIN, [lua5.2 lua5.1 lua])
+ AC_PATH_PROGS(LUABIN, [lua5.4 lua5.3 lua5.2 lua5.1 lua])
fi
# check version: we need Lua 5.x
if test "$LUABIN"; then
- AC_MSG_CHECKING(Lua version)
- # if version 5.x
- LUAV5=`$LUABIN -e 'if string.sub(_VERSION,5,5)=="5" then print "1" end'`
- # if not version 5.0
- LUAV51=`$LUABIN -e 'if string.sub(_VERSION,5,7)~="5.0" then print "1" end'`
-
- if test -z "$LUAV5"; then
- AC_MSG_WARN(Not Lua 5.x, SWIG does not support this version of Lua)
- LUABIN=""
- elif test -z "$LUAV51"; then
- AC_MSG_RESULT(Lua 5.0.x)
- else
- AC_MSG_RESULT(Lua 5.1 or later)
- fi
+ AC_MSG_CHECKING(Lua version)
+ # if version 5.x
+ LUAV5=`$LUABIN -e 'if string.sub(_VERSION,5,5)=="5" then print "1" end'`
+ # if not version 5.0
+ LUAV51=`$LUABIN -e 'if string.sub(_VERSION,5,7)~="5.0" then print "1" end'`
+
+ if test -z "$LUAV5"; then
+ AC_MSG_WARN(Not Lua 5.x, SWIG does not support this version of Lua)
+ LUABIN=""
+ elif test -z "$LUAV51"; then
+ AC_MSG_RESULT(Lua 5.0.x)
+ else
+ AC_MSG_RESULT(Lua 5.1 or later)
+ fi
fi
if test "$LUABIN"; then
- AC_MSG_CHECKING(whether Lua dynamic loading is enabled)
- # using Lua to check Lua
- # lua 5.0 & 5.1 have different fn names
- if test -z "$LUAV51"; then
- LUADYNAMICLOADLIB=`$LUABIN -e '_,_,c=loadlib("no_such_lib","") if c~="absent" then print "1" end'`
- else
- LUADYNAMICLOADLIB=`$LUABIN -e '_,_,c=package.loadlib("no_such_lib","") if c~="absent" then print "1" end'`
- fi
+ AC_MSG_CHECKING(whether Lua dynamic loading is enabled)
+ # using Lua to check Lua
+ # lua 5.0 & 5.1 have different fn names
+ if test -z "$LUAV51"; then
+ LUADYNAMICLOADLIB=`$LUABIN -e '_,_,c=loadlib("no_such_lib","") if c~="absent" then print "1" end'`
+ else
+ LUADYNAMICLOADLIB=`$LUABIN -e '_,_,c=package.loadlib("no_such_lib","") if c~="absent" then print "1" end'`
+ fi
- if test -z "$LUADYNAMICLOADLIB"; then
- AC_MSG_RESULT(no)
- else
- AC_MSG_RESULT(yes)
- fi
-fi
+ if test -z "$LUADYNAMICLOADLIB"; then
+ AC_MSG_RESULT(no)
+ else
+ AC_MSG_RESULT(yes)
+ fi
-# look for the header files & set LUAFLAGS accordingly
-# will clear LUABIN if not present
-if test -n "$LUAINCLUDE"; then
- AC_CHECK_FILE($LUAINCLUDE/lua.h,[LUAFLAGS="$ISYSTEM$LUAINCLUDE"],[LUABIN=])
-else
- LUA_OK="1"
- AC_CHECK_HEADER(lua.h,[LUAFLAGS=""],[LUA_OK=""])
- # if we didn't get it, going to have to look elsewhere (the hard way)
- if test -z "$LUA_OK"; then
- AC_MSG_CHECKING(for lua.h in other locations)
- # note: Debian/Ubuntu seem to like /usr/include/lua5.1/lua.h
- # The ordering of the include directories to search should match
- # the ordering of libraries to search in the library test below.
- inc=/usr/include
- dirs="$inc/lua5.2 $inc/lua5.1 $inc/lua51 $inc/lua5.0 $inc/lua50 /usr/local/include"
- for i in $dirs; do
- #echo "$i"
- if test -r $i/lua.h; then
- AC_MSG_RESULT($i/lua.h)
- LUAFLAGS="$ISYSTEM$i"
- break
+ # look for the header files & set LUAFLAGS accordingly
+ # will clear LUABIN if not present
+ if test -n "$LUAINCLUDE"; then
+ AC_CHECK_FILE($LUAINCLUDE/lua.h,[LUAFLAGS="$ISYSTEM$LUAINCLUDE"],[LUABIN=])
+ else
+ LUA_OK="1"
+ CFLAGS_SAVED=$CFLAGS
+ CFLAGS= # Use empty CFLAGS to avoid failure: "present but cannot be compiled"
+ AC_CHECK_HEADER([lua.h],[LUAFLAGS=""],[LUA_OK=""])
+ CFLAGS=$CFLAGS_SAVED
+ # if we didn't get it, going to have to look elsewhere (the hard way)
+ if test -z "$LUA_OK"; then
+ AC_MSG_CHECKING(for lua.h in other locations)
+ # note: Debian/Ubuntu seem to like /usr/include/lua5.1/lua.h
+ # The ordering of the include directories to search should match
+ # the ordering of libraries to search in the library test below.
+ inc=/usr/include
+ dirs="$inc/lua5.4 $inc/lua5.3 $inc/lua5.2 $inc/lua5.1 $inc/lua51 $inc/lua5.0 $inc/lua50 /usr/local/include"
+ for i in $dirs; do
+ #echo "$i"
+ if test -r $i/lua.h; then
+ AC_MSG_RESULT($i/lua.h)
+ LUAFLAGS="$ISYSTEM$i"
+ break
+ fi
+ done
+ if test -z "$LUAFLAGS"; then
+ AC_MSG_RESULT(not found)
+ LUABIN="" # clear the bin
fi
- done
- if test -z "$LUAFLAGS"; then
- AC_MSG_RESULT(not found)
- LUABIN="" # clear the bin
fi
fi
-fi
-# look for the library files & set LUALINK accordingly
-# will clear LUABIN if not present
-lua_save_LIBS=$LIBS # the code seems to disrupt LIBS, so saving
+ # look for the library files & set LUALINK accordingly
+ # will clear LUABIN if not present
+ lua_save_LIBS=$LIBS # the code seems to disrupt LIBS, so saving
-if test -n "$LUALIB"; then
- AC_CHECK_FILE($LUALIB/liblua.a,[LUALINK="-L$LUALIB -llua"],[LUABIN=])
-else
- AC_SEARCH_LIBS(lua_close, [lua lua5.2 lua5.1 lua51 lua5.0 lua50], [LUALINK="-l$ac_lib"],[LUABIN=])
-fi
+ if test -n "$LUALIB"; then
+ AC_CHECK_FILE($LUALIB/liblua.a,[LUALINK="-L$LUALIB -llua"],[LUABIN=])
+ else
+ AC_SEARCH_LIBS(lua_close, [lua lua5.4 lua5.3 lua5.2 lua5.1 lua51 lua5.0 lua50], [LUALINK="-l$ac_lib"],[LUABIN=])
+ fi
-# adding lualib for lua 5.0
-if test -z "$LUAV51"; then # extra for lua 5.0
- LUALINK="$LUALINK -llualib"
-fi
+ # adding lualib for lua 5.0
+ if test -z "$LUAV51"; then # extra for lua 5.0
+ LUALINK="$LUALINK -llualib"
+ fi
-LIBS=$lua_save_LIBS # restore LIBS
+ LIBS=$lua_save_LIBS # restore LIBS
+fi
fi # if not disabled
ALLEGROCLBIN=
AC_ARG_WITH(allegrocl, AS_HELP_STRING([--without-allegrocl], [Disable Allegro CL])
-AS_HELP_STRING([--with-allegrocl=path], [Set location of Allegro CL executable (alisp)]),[ ALLEGROCLBIN="$withval"], [ALLEGROCLBIN=yes])
+AS_HELP_STRING([--with-allegrocl=path], [Set location of Allegro CL executable (alisp)]),[ ALLEGROCLBIN="$withval"], [ALLEGROCLBIN="$alllang_default"])
# First, check for "--without-allegrocl" or "--with-allegrocl=no".
-if test x"${ALLEGROCLBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${ALLEGROCLBIN}" = xno; then
AC_MSG_NOTICE([Disabling Allegro CL])
ALLEGROCLBIN=
else
CLISPBIN=
AC_ARG_WITH(clisp, AS_HELP_STRING([--without-clisp], [Disable CLISP])
-AS_HELP_STRING([--with-clisp=path], [Set location of CLISP executable (clisp)]),[ CLISPBIN="$withval"], [CLISPBIN=yes])
+AS_HELP_STRING([--with-clisp=path], [Set location of CLISP executable (clisp)]),[ CLISPBIN="$withval"], [CLISPBIN="$alllang_default"])
# First, check for "--without-clisp" or "--with-clisp=no".
-if test x"${CLISPBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${CLISPBIN}" = xno; then
AC_MSG_NOTICE([Disabling CLISP])
CLISPBIN=
else
RBIN=
AC_ARG_WITH(r, AS_HELP_STRING([--without-r], [Disable R])
-AS_HELP_STRING([--with-r=path], [Set location of R executable (r)]),[ RBIN="$withval"], [RBIN=yes])
+AS_HELP_STRING([--with-r=path], [Set location of R executable (r)]),[ RBIN="$withval"], [RBIN="$alllang_default"])
# First, check for "--without-r" or "--with-r=no".
-if test x"${RBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${RBIN}" = xno; then
AC_MSG_NOTICE([Disabling R])
RBIN=
else
#----------------------------------------------------------------
AC_ARG_WITH(go, AS_HELP_STRING([--without-go], [Disable Go])
-AS_HELP_STRING([--with-go=path], [Set location of Go compiler]),[GOBIN="$withval"], [GOBIN=yes])
+AS_HELP_STRING([--with-go=path], [Set location of Go compiler]),[GOBIN="$withval"], [GOBIN="$alllang_default"])
-if test x"${GOBIN}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${GOBIN}" = xno; then
AC_MSG_NOTICE([Disabling Go])
GO=
GOC=
GO1=false
+ GO12=false
+ GO13=false
+ GO15=false
GOGCC=false
+ GCCGO=
GOOPT=
+ GCCGOOPT=
GOVERSIONOPTION=
else
if test "x$GOBIN" = xyes; then
- AC_CHECK_PROGS(GO, go 6g 8g gccgo)
+ AC_CHECK_PROGS(GO, go)
else
GO="$GOBIN"
fi
GOGCC=false
+ GCCGO=
GO1=false
+ GO12=false
+ GO13=false
+ GO15=false
GOOPT=
+ GCCGOOPT=
GOVERSIONOPTION=
+
if test -n "$GO" ; then
- if $GO --help 2>/dev/null | grep gccgo >/dev/null 2>&1 ; then
- GOGCC=true
- GOVERSIONOPTION=--version
+ GO1=true
+ GOVERSIONOPTION=version
+ go_version=$($GO $GOVERSIONOPTION | sed -e 's/go version //')
+ case "$go_version" in
+ go1 | go1.[[01234]]*)
+ GOC=$(sh -c "$(go env) && echo \$GOCHAR")c
+ ;;
+ *)
+ GOC=compile
+ ;;
+ esac
+ AC_MSG_CHECKING([whether go version is too old])
+ case $go_version in
+ go1.1* | go1.0* | go1 )
+ AC_MSG_RESULT([yes - minimum version is 1.2])
+ GO=
+ GOOPT="-intgosize 32"
+ ;;
+ *)
+ AC_MSG_RESULT([no])
+ case "$(go env GOARCH)" in
+ amd64 | arm64 | ppc64*)
+ GOOPT="-intgosize 64"
+ ;;
+ *)
+ GOOPT="-intgosize 32"
+ ;;
+ esac
+ ;;
+ esac
+ case $go_version in
+ go1.0* | go1 | go1.1*)
+ GOOPT="$GOOPT -use-shlib"
+ ;;
+ go1.2*)
+ GO12=true
+ ;;
+ go1.3* | go1.4*)
+ GO13=true
+ ;;
+ *)
+ GO15=true
+ ;;
+ esac
+ fi
+
+ AC_CHECK_PROGS(GCCGO, gccgo)
+
+ if test -n "$GCCGO" ; then
+ if $GCCGO --help 2>/dev/null | grep gccgo >/dev/null 2>&1 ; then
AC_MSG_CHECKING([whether gccgo version is too old])
- go_version=`$GO $GOVERSIONOPTION | sed -e 's/[^0-9]* \([0-9.]*\) .*$/\1/' -e 's/[.]//g'`
- if test "$go_version" -lt 470; then
+ go_version=[`$GO $GOVERSIONOPTION | sed -n '1p' | sed -e 's/^.* \([0-9.]*\) *$/\1/' -e 's/[.]//g'`]
+ if test "x$go_version" = x; then
+ AC_MSG_RESULT([could not determine gccgo version])
+ GCCGO=
+ elif test "$go_version" -lt 470; then
AC_MSG_RESULT([yes - minimum version is 4.7.0])
+ GCCGO=
else
- AC_MSG_RESULT([no])
+ AC_MSG_RESULT([no])
if test "$go_version" -lt 480; then
- GOOPT="-intgosize 32"
- else
- AC_CHECK_SIZEOF([void *], [4])
- if test "$ac_cv_sizeof_void_p" = "8"; then
- GOOPT="-intgosize 64"
- else
- GOOPT="-intgosize 32"
- fi
+ GCCGOOPT="-intgosize 32"
+ else
+ AC_CHECK_SIZEOF([void *], [4])
+ if test "$ac_cv_sizeof_void_p" = "8"; then
+ GCCGOOPT="-intgosize 64"
+ else
+ GCCGOOPT="-intgosize 32"
+ fi
fi
fi
- elif test "`echo $GO | sed -e 's|.*/||'`" = "go"; then
- GO1=true
- GOVERSIONOPTION=version
- GOC=$(sh -c "$(go env) && echo \$GOCHAR")c
- go_version=$($GO $GOVERSIONOPTION | sed -e 's/go version //')
- case $go_version in
- go1.0*) GOOPT="-intgosize 32" ;;
- *) if test "$GOC" = "6c"; then
- GOOPT="-intgosize 64"
- else
- GOOPT="-intgosize 32"
- fi
- ;;
- esac
- else
- GOC=`echo $GO | sed -e 's/g/c/'`
- GOVERSIONOPTION=-V
- AC_MSG_CHECKING([whether Go ($GO) version is too old])
- go_version=`$GO $GOVERSIONOPTION 2>/dev/null | sed -e 's/.*version.* \([[0-9]]*\).*/\1/'`
- go_min_version=7077
- if test "$go_version" != "" -a "$go_version" -lt $go_min_version; then
- AC_MSG_RESULT([yes - minimum version is $go_min_version])
- GO=
- else
- AC_MSG_RESULT([no])
- fi
- GOOPT="-intgosize 32"
fi
fi
fi
AC_SUBST(GOGCC)
+AC_SUBST(GCCGO)
AC_SUBST(GO)
AC_SUBST(GOC)
AC_SUBST(GO1)
+AC_SUBST(GO12)
+AC_SUBST(GO13)
+AC_SUBST(GO15)
AC_SUBST(GOOPT)
+AC_SUBST(GCCGOOPT)
AC_SUBST(GOVERSIONOPTION)
#----------------------------------------------------------------
# Look for D
#----------------------------------------------------------------
-AC_ARG_WITH(d, AS_HELP_STRING([--without-d], [Disable D]), [with_d="$withval"], [with_d=yes])
+AC_ARG_WITH(d, AS_HELP_STRING([--without-d], [Disable D]), [with_d="$withval"], [with_d="$alllang_default"])
AC_ARG_WITH(d1-compiler, [ --with-d1-compiler=path Set location of D1/Tango compiler (DMD compatible)],[D1COMPILERBIN="$withval"], [D1COMPILERBIN=])
AC_ARG_WITH(d2-compiler, [ --with-d2-compiler=path Set location of D2 compiler (DMD compatible)],[D2COMPILERBIN="$withval"], [D2COMPILERBIN=])
# First, check for "--without-d" or "--with-d=no".
-if test x"${with_d}" = xno -o x"${with_alllang}" = xno ; then
+if test x"${with_d}" = xno; then
AC_MSG_NOTICE([Disabling D])
D1COMPILER=
D2COMPILER=
SKIP_PERL5=
-if test -z "$PERL" || test -z "$PERL5EXT" ; then
+if test -z "$PERL" || test -z "$PERL5EXT" || test -z "$PERL5TESTMORE"; then
SKIP_PERL5="1"
fi
AC_SUBST(SKIP_PERL5)
SKIP_PYTHON=
-if (test -z "$PYINCLUDE") &&
- (test -z "$PY3INCLUDE") ; then
+if (test -z "$PYINCLUDE" || test -z "$PYLINK") &&
+ (test -z "$PY3INCLUDE" || test -z "$PY3LINK") ; then
SKIP_PYTHON="1"
fi
AC_SUBST(SKIP_PYTHON)
SKIP_PYTHON3=
-if test -z "$PY3INCLUDE" ; then
+if test -z "$PY3INCLUDE" || test -z "$PY3LINK" ; then
SKIP_PYTHON3="1"
fi
AC_SUBST(SKIP_PYTHON3)
fi
AC_SUBST(SKIP_JAVA)
+SKIP_JAVASCRIPT=
+if test -z "$JAVASCRIPT" || ( test -z "$NODEJS" && test -z "$JSCENABLED" && test -z "$JSV8ENABLED" ) ; then
+ SKIP_JAVASCRIPT="1"
+fi
+AC_SUBST(SKIP_JAVASCRIPT)
SKIP_GUILE=
if test -z "$GUILE" || test -z "$GUILE_LIBS" ; then
SKIP_OCAML=
-if test -z "$OCAMLBIN" || test -z "$OCAMLINC" ; then
+if test -z "$OCAMLC" ; then
SKIP_OCAML="1"
fi
AC_SUBST(SKIP_OCAML)
#fi
AC_SUBST(SKIP_UFFI)
+SKIP_SCILAB=
+if test -z "$SCILAB"; then
+ SKIP_SCILAB="1"
+fi
+AC_SUBST(SKIP_SCILAB)
+
SKIP_GO=
if test -z "$GO" ; then
SKIP_GO="1"
# Miscellaneous
#----------------------------------------------------------------
+ABS_SRCDIR=`(cd ${srcdir} && pwd)`
+
+dnl Under Cygwin, we may need native absolute path as it is used by SWIG, which
+dnl may be a native, and not a Cygwin, program (this is the case when it's
+dnl built using MinGW or cccl compiler in Cygwin environment). However it may,
+dnl although this is probably more rare, also be built as a Cygwin program.
+dnl Using "mixed" path like we do here allows the path to work in both cases.
+case $host in
+ *-*-mingw* ) ABS_SRCDIR=`${srcdir}/Tools/convertpath -m $ABS_SRCDIR` ;;
+ *-*-cygwin* ) ABS_SRCDIR=`cygpath --mixed $ABS_SRCDIR` ;;
+esac
# Root directory
-# Translate path for native Windows compilers for use with 'make check'
ROOT_DIR=`pwd`
case $host in
-*-*-cygwin* | *-*-mingw*)
+*-*-cygwin*)
+ # Translate path for native Windows compilers for use with 'make check'
if (cygpath --mixed $ROOT_DIR) >/dev/null 2>/dev/null; then
ROOT_DIR=`cygpath --mixed $ROOT_DIR`
fi
+ ;;
+esac
+
+case $host in
+*-*-cygwin* | *-*-mingw*)
# Extra files generated by some Windows compilers
EXTRA_CLEAN="*.stackdump *.exp *.lib *.pdb *.ilk"
;;
AC_ARG_WITH(swiglibdir,[ --with-swiglibdir=DIR Put SWIG system-independent libraries into DIR.],
[swig_lib="$withval"], [swig_lib="${datadir}/swig/${PACKAGE_VERSION}"])
-AC_SUBST(swig_lib)
+SWIG_LIB_INSTALL=${swig_lib}
+AC_SUBST(SWIG_LIB_INSTALL)
AC_DEFINE_DIR(SWIG_LIB, swig_lib, [Directory for SWIG system-independent libraries])
case $build in
- # Windows does not understand unix directories. Convert into a windows directory with drive letter.
- *-*-mingw*) SWIG_LIB_WIN_UNIX=`cmd //c echo $SWIG_LIB | sed -e "s/[ ]*$//"`;; # This echo converts unix to mixed paths. Then zap unexpected trailing space.
- *-*-cygwin*) SWIG_LIB_WIN_UNIX=`cygpath --mixed "$SWIG_LIB"`;;
- *) SWIG_LIB_WIN_UNIX="";;
+ # Windows does not understand unix directories. Convert into a windows directory with drive letter.
+ *-*-mingw*) SWIG_LIB_WIN_UNIX=`${srcdir}/Tools/convertpath -m $SWIG_LIB`;;
+ *-*-cygwin*) SWIG_LIB_WIN_UNIX=`cygpath --mixed "$SWIG_LIB"`;;
+ *) SWIG_LIB_WIN_UNIX="";;
esac
AC_DEFINE_UNQUOTED(SWIG_LIB_WIN_UNIX, ["$SWIG_LIB_WIN_UNIX"], [Directory for SWIG system-independent libraries (Unix install on native Windows)])
-AC_CONFIG_FILES([ \
- Makefile \
- swig.spec \
- Source/Makefile \
- Examples/Makefile \
- Examples/xml/Makefile \
- Examples/test-suite/chicken/Makefile \
- Examples/test-suite/csharp/Makefile \
- Examples/test-suite/d/Makefile \
- Examples/test-suite/guile/Makefile \
- Examples/test-suite/java/Makefile \
- Examples/test-suite/mzscheme/Makefile \
- Examples/test-suite/ocaml/Makefile \
- Examples/test-suite/octave/Makefile \
- Examples/test-suite/perl5/Makefile \
- Examples/test-suite/php/Makefile \
- Examples/test-suite/pike/Makefile \
- Examples/test-suite/python/Makefile \
- Examples/test-suite/ruby/Makefile \
- Examples/test-suite/tcl/Makefile \
- Examples/test-suite/lua/Makefile \
- Examples/test-suite/allegrocl/Makefile \
- Examples/test-suite/clisp/Makefile \
- Examples/test-suite/cffi/Makefile \
- Examples/test-suite/uffi/Makefile \
- Examples/test-suite/r/Makefile \
- Examples/test-suite/go/Makefile \
- Lib/ocaml/swigp4.ml
+SWIG_LIB_PREINST=$ABS_SRCDIR/Lib
+AC_SUBST(SWIG_LIB_PREINST)
+
+dnl For testing purposes, clear SWIG_LIB when building SWIG in the source
+dnl directory under Windows because it is supposed to work without SWIG_LIB
+dnl being set. Otherwise it always needs to be set.
+SWIG_LIB_SET="env SWIG_LIB=\$(SWIG_LIB_DIR)"
+if test "${srcdir}" = "."; then
+ AC_EGREP_CPP([yes],
+ [#ifdef _WIN32
+ yes
+ #endif
+ ], [SWIG_LIB_SET="env SWIG_LIB="], [])
+fi
+AC_SUBST(SWIG_LIB_SET)
+
+AC_CONFIG_FILES([
+ Makefile
+ swig.spec
+ Examples/Makefile
+ Examples/d/example.mk
+ Examples/xml/Makefile
+ Examples/test-suite/errors/Makefile
+ Examples/test-suite/chicken/Makefile
+ Examples/test-suite/csharp/Makefile
+ Examples/test-suite/d/Makefile
+ Examples/test-suite/guile/Makefile
+ Examples/test-suite/java/Makefile
+ Examples/test-suite/javascript/Makefile
+ Examples/test-suite/mzscheme/Makefile
+ Examples/test-suite/ocaml/Makefile
+ Examples/test-suite/octave/Makefile
+ Examples/test-suite/perl5/Makefile
+ Examples/test-suite/php/Makefile
+ Examples/test-suite/pike/Makefile
+ Examples/test-suite/python/Makefile
+ Examples/test-suite/ruby/Makefile
+ Examples/test-suite/scilab/Makefile
+ Examples/test-suite/tcl/Makefile
+ Examples/test-suite/lua/Makefile
+ Examples/test-suite/allegrocl/Makefile
+ Examples/test-suite/clisp/Makefile
+ Examples/test-suite/cffi/Makefile
+ Examples/test-suite/uffi/Makefile
+ Examples/test-suite/r/Makefile
+ Examples/test-suite/go/Makefile
+ Source/Makefile
+ Tools/javascript/Makefile
])
AC_CONFIG_FILES([preinst-swig], [chmod +x preinst-swig])
AC_CONFIG_FILES([CCache/ccache_swig_config.h])
+#--------------------------------------------------------------------
+# Building Examples/ out of source directory
+#--------------------------------------------------------------------
+
+# If building out of source tree, replicate Examples/ source tree in
+# build directory, and copy over Makefiles from source directory.
+# Prefix each Makefile with a header which sets SRCDIR to the relative
+# source directory, and provides a rule for updating the Makefile from
+# its original source.
+AC_CONFIG_COMMANDS([Examples],[
+ if test "x${srcdir}" != "x." ; then
+ AC_MSG_NOTICE([generating Examples build tree])
+ for mkfile in `cd ${srcdir} && find Examples/ -type f -name Makefile`; do
+ dir=`dirname ${mkfile}`
+ d=${dir}
+ reldir=""
+ while test "x$d" != "x." ; do
+ d=`dirname $d`
+ reldir="${reldir}../"
+ done
+ relsrcdir=${reldir}${srcdir}/
+ AS_MKDIR_P([${dir}])
+ cat <<EOF >${mkfile}
+# DO NOT EDIT: instead edit ${relsrcdir}${mkfile}
+# and run (cd ${reldir} && ./config.status) to regenerate
+TOP_BUILDDIR_TO_TOP_SRCDIR = ${srcdir}/
+SRCDIR = ${relsrcdir}${dir}/
+
+EOF
+ cat ${srcdir}/${mkfile} >>${mkfile}
+ done
+ fi
+])
+
+#--------------------------------------------------------------------
+
AC_OUTPUT
+
+langs=""
+test -n "$SKIP_ALLEGROCL" || langs="${langs}allegrocl "
+test -n "$SKIP_CFFI" || langs="${langs}cffi "
+test -n "$SKIP_CHICKEN" || langs="${langs}chicken "
+test -n "$SKIP_CLISP" || langs="${langs}clisp "
+test -n "$SKIP_CSHARP" || langs="${langs}csharp "
+test -n "$SKIP_D" || langs="${langs}d "
+test -n "$SKIP_GO" || langs="${langs}go "
+test -n "$SKIP_GUILE" || langs="${langs}guile "
+test -n "$SKIP_JAVA" || langs="${langs}java "
+test -n "$SKIP_JAVASCRIPT" || langs="${langs}javascript "
+test -n "$SKIP_LUA" || langs="${langs}lua "
+test -n "$SKIP_MODULA3" || langs="${langs}modula3 "
+test -n "$SKIP_MZSCHEME" || langs="${langs}mzscheme "
+test -n "$SKIP_OCAML" || langs="${langs}ocaml "
+test -n "$SKIP_OCTAVE" || langs="${langs}octave "
+test -n "$SKIP_PERL5" || langs="${langs}perl5 "
+test -n "$SKIP_PHP" || langs="${langs}php "
+test -n "$SKIP_PIKE" || langs="${langs}pike "
+test -n "$SKIP_PYTHON" || langs="${langs}python "
+test -n "$SKIP_R" || langs="${langs}r "
+test -n "$SKIP_RUBY" || langs="${langs}ruby "
+test -n "$SKIP_SCILAB" || langs="${langs}scilab "
+test -n "$SKIP_TCL" || langs="${langs}tcl "
+test -n "$SKIP_UFFI" || langs="${langs}uffi "
+
+echo "
+The SWIG test-suite and examples are configured for the following languages:
+$langs
+"
+
dnl configure.ac ends here
%define __spec_check_pre exit 0
Name: swig
-Version: 2.0.12
+Version: 3.0.10
Release: 0
License: GPL-3.0+ and BSD-3-Clause
Summary: Simplified Wrapper and Interface Generator
#!/bin/sh
-builddir=`dirname $0`
-srcdir=`cd "$builddir" && cd '@srcdir@' && pwd`
-SWIG_LIB=$srcdir/Lib
-#SWIG_LIB=`cygpath -w $srcdir/Lib` # For native Windows version of SWIG
+
+# Convenience script for running SWIG before it is installed.
+# Intended for ad-hoc usage and not by the test-suite or examples.
+
+builddir=`dirname "$0"`
+SWIG_LIB='@SWIG_LIB_PREINST@'
export SWIG_LIB
-exec "$builddir/swig" $*
+exec "$builddir/swig" "$@"
projects / platform / upstream / swig.git / commitdiff